Current Carlos Work.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 id=\"tocheading\">TABLE OF CONTENTS</h1>\n",
    "<div id=\"toc\"></div>\n",
    "\n",
    "**Updates to the table of contents are periodic, but run the cell below to first start or force an update.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "$.getScript('make_table_of_contents.js')\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "macro javascript_str(s) display(\"text/javascript\", s); end\n",
    "\n",
    "javascript\"\"\"\n",
    "$.getScript('make_table_of_contents.js')\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "465.6204011011422"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 * 65*(1.06)^10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(328864.6156185423, 19932.967738432024)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = 1200*12\n",
    "s = 55000\n",
    "for y=1:11\n",
    "    s = s*1.05 + c\n",
    "    c = c*1.03\n",
    "end\n",
    "for y=1:0\n",
    "    s = s*1.05 + c# - 125000\n",
    "    c = c*1.03\n",
    "end\n",
    "(s, c)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Optimizing the C17 farms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#@include_me  optimizing_C17.jl\n",
    "\n",
    "\n",
    "include(\"pro_anti.jl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#@include_me  optimizing_C17.jl\n",
    "\n",
    "mypars = Dict(\n",
    ":init_add               =>          0,\n",
    ":const_add              =>          0,\n",
    ":noise                  =>          Any[],\n",
    ":input                  =>          0,\n",
    ":start_anti             =>          [-0.5, -0.5, -0.5, -0.5],\n",
    ":start_pro              =>          [-0.5, -0.5, -0.5, -0.5],\n",
    ":rule_and_delay_period  =>          1.2,\n",
    ":rule_and_delay_periods =>          [1.2],\n",
    ":target_period          =>          0.3,\n",
    ":target_periods         =>          [0.3],\n",
    ":post_target_period     =>          0.3,\n",
    ":post_target_periods    =>          [0.3],\n",
    ":anti_rule_strength     =>          0.054,\n",
    ":U_rest                 =>          0,\n",
    ":theta                  =>          0.05,\n",
    ":beta                   =>          0.5,\n",
    ":g_leak                 =>          1,\n",
    ":nsteps                 =>          301,\n",
    ":dt                     =>          0.024,\n",
    ":tau                    =>          0.09,\n",
    ":right_light_excitation =>          0.49924152955481954,\n",
    ":opto_strength          =>          0.85,\n",
    ":opto_periods           =>          String[\n",
    "                                    \"trial_start\" \"trial_start\"; \n",
    "                                    \"trial_start\" \"trial_end\"; \n",
    "                                    \"trial_start\" \"target_start/2\"; \n",
    "                                    \"target_start/2\" \"target_start\"; \n",
    "                                    \"target_start\" \"target_end\"],\n",
    ":opto_targets          =>           [\n",
    "                                    0.9 0.7; \n",
    "                                    0.9 0.5; \n",
    "                                    0.9 0.7; \n",
    "                                    0.9 0.5; \n",
    "                                    0.9 0.7],\n",
    ":theta2 => 0.15,\n",
    ":theta1 => 0.05,\n",
    ":sigma => 0.01,\n",
    ":cbeta => 0.04,\n",
    ":sW => 0.6416875048295452,\n",
    ":hW => 0.054701836208134846,\n",
    ":dW => 0.1267124266934907,\n",
    ":vW => -1.588850577499782,\n",
    ":constant_excitation => -0.37242520737694207,\n",
    ":const_pro_bias => 0.04366897857834884,\n",
    ":target_period_excitation => 0.15315254453690974,\n",
    ":right_light_pro_extra => 0,\n",
    ":pro_rule_strength => 0.05,\n",
    ":nPro => 200,\n",
    ":nAnti => 200,\n",
    ")\n",
    "\n",
    "\n",
    "extra_pars = Dict(\n",
    ":plot_list        =>   [], \n",
    ":plot_conditions  =>   true,\n",
    ":verbose          =>   true,\n",
    ":opto_periods     =>   String[\"trial_start\" \"trial_start-0.1\"],\n",
    ":opto_targets     =>   [0.9,  0.7],\n",
    ":opto_times       =>   [\"trial_start\", \"trial_start-0.1\"],       # This one is for run_ntrials\n",
    ":cbeta            =>   0.001,\n",
    ":search_range     =>   1.2,\n",
    ")\n",
    "\n",
    "search_conditions = Dict(   # :param    default_start   search_box  bound_box\n",
    ":vW     =>                   [mypars[:vW],                       [-0.5, 0.5],  [-5,   5]], \n",
    ":hW     =>                   [mypars[:hW],                       [-0.5, 0.5],  [-5,   5]],\n",
    ":dW     =>                   [mypars[:dW],                       [-0.5, 0.5],  [-5,   5]],\n",
    ":sW     =>                   [mypars[:sW],                       [0,    0.5],  [-5,   5]],\n",
    ":sigma  =>                   [0.11,                              [0.1,  0.2],  [-2,   2]],\n",
    ":constant_excitation      => [mypars[:constant_excitation],      [-1,     1],  [-30, 30]], \n",
    ":target_period_excitation => [mypars[:target_period_excitation], [0.001,0.5],  [-30  30]],\n",
    ":right_light_excitation   => [mypars[:right_light_excitation],   [0.05, 0.5],  [-30, 30]],\n",
    ":const_pro_bias           => [mypars[:const_pro_bias],           [-0.5, 0.5],  [-30, 30]],\n",
    ":opto_strength            => [mypars[:opto_strength],            [0,      1],  [0,    1]],\n",
    ":pro_rule_strength        => [mypars[:pro_rule_strength],        [0,   0.2,],  [0,   30]],\n",
    ":anti_rule_strength       => [mypars[:anti_rule_strength],       [0,   0.2,],  [0,   30]],\n",
    ")\n",
    "\n",
    "\n",
    "bbox = Dict()\n",
    "for k in keys(search_conditions)\n",
    "    bbox = merge(bbox, Dict(k=>search_conditions[k][3]))\n",
    "end\n",
    "bbox\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#@include_me  optimizing_C17.jl\n",
    "\n",
    "README = \"\"\"\n",
    "Attempt to optimize the C17 farms, starting from all ending points that had\n",
    "test costs <= 0.\n",
    "\"\"\"\n",
    "\n",
    "if ~isnull(tryparse(Int64, ARGS[1])); my_run_number = parse(Int64, ARGS[1]); \n",
    "else                                  my_run_number = 1; \n",
    "end\n",
    "if ~isnull(tryparse(Int64, ARGS[2])); tot_n_runs    = parse(Int64, ARGS[2]); \n",
    "else                                  tot_n_runs = 1; \n",
    "end\n",
    "\n",
    "source_dir = \"MiniFarms\"\n",
    "optim_dir  = \"Optimized_C17_Farms\"\n",
    "cost_threshold = 0   # only work with test costs less than this\n",
    "\n",
    "if ~isdir(optim_dir); mkdir(optim_dir); end\n",
    "\n",
    "\n",
    "f = readdir(source_dir)\n",
    "nloops = 0\n",
    "\n",
    "while my_run_number + (nloops*tot_n_runs) <= length(f)\n",
    "    myfile = f[my_run_number + (nloops*tot_n_runs)]\n",
    "    @printf(\"\\n\\n*** %d %s: grabbing file %s ***\\n\\n\", my_run_number, \n",
    "        Dates.format(now(), \"e, dd u yyyy HH:MM:SS\"), myfile)\n",
    "    mypars, extra_pars, args, seed, test_cost = load(source_dir * \"/\" * myfile, \n",
    "        \"mypars\", \"extra_pars\", \"args\", \"pars3\", \"cost\")\n",
    "\n",
    "    if test_cost <= 0\n",
    "        mypars[:nPro]  = 1600\n",
    "        mypars[:nAnti] = 1600\n",
    "\n",
    "        maxiter1 = 1000;   # for func1, the regular search\n",
    "        testruns = 10000;  # Number of trials for evaluating the results of the model. 10000 is a good number \n",
    "\n",
    "        func1 =  (;params...) -> JJ(mypars[:nPro], mypars[:nAnti]; verbose=false, \n",
    "            merge(merge(mypars, extra_pars), Dict(params))...)[1]\n",
    "\n",
    "        try\n",
    "            pars3, traj3, cost3, cpm_traj3, ftraj3 = bbox_Hessian_keyword_minimization(seed, \n",
    "                args, bbox, func1, \n",
    "                start_eta = 0.01, tol=1e-12, \n",
    "                verbose=true, verbose_every=1, maxiter=maxiter1)\n",
    "\n",
    "            # evaluate the result with many trials, for accuracy\n",
    "            cost, cost1s, cost2s, hP, hA, dP, dA, hBP, hBA = JJ(testruns, testruns; verbose=false, \n",
    "                make_dict(args, pars3, merge(merge(mypars, extra_pars)))...)\n",
    "\n",
    "            # Write out the results\n",
    "            myfilename = optim_dir * \"/\" * myfile\n",
    "\n",
    "            @printf(\"\\n\\n ****** writing to file %s *******\\n\\n\", myfilename)\n",
    "\n",
    "            # write file\n",
    "            save(myfilename, Dict(\"README\"=>README, \"nPro\"=>mypars[:nPro], \"nAnti\"=>mypars[:nAnti], \n",
    "                \"mypars\"=>mypars, \"extra_pars\"=>extra_pars, \"args\"=>args, \"seed\"=>seed, \n",
    "                \"pars3\"=>pars3, \"traj3\"=>traj3, \"cost3\"=>cost3, \"cpm_traj3\"=>cpm_traj3, \"ftraj3\"=>ftraj3,\n",
    "                \"cost\"=>cost, \"cost1s\"=>cost1s, \"cost2s\"=>cost2s,\n",
    "                \"hP\"=>hP, \"hA\"=>hA, \"dP\"=>dP, \"dA\"=>dA, \"hBP\"=>hBP, \"hBA\"=>hBA))\n",
    "\n",
    "        catch y\n",
    "            # Interrupts should not get caught:\n",
    "            if isa(y, InterruptException); throw(InterruptException()); end\n",
    "\n",
    "            # Other errors get caught and a warning is issued but then we run again\n",
    "            @printf(\"\\n\\nWhoopsety, unkown error!\\n\\n\");\n",
    "            @printf(\"Error was :\\n\"); print(y); @printf(\"\\n\\nTrying new random seed.\\n\\n\")\n",
    "        end\n",
    "    end\n",
    "    \n",
    "    nloops += 1\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "G[\"extra_pars\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# An attempt at opto after reduced_farm.jl\n",
    "\n",
    "No pre-search yet, but might add it after"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#@include_me  opto_reduced.jl\n",
    "\n",
    "\n",
    "include(\"pro_anti.jl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#@include_me  opto_reduced.jl\n",
    "\n",
    "mypars = Dict(\n",
    ":init_add               =>          0,\n",
    ":const_add              =>          0,\n",
    ":noise                  =>          Any[],\n",
    ":input                  =>          0,\n",
    ":start_anti             =>          [-0.5, -0.5, -0.5, -0.5],\n",
    ":start_pro              =>          [-0.5, -0.5, -0.5, -0.5],\n",
    ":rule_and_delay_period  =>          1.2,\n",
    ":rule_and_delay_periods =>          [1.2],\n",
    ":target_period          =>          0.3,\n",
    ":target_periods         =>          [0.3],\n",
    ":post_target_period     =>          0.3,\n",
    ":post_target_periods    =>          [0.3],\n",
    ":anti_rule_strength     =>          0.054,\n",
    ":U_rest                 =>          0,\n",
    ":theta                  =>          0.05,\n",
    ":beta                   =>          0.5,\n",
    ":g_leak                 =>          1,\n",
    ":nsteps                 =>          301,\n",
    ":dt                     =>          0.024,\n",
    ":tau                    =>          0.09,\n",
    ":right_light_excitation =>          0.49924152955481954,\n",
    ":opto_strength          =>          0.85,\n",
    ":opto_periods           =>          String[\n",
    "                                    \"trial_start\" \"trial_start\"; \n",
    "                                    \"trial_start\" \"trial_end\"; \n",
    "                                    \"trial_start\" \"target_start/2\"; \n",
    "                                    \"target_start/2\" \"target_start\"; \n",
    "                                    \"target_start\" \"target_end\"],\n",
    ":opto_targets          =>           [\n",
    "                                    0.9 0.7; \n",
    "                                    0.9 0.5; \n",
    "                                    0.9 0.7; \n",
    "                                    0.9 0.5; \n",
    "                                    0.9 0.7],\n",
    ":theta2 => 0.15,\n",
    ":theta1 => 0.05,\n",
    ":sigma => 0.01,\n",
    ":cbeta => 0.04,\n",
    ":sW => 0.6416875048295452,\n",
    ":hW => 0.054701836208134846,\n",
    ":dW => 0.1267124266934907,\n",
    ":vW => -1.588850577499782,\n",
    ":constant_excitation => -0.37242520737694207,\n",
    ":const_pro_bias => 0.04366897857834884,\n",
    ":target_period_excitation => 0.15315254453690974,\n",
    ":right_light_pro_extra => 0,\n",
    ":pro_rule_strength => 0.05,\n",
    ":nPro => 200,\n",
    ":nAnti => 200,\n",
    ")\n",
    "\n",
    "\n",
    "extra_pars = Dict(\n",
    ":plot_list        =>   [], \n",
    ":plot_conditions  =>   true,\n",
    ":verbose          =>   true,\n",
    ":opto_periods     =>   String[\"trial_start\" \"trial_start-0.1\"],\n",
    ":opto_targets     =>   [0.9,  0.7],\n",
    ":opto_times       =>   [\"trial_start\", \"trial_start-0.1\"],       # This one is for run_ntrials\n",
    ":cbeta            =>   0.001,\n",
    ":search_range     =>   1.2,\n",
    ")\n",
    "\n",
    "\n",
    "search_conditions = Dict(   # :param    default_start   search_box  bound_box\n",
    ":vW     =>                   [mypars[:vW],                       [-0.5, 0.5],  [-5,   5]], \n",
    ":hW     =>                   [mypars[:hW],                       [-0.5, 0.5],  [-5,   5]],\n",
    ":dW     =>                   [mypars[:dW],                       [-0.5, 0.5],  [-5,   5]],\n",
    ":sW     =>                   [mypars[:sW],                       [0,    0.5],  [-5,   5]],\n",
    ":sigma  =>                   [0.11,                              [0.1,  0.2],  [-2,   2]],\n",
    ":constant_excitation      => [mypars[:constant_excitation],      [-1,     1],  [-30, 30]], \n",
    ":target_period_excitation => [mypars[:target_period_excitation], [0.001,0.5],  [-30  30]],\n",
    ":right_light_excitation   => [mypars[:right_light_excitation],   [0.05, 0.5],  [-30, 30]],\n",
    ":const_pro_bias           => [mypars[:const_pro_bias],           [-0.5, 0.5],  [-30, 30]],\n",
    ":opto_strength            => [mypars[:opto_strength],            [0,      1],  [0,    1]],\n",
    ":pro_rule_strength        => [mypars[:pro_rule_strength],        [0,   0.2,],  [0,   30]],\n",
    ":anti_rule_strength       => [mypars[:anti_rule_strength],       [0,   0.2,],  [0,   30]],\n",
    ")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#@include_me  opto_reduced.jl\n",
    "\n",
    "extra_pars[:seedrand] = Int64(round(1000*time()))   \n",
    "srand(extra_pars[:seedrand])\n",
    "search_range = extra_pars[:search_range]; \n",
    "\n",
    "README = \"\"\"\n",
    "\n",
    "Farm C17: Like C16, with opto_strength and pro_rule_stregth and anti_rule_strength as \n",
    "trainable parameters, but with reasonable bounds on the appropriate parameters,\n",
    "not no bounds at all.\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "extra_pars[:opto_periods]  = String[\n",
    "    \"trial_start-0.1\"     \"trial_start-0.2\" ; \n",
    "    \"target_start-0.4\"    \"target_start\" ; \n",
    "    \"target_start+0.016\"  \"target_end\" ; \n",
    "]\n",
    "\n",
    "extra_pars[:opto_targets] = [\n",
    "    0.9   0.7  ;\n",
    "    0.85  0.5  ;\n",
    "    0.9   0.7  ;\n",
    "]\n",
    "\n",
    "ftraj2 = []; cost2 = [];\n",
    "\n",
    "if !isdir(\"../NewFarms\"); mkdir(\"../NewFarms\"); end\n",
    "fbasename = \"../NewFarms/farm_C17_\"\n",
    "# If we wanted a unique identifier per processor run the following line would help:\n",
    "# if ~isnull(tryparse(Int64, ARGS[1])); fbasename = fbasename * ARGS[1] * \"_\"; end\n",
    "\n",
    "@printf(\"\\n\\n\\nStarting with random seed %d\\n\\n\\n\", extra_pars[:seedrand])\n",
    "\n",
    "while true\n",
    "    \n",
    "    @printf(\"\\n\\n--- new run ---\\n\\n\")\n",
    "    args = []; seed = []; bbox = Dict()\n",
    "    for k in keys(search_conditions)\n",
    "        search_box = search_conditions[k][2]\n",
    "        args = [args; String(k)]\n",
    "        # --- search within the indicated search range:\n",
    "        myseed = search_conditions[k][1] + search_range*(rand()-0.5)*diff(search_box); myseed = myseed[1]\n",
    "        if myseed > search_box[2]; myseed = search_box[2]; end\n",
    "        if myseed < search_box[1]; myseed = search_box[1]; end\n",
    "        seed = [seed ;  myseed]\n",
    "        # --- No search, just start at the indicated position:\n",
    "        # seed = [seed ; search_conditions[k][1]]\n",
    "        # --- search within the full indicated search box\n",
    "        # seed = [seed ; rand()*diff(search_box) + search_box[1]]\n",
    "        bbox = merge(bbox, Dict(k => Array{Float64}(search_conditions[k][3])))\n",
    "    end\n",
    "    args = Array{String}(args)\n",
    "    seed = Array{Float64}(seed)\n",
    "\n",
    "\n",
    "    maxiter1 = 1000;   # for func1, the regular search\n",
    "    testruns = 10000;  # Number of trials for evaluating the results of the model. 10000 is a good number \n",
    "\n",
    "\n",
    "    # Make sure to keep the noise frozen over the search, meaning JJ() needs the seedrand parameter\n",
    "    func1 =  (;params...) -> JJ(mypars[:nPro], mypars[:nAnti]; verbose=false, \n",
    "        merge(merge(mypars, extra_pars), Dict(params))...)[1]\n",
    "    \n",
    "    try\n",
    "        pars3, traj3, cost3, cpm_traj3, ftraj3 = bbox_Hessian_keyword_minimization(seed, \n",
    "            args, bbox, func1, \n",
    "            start_eta = 0.01, tol=1e-12, \n",
    "            verbose=true, verbose_every=1, maxiter=maxiter1)\n",
    "            \n",
    "        # evaluate the result with many trials, for accuracy\n",
    "        cost, cost1s, cost2s, hP, hA, dP, dA, hBP, hBA = JJ(testruns, testruns; verbose=false, \n",
    "            make_dict(args, pars3, merge(merge(mypars, extra_pars)))...)\n",
    "        \n",
    "        # Write out the results\n",
    "        myfilename = next_file(fbasename, 4)\n",
    "        myfilename = myfilename*\".jld\"\n",
    "\n",
    "        @printf(\"\\n\\n ****** writing to file %s *******\\n\\n\", myfilename)\n",
    "        \n",
    "        # write file\n",
    "        save(myfilename, Dict(\"README\"=>README, \"nPro\"=>mypars[:nPro], \"nAnti\"=>mypars[:nAnti], \n",
    "            \"mypars\"=>mypars, \"extra_pars\"=>extra_pars, \"args\"=>args, \"seed\"=>seed, \"bbox\"=>bbox, \n",
    "            \"search_conditions\"=>search_conditions,\n",
    "            \"pars3\"=>pars3, \"traj3\"=>traj3, \"cost3\"=>cost3, \"cpm_traj3\"=>cpm_traj3, \"ftraj3\"=>ftraj3,\n",
    "            \"cost\"=>cost, \"cost1s\"=>cost1s, \"cost2s\"=>cost2s,\n",
    "            \"hP\"=>hP, \"hA\"=>hA, \"dP\"=>dP, \"dA\"=>dA, \"hBP\"=>hBP, \"hBA\"=>hBA))\n",
    "\n",
    "    catch y\n",
    "        # Interrupts should not get caught:\n",
    "        if isa(y, InterruptException); throw(InterruptException()); end\n",
    "\n",
    "        # Other errors get caught and a warning is issued but then we run again\n",
    "        @printf(\"\\n\\nWhoopsety, unkown error!\\n\\n\");\n",
    "        @printf(\"Error was :\\n\"); print(y); @printf(\"\\n\\nTrying new random seed.\\n\\n\")\n",
    "    end\n",
    "\n",
    "    # Change random seed before next iteration so we don't get stuck in one loop\n",
    "    extra_pars[:seedrand] = extra_pars[:seedrand]+1\n",
    "end\n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analyzing runs from reduced_farm.jl : analyze_reduced_farm.jl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#@include_me  analyze_reduced_farm.jl\n",
    "\n",
    "include(\"pro_anti.jl\")\n",
    "\n",
    "#\n",
    "#  We're assuming that results of reduced_farm.jl were already generated.\n",
    "#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#@include_me  analyze_reduced_farm.jl\n",
    "\n",
    "\"\"\"\n",
    "hBP, hBA, d = function show_run(run_name, ntrials=100; farmdir=\"FarmFields\", further_pars...)\n",
    "\n",
    "Given a string representing the filename of a run generated in reduced_farm.jl\n",
    "(for example, \"farm_C3_0027.jld\"), tries to load that file from within \"FarmFields/\"\n",
    "runs it to plot 30 Pro trials in figure 1 and 30 Anti trials in figure 2,\n",
    "and indicates in those figures the corresponding number of binarized hits.\n",
    "\n",
    "Any further parameters override the contents of the farm and are passed on to \n",
    "run_ntrials(), so for example you can set rule_and_delay_period=0.2\n",
    "\n",
    "# RETURNS:\n",
    "\n",
    "- hBP, hBA   binarized Pro % hit and Anti % hit\n",
    "\n",
    "- d          the raw dictionary obtained from first loading the file.\n",
    "\n",
    "\"\"\"\n",
    "function show_run(run_name, ntrials=100; farmdir=\"FarmFields\", further_pars...)\n",
    "\n",
    "    pygui(true)\n",
    "    figure(1); clf();\n",
    "    figure(2); clf();\n",
    "\n",
    "    if endswith(farmdir, \"/\"); farmdir=farmdir[1:end-1]; end;\n",
    "    \n",
    "    if endswith(run_name, \".jld\")\n",
    "        d = load(farmdir * \"/\" * run_name)\n",
    "\n",
    "        extra_pars = d[\"extra_pars\"]\n",
    "        mypars     = d[\"mypars\"]\n",
    "        args       = d[\"args\"]\n",
    "        pars       = d[\"pars\"]\n",
    "    elseif endswith(run_name, \".mat\")                                \n",
    "        d = matread(farmdir * \"/\" * run_name)\n",
    "        \n",
    "        extra_pars = Dict()\n",
    "        mypars     = symbol_key_ize(d[\"model_params\"])\n",
    "        args       = d[\"args\"]\n",
    "        pars       = d[\"pars\"]\n",
    "    else\n",
    "        error(\"Whoa, I only know how to load .mat and .jld files\")\n",
    "    end\n",
    "\n",
    "    delete!(extra_pars, :plot_list)   # we want our own plot_list\n",
    "    delete!(extra_pars, :seedrand)    # don't use the farm's seedrand. (Could change this if wanted)\n",
    "\n",
    "    # Add or replace alternative period values if needed\n",
    "    # if rule_and_delay_period != nothing; extra_pars[:rule_and_delay_period] = rule_and_delay_period; end;\n",
    "    # if target_period         != nothing; extra_pars[:target_period]         = target_period;         end;\n",
    "    # if post_target_period    != nothing; extra_pars[:post_target_period]    = post_target_period;    end;\n",
    "\n",
    "    # Run it\n",
    "    proVs, antiVs = run_ntrials(ntrials, ntrials; plot_list=[1:30;], \n",
    "        merge(make_dict(args, pars, merge(mypars, extra_pars)), Dict(further_pars))...)[1:2]\n",
    "\n",
    "    # Add titles with the binarized hit rates\n",
    "    hBP = 100*length(find(proVs[1,:]  .> proVs[4,:])) /size(proVs, 2)\n",
    "    hBA = 100*length(find(antiVs[4,:] .> antiVs[1,:]))/size(antiVs,2)\n",
    "\n",
    "    figure(1); subplot(3,1,1); title(@sprintf(\"%s: binarized Pro  hits = %.1f %%\\n\", run_name, hBP))\n",
    "    figure(2); subplot(3,1,1); title(@sprintf(\"%s: binarized Anti hits = %.1f %%\\n\", run_name, hBA))\n",
    "    \n",
    "    return hBP, hBA, d\n",
    "end\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#@include_me analyze_reduced_farm.jl\n",
    "\n",
    "# IDENTIFY GOOD RUNS FROM FARM\n",
    "\n",
    "using JLD\n",
    "I = results = files = 0\n",
    "\n",
    "farm_id = \"C4\"; farmdir = \"FarmFields\"\n",
    "farm_id = \"C6\"; farmdir = \"../NewFarms\"\n",
    "farm_id = \"C11\"; farmdir = \"../NewFarms\"\n",
    "\n",
    "recompute_me = true; if recompute_me || !isfile(\"Temp/\" * farm_id * \"_results.jld\")\n",
    "    results = zeros(0,4)\n",
    "\n",
    "    files = []\n",
    "    for f in filter(x -> startswith(x, \"farm_\" * farm_id * \"_\"), readdir(farmdir * \"/\"))\n",
    "\n",
    "        hBP, hBA, dP, dA= load(farmdir * \"/\" * f, \"hBP\", \"hBA\", \"dP\", \"dA\")\n",
    "        results = [results; [hBP hBA dP dA]]; \n",
    "        files   = [files ; f]\n",
    "        if length(files)>71; break; end;\n",
    "    end\n",
    "    \n",
    "    I = find((results[:,1] .> 0.85) .& (results[:,2] .> 0.65) .& (results[:,3].>0.9) .& (results[:,4].>0.9) .&\n",
    "                ((results[:,1]-results[:,2]) .> 0.1) )\n",
    "\n",
    "    @save \"Temp/\" * farm_id * \"_results.jld\" results files I\n",
    "else\n",
    "    I, results, files = load(\"Temp/\" * farm_id *\"_results.jld\", \"I\", \"results\", \"files\");\n",
    "end\n",
    "\n",
    "@printf(\"%.2f %% good runs out of %d\\n\", 100*length(I)/length(files), length(files))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Look at individual trials"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "args = res[\"args\"]\n",
    "I= find((res[\"tcost\"].<-0.0002))\n",
    "res[\"files\"][I]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "testruns=800\n",
    "mypars, extra_pars, args, pars3 = load(\"MiniFarms/farm_C17_Farms024_0430.jld\", \"mypars\", \"extra_pars\", \"args\", \"pars3\")\n",
    "\n",
    "cost, cost1s, cost2s, hP, hA, dP, dA, hBP, hBA = JJ(testruns, testruns; verbose=false, \n",
    "    make_dict(args, pars3, merge(merge(mypars, extra_pars)))...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "pygui(true)\n",
    "figure(1); clf();\n",
    "figure(2); clf();\n",
    "\n",
    "these_pars = merge(mypars, extra_pars);\n",
    "these_pars = merge(these_pars, Dict(\n",
    "# :opto_strength=>0.3, \n",
    ":opto_times=>reshape(extra_pars[:opto_periods][2,:], 1, 2),\n",
    "# :opto_times=>[\"target_start-0.4\" \"target_start\"],\n",
    "# :opto_times=>[\"target_start\" \"target_end\"],\n",
    ":post_target_period=>0.3,\n",
    ":rule_and_delay_period=>1.2,\n",
    ":dt=>0.005,\n",
    "))\n",
    "delete!(these_pars, :plot_list)\n",
    "\n",
    "override = Dict(\n",
    "# :sigma=>0.02,\n",
    ")\n",
    "\n",
    "proVs, antiVs = run_ntrials(20, 20; plot_list=[1:20;], plot_Us=false, \n",
    "    merge(make_dict(args, pars3, these_pars), override)...);\n",
    "hBP = length(find(proVs[1,:]  .> proVs[4,:])) /size(proVs, 2)\n",
    "hBA = length(find(antiVs[4,:] .> antiVs[1,:]))/size(antiVs,2)\n",
    "@printf(\"hBP=%.2f%%, hBA=%.2f%%\\n\", 100*hBP, 100*hBA)\n",
    "\n",
    "figure(1); subplot(2,1,1)\n",
    "title(@sprintf(\"PRO hits = %.2f%%\", 100*hBP))\n",
    "figure(2); subplot(2,1,1)\n",
    "title(@sprintf(\"ANTI hits = %.2f%%\", 100*hBA))\n",
    "\n",
    "[args pars3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "pygui(true)\n",
    "figure(1); clf();\n",
    "figure(2); clf();\n",
    "\n",
    "these_pars = merge(mypars, extra_pars);\n",
    "these_pars = merge(these_pars, Dict(\n",
    "# :opto_strength=>0.3, \n",
    ":opto_times=>reshape(extra_pars[:opto_periods][2,:], 1, 2),\n",
    "# :opto_times=>[\"target_start-0.4\" \"target_start\"],\n",
    "# :opto_times=>[\"target_start\" \"target_end\"],\n",
    ":post_target_period=>0.3,\n",
    ":rule_and_delay_period=>1.2,\n",
    ":dt=>0.005,\n",
    "))\n",
    "delete!(these_pars, :plot_list)\n",
    "\n",
    "override = Dict(\n",
    "# :sigma=>0.02,\n",
    ")\n",
    "\n",
    "proVs, antiVs = run_ntrials(100, 100; plot_list=[1:20;], plot_Us=false, \n",
    "    merge(make_dict(args, pars3, these_pars), override)...);\n",
    "hBP = length(find(proVs[1,:]  .> proVs[4,:])) /size(proVs, 2)\n",
    "hBA = length(find(antiVs[4,:] .> antiVs[1,:]))/size(antiVs,2)\n",
    "@printf(\"hBP=%.2f%%, hBA=%.2f%%\\n\", 100*hBP, 100*hBA)\n",
    "\n",
    "figure(1); subplot(2,1,1)\n",
    "title(@sprintf(\"PRO hits = %.2f%%\", 100*hBP))\n",
    "figure(2); subplot(2,1,1)\n",
    "title(@sprintf(\"ANTI hits = %.2f%%\", 100*hBA))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "clf();\n",
    "ax = gca();\n",
    "axisHeightChange(0.5, ax=ax, lock=\"b\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for k in keys(ax)\n",
    "    print(k); print(\"\\n\")\n",
    "end\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ax[:set_position]([0.1, 0.1, 0.1, 0.1])\n",
    "b = ax[:get_position]()[:bounds]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "figure(2); clf()\n",
    "\n",
    "using StatsBase\n",
    "\n",
    "x = -0.001:0.000001:maximum(tcost)\n",
    "\n",
    "h1 = fit(Histogram, tcost[:,1], x, closed=:right)\n",
    "\n",
    "plot(x, [0 ; cumsum(h1.weights)]/sum(h1.weights), \"b-\")\n",
    "\n",
    "xlabel(\"Training cost\")\n",
    "ylabel(\"fraction of runs\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "find(tcost.<-0.00015)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# farm_id = \"C11\"; farmdir = \"../NewFarms\"\n",
    "\n",
    "\"\"\"\n",
    "    results, files, tcosts, qu_outs, sigmas, target_excites = lookem(;farm_id=\"C11\", farmdir=\"../NewFarms\")\n",
    "\"\"\"\n",
    "function lookem(;farm_id=\"C11\", farmdir=\"../NewFarms\")\n",
    "    results = zeros(0,2); files =[]; qu_outs=[]; sigmas=[]; target_excites=[]; tcosts=[];\n",
    "    for f in filter(x -> startswith(x, \"farm_\" * farm_id * \"_\"), readdir(farmdir * \"/\"))\n",
    "        d = load(farmdir * \"/\" * f)\n",
    "        if !haskey(d, \"qu_out\"); d[\"qu_out\"] = [0 0]; end;\n",
    "        traj3 = d[\"traj3\"]; qu_out = d[\"qu_out\"]\n",
    "        @printf(\"%s : sigma=%.3f, q=%.1f, %g\\n\", f, d[\"pars3\"][7], qu_out[1], traj3[2,end])\n",
    "        results = [results ; qu_out[1] traj3[2,end]]\n",
    "        files = [files ; f]\n",
    "        qu_outs = [qu_outs ; d[\"qu_out\"][1]]\n",
    "        sigmas  = [sigmas ; d[\"pars3\"][7]]\n",
    "        target_excites = [target_excites ; d[\"pars3\"][2]]\n",
    "        tcosts  = [tcosts ; traj3[2,end]]\n",
    "    end\n",
    "    return results, files, tcosts, qu_outs, sigmas, target_excites\n",
    "end\n",
    "\n",
    "res14 = lookem(farm_id=\"C14\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "[args pars3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "find(res[:,2].<-0.0002)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "res[res[:,2].<-0.0002,:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Looking at individual trials of individual farms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "res16 = farmload(\"C16\")\n",
    "res16[\"params\"][:,5]\n",
    "\n",
    "threshold = -0.0002;\n",
    "I = find(res16[\"tcost\"].<threshold)\n",
    "N = length(res16[\"tcost\"])\n",
    "@printf(\"You get %d/%d (%.2f%%) runs at training cost < %g\\n\", length(I), N, 100*length(I)/N, threshold)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "res16[\"args\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "I= find((res16[\"tcost\"].<-0.0002) .& (res16[\"params\"][:,5].<1) .& (res16[\"params\"][:,1].>0) .& (res16[\"params\"][:,11].>0))\n",
    "res16[\"files\"][I]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "testruns=10\n",
    "mypars, extra_pars, args, pars3 = load(\"../NewFarms/farm_C16_0175.jld\", \"mypars\", \"extra_pars\", \"args\", \"pars3\")\n",
    "\n",
    "cost, cost1s, cost2s, hP, hA, dP, dA, hBP, hBA = JJ(testruns, testruns; verbose=false, \n",
    "    make_dict(args, pars3, merge(merge(mypars, extra_pars)))...)\n",
    "\n",
    "pygui(true)\n",
    "figure(1); clf();\n",
    "figure(2); clf();\n",
    "\n",
    "these_pars = merge(mypars, extra_pars);\n",
    "these_pars = merge(these_pars, Dict(\n",
    "# :opto_strength=>0.3, \n",
    ":opto_times=>reshape(extra_pars[:opto_periods][1,:], 1, 2),\n",
    "# :opto_times=>[\"target_start-0.4\" \"target_start\"],\n",
    "# :opto_times=>[\"target_start\" \"target_end\"],\n",
    ":post_target_period=>0.3,\n",
    ":rule_and_delay_period=>1.2,\n",
    ":dt=>0.005,\n",
    "))\n",
    "delete!(these_pars, :plot_list)\n",
    "\n",
    "override = Dict(\n",
    "# :sigma=>0.02,\n",
    ")\n",
    "\n",
    "proVs, antiVs = run_ntrials(100, 100; plot_list=[1:20;], plot_Us=false, \n",
    "    merge(make_dict(args, pars3, these_pars), override)...);\n",
    "hBP = length(find(proVs[1,:]  .> proVs[4,:])) /size(proVs, 2)\n",
    "hBA = length(find(antiVs[4,:] .> antiVs[1,:]))/size(antiVs,2)\n",
    "@printf(\"hBP=%.2f%%, hBA=%.2f%%\\n\", 100*hBP, 100*hBA)\n",
    "\n",
    "figure(1); subplot(2,1,1)\n",
    "title(@sprintf(\"PRO hits = %.2f%%\", 100*hBP))\n",
    "figure(2); subplot(2,1,1)\n",
    "title(@sprintf(\"ANTI hits = %.2f%%\", 100*hBA))\n",
    "\n",
    "[args pars3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "pygui(true)\n",
    "figure(1); clf();\n",
    "figure(2); clf();\n",
    "\n",
    "these_pars = merge(mypars, extra_pars);\n",
    "these_pars = merge(these_pars, Dict(\n",
    "# :opto_strength=>0.3, \n",
    ":opto_times=>reshape(extra_pars[:opto_periods][2,:], 1, 2),\n",
    "# :opto_times=>[\"target_start-0.4\" \"target_start\"],\n",
    "# :opto_times=>[\"target_start\" \"target_end\"],\n",
    ":post_target_period=>0.3,\n",
    ":rule_and_delay_period=>1.2,\n",
    ":dt=>0.005,\n",
    "))\n",
    "delete!(these_pars, :plot_list)\n",
    "\n",
    "override = Dict(\n",
    "# :sigma=>0.02,\n",
    ")\n",
    "\n",
    "proVs, antiVs = run_ntrials(100, 100; plot_list=[1:20;], plot_Us=false, \n",
    "    merge(make_dict(args, pars3, these_pars), override)...);\n",
    "hBP = length(find(proVs[1,:]  .> proVs[4,:])) /size(proVs, 2)\n",
    "hBA = length(find(antiVs[4,:] .> antiVs[1,:]))/size(antiVs,2)\n",
    "@printf(\"hBP=%.2f%%, hBA=%.2f%%\\n\", 100*hBP, 100*hBA)\n",
    "\n",
    "figure(1); subplot(2,1,1)\n",
    "title(@sprintf(\"PRO hits = %.2f%%\", 100*hBP))\n",
    "figure(2); subplot(2,1,1)\n",
    "title(@sprintf(\"ANTI hits = %.2f%%\", 100*hBA))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mypars[:dt]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "res=lookem(farm_id=\"C11\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "load(\"../NewFarms/farm_C11_0001.jld\", \"README\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# farm_id = \"C11\"; farmdir = \"../NewFarms\"\n",
    "\n",
    "function lookem(;farm_id=\"C11\", farmdir=\"../NewFarms\")\n",
    "    results = zeros(0,2)\n",
    "    for f in filter(x -> startswith(x, \"farm_\" * farm_id * \"_\"), readdir(farmdir * \"/\"))\n",
    "        d = load(farmdir * \"/\" * f)\n",
    "        if !haskey(d, \"qu_out\"); d[\"qu_out\"] = [0 0]; end;\n",
    "        traj3 = d[\"traj3\"]; qu_out = d[\"qu_out\"]\n",
    "        @printf(\"%s : sigma=%.3f, q=%.1f, %g\\n\", f, d[\"pars3\"][7], qu_out[1], traj3[2,end])\n",
    "        results = [results ; qu_out[1] traj3[2,end]]\n",
    "    end\n",
    "    return results\n",
    "end\n",
    "\n",
    "res = lookem(farm_id=\"C12\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "find(res[:,2].<-0.0001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "load(\"../NewFarms/farm_C12_0144.jld\", \"bbox\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "function change_farm_name(from, to; farmdir=\"../NewFarms\")\n",
    "    for f in filter(x -> startswith(x, \"farm_\" * from * \"_\"), readdir(farmdir))\n",
    "        myfrom = farmdir * \"/\" * f\n",
    "        myto   = farmdir * \"/\" * replace(f, \"_\"*from*\"_\", \"_\"*to*\"_\")\n",
    "        @printf(\"mv %s %s\\n\", myfrom, myto)\n",
    "        mv(myfrom, myto)\n",
    "    end\n",
    "end\n",
    "\n",
    "change_farm_name(\"C12\", \"C13\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "res12 = lookem(farm_id=\"C12\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "gooders = find(res12[:,2].<-0.0002)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Investigate where farm C12 went outside the bounding box\n",
    "\n",
    "\n",
    "bbox = load(\"../NewFarms/farm_C13_0001.jld\", \"bbox\")\n",
    "print(bbox)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "function out_of_box(pdict, bbox)\n",
    "    outs = Dict()\n",
    "    for k in keys(bbox)\n",
    "        val = pdict[k]\n",
    "        if val <= bbox[k][1] || bbox[k][2] <= val\n",
    "            outs[k] = val\n",
    "        end\n",
    "    end\n",
    "    return outs\n",
    "end\n",
    "\n",
    "for k in find(res12[:,2].<-0.0002)\n",
    "    mynum = @sprintf(\"%d\", k); while length(mynum)<4; mynum=\"0\"*mynum; end;\n",
    "    \n",
    "    traj3, args = load(\"../NewFarms/farm_C12_\" * mynum * \".jld\", \"traj3\", \"args\") \n",
    "    @printf(\"farm_C12_%s.jld:\\n\", mynum)\n",
    "    print(out_of_box(make_dict(args, traj3[3:end,end]), bbox))\n",
    "    print(\"\\n\")\n",
    "end\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Sanity check on whether we are getting results in the trajectory that matches algorithm\n",
    "# behavior\n",
    "\n",
    "ngoods = [0, 0]\n",
    "nguys  = [0, 0]\n",
    "\n",
    "farm_id = \"C6\"; farmdir = \"../NewFarms\"\n",
    "for f in filter(x -> startswith(x, \"farm_\" * farm_id * \"_\"), readdir(farmdir * \"/\"))\n",
    "    d = load(farmdir * \"/\" * f)\n",
    "    @printf(\"n=%d %s: \", d[\"ntries\"], f); \n",
    "    if d[\"ntries\"]==1\n",
    "        print(d[\"traj1\"][2,end])        \n",
    "        nguys[1] += 1\n",
    "        ngoods[1] += d[\"traj1\"][2,end] <= -0.0009 ? 1 : 0\n",
    "    else\n",
    "        print(d[\"traj3\"][2,end])\n",
    "        nguys[2] += 1\n",
    "        ngoods[2] += d[\"traj3\"][2,end] <= -0.0009 ? 1 : 0\n",
    "    end\n",
    "    @printf(\"  hBP=%.2f, hBA=%.2f dP=%.2f dA=%.2f\", d[\"hBP\"][1], d[\"hBA\"][1], \n",
    "        d[\"dP\"][1], d[\"dA\"][1])\n",
    "    @printf(\"\\n\")\n",
    "end\n",
    "\n",
    "@printf(\"\\n For ntries=1, success rate %.2f%%, for ntries=2, rate %.2f%%\\n\", 100*ngoods[1]/nguys[1], 100*ngoods[2]/nguys[2])\n",
    "\n",
    "[\"nguys\" \"ngoods\" ; [nguys ngoods]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# For C6:\n",
    "\n",
    "For ntries=1, success rate 100.00%, for ntries=2, rate 13.29%\n",
    "Out[84]:\n",
    "3×2 Array{Any,2}:\n",
    "    \"nguys\"     \"ngoods\"\n",
    " 111         111        \n",
    " 143          19     \n",
    "    \n",
    "    \n",
    "# For C7:\n",
    "For ntries=1, success rate 100.00%, for ntries=2, rate 10.71%\n",
    "Out[85]:\n",
    "3×2 Array{Any,2}:\n",
    "    \"nguys\"     \"ngoods\"\n",
    " 107         107        \n",
    " 140          15      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "farm_id = \"C10\"; farmdir = \"../NewFarms\"\n",
    "for f in filter(x -> startswith(x, \"farm_\" * farm_id * \"_\"), readdir(farmdir * \"/\"))\n",
    "    d = load(farmdir * \"/\" * f)\n",
    "\n",
    "    @printf(\"%s: qu_out[1]=%.2f, cost=%g\\n\", f, d[\"qu_out\"][1], d[\"traj3\"][2,end]); \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "pygui(true)\n",
    "figure(1); clf();\n",
    "\n",
    "myouts = copy(outs);\n",
    "maxx   = -0.0007\n",
    "\n",
    "myouts[myouts[:,1].>maxx,1] = maxx\n",
    "myouts[myouts[:,2].>maxx,2] = maxx\n",
    "\n",
    "ax1 = subplot(2,1,1);\n",
    "plt[:hist](outs[:,1]*1000,-1:0.01:maxx*1000)\n",
    "vlines(-0.95, ylim()[1], ylim()[2], color=\"r\", linestyle=\"--\")\n",
    "ylabel(\"# of runs\")\n",
    "title(\"standard minimization -- left of red dashed line is a good run\")\n",
    "remove_xtick_labels()\n",
    "\n",
    "\n",
    "ax2 = subplot(2,1,2)\n",
    "plt[:hist](outs[:,2]*1000,-1:0.01:maxx*1000)\n",
    "vlines(-0.95, ylim()[1], ylim()[2], color=\"r\", linestyle=\"--\")\n",
    "xlabel(\"Final training cost/1000\")\n",
    "ylabel(\"# of runs\")\n",
    "title(\"minimization with pre-check\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "outs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mypars, extra_pars, start_pars, qu_out, args, bbox = load(\"../NewFarms/farm_C10_0008.jld\", \n",
    "    \"mypars\", \"extra_pars\", \"start_pars\", \"qu_out\", \"args\", \"bbox\")\n",
    "\n",
    "\n",
    "func1 =  (;params...) -> JJ(mypars[:nPro], mypars[:nAnti]; verbose=false, \n",
    "    merge(merge(mypars, extra_pars), Dict(params))...)[1]\n",
    "    \n",
    "            \n",
    "pars3, traj3, cost3, cpm_traj3, ftraj3 = bbox_Hessian_keyword_minimization(start_pars, \n",
    "    args, bbox, func1, \n",
    "    start_eta = 0.01, tol=1e-12, \n",
    "    verbose=true, verbose_every=1, maxiter=maxiter1)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "        cost, cost1s, cost2s, hP, hA, dP, dA, hBP, hBA = JJ(10000, 10000; verbose=false, \n",
    "            make_dict(args, pars3, merge(merge(mypars, extra_pars)))...)\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "[hBP, hBA, dP, dA]'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "        cost, cost1s, cost2s, hP, hA, dP, dA, hBP, hBA = JJ(200, 200; verbose=false, \n",
    "            make_dict(args, pars3, merge(merge(mypars, extra_pars)))...)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "[hBP, hBA, dP, dA]'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "[0.5/sqrt(200) 0.5/sqrt(400)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "d = load(\"../NewFarms/farm_C6_0002.jld\")\n",
    "\n",
    "mypars     = d[\"mypars\"]\n",
    "extra_pars = d[\"extra_pars\"] \n",
    "args       = d[\"args\"]\n",
    "pars1      = d[\"pars1\"]\n",
    "\n",
    "cost, cost1s, cost2s, hP, hA, dP, dA, hBP, hBA = JJ(400, 400; verbose=false, \n",
    "            make_dict(args, pars1, merge(merge(mypars, extra_pars)))...)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "extra_pars[:seedrand]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "~( abs(hBP[1]-0.9)<0.075 && abs(hBA[1]-0.7)<0.075 && dP[1] > 0.8 && dA[1] > 0.8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#@include_me  analyze_reduced_farm.jl\n",
    "\n",
    "\"\"\"\n",
    "    go_over_good_runs(files, I)\n",
    "\n",
    "Given a list of files, and a list of indices into those files, iterates over the indicated\n",
    "filenames, running show_run() on them, and then asking for user input.\n",
    "\"\"\"\n",
    "function go_over_good_runs(files, I)\n",
    "    for k=1:length(I)\n",
    "        show_run(files[I[k]])\n",
    "\n",
    "        @printf(\"Any key to continue, q to quit: \")\n",
    "        ans = chomp(readline())\n",
    "        if ans==\"q\" || ans==\"Q\"\n",
    "            break\n",
    "        end\n",
    "    end\n",
    "end\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "go_over_good_runs(files, I)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#@include_me analyze_reduced_farm.jl\n",
    "\n",
    "# show_run(\"farm_C3_0027.jld\", 400; opto_times=[\"trial_start\", \"trial_end\"], opto_strength=0.75)\n",
    "# show_run(\"farm_C3_0027.jld\", 400; opto_times=[\"target_start-0.5\", \"target_start\"], opto_strength=0, \n",
    "#   const_pro_bias=0, anti_rule_strength=0.05)\n",
    "show_run(\"farm_C3_0027.jld\", 400; opto_times=[\"target_start+0.016\", \"target_end\"], opto_strength=0.4, \n",
    "    const_pro_bias=0.02476, anti_rule_strength=0.054)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#@include_me analyze_reduced_farm.jl\n",
    "\n",
    "#  TARGET PERIOD OPTO\n",
    "\n",
    "run_name = \"farm_C3_0027.jld\"\n",
    "recompute_me = false; if recompute_me\n",
    "    ostrengths = 0.5:0.1:1\n",
    "    phits      = zeros(1, length(ostrengths))\n",
    "    ahits      = zeros(1, length(ostrengths))\n",
    "\n",
    "    for i=1:length(ostrengths)\n",
    "        phits[i], ahits[i] = show_run(run_name, 4000; \n",
    "        opto_times=[\"target_start+0.016\", \"target_end+0.016\"], opto_strength=ostrengths[i])\n",
    "        @printf(\"ostrength=%g, phits=%.1f, ahits=%.1f\\n\", ostrengths[i], phits[i], ahits[i])\n",
    "    end\n",
    "\n",
    "    @save(\"Temp/opto_target.jld\", ostrengths, ahits, phits)\n",
    "else\n",
    "    ostrengths, ahits, phits = load(\"Temp/opto_target.jld\", \"ostrengths\", \"ahits\", \"phits\")\n",
    "end\n",
    "\n",
    "figure(3);clf();\n",
    "plot(ostrengths, phits[:], \".-\", ostrengths, ahits[:], \".-\")\n",
    "legend([\"pro\", \"anti\"])\n",
    "xlabel(\"opto strength\")\n",
    "ylabel(\"binarized hits\")\n",
    "title(run_name * \" : TARGET PERIOD opto\")\n",
    "grid(\"on\")\n",
    "\n",
    "\n",
    "#  DELAY PERIOD OPTO  ---------\n",
    "\n",
    "recompute_me = false; if recompute_me\n",
    "    ostrengths = 0.5:0.1:1\n",
    "    phits      = zeros(1, length(ostrengths))\n",
    "    ahits      = zeros(1, length(ostrengths))\n",
    "\n",
    "    for i=1:length(ostrengths)\n",
    "        phits[i], ahits[i] = show_run(run_name, 4000; \n",
    "        opto_times=[\"target_start-0.5\", \"target_start\"], opto_strength=ostrengths[i])\n",
    "        @printf(\"ostrength=%g, phits=%.1f, ahits=%.1f\\n\", ostrengths[i], phits[i], ahits[i])\n",
    "    end\n",
    "    @save(\"Temp/opto_delay.jld\", ostrengths, ahits, phits)\n",
    "else\n",
    "    ostrengths, ahits, phits = load(\"Temp/opto_delay.jld\", \"ostrengths\", \"ahits\", \"phits\")\n",
    "end\n",
    "\n",
    "figure(4);clf();\n",
    "plot(ostrengths, phits[:], \".-\", ostrengths, ahits[:], \".-\")\n",
    "legend([\"pro\", \"anti\"])\n",
    "xlabel(\"opto strength\")\n",
    "ylabel(\"binarized hits\")\n",
    "title(run_name * \" : last 500 ms of DELAY PERIOD opto\")\n",
    "grid(\"on\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## workspace for double_search.jl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "extra_pars[:seedrand] = 1510799260433 # Int64(round(1000*time()))   # 1510782006169 causes lin.alg error but then looks like it'll succeed\n",
    "srand(extra_pars[:seedrand])\n",
    "\n",
    "    args = []; seed = []; bbox = Dict()\n",
    "    for k in keys(search_conditions)\n",
    "        search_box = search_conditions[k][2]\n",
    "        args = [args; String(k)]\n",
    "        # --- search within the indicated search range:\n",
    "        myseed = search_conditions[k][1] + search_range*(rand()-0.5)*diff(search_box); myseed = myseed[1]\n",
    "        if myseed > search_box[2]; myseed = search_box[2]; end\n",
    "        if myseed < search_box[1]; myseed = search_box[1]; end\n",
    "        seed = [seed ;  myseed]\n",
    "        # --- No search, just start at the indicated position:\n",
    "        # seed = [seed ; search_conditions[k][1]]\n",
    "        bbox = merge(bbox, Dict(k => Array{Float64}(search_conditions[k][3])))\n",
    "    end\n",
    "    args = Array{String}(args)\n",
    "    seed = Array{Float64}(seed)\n",
    "\n",
    "\n",
    "func1 =  (;params...) -> JJ(mypars[:nPro], mypars[:nAnti]; verbose=false, \n",
    "    merge(merge(mypars, extra_pars), Dict(params))...)[1]\n",
    "\n",
    "t_pars = [0.378, 0.164, 0.001, -0.203, 0.589, -0.673, 0.105, -0.582, 0.471]\n",
    "\n",
    "pars, traj, cost, cpm_traj, ftraj = bbox_Hessian_keyword_minimization(t_pars, args, bbox, func1, \n",
    "    start_eta = 0.1, tol=1e-12, \n",
    "    verbose=true, verbose_every=1, maxiter=1000)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "testruns = 1600\n",
    "\n",
    "pars = [0.356712, 0.000825015, 0.0218232, -0.0364268, 0.678269, -2.97884, 0.153528, -0.484789, 1.07313]\n",
    "\n",
    "cost, cost1s, cost2s, hP, hA, dP, dA, hBP, hBA = JJ(testruns, testruns; verbose=false, \n",
    "                make_dict(args, pars, merge(merge(mypars, extra_pars)))...)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "G = load(\"FarmFields/farm_C4_0041.jld\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "( abs(hBP[1]-0.9)<0.05 && abs(hBA[1]-0.7)<0.05 && dP[1] > 0.8 && dA[1] > 0.8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "    args = []; seed = []; bbox = Dict()\n",
    "    for k in keys(search_conditions)\n",
    "        search_box = search_conditions[k][2]\n",
    "        args = [args; String(k)]\n",
    "        # --- search within the indicated search range:\n",
    "        myseed = search_conditions[k][1] + search_range*(rand()-0.5)*diff(search_box); myseed = myseed[1]\n",
    "        if myseed > search_box[2]; myseed = search_box[2]; end\n",
    "        if myseed < search_box[1]; myseed = search_box[1]; end\n",
    "        seed = [seed ;  myseed]\n",
    "        # --- No search, just start at the indicated position:\n",
    "        # seed = [seed ; search_conditions[k][1]]\n",
    "        bbox = merge(bbox, Dict(k => Array{Float64}(search_conditions[k][3])))\n",
    "    end\n",
    "    args = Array{String}(args)\n",
    "    seed = Array{Float64}(seed)\n",
    "\n",
    "\n",
    "    maxiter1 = 10;  # for func1, the regular search\n",
    "    maxiter2 = 20;  # for func2, the reduced search\n",
    "\n",
    "    func1 =  (;params...) -> JJ(mypars[:nPro], mypars[:nAnti]; verbose=false, \n",
    "    merge(merge(mypars, extra_pars), Dict(params))...)[1]\n",
    "    \n",
    "    # For func2:\n",
    "    extra_pars[:opto_conditions] = []    \n",
    "    extra_pars[:plot_list] = [1:10;]    \n",
    "    extra_pars[:plot_condition] = 0\n",
    "\n",
    "    func2 =  (;params...) -> new_J(10, 10; verbose=false, merge(merge(mypars, extra_pars), Dict(params))...)\n",
    "\n",
    "    # For func2:\n",
    "    # This function will get the output of new_J() at each iteration, and will return \"true\", stopping\n",
    "    # the minimization, if hBP and hBA are both above a threshold.\n",
    "    function stopping_func(;cost=0, func_out=[], ignored_extra_params...)\n",
    "        costf, dP, dA, hBP, hBA = func_out\n",
    "        return hBP[1]>=0.6 && hBA[1] >= 0.6\n",
    "    end\n",
    "\n",
    "        extra_pars[:plot_list] = []\n",
    "        cost, cost1s, cost2s, hP, hA, dP, dA, hBP, hBA = JJ(100, 100; verbose=false, \n",
    "            make_dict(args, seed, merge(merge(mypars, extra_pars)))...)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "dA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "search_conditions = Dict(   # :param    default_start   search_box  bound_box\n",
    ":vW     =>                   [mypars[:vW],                       [-0.5, 0.5],  [-3,   3]], \n",
    ":hW     =>                   [mypars[:hW],                       [-0.5, 0.5],  [-3,   3]],\n",
    ":dW     =>                   [mypars[:dW],                       [-0.5, 0.5],  [-3,   3]],\n",
    ":sW     =>                   [mypars[:sW],                       [0,    0.5],  [0,    3]],\n",
    ":sigma  =>                   [0.11,                              [0.1,  0.2],  [0.1, 0.4]],\n",
    ":constant_excitation      => [mypars[:constant_excitation],      [-1,     1],  [-2,   2]], \n",
    ":target_period_excitation => [mypars[:target_period_excitation], [0.001,0.5],  [0     4]],\n",
    ":right_light_excitation   => [mypars[:right_light_excitation],   [0.05, 0.5],  [0.05, 4]],\n",
    ":const_pro_bias           => [mypars[:const_pro_bias],           [-0.5, 0.5],  [-2,   2]],\n",
    "# :opto_strength            => [mypars[:opto_strength],            [0.7, 0.99],  [0,    1]],\n",
    ")\n",
    "\n",
    "\n",
    "\n",
    "args = []; seed = []; bbox = Dict()\n",
    "\n",
    "for k in keys(search_conditions)\n",
    "    search_box = search_conditions[k][2]\n",
    "    args = [args; String(k)]\n",
    "    # myseed = rand()*diff(search_box) + search_box[1]; myseed = myseed[1]    \n",
    "    # seed = [seed ;  myseed]    \n",
    "    seed = [seed ; search_conditions[k][1]]    \n",
    "    bbox = merge(bbox, Dict(k => Array{Float64}(search_conditions[k][3])))    \n",
    "end\n",
    "args = Array{String}(args)\n",
    "seed = Array{Float64}(seed)\n",
    "\n",
    "func =  (;params...) -> new_J(10, 10; verbose=true,  merge(merge(mypars, extra_pars), Dict(params))...)[1]\n",
    "\n",
    "pars, traj, cost, cpm_traj, ftraj = bbox_Hessian_keyword_minimization(seed, args, bbox, func, \n",
    "            start_eta = 0.1, tol=1e-12, \n",
    "            verbose=true, verbose_every=1, maxiter=1000)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "mypars = Dict(\n",
    ":init_add               =>          0,\n",
    ":const_add              =>          0,\n",
    ":noise                  =>          Any[],\n",
    ":input                  =>          0,\n",
    ":seedrand               =>          1510340076445,\n",
    ":start_anti             =>          [-0.5, -0.5, -0.5, -0.5],\n",
    ":start_pro              =>          [-0.5, -0.5, -0.5, -0.5],\n",
    ":rule_and_delay_period  =>          1.2,\n",
    ":rule_and_delay_periods =>          [1.2],\n",
    ":target_period          =>          0.3,\n",
    ":target_periods         =>          [0.3],\n",
    ":post_target_period     =>          0.3,\n",
    ":post_target_periods    =>          [0.3],\n",
    ":anti_rule_strength     =>          0.054,\n",
    ":U_rest                 =>          0,\n",
    ":theta                  =>          0.05,\n",
    ":beta                   =>          0.5,\n",
    ":g_leak                 =>          1,\n",
    ":nsteps                 =>          301,\n",
    ":dt                     =>          0.024,\n",
    ":tau                    =>          0.09,\n",
    ":right_light_excitation =>          0.49924152955481954,\n",
    ":opto_strength          =>          0.85,\n",
    ":opto_periods           =>          String[\n",
    "                                    \"trial_start\" \"trial_start\"; \n",
    "                                    \"trial_start\" \"trial_end\"; \n",
    "                                    \"trial_start\" \"target_start/2\"; \n",
    "                                    \"target_start/2\" \"target_start\"; \n",
    "                                    \"target_start\" \"target_end\"],\n",
    ":opto_targets          =>           [\n",
    "                                    0.9 0.7; \n",
    "                                    0.9 0.5; \n",
    "                                    0.9 0.7; \n",
    "                                    0.9 0.5; \n",
    "                                    0.9 0.7],\n",
    ":theta2 => 0.15,\n",
    ":theta1 => 0.05,\n",
    ":sigma => 0.01,\n",
    ":cbeta => 0.04,\n",
    ":sW => 0.6416875048295452,\n",
    ":hW => 0.054701836208134846,\n",
    ":dW => 0.1267124266934907,\n",
    ":vW => -1.588850577499782,\n",
    ":constant_excitation => -0.37242520737694207,\n",
    ":const_pro_bias => 0.04366897857834884,\n",
    ":target_period_excitation => 0.15315254453690974,\n",
    ":right_light_pro_extra => 0,\n",
    ":pro_rule_strength => 0.05,\n",
    ":nPro => 100,\n",
    ":nAnti => 100,\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "extra_pars = Dict(\n",
    ":plot_list        =>   [1:10;], \n",
    ":plot_condition   =>   1,\n",
    ":verbose          =>   true,\n",
    ":opto_conditions  =>   Array{Any}(0, 4),\n",
    ")\n",
    "\n",
    "\n",
    "search_conditions = Dict(   # :param    default_start   search_box  bound_box\n",
    ":vW     =>                   [mypars[:vW],                       [-0.5, 0.5],  [-3,   3]], \n",
    ":hW     =>                   [mypars[:hW],                       [-0.5, 0.5],  [-3,   3]],\n",
    ":dW     =>                   [mypars[:dW],                       [-0.5, 0.5],  [-3,   3]],\n",
    ":sW     =>                   [mypars[:sW],                       [0,    0.5],  [0,    3]],\n",
    ":sigma  =>                   [0.11,                              [0.1,  0.2],  [0.1, 0.4]],\n",
    ":constant_excitation      => [mypars[:constant_excitation],      [-1,     1],  [-2,   2]], \n",
    ":target_period_excitation => [mypars[:target_period_excitation], [0.001,0.5],  [0     4]],\n",
    ":right_light_excitation   => [mypars[:right_light_excitation],   [0.05, 0.5],  [0.05, 4]],\n",
    ":const_pro_bias           => [mypars[:const_pro_bias],           [-0.5, 0.5],  [-2,   2]],\n",
    "# :opto_strength            => [mypars[:opto_strength],            [0.7, 0.99],  [0,    1]],\n",
    ")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a=(1, 2, 3, 4, \"5\")\n",
    "\n",
    "b,c,d,e,f = a\n",
    "f\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#@include_me interesting_minimization.jl\n",
    "\n",
    "include(\"pro_anti.jl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#@include_me interesting_minimization.jl\n",
    "\n",
    "pygui(true)\n",
    "d = load(\"FarmFields/farm_C3_0005.jld\")\n",
    "mypars     = d[\"mypars\"]\n",
    "extra_pars = d[\"extra_pars\"] \n",
    "\n",
    "seed = d[\"seed\"]\n",
    "args = d[\"args\"]\n",
    "bbox = d[\"bbox\"]\n",
    "\n",
    "extra_pars[:opto_conditions] = []\n",
    "extra_pars[:plot_list] = [1:10;]\n",
    "extra_pars[:plot_condition] = 1\n",
    "\n",
    "# This function will get the output of new_J() at each iteration, and will return \"true\", stopping\n",
    "# the minimization, if hBP and hBA are both above a threshold.\n",
    "function stopping_func(;cost=0, func_out=[], ignored_extra_params...)\n",
    "    costf, dP, dA, hBP, hBA = func_out\n",
    "    return hBP[1]>=0.6 && hBA[1] >= 0.6\n",
    "end\n",
    "\n",
    "func =  (;params...) -> new_J(10, 10; verbose=true, merge(merge(mypars, extra_pars), Dict(params))...)\n",
    "\n",
    "t_pars, traj, cost, cpm_traj, ftraj = bbox_Hessian_keyword_minimization(seed, args, bbox, func, \n",
    "    stopping_function = stopping_func, \n",
    "start_eta = 0.1, tol=1e-12, verbose=true, verbose_every=1, maxiter=2000)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "t_pars = pars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#@include_me  interesting_minimization.jl\n",
    "\n",
    "seed = t_pars\n",
    "\n",
    "func =  (;params...) -> JJ(mypars[:nPro], mypars[:nAnti]; verbose=false, \n",
    "    merge(merge(mypars, extra_pars), Dict(params))...)\n",
    "\n",
    "\n",
    "pars, traj, cost, cpm_traj, ftraj = bbox_Hessian_keyword_minimization(seed, args, bbox, func, \n",
    "    start_eta = 0.1, tol=1e-12, verbose=true, verbose_every=1, maxiter=1000)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "README = \"\"\"\n",
    "For the code that generated this file, see interesting_minimization.jl.\n",
    "\n",
    "The thing that is interesting, is that at the end of ths minimization, things are going VERY slowly, \n",
    "and cos theta is almost always close to 0! What is going on?  What is the landscape like around\n",
    "there? Are we really taking nicely-directed Hessian jumps?  Or is the wall screwing that up?\n",
    "\"\"\"\n",
    "\n",
    "@save \"Temp/interesting_minimization.jld\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "gu = true\n",
    "\n",
    "@printf(\"gu is %s\\n\", false)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "fbasename = \"FarmFields/farm_C4_\"\n",
    "\n",
    "# while true\n",
    "    args = []; seed = []; bbox = Dict()\n",
    "    for k in keys(search_conditions)\n",
    "        search_box = search_conditions[k][2]\n",
    "        args = [args; String(k)]\n",
    "        myseed = rand()*diff(search_box) + search_box[1]; myseed = myseed[1]\n",
    "        seed = [seed ;  myseed]\n",
    "        # seed = [seed ; search_conditions[k][1]]\n",
    "        bbox = merge(bbox, Dict(k => Array{Float64}(search_conditions[k][3])))\n",
    "    end\n",
    "    args = Array{String}(args)\n",
    "    seed = Array{Float64}(seed)\n",
    "\n",
    "\n",
    "\n",
    "    func =  (;params...) -> new_J(10, 10; verbose=true, \n",
    "        merge(merge(mypars, extra_pars), Dict(params))...)[1]\n",
    "\n",
    "    try\n",
    "        pars, traj, cost, cpm_traj, ftraj = bbox_Hessian_keyword_minimization(seed, args, bbox, func, \n",
    "            start_eta = 0.1, tol=1e-12, \n",
    "            verbose=true, verbose_every=1, maxiter=1000)\n",
    "\n",
    "\n",
    "        cost, cost1s, cost2s, hP, hA, dP, dA, hBP, hBA = JJ(10000, 10000; verbose=false, \n",
    "        make_dict(args, pars, merge(merge(mypars, extra_pars)))...)\n",
    "\n",
    "        myfilename = next_file(fbasename, 4)\n",
    "        myfilename = myfilename*\".jld\"\n",
    "        # write file\n",
    "        save(myfilename, Dict(\"nPro\"=>mypars[:nPro], \"nAnti\"=>mypars[:nAnti], \n",
    "        \"mypars\"=>mypars, \"extra_pars\"=>extra_pars, \"args\"=>args, \"seed\"=>seed, \"bbox\"=>bbox, \n",
    "        \"pars\"=>pars, \"traj\"=>traj, \"cost\"=>cost, \"cpm_traj\"=>cpm_traj, \"ftraj\"=>ftraj,\n",
    "        \"hP\"=>hP, \"hA\"=>hA, \"dP\"=>dP, \"dA\"=>dA, \"hBP\"=>hBP, \"hBA\"=>hBA))\n",
    "    catch\n",
    "        @printf(\"\\n\\nWhoopsety, unkown error!   Trying new random seed.\\n\\n\")\n",
    "    end\n",
    "# end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Alex-style runs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "using ForwardDiff\n",
    "using DiffBase\n",
    "using MAT\n",
    "using PyPlot\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "include(\"pro_anti.jl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "FarmName = \"CARLOS_TEST\"\n",
    "\n",
    "\n",
    "#Define core model parameters\n",
    "model_params = Dict(\n",
    ":dt     =>  0.002,      # Changed hyper-parameter\n",
    ":tau    =>  0.02,       # Changed hyper-parameter\n",
    ":vW     =>  -1.7, #FIT parameter\n",
    ":hW     =>  -1.7, #FIT parameter\n",
    ":sW     =>  0.2,  #FIT parameter\n",
    ":dW     =>  0,    #FIT parameter\n",
    ":nsteps =>  2, \n",
    ":noise  =>  [], \n",
    ":sigma  =>  0.08, #FIT parameter\n",
    ":input  =>  0,    #### Alex thinks this is out-dated \n",
    ":g_leak =>  1,          # Changed hyper-parameter\n",
    ":U_rest =>  0,          # Changed hyper-parameter\n",
    ":theta  =>  0.05,       # Changed hyper-parameter\n",
    ":beta   =>  0.5,        # Changed hyper-parameter \n",
    ":sw     =>  0.2,  #### Alex thinks this is out-dated\n",
    ":hw     =>  -1.7, #### Alex thinks this is out-dated\n",
    ":vw     =>  -1.7, #### Alex thinks this is out-dated\n",
    ":constant_excitation      => 0.19, #FIT  parameter\n",
    ":anti_rule_strength       => 0.05,      # Changed hyper-parameter\n",
    ":pro_rule_strength        => 0.05,      # Changed hyper-parameter\n",
    ":target_period_excitation => 1,    #FIT  parameter\n",
    ":right_light_excitation   => 0.5,  #FIT parameter\n",
    ":right_light_pro_extra    => 0,\n",
    ":const_add                => 0, \n",
    ":init_add                 => 0, \n",
    ":rule_and_delay_period    => 0.4,\n",
    ":target_period            => 0.1,\n",
    ":post_target_period       => 0.5,\n",
    ":const_pro_bias           => 0,    #FIT parameter\n",
    ":nPro                     => 100,\n",
    ":nAnti                    => 100,\n",
    ":theta1                   => 0.01,\n",
    ":theta2                   => 0.15,\n",
    ":start_pro                => [-0.5, -0.5, -0.5, -0.5],\n",
    ":start_anti               => [-0.5, -0.5, -0.5, -0.5],\n",
    ":opto_strength  => .7,             #FIT parameter\n",
    ":opto_periods   => [-1.1 -1; 0 20;0 50; 50 100; 100 20],  \n",
    "# The opto \"conditions\" correspond to the rows of opto_periods.\n",
    "# all conditions are in seconds relative to start of the trial\n",
    "# any value before 0 gets changed to 0\n",
    "# any value after the end of trial gets changed to end of trial\n",
    "# Special values allow for variable durations\n",
    "#  20 codes for \"end of trial\"\n",
    "#  -1 codes for \"start of trial\"\n",
    "# 100 codes for \"end of rule and delay period\"\n",
    "# 200 codes for \"end of target period\"\n",
    "# -------------------------------------------------------------\n",
    "# first column is frachit Pro, next column is Anti, rows are conditions\n",
    "# Actual Opto targets\n",
    "#:opto_targets   => [.75 .73;.77 .58;.75 .74; .72 .66;.73 .75] \n",
    "# Fake Targets\n",
    ":opto_targets => [.9 .7; .9 .5; .9 .7; .9 .5; .9 .7]  \n",
    ");\n",
    "\n",
    "# ======= ARGUMENTS AND SEED VALUES:\n",
    "args = [\"sW\", \"vW\", \"hW\", \"dW\", \"constant_excitation\", \"right_light_excitation\", \"target_period_excitation\", \"const_pro_bias\", \"sigma\",\"opto_strength\"];\n",
    "seed = [0.001,  -1.58,   -0.05,  0.001,    0.001,                0.6,                       0.001,                        0.0427,              0.05, .9];   \n",
    "# ======= BOUNDING BOX:\n",
    "bbox = Dict(:sW=>[0 3], :vW=>[-3 3], :hW=>[-3 3], :dW=>[-3 3], :constant_excitation=>[-2 2],\n",
    ":right_light_excitation=>[0.05 4], :target_period_excitation=>[0 4], :const_pro_bias=>[-2 2],\n",
    ":sigma=>[0.1 0.4],:opto_strength=>[0 1]);\n",
    "\n",
    "# ======== SEARCH ZONE:\n",
    "sbox = Dict(:sW=>[0 .5], :vW=>[-.5 .5], :hW=>[-.5 .5], :dW=>[-.5 .5],\n",
    ":constant_excitation=>[-.5 .5], :right_light_excitation=>[0.05 .5], :target_period_excitation=>[0.001 .5],:const_pro_bias=>[-.5 .5], :sigma=>[0.1 .2],:opto_strength=>[.7 .99]);\n",
    "\n",
    "# define a few hyper parameters\n",
    "cbetas = [4e-3];\n",
    "rule_and_delay_periods = [0.2];\n",
    "post_target_periods    = [0.05];\n",
    "num_eval_runs           = 1000;\n",
    "num_optimize_iter       = 2000;\n",
    "num_optimize_restarts   = 100;\n",
    "\n",
    "# define base filename\n",
    "fbasename = \"FarmFields/farm_\"*string(FarmName);\n",
    "\n",
    "for i=1:num_optimize_restarts   # Iterate this many optimizations\n",
    "for cb in cbetas                # Iterate over beta values, if there are multiple\n",
    "    # figure out initial seed for random number generator\n",
    "    sr = convert(Int64, round(time()))\n",
    "    srand(sr);\n",
    "\n",
    "    dista=rand();\n",
    "    println(\"dista\")\n",
    "    println(dista)\n",
    "    myseed1 = copy(seed);\n",
    "\n",
    "    # get initial parameter values by sampling from sbox\n",
    "    myseed = ForwardDiffZeros(length(args),1);\n",
    "    for j=1:length(args)\n",
    "        sym = Symbol(args[j])\n",
    "        if haskey(sbox, sym)\n",
    "#           myseed[j] = sbox[sym][1] + diff(sbox[sym],2)[1]*rand();\n",
    "            myseed[j] = dista*(sbox[sym][1] + diff(sbox[sym],2)[1]*rand())+(1-dista)*myseed1[j];\n",
    "        if myseed[j] > bbox[sym][2]\n",
    "            myseed[j] =bbox[sym][2] - 0.1;\n",
    "        elseif myseed[j] < bbox[sym][1]\n",
    "            myseed[j] =bbox[sym][1]+0.1;\n",
    "        end\n",
    "        else\n",
    "            myseed[j] = seed[j];\n",
    "        end\n",
    "    end\n",
    "\n",
    "    # define opto function with just value output\n",
    "    func =  (;params...) -> JJ(model_params[:nPro], model_params[:nAnti]; \n",
    "        rule_and_delay_periods=rule_and_delay_periods, \n",
    "        theta1=model_params[:theta1], theta2=model_params[:theta2], \n",
    "        post_target_periods=post_target_periods, seedrand=sr, cbeta=cb, \n",
    "        verbose=false, merge(model_params, Dict(params))...)[1]\n",
    "    \n",
    "    # run optimization with all parameters\n",
    "    @printf(\"Going with seed = \"); print_vector_g(myseed); print(\"\\n\")\n",
    "    pars, traj, cost, cpm_traj = bbox_Hessian_keyword_minimization(myseed, args, bbox, func, start_eta = 1, tol=1e-12, verbose=true, verbose_every=10, maxiter=num_optimize_iter)\n",
    "    @printf(\"Came out with cost %g and pars = \", cost); print_vector_g(pars); print(\"\\n\\n\")\n",
    "\n",
    "    # get gradient and hessian at end of optimization \n",
    "    value, grad, hess = keyword_vgh(func, args, pars)\n",
    "\n",
    "    # define function with all outputs, evaluate on training noise\n",
    "    t_standard_func =  (;params...) -> JJ_opto(model_params[:nPro], model_params[:nAnti]; rule_and_delay_periods=rule_and_delay_periods, theta1=model_params[:theta1], theta2=model_params[:theta2], post_target_periods=post_target_periods, seedrand=sr, cbeta=cb, verbose=false, merge(model_params, Dict(params))...)\n",
    "\n",
    "    # run opto model with all outputs, evaluate on training noise\n",
    "    t_opto_scost, t_opto_scost1, t_opto_scost2, t_opto_hitsP,t_opto_hitsA, t_opto_diffsP, t_opto_diffsA, t_opto_bP, t_opto_bA = t_standard_func(;make_dict(args, pars, model_params)...)\n",
    "    \n",
    "   ## evaluate for long form info\n",
    "    # reset random number generator for testing purposes\n",
    "    test_sr = convert(Int64, round(time()))\n",
    "    srand(test_sr); \n",
    "\n",
    "    # define function with all outputs, evaluate on test noise\n",
    "    standard_func =  (;params...) -> JJ_opto(num_eval_runs, num_eval_runs; rule_and_delay_periods=rule_and_delay_periods, theta1=model_params[:theta1], theta2=model_params[:theta2], post_target_periods=post_target_periods, seedrand=test_sr, cbeta=cb, verbose=false, merge(model_params, Dict(params))...)\n",
    "\n",
    "    # run opto model with all outputs, evaluate on test noise\n",
    "    opto_scost, opto_scost1, opto_scost2, opto_hitsP,opto_hitsA, opto_diffsP, opto_diffsA, opto_bP, opto_bA = standard_func(;make_dict(args, pars, model_params)...)\n",
    "\n",
    "   ## Save this run out to a file\n",
    "    # get filename\n",
    "    myfilename = next_file(fbasename, 4)\n",
    "    myfilename = myfilename*\".mat\"\n",
    "    # write file\n",
    "    matwrite(myfilename, Dict(\"args\"=>args, \"myseed\"=>myseed, \"pars\"=>pars, \"traj\"=>traj, \"cost\"=>cost, \"cpm_traj\"=>cpm_traj, \"nPro\"=>model_params[:nPro], \"nAnti\"=>model_params[:nAnti], \"sr\"=>sr, \"cb\"=>cb, \"theta1\"=>model_params[:theta1], \"theta2\"=>model_params[:theta2],\"value\"=>value,\"grad\"=>grad, \"hess\"=>hess, \"model_params\"=>ascii_key_ize(model_params), \"bbox\"=>ascii_key_ize(bbox), \"sbox\"=>ascii_key_ize(sbox), \"rule_and_delay_periods\"=>rule_and_delay_periods, \"post_target_periods\"=>post_target_periods, \"opto_scost\"=>opto_scost, \"opto_scost1\"=>opto_scost1, \"opto_scost2\"=>opto_scost2, \"opto_hitsP\"=>opto_hitsP, \"opto_hitsA\"=>opto_hitsA, \"opto_diffsP\"=>opto_diffsP, \"opto_diffsA\"=>opto_diffsA,\"test_sr\"=>test_sr,\"opto_bP\"=>opto_bP, \"opto_bA\"=>opto_bA, \"t_opto_scost\"=>t_opto_scost, \"t_opto_scost1\"=>t_opto_scost1, \"t_opto_scost2\"=>t_opto_scost2, \"t_opto_hitsP\"=>t_opto_hitsP, \"t_opto_hitsA\"=>t_opto_hitsA, \"t_opto_diffsP\"=>t_opto_diffsP, \"t_opto_diffsA\"=>t_opto_diffsA,\"t_opto_bP\"=>t_opto_bP, \"t_opto_bA\"=>t_opto_bA,\"dista\"=>dista  ))\n",
    "end\n",
    "end\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "using HypothesisTests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "N = 20\n",
    "x = 1+0.2*randn(N,1); y = x - 0.05 + 0.1*randn(N,1);\n",
    "\n",
    "\n",
    "using PyPlot\n",
    "pygui(true)\n",
    "\n",
    "figure(1); clf();\n",
    "subplot(1,2,1)\n",
    "\n",
    "for i=1:N\n",
    "    plot([1, 2], [x[i], y[i]], \"b.-\")\n",
    "end\n",
    "\n",
    "p = pvalue(OneSampleTTest(x[:], y[:]))\n",
    "\n",
    "title(\"Paired t-test :  p<\" * @sprintf(\"%.4g\", p))\n",
    "\n",
    "\n",
    "subplot(1,2,2)\n",
    "plot(x-y, \"b.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Marino's model in Marino's parameter settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#@include_me  scaling_up_dt.jl\n",
    "\n",
    "# In its own cell so we can run it just once\n",
    "\n",
    "include(\"pro_anti.jl\")   # Loads all the necessary pre-requisites\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#@include_me  scaling_up_dt.jl\n",
    "\n",
    "model_params, F, nPro, nAnti = load_run(\"farm_LD0003\"; farmdir=\"goodfarms\")\n",
    "\n",
    "# mypars = merge(model_params, Dict(:post_target_periods=>0.05))\n",
    "\n",
    "cost, cost1s, cost2s, hP, hA, dP, dA, hBP, hBA, proValls, antiValls, opto_fraction, pro_input, anti_input = \n",
    "JJ(model_params[:nPro], model_params[:nAnti]; verbose=true, model_details=true, model_params...);\n",
    "\n",
    "\n",
    "epochs = [\"control\";\"full\";\"rule\";\"delay\";\"choice\"]\n",
    "titles  = [\"epochs\" \"hitP\" \"hitA\" \"diffP\" \"diffA\" \"hBP\" \"hBA\"]\n",
    "\n",
    "@printf(\"\\n\\n--- The original run:\\n\\n\")\n",
    "\n",
    "sleep(0.5)  # A pause just to make sure everything has printed out \n",
    "display([titles; epochs hP hA dP dA hBP hBA])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#@include_me  scaling_up_dt.jl\n",
    "\n",
    "# Now scale things to make dt and tau are much larger, and involve 0.25 x the timesteps\n",
    "\n",
    "mypars = merge(model_params, Dict(:opto_times=>[0 0]))  # default is no opto\n",
    "\n",
    "mypars = merge(model_params, Dict(\n",
    ":dt=>0.024,\n",
    ":tau=>0.09,\n",
    ":rule_and_delay_period=>1.2,\n",
    ":target_period=>0.3,\n",
    ":post_target_period=>0.3,\n",
    ":anti_rule_strength=>0.054,\n",
    "# :post_target_period=>0.05, \n",
    "# :rule_and_delay_period=>0.8, \n",
    "# :opto_times=>[0 0],\n",
    "# :opto_times=>[\"target_start/2\" \"target_start\"],\n",
    "# :opto_times=>[\"target_start\", \"target_end\"],\n",
    ":opto_strength=>0.85,\n",
    "))# , :rule_and_delay_period=>0.8))\n",
    "\n",
    "\n",
    "mypars[:rule_and_delay_periods] = [mypars[:rule_and_delay_period]]\n",
    "mypars[:target_periods]         = [mypars[:target_period]]\n",
    "mypars[:post_target_periods]    = [mypars[:post_target_period]]\n",
    "\n",
    "mypars[:opto_periods] = [\n",
    "    \"trial_start\"     \"trial_start\"  ;\n",
    "    \"trial_start\"     \"trial_end\"    ; \n",
    "    \"trial_start\"     \"target_start/2\"  ;\n",
    "    \"target_start/2\"  \"target_start\"  ;\n",
    "    \"target_start\"    \"target_end\"\n",
    "];\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#@include_me  scaling_up_dt.jl\n",
    "\n",
    "# And run with these params.  \n",
    "\n",
    "# We run 1000 trials of Pro and ANti each, just to get a good estimate of probability correct in each condition\n",
    "\n",
    "mypars[:seedrand] = Int64(round(time()*1000))\n",
    "\n",
    "ntrials = 1000\n",
    "\n",
    "cost, cost1s, cost2s, hP, hA, dP, dA, hBP, hBA, proValls, antiValls, opto_fraction, pro_input, anti_input = \n",
    "JJ(ntrials, ntrials; verbose=true, model_details=true, mypars...);\n",
    "\n",
    "@printf(\"\\n\\n--- The hand-modified run at dt=0.024 at 4x fewer timesteps than the original:\\n\\n\")\n",
    "\n",
    "\n",
    "sleep(0.5)  # A pause just to make sure everything has printed out \n",
    "display([titles; epochs hP hA dP dA hBP hBA])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#@include_me  scaling_up_dt.jl\n",
    "\n",
    "# Finally, display some trajectories:\n",
    "\n",
    "pygui(true)\n",
    "\n",
    "# This example is with opto during the delay\n",
    "\n",
    "mypars = merge(mypars, Dict(\n",
    "# :opto_times => [\"target_start/2\"    \"target_start\"],\n",
    ":opto_times => [0    0],\n",
    ":sigma=>0.01\n",
    "))\n",
    "\n",
    "\n",
    "proVs, antiVs, pro_fullV, anti_fullV, opto_fraction, pro_input, anti_input = run_ntrials(1000, 1000; \n",
    "    plot_list=[1:40;], profig=1, antifig=2, opto_units = 1:4, mypars...);\n",
    "\n",
    "Np = size(proVs,2); Na = size(antiVs,2)\n",
    "@printf(\"hBP = %g, hBA = %g\\n\", length(find(proVs[1,:] .>= proVs[4,:]))/Np, length(find(antiVs[4,:] .> antiVs[1,:]))/Na)\n",
    "\n",
    "@printf(\"\\n\\n\\n---\\n\\nmypars contains all the parameters for the new run with the scaled up dt, tau, etc.\\n\\n\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mypars[:dt]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Print out mypars in full\n",
    "@printf(\"\\n\\nmypars = Dict(\\n\")\n",
    "for (k,v) in mypars\n",
    "    @printf(\":%s => \", k); print(v); print(\",\\n\")\n",
    "end\n",
    "@printf(\")\\n\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Make a set of reduced nsteps params and run with them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\n",
    "mypars = Dict(\n",
    ":init_add               =>          0,\n",
    ":const_add              =>          0,\n",
    ":noise                  =>          Any[],\n",
    ":input                  =>          0,\n",
    ":seedrand               =>          1510340076445,\n",
    ":start_anti             =>          [-0.5, -0.5, -0.5, -0.5],\n",
    ":start_pro              =>          [-0.5, -0.5, -0.5, -0.5],\n",
    ":rule_and_delay_period  =>          1.2,\n",
    ":rule_and_delay_periods =>          [1.2],\n",
    ":target_period          =>          0.3,\n",
    ":target_periods         =>          [0.3],\n",
    ":post_target_period     =>          0.3,\n",
    ":post_target_periods    =>          [0.3],\n",
    ":anti_rule_strength     =>          0.054,\n",
    ":U_rest                 =>          0,\n",
    ":theta                  =>          0.05,\n",
    ":beta                   =>          0.5,\n",
    ":g_leak                 =>          1,\n",
    ":nsteps                 =>          301,\n",
    ":dt                     =>          0.024,\n",
    ":tau                    =>          0.09,\n",
    ":right_light_excitation =>          0.49924152955481954,\n",
    ":opto_strength          =>          0.85,\n",
    ":opto_periods           =>          String[\n",
    "                                    \"trial_start\" \"trial_start\"; \n",
    "                                    \"trial_start\" \"trial_end\"; \n",
    "                                    \"trial_start\" \"target_start/2\"; \n",
    "                                    \"target_start/2\" \"target_start\"; \n",
    "                                    \"target_start\" \"target_end\"],\n",
    ":opto_targets          =>           [\n",
    "                                    0.9 0.7; \n",
    "                                    0.9 0.5; \n",
    "                                    0.9 0.7; \n",
    "                                    0.9 0.5; \n",
    "                                    0.9 0.7],\n",
    ":theta2 => 0.15,\n",
    ":theta1 => 0.05,\n",
    ":sigma => 0.01,\n",
    ":cbeta => 0.04,\n",
    ":sW => 0.6416875048295452,\n",
    ":hW => 0.054701836208134846,\n",
    ":dW => 0.1267124266934907,\n",
    ":vW => -1.588850577499782,\n",
    ":constant_excitation => -0.37242520737694207,\n",
    ":const_pro_bias => 0.04366897857834884,\n",
    ":target_period_excitation => 0.15315254453690974,\n",
    ":right_light_pro_extra => 0,\n",
    ":pro_rule_strength => 0.05,\n",
    ":nPro => 100,\n",
    ":nAnti => 100,\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\n",
    "extra_pars = Dict(\n",
    ":plot_list        =>   [1:5;], \n",
    ":plot_conditions  =>   true,\n",
    ":verbose          =>   true,\n",
    ":opto_periods     =>   String[\"trial_start\" \"trial_start\"],\n",
    ":opto_targets     =>   [0.9,  0.7],\n",
    ":opto_times       =>   [\"trial_start\", \"trial_start\"],       # This one is for run_ntrials\n",
    ":seedrand         =>   Int64(round(time()*1000)),\n",
    ")\n",
    "\n",
    "\n",
    "# proVs, antiVs, pro_fullV, anti_fullV, opto_fraction, pro_input, anti_input = run_ntrials(1000, 1000; \n",
    "#    merge(mypars, extra_pars)...);\n",
    "\n",
    "\n",
    "JJ(mypars[:nPro], mypars[:nAnti]; merge(mypars, extra_pars)...)[1]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "extra_pars[:search_range] = 0.4\n",
    "extra_pars"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Try a search : reduced_farm.jl\n",
    "\n",
    "`Temp/answers.jld`   contains the result of taking the result of scaling_up_dt.jl, and then optimizing it on control alone, with Pro target=0.9, Anti target = 0.7.  It optimizes very very well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#@include_me reduced_farm.jl\n",
    "\n",
    "include(\"pro_anti.jl\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "@load(\"FarmFields/farm_C3_0027.jld\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "[args pars]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mypars[:tau]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#@include_me reduced_farm.jl\n",
    "\n",
    "\n",
    "mypars = Dict(\n",
    ":init_add               =>          0,\n",
    ":const_add              =>          0,\n",
    ":noise                  =>          Any[],\n",
    ":input                  =>          0,\n",
    ":start_anti             =>          [-0.5, -0.5, -0.5, -0.5],\n",
    ":start_pro              =>          [-0.5, -0.5, -0.5, -0.5],\n",
    ":rule_and_delay_period  =>          1.2,\n",
    ":rule_and_delay_periods =>          [1.2],\n",
    ":target_period          =>          0.3,\n",
    ":target_periods         =>          [0.3],\n",
    ":post_target_period     =>          0.3,\n",
    ":post_target_periods    =>          [0.3],\n",
    ":anti_rule_strength     =>          0.054,\n",
    ":U_rest                 =>          0,\n",
    ":theta                  =>          0.05,\n",
    ":beta                   =>          0.5,\n",
    ":g_leak                 =>          1,\n",
    ":nsteps                 =>          301,\n",
    ":dt                     =>          0.024,\n",
    ":tau                    =>          0.09,\n",
    ":right_light_excitation =>          0.49924152955481954,\n",
    ":opto_strength          =>          0.85,\n",
    ":opto_periods           =>          String[\n",
    "                                    \"trial_start\" \"trial_start\"; \n",
    "                                    \"trial_start\" \"trial_end\"; \n",
    "                                    \"trial_start\" \"target_start/2\"; \n",
    "                                    \"target_start/2\" \"target_start\"; \n",
    "                                    \"target_start\" \"target_end\"],\n",
    ":opto_targets          =>           [\n",
    "                                    0.9 0.7; \n",
    "                                    0.9 0.5; \n",
    "                                    0.9 0.7; \n",
    "                                    0.9 0.5; \n",
    "                                    0.9 0.7],\n",
    ":theta2 => 0.15,\n",
    ":theta1 => 0.05,\n",
    ":sigma => 0.01,\n",
    ":cbeta => 0.04,\n",
    ":sW => 0.6416875048295452,\n",
    ":hW => 0.054701836208134846,\n",
    ":dW => 0.1267124266934907,\n",
    ":vW => -1.588850577499782,\n",
    ":constant_excitation => -0.37242520737694207,\n",
    ":const_pro_bias => 0.04366897857834884,\n",
    ":target_period_excitation => 0.15315254453690974,\n",
    ":right_light_pro_extra => 0,\n",
    ":pro_rule_strength => 0.05,\n",
    ":nPro => 100,\n",
    ":nAnti => 100,\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#@include_me  reduced_farm.jl\n",
    "\n",
    "\n",
    "extra_pars = Dict(\n",
    ":plot_list        =>   [], \n",
    ":plot_conditions  =>   true,\n",
    ":verbose          =>   true,\n",
    ":opto_periods     =>   String[\"trial_start\" \"trial_start-0.1\"],\n",
    ":opto_targets     =>   [0.9,  0.7],\n",
    ":opto_times       =>   [\"trial_start\", \"trial_start-0.1\"],       # This one is for run_ntrials\n",
    ":cbeta            =>   0.001,\n",
    ":search_range     =>   1.2,\n",
    ")\n",
    "\n",
    "\n",
    "search_conditions = Dict(   # :param    default_start   search_box  bound_box\n",
    ":vW     =>                   [mypars[:vW],                       [-0.5, 0.5],  [-3,   3]], \n",
    ":hW     =>                   [mypars[:hW],                       [-0.5, 0.5],  [-3,   3]],\n",
    ":dW     =>                   [mypars[:dW],                       [-0.5, 0.5],  [-3,   3]],\n",
    ":sW     =>                   [mypars[:sW],                       [0,    0.5],  [0,    3]],\n",
    ":sigma  =>                   [0.11,                              [0.1,  0.2],  [0.1, 0.4]],\n",
    ":constant_excitation      => [mypars[:constant_excitation],      [-1,     1],  [-2,   2]], \n",
    ":target_period_excitation => [mypars[:target_period_excitation], [0.001,0.5],  [0     4]],\n",
    ":right_light_excitation   => [mypars[:right_light_excitation],   [0.05, 0.5],  [0.05, 4]],\n",
    ":const_pro_bias           => [mypars[:const_pro_bias],           [-0.5, 0.5],  [-2,   2]],\n",
    "# :opto_strength            => [mypars[:opto_strength],            [0.7, 0.99],  [0,    1]],\n",
    ")\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loop for reduced_farm.jl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#@include_me  reduced_farm.jl\n",
    "\n",
    "extra_pars[:seedrand] = Int64(round(time()*1000))\n",
    "srand(extra_pars[:seedrand])\n",
    "\n",
    "@printf(\"\\n\\n\\nStarting with random seed %d\\n\\n\\n\", extra_pars[:seedrand])\n",
    "\n",
    "search_range = extra_pars[:search_range]; \n",
    "\n",
    "fbasename = \"FarmFields/farm_C5_\"\n",
    "\n",
    "while true\n",
    "    args = []; seed = []; bbox = Dict()\n",
    "    for k in keys(search_conditions)\n",
    "        search_box = search_conditions[k][2]\n",
    "        args = [args; String(k)]\n",
    "        myseed = search_conditions[k][1] + search_range*(rand()-0.5)*diff(search_box); myseed = myseed[1]\n",
    "        if myseed > search_box[2]; myseed = search_box[2]; end\n",
    "        if myseed < search_box[1]; myseed = search_box[1]; end\n",
    "        seed = [seed ;  myseed]\n",
    "        # seed = [seed ; search_conditions[k][1]]\n",
    "        bbox = merge(bbox, Dict(k => Array{Float64}(search_conditions[k][3])))\n",
    "    end\n",
    "    args = Array{String}(args)\n",
    "    seed = Array{Float64}(seed)\n",
    "\n",
    "\n",
    "    # Make sure to keep the noise frozen over the search, meaning JJ() needs the seedrand parameter\n",
    "    func =  (;params...) -> JJ(mypars[:nPro], mypars[:nAnti]; verbose=true, \n",
    "        merge(merge(mypars, extra_pars), Dict(params))...)[1]\n",
    "\n",
    "    try\n",
    "        pars, traj, cost, cpm_traj, ftraj = bbox_Hessian_keyword_minimization(seed, args, bbox, func, \n",
    "            start_eta = 0.1, tol=1e-12, \n",
    "            verbose=true, verbose_every=1, maxiter=1000)\n",
    "\n",
    "\n",
    "        cost, cost1s, cost2s, hP, hA, dP, dA, hBP, hBA = JJ(1000, 1000; verbose=false, \n",
    "        make_dict(args, pars, merge(merge(mypars, extra_pars)))...)\n",
    "\n",
    "        myfilename = next_file(fbasename, 4)\n",
    "        myfilename = myfilename*\".jld\"\n",
    "        # write file\n",
    "        save(myfilename, Dict(\"nPro\"=>mypars[:nPro], \"nAnti\"=>mypars[:nAnti], \n",
    "        \"mypars\"=>mypars, \"extra_pars\"=>extra_pars, \"args\"=>args, \"seed\"=>seed, \"bbox\"=>bbox, \n",
    "        \"pars\"=>pars, \"traj\"=>traj, \"cost\"=>cost, \"cpm_traj\"=>cpm_traj, \"ftraj\"=>ftraj,\n",
    "        \"hP\"=>hP, \"hA\"=>hA, \"dP\"=>dP, \"dA\"=>dA, \"hBP\"=>hBP, \"hBA\"=>hBA))\n",
    "    catch y\n",
    "        if isa(y, InterruptException); throw(InterruptException()); end\n",
    "        @printf(\"\\n\\nWhoopsety, unkown error!\\n\\n\");\n",
    "        @printf(\"Error was :\\n\"); print(y); @printf(\"\\n\\nTrying new random seed.\\n\\n\")\n",
    "    end\n",
    "\n",
    "    # Change the frozen noise random seed so we don't get stuck in one loop    \n",
    "    extra_pars[:seedrand] = extra_pars[:seedrand]+1\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "effective_search_box = Dict()\n",
    "for k in keys(search_conditions)\n",
    "    search_box = search_conditions[k][2]\n",
    "    ebox = zeros(1,2)\n",
    "    ebox[1] = search_conditions[k][1] - 0.5*diff(search_box)[1]\n",
    "    ebox[2] = search_conditions[k][1] + 0.5*diff(search_box)[1]\n",
    "    effective_search_box[k] = ebox\n",
    "end\n",
    "\n",
    "effective_search_box"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# Analyze a Marino goodfarm:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "include(\"pro_anti.jl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "hBP, hBA, d = show_run(\"farm_LA0001.mat\", 100; farmdir=\"goodfarms\", opto_times=[\"target_start-0.2\", \"target_start\"], \n",
    "const_pro_bias = 0.0, opto_strength = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "model_params = symbol_key_ize(d[\"model_params\"])\n",
    "[d[\"args\"] d[\"pars\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "show_run(\"farm_LD0053.mat\", 100; farmdir=\"goodfarms\", opto_times=[\"target_start-2\", \"target_end-2\"],\n",
    "    const_pro_bias=0.04745, rule_and_delay_period=0.4, right_light_excitation=0.4)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "model_params, F, nPro, nAnti = load_run(\"farm_LD0053.mat\"; farmdir=\"goodfarms\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "[F[\"args\"] F[\"pars\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "model_params[:opto_periods] = [\n",
    "    \"trial_start-0.1\"   \"trial_start-0.1\"; \n",
    "    \"trial_start\"       \"trial_end\" ; \n",
    "    \"trial_start\"       \"trial_start+0.2\" ; \n",
    "    \"target_start-0.2\"  \"target_start\"  ;\n",
    "    \"target_start\"      \"trial_end\"\n",
    "]\n",
    "\n",
    "model_params[:opto_targets]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "pygui(true)\n",
    "cost, cost1s, cost2s, hP, hA, dP, dA, hBP, hBA, proValls, antiValls = JJ(100, 100; plot_list=[1:10;], \n",
    "    plot_conditions=[false, false, false, true, false], verbose=true, model_details=true, model_params...);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "include(\"farm_plotting_carlos.jl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "show_run(\"farm_C3_0002.jld\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "figure(1); subplot(3,1,1); title(@sprintf(\"%s: binarized Pro  hits = %.1f %%\\n\", run_name, 97.3))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# @save \"Temp/answers.jld\" \n",
    "# @load \"Temp/answers.jld\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "@load \"Temp/answers3.jld\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "[args pars seed]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "pygui(true)\n",
    "figure(1); clf();\n",
    "\n",
    "delete!(extra_pars, :plot_list)\n",
    "delete!(extra_pars, :seedrand)\n",
    "\n",
    "more_pars = Dict(\n",
    "# :post_target_period => 0.25,\n",
    ":rule_and_delay_period => 2,\n",
    ")\n",
    "proVs, antiVs = run_ntrials(1000, 1000; plot_list=[1:10;], make_dict(args, pars, merge(merge(mypars, extra_pars), more_pars))...)[1:2]\n",
    "\n",
    "@printf(\"Binarized Pro hits = %.1f %%\\n\", 100*length(find(proVs[1,:] .> proVs[4,:]))/size(proVs,2))\n",
    "@printf(\"Binarized Anti hits = %.1f %%\\n\", 100*length(find(antiVs[4,:] .> antiVs[1,:]))/size(antiVs,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "search_conditions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "include(\"pro_anti.jl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "bbox[:dW]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "[1, [2,3], 4]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#  size(proValls)  (4, 301, 100, 5)\n",
    "\n",
    "figure(3); clf(); N=40\n",
    "\n",
    "t = 0:size(proValls, 2)-1; t = model_params[:dt]*t\n",
    "\n",
    "figure(3); clf();\n",
    "for i=1:N \n",
    "    plot_PA(t, 0, proValls[:,:,i,1], fignum=3, plot_Us=false,\n",
    "    rule_and_delay_period=model_params[:rule_and_delay_period], target_period=model_params[:target_period],\n",
    "    post_target_period = model_params[:post_target_period])\n",
    "end\n",
    "\n",
    "figure(4); clf();\n",
    "for i=1:N \n",
    "    plot_PA(t, 0, antiValls[:,:,i,1], fignum=4, plot_Us=false,\n",
    "    rule_and_delay_period=model_params[:rule_and_delay_period], target_period=model_params[:target_period],\n",
    "    post_target_period = model_params[:post_target_period])\n",
    "end\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(model_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Define core model parameters\n",
    "model_params = Dict(\n",
    ":dt     =>  0.002, \n",
    ":tau    =>  0.02, \n",
    ":vW     =>  -1.58,\n",
    ":hW     =>  -0.05,\n",
    ":sW     =>  0,\n",
    ":dW     =>  0,\n",
    ":nsteps =>  301, \n",
    ":noise  =>  [], \n",
    ":sigma  =>  0.08, \n",
    ":input  =>  0, \n",
    ":g_leak =>  1, \n",
    ":U_rest =>  0,\n",
    ":theta  =>  0.05, \n",
    ":beta   =>  0.5, \n",
    ":constant_excitation      => 0, \n",
    ":anti_rule_strength       => 0.05,\n",
    ":pro_rule_strength        => 0.05, \n",
    ":target_period_excitation => 0,\n",
    ":right_light_excitation   => 0.6, \n",
    ":right_light_pro_extra    => 0,\n",
    ":const_add                => 0, \n",
    ":init_add                 => 0, \n",
    ":rule_and_delay_period    => 0.2,\n",
    ":target_period            => 0.1,\n",
    ":post_target_period       => 0.1,\n",
    ":const_pro_bias           => 0.0427,\n",
    ":nPro                     => 100,\n",
    ":nAnti                    => 100,\n",
    ":theta1                   => 0.05,\n",
    ":theta2                   => 0.15,\n",
    ":opto_strength  => .9,\n",
    ":opto_periods   => [\n",
    "    0               0 ; \n",
    "    0              \"trial_end\" ;\n",
    "    \"target_start/2\"  \"target_start\";\n",
    "    \"target_start\"    \"target_end\"],  \n",
    "# set of opto conditions, in seconds, with 0 the start \n",
    "# of the trial (i.e. start of rule_and_delay_period), anything before 0 or after end of trial gets ignored.\n",
    "#:opto_targets   => [.75 .73;.77 .58;.75 .74;.72 .66;.73 .75] \n",
    ":opto_targets => [\n",
    "    .9      .7; \n",
    "    .9      .5; \n",
    "    .9      .55; \n",
    "    .9      .7;\n",
    "    ],  # first column is frachit Pro, next column is Anti, rows are conditions\n",
    "# The \"conditions\" correspond to the rows of opto_periods.\n",
    ");\n",
    "\n",
    "\n",
    "# ======= ARGUMENTS AND SEED VALUES:\n",
    "args = [\"sW\", \"vW\", \"hW\", \"dW\", \"constant_excitation\", \"right_light_excitation\", \"target_period_excitation\"]\n",
    "seed = [0.001,  -1.58,   -0.05,  0.001,    0.001,                0.6,                       0.001]   \n",
    "args = [args ; [\"const_pro_bias\", \"sigma\",\"opto_strength\", \"pro_rule_strength\", \"anti_rule_strength\"]];\n",
    "seed = [seed ; [  0.0427,            .05,      .9,              0.05,                0.05]];\n",
    "\n",
    "# ======= BOUNDING BOX:\n",
    "bbox = Dict(:sW=>[0 3], :vW=>[-3 3], :hW=>[-3 3], :dW=>[-3 3], :constant_excitation=>[-2 2],\n",
    ":right_light_excitation=>[0.05 4], :target_period_excitation=>[0 4], :const_pro_bias=>[-2 2],\n",
    ":sigma=>[0.01 0.2],:opto_strength=>[0 1]);\n",
    "\n",
    "# ======== SEARCH ZONE:\n",
    "sbox = Dict(:sW=>[0 .5], :vW=>[-.5 .5], :hW=>[-.5 .5], :dW=>[-.5 .5],\n",
    ":constant_excitation=>[-.5 .5], :right_light_excitation=>[0.05 .5], :target_period_excitation=>[0.001 .5],:const_pro_bias=>[-.5 .5], :sigma=>[0.02 0.19],:opto_strength=>[.7 .99]);\n",
    "\n",
    "# define a few hyper parameters\n",
    "cbetas = [0.04];\n",
    "rule_and_delay_periods = [0.2];\n",
    "post_target_periods    = [0.1];\n",
    "num_eval_runs           = 100;\n",
    "num_optimize_iter       = 2000;\n",
    "num_optimize_restarts   = 1;\n",
    "\n",
    "\n",
    "cb = 0.04\n",
    "\n",
    "# figure out initial seed for random number generator\n",
    "sr = convert(Int64, round(time()))\n",
    "srand(sr);\n",
    "\n",
    "mypars = merge(model_params, Dict(:opto_times => [\"target_start\", \"target_end\"], :rule_and_delay_period=>0.2,\n",
    ":anti_rule_strength=>0.06))\n",
    "# mypars = merge(model_params, Dict(:opto_times => [0 0], :rule_and_delay_period=>0.1,\n",
    "# :anti_rule_strength=>0.06))\n",
    "pygui(true)\n",
    "proVs, antiVs, pro_fullV, anti_fullV, opto_fraction, pro_input, anti_input = run_ntrials(15, 15; \n",
    "plot_list=[1:15;], profig=1, antifig=2, opto_units = 1:4, mypars...)\n",
    "\n",
    "# define opto function with just value output\n",
    "func =  (;params...) -> JJ(model_params[:nPro], model_params[:nAnti]; \n",
    "    rule_and_delay_periods=rule_and_delay_periods, theta1=model_params[:theta1], theta2=model_params[:theta2], \n",
    "    post_target_periods=post_target_periods, seedrand=sr, cbeta=cb, verbose=true, \n",
    "    merge(mypars, Dict(params))...)[1]\n",
    "\n",
    "\n",
    "# cost, cost1s, cost2s, hP, hA, dP, dA, hBP, hBA = JJ(model_params[:nPro], model_params[:nAnti]; \n",
    "#     rule_and_delay_periods=rule_and_delay_periods, theta1=model_params[:theta1], theta2=model_params[:theta2], \n",
    "#     post_target_periods=post_target_periods, seedrand=sr, cbeta=cb, verbose=true, model_params...)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "@printf(\"Going with seed = \"); print_vector_g(seed); print(\"\\n\")\n",
    "pars, traj, cost, cpm_traj, ftraj = bbox_Hessian_keyword_minimization(seed, args, bbox, func, \n",
    "    start_eta = 1, tol=1e-12, verbose=true, verbose_every=1, maxiter=num_optimize_iter)\n",
    "@printf(\"Came out with cost %g and pars = \", cost); print_vector_g(pars); print(\"\\n\\n\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# run optimization with all parameters\n",
    "@printf(\"Going with seed = \"); print_vector_g(seed); print(\"\\n\")\n",
    "pars, traj, cost, cpm_traj, ftraj = bbox_Hessian_keyword_minimization(seed, args, bbox, func, \n",
    "    start_eta = 1, tol=1e-12, verbose=true, verbose_every=1, maxiter=num_optimize_iter)\n",
    "@printf(\"Came out with cost %g and pars = \", cost); print_vector_g(pars); print(\"\\n\\n\")\n",
    "\n",
    "    # get gradient and hessian at end of optimization \n",
    "    value, grad, hess = keyword_vgh(func, args, pars)\n",
    "\n",
    "    # define function with all outputs, evaluate on training noise\n",
    "    t_standard_func =  (;params...) -> JJ_opto(model_params[:nPro], model_params[:nAnti]; rule_and_delay_periods=rule_and_delay_periods, theta1=model_params[:theta1], theta2=model_params[:theta2], post_target_periods=post_target_periods, seedrand=sr, cbeta=cb, verbose=false, merge(model_params, Dict(params))...)\n",
    "\n",
    "    # run opto model with all outputs, evaluate on training noise\n",
    "    t_opto_scost, t_opto_scost1, t_opto_scost2, t_opto_hitsP,t_opto_hitsA, t_opto_diffsP, t_opto_diffsA, t_opto_bP, t_opto_bA = t_standard_func(;make_dict(args, pars, model_params)...)\n",
    "    \n",
    "   ## evaluate for long form info\n",
    "    # reset random number generator for testing purposes\n",
    "    test_sr = convert(Int64, round(time()))\n",
    "    srand(test_sr); \n",
    "\n",
    "    # define function with all outputs, evaluate on test noise\n",
    "    standard_func =  (;params...) -> JJ_opto(num_eval_runs, num_eval_runs; rule_and_delay_periods=rule_and_delay_periods, theta1=model_params[:theta1], theta2=model_params[:theta2], post_target_periods=post_target_periods, seedrand=test_sr, cbeta=cb, verbose=false, merge(model_params, Dict(params))...)\n",
    "\n",
    "    # run opto model with all outputs, evaluate on test noise\n",
    "    opto_scost, opto_scost1, opto_scost2, opto_hitsP,opto_hitsA, opto_diffsP, opto_diffsA, opto_bP, opto_bA = standard_func(;make_dict(args, pars, model_params)...)\n",
    "\n",
    "    # define non-opto model with all outputs, to check opto model, evaluate on test noise\n",
    "    standard_func =  (;params...) -> JJ(num_eval_runs, num_eval_runs; rule_and_delay_periods=rule_and_delay_periods, theta1=model_params[:theta1], theta2=model_params[:theta2], post_target_periods=post_target_periods, seedrand=test_sr, cbeta=cb, verbose=false, merge(model_params, Dict(params))...)\n",
    "\n",
    "    # run non-opto model with all outputs, evaluate on test noise\n",
    "    scost, scost1, scost2, hitsP,hitsA, diffsP, diffsA = standard_func(;make_dict(args, pars, model_params)...)\n",
    " \n",
    "   ## Save this run out to a file\n",
    "    # get filename\n",
    "    myfilename = next_file(fbasename, 4)\n",
    "    myfilename = myfilename*\".mat\"\n",
    "    # write file\n",
    "    matwrite(myfilename, Dict(\"args\"=>args, \"myseed\"=>myseed, \"dista\"=>dista, \"pars\"=>pars, \"traj\"=>traj, \"cost\"=>cost, \"cpm_traj\"=>cpm_traj, \"nPro\"=>model_params[:nPro], \"nAnti\"=>model_params[:nAnti], \"sr\"=>sr, \"cb\"=>cb, \"theta1\"=>model_params[:theta1], \"theta2\"=>model_params[:theta2],\"value\"=>value,\"grad\"=>grad, \"hess\"=>hess, \"scost\"=>scost, \"scost1\"=>scost1, \"scost2\"=>scost2, \"hitsP\"=>hitsP,\"hitsA\"=>hitsA, \"diffsP\"=>diffsP, \"diffsA\"=>diffsA, \"model_params\"=>ascii_key_ize(model_params), \"bbox\"=>ascii_key_ize(bbox), \"sbox\"=>ascii_key_ize(sbox), \"rule_and_delay_periods\"=>rule_and_delay_periods, \"post_target_periods\"=>post_target_periods, \"opto_scost\"=>opto_scost, \"opto_scost1\"=>opto_scost1, \"opto_scost2\"=>opto_scost2, \"opto_hitsP\"=>opto_hitsP, \"opto_hitsA\"=>opto_hitsA, \"opto_diffsP\"=>opto_diffsP, \"opto_diffsA\"=>opto_diffsA,\"test_sr\"=>test_sr,\"opto_bP\"=>opto_bP, \"opto_bA\"=>opto_bA, \"t_opto_scost\"=>t_opto_scost, \"t_opto_scost1\"=>t_opto_scost1, \"t_opto_scost2\"=>t_opto_scost2, \"t_opto_hitsP\"=>t_opto_hitsP, \"t_opto_hitsA\"=>t_opto_hitsA, \"t_opto_diffsP\"=>t_opto_diffsP, \"t_opto_diffsA\"=>t_opto_diffsA,\"t_opto_bP\"=>t_opto_bP, \"t_opto_bA\"=>t_opto_bA  ))\n",
    "end\n",
    "end"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 0.6.0",
   "language": "julia",
   "name": "julia-0.6"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "0.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}