TouchWebData.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "sess = tf.InteractiveSession()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# construct a 3d convolutional network\n",
    "x = tf.placeholder(tf.float32, shape=[None, 12,12,12])\n",
    "y_ = tf.placeholder(tf.float32, shape=[None, 10])\n",
    "\n",
    "def weight_variable(shape):\n",
    "  initial = tf.truncated_normal(shape, stddev=0.1)\n",
    "  return tf.Variable(initial)\n",
    "\n",
    "def bias_variable(shape):\n",
    "  initial = tf.constant(0.1, shape=shape)\n",
    "  return tf.Variable(initial)\n",
    "\n",
    "def conv3d(x, W):\n",
    "  return tf.nn.conv3d(x, W, strides=[1, 1, 1, 1, 1], padding='SAME')\n",
    "\n",
    "def max_pool_2x2x2(x):\n",
    "  return tf.nn.max_pool3d(x, ksize=[1, 2, 2, 2, 1],\n",
    "                        strides=[1, 2, 2, 2, 1], padding='SAME')\n",
    "\n",
    "W_conv1 = weight_variable([4, 4, 4, 1, 32])\n",
    "b_conv1 = bias_variable([32])\n",
    "x_image = tf.reshape(x, [-1,12,12,12,1])\n",
    "\n",
    "h_conv1 = tf.nn.relu(conv3d(x_image, W_conv1) + b_conv1)\n",
    "h_pool1 = max_pool_2x2x2(h_conv1)\n",
    "\n",
    "W_conv2 = weight_variable([4, 4, 4, 32, 64])\n",
    "b_conv2 = bias_variable([64])\n",
    "\n",
    "h_conv2 = tf.nn.relu(conv3d(h_pool1, W_conv2) + b_conv2)\n",
    "h_pool2 = max_pool_2x2x2(h_conv2)\n",
    "\n",
    "W_fc1 = weight_variable([3 * 3 * 3 * 64, 1024])\n",
    "b_fc1 = bias_variable([1024])\n",
    "\n",
    "h_pool2_flat = tf.reshape(h_pool2, [-1, 3*3*3*64])\n",
    "h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)\n",
    "\n",
    "keep_prob = tf.placeholder(tf.float32)\n",
    "h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)\n",
    "\n",
    "W_fc2 = weight_variable([1024, 10])\n",
    "b_fc2 = bias_variable([10])\n",
    "\n",
    "y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2\n",
    "\n",
    "saver = tf.train.Saver()\n",
    "cross_entropy = tf.reduce_mean(\n",
    "    tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))\n",
    "train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)\n",
    "correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n",
    "sess.run(tf.global_variables_initializer())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import json\n",
    "from pprint import pprint\n",
    "\n",
    "with open('touchdata.json') as data_file:    \n",
    "    data = json.load(data_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import operator\n",
    "import math\n",
    "from functools import reduce\n",
    "\n",
    "# anti aliased n-dimensional line\n",
    "# works well for lines <1 pixel length\n",
    "def aline(s, e, cb):\n",
    "    def _fpart(x):\n",
    "        return x - math.floor(x)\n",
    "    def _rfpart(x):\n",
    "        return 1 - _fpart(x)\n",
    "    \n",
    "    diff = [abs(j-i) for (j, i) in zip(e, s)]\n",
    "    maxd = max(diff)\n",
    "    if maxd <= 0: return\n",
    "    maxi = np.argmax(diff)\n",
    "    sign = int(np.sign(e[maxi] - s[maxi]))\n",
    "    grad = [(j-i) / maxd for (j, i) in zip(e, s)]\n",
    "    sv = np.zeros_like(s)\n",
    "    sv[maxi] = sign\n",
    "    \n",
    "    if sign < 0: (s, e) = (s + sv, e + sv) \n",
    "    sf = _rfpart(s[maxi]) if sign > 0 else _fpart(s[maxi])\n",
    "    q = (s + np.multiply(grad, sf))\n",
    "    sq = (s - np.multiply(sv, 1-sf))\n",
    "\n",
    "    ef = _rfpart(e[maxi]) if sign > 0 else _fpart(e[maxi])\n",
    "    qe = (e - np.multiply(grad, 1 - ef))\n",
    "    eq = (e + np.multiply(sv, ef))\n",
    "    \n",
    "    #print(sf)\n",
    "    #print(q)\n",
    "    #print(qe)\n",
    "    \n",
    "    for n in range(2**len(s)):\n",
    "        if n & (2**maxi): continue\n",
    "        nd = [0 != (n & (2**a)) for a in range(len(s))]\n",
    "        o = reduce(operator.mul, \n",
    "                   [_fpart(v) if b else _rfpart(v) for (v, b) in zip(sq, nd)])\n",
    "        if o == 0: continue\n",
    "        cb(tuple((sq + nd).astype(int)), o * sf)\n",
    "\n",
    "    for _ in range(int(q[maxi]), int(qe[maxi] + sign), sign):\n",
    "        for n in range(2**len(q)):\n",
    "            if n & (2**maxi): continue\n",
    "            nd = [0 != n & (2**a) for a in range(len(q))]\n",
    "            o = reduce(operator.mul, \n",
    "                       [_fpart(v) if b else _rfpart(v) for (v, b) in zip(q, nd)])\n",
    "            if o == 0: continue\n",
    "            cb(tuple((q + nd).astype(int)), o)\n",
    "        q = np.add(q, grad)\n",
    "\n",
    "    for n in range(2**len(e)):\n",
    "        if n & (2**maxi): continue\n",
    "        nd = [0 != (n & (2**a)) for a in range(len(e))]\n",
    "        o = -reduce(operator.mul, \n",
    "                   [_fpart(v) if b else _rfpart(v) for (v, b) in zip(qe, nd)])\n",
    "        if o == 0: continue\n",
    "        cb(tuple((qe + nd).astype(int)), o * ef)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# n-dimensional line without anti aliasing\n",
    "def line(s, e, cb):\n",
    "    diff = [abs(i-j) for (i,j) in zip(s, e)]\n",
    "    sign = [1 if i < j else -1 for (i,j) in zip(s, e)]\n",
    "    maxd = max(diff)\n",
    "    p = [maxd/2]*len(s)\n",
    "    q = list(s)\n",
    "    \n",
    "    for _ in range(maxd):\n",
    "        cb(tuple(q))\n",
    "        for i in range(len(s)):\n",
    "            p[i] -= diff[i]\n",
    "            if (p[i] < 0):\n",
    "                p[i] += maxd\n",
    "                q[i] += sign[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from collections import namedtuple\n",
    "from itertools import chain\n",
    "\n",
    "Point = namedtuple(\"Point\", \"x y t p\")\n",
    "\n",
    "def make_picture(drawing):\n",
    "    #drawing2 = [[Point(**p) for p in s] for s in drawing]\n",
    "    #def point_min(p1, p2):\n",
    "    #    return Point(min(p1.x, p2.x), min(p1.y, p2.y), min(p1.t, p2.t), p1.p)\n",
    "    #mini = reduce(point_min, chain(*drawing2), drawing2[0][0])\n",
    "    \n",
    "    mini = dict(drawing[0][0])\n",
    "    maxi = dict(drawing[0][0])\n",
    "    for s in drawing:\n",
    "        for p in s:\n",
    "            mini['x'] = min(float(mini['x']), float(p['x']))\n",
    "            mini['y'] = min(float(mini['y']), float(p['y']))\n",
    "            mini['t'] = min(float(mini['t']), float(p['t']))\n",
    "            maxi['x'] = max(float(maxi['x']), float(p['x']))\n",
    "            maxi['y'] = max(float(maxi['y']), float(p['y']))\n",
    "            maxi['t'] = max(float(maxi['t']), float(p['t']))\n",
    "\n",
    "    for s in drawing:\n",
    "        for p in s:\n",
    "            p['x'] = 11 * (float(p['x']) - mini['x']) / (maxi['x'] - mini['x'])\n",
    "            p['y'] = 11 * (float(p['y']) - mini['y']) / (maxi['y'] - mini['y'])\n",
    "            p['t'] = 11 * (float(p['t']) - mini['t']) / (maxi['t'] - mini['t'])\n",
    "    \n",
    "    picture = np.zeros((12, 12, 12))\n",
    "    def pixel(p, a):\n",
    "        if np.all(np.less(p, picture.shape)):\n",
    "            picture[p] += a\n",
    "\n",
    "    for stroke in drawing:\n",
    "        for (s, e) in zip(stroke, stroke[1:]):\n",
    "            #spoint = (round(s['t']), round(s['y']), round(s['x']))\n",
    "            #epoint = (round(e['t']), round(e['y']), round(e['x']))\n",
    "            #line(spoint, epoint, pixel)\n",
    "            spoint = (s['t'], s['y'], s['x'])\n",
    "            epoint = (e['t'], e['y'], e['x'])\n",
    "            aline(spoint, epoint, pixel)\n",
    "\n",
    "    return picture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "i = 0\n",
    "#np.set_printoptions(threshold=np.nan, linewidth=140, precision=4, suppress=True)\n",
    "for challenge in data['submission']:\n",
    "    if len(challenge) != 10 or len(challenge[0]['strokes']) == 0 or len(challenge[0]['strokes'][0]) == 0:\n",
    "        continue # filter out submissions we cannot train\n",
    "    #pprint(challenge)\n",
    "    pictures = np.array([make_picture(c['strokes']) for c in challenge])\n",
    "    classification = sess.run(tf.one_hot([int(c['description']) for c in challenge], 10))\n",
    "    \n",
    "    #pprint(classification)\n",
    "    #pprint(pictures)\n",
    "    \n",
    "    if i%2 == 0:\n",
    "        train_accuracy = accuracy.eval(feed_dict={\n",
    "            x:pictures, y_: classification, keep_prob: 1.0})\n",
    "        print(\"step %d, training accuracy %g\"%(i, train_accuracy))\n",
    "    train_step.run(feed_dict={x:pictures, y_: classification, keep_prob: 0.5})\n",
    "    i = i + 1"
   ]
  }
 ],
 "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.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}