pycuda-stack-gp-1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "%pylab inline \n",
    "\n",
    "import numpy as np\n",
    "import numpy\n",
    "import pandas as pd\n",
    "import re\n",
    "import random as rnd\n",
    "from sklearn.metrics import accuracy_score\n",
    "import math\n",
    "import operator\n",
    "from tqdm import tqdm_notebook as tqdm\n",
    "import random\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pycuda.driver as cuda\n",
    "import pycuda.autoinit\n",
    "from pycuda.compiler import SourceModule"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(891, 8)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# read the arrays\n",
    "a = [float(x) for x in open('titanic_cpp_x_old.txt').read().split()]\n",
    "cols = int(a[0])\n",
    "bdx = array(a[1:]).reshape(-1, cols)\n",
    "bdx.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(418, 8)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [float(x) for x in open('titanic_cpp_test_x_old.txt').read().split()]\n",
    "cols = int(a[0])\n",
    "bdx_test = array(a[1:]).reshape(-1, cols)\n",
    "bdx_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(891,)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bdy = array([float(x) for x in open('titanic_cpp_y.txt').read().split()])\n",
    "bdy.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(418,)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bdy_test = array([float(x) for x in open('titanic_cpp_test_y.txt').read().split()])\n",
    "bdy_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(891, 8)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bdx.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# data organization\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_insts = 19"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_rows = 1024\n",
    "num_features = bdx.shape[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_threads_x = 16384\n",
    "num_threads_y = num_rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "prog_len = 16\n",
    "gprogs = np.zeros((1, prog_len*num_threads_x), dtype=np.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2. The data is a single array of 8 features, many rows, and each thread on the Y axis takes an individual row\n",
    "gdata = np.zeros((num_rows, num_features), dtype=np.float32)\n",
    "gdatay = np.zeros((num_rows, 1), dtype=np.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3. The results - for each thread, single column of results\n",
    "gresult = np.zeros((num_rows, 1*num_threads_x), dtype=np.float32)\n",
    "gscores = np.zeros((1, 1*num_threads_x), dtype=np.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Allocate the buffers in GPU memory\n",
    "gprogs_gpu = cuda.mem_alloc(gprogs.nbytes)\n",
    "\n",
    "gdata_gpu = cuda.mem_alloc(gdata.nbytes)\n",
    "gdatay_gpu = cuda.mem_alloc(gdatay.nbytes)\n",
    "gresult_gpu = cuda.mem_alloc(gresult.nbytes)\n",
    "gscores_gpu = cuda.mem_alloc(gscores.nbytes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The GP kernel\n",
    "mod = SourceModule(\"\"\"\n",
    "\n",
    "#define PROGLEN %d\n",
    "#define NUM_FEATURES %d\n",
    "#define NUM_THREADS_X %d\n",
    "\n",
    "#define NOP 0\n",
    "#define PUSHV 1\n",
    "#define PUSHC 2\n",
    "#define ADD 3\n",
    "#define MUL 4\n",
    "#define DIV 5\n",
    "#define NEG 6\n",
    "#define MIN 7\n",
    "#define MAX 8\n",
    "#define GREATER 9\n",
    "#define LESS 10\n",
    "#define EQUAL 11\n",
    "#define SIN 12\n",
    "#define COS 13\n",
    "#define EXP 14\n",
    "#define LOG 15\n",
    "#define SQR 16\n",
    "#define SQRT 17\n",
    "#define TANH 18\n",
    "\n",
    "  __global__ void compute(int num_real_rows, float *gprogs, float *gdata, float *gresult)\n",
    "  {\n",
    "  \n",
    "    int prog_idx = (blockIdx.x * blockDim.x + threadIdx.x) * PROGLEN;\n",
    "    int data_row_idx = (blockIdx.y * blockDim.y + threadIdx.y) * NUM_FEATURES;\n",
    "    \n",
    "    int th_y = blockIdx.y * blockDim.y + threadIdx.y;\n",
    "    int th_x = blockIdx.x * blockDim.x + threadIdx.x;\n",
    " \n",
    "    int result_idx = NUM_THREADS_X * th_y + th_x; \n",
    "    \n",
    "    if (th_y >= num_real_rows)\n",
    "        return; // don't compute where there's no data\n",
    "        \n",
    "    float stack[PROGLEN+4]; // a little bigger just in case\n",
    "    \n",
    "    int sp = 0;\n",
    "    \n",
    "    // push a 0 to the stack\n",
    "    stack[sp] = 0;\n",
    "    sp++;\n",
    "    \n",
    "    float x = 0;\n",
    "    float y = 0;\n",
    "    \n",
    "    float inst = 0;\n",
    "    float operand = 0;\n",
    "    \n",
    "    /////////////////////////////////\n",
    "    // Evaluate program on data row\n",
    "    float* start_idx = (gprogs + prog_idx);\n",
    "    \n",
    "    for(int ip=0; ip<(PROGLEN*2); ip += 2)\n",
    "    {\n",
    "        // fetch instruction and operand\n",
    "        inst = *(start_idx + ip);\n",
    "        operand = *(start_idx + ip + 1);\n",
    "        \n",
    "        // execute instruction\n",
    "        if (inst == NOP)\n",
    "            continue; \n",
    "        \n",
    "        if (inst == PUSHV)\n",
    "        {\n",
    "            // fetch variable from data\n",
    "            x = *(gdata + data_row_idx + (int)(operand));\n",
    "            \n",
    "            // push to stack\n",
    "            stack[sp] = x;\n",
    "            sp++;\n",
    "        }\n",
    "        \n",
    "        if (inst == PUSHC)\n",
    "        {\n",
    "            // push constant to stack\n",
    "            stack[sp] = operand;\n",
    "            sp++;\n",
    "        }\n",
    "        \n",
    "        // math/logic instructions go below\n",
    "        if ((inst == ADD) && (sp >= 2))\n",
    "        {\n",
    "            // pop two values from stack\n",
    "            x = stack[sp];\n",
    "            sp--;\n",
    "            y = stack[sp];\n",
    "            sp--;\n",
    "            \n",
    "            // push result to stack\n",
    "            stack[sp] = x + y;\n",
    "            sp++;\n",
    "        }\n",
    "    \n",
    "        if ((inst == MUL) && (sp >= 2))\n",
    "        {\n",
    "            // pop two values from stack\n",
    "            x = stack[sp];\n",
    "            sp--;\n",
    "            y = stack[sp];\n",
    "            sp--;\n",
    "            \n",
    "            // push result to stack\n",
    "            stack[sp] = x * y;\n",
    "            sp++;\n",
    "        }\n",
    "\n",
    "        if ((inst == DIV) && (sp >= 2))\n",
    "        {\n",
    "            // pop two values from stack\n",
    "            x = stack[sp];\n",
    "            sp--;\n",
    "            y = stack[sp];\n",
    "            sp--;\n",
    "            \n",
    "            // push result to stack\n",
    "            stack[sp] = x / y;\n",
    "            sp++;\n",
    "        }\n",
    "\n",
    "        if ((inst == NEG) && (sp >= 1))\n",
    "        {\n",
    "            /*\n",
    "            // pop one value from stack\n",
    "            x = stack[sp];\n",
    "            sp--;\n",
    "            \n",
    "            // push result to stack\n",
    "            stack[sp] = -x;\n",
    "            sp++;*/\n",
    "            \n",
    "            stack[sp] = -stack[sp];\n",
    "        }\n",
    "        \n",
    "        if ((inst == MIN) && (sp >= 2))\n",
    "        {\n",
    "            // pop two values from stack\n",
    "            x = stack[sp];\n",
    "            sp--;\n",
    "            y = stack[sp];\n",
    "            sp--;\n",
    "            \n",
    "            // push result to stack\n",
    "            stack[sp] = (x > y)?y:x;\n",
    "            sp++;\n",
    "        }\n",
    "\n",
    "        if ((inst == MAX) && (sp >= 2))\n",
    "        {\n",
    "            // pop two values from stack\n",
    "            x = stack[sp];\n",
    "            sp--;\n",
    "            y = stack[sp];\n",
    "            sp--;\n",
    "            \n",
    "            // push result to stack\n",
    "            stack[sp] = (x > y)?x:y;\n",
    "            sp++;\n",
    "        }\n",
    "\n",
    "        if ((inst == GREATER) && (sp >= 2))\n",
    "        {\n",
    "            // pop two values from stack\n",
    "            x = stack[sp];\n",
    "            sp--;\n",
    "            y = stack[sp];\n",
    "            sp--;\n",
    "            \n",
    "            // push result to stack\n",
    "            stack[sp] = (float)(x > y);\n",
    "            sp++;\n",
    "        }\n",
    "\n",
    "        if ((inst == LESS) && (sp >= 2))\n",
    "        {\n",
    "            // pop two values from stack\n",
    "            x = stack[sp];\n",
    "            sp--;\n",
    "            y = stack[sp];\n",
    "            sp--;\n",
    "            \n",
    "            // push result to stack\n",
    "            stack[sp] = (float)(x < y);\n",
    "            sp++;\n",
    "        }\n",
    "\n",
    "        if ((inst == EQUAL) && (sp >= 2))\n",
    "        {\n",
    "            // pop two values from stack\n",
    "            x = stack[sp];\n",
    "            sp--;\n",
    "            y = stack[sp];\n",
    "            sp--;\n",
    "            \n",
    "            // push result to stack\n",
    "            stack[sp] = (float)(x == y);\n",
    "            sp++;\n",
    "        }\n",
    "        \n",
    "        if ((inst == SIN) && (sp >= 1))\n",
    "        {\n",
    "            stack[sp] = sin(stack[sp]);\n",
    "        }\n",
    "\n",
    "        if ((inst == COS) && (sp >= 1))\n",
    "        {\n",
    "            stack[sp] = cos(stack[sp]);\n",
    "        }\n",
    "\n",
    "        if ((inst == EXP) && (sp >= 1))\n",
    "        {\n",
    "            stack[sp] = exp(stack[sp]);\n",
    "        }\n",
    "\n",
    "        if ((inst == LOG) && (sp >= 1))\n",
    "        {\n",
    "            stack[sp] = log(stack[sp]);\n",
    "        }\n",
    "\n",
    "        if ((inst == SQR) && (sp >= 1))\n",
    "        {\n",
    "            stack[sp] = stack[sp]*stack[sp];\n",
    "        }\n",
    "\n",
    "        if ((inst == SQRT) && (sp >= 1))\n",
    "        {\n",
    "            stack[sp] = sqrt(stack[sp]);\n",
    "        }\n",
    "\n",
    "        if ((inst == TANH) && (sp >= 1))\n",
    "        {\n",
    "            stack[sp] = tanh(stack[sp]);\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    // store result\n",
    "    float f = 1/(1+exp(-stack[sp]));\n",
    "    if (f > 0.5) \n",
    "    {\n",
    "        f = 1.0;\n",
    "    }\n",
    "    else \n",
    "    {\n",
    "        f = 0.0;\n",
    "    }\n",
    "    gresult[result_idx] = f;    \n",
    "  }\n",
    "  \"\"\" % (prog_len, num_features, num_threads_x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "func = mod.get_function(\"compute\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "modsc = SourceModule(\"\"\"\n",
    "\n",
    "#define NUM_THREADS_X %d\n",
    "\n",
    "  __global__ void scores(int num_real_rows, float *gdatay, float *gresult, float *gscores)\n",
    "  {\n",
    "      int th_x = blockIdx.x * blockDim.x + threadIdx.x;\n",
    "      float sum = 0;\n",
    "      \n",
    "      for(int i=0; i<num_real_rows; i++)\n",
    "      {\n",
    "          float y1 = gdatay[i];\n",
    "          float y2 = *(gresult + i*NUM_THREADS_X + th_x);\n",
    "          if (y1 == y2)\n",
    "          {\n",
    "              sum ++;\n",
    "          }\n",
    "      }\n",
    "      \n",
    "      sum /= num_real_rows;\n",
    "      gscores[th_x] = sum;\n",
    "  }\n",
    "  \"\"\" % (num_threads_x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "funcsc = modsc.get_function(\"scores\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "gdata[0 : bdx.shape[0], :] = bdx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "gdatay[0 : bdx.shape[0], :] = bdy.reshape(-1, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this will hold the result\n",
    "gresult = np.zeros((num_rows, 1*num_threads_x), dtype=np.float32)\n",
    "gresult, gresult.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this will hold the scores\n",
    "gscores = np.zeros((1, 1*num_threads_x), dtype=np.float32)\n",
    "gscores, gscores.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# copy arrays to GPU\n",
    "cuda.memcpy_htod(gprogs_gpu, gprogs)\n",
    "\n",
    "cuda.memcpy_htod(gdata_gpu, gdata)\n",
    "cuda.memcpy_htod(gdatay_gpu, gdatay)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "threads_per_block = 16\n",
    "blocks_x = num_threads_x // threads_per_block\n",
    "blocks_y = num_threads_y // threads_per_block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_real_rows = np.array(bdx.shape).astype(np.int32)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# execute kernel\n",
    "func(num_real_rows, gprogs_gpu, gdata_gpu, gresult_gpu, \n",
    "     block=(threads_per_block, threads_per_block, 1), grid=(blocks_x, blocks_y, 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute the scores now\n",
    "funcsc(num_real_rows, gdatay_gpu, gresult_gpu, gscores_gpu, \n",
    "     block=(threads_per_block, 1, 1), grid=(blocks_x, 1, 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get back the data and display it\n",
    "cuda.memcpy_dtoh(gscores, gscores_gpu)\n",
    "gscores.reshape(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sort the arrays by score\n",
    "hs_idx = np.argsort(gscores.reshape(-1))[::-1]\n",
    "gprogs = gprogs[hs_idx]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# choose parent indices\n",
    "pr_idx = np.random.randint(0, int(len(hs_idx)*0.2), size=(len(hs_idx),))\n",
    "pr_idx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# replace pop with the new individuals, but flatten them\n",
    "gprogs = gprogs[pr_idx].reshape(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mutate the pop randomly\n",
    "numtomut = int( len(pr_idx)*0.3 )\n",
    "mt_idx = np.random.randint(0, numtomut, size=(numtomut,))\n",
    "\n",
    "gprogs[mt_idx] = np.random.randint(0, num_insts, size=(numtomut,)).astype(dtype=np.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gprogs = gprogs.reshape(len(hs_idx),-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gprogs = np.zeros((num_threads_x, prog_len), dtype=np.float32)\n",
    "inst_idx = np.arange(0, prog_len, 2)\n",
    "gprogs[:,inst_idx] = np.random.randint(0, num_insts, size=(num_threads_x, prog_len//2))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %%timeit \n",
    "\n",
    "# gresult = np.zeros((num_rows, 1*num_threads_x), dtype=np.float32)\n",
    "\n",
    "# cuda.memcpy_htod(gops_gpu, gops)\n",
    "# cuda.memcpy_htod(gvars_gpu, gvars)\n",
    "# cuda.memcpy_htod(gconsts_gpu, gconsts)\n",
    "# cuda.memcpy_htod(gis_var_gpu, gis_var)\n",
    "# cuda.memcpy_htod(gdata_gpu, gdata)\n",
    "\n",
    "# func(num_real_rows, gops_gpu, gvars_gpu, gconsts_gpu, gis_var_gpu, gdata_gpu, gresult_gpu, \n",
    "#      block=(threads_per_block, threads_per_block, 1), grid=(blocks_x, blocks_y, 1))\n",
    "\n",
    "# funcsc(num_real_rows, gdatay_gpu, gresult_gpu, gscores_gpu, \n",
    "#      block=(threads_per_block, 1, 1), grid=(blocks_x, 1, 1))\n",
    "\n",
    "# cuda.memcpy_dtoh(gscores, gscores_gpu)\n",
    "\n",
    "# # new generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hist(gscores.reshape(-1), 50);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cuda.memcpy_htod(gdata_gpu, gdata)\n",
    "cuda.memcpy_htod(gdatay_gpu, gdatay)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initial random population \n",
    "\n",
    "gprogs = np.zeros((num_threads_x, prog_len), dtype=np.float32)\n",
    "inst_idx = np.arange(0, prog_len, 2)\n",
    "gprogs[:,inst_idx] = np.random.randint(0, num_insts, size=(num_threads_x, prog_len//2))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "best_ever = 0\n",
    "for i in tqdm(range(10000000)):\n",
    "    \n",
    "    #cuda.memcpy_htod(gprogs_gpu, gprogs)\n",
    "\n",
    "    func(num_real_rows, gprogs_gpu, gdata_gpu, gresult_gpu, \n",
    "         block=(threads_per_block, threads_per_block, 1), grid=(blocks_x, blocks_y, 1))\n",
    "    \n",
    "    funcsc(num_real_rows, gdatay_gpu, gresult_gpu, gscores_gpu, \n",
    "     block=(threads_per_block, 1, 1), grid=(blocks_x, 1, 1))\n",
    "\n",
    "    cuda.memcpy_dtoh(gscores, gscores_gpu)\n",
    "    accs = gscores.reshape(-1)\n",
    "    best = np.max(accs)\n",
    "    if best > best_ever:\n",
    "        best_ever = best\n",
    "        print('new best', best)\n",
    "        \n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}