notebooks/particle_predictor/particle_predictor_v3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# import tensorflow and numpy\n",
    "import tensorflow as tf\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Hyperparameters\n",
    "# number of points for input data\n",
    "vals = 4\n",
    "# size of frame (1d in this case)\n",
    "max_answer = 100\n",
    "\n",
    "# number of gradients to learn, it goes up to\n",
    "# the maximum linear line for this size of frame\n",
    "gradients = max_answer/(vals)+1\n",
    "\n",
    "iterations = 10000\n",
    "\n",
    "# limit gpu memory usage\n",
    "gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.5)\n",
    "learning_rate = 1e-5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([[  0,   0,   0,   0,   0],\n",
      "       [  0,   1,   2,   3,   4],\n",
      "       [  0,   2,   4,   6,   8],\n",
      "       [  0,   3,   6,   9,  12],\n",
      "       [  0,   4,   8,  12,  16],\n",
      "       [  0,   5,  10,  15,  20],\n",
      "       [  0,   6,  12,  18,  24],\n",
      "       [  0,   7,  14,  21,  28],\n",
      "       [  0,   8,  16,  24,  32],\n",
      "       [  0,   9,  18,  27,  36],\n",
      "       [  0,  10,  20,  30,  40],\n",
      "       [  0,  11,  22,  33,  44],\n",
      "       [  0,  12,  24,  36,  48],\n",
      "       [  0,  13,  26,  39,  52],\n",
      "       [  0,  14,  28,  42,  56],\n",
      "       [  0,  15,  30,  45,  60],\n",
      "       [  0,  16,  32,  48,  64],\n",
      "       [  0,  17,  34,  51,  68],\n",
      "       [  0,  18,  36,  54,  72],\n",
      "       [  0,  19,  38,  57,  76],\n",
      "       [  0,  20,  40,  60,  80],\n",
      "       [  0,  21,  42,  63,  84],\n",
      "       [  0,  22,  44,  66,  88],\n",
      "       [  0,  23,  46,  69,  92],\n",
      "       [  0,  24,  48,  72,  96],\n",
      "       [  0,  25,  50,  75, 100]], dtype=int32), 26)\n"
     ]
    }
   ],
   "source": [
    "# function to create line data\n",
    "def training_data():\n",
    "\n",
    "    # initialize variable and arrays\n",
    "\n",
    "    M = 0                  # gradient\n",
    "    rows = 1               # number of rows in output array\n",
    "    X = np.arange(vals+1)  # input array, x values of line, extra value for the labels\n",
    "    Y = np.array([])       # output array, y values of line\n",
    "\n",
    "    # loop for each gradient\n",
    "    for i in range(gradients):\n",
    "\n",
    "        # append a new line to Y array and reshape to have one line per row\n",
    "        Y = np.append(Y, X*M).reshape(rows,vals+1)\n",
    "\n",
    "        # increase gradient and rows by 1\n",
    "        rows += 1\n",
    "        M+=1\n",
    "\n",
    "    # return linedata in Y array and number of rows\n",
    "    return(Y.astype(np.int32),np.size(Y,0))\n",
    "\n",
    "print(training_data())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# y arrays and number of them form before\n",
    "training_line_data,training_lines = training_data()\n",
    "\n",
    "# set lengths to use when formatting input data\n",
    "length = max_answer\n",
    "full_length = length*vals\n",
    "\n",
    "# function to format data\n",
    "# variables are line data in number form and mode\n",
    "def format_data(training_line_data, mode):\n",
    "            \n",
    "    # if its in training mode\n",
    "    if mode == 'train':\n",
    "        # set number of times to loop\n",
    "        number_points = vals\n",
    "        number_lines = training_lines\n",
    "        # create labels and input data\n",
    "        labels = np.zeros([training_lines,1,gradients])\n",
    "        input_data = np.zeros([training_lines,vals,length])\n",
    "        \n",
    "    else:\n",
    "        # set number of times to loop\n",
    "        number_points = vals\n",
    "        number_lines = 1\n",
    "        # set first value to take away from the array to remove b\n",
    "        first_value = test_line[0]\n",
    "        training_line_data = np.subtract(training_line_data,first_value)\n",
    "        # create input data\n",
    "        input_data = np.zeros([vals,length])\n",
    "        \n",
    "    # loop for each different line\n",
    "    for i in range(number_lines):\n",
    "        # loop for each value to plot\n",
    "        for a in range(number_points):\n",
    "            \n",
    "            # set the specified input data values to 1\n",
    "            if mode == 'train':\n",
    "                input_data[i,a,training_line_data[i,a]] = 1\n",
    "            else:\n",
    "                # only do it for one line if not in training mode\n",
    "                input_data[a,training_line_data[a]] = 1\n",
    "            \n",
    "        # set the specified label values to 1 if in train mode\n",
    "        if mode == 'train':\n",
    "            labels[i,0,training_line_data[i,1]] = 1\n",
    "    \n",
    "    # reshape and return data and labels if in train mode\n",
    "    if mode == 'train':\n",
    "        input_data = input_data.reshape(number_lines,1,full_length)\n",
    "        return(input_data.astype(np.float32),labels)\n",
    "    else:\n",
    "        input_data = input_data.reshape(1,full_length)\n",
    "        return(input_data.astype(np.float32))\n",
    "\n",
    "# print data if necessary\n",
    "#print(format_data(training_line_data, 'train'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# define functions to create weights/biases\n",
    "def weight_variable(shape):\n",
    "    # will return a random array in shape specified\n",
    "    initial = tf.truncated_normal(shape, stddev=0.1)\n",
    "    return tf.Variable(initial)\n",
    "\n",
    "def bias_variable(shape):\n",
    "    # will return a random array in shape specified\n",
    "    initial = tf.constant(0.1, shape=shape)\n",
    "    return tf.Variable(initial)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# define the convolutional layer\n",
    "def conv2d(x, W):\n",
    "    # returns the  output of conv2d \n",
    "    # x is input tensor\n",
    "    # W is the weights that sweep over x\n",
    "    # strides is the size steps the filter moves in each dimension\n",
    "    # padding = SAME means it will pad the outside with zeros to  kepp the same size\n",
    "    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')\n",
    "\n",
    "# define the pooling layer\n",
    "def max_pool_2x2(x):\n",
    "    # this reduces the size of the tensor\n",
    "    # ksize is the window size\n",
    "    # strides is the same as above\n",
    "    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# define function which creates the neural net\n",
    "def deepnn(x):\n",
    "    # make initial weights and biases\n",
    "    # first 2 are size of  window, then input channels and 32 is the number of output channels\n",
    "    W_conv1 = weight_variable([4, 4, 1, 32])\n",
    "    b_conv1 = bias_variable([32])\n",
    "\n",
    "    # reshape x to a 4d tensor, batch size , dimensions and colour channels\n",
    "    x_image = tf.reshape(x, [-1,vals,length,1])\n",
    "    \n",
    "    # convolve the input tensor and apply the relu function \n",
    "    h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)\n",
    "    # apply max pooling to the output of the convolutional layer\n",
    "    # this will  halve the size of the tensor dimensions\n",
    "    h_pool1 = max_pool_2x2(h_conv1)\n",
    "    \n",
    "    # make initial weights and biases for second layer\n",
    "    # this time with 32 input channels and 64 output channels\n",
    "    W_conv2 = weight_variable([4, 4, 32, 64])\n",
    "    b_conv2 = bias_variable([64])\n",
    "\n",
    "    # we do the same as the first layer\n",
    "    # this will again halve the tensor dimensions\n",
    "    h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)\n",
    "    h_pool2 = max_pool_2x2(h_conv2)\n",
    "\n",
    "    # Now we put it through the densley connected layer\n",
    "    # make the weights and biases with 1024 neurons in a 2d array\n",
    "    W_fc1 = weight_variable([(vals/4) * (length/4) * 64, 1024])\n",
    "    b_fc1 = bias_variable([1024])\n",
    "\n",
    "    # flatten  the tensor and apply the weights and biases\n",
    "    # and apply the relu function\n",
    "    h_pool2_flat = tf.reshape(h_pool2, [-1, (vals/4)*(length/4)*64])\n",
    "    h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)\n",
    "    \n",
    "    # dropout to prevent overfitting\n",
    "    # it is a placeholder so we can change it for training or testing\n",
    "    keep_prob = tf.placeholder(tf.float32)\n",
    "    h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)\n",
    "    \n",
    "    # In Readout layer weapply the final weights and biases to find the probabilities ofeach gradient\n",
    "    W_fc2 = weight_variable([1024, gradients])\n",
    "    b_fc2 = bias_variable([gradients])\n",
    "\n",
    "    y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2\n",
    "    \n",
    "    # return the probabilities and keep prob\n",
    "    return(y_conv, keep_prob)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 0 training accuracy 0.0384615 \n",
      "error = 3.73074\n",
      "step 500 training accuracy 0.0769231 \n",
      "error = 5.36521\n",
      "step 1000 training accuracy 0.307692 \n",
      "error = 2.7121\n",
      "step 1500 training accuracy 0.576923 \n",
      "error = 2.41091\n",
      "step 2000 training accuracy 0.653846 \n",
      "error = 2.189\n",
      "step 2500 training accuracy 0.730769 \n",
      "error = 2.43226\n",
      "step 3000 training accuracy 0.884615 \n",
      "error = 1.89678\n",
      "step 3500 training accuracy 0.884615 \n",
      "error = 2.08981\n",
      "step 4000 training accuracy 0.923077 \n",
      "error = 2.16046\n",
      "step 4500 training accuracy 0.961538 \n",
      "error = 2.02216\n",
      "step 5000 training accuracy 0.923077 \n",
      "error = 1.52454\n",
      "step 5500 training accuracy 0.961538 \n",
      "error = 1.26528\n",
      "step 6000 training accuracy 0.961538 \n",
      "error = 0.720042\n",
      "step 6500 training accuracy 1.0 \n",
      "error = 2.21224\n",
      "step 7000 training accuracy 1.0 \n",
      "error = 1.36932\n",
      "step 7500 training accuracy 1.0 \n",
      "error = 0.800758\n",
      "step 8000 training accuracy 1.0 \n",
      "error = 0.436314\n",
      "step 8500 training accuracy 1.0 \n",
      "error = 0.267335\n",
      "step 9000 training accuracy 1.0 \n",
      "error = 0.793557\n",
      "step 9500 training accuracy 1.0 \n",
      "error = 0.250941\n",
      "test accuracy 1\n"
     ]
    }
   ],
   "source": [
    "# x placeholder for input data\n",
    "x = tf.placeholder(tf.float32, [None, full_length])\n",
    "# y_ placeholder for labels\n",
    "y_ = tf.placeholder(tf.float32, [None, gradients])\n",
    "\n",
    "# set y_conv and keep_prob by running the deepnn function inputting x\n",
    "y_conv, keep_prob = deepnn(x)\n",
    "\n",
    "# work out error with cross etntropy\n",
    "cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))\n",
    "\n",
    "# set optimizer to AdamOptimizer\n",
    "train_step = tf.train.AdamOptimizer(learning_rate).minimize(cross_entropy)\n",
    "\n",
    "# return boolean whether on whether the prediction(s) are equal to the label(s)\n",
    "correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))\n",
    "\n",
    "# turns boolean into float to represent accuracy percentage\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction, dtype=tf.float32))\n",
    "\n",
    "# run session\n",
    "sess = tf.InteractiveSession(config=tf.ConfigProto(gpu_options=gpu_options))\n",
    "   \n",
    "# initialize variables\n",
    "sess.run(tf.global_variables_initializer())\n",
    "\n",
    "# training loop\n",
    "for i in range(iterations):\n",
    "\n",
    "    # select data for training and for accuracy testing\n",
    "    x_data, y_data = format_data(training_line_data, 'train')\n",
    "    \n",
    "    # this chooses the whole batch (since its very small) and later uses it for accuracy testing\n",
    "    x_acc_test = x_data.reshape(training_lines,-1)\n",
    "    y_acc_test = y_data.reshape(training_lines,-1)\n",
    "    \n",
    "    # this is the training data and it picks just one line in the whole data set\n",
    "    x_data = x_data[i%training_lines]\n",
    "    y_data = y_data[i%training_lines]\n",
    "\n",
    "    # print accuracy and error 20 times\n",
    "    if i % (iterations/20) == 0:\n",
    "        # set accuracy and error by running accuracy from before and error from cross entropy\n",
    "        train_accuracy = sess.run(accuracy, feed_dict={x:x_acc_test, y_: y_acc_test, keep_prob: 1.0})\n",
    "        error = sess.run(cross_entropy, feed_dict={x:x_data, y_: y_data, keep_prob: 1.0})\n",
    "        \n",
    "        # print accuracy and error\n",
    "        print 'step', i, 'training accuracy', train_accuracy,  '\\nerror =', error\n",
    "        \n",
    "    # run the training for  this iteration\n",
    "    train_step.run(feed_dict={x: x_data, y_: y_data, keep_prob: 0.5})\n",
    "    \n",
    "# once training is complete, test teh accuracy for the final time\n",
    "x_data, y_data = format_data(training_line_data, 'train')\n",
    "\n",
    "x_acc_test = x_data.reshape(training_lines,-1)\n",
    "y_acc_test = y_data.reshape(training_lines,-1)\n",
    "\n",
    "print(\"test accuracy %g\" % sess.run(accuracy, feed_dict={x: x_acc_test, y_: y_acc_test, keep_prob: 1.0}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input values, the max gradient is 25\n",
      "\n",
      "value 1 ?\n",
      "3\n",
      "\n",
      "value 2 ?\n",
      "21\n",
      "\n",
      "value 3 ?\n",
      "39\n",
      "\n",
      "value 4 ?\n",
      "57\n"
     ]
    }
   ],
   "source": [
    "# initialize array to record test values\n",
    "test_line = np.array([])\n",
    "\n",
    "print 'input values, the max gradient is', gradients-1\n",
    "# loop to ask user for input values\n",
    "for i in range(vals):\n",
    "    print '\\nvalue',i+1,'?'\n",
    "    val = int(input())\n",
    "    test_line = np.append(test_line, val)\n",
    "    \n",
    "# set test line to int32 and setlast value\n",
    "test_line = test_line.astype(np.int32)\n",
    "last_val = test_line[-1]\n",
    "\n",
    "# use format data function to set data to binary\n",
    "input_array = format_data(test_line, 0)\n",
    "#print input_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correct\n",
      "\n",
      "Learnt answer = 75\n",
      "Probaility of Gradient 18 = 4.40789\n",
      "\n",
      "\n",
      "[[ 0.14531893 -0.82333469 -1.98471999 -1.85672617 -1.88744891 -0.45970443\n",
      "  -0.73048437 -2.37755847 -2.8374784  -0.32539451 -0.61530614 -0.51234913\n",
      "   0.38969555 -1.44128692 -1.36958468 -0.78214884 -1.29325604  1.51862693\n",
      "   4.40788698  1.17572415 -0.96419382 -1.68351233 -1.61952364 -1.64203477\n",
      "  -1.90566289 -1.48043108]]\n"
     ]
    }
   ],
   "source": [
    "probs = sess.run(y_conv, feed_dict={x:input_array, keep_prob:1.})\n",
    "# now we have found the predicted gradient,\n",
    "# we add the last value to get the next value\n",
    "learnt_ans = np.argmax(probs)+last_val\n",
    "# \"true\" answer, should work with all linear lines\n",
    "# this numerically works out hte gradient by findingthe difference,\n",
    "# then also adds the last value\n",
    "answer = (test_line[1]-test_line[0])+last_val\n",
    "\n",
    "if answer == learnt_ans:\n",
    "    print 'Correct'\n",
    "    \n",
    "    # print learnt answer and it probability\n",
    "    print '\\nLearnt answer =', learnt_ans\n",
    "    print 'Probaility of Gradient', np.argmax(probs), '=', probs[0,learnt_ans-last_val]\n",
    "else:\n",
    "    print 'Wrong'\n",
    "    \n",
    "    # print learnt answer and it probability\n",
    "    print '\\nLearnt answer =', learnt_ans\n",
    "    print 'Probaility of Gradient', np.argmax(probs), '=', probs[0,learnt_ans-last_val]\n",
    "    \n",
    "    # print true answer and its probabilities\n",
    "    print '\\nNumerical answer =', answer\n",
    "    print 'Probability of Gradient', test_line[1]-test_line[0], '=', probs[0,answer-last_val]\n",
    "    \n",
    "\n",
    "# print the probabilities\n",
    "print '\\n\\n', probs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}