10by10-2L-100K.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:7f9e7ac602a08538efb332a799b77fcac86f0e4b8295232483cc6c659802f9ab"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import theanets\n",
      "import logging\n",
      "from sklearn.datasets import make_classification\n",
      "from sklearn.metrics import confusion_matrix\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",
      "from numpy import float32,int32\n",
      "from sklearn.cluster import KMeans\n",
      "import pickle\n",
      "\n",
      "\n",
      "nlayers = 4\n",
      "module_size=20 #cm\n",
      "module_cell = 10 #per edge\n",
      "distance_between_layers = 5 #cm\n",
      "ncells=module_cell*module_cell*nlayers\n",
      "nhidden=100\n",
      "nhidden_layers = 10\n",
      "layers = (ncells,) + tuple([nhidden for i in range(nhidden_layers)])\n",
      "#net = theanets.Regressor((ncells,ncells,ncells,ncells,ncells,ncells,ncells,ncells,ncells,ncells,ncells,(ncells,'logistic')))\n",
      "trainer = theanets.Experiment(theanets.feedforward.Regressor(layers=(ncells,(nhidden,'logistic'),(nhidden,'logistic'),(ncells,'logistic'))))\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",
      "spent = []\n",
      "list_error = []\n",
      "color_list = ['bo','yo','ro','co','mo','go','ko','wo']\n",
      "min_ntracks = 4\n",
      "max_ntracks = 4\n",
      "nsamples = 100000\n",
      "#nsamples = 2 * ncells * ncells * (nhidden_layers + 1)\n",
      "#print nsamples\n",
      "training_ratio = 0.9\n",
      "ds_input = np.zeros((nsamples,ncells),dtype = float32)\n",
      "ds_output = np.zeros((nsamples,ncells),dtype = float32)\n",
      "cut = int(nsamples * training_ratio)\n",
      "\n",
      "def addSample (sample_number = 1,sampleInput = np.zeros (ncells,dtype = float32),sampleOutput = np.zeros (ncells,dtype = float32)) :\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,dtype = float32)\n",
      "    sampleOutput = np.zeros (ncells,dtype = float32)\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,dtype = float32)\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",
      "def new_samples() :\n",
      "    ds_input = np.zeros((nsamples,ncells),dtype = float32)\n",
      "    ds_output = np.zeros((nsamples,ncells),dtype = float32)\n",
      "    for i in range (nsamples) :\n",
      "        sample_creater(i,False)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Couldn't import dot_parser, loading of dot files will not be possible.\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def clusterer (in_array,revised_number = 0) :\n",
      "    n_lines = len(in_array)\n",
      "    n_gaps = n_lines - 1\n",
      "    gap_matrix = np.zeros((n_gaps,3),dtype=float32)\n",
      "    length_array = np.zeros(n_gaps,dtype=float32)\n",
      "    for i in range (n_gaps) :\n",
      "        gap_matrix[i][2] = i\n",
      "        gap_matrix[i][0] = in_array[i+1] - in_array[i]\n",
      "        length_array[i] = in_array[i+1] - in_array[i]\n",
      "        gap_matrix[i][1] = (in_array[i+1] + in_array[i])/2.0\n",
      "    length_array = sorted(length_array)\n",
      "    gap_matrix.view('f32,f32,f32').sort(order=['f0'], axis=0)\n",
      "    out_matrix = np.zeros((int(n_lines),2),dtype=int32)\n",
      "    if revised_number == 0 :\n",
      "        col = np.reshape(length_array,(len(length_array),1))\n",
      "        algo = KMeans(n_clusters=2)\n",
      "        gap_candidates = algo.fit_predict(col)\n",
      "        if gap_candidates[0] == 0:\n",
      "            accepted = list(gap_candidates).count(1)\n",
      "        else :\n",
      "            accepted = list(gap_candidates).count(0)\n",
      "    else :\n",
      "        accepted = revised_number-1\n",
      "    for i in range (n_gaps-accepted) :\n",
      "        gap_matrix[i][1] = in_array[n_gaps]\n",
      "    gap_matrix.view('f32,f32,f32').sort(order=['f1'], axis=0)\n",
      "    if accepted == 0 :\n",
      "        out_matrix [0] = [0,n_gaps]\n",
      "        return accepted+1,out_matrix\n",
      "    out_matrix [0] = [0,gap_matrix[0][2]]\n",
      "    out_matrix [accepted] = [gap_matrix[accepted-1][2]+1,n_gaps]\n",
      "    for bunch in range (1,accepted) :\n",
      "        out_matrix [bunch] = [int(gap_matrix[bunch-1][2]+1),int(gap_matrix[bunch][2])]\n",
      "    return accepted+1,out_matrix\n",
      "\n",
      "def clustering (in_array) :\n",
      "    central_tracks ,_ = clusterer (in_array)\n",
      "    col = np.reshape(in_array,(len(in_array),1))\n",
      "    min_n = max(1,int((0.75*central_tracks)))\n",
      "    max_n = int(1.25*central_tracks)\n",
      "    if max_n <= min_n + 1 :\n",
      "        return clusterer (in_array,max_n)\n",
      "    goc = np.zeros(1+max_n-min_n)\n",
      "    for nclu in range(min_n ,max_n +1):\n",
      "        algo = KMeans(n_clusters=nclu)\n",
      "        track_candidates = algo.fit_predict(col)\n",
      "        track_candidate_values = [np.array(in_array)[np.where(track_candidates==n)] for n in range(nclu)]\n",
      "        goc[nclu - min_n] = algo.score(col)\n",
      "    d_goc = []\n",
      "    for i in range (max_n-min_n):\n",
      "        d_goc.append(goc[i+1] - goc[i])\n",
      "    col = np.reshape(d_goc,(len(d_goc),1))\n",
      "    algo = KMeans(n_clusters=2)\n",
      "    gap_candidates = algo.fit_predict(col)\n",
      "    if gap_candidates[0] == 0:\n",
      "        accepted = list(gap_candidates).count(1)\n",
      "    else :\n",
      "        accepted = list(gap_candidates).count(0)\n",
      "    revised_number = max_n-accepted\n",
      "    return clusterer (in_array,revised_number)\n",
      "def similarity (exptrack,nntrack) :\n",
      "    sim_counter = 0\n",
      "    for exphit in range (len(exptrack)) :\n",
      "        for nnhit in range (len(nntrack)) :\n",
      "            if exptrack[exphit] == nntrack[nnhit] :\n",
      "                sim_counter += 1\n",
      "    return sim_counter\n",
      "def got (exp,nn,cut = 0.1,requested_efficiency = 1) : # Dear reader, get ready for awful variable names and no comment !\n",
      "    goodTrack = 0\n",
      "    # creating MidPut\n",
      "    for i in range (len(nn)) :\n",
      "        if nn[i] < cut :\n",
      "            nn[i] = 0\n",
      "    exp_Output = np.array([[i,exp[i]] for i in range (len(exp)) if exp[i] != 0],dtype = float32)\n",
      "    nn_Output = np.array([[i,nn[i]] for i in range (len(nn)) if nn[i] != 0],dtype = float32)\n",
      "    exp_Output.view('f32,f32').sort(order=['f1'], axis=0)\n",
      "    nn_Output.view('f32,f32').sort(order=['f1'], axis=0)\n",
      "    n_exp,exp_matrix = clustering (exp_Output[:,1])\n",
      "    n_nn,nn_matrix = clustering (nn_Output[:,1])\n",
      "    expM = np.array([[exp_Output[i][0] for i in range (exp_matrix[track][0],exp_matrix[track][1]+1)] for track in range (n_exp)])\n",
      "    nnM = np.array([[nn_Output[i][0] for i in range (nn_matrix[track][0],nn_matrix[track][1]+1)] for track in range (n_nn)])\n",
      "    similarities = np.zeros(n_exp,dtype = float32)\n",
      "    # doesn't work quite well for efficiencies less than 1,I know the reason,but don't have time to fix it !\n",
      "    remained_NNtracks = np.array([i for i in range (len(nnM))])\n",
      "    for exptrack in range (n_exp) :\n",
      "        for nntrack in remained_NNtracks :\n",
      "            if similarity(expM[exptrack],nnM[nntrack]) >= requested_efficiency * len(expM[1]) :\n",
      "                goodTrack +=1\n",
      "                remained_NNtracks = np.array([remained_NNtracks[i] for i in range (len(remained_NNtracks)) if i != nntrack]) #like !\n",
      "        #similarities[exptrack] = max([similarity(expM[exptrack],nnM[nntrack]) for nntrack in range (len(nnM))])\n",
      "    for exptrack in range (n_exp) :\n",
      "        if similarities[exptrack] >= requested_efficiency * len(expM[1]) :\n",
      "            goodTrack +=1\n",
      "    return float(goodTrack)/len(expM)\n",
      "def max_finder (listt) :\n",
      "    m = 0\n",
      "    for i in range (len(listt)) :\n",
      "        if listt[i] > listt[m] :\n",
      "            m = i\n",
      "    return m\n",
      "def compare (out,learn,n = 4,m = 4,efficiency = 1) : # n is nlayers , m is ntracks\n",
      "    counter = 0\n",
      "    output = np.zeros(len(out) , dtype=float32)\n",
      "    Otracks = np.zeros((m,n),dtype = float32)\n",
      "    Ltracks = np.zeros((m,n),dtype = float32)\n",
      "    for i in range (len(out)) :\n",
      "        output[i] = out[i]\n",
      "    learned = learn\n",
      "    for track in range (m) :\n",
      "        for layer in range (n) :\n",
      "            start = int(float(layer) * len(output) / n)\n",
      "            end = int(float(layer+1) * len(output) / n)\n",
      "            subOutput = output[start:end]\n",
      "            subLearned = learned[start:end]\n",
      "            Otracks[track][layer] = max_finder(subOutput)+start\n",
      "            Ltracks[track][layer] = max_finder(subLearned)+start\n",
      "            output[max_finder(subOutput)+start] = 0\n",
      "            learned[max_finder(subLearned)+start] = 0\n",
      "    for track in range (m) :\n",
      "        if max([similarity(Otracks[track],Ltracks[i]) for i in range(m)]) >= efficiency * n :\n",
      "            counter += 1\n",
      "    return counter"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 2
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "new_samples()\n",
      "train = ds_input[:cut], ds_output[:cut]\n",
      "valid = ds_input[cut:], ds_output[cut:]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 3
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#trainer.load(\"network/10by10-2L-100K\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 46,
       "text": [
        "<theanets.feedforward.Regressor at 0x7f891650bd50>"
       ]
      }
     ],
     "prompt_number": 46
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# we try to create some training samples and train on them and then check the mean error in some testing samples\n",
      "# a function of iteration and train per iterations\n",
      "niter=1\n",
      "ntrain=1\n",
      "for i in range (1,niter+1) :\n",
      "    # training on training samples\n",
      "    for j in range (ntrain) :\n",
      "        start = time.mktime(time.gmtime())\n",
      "        print \"training started ... \"\n",
      "        epoch_counter = 0\n",
      "        LR = 1e-3\n",
      "        for trn, val in trainer.itertrain(train,valid,hidden_dropout=0.9, algo='rprop',learning_rate = LR,iteration_size = 100,batch_size=1333,validate_every = 1,patience=300,min_improvement = 0.0000001) :\n",
      "            #if trn['err'] < 0.2 and val['err'] < 0.2 :\n",
      "            print \"epoch \",epoch_counter+1\n",
      "            if epoch_counter%1 == 0 :\n",
      "                print \"training_error = \\t\",1000*trn['err']\n",
      "                print \"validation_error = \\t\",1000*val['err']\n",
      "            epoch_counter += 1\n",
      "            if epoch_counter == 80 :\n",
      "              LR = 1e-4\n",
      "            if epoch_counter == 160 :\n",
      "              break\n",
      "        print \"\\t training ended\"\n",
      "        stop = time.mktime (time.gmtime())\n",
      "        spent.append (stop - start)\n",
      "        print \"training time (seconds) \\t\" , stop - start"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "training started ... \n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 1\n",
        "training_error = \t51.2116292827\n",
        "validation_error = \t266.244140426\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 2\n",
        "training_error = \t16.8603530373\n",
        "validation_error = \t17.3513964431\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 3\n",
        "training_error = \t14.8324234431\n",
        "validation_error = \t15.8948369852\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 4\n",
        "training_error = \t12.9130657346\n",
        "validation_error = \t13.9015988576\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 5\n",
        "training_error = \t11.3345557355\n",
        "validation_error = \t12.0527114155\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 6\n",
        "training_error = \t10.2134604567\n",
        "validation_error = \t10.7671733423\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 7\n",
        "training_error = \t9.18317895976\n",
        "validation_error = \t9.72278545589\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 8\n",
        "training_error = \t8.28490660973\n",
        "validation_error = \t8.75703966349\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 9\n",
        "training_error = \t7.56189102962\n",
        "validation_error = \t7.95423254632\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 10\n",
        "training_error = \t6.97741842297\n",
        "validation_error = \t7.32818334214\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 11\n",
        "training_error = \t6.48166604756\n",
        "validation_error = \t6.79409610268\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 12\n",
        "training_error = \t6.05196824405\n",
        "validation_error = \t6.3452530533\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 13\n",
        "training_error = \t5.66051792447\n",
        "validation_error = \t5.94672079169\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 14\n",
        "training_error = \t5.301445693\n",
        "validation_error = \t5.58292981933\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 15\n",
        "training_error = \t4.97491327249\n",
        "validation_error = \t5.25185494944\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 16\n",
        "training_error = \t4.69134471154\n",
        "validation_error = \t4.95617121956\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 17\n",
        "training_error = \t4.42955935816\n",
        "validation_error = \t4.68498328431\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 18\n",
        "training_error = \t4.20940376112\n",
        "validation_error = \t4.45367865626\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 19\n",
        "training_error = \t4.0197440211\n",
        "validation_error = \t4.25639849466\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 20\n",
        "training_error = \t3.85284832322\n",
        "validation_error = \t4.08900791937\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 21\n",
        "training_error = \t3.7013811251\n",
        "validation_error = \t3.93180703566\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 22\n",
        "training_error = \t3.5808364385\n",
        "validation_error = \t3.80380634707\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 23\n",
        "training_error = \t3.47397285952\n",
        "validation_error = \t3.68643224383\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 24\n",
        "training_error = \t3.38413635469\n",
        "validation_error = \t3.59070934997\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 25\n",
        "training_error = \t3.30345884464\n",
        "validation_error = \t3.5053804111\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 26\n",
        "training_error = \t3.23945843131\n",
        "validation_error = \t3.43671985839\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 27\n",
        "training_error = \t3.17957016887\n",
        "validation_error = \t3.36830935807\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 28\n",
        "training_error = \t3.13434389037\n",
        "validation_error = \t3.32228035381\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 29\n",
        "training_error = \t3.08950727356\n",
        "validation_error = \t3.271162395\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 30\n",
        "training_error = \t3.05063923628\n",
        "validation_error = \t3.23145447513\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 31\n",
        "training_error = \t3.0097739956\n",
        "validation_error = \t3.1966973053\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 32\n",
        "training_error = \t2.98344773628\n",
        "validation_error = \t3.16743846136\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 33\n",
        "training_error = \t2.94868894316\n",
        "validation_error = \t3.13249991805\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 34\n",
        "training_error = \t2.92661615482\n",
        "validation_error = \t3.10660139368\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 35\n",
        "training_error = \t2.8976065822\n",
        "validation_error = \t3.07844392915\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 36\n",
        "training_error = \t2.87805141316\n",
        "validation_error = \t3.06147543365\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 37\n",
        "training_error = \t2.8590976761\n",
        "validation_error = \t3.03720374324\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 38\n",
        "training_error = \t2.83616480581\n",
        "validation_error = \t3.0178206262\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 39\n",
        "training_error = \t2.81805423167\n",
        "validation_error = \t2.99706243957\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 40\n",
        "training_error = \t2.80265310645\n",
        "validation_error = \t2.98129342437\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 41\n",
        "training_error = \t2.7820970856\n",
        "validation_error = \t2.96679933064\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 42\n",
        "training_error = \t2.77228462564\n",
        "validation_error = \t2.95248883823\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 43\n",
        "training_error = \t2.75587773908\n",
        "validation_error = \t2.93748308946\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 44\n",
        "training_error = \t2.74450641274\n",
        "validation_error = \t2.92806821567\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 45\n",
        "training_error = \t2.72628488651\n",
        "validation_error = \t2.91255183787\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 46\n",
        "training_error = \t2.72211040705\n",
        "validation_error = \t2.89972999335\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 47\n",
        "training_error = \t2.70692328661\n",
        "validation_error = \t2.88891276846\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 48\n",
        "training_error = \t2.69516555851\n",
        "validation_error = \t2.87925470379\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 49\n",
        "training_error = \t2.68753528448\n",
        "validation_error = \t2.86820746912\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 50\n",
        "training_error = \t2.67598439082\n",
        "validation_error = \t2.86107913235\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 51\n",
        "training_error = \t2.66671528596\n",
        "validation_error = \t2.84925518287\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 52\n",
        "training_error = \t2.6599972194\n",
        "validation_error = \t2.84134785484\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 53\n",
        "training_error = \t2.6511023975\n",
        "validation_error = \t2.8345467134\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 54\n",
        "training_error = \t2.64548292751\n",
        "validation_error = \t2.82653843018\n",
        "\t training ended"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "training time (seconds) \t1331.0\n"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "trainer.save(\"network/10by10-2L-100K\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 5
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "Predict = trainer.network.predict(valid[0])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "gots = np.zeros(5 , dtype=float32)\n",
      "start = time.mktime(time.gmtime())\n",
      "for i in range (200) :\n",
      "    n_goodTracks = int(4*got(ds_output[cut+i],Predict[i],0.1,1))\n",
      "    if n_goodTracks == 4 :\n",
      "        print i\n",
      "    gots[n_goodTracks] += 1\n",
      "stop = time.mktime (time.gmtime())\n",
      "spent.append (stop - start)\n",
      "print \"\\t\" , stop - start\n",
      "print \"gots :\\t\",gots\n",
      "print sum([i*gots[i] for i in range (5)])/(200*0.04)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\t33.0\n",
        "gots :\t[ 96.  93.  10.   1.   0.]\n",
        "14.5\n"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "counter = np.zeros(5 , dtype=float32)\n",
      "start = time.mktime(time.gmtime())\n",
      "for i in range (200) :\n",
      "    n_good_tracks = compare(ds_output[cut+i],Predict[i],4,4,1)\n",
      "    if n_good_tracks == 4 :\n",
      "        print i\n",
      "    counter[n_good_tracks] += 1\n",
      "stop = time.mktime (time.gmtime())\n",
      "spent.append (stop - start)\n",
      "print \"\\t\" , stop - start\n",
      "print \"A-error: \",counter\n",
      "print sum([i*counter[i] for i in range (5)])/(200*0.04)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\t1.0\n",
        "A-error:  [ 141.   46.   11.    2.    0.]\n",
        "9.25\n"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print ds_output[cut]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[ 0.    0.    0.    0.    0.    0.    0.    0.    0.    0.25  0.    0.75\n",
        "  0.5   1.    0.    0.    0.    0.    0.    0.    0.    0.    0.    0.    0.\n",
        "  0.    0.    0.    0.    0.    0.    0.    0.    0.    0.25  0.    0.75\n",
        "  0.5   0.    0.    0.    0.    0.    1.    0.    0.    0.    0.    0.    0.\n",
        "  0.    0.    0.    0.    0.25  0.    0.    0.    0.    0.    0.75  0.    0.\n",
        "  0.5   0.    0.    0.    0.    1.    0.    0.    0.    0.    0.    0.    0.\n",
        "  0.25  0.    0.    0.    0.75  0.    0.    0.    0.    0.    0.    0.    0.\n",
        "  0.    0.    0.    0.    0.5   1.    0.    0.    0.    0.    0.  ]\n"
       ]
      }
     ],
     "prompt_number": 49
    }
   ],
   "metadata": {}
  }
 ]
}