keras_mle_bg_stn.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load packages\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import os\n",
    "import scipy as scp\n",
    "import scipy.stats as scps\n",
    "from scipy.optimize import differential_evolution\n",
    "from scipy.optimize import minimize\n",
    "from datetime import datetime\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.linear_model import LinearRegression\n",
    "\n",
    "# Load my own functions\n",
    "import dnnregressor_train_eval_keras as dnnk\n",
    "import make_data_wfpt as mdw\n",
    "from kde_training_utilities import kde_load_data\n",
    "import ddm_data_simulation as ddm_sim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.1.0'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Enable cuda\n",
    "os.environ['CUDA_VISIBLE_DEVICES'] = '2'\n",
    "scp.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.training.checkpointable.util.CheckpointLoadStatus at 0x7f1e02892208>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load Model\n",
    "model_path = os.getcwd() + '/keras_models/dnnregressor_kde_ddm_flexbnd_c1_c206_02_19_15_25_32/model_0' \n",
    "ckpt_path = os.getcwd() + '/keras_models/dnnregressor_kde_ddm_flexbound_05_03_19_20_15_59/ckpt_0_final'\n",
    "model = keras.models.load_model(model_path)\n",
    "model.load_weights(ckpt_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the likelihood function DDM\n",
    "def log_p_ddm(params = [0, 1, 0.9], model = [], data = [], my_columns = []):\n",
    "    feature_pd = pd.DataFrame(np.zeros((data[0].shape[0], len(my_columns))), columns = ['v', 'a', 'w', 'rt', 'choice'])\n",
    "    feature_pd['rt'] = data[0]\n",
    "    feature_pd['choice'] = data[1]\n",
    "    feature_pd['v'] = params[0]\n",
    "    feature_pd['a'] = params[1]\n",
    "    feature_pd['w'] = params[2]\n",
    "    prediction = model.predict(feature_pd)\n",
    "    prediction[prediction < 1e-29] = 1e-29\n",
    "    return(- np.sum(np.log(prediction)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the likelihood function DDM-FLEXBOUND\n",
    "def log_p_flexbound(params = [0, 1, 0.9], model = [], data = [], my_columns = []):\n",
    "    feature_pd = pd.DataFrame(np.zeros((data[0].shape[0], len(my_columns))), columns = my_columns)\n",
    "    feature_pd['rt'] = data[0]\n",
    "    feature_pd['choice'] = data[1]\n",
    "    feature_pd['v'] = params[0]\n",
    "    feature_pd['a'] = params[1]\n",
    "    feature_pd['w'] = params[2]\n",
    "    feature_pd['c1'] = params[3]\n",
    "    feature_pd['c2'] = params[4]\n",
    "    prediction = model.predict(feature_pd)\n",
    "    prediction[prediction < 1e-29] = 1e-29\n",
    "    return(- np.sum(np.log(prediction)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "ddm_model = 'flexbound'\n",
    "data_file = os.getcwd() + '/data_storage/michael_bg_nn_data/bg_stn_full.csv'\n",
    "data = pd.read_csv(data_file)\n",
    "files_ = np.unique(data['file'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_tmp = data.loc[data['file'] == files_[0],].copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3.14080390e-01 8.32063784e-01 4.99464862e-01 1.24795744e-04\n",
      " 1.16636605e+00]\n",
      "hiconf_go_stnhi.txt\n",
      "0\n",
      "[0.16694752 0.74377952 0.50098321 0.         1.17385442]\n",
      "hiconf_go_stnlo.txt\n",
      "1\n",
      "[3.76491698e-01 7.42336566e-01 4.99089751e-01 1.19320669e-04\n",
      " 1.23782273e+00]\n",
      "hiconf_go_stnmid.txt\n",
      "2\n",
      "[1.59282166 0.84817546 0.49901256 0.19183599 1.49640757]\n",
      "loconf7_go_stnhi.txt\n",
      "3\n",
      "[1.17293613 0.69468607 0.49912211 0.13622018 1.45112962]\n",
      "loconf7_go_stnlo.txt\n",
      "4\n",
      "[1.53621597 0.81027668 0.499      0.18202996 1.49884704]\n",
      "loconf7_go_stnmid.txt\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# Run MLE on real data\n",
    "ddm_model = 'flexbound'\n",
    "data_file = os.getcwd() + '/data_storage/michael_bg_nn_data/bg_stn_full.csv'\n",
    "data = pd.read_csv(data_file)\n",
    "files_ = np.unique(data['file'])\n",
    "\n",
    "# Initializations -----\n",
    "\n",
    "# Process parameters\n",
    "v_range = [-2, 2]\n",
    "a_range = [0.5, 3] # previous [1,2] # previous [2, 3]\n",
    "w_range = [0.499, 0.501]\n",
    "\n",
    "# Boundary parameters\n",
    "c1_range = [0, 5]\n",
    "c2_range = [0, 1.5]\n",
    "\n",
    "# Appropriate columns for input data frame\n",
    "columns = ['v', 'a', 'w', 'c1', 'c2', 'rt', 'choice']\n",
    "\n",
    "if ddm_model == 'ddm':\n",
    "    optim_results = pd.DataFrame(np.zeros((len(files_), 6)), columns = ['file',\n",
    "                                                                        'ndt',\n",
    "                                                                   'v_mle', \n",
    "                                                                   'a_mle', \n",
    "                                                                   'w_mle', \n",
    "                                                                   'n_samples'])\n",
    "\n",
    "if ddm_model == 'flexbound':\n",
    "    optim_results = pd.DataFrame(np.zeros((len(files_), 8)), columns = ['file',\n",
    "                                                                        'ndt',\n",
    "                                                                   'v_mle', \n",
    "                                                                   'a_mle', \n",
    "                                                                   'w_mle', \n",
    "                                                                   'c1_mle',\n",
    "                                                                   'c2_mle',\n",
    "                                                                   'n_samples'])\n",
    "    \n",
    "    # Define boundary function \n",
    "    def exp_c1_c2(t = 1, \n",
    "                  c1 = 1,\n",
    "                  c2 = 1):\n",
    "\n",
    "        b = np.exp(- c2*(t-c1))\n",
    "\n",
    "        if t >= c1:\n",
    "\n",
    "            return b\n",
    "\n",
    "        else:\n",
    "            return 1\n",
    "        \n",
    "    # Define appropriate range of parameters\n",
    "    c1_range = [0, 5]\n",
    "    c2_range = [0, 1.5]\n",
    "# ---------------------\n",
    "\n",
    "# Main loop ----------- TD: Parallelize\n",
    "cnt = 0\n",
    "for file_ in files_: \n",
    "    \n",
    "    data_tmp = data.loc[data['file'] == file_,].copy()\n",
    "    ndt = (min(data_tmp['avg_cycles'])) - 0.05 \n",
    "    data_tmp['avg_cycles'] = data_tmp['avg_cycles'] - ndt\n",
    "    data_feed_tmp = [data_tmp['avg_cycles'].values, data_tmp['cnt_err'].values]\n",
    "\n",
    "    # Sample parameters\n",
    "    v_sim = np.random.uniform(high = v_range[1], low = v_range[0])\n",
    "    a_sim = np.random.uniform(high = a_range[1], low = a_range[0])\n",
    "    w_sim = np.random.uniform(high = w_range[1], low = w_range[0])\n",
    "    \n",
    "    if ddm_model == 'ddm':\n",
    "        optim_results.iloc[cnt, 0] = file_\n",
    "        optim_results.iloc[cnt, 1] = ndt\n",
    "        optim_results.iloc[cnt, 5] = n_samples\n",
    "        \n",
    "    if ddm_model == 'flexbound':\n",
    "        c1_sim = np.random.uniform(high = c1_range[1], low = c1_range[0])\n",
    "        c2_sim = np.random.uniform(high = c2_range[1], low = c2_range[0])\n",
    "        \n",
    "        # Store in output file\n",
    "        optim_results.iloc[cnt, 0] = file_\n",
    "        optim_results.iloc[cnt, 1] = ndt\n",
    "        optim_results.iloc[cnt, 7] = data_tmp.shape[0]\n",
    "\n",
    "\n",
    "    # Run optimizer\n",
    "    if ddm_model == 'ddm':\n",
    "        out = differential_evolution(log_p_ddm, \n",
    "                                     bounds = [(v_range[0],v_range[1]), \n",
    "                                               (a_range[0], a_range[1]), \n",
    "                                               (w_range[0], w_range[1]),\n",
    "                                               (c1_range[0], c1_range[1]),\n",
    "                                               (c2_range[0], c2_range[1])], \n",
    "                                     args = (model, data_feed_tmp, columns), \n",
    "                                     popsize = 30)\n",
    "    \n",
    "    if ddm_model == 'flexbound':\n",
    "        out = differential_evolution(log_p_flexbound, \n",
    "                                     bounds = [(v_range[0],v_range[1]), \n",
    "                                               (a_range[0], a_range[1]), \n",
    "                                               (w_range[0], w_range[1]),\n",
    "                                               (c1_range[0], c1_range[1]),\n",
    "                                               (c2_range[0], c2_range[1])], \n",
    "                                     args = (model, data_feed_tmp, columns), \n",
    "                                     popsize = 30\n",
    "                                    )\n",
    "    \n",
    "    print(out.x)\n",
    "    \n",
    "    # Store result in output file\n",
    "    if ddm_model == 'ddm':\n",
    "        optim_results.iloc[cnt, 2:5] = out.x\n",
    "        \n",
    "    if ddm_model == 'flexbound':\n",
    "        optim_results.iloc[cnt, 2:7] = out.x\n",
    "    \n",
    "    #Print and update counter\n",
    "    print(file_)\n",
    "    print(cnt)\n",
    "    cnt += 1\n",
    "# -----------------------\n",
    "\n",
    "\n",
    "# Save optimization results to file\n",
    "optim_results.to_csv(os.getcwd() + '/experiments/ddm_flexbound_kde_bg_stn_full_ndt_minrt/optim_results_c1_c2_extended_params.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "optim_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0  datapoints sampled\n",
      "1000  datapoints sampled\n",
      "2000  datapoints sampled\n"
     ]
    }
   ],
   "source": [
    "# NEW DIAGNOSTIC GRAPHS HERE\n",
    "ddm_dat_tmp = ddm_sim.ddm_flexbound_simulate(v = optim_results.iloc[4, 2],\n",
    "                                             a = optim_results.iloc[4, 3],\n",
    "                                             w = optim_results.iloc[4, 4],\n",
    "                                             s = 1,\n",
    "                                             delta_t = 0.001,\n",
    "                                             max_t = 20,\n",
    "                                             n_samples = 3000,\n",
    "                                             boundary_fun = exp_c1_c2, # function of t (and potentially other parameters) that takes in (t, *args)\n",
    "                                             boundary_multiplicative = True,\n",
    "                                             boundary_params = {'c1': optim_results.iloc[4, 5], \n",
    "                                                                'c2': optim_results.iloc[4, 6]})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 5)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "dat_tmp = data.loc[data['file'] == optim_results.iloc[4, 0], ]\n",
    "plt.hist(dat_tmp['avg_cycles'] * dat_tmp['cnt_err'], bins = 30, color = 'green', density=True, alpha= 0.5)\n",
    "plt.ylim((0, 5))\n",
    "\n",
    "plt.hist((ddm_dat_tmp[0] + optim_results.iloc[4, 1]) * ddm_dat_tmp[1], bins = 30, color = 'blue', density = True, alpha = 0.5)\n",
    "plt.ylim((0, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "optim_results.iloc[3,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Boundary plots\n",
    "t_s = np.arange(0, 3, 0.01)\n",
    "boundary = np.zeros((len(t_s),2))\n",
    "colors = ['red', 'green', 'blue']\n",
    "a = optim_results.iloc[0,3]\n",
    "color_cnt = 0\n",
    "for c2 in optim_results.iloc[3:6,6]:\n",
    "    cnt = 0\n",
    "    for i in t_s:\n",
    "        b = a * exp_c1_c2(t = i, c1 = optim_results.iloc[0, 5], c2 = optim_results.iloc[0, 6])\n",
    "        if b <= 0:\n",
    "            boundary[cnt, 0] = 0\n",
    "            boundary[cnt, 1] = 0\n",
    "        else: \n",
    "            boundary[cnt, 0] = b\n",
    "            boundary[cnt, 1] = - boundary[cnt, 0]\n",
    "        cnt += 1\n",
    "\n",
    "    plt.plot(t_s, boundary[:, 0], color = colors[color_cnt])\n",
    "    plt.plot(t_s, boundary[:, 1], color = colors[color_cnt]) \n",
    "    color_cnt += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 5)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAAD8CAYAAABXe05zAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAACyhJREFUeJzt3V2MbXdZx/HfY4vUVCJvI9aWgERiQ0ykOqnGXllfUtAUXxNIVExqjlxoMDExGK70xuiFGhNjPKkNGBVQlIhEJYWWNCRSnIO89EWkIIk0lTMIIk1MtfB4cTZybGfOrNMze895Zj6fZGf2nr0yedbsmW/W/GetmeruADDHVx31AABcHOEGGEa4AYYRboBhhBtgGOEGGObKJRtV1SeTfCHJF5M83t3b6xwKgP0tCvfK93T3Z9Y2CQCLWCoBGKaWXDlZVf+S5HNJOskfdPfpPbY5leRUklx99dXfcf311x/yqADH15kzZz7T3VtLtl0a7mu7++Gq+vokdyb5he6+Z7/tt7e3e2dnZ/HAACddVZ1Z+vvDRUsl3f3w6u3ZJG9LcuNTHw+AS3FguKvq6qp6xpfvJ/mBJPetezAA9rbkrJLnJXlbVX15+z/t7r9b61QA7OvAcHf3J5J82wZmAWABpwMCDCPcAMMIN8Awwg0wjHADDCPcAMMIN8Awwg0wjHADDCPcAMMIN8Awwg0wjHADDCPcAMMIN8Awwg0wjHADDCPcAMMIN8Awwg0wjHADDCPcAMMIN8Awwg0wjHADDCPcAMMIN8Awwg0wjHADDCPcAMMIN8Awwg0wjHADDCPcAMMIN8Awi8NdVVdU1T9W1TvWORAAF3YxR9yvTfLgugYBYJlF4a6q65L8YJLb1zsOAAdZesT9O0l+OcmX9tugqk5V1U5V7ezu7h7KcAA82YHhrqofSnK2u89caLvuPt3d2929vbW1dWgDAvD/LTnivinJrVX1ySRvTnJzVf3xWqcCYF8Hhru7f6W7r+vuFyZ5ZZK7uvsn1z4ZAHtyHjfAMFdezMbd/Z4k71nLJAAs4ogbYBjhBhhGuAGGEW6AYYQbYBjhBhhGuAGGEW6AYYQbYBjhBhhGuAGGEW6AYYQbYBjhBhhGuAGGEW6AYYQbYBjhBhhGuAGGEW6AYYQbYBjhBhhGuAGGEW6AYYQbYBjhBhhGuAGGEW6AYYQbYBjhBhhGuAGGEW6AYYQbYBjhBhjmwHBX1VVV9f6q+lBV3V9Vv7qJwQDY25ULtnksyc3d/WhVPS3Je6vqb7v7fWueDYA9HBju7u4kj64ePm1163UOBcD+Fq1xV9UVVfXBJGeT3Nnd9+6xzamq2qmqnd3d3cOeE4CVReHu7i9290uTXJfkxqr61j22Od3d2929vbW1ddhzArByUWeVdPd/JLk7yS3rGQeAgyw5q2Srqp65uv81Sb4/yT+tezAA9rbkrJJrkryxqq7IudD/WXe/Y71jAbCfJWeVfDjJDRuYBYAFXDkJMIxwAwwj3ADDCDfAMMINMIxwAwwj3ADDCDfAMMINMIxwAwwj3ADDCDfAMMINMIxwAwwj3ADDLPlHCsBlqGrZdt3rnYPNc8QNMIxwAwwj3ADDCDfAMMINMIxwAwwj3ADDCDfAMMINMIxwAwwj3ADDCDfAMMINMIxwAwwj3ADDCDfAMMINMIxwAwwj3ADDHBjuqnp+Vd1dVQ9U1f1V9dpNDAbA3pb8s+DHk/xSd3+gqp6R5ExV3dndD6x5NgD2cOARd3c/0t0fWN3/QpIHk1y77sEA2NtFrXFX1QuT3JDk3j2eO1VVO1W1s7u7ezjTAfAki8NdVV+b5C+S/GJ3/+cTn+/u09293d3bW1tbhzkjAOdZFO6qelrORftPuvsv1zsSABey5KySSvKHSR7s7t9a/0gAXMiSI+6bkvxUkpur6oOr28vXPBcA+zjwdMDufm+S2sAsACzgykmAYYQbYBjhBhhGuAGGEW6AYYQbYBjhBhhGuAGGEW6AYYQbYBjhBhhGuAGGEW6AYYQbYJgl/+UdGKwW/lHm7vXOweFxxA0wjHADDCPcAMMIN8Awwg0wjLNKBnF2AJA44gYYR7gBhhFugGGEG2AY4QYYRrgBhhFugGGcxw2XmaXn63NyOeIGGEa4AYYRboBhhBtgGOEGGObAcFfVHVV1tqru28RAAFzYkiPuNyS5Zc1zALDQgeHu7nuSfHYDswCwwKGtcVfVqaraqaqd3d3dw/qwADzBoYW7u09393Z3b29tbR3Wh+UpqFp2A2ZyVgnAMMINMMyS0wHflOTvk3xLVX2qqm5b/1jApllim+PAvw7Y3a/axCAALGOpBGAY4QYYRrgBhhFugGGEG2AY/3PyMuAUK+BiOOIGGEa4AYYRboBhhBtgGOEGGEa4AYYRboBhhBtgGOEGGEa4AYYRboBhhBtgGH9kao388ShgHRxxAwwj3ADDWCoBLsrSJcDu9c5xkjniBhhGuAGGEW6AYaxxA2thLXx9HHEDDCPcAMNYKrlIroYEjppwA0fqYg6GrIefI9ywAX5S4zAJ98pJ/MbyW3+YyS8nAYY59kfcJ/FIGjjejn24gePD8t45i5ZKquqWqvpoVT1UVa9b91BLVC27ARw3B4a7qq5I8ntJXpbkJUleVVUvWfdgAE/VcT+wW3LEfWOSh7r7E93930nenOQV6xrouH/CgcvH1N4sWeO+Nsm/nvf4U0m+84kbVdWpJKdWDx+tqo9e+nhr89wknznqITbkkvf1cvzCvQCv7fF1ZPu7oe+BFyzd8NB+Odndp5OcPqyPt05VtdPd20c9xyacpH1NTtb+nqR9TU7e/l7IkqWSh5M8/7zH163eB8ARWBLuf0jy4qr6pqr66iSvTPL29Y4FwH4OXCrp7ser6ueTvDPJFUnu6O771z7Zeo1Y0jkkJ2lfk5O1vydpX5OTt7/7qj7uZ6oDHDP+VgnAMMINMMyJCHdV/URV3V9VX6qqfU8nuhwv7b9YVfXsqrqzqj62evusfbb7YlV9cHUb9cvmg16nqnp6Vb1l9fy9VfXCzU95eBbs789U1e55r+fPHsWch6Gq7qiqs1V13z7PV1X97upz8eGq+vZNz3g5OBHhTnJfkh9Ncs9+GxyjS/tfl+Td3f3iJO9ePd7Lf3X3S1e3Wzc33qVZ+DrdluRz3f3NSX47yW9sdsrDcxFfl2857/W8faNDHq43JLnlAs+/LMmLV7dTSX5/AzNddk5EuLv7we4+6ErOjV7av0avSPLG1f03JvnhI5xlHZa8Tud/Dt6a5Hurhl3/+RXH5etyke6+J8lnL7DJK5L8UZ/zviTPrKprNjPd5eNEhHuhvS7tv/aIZrkUz+vuR1b3/y3J8/bZ7qqq2qmq91XVpLgveZ3+b5vufjzJ55M8ZyPTHb6lX5c/tlo6eGtVPX+P54+L4/J9ekmOzd/jrqp3JfmGPZ56fXf/1abnWacL7ev5D7q7q2q/8z1f0N0PV9WLktxVVR/p7o8f9qxsxF8neVN3P1ZVP5dzP23cfMQzsUbHJtzd/X2X+CHGXNp/oX2tqk9X1TXd/cjqR8iz+3yMh1dvP1FV70lyQ5IJ4V7yOn15m09V1ZVJvi7Jv29mvEN34P529/n7dnuS39zAXEdlzPfpOlkq+Yrjcmn/25O8enX/1Ume9NNGVT2rqp6+uv/cJDcleWBjE16aJa/T+Z+DH09yV8+90uzA/X3CGu+tSR7c4Hyb9vYkP706u+S7knz+vKXBk6O7j/0tyY/k3FrYY0k+neSdq/d/Y5K/OW+7lyf555w78nz9Uc/9FPf1OTl3NsnHkrwrybNX799Ocvvq/ncn+UiSD63e3nbUc1/kPj7pdUrya0luXd2/KsmfJ3koyfuTvOioZ17z/v56kvtXr+fdSa4/6pkvYV/flOSRJP+z+p69Lclrkrxm9Xzl3Fk2H1997W4f9cxHcXPJO8AwlkoAhhFugGGEG2AY4QYYRrgBhhFugGGEG2CY/wUUyxPuCLJqdwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "dat_tmp = data.loc[data['file'] == optim_results.iloc[0, 0], ]\n",
    "plt.hist(dat_tmp['avg_cycles'] * dat_tmp['cnt_err'], bins = 30, color = 'blue', density=True)\n",
    "plt.ylim((0, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>file</th>\n",
       "      <th>ndt</th>\n",
       "      <th>v_mle</th>\n",
       "      <th>a_mle</th>\n",
       "      <th>w_mle</th>\n",
       "      <th>c1_mle</th>\n",
       "      <th>c2_mle</th>\n",
       "      <th>n_samples</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>hiconf_go_stnhi.txt</td>\n",
       "      <td>0.27</td>\n",
       "      <td>0.314080</td>\n",
       "      <td>0.832064</td>\n",
       "      <td>0.499465</td>\n",
       "      <td>0.000125</td>\n",
       "      <td>1.166366</td>\n",
       "      <td>5000.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>hiconf_go_stnlo.txt</td>\n",
       "      <td>0.18</td>\n",
       "      <td>0.166948</td>\n",
       "      <td>0.743780</td>\n",
       "      <td>0.500983</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.173854</td>\n",
       "      <td>5000.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>hiconf_go_stnmid.txt</td>\n",
       "      <td>0.24</td>\n",
       "      <td>0.376492</td>\n",
       "      <td>0.742337</td>\n",
       "      <td>0.499090</td>\n",
       "      <td>0.000119</td>\n",
       "      <td>1.237823</td>\n",
       "      <td>5000.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>loconf7_go_stnhi.txt</td>\n",
       "      <td>0.23</td>\n",
       "      <td>1.592822</td>\n",
       "      <td>0.848175</td>\n",
       "      <td>0.499013</td>\n",
       "      <td>0.191836</td>\n",
       "      <td>1.496408</td>\n",
       "      <td>5000.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>loconf7_go_stnlo.txt</td>\n",
       "      <td>0.20</td>\n",
       "      <td>1.172936</td>\n",
       "      <td>0.694686</td>\n",
       "      <td>0.499122</td>\n",
       "      <td>0.136220</td>\n",
       "      <td>1.451130</td>\n",
       "      <td>5000.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>loconf7_go_stnmid.txt</td>\n",
       "      <td>0.20</td>\n",
       "      <td>1.536216</td>\n",
       "      <td>0.810277</td>\n",
       "      <td>0.499000</td>\n",
       "      <td>0.182030</td>\n",
       "      <td>1.498847</td>\n",
       "      <td>5000.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    file   ndt     v_mle     a_mle     w_mle    c1_mle  \\\n",
       "0    hiconf_go_stnhi.txt  0.27  0.314080  0.832064  0.499465  0.000125   \n",
       "1    hiconf_go_stnlo.txt  0.18  0.166948  0.743780  0.500983  0.000000   \n",
       "2   hiconf_go_stnmid.txt  0.24  0.376492  0.742337  0.499090  0.000119   \n",
       "3   loconf7_go_stnhi.txt  0.23  1.592822  0.848175  0.499013  0.191836   \n",
       "4   loconf7_go_stnlo.txt  0.20  1.172936  0.694686  0.499122  0.136220   \n",
       "5  loconf7_go_stnmid.txt  0.20  1.536216  0.810277  0.499000  0.182030   \n",
       "\n",
       "     c2_mle  n_samples  \n",
       "0  1.166366     5000.0  \n",
       "1  1.173854     5000.0  \n",
       "2  1.237823     5000.0  \n",
       "3  1.496408     5000.0  \n",
       "4  1.451130     5000.0  \n",
       "5  1.498847     5000.0  "
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "optim_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tf",
   "language": "python",
   "name": "tf"
  },
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}