joint_control/learn_posture.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Learn Posture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "use machine learning to recognize robot's posture (following the example in [scikit-learn-intro.ipynb](./scikit-learn-intro.ipynb) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Data collection\n",
    "\n",
    "We have colleceted data before, you need to add new data if you want to add new posture.\n",
    "\n",
    "* the dateset are in *robot_pose_data* folder\n",
    "* each file contains the data belongs to this posture, e.g. the data in *Back* file are collected when robot was in \"Back\" posture\n",
    "* the data file can be load by ```pickle```, e.g. ```pickle.load(open('Back'))```, the data is a list of feature data\n",
    "* the features (e.g. each row of the data) are ['LHipYawPitch', 'LHipRoll', 'LHipPitch', 'LKneePitch', 'RHipYawPitch', 'RHipRoll', 'RHipPitch', 'RKneePitch', 'AngleX', 'AngleY'], where 'AngleX' and 'AngleY' are body angle (e.g. ```Perception.imu```) and others are joint angles."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Data preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "%pylab inline\n",
    "import pickle\n",
    "from os import listdir, path\n",
    "import numpy as np\n",
    "from sklearn import svm, metrics\n",
    "\n",
    "ROBOT_POSE_DATA_DIR = 'robot_pose_data'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Back', 'Belly', 'Crouch', 'Frog', 'HeadBack', 'Knee', 'Left', 'Right', 'Sit', 'Stand', 'StandInit']\n"
     ]
    }
   ],
   "source": [
    "classes = listdir(ROBOT_POSE_DATA_DIR)\n",
    "print classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "def load_pose_data(i):\n",
    "    '''load pose data from file'''\n",
    "    data = []\n",
    "    target = []\n",
    "    # YOUR CODE HERE\n",
    "    \n",
    "    filename = path.join(ROBOT_POSE_DATA_DIR, classes[i])\n",
    "    data = pickle.load(open(filename))\n",
    "    target = [classes[i]] * len(data)\n",
    "    return data, target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total number of data 222\n"
     ]
    }
   ],
   "source": [
    "# load all the data\n",
    "all_data = []\n",
    "all_target = []\n",
    "# YOUR CODE HERE\n",
    "for i in range(len(classes)):\n",
    "    data, target = load_pose_data(i)\n",
    "    all_data.extend(data)\n",
    "    all_target.extend(target)\n",
    "    \n",
    "all_data = np.asarray(all_data)\n",
    "all_target = np.asarray(all_target)\n",
    "\n",
    "print 'total number of data', len(all_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "# shuffule data\n",
    "permutation = np.random.permutation(len(all_data))\n",
    "n_training_data = int(len(all_data) * 0.7)\n",
    "training_data = permutation[:n_training_data]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Learn on training data\n",
    "\n",
    "In scikit-learn, an estimator for classification is a Python object that implements the methods fit(X, y) and predict(T). An example of an estimator is the class sklearn.svm.SVC that implements support vector classification."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "clf = svm.SVC(gamma=0.001, C=100.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SVC(C=100.0, cache_size=200, class_weight=None, coef0=0.0,\n",
       "  decision_function_shape='ovr', degree=3, gamma=0.001, kernel='rbf',\n",
       "  max_iter=-1, probability=False, random_state=None, shrinking=True,\n",
       "  tol=0.001, verbose=False)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# YOUR CODE HERE\n",
    "clf.fit(all_data[training_data], all_target[training_data])\n",
    "# clf.fit(digits.data[:-500], digits.target[:-500]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### predicting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.24693203  0.12582994 -0.28681612  0.99552417 -0.24693203 -0.12421203\n",
      "  -0.30049455  1.01094818  0.01514834  0.11869175]]\n",
      "['StandInit']\n"
     ]
    }
   ],
   "source": [
    "clf.predict(all_data[-1:]), all_target[-1:]\n",
    "print all_data[-1:]\n",
    "print all_target[-1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "def evaluate(expected, predicted):\n",
    "    print(\"Classification report:\\n%s\\n\" % metrics.classification_report(expected, predicted))\n",
    "\n",
    "    print(\"Confusion matrix:\\n%s\" % metrics.confusion_matrix(expected, predicted))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "expected = []\n",
    "predicted = []\n",
    "# YOUR CODE HERE\n",
    "expected = all_target[training_data]\n",
    "predicted = clf.predict(all_data[training_data])\n",
    "evaluate(expected, predicted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Evaluate on the test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "expected = []\n",
    "predicted = []\n",
    "# YOUR CODE HERE\n",
    "test_data = permutation[n_training_data:]\n",
    "expected = all_target[test_data]\n",
    "predicted = clf.predict(all_data[test_data])\n",
    "evaluate(expected, predicted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Deploy to the real system\n",
    "\n",
    "We can simple use `pickle` module to serialize the trained classifier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "import pickle\n",
    "ROBOT_POSE_CLF = 'robot_pose.pkl'\n",
    "pickle.dump(clf, open(ROBOT_POSE_CLF, 'w'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, in the application we can load the trained classifier again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "clf2 = pickle.load(open(ROBOT_POSE_CLF))\n",
    "clf2.predict(all_data[-1:]), all_target[-1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "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.17"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "metadata": {
     "collapsed": false
    },
    "source": []
   }
  },
  "widgets": {
   "state": {},
   "version": "1.0.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}