10by10-1L-2000N400K.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:fa126fc4622cb7d4e865816d770b2b0a819f84dcaaadd099136eb2681979e526"
 },
 "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=2000\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,'relu'),(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 = 4000\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-1L-2000N400K\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 4,
       "text": [
        "<theanets.feedforward.Regressor at 0x7f1072c5a310>"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "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 = 400,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 == 20 :\n",
      "              LR = 1e-4\n",
      "            if epoch_counter == 40 :\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 = \t6.31390283119\n",
        "validation_error = \t302.678963778\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 2\n",
        "training_error = \t1.1434338234\n",
        "validation_error = \t1.28943403196\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 3\n",
        "training_error = \t1.03567368448\n",
        "validation_error = \t1.08204735774\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 4\n",
        "training_error = \t0.999948546271\n",
        "validation_error = \t1.034454069\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 5\n",
        "training_error = \t0.97362006869\n",
        "validation_error = \t1.00915179943\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 6\n",
        "training_error = \t0.956436559317\n",
        "validation_error = \t0.99509208863\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 7\n",
        "training_error = \t0.940402743772\n",
        "validation_error = \t0.98012414095\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 8\n",
        "training_error = \t0.93141718514\n",
        "validation_error = \t0.973114502728\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 9\n",
        "training_error = \t0.920838524995\n",
        "validation_error = \t0.963342409699\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 10\n",
        "training_error = \t0.917509623367\n",
        "validation_error = \t0.960840672605\n",
        "epoch "
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " 11\n",
        "training_error = \t0.915382019141\n",
        "validation_error = \t0.960372380772\n",
        "\t training ended"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "training time (seconds) \t8561.0\n"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#trainer.save(\"network/10by10-1L-2000N400K\")"
     ],
     "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": 5
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "gots = np.zeros(5 , dtype=float32)\n",
      "start = time.mktime(time.gmtime())\n",
      "for i in range (400) :\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": [
        "13\n",
        "20"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "31"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "32"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "64"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "79"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "105"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "127"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "139"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "143"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "148"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "150"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "152"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "162"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "173"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "176"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "191"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "204"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "212"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "217"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "224"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "230"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "231"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "266"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "283"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "284"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "290"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "297"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "300"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "305"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "322"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "342"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "357"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "370"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "392"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "396"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "\t"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100.0\n",
        "gots :\t[  30.  107.  125.  102.   36.]\n",
        "100.875\n"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "counter = np.zeros(5 , dtype=float32)\n",
      "start = time.mktime(time.gmtime())\n",
      "for i in range (400) :\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": [
        "4\n",
        "6\n",
        "7\n",
        "10\n",
        "17"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "26"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "27\n",
        "29\n",
        "30\n",
        "38"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "43\n",
        "44\n",
        "46"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "56"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "60\n",
        "65"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "66\n",
        "77"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "80\n",
        "87"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "89\n",
        "102"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "110"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "111\n",
        "113\n",
        "117"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "118\n",
        "127"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "128\n",
        "137"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "142\n",
        "149"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "161"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "164\n",
        "169"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "178"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "180\n",
        "181\n",
        "184"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "187\n",
        "189\n",
        "197"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "200\n",
        "201\n",
        "202\n",
        "204\n",
        "208"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "212\n",
        "225"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "226\n",
        "230\n",
        "235\n",
        "236"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "241\n",
        "254"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "255\n",
        "257\n",
        "258\n",
        "264\n",
        "266"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "267\n",
        "274\n",
        "276"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "277\n",
        "284\n",
        "287"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "292\n",
        "297\n",
        "302"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "303\n",
        "312"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "317\n",
        "321\n",
        "322\n",
        "324"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "327\n",
        "329\n",
        "330\n",
        "331\n",
        "335"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "339\n",
        "349"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "351\n",
        "352\n",
        "353\n",
        "355\n",
        "356\n",
        "357\n",
        "366"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "367\n",
        "371\n",
        "377"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "387"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "389\n",
        "\t2.0\n",
        "A-error:  [  69.   74.  162.    1.   94.]\n",
        "97.125\n"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}