DataGeneration+Relu.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:4cbd5a42e1d741de7f3d970723659d634c882404a3ef5a0e2b90dedc877eb6e3"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math, string, random, itertools, copy\n",
      "import numpy as np\n",
      "from numpy import float32\n",
      "from math import sqrt\n",
      "import matplotlib.pyplot as plt\n",
      "from scipy.stats import poisson\n",
      "from copy        import deepcopy\n",
      "import time\n",
      "import theanets"
     ],
     "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": 2
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import h5py\n",
      "f=h5py.File(\"data/data2M.hdf5\")\n",
      "f.keys()\n",
      "f['data'].keys()\n",
      "input_matrix = f['data']['input'].value\n",
      "target_matrix = f['data']['target'].value\n",
      "decorator_matrix = f['data']['deco'].value\n",
      "f.close()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "maxJets  = 20\n",
      "nInputs  = maxJets * 4 + 2                    # Maximum number of Jets x 4-momentum + METx,y              \n",
      "nOutputs = 1                                  # Trigger Bit: 0 or 1  "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 2
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print 'MaxJets=',maxJets,'nInputs=',nInputs, 'nOutputs=',nOutputs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "MaxJets= 20 nInputs= 82 nOutputs= 1\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "nInputs  = input_matrix.shape[1]\n",
      "nOutputs = target_matrix.shape[1]\n",
      "print \"Samples in input_matrix=\", len(input_matrix), \"       Inputs=\", nInputs, \"       Outputs=\",nOutputs"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def allincluded(truncated, nHiddenLayers, nHiddenNeurons):\n",
      "\n",
      "    # Create Training & Validation Set\n",
      "    # ------------------------------------------------\n",
      "    IN_matrix     = input_matrix[0:truncate,...]      \n",
      "    TARGET_matrix = target_matrix[0:truncate,...]\n",
      "    DEC_matrix    = decorator_matrix[0:truncate,...] \n",
      "    \n",
      "    cut   =int(IN_matrix.shape[0]*0.8)\n",
      "    train =IN_matrix[:cut], TARGET_matrix[:cut]\n",
      "    valid =IN_matrix[cut:], TARGET_matrix[cut:]\n",
      "    \n",
      "    # Build the NN\n",
      "    # -----------------------------------------------------------------------------------------------------------------------------------\n",
      "    # Topology: Feedforward\n",
      "    # Inputs = 82 (Jets 4-momenta (20 Jets maximum), METx, METy)\n",
      "    # Number of Hidden Layers = nHiddenLayers\n",
      "    # Activation function for Hidden Layers = RELU\n",
      "    # Outputs=1 (NN Trigger Bits= 0 or 1)\n",
      "    # Activation function for the Output Layer= RELU\n",
      "\n",
      "    exp=theanets.Experiment(theanets.feedforward.Regressor(layers=(nInputs,)+tuple([nHiddenNeurons for l in range(nHiddenLayers)])+ ( (nOutputs),)))  \n",
      "    # ------------------------------------------------------------------------------------------------------------------------------------\n",
      "    fom   = 1.0\n",
      "    LearningRate=0.001\n",
      "    Epochs= 0\n",
      "    \n",
      "    timing_start = time.mktime(time.gmtime())\n",
      "    \n",
      "    for TrainError, ValError in exp.itertrain(train,valid, learning_rate= LearningRate, algo='rprop', \n",
      "                                              hidden_dropout=0.9, iteration_size = 400, batch_size=1000, \n",
      "                                              validate_every = 1, patience=300, min_improvement = 0.0000001,\n",
      "                                              rms_halflife=0.995, rms_regularizer=1e-09):\n",
      "        print 'Epoch=', Epochs+1\n",
      "        if Epochs%1 == 0 :\n",
      "            print 'Training   Error = \\t',TrainError['err']\n",
      "            print 'Validation Error = \\t',ValError['err']\n",
      "        Epochs+=1\n",
      "        if Epochs == 30 :\n",
      "            break   \n",
      "    timing_end=time.mktime(time.gmtime())\n",
      "    \n",
      "    prediction = exp.network.predict(train[0])\n",
      "    goodness = np.asarray([[cut,(list(train[1][np.where(prediction>cut)]==1).count(True)+list(train[1][np.where(prediction<cut)]==0).count(True))/ float(train[0].shape[0])]  for cut in np.arange(0,1,0.05)])   \n",
      "    fom_train = max( goodness[:,1])    \n",
      "    \n",
      "    prediction = exp.network.predict(valid[0])\n",
      "    goodness   = np.asarray([[cut,(list(valid[1][np.where(prediction>cut)]==1).count(True)+list(valid[1][np.where(prediction<cut)]==0).count(True))/ float(valid[0].shape[0])]  for cut in np.arange(0,1,0.05)])\n",
      "    fom_valid  = max( goodness[:,1])     \n",
      "\n",
      "    MaxCut= goodness[np.where(goodness[:,1]==goodness[:,1].max())][0][0]\n",
      "\n",
      "    timing=timing_end-timing_start\n",
      "    \n",
      "    exp.save('network-pickle.pkl.gz')\n",
      "    \n",
      "    return fom_valid, fom_train, MaxCut,timing"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "mapAlgo=[]\n",
      "\n",
      "for iLayers in range(1,11):\n",
      "    print \"--------------------- iLayers = \",iLayers, \"--------------------------------------\"\n",
      "    for nHiddenNeurons in range(800, 2000, 200):\n",
      "        print \"   Hidden Neurons=\", nHiddenNeurons\n",
      "        for truncate in range(800000,1800000,200000):\n",
      "            print \"   Samples=\",truncate\n",
      "            fom_valid, fom_train, MaxCut, timing = allincluded(truncate, iLayers, nHiddenNeurons)\n",
      "            mapAlgo.append((truncate, iLayers, nHiddenNeurons, timing, fom_valid, fom_train, MaxCut))\n",
      "            print  \"   F.O.M. valid=\",fom_valid, \"FOM train=\", fom_train, \"  Time=\", timing, ' MaxCut=',MaxCut "
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print mapAlgo"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}