Saving Data Batch by Batch.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:583959332fc5a7d900467e1bfe555108b5e4dfecdf8c45b3f126d9ace5bef5a1"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import theanets\n",
      "import matplotlib.pyplot as plt\n",
      "import time\n",
      "import numpy as np\n",
      "from theanets.trainer import SupervisedPretrainer\n",
      "import math\n",
      "from random import uniform\n",
      "from math import cos,tan,sqrt\n",
      "import pickle\n",
      "from numpy import float32,int32\n",
      "dt = np.dtype(float32)\n",
      "#from sklearn.cluster import KMeans"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "nlayers = 4\n",
      "min_ntracks = 4\n",
      "max_ntracks = 4\n",
      "nsamples = 2000000\n",
      "BATCH_SIZE = 1000\n",
      "module_cell = 5 #per edge\n",
      "module_size=20 #cm\n",
      "distance_between_layers = 5 #cm\n",
      "ncells=module_cell*module_cell*nlayers\n",
      "maximum_hight = nlayers * distance_between_layers\n",
      "theta_max = math.atan(0.5 * module_size / maximum_hight)\n",
      "theta_min = -1 * theta_max\n",
      "y = []\n",
      "y.append(0)\n",
      "y_prime = []\n",
      "y_prime.append(0)\n",
      "z = []\n",
      "z.append(0)\n",
      "x = []\n",
      "x.append(0)\n",
      "for i in range (nlayers) :\n",
      "    y.append((i+1) * distance_between_layers)\n",
      "    y_prime.append((i+1) * distance_between_layers)\n",
      "    z.append(0)\n",
      "    x.append(0)\n",
      "color_list = ['bo','yo','ro','co','mo','go','ko','wo']\n",
      "ds_input = np.zeros((BATCH_SIZE,ncells),dt)\n",
      "ds_output = np.zeros((BATCH_SIZE,ncells),dt)\n",
      "\n",
      "def addSample (sample_number = 1,sampleInput = np.zeros (ncells,dt),sampleOutput = np.zeros (ncells,dt)) :\n",
      "    for i in range (ncells) :\n",
      "        ds_input[sample_number][i] = sampleInput[i]\n",
      "        ds_output[sample_number][i] = sampleOutput[i]\n",
      "    \n",
      "def sample_creater(sample_number = 1,display = False) :                  # creates a sample with a random number of tracks\n",
      "    sampleInput = np.zeros (ncells,dt)\n",
      "    sampleOutput = np.zeros (ncells,dt)\n",
      "    ntracks = int( uniform(min_ntracks, max_ntracks ) ) #should be a better model than flat\n",
      "    sample_matrix = [[0 for t in range(nlayers + 1)] for t in range(ntracks)]\n",
      "# first argument of each row is track's radius and the other \"nlayers\" ones are hit indices of that track\n",
      "# then we would be able to sort these hits by their radius\n",
      "    \n",
      "# theta is the angle between the circle plane and xy plane. we randomly choose two points in the second and 4th layer and then fit a circle through these two points and also the coordinate origin\n",
      "# as y is fixed for each layer and z can be derived easily by y*tan(theta) , to specify a point in a layer we only need x of it\n",
      "    track = 0\n",
      "    while track < ntracks :\n",
      "        theta = uniform (theta_min,theta_max)\n",
      "        x[2] = uniform (-1*module_size/2.0,module_size/2.0)\n",
      "        x[4] = uniform (-1*module_size/2.0,module_size/2.0)\n",
      "        for i in range (4) :\n",
      "            y_prime[i+1] = y[i+1] / cos(theta)\n",
      "            z[i+1] = y[i+1] * tan(theta)\n",
      "        # center point of our circle\n",
      "        x_c = 0.5 * (((x[2]**2 + y_prime[2]**2) * y_prime[4]/y_prime[2] ) - x[4]**2 - y_prime[4]**2 )/ (x[2] * y_prime[4]/y_prime[2] - x[4])\n",
      "        y_c = 0.5 * (x[2]**2 + y_prime[2]**2 - 2 * x[2] * x_c) / y_prime[2]\n",
      "        R = sqrt(x_c**2 + y_c**2)\n",
      "# y_prime is the y component when we place our coordinate on the circle plane and as the layers are parallel, it would be y/cos(theta) for each layer\n",
      "        if x[2] > 0.5 * x[4] :\n",
      "            x[1] = x_c + sqrt(R**2 - (y_prime[1] - y_c)**2)\n",
      "            x[3] = x_c + sqrt(R**2 - (y_prime[3] - y_c)**2)\n",
      "        else :\n",
      "            x[1] = x_c - sqrt(R**2 - (y_prime[1] - y_c)**2)\n",
      "            x[3] = x_c - sqrt(R**2 - (y_prime[3] - y_c)**2)\n",
      "        sample_matrix [track][0] = R\n",
      "        x_edge = (-1) * module_size / 2.0\n",
      "        z_edge = (-1) * module_size / 2.0\n",
      "        \n",
      "        track_hits = np.zeros(nlayers,dt)\n",
      "        no_good = False\n",
      "        for layer in range (1,nlayers+1) :\n",
      "            # local indices on the module\n",
      "            index_hit1 = int( (x[layer] - x_edge ) / module_size * module_cell )\n",
      "            index_hit2 = int( (z[layer] - z_edge ) / module_size * module_cell )\n",
      "            # transform into the global index\n",
      "            hit = module_cell**2 * (layer - 1) + index_hit2 * module_cell + index_hit1\n",
      "            track_hits[layer-1] = hit\n",
      "            if sampleInput[hit] == 1:\n",
      "                    #discard this track\n",
      "                    no_good = True\n",
      "        if no_good:\n",
      "            #print \"discarding an overlaping track\"\n",
      "            continue\n",
      "        else:\n",
      "            for (layer,hit) in enumerate(track_hits):\n",
      "                sampleInput[int(hit)] = 1\n",
      "                sample_matrix [track][layer+1] = int(hit)\n",
      "        if display:\n",
      "            for i in range (0,5) :\n",
      "                plt.figure(1)\n",
      "                plt.plot(x[i],y_prime[i],color_list[track])\n",
      "                axis([-module_size/2. + 1 , module_size/2. + 1, 0, maximum_hight/cos(theta) + 1])\n",
      "                plt.suptitle('x - y_prime (perpendicular view of the circle plane)')\n",
      "                plt.xlabel('x')\n",
      "                plt.ylabel('y_prime')\n",
      "                plt.figure(2)\n",
      "                plt.plot(x[i],z[i],color_list[track])\n",
      "                axis([-module_size/2. + 1, module_size/2. + 1,-module_size/2. + 1, module_size/2. + 1])\n",
      "                plt.suptitle('x - z')\n",
      "                plt.xlabel('x')\n",
      "                plt.ylabel('z')\n",
      "                plt.figure(3)\n",
      "                plt.plot(z[i],y[i],color_list[track])\n",
      "                axis([-module_size/2. + 1, module_size/2. + 1, 0, maximum_hight/cos(theta) + 1])\n",
      "                plt.suptitle('z - y')\n",
      "                plt.xlabel('z')\n",
      "                plt.ylabel('y')\n",
      "        track += 1\n",
      "    sample_matrix.sort(key=lambda x: x[0])\n",
      "    for i in range (ntracks) :\n",
      "        for j in range(1,nlayers+1) :\n",
      "            sampleOutput[sample_matrix[i][j]] = (i+1)/float(ntracks)\n",
      "    if display == False :\n",
      "        addSample(sample_number,sampleInput,sampleOutput)\n",
      "\n",
      "        \n",
      "def Add_Data(First_Batch = True) :\n",
      "    ds_input = np.zeros((BATCH_SIZE,ncells),dt)\n",
      "    ds_output = np.zeros((BATCH_SIZE,ncells),dt)\n",
      "    for i in range (BATCH_SIZE) :\n",
      "        sample_creater(i,False)\n",
      "    if First_Batch:\n",
      "        np.save('network/4Layers_5by5Cells-4Tracks_Input.npy', ds_input)\n",
      "        np.save('network/4Layers_5by5Cells-4Tracks_Output.npy', ds_output)\n",
      "    else:\n",
      "        np.save('network/XOR_Input.npy', np.concatenate((np.load('network/4Layers_5by5Cells-4Tracks_Input.npy', mmap_mode='r'),ds_input)))\n",
      "        np.save('network/XOR_Output.npy', np.concatenate((np.load('network/4Layers_5by5Cells-4Tracks_Output.npy', mmap_mode='r'),ds_output)))\n",
      "def Make_Data(dataset_size = nsamples):\n",
      "    nbatch = int(float(dataset_size)/BATCH_SIZE)\n",
      "    for batch in range (nbatch):\n",
      "        if batch == 0:\n",
      "            Add_Data(First_Batch = True)\n",
      "        else:\n",
      "            Add_Data(First_Batch = False)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "Make_Data()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}