v5_Gesture_Recognition_Training.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# AI DEMO - Summit -Tensorflow Dance Move Training\n",
    "\n",
    "This note book should be able to run on the OCP4 Demo Cluster by simply selecting \"Cell\" and then \"Run All\" at the top of the page.\n",
    "\n",
    "Running this notebook will:\n",
    "* Pull gesture data from S3\n",
    "* Preprocess the gesture data\n",
    "* Train a Tensorflow neural network model\n",
    "* Save the model for serving"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:44:52.333944Z",
     "start_time": "2019-04-17T16:44:51.770098Z"
    }
   },
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:44:55.904844Z",
     "start_time": "2019-04-17T16:44:52.337563Z"
    }
   },
   "outputs": [],
   "source": [
    "import json\n",
    "import time\n",
    "import os\n",
    "\n",
    "import itertools\n",
    "import joblib\n",
    "\n",
    "import s3fs\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import scipy\n",
    "import scipy.stats\n",
    "\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pylab as plt\n",
    "\n",
    "from pathlib import Path\n",
    "from datetime import datetime as dt\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import confusion_matrix,classification_report\n",
    "from sklearn.preprocessing import LabelEncoder, OneHotEncoder, MinMaxScaler\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:44:55.971057Z",
     "start_time": "2019-04-17T16:44:55.907428Z"
    }
   },
   "outputs": [],
   "source": [
    "motion_cols = [\n",
    "    'acceleration_x', 'acceleration_y', 'acceleration_z',\n",
    "    'rotation_alpha', 'rotation_beta', 'rotation_gamma',\n",
    "]\n",
    "orientation_cols = ['alpha', 'beta', 'gamma']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:44:56.037520Z",
     "start_time": "2019-04-17T16:44:55.975568Z"
    }
   },
   "outputs": [],
   "source": [
    "def process_acceleration_rotation(example: dict, ts: str = None):\n",
    "    \"\"\"Process single raw example and returns dataframe.\n",
    "    \n",
    "    :returns: DataFrame\n",
    "    \"\"\"\n",
    "    df = pd.DataFrame([], columns = motion_cols + ['timestamp'] + orientation_cols)\n",
    "\n",
    "    acc_data = pd.DataFrame([x['acceleration'] for elem in example for x in elem['motion']])\n",
    "    rot_data = pd.DataFrame([x['rotationRate'] for elem in example for x in elem['motion']])\n",
    "\n",
    "    df[motion_cols] = pd.concat([acc_data, rot_data], axis=1)\n",
    "    df['timestamp'] = pd.DataFrame(\n",
    "        [x['timestamp'] for elem in example for x in elem['motion']])\n",
    "\n",
    "    df = df \\\n",
    "        .sort_values('timestamp', ascending=True) \\\n",
    "        .drop('timestamp', axis=1)\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:44:56.109506Z",
     "start_time": "2019-04-17T16:44:56.054894Z"
    }
   },
   "outputs": [],
   "source": [
    "def process_cross_data(data, *, bins: dict = None, method: str = None):\n",
    "    \"\"\"Process collection of raw examples.\n",
    "    \n",
    "    :returns: bins, DataFrame\n",
    "    \"\"\"\n",
    "    bins = bins or {}\n",
    "    gesture = 'draw-cross'\n",
    "    \n",
    "    data_processed = []\n",
    "    for ts, d in data.items(): #loop over each sample\n",
    "        data_processed.append(process_acceleration_rotation(d, ts))\n",
    "    \n",
    "    data_clean = list(clean_data(data_processed))\n",
    "\n",
    "    col_bins, feature_df = featurize(\n",
    "        data_clean, label=gesture, col_bins=bins.get(gesture, None), method=method)\n",
    "    \n",
    "    return {gesture: col_bins}, feature_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:44:56.203097Z",
     "start_time": "2019-04-17T16:44:56.115096Z"
    }
   },
   "outputs": [],
   "source": [
    "def process_motion_rotation(example: dict):\n",
    "    \"\"\"Process single raw example and returns dataframe.\n",
    "    \n",
    "    :returns: DataFrame\n",
    "    \"\"\"\n",
    "    motion = np.array(example['motion'])\n",
    "    orientation = np.array(example['orientation'])\n",
    "\n",
    "    # process motion data\n",
    "    df = pd.DataFrame([], columns = motion_cols + ['timestamp'] + orientation_cols)\n",
    "    \n",
    "    if len(motion) > 0:\n",
    "        if motion.shape[1] == 7: # incl. acc and rotational velocities\n",
    "            df[motion_cols + ['timestamp']] = pd.DataFrame(motion)\n",
    "            \n",
    "    # process orientation data\n",
    "    if len(orientation) > 0:\n",
    "        df[orientation_cols] = pd.DataFrame(orientation[:, :-1])\n",
    "\n",
    "    df = df \\\n",
    "        .sort_values('timestamp', ascending=True) \\\n",
    "        .drop('timestamp', axis=1)\n",
    "        \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:44:56.292549Z",
     "start_time": "2019-04-17T16:44:56.207882Z"
    }
   },
   "outputs": [],
   "source": [
    "def process_dance_data(data, *,\n",
    "                       bins: dict = None,\n",
    "                       method: str = None):\n",
    "    \"\"\"Process raw data into single dataframe.\n",
    "    \n",
    "    :returns: bins, DataFrame\n",
    "    \"\"\" \n",
    "    df = pd.DataFrame()\n",
    "    bins = bins or {}\n",
    "    \n",
    "    for gesture, d in data.items(): # loop over each dance type\n",
    "        data_clean = list(clean_data(\n",
    "            process_motion_rotation(example) for example in d))\n",
    "        \n",
    "        col_bins, feature_df = featurize(\n",
    "            data_clean, label=gesture, col_bins=bins.get(gesture, None), method=method)\n",
    "        \n",
    "        bins[gesture] = col_bins\n",
    "        \n",
    "        df = pd.concat([df, feature_df], axis=0, ignore_index=True)\n",
    "        \n",
    "    return bins, df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:44:56.406380Z",
     "start_time": "2019-04-17T16:44:56.305366Z"
    }
   },
   "outputs": [],
   "source": [
    "def clean_data(data: list) -> list:\n",
    "    \"\"\"Clean collection of dataframes.\"\"\"\n",
    "    def condition(df): return all(df[motion_cols].any()) and len(df) > 50\n",
    "    \n",
    "    return filter(condition, map(lambda df: df[motion_cols].dropna(), data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:44:56.535176Z",
     "start_time": "2019-04-17T16:44:56.412878Z"
    }
   },
   "outputs": [],
   "source": [
    "def featurize(data, *, label: str = None, col_bins: dict = None, method: str = None):\n",
    "    \"\"\"Featurize.\"\"\"\n",
    "    col_bins = col_bins or {}\n",
    "\n",
    "    df = pd.DataFrame()\n",
    "    for idx, col in enumerate(motion_cols):\n",
    "        bins = col_bins.get(col, None)\n",
    "\n",
    "        if bins is None:\n",
    "            _, bins = find_bins(\n",
    "                np.concatenate([d[col] for d in data]), method=method)\n",
    "            col_bins[col] = bins\n",
    "\n",
    "        TAG = col.upper()\n",
    "\n",
    "        feature_list = []\n",
    "        for d in data:\n",
    "            ts = d[col]\n",
    "\n",
    "            mean = np.mean(ts)\n",
    "            median = np.median(ts)\n",
    "            std = np.std(ts)\n",
    "            length = len(ts)\n",
    "            kurtosis = scipy.stats.kurtosis(ts)\n",
    "\n",
    "            n,b = np.histogram(ts, bins=bins)\n",
    "            n = np.array(n)/float(np.sum(n)) #normalize i.e. fraction of entries in each bin\n",
    "\n",
    "            if median == 0: \n",
    "                features = {f'{TAG}_mean_over_median': 0, #dimensionless            \n",
    "                            f'{TAG}_std_over_median': 0, #dimensionless            \n",
    "                            f'{TAG}_length': length,\n",
    "                            f'{TAG}_kurtosis': kurtosis, #already dimensionless by definition\n",
    "                           }\n",
    "\n",
    "            else: \n",
    "                features = {f'{TAG}_mean_over_median': mean/median, #dimensionless            \n",
    "                    f'{TAG}_std_over_median': std/median, #dimensionless            \n",
    "                    f'{TAG}_length': length,\n",
    "                    f'{TAG}_kurtosis': kurtosis, #already dimensionless by definition\n",
    "                   }\n",
    "\n",
    "            for i, val in enumerate(n):\n",
    "                features[f'{TAG}_binfrac_{i}'] = val\n",
    "                \n",
    "            feature_list.append(features)\n",
    "\n",
    "        df = pd.concat([df, pd.DataFrame(feature_list)], axis=1)\n",
    "            \n",
    "    if label:\n",
    "        df['label'] = label\n",
    "        \n",
    "    return col_bins, df.to_sparse()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:44:56.669060Z",
     "start_time": "2019-04-17T16:44:56.540889Z"
    },
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "def find_bins(x, method: str = None):\n",
    "    \"\"\"Find bin edges for histograms based on different methods.\"\"\"\n",
    "    if np.isscalar(x):\n",
    "        x = [x]\n",
    "\n",
    "    bins = method or mpl.rcParams['hist.bins']\n",
    "\n",
    "    # basic input validation\n",
    "    input_empty = np.size(x) == 0\n",
    "    \n",
    "    if input_empty:\n",
    "        x = [np.array([])]\n",
    "    else:\n",
    "        x = mpl.cbook._reshape_2D(x, 'x')\n",
    "\n",
    "    nx = len(x)  # number of datasets\n",
    "    w  = [None] * nx\n",
    "\n",
    "    xmin = np.inf\n",
    "    xmax = -np.inf\n",
    "    for xi in x:\n",
    "        if len(xi) > 0:\n",
    "            xmin = min(xmin, np.nanmin(xi))\n",
    "            xmax = max(xmax, np.nanmax(xi))\n",
    "    bin_range = (xmin, xmax)\n",
    "\n",
    "    # List to store all the top coordinates of the histograms\n",
    "    tops = []\n",
    "    mlast = None\n",
    "\n",
    "    hist_kwargs = dict(range=bin_range)\n",
    "\n",
    "    # Loop through datasets\n",
    "    for i in range(nx):\n",
    "        # this will automatically overwrite bins,\n",
    "        # so that each histogram uses the same bins\n",
    "        m, bins = np.histogram(x[i], bins, weights=w[i], **hist_kwargs)\n",
    "        m = m.astype(float)  # causes problems later if it's an int\n",
    "        tops.append(m)\n",
    "\n",
    "    return tops, bins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:44:56.785854Z",
     "start_time": "2019-04-17T16:44:56.688196Z"
    },
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "def find_col_bins(data, method: str = None, export: str = None):\n",
    "    \"\"\"Find bins for every column in the data. Optinally exports as JSON.\"\"\"\n",
    "    data = list(data)\n",
    "\n",
    "    df = pd.DataFrame()\n",
    "    col_bins = {}\n",
    "    \n",
    "    for idx, col in enumerate(motion_cols):\n",
    "        bins = col_bins.get(col, None)\n",
    "\n",
    "        if bins is None:\n",
    "            _, bins = find_bins(\n",
    "                np.concatenate([d[col] for d in data]), method=method)\n",
    "            col_bins[col] = bins\n",
    "            \n",
    "    if export:\n",
    "        bins_export = Path(export)\n",
    "        bins_export.parent.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "        bins_export.write_text(json.dumps({\n",
    "            col: bins.tolist() for col, bins in col_bins.items()\n",
    "        }))\n",
    "    \n",
    "    return col_bins"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Loading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-11T14:31:20.462665Z",
     "start_time": "2019-04-11T14:31:20.358176Z"
    }
   },
   "outputs": [],
   "source": [
    "def get_raw_data(fs, path, debug=False):\n",
    "    '''Reads raw data from S3 - not parallelized\n",
    "    '''\n",
    "    data = {}\n",
    "    \n",
    "    gestures_paths = fs.ls(path)\n",
    "    \n",
    "    for gesture in gestures_paths:\n",
    "        files_to_read = fs.ls(gesture)\n",
    "    \n",
    "        key = gesture.split('/')[-1] \n",
    "        data[key] = []\n",
    "        if debug:\n",
    "            print(key)\n",
    "    \n",
    "        for file in files_to_read:\n",
    "            with fs.open(file) as f:\n",
    "                content = json.loads(f.read())\n",
    "            data[key].append(content)\n",
    "    \n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-10T15:11:01.263988Z",
     "start_time": "2019-04-10T15:11:01.162326Z"
    }
   },
   "outputs": [],
   "source": [
    "fs = s3fs.S3FileSystem()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-10T15:11:01.318573Z",
     "start_time": "2019-04-10T15:11:01.265947Z"
    }
   },
   "outputs": [],
   "source": [
    "path_to_dance_data = 'cchase-rh-demo-4/training-data'\n",
    "path_to_cross_data = 'cchase-rh-demo-4/mock-server-data/motions/2019-02-26'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-10T15:11:02.417710Z",
     "start_time": "2019-04-10T15:11:01.323571Z"
    }
   },
   "outputs": [],
   "source": [
    "data_dance_raw = get_raw_data(fs, path_to_dance_data, debug=False)\n",
    "data_cross_raw = get_raw_data(fs, path_to_cross_data, debug=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:47:20.143515Z",
     "start_time": "2019-04-17T16:47:18.431483Z"
    }
   },
   "outputs": [],
   "source": [
    "data_dance_raw = json.loads(Path('data/dance/data_dance_raw.json').read_text())\n",
    "data_cross_raw = json.loads(Path('data/dance/data_cross_raw.json').read_text())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:47:42.760906Z",
     "start_time": "2019-04-17T16:47:20.145803Z"
    }
   },
   "outputs": [],
   "source": [
    "bins_dance, data_dance_proc_partial = process_dance_data(data_dance_raw)\n",
    "bins_cross, data_cross_proc_partial = process_cross_data(data_cross_raw)\n",
    "\n",
    "bins_per_gesture = {**bins_dance, **bins_cross}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:48:01.037168Z",
     "start_time": "2019-04-17T16:47:42.762284Z"
    }
   },
   "outputs": [],
   "source": [
    "bins_total = find_col_bins(\n",
    "    clean_data(\n",
    "        itertools.chain(\n",
    "            (process_motion_rotation(x) for d in data_dance_raw.values() for x in d),\n",
    "            (process_acceleration_rotation(x, ts) for ts, x in data_cross_raw.items())\n",
    "        )\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:48:01.068470Z",
     "start_time": "2019-04-17T16:48:01.040296Z"
    }
   },
   "outputs": [],
   "source": [
    "bins = {\n",
    "    gesture: bins_total\n",
    "    for gesture in bins_per_gesture.keys()\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:48:20.768984Z",
     "start_time": "2019-04-17T16:48:01.071410Z"
    }
   },
   "outputs": [],
   "source": [
    "_, data_dance_proc_total = process_dance_data(data_dance_raw, bins=bins)\n",
    "_, data_cross_proc_total = process_cross_data(data_cross_raw, bins=bins)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:48:20.817896Z",
     "start_time": "2019-04-17T16:48:20.770535Z"
    }
   },
   "outputs": [],
   "source": [
    "arr_partial = np.concatenate(\n",
    "    (np.array(data_dance_proc_partial),np.array(data_cross_proc_partial)),\n",
    "    axis=0\n",
    ")\n",
    "\n",
    "arr_total = np.concatenate(\n",
    "    (np.array(data_dance_proc_total),np.array(data_cross_proc_total)),\n",
    "    axis=0\n",
    ")\n",
    "\n",
    "arr = np.array(list(zip(arr_partial, arr_total)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:48:20.848637Z",
     "start_time": "2019-04-17T16:48:20.819407Z"
    }
   },
   "outputs": [],
   "source": [
    "del data_dance_proc_partial\n",
    "del data_cross_proc_partial\n",
    "del data_dance_proc_total\n",
    "del data_cross_proc_total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:48:20.879573Z",
     "start_time": "2019-04-17T16:48:20.850292Z"
    }
   },
   "outputs": [],
   "source": [
    "# drop triangles\n",
    "idx = np.where(arr[:, 0, -1] != 'draw-triangle')\n",
    "\n",
    "data,   = arr[idx, :, :-1]\n",
    "labels, = arr[idx, 0, -1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:48:20.911436Z",
     "start_time": "2019-04-17T16:48:20.881511Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(812, 2, 84)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:48:20.942309Z",
     "start_time": "2019-04-17T16:48:20.913564Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(812,)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "labels.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:48:20.975384Z",
     "start_time": "2019-04-17T16:48:20.944693Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "draw-cross     185\n",
       "roll           137\n",
       "shake          136\n",
       "fever          123\n",
       "draw-circle    121\n",
       "floss          110\n",
       "dtype: int64"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(labels).value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:48:21.026749Z",
     "start_time": "2019-04-17T16:48:20.978305Z"
    }
   },
   "outputs": [],
   "source": [
    "np.random.seed(42)\n",
    "\n",
    "train_data, test_data, train_labels, test_labels = train_test_split(\n",
    "    data, labels, stratify=labels, test_size=0.20, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:48:21.061509Z",
     "start_time": "2019-04-17T16:48:21.029380Z"
    }
   },
   "outputs": [],
   "source": [
    "label_encoder = LabelEncoder()\n",
    "one_hot_encoder = OneHotEncoder(sparse=False, categories='auto')\n",
    "\n",
    "train_integer = label_encoder.fit_transform(train_labels)\n",
    "train_onehot = one_hot_encoder.fit_transform(train_integer.reshape(len(train_integer), 1))\n",
    "\n",
    "test_integer = label_encoder.transform(test_labels)\n",
    "test_onehot = one_hot_encoder.transform(test_integer.reshape(len(test_integer), 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:50:18.053031Z",
     "start_time": "2019-04-17T16:49:47.116888Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/15\n",
      "200/200 [==============================] - 2s 10ms/step - loss: 0.9304 - acc: 0.6246 - val_loss: 2.5015 - val_acc: 0.2615\n",
      "Epoch 2/15\n",
      "200/200 [==============================] - 2s 9ms/step - loss: 0.3326 - acc: 0.8909 - val_loss: 2.4146 - val_acc: 0.7846\n",
      "Epoch 3/15\n",
      "200/200 [==============================] - 2s 9ms/step - loss: 0.1782 - acc: 0.9465 - val_loss: 2.8154 - val_acc: 0.8692\n",
      "Epoch 4/15\n",
      "200/200 [==============================] - 3s 13ms/step - loss: 0.1423 - acc: 0.9595 - val_loss: 3.1794 - val_acc: 0.8000\n",
      "Epoch 5/15\n",
      "200/200 [==============================] - 2s 9ms/step - loss: 0.0991 - acc: 0.9707 - val_loss: 3.0264 - val_acc: 0.8769\n",
      "Epoch 6/15\n",
      "200/200 [==============================] - 2s 9ms/step - loss: 0.0923 - acc: 0.9733 - val_loss: 3.6470 - val_acc: 0.8923\n",
      "Epoch 7/15\n",
      "200/200 [==============================] - 2s 9ms/step - loss: 0.0874 - acc: 0.9745 - val_loss: 4.4382 - val_acc: 0.8462\n",
      "Epoch 8/15\n",
      "200/200 [==============================] - 2s 12ms/step - loss: 0.0725 - acc: 0.9781 - val_loss: 3.7400 - val_acc: 0.8846\n",
      "Epoch 9/15\n",
      "200/200 [==============================] - 2s 10ms/step - loss: 0.0870 - acc: 0.9737 - val_loss: 3.8904 - val_acc: 0.8462\n",
      "Epoch 10/15\n",
      "200/200 [==============================] - 2s 9ms/step - loss: 0.0904 - acc: 0.9723 - val_loss: 10.9755 - val_acc: 0.7615\n",
      "Epoch 11/15\n",
      "200/200 [==============================] - 2s 9ms/step - loss: 0.0667 - acc: 0.9798 - val_loss: 22.9346 - val_acc: 0.9000\n",
      "Epoch 12/15\n",
      "200/200 [==============================] - 2s 9ms/step - loss: 0.0706 - acc: 0.9778 - val_loss: 68.5640 - val_acc: 0.9000\n",
      "Epoch 13/15\n",
      "200/200 [==============================] - 2s 9ms/step - loss: 0.0677 - acc: 0.9802 - val_loss: 133.2237 - val_acc: 0.9077\n",
      "Epoch 14/15\n",
      "200/200 [==============================] - 2s 9ms/step - loss: 0.0555 - acc: 0.9831 - val_loss: 199.2527 - val_acc: 0.9077\n",
      "Epoch 15/15\n",
      "200/200 [==============================] - 2s 11ms/step - loss: 0.0570 - acc: 0.9816 - val_loss: 229.3294 - val_acc: 0.9077\n"
     ]
    }
   ],
   "source": [
    "model = keras.Sequential([\n",
    "    keras.layers.Reshape((168,), input_shape=(2, 84)),\n",
    "    keras.layers.Dense(40,  activation=tf.nn.relu),\n",
    "    keras.layers.BatchNormalization(),\n",
    "    keras.layers.Dropout(0.2),\n",
    "    keras.layers.Dense(6, activation=tf.nn.log_softmax),\n",
    "]) \n",
    "\n",
    "optimizer = keras.optimizers.Adam(lr=1e-2)\n",
    "loss      = tf.nn.softmax_cross_entropy_with_logits_v2\n",
    "metrics   = ['accuracy']\n",
    "\n",
    "model.compile(optimizer=optimizer,  loss=loss, metrics=metrics)\n",
    "\n",
    "c = 1 / len(label_encoder.classes_) \n",
    "penalization = {\n",
    "    'draw-circle': c / 2,\n",
    "    'draw-cross' : c / 2,\n",
    "    'fever': c,\n",
    "    'floss': 2 * c,\n",
    "    'roll' : c,\n",
    "    'shake': c / 2\n",
    "}\n",
    "class_weight = dict(zip(label_encoder.transform(list(penalization.keys())), penalization.values()))\n",
    "\n",
    "history = model.fit(train_data,\n",
    "                    train_onehot,\n",
    "                    class_weight=class_weight,\n",
    "                    batch_size=100,\n",
    "                    epochs=15,\n",
    "                    steps_per_epoch=200,\n",
    "                    shuffle=True,\n",
    "                    validation_split=0.2,\n",
    "                    verbose=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:50:19.297379Z",
     "start_time": "2019-04-17T16:50:19.121574Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "163/163 [==============================] - 0s 498us/sample - loss: 100.7633 - acc: 0.9387\n",
      "Test accuracy: 0.9386503\n"
     ]
    }
   ],
   "source": [
    "test_loss, test_acc = model.evaluate(test_data, test_onehot)\n",
    "\n",
    "print('Test accuracy:', test_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:50:23.724622Z",
     "start_time": "2019-04-17T16:50:23.087483Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'predicted')"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_hat = model.predict(test_data)\n",
    "y_hat = y_hat.argmax(axis=1)\n",
    "y_hat = label_encoder.inverse_transform(y_hat)\n",
    "\n",
    "fig = plt.figure(figsize=(5,5))\n",
    "ax = plt.subplot()\n",
    "\n",
    "labels = pd.Series(test_labels).value_counts().index\n",
    "\n",
    "confusion = confusion_matrix(test_labels, y_hat, labels=labels)\n",
    "ax.matshow(confusion)\n",
    "\n",
    "ax.set_xticks(range(len(labels)))\n",
    "ax.set_yticks(range(len(labels)))\n",
    "\n",
    "ax.set_xticklabels(labels, rotation=90);\n",
    "ax.set_yticklabels(labels);\n",
    "\n",
    "for i in range(len(labels)):\n",
    "    for j in range(len(labels)):        \n",
    "        ax.text(j, i, confusion[i,j], va='center', ha='center')\n",
    "        \n",
    "plt.xlabel('true')\n",
    "plt.ylabel('predicted')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:50:24.814175Z",
     "start_time": "2019-04-17T16:50:24.705581Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "  draw-cross       0.97      0.97      0.97        37\n",
      "        roll       0.96      0.93      0.95        28\n",
      "       shake       0.89      0.89      0.89        27\n",
      "       fever       0.88      0.88      0.88        25\n",
      " draw-circle       1.00      1.00      1.00        24\n",
      "       floss       0.91      0.95      0.93        22\n",
      "\n",
      "   micro avg       0.94      0.94      0.94       163\n",
      "   macro avg       0.94      0.94      0.94       163\n",
      "weighted avg       0.94      0.94      0.94       163\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(test_labels, y_hat, labels=labels))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:50:50.818379Z",
     "start_time": "2019-04-17T16:50:49.340984Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rm: cannot remove 'models/v5/pb/1555519849': No such file or directory\n",
      "INFO:tensorflow:Assets added to graph.\n",
      "INFO:tensorflow:No assets to write.\n",
      "INFO:tensorflow:SavedModel written to: models/v5/pb/1555519849/saved_model.pb\n",
      "\n",
      "Saved model:\n",
      "total 444\n",
      "-rw-r--r--. 1 macermak vpnusers 450294 Apr 17 18:50 saved_model.pb\n",
      "drwxr-xr-x. 2 macermak vpnusers   4096 Apr 17 18:50 variables\n",
      "\n",
      "Saved model:\n",
      "total 116\n",
      "-rw-r--r--. 1 macermak vpnusers 115216 Apr 17 18:50 saved_model.h5\n",
      "WARNING:tensorflow:This model was compiled with a Keras optimizer (<tensorflow.python.keras.optimizers.Adam object at 0x7fc41821c278>) but is being saved in TensorFlow format with `save_weights`. The model's weights will be saved, but unlike with TensorFlow optimizers in the TensorFlow format the optimizer's state will not be saved.\n",
      "\n",
      "Consider using a TensorFlow optimizer from `tf.train`.\n",
      "\n",
      "Saved model:\n",
      "total 48\n",
      "-rw-r--r--. 1 macermak vpnusers    77 Apr 17 18:50 checkpoint\n",
      "-rw-r--r--. 1 macermak vpnusers 34219 Apr 17 18:50 checkpoint.data-00000-of-00001\n",
      "-rw-r--r--. 1 macermak vpnusers   997 Apr 17 18:50 checkpoint.index\n",
      "-rw-r--r--. 1 macermak vpnusers  2001 Apr 17 18:50 saved_model_spec.json\n"
     ]
    }
   ],
   "source": [
    "save = True\n",
    "ver = int(dt.now().timestamp())\n",
    "\n",
    "if save:\n",
    "    # export bins\n",
    "    bins_export = Path('models/v5/bins_partial.json')\n",
    "    bins_export.parent.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "    bins_export.write_text(json.dumps({\n",
    "        gesture: {\n",
    "            col: bins.tolist() for col, bins in col_bin.items()\n",
    "        } for gesture, col_bin in bins_per_gesture.items()\n",
    "    }))\n",
    "    \n",
    "    bins_export = Path('models/v5/bins.json')\n",
    "    bins_export.write_text(json.dumps({\n",
    "        gesture: {\n",
    "            col: bins.tolist() for col, bins in col_bin.items()\n",
    "        } for gesture, col_bin in bins.items()\n",
    "    }))\n",
    "    \n",
    "    # export encoder\n",
    "    joblib.dump(label_encoder, 'models/v5/encoder.joblib')\n",
    "    \n",
    "    for fmt in ['pb', 'hdf5', 'json']:\n",
    "        # save model as hdf5\n",
    "        MODEL_DIR = f\"models/v5/{fmt}\"\n",
    "        export_path = Path(MODEL_DIR, str(ver))\n",
    "\n",
    "        if fmt == 'pb':\n",
    "            # simple_save can not handle existing repository\n",
    "            !rm -r {export_path}\n",
    "\n",
    "            # Inspired by https://www.tensorflow.org/serving/tutorials/Serving_REST_simple\n",
    "            # to save model for TF-serving\n",
    "            tf.saved_model.simple_save(\n",
    "                tf.keras.backend.get_session(),\n",
    "                str(export_path),\n",
    "                inputs={'input_data': model.input},\n",
    "                outputs={t.name:t for t in model.outputs})\n",
    "            \n",
    "        elif fmt == 'hdf5':\n",
    "            # make sure directory exists\n",
    "            os.makedirs(export_path, exist_ok=True)\n",
    "            \n",
    "            model_path = Path(export_path, 'saved_model.h5') \n",
    "            \n",
    "            # hdf5\n",
    "            model.save(model_path)\n",
    "            \n",
    "        else:\n",
    "            # make sure directory exists\n",
    "            os.makedirs(export_path, exist_ok=True)\n",
    "            \n",
    "            # json\n",
    "            model_spec_path = Path(\n",
    "                export_path, 'saved_model_spec.json'\n",
    "            )\n",
    "            model_weights_path = Path(\n",
    "                export_path, 'checkpoint')\n",
    "            \n",
    "            model_spec_path.write_text(model.to_json(), encoding='utf-8')\n",
    "            model.save_weights(str(model_weights_path))\n",
    "\n",
    "        print('\\nSaved model:')\n",
    "        !ls -l {export_path}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prediction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Local"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:48:45.469626Z",
     "start_time": "2019-04-17T16:48:44.901046Z"
    }
   },
   "outputs": [],
   "source": [
    "import requests\n",
    "\n",
    "data = {\n",
    "    \"instances\": data_dance_raw['floss'][-5:] + data_dance_raw['fever'][-5:]\n",
    "}\n",
    "json_response = requests.post(\"http://localhost:5000/model/predict\", json=data, headers={\"Host\": 'localhost', \"Content-Type\":\"application/json\"})\n",
    "\n",
    "print(json.dumps(json_response.json(), indent=4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:48:45.486784Z",
     "start_time": "2019-04-17T16:47:18.607Z"
    }
   },
   "outputs": [],
   "source": [
    "fake_instances = data_dance_raw['floss'][-10:]\n",
    "\n",
    "[d.update(gesture='roll') for d in fake_instances]\n",
    "\n",
    "data = {\n",
    "    \"instances\": fake_instances\n",
    "}\n",
    "json_response = requests.post(\"http://localhost:5000/model/predict\", json=data, headers={\"Host\": 'localhost', \"Content-Type\":\"application/json\"})\n",
    "\n",
    "print(json.dumps(json_response.json(), indent=4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Knative"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:48:45.490593Z",
     "start_time": "2019-04-17T16:47:18.657Z"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "\n",
    "oc start-build tf-serving --from-dir ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:48:45.499097Z",
     "start_time": "2019-04-17T16:47:18.660Z"
    }
   },
   "outputs": [],
   "source": [
    "builds = !oc get builds\n",
    "latest = builds[-1].split()[0]\n",
    "\n",
    "!oc logs -f build.build.openshift.io/$latest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:48:45.502954Z",
     "start_time": "2019-04-17T16:47:18.666Z"
    }
   },
   "outputs": [],
   "source": [
    "revision = int(dt.timestamp(dt.now()))\n",
    "\n",
    "!oc process tf-serving-knative -p REVISION=$revision | oc apply -f -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:48:45.512681Z",
     "start_time": "2019-04-17T16:47:18.669Z"
    }
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "\n",
    "while oc get pods | grep tf-serving-knative | grep -v Running; do \n",
    "    oc get pods | grep tf-serving-knative\n",
    "    sleep 1\n",
    "done"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:48:45.516970Z",
     "start_time": "2019-04-17T16:47:18.673Z"
    }
   },
   "outputs": [],
   "source": [
    "%%bash --out KSERVICE_DOMAIN\n",
    "\n",
    "oc get kservice tf-serving-knative-demo -o jsonpath='{.status.domain}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:48:45.520632Z",
     "start_time": "2019-04-17T16:47:18.679Z"
    }
   },
   "outputs": [],
   "source": [
    "KSERVICE_DOMAIN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-04-17T16:48:45.525581Z",
     "start_time": "2019-04-17T16:47:18.682Z"
    }
   },
   "outputs": [],
   "source": [
    "import requests\n",
    "\n",
    "INGRESS_GATEWAY=\"istio-ingressgateway.istio-system.svc.cluster.local\"\n",
    "\n",
    "data = {\n",
    "  \"instances\": [\n",
    "      json.loads(Path('data/dance/floss/example.json').read_text())\n",
    "  ]\n",
    "}\n",
    "json_response = requests.post(\"http://%s/model/predict\" % INGRESS_GATEWAY, json=data, headers={\"Host\": KSERVICE_DOMAIN, \"Content-Type\":\"application/json\"})\n",
    "\n",
    "print(json.dumps(json_response.json(), indent=4))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "rh-summit-demo",
   "language": "python",
   "name": "rh-summit-demo"
  },
  "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.6"
  },
  "require": {
   "paths": {
    "buttons.colvis": "https://cdn.datatables.net/buttons/1.5.6/js/buttons.colVis.min",
    "buttons.flash": "https://cdn.datatables.net/buttons/1.5.6/js/buttons.flash.min",
    "buttons.html5": "https://cdn.datatables.net/buttons/1.5.6/js/buttons.html5.min",
    "buttons.print": "https://cdn.datatables.net/buttons/1.5.6/js/buttons.print.min",
    "d3": "https://cdnjs.cloudflare.com/ajax/libs/d3/5.9.2/d3.min",
    "datatables.net": "https://cdn.datatables.net/1.10.18/js/jquery.dataTables",
    "datatables.net-buttons": "https://cdn.datatables.net/buttons/1.5.6/js/dataTables.buttons.min",
    "datatables.scroller": "https://cdn.datatables.net/scroller/2.0.0/js/dataTables.scroller.min",
    "datatables.select": "https://cdn.datatables.net/select/1.3.0/js/dataTables.select.min",
    "jszip": "https://cdnjs.cloudflare.com/ajax/libs/jszip/2.5.0/jszip.min",
    "pdfmake": "https://cdnjs.cloudflare.com/ajax/libs/pdfmake/0.1.36/pdfmake.min",
    "vfsfonts": "https://cdnjs.cloudflare.com/ajax/libs/pdfmake/0.1.36/vfs_fonts"
   },
   "shim": {
    "buttons.colvis": {
     "deps": [
      "jszip",
      "datatables.net-buttons"
     ]
    },
    "buttons.flash": {
     "deps": [
      "jszip",
      "datatables.net-buttons"
     ]
    },
    "buttons.html5": {
     "deps": [
      "jszip",
      "datatables.net-buttons"
     ]
    },
    "buttons.print": {
     "deps": [
      "jszip",
      "datatables.net-buttons"
     ]
    },
    "datatables.net": {
     "exports": "$.fn.dataTable"
    },
    "datatables.net-buttons": {
     "deps": [
      "datatables.net"
     ]
    },
    "pdfmake": {
     "deps": [
      "datatables.net"
     ]
    },
    "vfsfonts": {
     "deps": [
      "datatables.net"
     ]
    }
   }
  },
  "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
}