minimal_param_sweep.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Source: https://github.com/cadCAD-org/snippets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip install seaborn plotly "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from cadCAD.configuration import Experiment\n",
    "from cadCAD.configuration.utils import config_sim\n",
    "from cadCAD.configuration import Configuration\n",
    "from cadCAD.engine import ExecutionMode, ExecutionContext, Executor\n",
    "import pandas as pd\n",
    "from cadcadgolem.golem_embassy import Ambassador\n",
    "\n",
    "import plotly.express as px\n",
    "import plotly.io as pio\n",
    "#pio.renderers.default = \"jupyterlab\"\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def p_something(params,\n",
    "                substep,\n",
    "                state_history,\n",
    "                prev_state):\n",
    "    parameter = params['parameter']\n",
    "    random_value_1 = parameter\n",
    "    random_value_2 = np.random.randn() \n",
    "    return {'policy_input_1': random_value_1,\n",
    "            'policy_input_2': random_value_2}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def s_something(params,\n",
    "                substep,\n",
    "                state_history,\n",
    "                prev_state,\n",
    "                policy_input):\n",
    "    new_value = policy_input['policy_input_1']\n",
    "    new_value += policy_input['policy_input_2']\n",
    "    return ('something', new_value)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "partial_state_update_blocks = [\n",
    "    {\n",
    "        'policies': {\n",
    "            'something': p_something\n",
    "\n",
    "        },\n",
    "        'variables': {\n",
    "            'something': s_something\n",
    "        }\n",
    "    }\n",
    "]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from cadCAD import configs\n",
    "del configs[:]\n",
    "\n",
    "MONTE_CARLO_RUNS = 100\n",
    "SIMULATION_TIMESTEPS =200 \n",
    "\n",
    "sys_params = {\n",
    "'parameter': np.linspace(0,30,5), #[0.1, 0.2, 0.3],\n",
    "}\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "genesis_states = {\n",
    "    'something': 0\n",
    "}\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "sim_config = {\n",
    "    'N': MONTE_CARLO_RUNS,\n",
    "    'T': range(SIMULATION_TIMESTEPS),\n",
    "    'M': sys_params\n",
    "}\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "sim_params = config_sim(sim_config)\n",
    "\n",
    "exp = Experiment()\n",
    "exp.append_configs(\n",
    "    sim_configs=sim_params,\n",
    "    initial_state=genesis_states,\n",
    "    partial_state_update_blocks=partial_state_update_blocks\n",
    ")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "golem_conf = {\n",
    "        'NODES': 10, # Number of nodes to utilise from the Golem Network. If you've got a big simulation to run, try pushing this up to 30. Remember you need at least twice as many simulation runs as you have nodes.\n",
    "        'BUDGET': 10.0, # Maximum amount of crypto you are prepared to spend\n",
    "        'SUBNET': \"community.3\", # choose your subnet, currently this is the test network\n",
    "#        'SUBNET': \"devnet-alpha.3\",\n",
    "        'YAGNA_APPKEY':'517fa9720e9f43a7af2325a92b401e3e', # get this from `yagna app-key list`\n",
    "        'TIMEOUT': 120 # In seconds - you will need to figure this out for your workload. Max currently is 25min, so 25 * 60 seconds\n",
    "        }\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "Executor = Ambassador(Executor, golem_conf)\n",
    "exec_context = ExecutionContext()\n",
    "simulation = Executor(exec_context=exec_context, configs=configs)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[33;1m===================================================================\n",
      "Initiating Negotiations With Golem Network\n",
      "===================================================================\n",
      "Patience you must have.\n",
      "See your Jupyter server terminal/log for realtime details\n",
      "This is a good time to go think about what TIMEOUT you set.\n",
      "If you are not in a hurry, or you just don't know, you can\n",
      "set it up to 25 minutes.But note, that is 25 minutes per attempt.\n",
      "A server could stall, and hold you there for 25 minutes,\n",
      "before you let that workload go and go find another server.\n",
      "To stop this, you will have to kill your Jupyter Server.\n",
      "Just Ctrl-c (a few times) at the same place you're watching the logs.\n",
      "===================================================================\n",
      "\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "raw_system_events, tensor_field, sessions = simulation.execute()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame(raw_system_events)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(df)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig =px.scatter(df,\n",
    "    x='timestep',\n",
    "    y='something',\n",
    "    color='subset',\n",
    "    opacity=0.2\n",
    ")\n",
    "\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}