diff --git a/demos/ThreeSidedMarket.ipynb b/demos/ThreeSidedMarket.ipynb new file mode 100644 index 0000000..badf73a --- /dev/null +++ b/demos/ThreeSidedMarket.ipynb @@ -0,0 +1,893 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Three Sided Market Model" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from decimal import Decimal\n", + "from datetime import timedelta\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "%matplotlib inline\n", + "import pandas as pd\n", + "from tabulate import tabulate\n", + "\n", + "from __future__ import print_function\n", + "from ipywidgets import interact, interactive, fixed, interact_manual\n", + "import ipywidgets as widgets\n", + "from IPython.display import clear_output\n", + "\n", + "from SimCAD.configuration import Configuration\n", + "from SimCAD.configuration.utils import exo_update_per_ts, proc_trigger, bound_norm_random, \\\n", + " ep_time_step\n", + "from SimCAD.engine import ExecutionMode, ExecutionContext, Executor" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "sim_config = {\n", + " 'N': 1,\n", + " 'T': range(50)\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Environmental Processes" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "eta = 1\n", + "def tx_volume_generator(step, sL, s, _input):\n", + " y = 'tx_volume'\n", + " x = eta*s['tx_volume']\n", + " return (y, x)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "alpha = .999\n", + "beta = 1.0\n", + "def cost_of_production_generator(step, sL, s, _input):\n", + " y = 'cost_of_production'\n", + " x = alpha*s['cost_of_production']+beta\n", + " return (y, x)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "#log quadratic overhead model; parameters\n", + "a = 1.0\n", + "b = 1.0\n", + "c = 1.0\n", + "d = 0\n", + "def overhead_cost_generator(step, sL, s, _input):\n", + " #unit fiat\n", + " y = 'overhead_costs'\n", + " q = a+b*s['tx_volume']+c*s['volume_production']+d*s['tx_volume']*s['volume_production']\n", + " x = np.log(q)\n", + " return (y, x)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#State Variables" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "seed = {}\n", + "env_processes = {}\n", + "initial_condition = {\n", + " 'fiat_reserve': float(2000),#unit: fiat\n", + " 'token_reserve': float(2000),#unit: tok\n", + " 'token_supply': float(5000),#unit: tok\n", + " 'tx_volume': float(2000), #unit: fiat\n", + " 'txo_fiat': float(1000), #unit: fiat\n", + " 'txo_token': float(1000), #unit: tok\n", + " 'txi_fiat': float(1000), #unit: fiat\n", + " 'txi_token': float(1000), #unit: tok\n", + " 'conversion_rate': float(1), #unit: tok/fiat\n", + " 'cost_of_production': float(25), #unit: fiat/labor \n", + " 'volume_of_production': float(100), #unit: labor\n", + " 'timestamp': '2019-01-01 00:00:00'\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "#exogenous states\n", + "ts_format = '%Y-%m-%d %H:%M:%S'\n", + "t_delta = timedelta(days=0, minutes=0, seconds=1)\n", + "def time_model(step, sL, s, _input):\n", + " y = 'timestamp'\n", + " x = ep_time_step(s, dt_str=s['timestamp'], fromat_str=ts_format, _timedelta=t_delta)\n", + " return (y, x)\n", + "\n", + "exogenous_states = exo_update_per_ts(\n", + " {\n", + " 'timestamp': time_model\n", + " }\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "#Behavoirs (two types: controlled and uncontrolled)\n", + "#user behavoir is uncontrolled (estimated or modeled),\n", + "#governance policies are controlled (enforced)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#governance decision ~ system policy for token/fiat unit of value conversion\n", + "def conversion_policy(step, sL, s):\n", + " ncr = 1 #placeholder logic: fixed value\n", + " return {'new_conversion_rate': ncr}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#governance decision ~ determines the conditions or schedule of new tokens minted\n", + "\n", + "final_supply = 10000.0 #unit: tokens\n", + "release_rate = .01 #percent of remaining\n", + "\n", + "def mint_policy(step, sL, s):\n", + " mint = s['token_supply']\n", + " return {'new_conversion_rate': ncr}" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "invalid syntax (, line 4)", + "output_type": "error", + "traceback": [ + "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m4\u001b[0m\n\u001b[0;31m txi_fiat=\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" + ] + } + ], + "source": [ + "#these are uncontrollerd choices of users in the provider consumer\n", + "\n", + "def consumer_choice(step, sL, s):\n", + " #fiat paid by consumers\n", + " #note: balance of consumption vol covered in tokens (computed later)\n", + " txi_fiat= \n", + " return {'txi_fiat': txi_fiat}" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "invalid syntax (, line 4)", + "output_type": "error", + "traceback": [ + "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m4\u001b[0m\n\u001b[0;31m txo_fiat =\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" + ] + } + ], + "source": [ + "#these are uncontrollerd choices of users in the provider role\n", + "\n", + "def provider_choice(step, sL, s):\n", + " #fiat claimed by providers\n", + " #note: balance of provided vol covered in tokens (computed later)\n", + " txo_fiat = \n", + " return {'txo_fiat': txo_fiat}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#these are uncontrollerd choices of users in the producer role\n", + "\n", + "roi_threshold = 1.1 #estimatable parameter\n", + "\n", + "def producer_choice(step, sL, s):\n", + " #ROI heuristic\n", + " # add or remove resources until roi_threshold hit\n", + " return {'delta_labor': delta_labor}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#governance decision ~ system policy for compensating producers\n", + "#consider transaction volume, labor committed and token reserve and supply to determine payout\n", + "\n", + "def producer_compensation_policy(step, sL, s):\n", + " tokens_paid = \n", + " return {'tokens_paid': tokens_paid}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#used to trigger mechanisms with no explicit input\n", + "def dummy_behavior(step, sL, s):\n", + " return {'value': 0}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Mechanisms" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def update_conversion_rate(step, sL, s):\n", + " y = 'conversion_rate'\n", + " x = _input['new_conversion_rate']\n", + " return (y, x)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#minting process mints into the reserve\n", + "def mint1(step, sL, s):\n", + " y = 'token_supply'\n", + " x = s['token_supply'] + _input['mint']\n", + " return (y, x)\n", + "\n", + "def mint2(step, sL, s):\n", + " y = 'token_reserve'\n", + " x = s['token_reserve'] + _input['mint']\n", + " return (y, x)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def commit_delta_production(step, sL, s, _input):\n", + " y = 'volume_of_production'\n", + " x = s['volume_of_production']+_input['delta_production']\n", + " return (y, x)\n", + "\n", + "def compensate_production(step, sL, s, _input):\n", + " y = 'token_reserve'\n", + " x = s['token_reserve']-_input['tokens_paid']\n", + " return (y, x)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "conversion_fee = .01\n", + "\n", + "def capture_consumer_payments1(step, sL, s, _input):\n", + " #fiat inbound\n", + " y = 'fiat_reserve'\n", + " x = s['fiat_reserve']+_input['txi_fiat']\n", + " return (y, x)\n", + "\n", + "def capture_consumer_payments2(step, sL, s, _input):\n", + " #tokens inbound\n", + " y = 'token_reserve'\n", + " fiat_eq = s['tx_volume']-_input['txi_fiat']\n", + " x = s['token_reserve']+s['conversion_rate']*fiat_eq*(1.0+conversion_fee)\n", + " return (y, x)\n", + "\n", + "platform_fee = 0.03\n", + "\n", + "def compensate_providers1(step, sL, s, _input):\n", + " #fiat outbound\n", + " y = 'fiat_reserve'\n", + " x = s['fiat_reserve']-_input['txo_fiat']*(1.0-platform_fee)\n", + " return (y, x)\n", + "\n", + "def compensate_providers2(step, sL, s, _input):\n", + " #tokens outbound\n", + " y = 'token_reserve'\n", + " fiat_eq = s['tx_volume']-_input['txo_fiat']\n", + " x = s['token_reserve']-s['conversion_rate']*fiat_eq*(1.0-platform_fee-conversion_fee)\n", + " return (y, x)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#~~~~ break point (copy pasted started code below)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Behaviors choose actions depending on states\n", + "# 1) increase contact rate, beta (create incentive to spread)\n", + "# 2) decrease recover rate, gamma (improve stickiness)\n", + "\n", + "def add_incentive(step, sL, s):\n", + " incentive_allocation_as_share_of_budget = 0.02\n", + " target_beta = .5\n", + " potential_spend = s['Budget']*incentive_allocation_as_share_of_budget\n", + " \n", + " potential_delta = target_beta-s['beta']\n", + " \n", + " cost_of_potential_delta = potential_delta * incentive_cost * s['Ps']\n", + " if cost_of_potential_delta <= potential_spend:\n", + " delta = potential_delta\n", + " else:\n", + " delta = potential_spend/(incentive_cost * s['Ps'])\n", + "\n", + " return {'delta': delta}\n", + "\n", + "def add_stickiness(step, sL, s):\n", + " stickiness_allocation_as_share_of_budget = 0.08\n", + " target_gamma = .1\n", + " potential_spend = s['Budget']*stickiness_allocation_as_share_of_budget\n", + " \n", + " potential_delta = s['gamma']-target_gamma\n", + " \n", + " cost_of_potential_delta = potential_delta * stickiness_cost * s['Pi']\n", + " if cost_of_potential_delta <= potential_spend:\n", + " delta = potential_delta\n", + " else:\n", + " delta = potential_spend/(stickiness_cost * s['Pi'])\n", + " \n", + " \n", + " return {'delta': delta}\n", + "\n", + "# def add_stickiness(step, sL, s):\n", + "# delta = 0.0\n", + "# potential_delta = s['gamma'] * delta_gamma\n", + "# if (s['Pr'] > 2 * s['Pi']) and s['Budget'] > \\\n", + "# abs(potential_delta * stickiness_cost * s['Pi']):\n", + "# delta = potential_delta\n", + "# return {'delta': delta}\n", + "\n", + "# def add_incentive(step, sL, s):\n", + "# delta = 0.0\n", + "# potential_delta = s['beta'] * delta_beta\n", + "# if (s['Ps'] > 3 * s['Pi']) and s['Budget'] > \\\n", + "# abs(potential_delta * incentive_cost * s['Ps']):\n", + "# delta = potential_delta\n", + "# return {'delta': delta}\n", + "\n", + "def dummy_behavior(step, sL, s):\n", + " return {'delta': 0.0}\n", + "\n", + "# Mechanisms incur cost to modify beta or gamma\n", + "# 1) incur cost to create incentive to spread\n", + "# 2) incur cost to improve stickiness\n", + "\n", + "def incur_incentive_cost(step, sL, s, _input):\n", + " y = 'Budget'\n", + " x = s['Budget'] - abs(_input['delta'] * s['Ps'] * incentive_cost)\n", + " return (y, x)\n", + "\n", + "def incur_stickiness_cost(step, sL, s, _input):\n", + " y = 'Budget'\n", + " x = s['Budget'] - abs(_input['delta'] * s['Pi'] * stickiness_cost)\n", + " return (y, x)\n", + "\n", + "def update_beta(step, sL, s, _input):\n", + " y = 'beta'\n", + " x = s['beta'] + _input['delta']\n", + " return (y, x)\n", + "\n", + "def update_gamma(step, sL, s, _input):\n", + " y = 'gamma'\n", + " x = s['gamma'] - _input['delta']\n", + " return (y, x)\n", + "\n", + "def S_model(step, sL, s, _input):\n", + " y = 'Ps'\n", + " x = s['Ps'] - s['beta'] * s['Ps']\n", + " return (y, x)\n", + "\n", + "def I_model(step, sL, s, _input):\n", + " y = 'Pi'\n", + " x = s['Pi'] + s['beta'] * s['Ps'] - s['gamma'] * s['Pi']\n", + " return (y, x)\n", + " \n", + "def R_model(step, sL, s, _input):\n", + " y = 'Pr'\n", + " x = s['Pr'] + s['gamma'] * s['Pi']\n", + " return (y, x)\n", + "\n", + "def collect_subscription(step, sL, s, _input):\n", + " y = 'Budget'\n", + " x = s['Budget'] + s['Pi'] * epsilon * subscription_fee\n", + " return (y, x)\n", + "\n", + "def incentive_degrade(step, sL, s, _input):\n", + " y = 'beta'\n", + " x = s['beta']*(1-incentive_degredation_rate)\n", + " return (y, x)\n", + "\n", + "def stickiness_degrade(step, sL, s, _input):\n", + " y = 'gamma'\n", + " x = (s['gamma']+stickiness_degredation_rate)/(1+stickiness_degredation_rate)\n", + " return (y, x)\n", + "\n", + "mechanisms = {\n", + " 'spread': {\n", + " 'behaviors': {\n", + " 'dummy': dummy_behavior\n", + " },\n", + " 'states': {\n", + " 'Ps': S_model,\n", + " 'Pi': I_model,\n", + " 'Pr': R_model,\n", + " 'Budget': collect_subscription,\n", + " 'beta': incentive_degrade,\n", + " 'gamma': stickiness_degrade \n", + " } \n", + " },\n", + " 'create_incentive': {\n", + " 'behaviors': {\n", + " 'action': add_incentive,\n", + " },\n", + " 'states': {\n", + " 'beta': update_beta,\n", + " 'Budget': incur_incentive_cost,\n", + " }\n", + " },\n", + " 'improve_stickiness': {\n", + " 'behaviors': {\n", + " 'action': add_stickiness\n", + " },\n", + " 'states': {\n", + " 'gamma': update_gamma,\n", + " 'Budget': incur_stickiness_cost,\n", + " }\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9291d79f4e0441c8a2cefd78840f80a2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=0.05, description='beta', max=1.0, step=0.01), FloatSlider(value=0.2, …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def widget_handler(beta=float(0.05), gamma=float(0.20),\n", + " subscription_fee=float(1.0), \n", + " incentive_cost=float(10.0), \n", + " stickiness_cost=float(5.0)):\n", + " initial_condition['beta'] = beta\n", + " initial_condition['gamma'] = gamma\n", + " subscription_fee = subscription_fee\n", + " incentive_cost = incentive_cost\n", + " stickiness_cost = stickiness_cost\n", + " \n", + " config = Configuration(\n", + " sim_config=sim_config,\n", + " state_dict=initial_condition,\n", + " seed=seed,\n", + " exogenous_states=exogenous_states,\n", + " env_processes=env_processes,\n", + " mechanisms=mechanisms)\n", + "\n", + " exec_mode = ExecutionMode()\n", + " exec_context = ExecutionContext(exec_mode.single_proc)\n", + " executor = Executor(exec_context, [config]) # Pass the configuration object inside an array\n", + " raw_result, tensor = executor.main()\n", + " df = pd.DataFrame(raw_result)\n", + " df['timestamp'] = pd.to_datetime(df['timestamp'], format=ts_format)\n", + " \n", + " fig = plt.figure(figsize=(7, 14))\n", + " \n", + " sir = fig.add_subplot(3, 1, 1)\n", + " sir.plot('timestamp', 'Ps', data=df, marker='', color='C0', linewidth=2)\n", + " sir.plot('timestamp', 'Pi', data=df, marker='', color='orange', linewidth=2)\n", + " sir.plot('timestamp', 'Pr', data=df, marker='', color='green', linewidth=2)\n", + " sir.legend()\n", + " \n", + " beta_gamma = fig.add_subplot(3, 1, 2)\n", + " beta_gamma.plot('timestamp', 'beta', data=df, marker='', color='C0', linewidth=2)\n", + " beta_gamma.plot('timestamp', 'gamma', data=df, marker='', color='orange', linewidth=2)\n", + " beta_gamma.legend()\n", + " \n", + " budget_pi = fig.add_subplot(3, 1, 3)\n", + " budget_pi.plot('timestamp', 'Budget', data=df, marker='', color='C0', linewidth=2)\n", + " budget_pi.plot('timestamp', 'Pi', data=df, marker='', color='orange', linewidth=2)\n", + " budget_pi.legend()\n", + " \n", + " plt.show()\n", + " \n", + "sliders = interact_manual(widget_handler, \n", + " beta=(0, 1, 0.01),\n", + " gamma=(0, 1, 0.01),\n", + " subscription_fee=(0, 10, 0.1),\n", + " incentive_cost=(0, 20, 0.5),\n", + " stickiness_cost=(0, 20, 0.5)\n", + " )\n", + "sliders" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "single_proc: []\n" + ] + } + ], + "source": [ + "config = Configuration(\n", + " sim_config=sim_config,\n", + " state_dict=initial_condition,\n", + " seed=seed,\n", + " exogenous_states=exogenous_states,\n", + " env_processes=env_processes,\n", + " mechanisms=mechanisms)\n", + "\n", + "from SimCAD.engine import ExecutionMode, ExecutionContext, Executor\n", + "exec_mode = ExecutionMode()\n", + "exec_context = ExecutionContext(exec_mode.single_proc)\n", + "executor = Executor(exec_context, [config]) # Pass the configuration object inside an array\n", + "raw_result, tensor = executor.main()\n", + "df = pd.DataFrame(raw_result)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
PsPiPr
count151.000000151.000000151.000000
mean379.57659978.205623552.217778
std240.76954445.833265277.799255
min109.87315810.0000000.000000
25%177.55675037.674442345.635550
50%307.91099763.037371632.174679
75%529.106433120.040677794.768808
max1000.000000160.085658877.383072
\n", + "
" + ], + "text/plain": [ + " Ps Pi Pr\n", + "count 151.000000 151.000000 151.000000\n", + "mean 379.576599 78.205623 552.217778\n", + "std 240.769544 45.833265 277.799255\n", + "min 109.873158 10.000000 0.000000\n", + "25% 177.556750 37.674442 345.635550\n", + "50% 307.910997 63.037371 632.174679\n", + "75% 529.106433 120.040677 794.768808\n", + "max 1000.000000 160.085658 877.383072" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df.plot('timestamp', ['Ps','Pi', 'Pr'])\n", + "df.plot('timestamp', ['beta', 'gamma'])\n", + "df.plot('timestamp', ['Budget', 'Pi'])\n", + "df[['Ps','Pi', 'Pr']].describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "count 150.000000\n", + "mean -0.000079\n", + "std 0.000264\n", + "min -0.000500\n", + "25% -0.000403\n", + "50% 0.000000\n", + "75% 0.000170\n", + "max 0.000225\n", + "Name: beta, dtype: float64" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.beta.diff().describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df.beta.diff().plot()" + ] + }, + { + "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.7.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/demos/susceptible_infected_recovered.ipynb b/demos/susceptible_infected_recovered.ipynb index 8a20dec..637064f 100644 --- a/demos/susceptible_infected_recovered.ipynb +++ b/demos/susceptible_infected_recovered.ipynb @@ -238,7 +238,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5b2247820f7a4af894245eb22ec5716d", + "model_id": "9291d79f4e0441c8a2cefd78840f80a2", "version_major": 2, "version_minor": 0 }, @@ -325,7 +325,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "single_proc: []\n" + "single_proc: []\n" ] } ], @@ -492,7 +492,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -509,7 +509,7 @@ "Name: beta, dtype: float64" ] }, - "execution_count": 11, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -520,16 +520,16 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 12, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" },