diff --git a/README.md b/README.md index cb835cd..11235cc 100644 --- a/README.md +++ b/README.md @@ -5,8 +5,8 @@ ## Simulations -[Initial model](Aragon_Conviction_Voting_Model.ipynb) - +[Initial model](v1/Aragon_Conviction_Voting_Model.ipynb) +[Full complexity modell](v2/Aragon_Conviction_Voting_Model.ipynb) ## Background information & concepts addressed ### What is cadCAD? diff --git a/Aragon_Conviction_Voting_Model.ipynb b/v1/Aragon_Conviction_Voting_Model.ipynb similarity index 100% rename from Aragon_Conviction_Voting_Model.ipynb rename to v1/Aragon_Conviction_Voting_Model.ipynb diff --git a/images/Aragon_v1.png b/v1/images/Aragon_v1.png similarity index 100% rename from images/Aragon_v1.png rename to v1/images/Aragon_v1.png diff --git a/images/bipartite-cv-compute.png b/v1/images/bipartite-cv-compute.png similarity index 100% rename from images/bipartite-cv-compute.png rename to v1/images/bipartite-cv-compute.png diff --git a/images/stockflow-cv-trigger.png b/v1/images/stockflow-cv-trigger.png similarity index 100% rename from images/stockflow-cv-trigger.png rename to v1/images/stockflow-cv-trigger.png diff --git a/model/__pycache__/economyconfig.cpython-36.pyc b/v1/model/__pycache__/economyconfig.cpython-36.pyc similarity index 100% rename from model/__pycache__/economyconfig.cpython-36.pyc rename to v1/model/__pycache__/economyconfig.cpython-36.pyc diff --git a/model/__pycache__/economyconfig.cpython-37.pyc b/v1/model/__pycache__/economyconfig.cpython-37.pyc similarity index 100% rename from model/__pycache__/economyconfig.cpython-37.pyc rename to v1/model/__pycache__/economyconfig.cpython-37.pyc diff --git a/model/__pycache__/genesis_states.cpython-36.pyc b/v1/model/__pycache__/genesis_states.cpython-36.pyc similarity index 100% rename from model/__pycache__/genesis_states.cpython-36.pyc rename to v1/model/__pycache__/genesis_states.cpython-36.pyc diff --git a/model/__pycache__/genesis_states.cpython-37.pyc b/v1/model/__pycache__/genesis_states.cpython-37.pyc similarity index 100% rename from model/__pycache__/genesis_states.cpython-37.pyc rename to v1/model/__pycache__/genesis_states.cpython-37.pyc diff --git a/model/__pycache__/partial_state_update_block.cpython-36.pyc b/v1/model/__pycache__/partial_state_update_block.cpython-36.pyc similarity index 100% rename from model/__pycache__/partial_state_update_block.cpython-36.pyc rename to v1/model/__pycache__/partial_state_update_block.cpython-36.pyc diff --git a/model/__pycache__/partial_state_update_block.cpython-37.pyc b/v1/model/__pycache__/partial_state_update_block.cpython-37.pyc similarity index 100% rename from model/__pycache__/partial_state_update_block.cpython-37.pyc rename to v1/model/__pycache__/partial_state_update_block.cpython-37.pyc diff --git a/model/__pycache__/run.cpython-36.pyc b/v1/model/__pycache__/run.cpython-36.pyc similarity index 100% rename from model/__pycache__/run.cpython-36.pyc rename to v1/model/__pycache__/run.cpython-36.pyc diff --git a/model/__pycache__/run.cpython-37.pyc b/v1/model/__pycache__/run.cpython-37.pyc similarity index 100% rename from model/__pycache__/run.cpython-37.pyc rename to v1/model/__pycache__/run.cpython-37.pyc diff --git a/model/economyconfig.py b/v1/model/economyconfig.py similarity index 100% rename from model/economyconfig.py rename to v1/model/economyconfig.py diff --git a/model/genesis_states.py b/v1/model/genesis_states.py similarity index 100% rename from model/genesis_states.py rename to v1/model/genesis_states.py diff --git a/model/model/__pycache__/conviction_helper_functions.cpython-36.pyc b/v1/model/model/__pycache__/conviction_helper_functions.cpython-36.pyc similarity index 100% rename from model/model/__pycache__/conviction_helper_functions.cpython-36.pyc rename to v1/model/model/__pycache__/conviction_helper_functions.cpython-36.pyc diff --git a/model/model/__pycache__/conviction_helper_functions.cpython-37.pyc b/v1/model/model/__pycache__/conviction_helper_functions.cpython-37.pyc similarity index 100% rename from model/model/__pycache__/conviction_helper_functions.cpython-37.pyc rename to v1/model/model/__pycache__/conviction_helper_functions.cpython-37.pyc diff --git a/model/model/__pycache__/designed.cpython-36.pyc b/v1/model/model/__pycache__/designed.cpython-36.pyc similarity index 100% rename from model/model/__pycache__/designed.cpython-36.pyc rename to v1/model/model/__pycache__/designed.cpython-36.pyc diff --git a/model/model/__pycache__/designed.cpython-37.pyc b/v1/model/model/__pycache__/designed.cpython-37.pyc similarity index 100% rename from model/model/__pycache__/designed.cpython-37.pyc rename to v1/model/model/__pycache__/designed.cpython-37.pyc diff --git a/model/model/__pycache__/exogenousProcesses.cpython-36.pyc b/v1/model/model/__pycache__/exogenousProcesses.cpython-36.pyc similarity index 100% rename from model/model/__pycache__/exogenousProcesses.cpython-36.pyc rename to v1/model/model/__pycache__/exogenousProcesses.cpython-36.pyc diff --git a/model/model/__pycache__/exogenousProcesses.cpython-37.pyc b/v1/model/model/__pycache__/exogenousProcesses.cpython-37.pyc similarity index 100% rename from model/model/__pycache__/exogenousProcesses.cpython-37.pyc rename to v1/model/model/__pycache__/exogenousProcesses.cpython-37.pyc diff --git a/model/model/__pycache__/initialization.cpython-36.pyc b/v1/model/model/__pycache__/initialization.cpython-36.pyc similarity index 100% rename from model/model/__pycache__/initialization.cpython-36.pyc rename to v1/model/model/__pycache__/initialization.cpython-36.pyc diff --git a/model/model/__pycache__/initialization.cpython-37.pyc b/v1/model/model/__pycache__/initialization.cpython-37.pyc similarity index 100% rename from model/model/__pycache__/initialization.cpython-37.pyc rename to v1/model/model/__pycache__/initialization.cpython-37.pyc diff --git a/model/model/__pycache__/kpis.cpython-36.pyc b/v1/model/model/__pycache__/kpis.cpython-36.pyc similarity index 100% rename from model/model/__pycache__/kpis.cpython-36.pyc rename to v1/model/model/__pycache__/kpis.cpython-36.pyc diff --git a/model/model/__pycache__/kpis.cpython-37.pyc b/v1/model/model/__pycache__/kpis.cpython-37.pyc similarity index 100% rename from model/model/__pycache__/kpis.cpython-37.pyc rename to v1/model/model/__pycache__/kpis.cpython-37.pyc diff --git a/model/model/__pycache__/operatorentity.cpython-37.pyc b/v1/model/model/__pycache__/operatorentity.cpython-37.pyc similarity index 100% rename from model/model/__pycache__/operatorentity.cpython-37.pyc rename to v1/model/model/__pycache__/operatorentity.cpython-37.pyc diff --git a/model/model/__pycache__/participants.cpython-36.pyc b/v1/model/model/__pycache__/participants.cpython-36.pyc similarity index 100% rename from model/model/__pycache__/participants.cpython-36.pyc rename to v1/model/model/__pycache__/participants.cpython-36.pyc diff --git a/model/model/__pycache__/participants.cpython-37.pyc b/v1/model/model/__pycache__/participants.cpython-37.pyc similarity index 100% rename from model/model/__pycache__/participants.cpython-37.pyc rename to v1/model/model/__pycache__/participants.cpython-37.pyc diff --git a/model/model/__pycache__/proposals.cpython-36.pyc b/v1/model/model/__pycache__/proposals.cpython-36.pyc similarity index 100% rename from model/model/__pycache__/proposals.cpython-36.pyc rename to v1/model/model/__pycache__/proposals.cpython-36.pyc diff --git a/model/model/__pycache__/proposals.cpython-37.pyc b/v1/model/model/__pycache__/proposals.cpython-37.pyc similarity index 100% rename from model/model/__pycache__/proposals.cpython-37.pyc rename to v1/model/model/__pycache__/proposals.cpython-37.pyc diff --git a/model/model/__pycache__/subpopulation_clusters.cpython-37.pyc b/v1/model/model/__pycache__/subpopulation_clusters.cpython-37.pyc similarity index 100% rename from model/model/__pycache__/subpopulation_clusters.cpython-37.pyc rename to v1/model/model/__pycache__/subpopulation_clusters.cpython-37.pyc diff --git a/model/model/__pycache__/supportingFunctions.cpython-37.pyc b/v1/model/model/__pycache__/supportingFunctions.cpython-37.pyc similarity index 100% rename from model/model/__pycache__/supportingFunctions.cpython-37.pyc rename to v1/model/model/__pycache__/supportingFunctions.cpython-37.pyc diff --git a/model/model/__pycache__/system.cpython-36.pyc b/v1/model/model/__pycache__/system.cpython-36.pyc similarity index 100% rename from model/model/__pycache__/system.cpython-36.pyc rename to v1/model/model/__pycache__/system.cpython-36.pyc diff --git a/model/model/__pycache__/system.cpython-37.pyc b/v1/model/model/__pycache__/system.cpython-37.pyc similarity index 100% rename from model/model/__pycache__/system.cpython-37.pyc rename to v1/model/model/__pycache__/system.cpython-37.pyc diff --git a/model/model/conviction_helper_functions.py b/v1/model/model/conviction_helper_functions.py similarity index 100% rename from model/model/conviction_helper_functions.py rename to v1/model/model/conviction_helper_functions.py diff --git a/model/model/initialization.py b/v1/model/model/initialization.py similarity index 100% rename from model/model/initialization.py rename to v1/model/model/initialization.py diff --git a/model/model/participants.py b/v1/model/model/participants.py similarity index 100% rename from model/model/participants.py rename to v1/model/model/participants.py diff --git a/model/model/proposals.py b/v1/model/model/proposals.py similarity index 100% rename from model/model/proposals.py rename to v1/model/model/proposals.py diff --git a/model/model/system.py b/v1/model/model/system.py similarity index 100% rename from model/model/system.py rename to v1/model/model/system.py diff --git a/model/partial_state_update_block.py b/v1/model/partial_state_update_block.py similarity index 100% rename from model/partial_state_update_block.py rename to v1/model/partial_state_update_block.py diff --git a/model/run.py b/v1/model/run.py similarity index 100% rename from model/run.py rename to v1/model/run.py diff --git a/v2/.ipynb_checkpoints/Aragon Conviction Voting Model-checkpoint.ipynb b/v2/.ipynb_checkpoints/Aragon Conviction Voting Model-checkpoint.ipynb new file mode 100644 index 0000000..72936f1 --- /dev/null +++ b/v2/.ipynb_checkpoints/Aragon Conviction Voting Model-checkpoint.ipynb @@ -0,0 +1,892 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Aragon Conviction Voting Model - Version 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model Overview \n", + "\n", + "[Conviction Voting](https://medium.com/giveth/conviction-voting-a-novel-continuous-decision-making-alternative-to-governance-aa746cfb9475) is a novel decision making process where votes express their preference for which proposals they would like to see approved in a continuous rather than discrete way. The longer the community keeps a preference on an individual proposal, the “stronger” the proposal conviction becomes. In the conviction voting model, a graph structure is used to record the the introduction and removal of participants, candidates, proposals, and their outcomes.\n", + "\n", + "## cadCAD Overview\n", + "\n", + "In the cadCAD simulation [methodology](https://community.cadcad.org/t/differential-specification-syntax-key/31), we operate on four layers: **Policies, Mechanisms, States**, and **Metrics**. Information flows do not have explicit feedback loop unless noted. **Policies** determine the inputs into the system dynamics, and can come from user input, observations from the exogenous environment, or algorithms. **Mechanisms** are functions that take the policy decisions and update the States to reflect the policy level changes. **States** are variables that represent the system quantities at the given point in time, and **Metrics** are computed from state variables to assess the health of the system. Metrics can often be thought of as KPIs, or Key Performance Indicators. \n", + "\n", + "At a more granular level, to setup a model, there are system conventions and configurations that must be [followed.](https://community.cadcad.org/t/introduction-to-simulation-configurations/34)\n", + "\n", + "The way to think of cadCAD modeling is analogous to machine learning pipelines which normally consist of multiple steps when training and running a deployed model. There is preprocessing, which includes segregating features between continuous and categorical, transforming or imputing data, and then instantiating, training, and running a machine learning model with specified hyperparameters. cadCAD modeling can be thought of in the same way as states, roughly translating into features, are fed into pipelines that have built-in logic to direct traffic between different mechanisms, such as scaling and imputation. Accuracy scores, ROC, etc are analogous to the metrics that can be configured on a cadCAD model, specifying how well a given model is doing in meeting its objectives. The parameter sweeping capability of cadCAD can be thought of as a grid search, or way to find the optimal hyperparameters for a system by running through alternative scenarios. A/B style testing that cadCAD enables is used in the same way machine learning models are A/B tested, except out of the box, in providing a side by side comparison of muliple different models to compare and contract performance. Utilizing the field of Systems Identification, dynamical systems models can be used to \"online learn\" by providing a feedback loop to generative system mechanisms. \n", + "\n", + "\n", + "## Differential Specification\n", + "![](images/Aragon_v1.png)\n", + "\n", + "## Schema of the states\n", + "The model consistes of a temporal in memory graph database called *network* containing nodes of type **Participant** and type **Proposal**. Participants will have *holdings* and Proposals will have *funds_required, status*(candidate or active), *conviction*. Edges in the network go from nodes of type Participant to nodes of type Proposal with the edges having the key *type*, off which all will be set to *support*. Edges from participant $i$ to proposal $j$ will have the following additional characteristics:\n", + "* Each pairing (i,j) will have *affinity*, which determines how much $i$ likes or dislikes proposal $j$.\n", + "* Each participant $i$, assigns it's $tokens$ over the edges (i,j) for all $j$ such that the summation of all $j$ such that ```Sum_j = network.edges[(i,j)]['tokens'] = network.nodes[i]['holdings']```\n", + "* Each pairing (i,j) will have *conviction* local to that edge whose update at each timestep is computed using the value of *tokens* at that edge.\n", + "* Each proposal *j* will have a *conviction* which is equal to the sum of the conviction on its inbound edges: ```network.nodes[j]['conviction'] = Sum_i network.edges[(i,j)]['conviction']```\n", + "* The \"trigger function\" will check whether each proposal $j$ has met the criteria for passing; if a proposal passes its *status* changes from *candidate* to *active*, and an amount of funds equal to it's *funds_required* will be decremented from *funds*.\n", + "\n", + "\n", + "The other state variable in the model is *funds*, which is a numpy floating point. \n", + "\n", + "The system consists of 100 time steps without a parameter sweep or monte carlo.\n", + "\n", + "\n", + "## Partial State Update Blocks\n", + "\n", + "Each partial state update block is kind of a like a phase in a phased based board game. Everyone decides what to do and it reconciles all decisions. One timestep is a full turn, with each block being a phase of a timestep or turn. We will walk through the individaul Partial State update blocks one by one below." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```\n", + "{\n", + "# system.py: \n", + "'policies': { \n", + " 'random': driving_process\n", + "},\n", + "'variables': {\n", + " 'network': update_network,\n", + " 'funds':increment_funds,\n", + "}\n", + "```\n", + "\n", + "To simulate the arrival of participants and proposal into the system, we have a driving process to represent the arrival of individual agents. For simplification, we are using hyperparameters for supply and sentiment, 1,231,286.81 and 0.6 respectively. We use a random uniform distribution generator, over [0, 1), to calculate the number of new participants. We then use an expoential distribution to calculate the particpant's tokens by using a loc of 0.0 and a scale of expected holdings, which is calcutulaed by .1*supply/number of existing participants. We calcualte the number of new proposals by \n", + "```\n", + "proposal_rate = 1/median_affinity * (1+total_funds_requested/funds)\n", + "rv2 = np.random.rand()\n", + "new_proposal = bool(rv2<1/proposal_rate)\n", + "```\n", + "The network state variable is updated to include the new participants and proposals, while the funds state variable is updated for the increase in system funds. \n", + "[To see the partial state update code, click here](model/model/system.py)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```\n", + "{\n", + " # participants.py \n", + " 'policies': {\n", + " 'completion': check_progress \n", + " },\n", + " 'variables': { \n", + " 'network': complete_proposal\n", + " }\n", + "},\n", + "```\n", + "\n", + "In the next phase of the turn, [to see the logic code, click here](model/model/participants.py), the *check_progress* behavior checks for the completion of previously funded proposals. The code calculates the completion and failure rates as follows:\n", + "\n", + "```\n", + "likelihood = 1.0/(base_completion_rate+np.log(grant_size))\n", + "\n", + "failure_rate = 1.0/(base_failure_rate+np.log(grant_size))\n", + "if np.random.rand() < likelihood:\n", + " completed.append(j)\n", + "elif np.random.rand() < failure_rate:\n", + " failed.append(j)\n", + "```\n", + "With the base_completion_rate being 100 and the base_failure_rate as 200. \n", + "\n", + "The mechanism then updates the respective *network* nodes. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```\n", + "{\n", + " # proposals.py\n", + " 'policies': {\n", + " 'release': trigger_function \n", + " },\n", + " 'variables': { \n", + " 'funds': decrement_funds, \n", + " 'network': update_proposals \n", + " }\n", + "},\n", + " ```\n", + " \n", + "The [trigger release function]((model/model/proposals.py) checks to see if each proposal passes or not. If a proposal passes, funds are decremented by the amount of the proposal, while the proposal's status is changed in the network object." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```\n", + "{ \n", + " # participants.py\n", + " 'policies': { \n", + " 'participants_act': participants_decisions\n", + " },\n", + " 'variables': {\n", + " 'network': update_tokens \n", + " }\n", + "}\n", + "```\n", + "\n", + "The Participants decide based on their affinity if which proposals they would like to support,[to see the logic code, click here](model/model/participants.py). Proposals that participants have high affinity for receive more support and pledged tokens than proposals with lower affinity and sentiment. We then update everyone's holdings and their conviction for each proposal.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model next steps\n", + "\n", + "The the model described above is a minimalist model, first iteration model that covers the core mechanisms of the Aragon Conviction Voting model. Below are next additional dynamics we can attend to enrich the model, and provide workstreams for subsequent iterations of this lab notebook.\n", + "* Sentiment\n", + "* Mixing of token holdings among participants\n", + "* Departure of participants\n", + "* Participants influencing each others opinions\n", + "* Proposals which are good or no good together\n", + "* Multiple proposal stages such as killed, failed and completed\n", + "* Affects of outcomes on sentiment" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Simulation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Configuration\n", + "let's factor out into its own notebook where we review the config object and its partial state update blocks, with a slightly deeper dive on the trigger function. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/aclarkdata/anaconda3/lib/python3.7/site-packages/statsmodels/tools/_testing.py:19: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.\n", + " import pandas.util.testing as tm\n" + ] + } + ], + "source": [ + "from model import economyconfig" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# pull out configurations to illustrate\n", + "sim_config,genesis_states,seeds,partial_state_update_blocks = economyconfig.get_configs()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'N': 1, 'T': range(0, 100), 'M': [{}], 'simulation_id': 0, 'run_id': 0}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sim_config" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'policies': {'random': },\n", + " 'variables': {'network': ,\n", + " 'funds': }},\n", + " {'policies': {'completion': },\n", + " 'variables': {'network': }},\n", + " {'policies': {'release': },\n", + " 'variables': {'funds': ,\n", + " 'network': }},\n", + " {'policies': {'participants_act': },\n", + " 'variables': {'network': }}]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "partial_state_update_blocks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Initialization\n", + "To create the genesis_states, we create our in-memory graph database within networkx. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# import libraries\n", + "import networkx as nx\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from model.model.conviction_helper_functions import * \n", + "\n", + "# Parameters\n", + "#maximum share of funds a proposal can take\n", + "beta = .2 \n", + "# tuning param for the trigger function\n", + "rho = .001\n", + "\n", + "\n", + "\n", + "n= 60 #initial participants\n", + "m= 3 #initial proposals\n", + "\n", + "initial_sentiment = .6\n", + "\n", + "initial_funds = 40781.42\n", + "\n", + "def initialize_network(n,m, inital_funds, expected_supply = 10**6):\n", + " '''\n", + " Definition:\n", + " Function to initialize network x object\n", + " '''\n", + " # initilize network x graph\n", + " network = nx.DiGraph()\n", + " # create participant nodes with type and token holding\n", + " for i in range(n):\n", + " network.add_node(i)\n", + " network.nodes[i]['type']= \"participant\"\n", + " \n", + " h_rv = expon.rvs(loc=0.0, scale= expected_supply/n)\n", + " network.nodes[i]['holdings'] = h_rv\n", + " \n", + " \n", + " participants = get_nodes_by_type(network, 'participant')\n", + " initial_supply = np.sum([ network.nodes[i]['holdings'] for i in participants])\n", + " \n", + " \n", + " # Generate initial proposals\n", + " for ind in range(m):\n", + " j = n+ind\n", + " network.add_node(j)\n", + " network.nodes[j]['type']=\"proposal\"\n", + " network.nodes[j]['conviction'] = 0\n", + " network.nodes[j]['status'] = 'candidate'\n", + " network.nodes[j]['age'] = 0\n", + " \n", + " r_rv = gamma.rvs(3,loc=0.001, scale=10000)\n", + " network.nodes[j]['funds_requested'] = r_rv\n", + " \n", + " network.nodes[j]['trigger']= trigger_threshold(r_rv, initial_funds, initial_supply,beta=beta,rho=rho)\n", + " \n", + " for i in range(n):\n", + " network.add_edge(i, j)\n", + " \n", + " rv = np.random.rand()\n", + " a_rv = 1-4*(1-rv)*rv #polarized distribution\n", + " network.edges[(i, j)]['affinity'] = a_rv\n", + " network.edges[(i, j)]['tokens'] = 0\n", + " network.edges[(i, j)]['conviction'] = 0\n", + " network.edges[(i, j)]['type'] = 'support'\n", + " \n", + " proposals = get_nodes_by_type(network, 'proposal')\n", + " total_requested = np.sum([ network.nodes[i]['funds_requested'] for i in proposals])\n", + " \n", + " \n", + " return network, initial_funds\n", + "\n", + "# run the initialize_network function to create the initial states of the simulation\n", + "network, initial_funds = initialize_network(n,m,initial_funds)\n", + "\n", + "\n", + "# Create initial states\n", + "genesis_states = { \n", + " 'network':network,\n", + " 'funds':initial_funds\n", + "\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'network': ,\n", + " 'funds': 40781.42}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "genesis_states" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "# To explore our model prior to the simulation, we extract key components from our networkX object into lists.\n", + "proposals = get_nodes_by_type(network, 'proposal')\n", + "participants = get_nodes_by_type(network, 'participant')\n", + "supporters = get_edges_by_type(network, 'support')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Exploring the State Data Structure\n", + "\n", + "A graph is a type of temporal data structure that evolves over time. A graph $\\mathcal{G}(\\mathcal{V},\\mathcal{E})$ consists of vertices or nodes, $\\mathcal{V} = \\{1...\\mathcal{V}\\}$ and is connected by edges $\\mathcal{E} \\subseteq \\mathcal{V} \\times \\mathcal{V}$.\n", + "\n", + "See *Schema of the states* above for more details\n", + "\n", + "\n", + "Let's explore!" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'type': 'participant', 'holdings': 62762.37191305695}" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#sample a participant\n", + "network.nodes[participants[0]]" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Histogram of Participants Token Holdings')" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Let's look at the distribution of participant holdings at the start of the sim\n", + "plt.hist([ network.nodes[i]['holdings'] for i in participants])\n", + "plt.title('Histogram of Participants Token Holdings')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'type': 'proposal',\n", + " 'conviction': 0,\n", + " 'status': 'candidate',\n", + " 'age': 0,\n", + " 'funds_requested': 3008.044737208468,\n", + " 'trigger': 74513.40829890648}" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#lets look at proposals\n", + "network.nodes[proposals[0]]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Proposals initially start without any conviction, and with the status of a candidate. If the proposal's amount of conviction is greater than it's trigger, then the proposal moves to active and it's funds requested are granted. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All initial proposal start with 0 conviction and state 'candidate'we can simply examine the amounts of funds requested" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Proposals')" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.bar( proposals, [ network.nodes[i]['funds_requested'] for i in proposals])\n", + "plt.title('Histogram of Proposals Funds Requested')\n", + "plt.xlabel('Proposals')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Conviction is a concept that arises in the edges between participants and proposals in the initial conditions there are no votes yet so we can look at that later however, the voting choices are driven by underlying affinities which we can see now." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 137.58, 'participant_id')" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "affinities = np.empty((n,m))\n", + "for i_ind in range(n):\n", + " for j_ind in range(m):\n", + " i = participants[i_ind]\n", + " j = proposals[j_ind]\n", + " affinities[i_ind][j_ind] = network.edges[(i,j)]['affinity']\n", + "\n", + "dims = (20, 5)\n", + "fig, ax = plt.subplots(figsize=dims)\n", + "\n", + "sns.heatmap(affinities.T,\n", + " xticklabels=participants,\n", + " yticklabels=proposals,\n", + " square=True,\n", + " cbar=True,\n", + " ax=ax)\n", + "\n", + "plt.title('affinities between participants and proposals')\n", + "plt.ylabel('proposal_id')\n", + "plt.xlabel('participant_id')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run simulation\n", + "\n", + "Now we will create the final system configuration, append the genesis states we created, and run our simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "from cadCAD.configuration import append_configs\n", + "\n", + "# Create configuration\n", + "append_configs(\n", + " sim_configs=sim_config,\n", + " initial_state=genesis_states,\n", + " seeds=seeds,\n", + " partial_state_update_blocks=partial_state_update_blocks\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " __________ ____ \n", + " ________ __ _____/ ____/ | / __ \\\n", + " / ___/ __` / __ / / / /| | / / / /\n", + "/ /__/ /_/ / /_/ / /___/ ___ |/ /_/ / \n", + "\\___/\\__,_/\\__,_/\\____/_/ |_/_____/ \n", + "by cadCAD\n", + "\n", + "Execution Mode: local_proc\n", + "Configuration Count: 2\n", + "Dimensions of the first simulation: (Timesteps, Params, Runs, Vars) = (100, 1, 1, 2)\n", + "Execution Method: local_simulations\n", + "Execution Mode: parallelized\n", + "Total execution time: 51.78s\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from model.model.conviction_helper_functions import *\n", + "from model import run\n", + "from cadCAD import configs\n", + "pd.options.display.float_format = '{:.2f}'.format\n", + "\n", + "%matplotlib inline\n", + "\n", + "# Pass in configuration to run\n", + "df = run.run(configs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After the simulation has run successfully, we perform some postprocessing to extract node and edge values from the network object and add as columns to the pandas dataframe. For the rdf, we take only the values at the last substep of each timestep in the simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "df,rdf = run.postprocessing(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "affinities_plot(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "rdf.plot(x='timestep',y=['candidate_count','active_count','completed_count', 'killed_count', 'failed_count'])\n", + "plt.title('Proposal Status')\n", + "plt.ylabel('count of proposals')\n", + "plt.legend(ncol = 3,loc='upper center', bbox_to_anchor=(0.5, -0.15))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "rdf.plot(x='timestep',y=['candidate_funds','active_funds','completed_funds', 'killed_funds', 'failed_funds'])\n", + "plt.title('Proposal Status weighted by funds requested')\n", + "plt.ylabel('Funds worth of proposals')\n", + "plt.legend(ncol = 3,loc='upper center', bbox_to_anchor=(0.5, -0.15))" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "nets = rdf.network.values" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/aclarkdata/anaconda3/lib/python3.7/site-packages/networkx/drawing/nx_pylab.py:563: MatplotlibDeprecationWarning: \n", + "The iterable function was deprecated in Matplotlib 3.1 and will be removed in 3.3. Use np.iterable instead.\n", + " if not cb.iterable(width):\n", + "/home/aclarkdata/anaconda3/lib/python3.7/site-packages/networkx/drawing/nx_pylab.py:569: MatplotlibDeprecationWarning: \n", + "The iterable function was deprecated in Matplotlib 3.1 and will be removed in 3.3. Use np.iterable instead.\n", + " and cb.iterable(edge_color) \\\n", + "/home/aclarkdata/anaconda3/lib/python3.7/site-packages/networkx/drawing/nx_pylab.py:579: MatplotlibDeprecationWarning: \n", + "The iterable function was deprecated in Matplotlib 3.1 and will be removed in 3.3. Use np.iterable instead.\n", + " for c in edge_color]):\n", + "/home/aclarkdata/anaconda3/lib/python3.7/site-packages/networkx/drawing/nx_pylab.py:660: MatplotlibDeprecationWarning: \n", + "The iterable function was deprecated in Matplotlib 3.1 and will be removed in 3.3. Use np.iterable instead.\n", + " if cb.iterable(node_size): # many node sizes\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "K = 3\n", + "snap_plot(nets[K:K+1], size_scale = 1/300)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "K = 56\n", + "snap_plot(nets[K:K+1], size_scale = 1/300)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "quantile_plot('timestep','conviction_share_of_trigger', rdf, .25)\n", + "plt.hlines(1,0,df.timestep.values[-1], linestyle='--')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conclusion\n", + "\n", + "We have created a simplified conviction voting model that illustrates the state objects, and provides descriptions of how the model fits together. In subsequent notebooks, we will expand the model to introduce additional complexity to more fit real world implementations. " + ] + } + ], + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/v2/.ipynb_checkpoints/Aragon_Conviction_Voting_Model-checkpoint.ipynb b/v2/.ipynb_checkpoints/Aragon_Conviction_Voting_Model-checkpoint.ipynb new file mode 100644 index 0000000..99841fe --- /dev/null +++ b/v2/.ipynb_checkpoints/Aragon_Conviction_Voting_Model-checkpoint.ipynb @@ -0,0 +1,1317 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Aragon Conviction Voting Model - Version 2\n", + "\n", + "New to this model are the following elements:\n", + "\n", + "* Influence - Participant social network where participants influence each others perception of a a proposal.\n", + "* Conflict - A network with the notion of supporting one proposal may mean going against an alternative proposal. For proposals with conflicts, an edge is created between them with a function to calculate the degree of conflict.\n", + "* Sentiment - Participant sentiment\n", + "* Updated trigger function to better represent 1Hive's implementation\n", + "* Updated plotting\n", + "* Updated affinity distribution to between -1, 1\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# An Introduction to Conviction Voting\n", + "\n", + "Conviction Voting is an approach to organizing a communities preferences into discrete decisions in the management of that communities resources. Strictly speaking conviction voting is less like voting and more like signal processing. Framing the approach and the initial algorithm design was done by Michael Zargham and published in a short research proposal [Social Sensor Fusion](https://github.com/BlockScience/conviction/blob/master/social-sensorfusion.pdf). This work is based on a dynamic resource allocation algorithm presented in Zargham's PhD Thesis.\n", + "\n", + "The work proceeded in collaboration with the Commons Stack, including expanding on the pythin implementation to makeup part of the Commons Simulator game. An implemention of Conviction Voting as a smart contract within the Aragon Framework was developed by 1hive.org and is currently being used for community decision making around allocations their community currency, Honey.\n", + "\n", + "\n", + "## The Word Problem\n", + "\n", + "Suppose a group of people want to coordinate to make a collective decision. Social dynamics such as discussions, signaling, and even changing ones mind based on feedback from others input play an important role in these processes. While the actual decision making process involves a lot of informal processes, in order to be fair the ultimate decision making process still requires a set of formal rules that the community collecively agrees to, which serves to functionally channel a plurality of preferences into a discrete outcomes. In our case we are interested in a procedure which supports asynchronous interactions, an provides visibility into likely outcomes prior to their resolution to serve as a driver of good faith, debate and healthy forms of coalition building. Furthermore, participations should be able to show support for multiple initiatives, and to vary the level of support shown. Participants a quantity of signaling power which may be fixed or variable, homogenous or heterogenous. For the purpose of this document, we'll focus on the case where the discrete decisions to be made are decisions to allocate funds from a shared funding pool towards projects of interest to the community.\n", + "\n", + "## Converting to a Math Problem\n", + "\n", + "Let's start taking these words and constructing a mathematical representation that supports a design that meets the description above. To start we need to define participants.\n", + "\n", + "### Participants\n", + "Let $\\mathcal{A}$ be the set of participants. Consider a participant $a\\in \\mathcal{A}$. Any participant $a$ has some capacity to participate in the voting process $h[a]$. In a fixed quantity, homogenous system $h[a] = h$ for all $a\\in \\mathcal{A}$ where $h$ is a constant. The access control process managing how one becomes a participant determines the total supply of \"votes\" $S = \\sum_{a\\in \\mathcal{A}} = n\\cdot h$ where the number of participants is $n = |\\mathcal{A}|$. In a smart contract setting, the set $\\mathcal{A}$ is a set of addresses, and $h[a]$ is a quantity of tokens held by each address $a\\in \\mathcal{A}$. \n", + "\n", + "### Proposals & Shares Resources\n", + "Next, we introduce the idea of proposals. Consider a proposal $i\\in \\mathcal{C}$. Any proposal $i$ is associated with a request for resources $r[i]$. Those requested resources would be allocated from a constrained pool of communal resources currently totaling $R$. The pool of resources may become depleted because when a proposal $i$ passes $R^+= R-r[i]$. Therefore it makes sense for us to consider what fraction of the shared resources are being request $\\mu_i = \\frac{r[i]}{R}$, which means that thre resource depletion from passing proposals can be bounded by requiring $\\mu_i < \\mu$ where $\\mu$ is a constant representing the maximum fraction of the shared resources which can be dispersed by any one proposal. In order for the system to be sustainable a source of new resources is required. In the case where $R$ is funding, new funding can come from revenues, donations, or in some DAO use cases minting tokens.\n", + "\n", + "### Participants Preferences for Proposals\n", + "\n", + "Most of the interesting information in this system is distributed amongst the participants and it manifests as preferences over the proposals. This can be thought of as a matrix $W\\in \\mathbb{R}^{n \\times m}$.\n", + "![Replace this later](https://i.imgur.com/vxKNtxi.png)\n", + "\n", + "These private hidden signals drive discussions and voting actions. Each participant individually decides how to allocate their votes across the available proposals. Participant $a$ supports proposal $i$ by setting $x[a,i]>0$ but they are limited by their capacity $\\sum_{k\\in \\mathcal{C}} x[a,k] \\le h[a]$. Assuming each participant chooses a subset of the proposals to support, a support graph is formed.\n", + "![](https://i.imgur.com/KRh8tKn.png)\n", + "\n", + "## Aggregating Information\n", + "\n", + "In order to break out of the synchronous voting model, a dynamical systems model of this system is introduced.\n", + "\n", + "### Participants Allocate Voting Power\n", + "![](https://i.imgur.com/DZRDwk6.png)\n", + "\n", + "### System Accounts Proposal Conviction\n", + "![](https://i.imgur.com/euAei5R.png)\n", + "\n", + "### Understanding Alpha\n", + "https://www.desmos.com/calculator/x9uc6w72lm\n", + "https://www.desmos.com/calculator/0lmtia9jql\n", + "\n", + "\n", + "## Converting Signals to Discrete Decisions\n", + "\n", + "Conviction as kinetic energy and Trigger function as required activation energy.\n", + "\n", + "### The Trigger Function\n", + "\n", + "https://www.desmos.com/calculator/yxklrjs5m3\n", + "\n", + "Below we show a sweep of the trigger function threshold:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/aclarkdata/anaconda3/lib/python3.7/site-packages/statsmodels/tools/_testing.py:19: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.\n", + " import pandas.util.testing as tm\n" + ] + } + ], + "source": [ + "from model.model.conviction_helper_functions import *\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "beta = .2 #later we should set this to be param so we can sweep it\n", + "# tuning param for the trigger function\n", + "rho = .001\n", + "alpha = 1 - 0.9999599" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "supply_sweep = trigger_sweep('effective_supply',trigger_threshold,beta,rho,alpha)\n", + "alpha_sweep = trigger_sweep('alpha',trigger_threshold,beta,rho,alpha)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "trigger_grid(supply_sweep, alpha_sweep)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Resolving Passed Proposals\n", + "\n", + "![](https://i.imgur.com/lmOl9HE.png)\n", + "\n", + "\n", + "## Social Systems Modeling\n", + "\n", + "Subjective, exploratory modeling of the social system interacting through the conviction voting algorithm.\n", + "\n", + "### Sentiment\n", + "\n", + "Global Sentiment -- the outside world appreciating the output of the community\n", + "Local Sentiment -- agents within the system feeling good about the community\n", + "\n", + "### Social Networks\n", + "\n", + "Preferences as mixing process (social influence)\n", + "\n", + "### Relationships between Proposals\n", + "\n", + "Some proposals are synergistic (passing one makes the other more desireable)\n", + "Some proposals are (parially) substitutable (passing one makes the other less desirable)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Schema of the states \n", + "The model consists of a temporal in memory graph database called *network* containing nodes of type **Participant** and type **Proposal**. Participants will have *holdings* and *sentiment* and Proposals will have *funds_required, status*(candidate or active), *conviction* Tthe model as three kinds of edges:\n", + "* (Participant, participant), we labeled this edge type \"influencer\" and it contains information about how the preferences and sentiment of one participant influence another \n", + "* (Proposal, Proposal), we labeled this edge type \"conflict\" and it contains information about how synergistic or anti-synergistic two proposals are; basically people are likely to support multiple things that have synergy (meaning once one is passed there is more utility from the other) but they are not likely to pass things that have antisynergy (meaning once one is passed there is less utility from the other).\n", + "* The edges between Participant and Proposal, which are described below.\n", + " \n", + "\n", + "Edges in the network go from nodes of type Participant to nodes of type Proposal with the edges having the key *type*, of which all will be set to *support*. Edges from participant $i$ to proposal $j$ will have the following additional characteristics:\n", + "* Each pairing (i,j) will have *affinity*, which determines how much $i$ likes or dislikes proposal $j$.\n", + "* Each participant $i$, assigns its $tokens$ over the edges (i,j) for all $j$ such that the summation of all $j$ such that ```Sum_j = network.edges[(i,j)]['tokens'] = network.nodes[i]['holdings']```. This value of tokens for participants on proposals must be less than or equal to the total number of tokens held by the participant.\n", + "* Each pairing (i,j) will have *conviction* local to that edge whose update at each timestep is computed using the value of *tokens* at that edge.\n", + "* Each proposal *j* will have a *conviction* which is equal to the sum of the conviction on its inbound edges: ```network.nodes[j]['conviction'] = Sum_i network.edges[(i,j)]['conviction']```. \n", + "\n", + "\n", + "The other state variable in the model is *funds*, which is a numpy floating point. \n", + "\n", + "The system consists of 100 time steps without a parameter sweep or monte carlo.\n", + "\n", + "\n", + "## Partial State Update Blocks\n", + "\n", + "Each partial state update block is kind of a like a phase in a phased based board game. Everyone decides what to do and it reconciles all decisions. One timestep is a full turn, with each block being a phase of a timestep or turn. We will walk through the individaul Partial State update blocks one by one below." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```\n", + "{\n", + "# system.py: \n", + "'policies': { \n", + " 'random': driving_process\n", + "},\n", + "'variables': {\n", + " 'network': update_network,\n", + " 'funds':increment_funds,\n", + "}\n", + "```\n", + "\n", + "To simulate the arrival of participants and proposal into the system, we have a driving process to represent the arrival of individual agents. We use a random uniform distribution generator, over [0, 1), to calculate the number of new participants. We then use an exponential distribution to calculate the particpant's tokens by using a loc of 0.0 and a scale of expected holdings, which is calculated by .1*supply/number of existing participants. We calculate the number of new proposals by \n", + "```\n", + "proposal_rate = 1/median_affinity * (1+total_funds_requested/funds)\n", + "rv2 = np.random.rand()\n", + "new_proposal = bool(rv2<1/proposal_rate)\n", + "```\n", + "The network state variable is updated to include the new participants and proposals, while the funds state variable is updated for the increase in system funds. \n", + "[To see the partial state update code, click here](model/model/system.py)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```\n", + "{\n", + " # participants.py \n", + " 'policies': {\n", + " 'completion': check_progress \n", + " },\n", + " 'variables': { \n", + " 'sentiment': update_sentiment_on_completion, #note completing decays sentiment, completing bumps it\n", + " 'network': complete_proposal\n", + " }\n", + "},\n", + "```\n", + "\n", + "In the next phase of the turn, [to see the logic code, click here](model/model/participants.py), the *check_progress* behavior checks for the completion of previously funded proposals. The code calculates the completion and failure rates as follows:\n", + "\n", + "```\n", + "likelihood = 1.0/(base_completion_rate+np.log(grant_size))\n", + "\n", + "failure_rate = 1.0/(base_failure_rate+np.log(grant_size))\n", + "if np.random.rand() < likelihood:\n", + " completed.append(j)\n", + "elif np.random.rand() < failure_rate:\n", + " failed.append(j)\n", + "```\n", + "With the base_completion_rate being 100 and the base_failure_rate as 200. \n", + "\n", + "The mechanism then updates the respective *network* nodes and updates the sentiment variable on proposal completion. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```\n", + " # proposals.py\n", + " 'policies': {\n", + " 'release': trigger_function \n", + " },\n", + " 'variables': { \n", + " 'funds': decrement_funds, \n", + " 'sentiment': update_sentiment_on_release, #releasing funds can bump sentiment\n", + " 'network': update_proposals \n", + " }\n", + "},\n", + " ```\n", + " \n", + "The [trigger release function](model/model/proposals.py) checks to see if each proposal passes or not. If a proposal passes, funds are decremented by the amount of the proposal, while the proposal's status is changed in the network object." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```\n", + "{ \n", + " # participants.py\n", + " 'policies': { \n", + " 'participants_act': participants_decisions\n", + " },\n", + " 'variables': {\n", + " 'network': update_tokens \n", + " }\n", + "}\n", + "```\n", + "\n", + "The Participants decide based on their affinity if which proposals they would like to support,[to see the logic code, click here](model/model/participants.py). Proposals that participants have high affinity for receive more support and pledged tokens than proposals with lower affinity and sentiment. We then update everyone's holdings and their conviction for each proposal.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model next steps\n", + "\n", + "The the model described above is the second iteration model that covers the core mechanisms of the Aragon Conviction Voting model. Below are next additional dynamics we can attend to enrich the model, and provide workstreams for subsequent iterations of this lab notebook.\n", + "\n", + "* Mixing of token holdings among participants\n", + "* Departure of participants\n", + "* Proposals which are good or no good together\n", + "* Multiple proposal stages such as killed, failed and completed\n", + "* Affects of outcomes on sentiment" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Simulation\n", + "\n", + "## cadCAD Overview\n", + "\n", + "In the cadCAD simulation [methodology](https://community.cadcad.org/t/differential-specification-syntax-key/31), we operate on four layers: **Policies, Mechanisms, States**, and **Metrics**. Information flows do not have explicit feedback loop unless noted. **Policies** determine the inputs into the system dynamics, and can come from user input, observations from the exogenous environment, or algorithms. **Mechanisms** are functions that take the policy decisions and update the States to reflect the policy level changes. **States** are variables that represent the system quantities at the given point in time, and **Metrics** are computed from state variables to assess the health of the system. Metrics can often be thought of as KPIs, or Key Performance Indicators. \n", + "\n", + "At a more granular level, to setup a model, there are system conventions and configurations that must be [followed.](https://community.cadcad.org/t/introduction-to-simulation-configurations/34)\n", + "\n", + "The way to think of cadCAD modeling is analogous to machine learning pipelines which normally consist of multiple steps when training and running a deployed model. There is preprocessing, which includes segregating features between continuous and categorical, transforming or imputing data, and then instantiating, training, and running a machine learning model with specified hyperparameters. cadCAD modeling can be thought of in the same way as states, roughly translating into features, are fed into pipelines that have built-in logic to direct traffic between different mechanisms, such as scaling and imputation. Accuracy scores, ROC, etc. are analogous to the metrics that can be configured on a cadCAD model, specifying how well a given model is doing in meeting its objectives. The parameter sweeping capability of cadCAD can be thought of as a grid search, or way to find the optimal hyperparameters for a system by running through alternative scenarios. A/B style testing that cadCAD enables is used in the same way machine learning models are A/B tested, except out of the box, in providing a side by side comparison of muliple different models to compare and contrast performance. Utilizing the field of Systems Identification, dynamical systems models can be used to \"online learn\" by providing a feedback loop to generative system mechanisms. \n", + "\n", + "\n", + "## Differential Specification \n", + "![](images/Aragon_v2.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Configuration\n", + "Let's factor out into its own notebook where we review the config object and its partial state update blocks." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from model import economyconfig" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# pull out configurations to illustrate\n", + "sim_config,genesis_states,seeds,partial_state_update_blocks = economyconfig.get_configs()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'N': 1, 'T': range(0, 100), 'M': [{}], 'simulation_id': 0, 'run_id': 0}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sim_config" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'policies': {'random': },\n", + " 'variables': {'network': ,\n", + " 'funds': }},\n", + " {'policies': {'completion': },\n", + " 'variables': {'sentiment': ,\n", + " 'network': }},\n", + " {'policies': {'release': },\n", + " 'variables': {'funds': ,\n", + " 'sentiment': ,\n", + " 'network': }},\n", + " {'policies': {'participants_act': },\n", + " 'variables': {'network': }}]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "partial_state_update_blocks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Initialization\n", + "To create the genesis_states, we create our in-memory graph database within networkx. \n", + "\n", + "\n", + "### Hyperparameters\n", + "* $\\beta$ = .2 # maximum share of funds a proposal can take\n", + "* $\\rho$ = 0.002 # tuning param for the trigger function\n", + "* $\\alpha$ = 1 - 0.9999599\n", + "* supply = 21706 # Honey supply balance as of 7-17-2020 \n", + "* initial_sentiment = .9\n", + "* n= 24 #initial participants\n", + "* m= 3 #initial proposals\n", + "* sensitivity = .75\n", + "* tmin = 7 #unit days; minimum periods passed before a proposal can pass\n", + "* min_supp = 50 #number of tokens that must be stake for a proposal to be a candidate\n", + "* base_completion_rate = 100\n", + "* base_failure_rate = 200 \n", + "* initial_funds = 48000 # in xDai" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# import libraries\n", + "import networkx as nx\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from model.model.conviction_helper_functions import * \n", + "\n", + "# Parameters\n", + "# maximum share of funds a proposal can take\n", + "beta = .2 #later we should set this to be param so we can sweep it\n", + "# tuning param for the trigger function\n", + "rho = 0.002\n", + "alpha = 1 - 0.9999599\n", + "supply = 21706 # Honey supply balance as of 7-17-2020 \n", + "initial_sentiment = .9\n", + "\n", + "\n", + "n= 24 #initial participants\n", + "m= 3 #initial proposals\n", + "\n", + "\n", + "sensitivity = .75\n", + "tmin = 7 #unit days; minimum periods passed before a proposal can pass\n", + "min_supp = 50 #number of tokens that must be stake for a proposal to be a candidate\n", + "base_completion_rate = 100\n", + "base_failure_rate = 200 \n", + "\n", + "initial_funds = 48000 # in xDai\n", + "\n", + "def initialize_network(n,m, inital_funds, supply):\n", + " '''\n", + " Definition:\n", + " Function to initialize network x object\n", + "\n", + " Parameters:\n", + "\n", + " Assumptions:\n", + "\n", + " Returns:\n", + "\n", + " Example:\n", + " '''\n", + " # initilize network x graph\n", + " network = nx.DiGraph()\n", + " # create participant nodes with type and token holding\n", + " for i in range(n):\n", + " network.add_node(i)\n", + " network.nodes[i]['type']= \"participant\"\n", + " \n", + " h_rv = expon.rvs(loc=0.0, scale= supply/n)\n", + " network.nodes[i]['holdings'] = h_rv # SOL check\n", + " \n", + " s_rv = np.random.rand() \n", + " network.nodes[i]['sentiment'] = s_rv\n", + " \n", + " participants = get_nodes_by_type(network, 'participant')\n", + " initial_supply = np.sum([ network.nodes[i]['holdings'] for i in participants])\n", + " \n", + " \n", + " # Generate initial proposals\n", + " for ind in range(m):\n", + " j = n+ind\n", + " network.add_node(j)\n", + " network.nodes[j]['type']=\"proposal\"\n", + " network.nodes[j]['conviction'] = 0\n", + " network.nodes[j]['status'] = 'candidate'\n", + " network.nodes[j]['age'] = 0\n", + " \n", + " r_rv = gamma.rvs(3,loc=0.001, scale=100)\n", + " network.nodes[j]['funds_requested'] = r_rv\n", + " \n", + " network.nodes[j]['trigger']= trigger_threshold(r_rv, initial_funds, initial_supply,beta,rho,alpha)\n", + " \n", + " for i in range(n):\n", + " network.add_edge(i, j)\n", + " \n", + " rv = np.random.rand()\n", + " a_rv = np.random.uniform(-1,1,1)[0]\n", + " network.edges[(i, j)]['affinity'] = a_rv\n", + " network.edges[(i, j)]['tokens'] = 0\n", + " network.edges[(i, j)]['conviction'] = 0\n", + " network.edges[(i, j)]['type'] = 'support'\n", + " \n", + " proposals = get_nodes_by_type(network, 'proposal')\n", + " total_requested = np.sum([ network.nodes[i]['funds_requested'] for i in proposals])\n", + " \n", + " network = initial_conflict_network(network, rate = .25)\n", + " network = initial_social_network(network, scale = 1)\n", + " \n", + " return network, initial_funds\n", + "#initializers\n", + "network, initial_funds = initialize_network(n,m,initial_funds,supply)\n", + "\n", + "\n", + "\n", + "# Create initial states\n", + "genesis_states = { \n", + " 'network':network,\n", + " 'funds':initial_funds,\n", + " 'sentiment':initial_sentiment,\n", + "\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'network': ,\n", + " 'funds': 48000,\n", + " 'sentiment': 0.9}" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "genesis_states" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Exploring the State Data Structure\n", + "\n", + "A graph is a type of temporal data structure that evolves over time. A graph $\\mathcal{G}(\\mathcal{V},\\mathcal{E})$ consists of vertices or nodes, $\\mathcal{V} = \\{1...\\mathcal{V}\\}$ and is connected by edges $\\mathcal{E} \\subseteq \\mathcal{V} \\times \\mathcal{V}$.\n", + "\n", + "See *Schema of the states* above for more details\n", + "\n", + "\n", + "Let's explore!" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# To explore our model prior to the simulation, we extract key components from our networkX object into lists.\n", + "proposals = get_nodes_by_type(network, 'proposal')\n", + "participants = get_nodes_by_type(network, 'participant')\n", + "supporters = get_edges_by_type(network, 'support')\n", + "influencers = get_edges_by_type(network, 'influence')\n", + "competitors = get_edges_by_type(network, 'conflict')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'type': 'participant',\n", + " 'holdings': 893.6452645743616,\n", + " 'sentiment': 0.102446375901169}" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#sample a participant\n", + "network.nodes[participants[0]]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Count of Participants')" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Let's look at the distribution of participant holdings at the start of the sim\n", + "plt.hist([ network.nodes[i]['holdings'] for i in participants])\n", + "plt.title('Histogram of Participants Token Holdings')\n", + "plt.xlabel('Amount of Honey')\n", + "plt.ylabel('Count of Participants')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Participants Social Network')" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nx.draw_kamada_kawai(network, nodelist = participants, edgelist=influencers)\n", + "plt.title('Participants Social Network')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'type': 'proposal',\n", + " 'conviction': 0,\n", + " 'status': 'candidate',\n", + " 'age': 0,\n", + " 'funds_requested': 533.7442840291636,\n", + " 'trigger': 862.188323033792}" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#lets look at proposals\n", + "network.nodes[proposals[0]]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Proposals initially start without any conviction, and with the status of a candidate. If the proposal's amount of conviction is greater than it's trigger, then the proposal moves to active and it's funds requested are granted. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All initial proposal start with 0 conviction and state 'candidate'we can simply examine the amounts of funds requested" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Amount of Honey requested')" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.bar( proposals, [ network.nodes[i]['funds_requested'] for i in proposals])\n", + "plt.title('Bar chart of Proposals Funds Requested')\n", + "plt.xlabel('Proposal identifier')\n", + "plt.ylabel('Amount of Honey requested')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Conviction is a concept that arises in the edges between participants and proposals in the initial conditions there are no votes yet so we can look at that later however, the voting choices are driven by underlying affinities which we can see now." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 104.1, 'participant_id')" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "affinities = np.empty((n,m))\n", + "for i_ind in range(n):\n", + " for j_ind in range(m):\n", + " i = participants[i_ind]\n", + " j = proposals[j_ind]\n", + " affinities[i_ind][j_ind] = network.edges[(i,j)]['affinity']\n", + "\n", + "dims = (20, 5)\n", + "fig, ax = plt.subplots(figsize=dims)\n", + "\n", + "sns.heatmap(affinities.T,\n", + " xticklabels=participants,\n", + " yticklabels=proposals,\n", + " square=True,\n", + " cbar=True,\n", + " ax=ax)\n", + "\n", + "plt.title('affinities between participants and proposals')\n", + "plt.ylabel('proposal_id')\n", + "plt.xlabel('participant_id')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run simulation\n", + "\n", + "Now we will create the final system configuration, append the genesis states we created, and run our simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "from cadCAD.configuration import append_configs\n", + "\n", + "# Create configuration\n", + "append_configs(\n", + " sim_configs=sim_config,\n", + " initial_state=genesis_states,\n", + " seeds=seeds,\n", + " partial_state_update_blocks=partial_state_update_blocks\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " ___________ ____\n", + " ________ __ ___/ / ____/ | / __ \\\n", + " / ___/ __` / __ / / / /| | / / / /\n", + "/ /__/ /_/ / /_/ / /___/ ___ |/ /_/ /\n", + "\\___/\\__,_/\\__,_/\\____/_/ |_/_____/\n", + "by cadCAD\n", + "\n", + "Execution Mode: local_proc\n", + "Configuration Count: 2\n", + "Dimensions of the first simulation: (Timesteps, Params, Runs, Vars) = (100, 1, 1, 3)\n", + "Execution Method: local_simulations\n", + "Execution Mode: parallelized\n", + "Total execution time: 9.99s\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from model.model.conviction_helper_functions import *\n", + "from model import run\n", + "from cadCAD import configs\n", + "pd.options.display.float_format = '{:.2f}'.format\n", + "\n", + "%matplotlib inline\n", + "\n", + "# Pass in configuration to run\n", + "df = run.run(configs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After the simulation has run successfully, we perform some postprocessing to extract node and edge values from the network object and add as columns to the pandas dataframe. For the rdf, we take only the values at the last substep of each timestep in the simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "df= run.postprocessing(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "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", + " \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", + " \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", + "
networkfundssentimentsimulationrunsubsteptimestepconvictioncandidate_countcandidate_funds...funds_requestedshare_of_funds_requestedshare_of_funds_requested_alltriggersconviction_share_of_triggerageage_allconviction_alltriggers_allconviction_share_of_trigger_all
785(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,...46982.840.9111496[]00.00...[533.7442840291636, 101.99039020309893, 681.00...[][0.011360408350392771, 0.002170800728349896, 0...[][][][96, 96, 96, 37][nan, nan, 0.0, nan][nan, nan, nan, nan][nan, nan, nan, nan]
789(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,...46991.860.9011497[]00.00...[533.7442840291636, 101.99039020309893, 681.00...[][0.01135822863874518, 0.002170384218706383, 0....[][][][97, 97, 97, 38][nan, nan, 0.0, nan][nan, nan, nan, nan][nan, nan, nan, nan]
793(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,...46997.550.9011498[]00.00...[533.7442840291636, 101.99039020309893, 681.00...[][0.0113568542037439, 0.002170121585145174, 0.0...[][][][98, 98, 98, 39][nan, nan, 0.0, nan][nan, nan, nan, nan][nan, nan, nan, nan]
797(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,...47001.320.8911499[]00.00...[533.7442840291636, 101.99039020309893, 681.00...[][0.011355942408387219, 0.0021699473549623024, ...[][][][99, 99, 99, 40][nan, nan, 0.0, nan][nan, nan, nan, nan][nan, nan, nan, nan]
801(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,...47002.120.88114100[]00.00...[533.7442840291636, 101.99039020309893, 681.00...[][0.011355749547503383, 0.0021699105021895683, ...[][][][100, 100, 100, 41][nan, nan, 0.0, nan][nan, nan, nan, nan][nan, nan, nan, nan]
\n", + "

5 rows × 29 columns

\n", + "
" + ], + "text/plain": [ + " network funds sentiment \\\n", + "785 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,... 46982.84 0.91 \n", + "789 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,... 46991.86 0.90 \n", + "793 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,... 46997.55 0.90 \n", + "797 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,... 47001.32 0.89 \n", + "801 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,... 47002.12 0.88 \n", + "\n", + " simulation run substep timestep conviction candidate_count \\\n", + "785 1 1 4 96 [] 0 \n", + "789 1 1 4 97 [] 0 \n", + "793 1 1 4 98 [] 0 \n", + "797 1 1 4 99 [] 0 \n", + "801 1 1 4 100 [] 0 \n", + "\n", + " candidate_funds ... funds_requested \\\n", + "785 0.00 ... [533.7442840291636, 101.99039020309893, 681.00... \n", + "789 0.00 ... [533.7442840291636, 101.99039020309893, 681.00... \n", + "793 0.00 ... [533.7442840291636, 101.99039020309893, 681.00... \n", + "797 0.00 ... [533.7442840291636, 101.99039020309893, 681.00... \n", + "801 0.00 ... [533.7442840291636, 101.99039020309893, 681.00... \n", + "\n", + " share_of_funds_requested \\\n", + "785 [] \n", + "789 [] \n", + "793 [] \n", + "797 [] \n", + "801 [] \n", + "\n", + " share_of_funds_requested_all triggers \\\n", + "785 [0.011360408350392771, 0.002170800728349896, 0... [] \n", + "789 [0.01135822863874518, 0.002170384218706383, 0.... [] \n", + "793 [0.0113568542037439, 0.002170121585145174, 0.0... [] \n", + "797 [0.011355942408387219, 0.0021699473549623024, ... [] \n", + "801 [0.011355749547503383, 0.0021699105021895683, ... [] \n", + "\n", + " conviction_share_of_trigger age age_all \\\n", + "785 [] [] [96, 96, 96, 37] \n", + "789 [] [] [97, 97, 97, 38] \n", + "793 [] [] [98, 98, 98, 39] \n", + "797 [] [] [99, 99, 99, 40] \n", + "801 [] [] [100, 100, 100, 41] \n", + "\n", + " conviction_all triggers_all \\\n", + "785 [nan, nan, 0.0, nan] [nan, nan, nan, nan] \n", + "789 [nan, nan, 0.0, nan] [nan, nan, nan, nan] \n", + "793 [nan, nan, 0.0, nan] [nan, nan, nan, nan] \n", + "797 [nan, nan, 0.0, nan] [nan, nan, nan, nan] \n", + "801 [nan, nan, 0.0, nan] [nan, nan, nan, nan] \n", + "\n", + " conviction_share_of_trigger_all \n", + "785 [nan, nan, nan, nan] \n", + "789 [nan, nan, nan, nan] \n", + "793 [nan, nan, nan, nan] \n", + "797 [nan, nan, nan, nan] \n", + "801 [nan, nan, nan, nan] \n", + "\n", + "[5 rows x 29 columns]" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.tail()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABA8AAAEeCAYAAADl8jxCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO3deZwsVX3+8c9z2XcEFJFVEY1oBANojEZR1OASiCsa3I38osEt0URjoiiucYtLjKIiRFFR1IiKihtqVBBEUBZBFBCQCwIqICDLfH9/VI00l+m6093V3Jm5n/d99ev2dFc/dar7VHfX6XNOpaqQJEmSJEkaZtmqLoAkSZIkSVrYbDyQJEmSJEmdbDyQJEmSJEmdbDyQJEmSJEmdbDyQJEmSJEmdbDyQJEmSJEmd1lzVBZAkSZIkaSm64bJf1KiPWWuLu2QaZZmUPQ8kSZIkSVInex5IkiRJkjQNMzet6hL0xsYDSZIkSZKmoWZWdQl6Y+OBJEmSJEnTMGPjgSRJkiRJ6lD2PJAkSZIkSZ3seSBJkiRJkjrZ80CSJEmSJHXybAuSJEmSJKmTPQ8kSZIkSVIn5zyQJEmSJEldPNuCJEmSJEnqZs8DSZIkSZLUyZ4HkiRJkiSpk2dbkCRJkiRJnex5IEmSJEmSOjnngSRJkiRJ6rSEeh4sW9UFkCRJkiRJC5s9DyRJkiRJmgaHLUiSJEmSpC5Vnm1BkiRJkiR1WUJzHth4IEmSJEnSNCyhYQtOmChJkiRJ0jTUzOiXeUiyd5KzkpyT5OVz3L9dkm8m+VGSHyd51KSbYs8DSZIkSZKmYab/OQ+SrAH8F/Bw4ELgxCRHV9UZA4v9G/DJqvrvJDsDxwA7TLJeex5IkiRJkjQN0+l5cF/gnKr6RVVdD3wC2HfFNQMbt9c3AX416abY80CSJEmSpGmYzpwHWwMXDPx9IXC/FZY5CDg2yQuADYCHTbpSex5IkiRJkjQNY/Q8SHJAkpMGLgeMseanAIdV1TbAo4CPJJno+N+eB5IkSZIkTcMYPQ+q6hDgkI5FLgK2Hfh7m/a2Qc8B9m7zvp9kXWAL4NKRC9Sy54EkSZIkSdMwMzP6ZeVOBHZKcuckawNPBo5eYZlfAnsBJLkHsC7w60k2xZ4HkiRJkiRNQVX/Z1uoqhuTHAh8BVgDOLSqTk/yWuCkqjoa+CfgA0leQjN54jOrqiZZbyZ8vCRJkiRJmsO1xx068gH3ens+O9Moy6TseSBJkiRJ0jTM79SLi4KNB5IkSZIkTcN0TtW4Sth4IEmSJEnSNCyhngeebUGSJEmSJHWy54EkSZIkSdPgsAVJkiRJktRpCQ1bsPFAkiRJkqRpsOeBJEmSJEnqZOOBJEmSJEnq5LAFSZIkSZLUyZ4HkiRJkiSpkz0PJEmSJElSJ3seSJIkSZKkTvY8kCRJkiRJnex5IEmSJEmSOtl4IEmSJEmSOlWt6hL0xsYDSZIkSZKmwZ4HkiRJkiSpk40HkiRJkiSpk2dbkCRJkiRJnZZQz4Nlq7oAkiRJkiRpYbPngSRJkiRJ0+DZFiRJkiRJUqclNGzBxgNJkiRJkqbBxgNJkiRJktTJsy1IkiRJkqQuNeOcB5IkSZIkqYvDFiRJkiRJUieHLUiSJEmSpE4OW5AkSZIkSZ0ctiBJkiRJkjrZeCBJkiRJkjqVwxYkSZIkSVIXex5IkiRJkqROTpgoSZIkSZI6eapGSZIkSZLUyZ4HkiRJkiSpSy2hOQ+WreoCSJIkSZKkhc2eB5IkSZIkTYPDFiRJkiRJUicnTJQkSZIkSZ3seSBJkiRJkjotoQkTbTyQJEmSJGka7HkgSZIkSZI6OeeBJEmSJEnqZM8DSZIkSZLUpZbQnAfLVnUBJEmSJElakmZq9Ms8JNk7yVlJzkny8o7lHp+kkuw+6abYeCBJC0yS1yW5LMny9u/HJrkgydVJ7pPk9CR7zjOrc9kkX0ryjH5K/sfM45L8XZ+Zq5v2tb7LSpbZrl1ujduqXKtaksOSvG5Vl2Na2i93d13V5ZAk9WgKjQftZ/9/AY8EdgaekmTnOZbbCHgRcEIfm2LjgSQtIEm2A/4J2Lmq7tje/FbgwKrasKp+VFX3rKrj5pM3uGySg5J8dIX7H1lVh/e3BZNZHRse5trm9rX+RdfjquqX7XI3TbeEHtRKkjS2mhn9snL3Bc6pql9U1fXAJ4B951juYODNwHV9bIqNB5K0sGwHXF5Vlw7ctj1w+ioqj6YkDT+HVwGfe0nSbWY6wxa2Bi4Y+PvC9rY/SvJnwLZV9cW+NsUPTkm6jSV5eZKfJ7kqyRlJHtve/jDgq8Cd2u7oH09yNbAGcGqSn7fLndcuO9ub4JNJ/qfNO31wTNvsskn2Bv4V2K/NPrW9/xa/eid5dpIzk/wmyVeSbN/eniTvSHJpkiuT/CTJvTo2c8ckP2iX/VySzQbW8edJvpfkt0lOnR1WkeT1wF8C72nL+J4kr0ny7vb+tZL8Pslb2r/XS3LdbPaw3Pa+TZJ8KMnFSS5qh4as0d73zCT/l+St7Xafm+SRHa/feUle0b52v0ny4STrtvfdLskXkvy6ve8LSbYZeOxxSV6f5LvANcBHVtzmdrk//tLfbufbkpyf5HdtWddLskO73JoD2W/seN4/lWR5m/HtJPccuO+wJP+V5IttPTohyY7tfd9uFzu1LeN+SbZot+23Sa5I8p0MORhP8s40w26uTPLDJH85cN/K6u99kpzc3ncksG7H6/LMJN9t683vkvw0yV4dz/1dkvxFkhPb5U9M8hcrLN/1fO7Tlve37bL3GLjvX9p6dlWa8ah7tbffN8n328dc3JZ17SHb86i2jl3VZr102LZLkhaumqmRL0kOSHLSwOWAUdbZfia/naY3a29sPJCk297PaQ4YNwFeA3w0yVZV9TWasWu/arujP6WqNmwfs0tV7Tgkbx+a7mqbAkcD71lxgar6MvAG4Mg2e5cVl0myL00Dw+OA2wPfAT7e3v0I4EHA3dpyPwm4vGMbnw48G9gKuBF4V7uOrYEvAq8DNgNeCnw6ye2r6pXtOmeHaBwIfAvYs83cA1jelgPg/sBZVXVFV2677GFtOe4K3KfdnsGhAvcDzgK2AP4D+FCSdGzf/sBfATu2z8m/tbcvAz5M01tkO+Babv16PA04ANgIeOYc27yitwK7AX/Rbts/A8P6NM75vLe+BOwE3AE4GThihcc+maY+3g44B3g9QFXNPt+7tGU8kubLyIU09WRLmnoz7KeSE4Fd27J/DPjUbGNLa8762x5U/y9NA8tmwKeAxw9Zx6z70exfWwCvBj4zeMDPLZ/7q2jqzLuAzWm+ZH0xyeYDyw+rx3ej2Tde3D4HxwCfT7J2krsDBwJ7VNVGNPXkvDbvJuAlbfnuD+wFPH/ItnwI+H9txr2Ab6xk2yVJC9EYPQ+q6pCq2n3gcsgKqRcB2w78vU1726zZz47jkpwH/DlwdCacNNHGA0m6jVXVp6rqV1U10x6I/Yxm7Nq4/q+qjmnHvn8EuFXDwDz9PfDGqjqzqm6kaWzYNU3vgxtoPoj+BEi7zMUdWR+pqtOq6vfAvwNPSvNL/1OBY9ryzlTVV4GTgEcNyfk+sFN7QPcgmgOqrZNsCDyYpnGBrtwkW7b5L66q37dDQt5Bc7A86/yq+kD7HB5Oc7C4Zcf2vaeqLqiqK2gOsp8CUFWXV9Wnq+qaqrqqve/BKzz2sKo6vapurKobOtYx+8vBs4EXVdVFVXVTVX2vqv4w5CHDnneq6tCquqp97EHALkk2GXjsZ6vqB+1rfwTNAf8wN9A8R9tX1Q1V9Z2qmrPxoKo+2j4vN1bV24B1gLsPLDKs/v45sBbwn+06jqJpiOhy6cDyR9I0CD164P4/Pvc0DUg/q6qPtGX7OPBT4K8Hlh/2fO4HfLGqvtq+hm8F1qNp4Lmp3cadk6xVVedV1c/b5+KHVXV8u77zgPdz6/ox64Y2Y+Oq+k1VnbySbZckLUQzM6NfVu5Emu9Hd24b259M0wAPQFX9rqq2qKodqmoH4Hhgn6o6aZJNsfFAkm5jSZ6e5JS26/JvaVqGt5ggcvnA9WuAdWe7so9oe+CdA+W6AgiwdVV9g+YX4f8CLk1ySJKNO7IGx+GdT3MQuEW7jifOrqNdzwNpDkRvpaqupWkEeDBN48G3gO8BD+CWjQddudu367944L730/wCP+uPz2FVXdNe3ZDhVty+OwEkWT/J+9MMMbgS+DawaW55RoTBx67MFjRd9X8+z+XnfN6TrJHkTWmGy1zJzb+ED9a7FetR1/a/haZ3wrFJfpHuU0S9NM1QmN+1z/0mK1nvbP29E3DRCo0S53eUiSHL32ng78Hn505z5J3PLceMDqvHt3hsVc20y25dVefQ9Eg4iGZf+USS2fpxtzTDPZa3r8MbGL7vP56m0ev8JN9Kcv/hmy1JWrCmMOdB2wh+IPAV4Ezgk1V1epLXJtlnWpti44Ek3YbaX/E/QPOGv3lVbQqcRnOQPm0r+zS6gKab9KYDl/Wq6nsAVfWuqtqN5pRAdwNe1pE12JVuO5pfUS9r1/GRFdaxQVW9qaOM3wIeSjPc4MT277+i6a0xOx6/K/cC4A/AFgP3bVxV97z1quZtxe37VXv9n2h+Vb9fVW3MzUMsBl/fFbex63W5jGaG5GFDVlZWrtnn/W9pZmF+GM3B+w5zlGve2h4M/1RVd6EZdvCPg/MLzEozv8E/0wxzuV1b3383z/VeTNPLZHDZ7VbymLmW/9XA34PP9a9oGpYGbcctu30Oez5v8dh2ndvOPraqPlZVD2yXKZqZrgH+m6Z3w05t/fhXhjwXVXViVe1L08j1v8An595kSdKCNp0JE2l77d2tqnasqtmhhq+qqqPnWHbPSXsdgI0HknRb24DmYOLXAEmeRdPz4LZwCbBDhs8y/z7gFWkn0kszyeAT2+t7JLlfkrWA39Mc0Hb1q3tqkp2TrA+8Fjiq7Zb+UeCvk/xV+2v4ukn2zM2TCl4C3GWFrG/RjD0/o5rTER1HM1/BuVX163aZobnt8Ipjgbcl2TjJsiQ7JhnWXXw+/iHJNu14+lcCR7a3b0Qzz8Fv2/tePY+subYZ+OMv2ocCb09yp3bb7p9knSFZw573jWgaUC4H1qf5xXsUtyhjksckuWt70Pw7mq76c9WHjWjmCvg1sGaSVwFdPVYGfb997AvTTJb5OFY+vOcOA8s/EbgHzXwEczkGuFuSv02yZpL9aBrGvjCwzLDn85PAo5Ps1e4T/0Tz/H4vyd2TPLR9ja6jqQ+zz81GwJXA1Un+BHjeXAVr507YP8km7bCIK+ne3yRJmjobDyTpNlRVZwBvozkwugT4U+C7t9HqP9X+f3mSW42frqrP0vxC+om2S/VpNBM4QnPA9wHgNzTdtS+n6bo+zEdoJilcTtPt/oXtOi6g+QX8X2kOKC+g6cEw+3n0TuAJac5UMDvZ3/doxpPP9jI4g+agbPbv+eQ+HVi7fexvgKMYMlRinj5G0yDxC5ohBa9rb//PtqyX0Ywv/PI8suba5kEvBX5C0+viCprXaNjn95zPO/A/NK/bRTTPwfHzKNegg4DD22EfT6KZePFrwNU0dfm9VfXNOR73FZrn4Ox2/dcxz2EbbUPR42gmlbyCZp6Bz6zkYSe0ZbuMZr6JJ1TVnBN7trc/hubA/3KaHhKPqarLBhYbVo/Popln493tuv4a+Ou2zOsAb2pvX07ToPGKNu+lNL1ArqLZn2YbnebyNOC8dl/8e5pJOiVJi0xVjXxZqLKQCydJ0kKTZtbiv6vm7BgLRpLjgI9W1QdXdVlWhSTPpHldHthT3nGsxs+nJKkfVz73ESMfcG/8gWNvi+GsIxtnQi1JkiRJkrQy85zDYDGw8UCSJEmSpCmoJdR44LAFSZIkSZKm4HfP2GvkA+5NDv+6wxYkSZIkSVptLKFz5SzoxoOvb7lfr90i1kr/r9z6a97Qe+Zvbhh2Bq7xbbxGv+Vcf53+t/sPN6zRe+Zmt7um98yfX3q7XvPWzU295sF0TqOy9hr9l3PD9f/Qe+aNN/Zbjy6/Zt1e8wBumMIrtAb99yLbauOre827YQr7+PrrX9975tmX97uPA2zY835+TfX/XG6QG3vP3HyDa3vPvPz36/Wat8VG/X9ObP/iOc+8OZE9Xnti75kn7L9lr3kHf2aDXvMA3nfZD3rPXH/N/r9nHb7OvXvPfOC/btpr3pp//exe8wBuuvCM3jO5tt/PHoAbv/SVXvMO+/QmveYB/P0PXtl75rd3Paj3zKvT/+fPvss/tiB/Ze/LUhq2sKAbDyRJkiRJWrRsPJAkSZIkSZ0ctiBJkiRJkro4bEGSJEmSJHWz54EkSZIkSepizwNJkiRJktTNngeSJEmSJKlL2XggSZIkSZI62XgwniR3qKpLb8t1SpIkSZK0KtjzYB6SbLbiTcAPktwHSFVdMa11S5IkSZKk/kyz58FlwPkr3LY1cDJQwF3melCSA4ADAF680W48Zr0dp1hESZIkSZKmZAn1PFg2xeyXAWcB+1TVnavqzsCF7fU5Gw4AquqQqtq9qna34UCSJEmStFjVzOiXhWpqPQ+q6m1JjgTekeQC4NU0PQ4kSZIkSVryFnJjwKimOmFiVV0IPDHJPsBXgfWnuT5JkiRJkhYKGw/mKcmf0Mxz8A2axoMd29v3rqovT3PdkiRJkiStUpVVXYLeTG3OgyQvBD4HvAA4DXhEVZ3W3v2Gaa1XkiRJkqSFYLWa8yDJVXTMVVBVGw+567nAblV1dZIdgKOS7FBV76Q5baMkSZIkSUtWzSydQ9+VNh5U1UYASQ4GLgY+QnPwvz+wVcdDl1XV1W3GeUn2pGlA2B4bDyRJkiRJS9xC7kkwqlGGLexTVe+tqquq6sqq+m9g347lL0my6+wfbUPCY4AtgD8dr7iSJEmSJC0OVRn5slCN0njw+yT7J1kjybIk+wO/71j+6cDywRuq6saqejrwoDHKKkmSJEnSorGU5jxI1dDpDG65YDNvwTuBB9DMgfBd4MVVdd6UysY2m91rfoWbp+VX/6bPOADef4eH9J7595d+s/fMH97pz3rN+5Nv/HuveQCfe8A7e8984I6/6j1z05c9ste8c178nV7zAO568L17zzz/tT/qPXOHD+/fe+bZ+3+i17yNN72u1zyALR7W/1lr7/jeH/eeedn/9btPLtv0jr3mAVz+9H/pPXO9rXuPZL03vLHXvPrdpb3mAZy2z6G9Z+533S97z/zhXpv0mrf+m9/Sax7Adrs+rffMv9+k389xgPf85sRe89ZctkaveQA/3u0OvWdu+pH39p55xZP/offMPX/a9Rvd6LZbZ/Ne8wBedn2/+yPAwWte1nvmMU/tt5wXfe7aXvMA7rjH9b1n7vW1/jM/t8NavWdu/f1vLNyf2ntwwR57jXxMu+2JX1+Qz8m8T9XYNhJ0DVOQJEmSJEmtef5WvyjM52wL/1xV/5Hk3cxx1oWqeuFUSiZJkiRJ0iK2Wp1tATiz/f+kaRZEkiRJkqSlZLVqPKiqz7f/H961XJJ3V9UL+iqYJEmSJEmL2Wo1bGEED+gxS5IkSZKkRW0p9TwY5VSNkiRJkiRpNdRnzwNJkiRJktSqWjo9D/psPFg6z4okSZIkSROqmVVdgv70OWzhnYN/JNl74PomST6U5MdJPpZkyx7XK0mSJEnSgjNTGfmyUK2050GSzwND54isqn3a/w9b4a43AF9ur78NuBj4a+BxwPuBvxm9uJIkSZIkLQ6r27CFt/awnt2ratf2+juSPGPYgkkOAA4A2HT9rdhgnc16WL0kSZIkSbetpXS2hZU2HlTVt8bMvkOSf6SZC2HjJKn641kuhw6XqKpDgEMAttnsXkvorJiSJEmSpNVJLaEj2nlPmJhkJ+CNwM7AurO3V9VdhjzkA8BG7fXDgS2AXye5I3DKWKWVJEmSJGmRWK16Hgz4MPBq4B3AQ4Bn0d2D4DVJ/gTYGjihqq5ub1+e5GPjF1mSJEmSpIVvIU+AOKpRzrawXlV9HUhVnV9VBwGPHrZwkhcAnwNeAJyWZN+Bu98wTmElSZIkSVosqjLyZaEapefBH5IsA36W5EDgImDDjuUPAHarqquT7AAclWSHqnonzTwIkiRJkiQtWUtpzoNReh68CFgfeCGwG/A0YOhZE4BlA0MVzgP2BB6Z5O3YeCBJkiRJWuJmKiNf5iPJ3knOSnJOkpfPcf86SY5s7z+h/UF/IvNuPKiqE6vq6qq6EHgO8MyqOr7jIZckmT09I21DwmNoJk7803ELLEmSJEnSYjCNYQtJ1gD+C3gkzQkNnpJk5xUWew7wm6q6K828hW+edFvm3XiQ5GNJNk6yAXAacEaSl3U85OnA8sEbqurGqno68KCxSitJkiRJ0iJRNfplHu4LnFNVv6iq64FPAPuusMy+NGc9BDgK2CvJRCMARpnzYOequjLJ/sCXgJcDPwTeMtfCbQ+FOVXVd+ezwrWyxgjFW7ltN9qi1zyAP0xhAMbvf/b53jP//cFzvkxje82l5/aaB/CY9+3Se+arXzTTe+ZRz/l475mvX3vFhsLJ7HD8j3rNA9jwdtf1nvmsv/1U75lfvOz0XvOWv+QRveYBvOkdV/Weuck66/eeee0b395r3l2+NPRjYWwf3vC+vWfu/cZH9p75h/94da95a2x7+17zAI5ec4PeM7+5w+16z/zE97bqNe/wB3T9DjKec9/zuN4zf/ZvP+4986XPu1fvmV/8n/V6zdvwCZv1mgfwo93/vffMD67d/z55/MNHGV28cud+Z51e8wC2uffylS80ou3O3rz3zAs/2+93mON/338Z93v4tr1nPvlbF/Se+daLb+w98x29Jy4sUzrbwtbA4At8IXC/YctU1Y1JfgdsDlw27kpHeVdaK8lawN8AR1fVDcASmv5BWjX6bjiQJGlV6LvhQJKWgnGGLSQ5IMlJA5cDVvV2wGg9D94PnAecCnw7yfbAldMolCRJkiRJi904PQ+q6hDgkI5FLgIGu6ts09421zIXJlkT2AS4fOTCDBhlwsR3VdXWVfWoapwPPGSSlUuSJEmSpJGcCOyU5M5J1gaeDBy9wjJHc/PZEZ8AfKNqshNHjjJh4iZJ3j7QdeJtQP8DJCVJkiRJWgJqjMtKM6tuBA4EvgKcCXyyqk5P8tok+7SLfQjYPMk5wD/SzFk4kVGGLRxKc5aFJ7V/Pw34MND/rECSJEmSJC1yU5owkao6BjhmhdteNXD9OuCJfa5zlMaDHavq8QN/vybJKX0WRpIkSZKkpaKm1HiwKoxytoVrkzxw9o8kDwCu7b9IkiRJkiQtfjNjXBaqUXoePA84PMkmQIAruHkCBkmSJEmSNKBYOj0P5t14UFWnALsk2bj9e+TTNCbZvKomOj2EJEmSJEmLwcxE5zdYWEY528LmSd4FHAd8M8k7k2zesfybkmzRXt89yS+AE5Kcn+TBkxZckiRJkqSFbIaMfFmoRpnz4BPAr4HH05wn8tfAkR3LP7qqLmuvvwXYr6ruCjwceNuwByU5YPZ0kFddZycFSZIkSdLiVGTky0I1SuPBVlV1cFWd215eB2zZsfyaSWaHRaxXVScCVNXZwDrDHlRVh1TV7lW1+0brDu3YIEmSJEnSgraUJkwcpfHg2CRPTrKsvTwJ+ErH8u8FjknyUODL7TCHByd5DeApHiVJkiRJS9pS6nkwytkWngu8GPho+/cy4PdJ/h9QVbXx4MJV9e4kP6E5S8Pd2nXtBPwv8LpJCy5JkiRJ0kK2kHsSjGqUsy1sNEb+cuAQ4ISqunr2xiR7A18eI0+SJEmSpEVhKTUejDJsgST7JHlre3nMSpZ9IfA54AXAaUn2Hbj7DaMXVZIkSZKkxWO1HLaQ5E3AHsAR7U0vSvKAqnrFkIc8F9itqq5OsgNwVJIdquqdsICfEUmSJEmSejCzhI58R5nz4FHArlU1A5DkcOBHwLDGg2WzQxWq6rwke9I0IGyPjQeSJEmSpCVuZgkd+o40bAHYdOD6JitZ9pIku87+0TYkPAbYAvjTEdcrSZIkSdKiUmNcFqpReh68AfhRkm/S9Bx4EPDyjuWfDtw4eENV3Qg8Pcn7Ry2oJEmSJElaNVK18raNJMuAJwDfoZn3AOAHVbV8imXjmjc/q9eGlz+cdG6fcQC848Ste888/Kqf9J75rrXu1WveFWuM2mll5a7uP5LHb3tR75l3PvmcXvMue+Y9e80DuPDr/T+ZX7tus/4z89veM486+V295t10/o97zQOo5ef1nrlsx/v0nvmAh/xbr3n/b43te80D+OffHt975iM27/f9EuDg9a/rNW+X887sNQ/g+3fYpffMN4/cwXHlPr38pF7zfrz9vXvNA7jLlw/qPfO6N/9775lr3mOHXvMO/M/Le80DuL76n6f8mlv+ttWL7/727N4zz33tnr3m3evgE3rNA/jcRtv0nvmgX/f//nbsJv12ev7wWmv1mgfw6GvX6D3z3LX7z9z0pt4jeeqvPrp0+vXP4TN3/NuRj2kft/xjC/I5mVfPg6qaSfLPVfVJ4Ogpl0mSJEmSpEVvJguyHWAso/wk8LUkL02ybZLNZi9TK5kkSZIkSYvY6jrnwX402/L8FW6/S3/FkSRJkiRpaeh/8NWqM0rjwc40DQcPpGlE+A7wvmkUSpIkSZKkxW5m6YxaGKnx4HDgSmB2NrK/bW97Ut+FkiRJkiRpsZth6bQejNJ4cK+q2nng728mOaPvAkmSJEmStBQs5DkMRjXKhIknJ/nz2T+S3A/o93xJkiRJkiQtETMZ/bJQjdLzYDfge0l+2f69HXBWkp8AVVX9nyhZkiRJkqRFanWdMHHvqZVCkiRJkqQlZikNW5h340FVnT9KcJI1gecAjwXu1N58EfA54ENVdcMoeZIkSZIkLSYLeRjCqEaZ82BUHwF2BQ4CHtVeXgPsAnx02IOSHJDkpCQnHXrCWVMsniRJkiRJ0zMzxmWhGmXYwqh2q6q7rXDbhcDxSc4e9qCqOgQ4BOCaNz9rKfXykCRJkiStRhZyY8Coptnz4IokT0zyx3UkWZZkP+A3U1yvJEmSJEmrXGX0y0I1zcaDJwNPAC5JcnaSnwHLgce190mSJGEc9vUAABcXSURBVEmStGQ5bGEequo8YD+AJJu3N7+zqp46rXVKkiRJkrRQLOTGgFFNrfEgydFz3PzQ2durap9prVuSJEmSpFVtKU3iN80JE7cBzgA+SPOcBdgDeNsU1ylJkiRJkno2zTkPdgd+CLwS+F1VHQdcW1XfqqpvTXG9kiRJkiStcjMZ/bJQTXPOgxngHUk+1f5/yTTXJ0mSJEnSQuKcByOoqguBJyZ5NHDltNcnSZIkSdJCsJQaD1K1+KdwSHJAVR1i5sLMXAxlXCyZi6GMiyVzMZRxsWQuhjKuzpmLoYyLJXMxlHGxZC6GMi6WzMVQxsWSuRjKuLpnLkZv3e6pIx9wv/SXH12QgxemOefBbekAMxd05mIo42LJXAxlXCyZi6GMiyVzMZRxdc5cDGVcLJmLoYyLJXMxlHGxZC6GMi6WzMVQxtU9c9FxzgNJkiRJktRpKQ1bsPFAkiRJkqQpWPyTBNxsqTQeTGMsjZkLN291zlwMZVwsmYuhjIslczGUcXXOXAxlXCyZi6GMiyVzMZRxsWQuhjIulszFUMbVPXPRmVlCzQdLYsJESZIkSZIWmoO333/kA+5/P/+IBTnzwVLpeSBJkiRJ0oKylH6qt/FAkiRJkqQpWEoTJi76UzUm2TvJWUnOSfLyHvIOTXJpktP6KF+buW2SbyY5I8npSV40Yd66SX6Q5NQ27zU9lnWNJD9K8oWe8s5L8pMkpyQ5qafMTZMcleSnSc5Mcv8Jsu7elm32cmWSF/dQxpe0r81pST6eZN0eMl/U5p0+bhnnqt9JNkvy1SQ/a/+/XQ+ZT2zLOZNk9x7y3tK+3j9O8tkkm/aQeXCbd0qSY5PcadLMgfv+KUkl2aKHch6U5KKBOvqoScuY5AXt83l6kv/ooYxHDpTvvCSn9JC5a5LjZ987kty3h8xdkny/fU/6fJKNR8ib8318kv2nI3OS/WdY5lj7UEfe2PtPR+bY9agjc+x61JE5ST2a8/M7yZ2TnJDmu8yRSdaeMO/ANmuc96FhmUek+b51Wrt/rdVD5ofa236c5nN9w0kzB+5/V5KreyjjYUnOHaibu/aQmSSvT3J2mu8xL+wh8zsDZfxVkv/tIXOvJCe3mf+X5K4T5j20zTstyeFJRv4RMyt8T52krndkjl3Xh+SNXc+HZQ7cPlI9X0k5x67rHZlj1/WlZCmdqpGqWrQXYA3g58BdgLWBU4GdJ8x8EPBnwGk9lnMr4M/a6xsBZ09STiDAhu31tYATgD/vqaz/CHwM+EJPeecBW/T8uh8O/F17fW1g0x7r03Jg+wlztgbOBdZr//4k8MwJM+8FnAasT9Nj6GvAXcfIuVX9Bv4DeHl7/eXAm3vIvAdwd+A4YPce8h4BrNlef3NPZdx44PoLgfdNmtnevi3wFeD8Uev+kHIeBLx0zHozV95D2vqzTvv3HfrY7oH73wa8qodyHgs8sr3+KOC4HjJPBB7cXn82cPAIeXO+j0+y/3RkTrL/DMscax/qyBt7/xmWOUk96ijn2PWoI3OSejTn5zfN58ST29vfBzxvwrz7ADswxmdwR+aj2vsCfHy+ZVxJ5mA9evvsvjRJZvv37sBHgKt7KONhwBNGeQ7nkfks4H+AZe19834f7trugWU+DTy9h3KeDdyjvf35wGET5P0FcAFwt/b21wLPGeM5vcX31Enqekfm2HV9SN7Y9XxY5rj1fCXlHLuud2SOXdeX0uWV2z+lRr2s6jIPuyz2ngf3Bc6pql9U1fXAJ4B9Jwmsqm8DV/RRuIHMi6vq5Pb6VcCZNAeY4+ZVVc22Mq7VXiYeTpNkG+DRwAcnzZqWJJvQHBR8CKCqrq+q3/YUvxfw86o6v4esNYH12lb19YFfTZh3D+CEqrqmqm4EvgU8btSQIfV7X5oGGdr//2bSzKo6s6rOGrV8HXnHttsNcDywTQ+ZVw78uQEj7kMd7xXvAP551LyVZI5lSN7zgDdV1R/aZS7tIRNofmEAnkTzZWvSzAJmf9HdhBH3oSGZdwO+3V7/KvD4EfKGvY+Pvf8My5xw/xmWOdY+1JE39v6zss/EcepRR+bY9agjc5J6NOzz+6HAUe3t865Hw/Kq6kdVdd58yzXPzGPa+wr4ASO8D3dkXgl/fM3XY7R6NGdmkjWAt9C8D8/bNL5bdWQ+D3htVc20y837fXhl5UzTE+ahwLx7HnRkjrX/DMm7Cbi+qs5ubx9p34G5v6dOUtc7Mseu60Pyxq7nwzLHreddmZMakjl2XV9KaozLJDJCr8gkGye5MMl75pO92BsPtqZpxZx1IRMclN8WkuxA00p6woQ5a6Tp0nkp8NWqmiiv9Z80b0J9Ds0p4NgkP0xyQA95dwZ+DXy47Rb1wSQb9JAL8GRGPOiZS1VdBLwV+CVwMfC7qjp2wtjTgL9MsnmS9WlaxbedMHPWllV1cXt9ObBlT7nT8mzgS30EtV3pLgD2B17VQ96+wEVVderEhbulA9vujod2fQDM091o6tIJSb6VZI8+Ctj6S+CSqvpZD1kvBt7Svj5vBV7RQ+bp3NzA/ETG3IdWeB/vZf/p67Nhnplj7UMr5vWx/wwp40T1aIXMXurRCpkT1aMVP79pelD+dqBxZ6TvMtP4PtCV2Xbhfhrw5T4yk3yYZt/5E+DdPWQeCBw9sF9OXEbg9e178DuSrNND5o7AfmmG0nwpyU49lROahqevr9DAN27m3wHHJLmQ5jV/07h5NAfha+bmoVhPYPT34Gl8Tx2aOWZdnzNvkno+JHPset5VTiao60MyJ6rrS8XMGJcJvZzmfWAn4Ovt38MczM0N4iu12BsPFpV2jNOngReP+qa+oqq6qap2pWkNvW+Se01YtscAl1bVDyfJmcMDq+rPgEcC/5DkQRPmrUnTFfm/q+o+wO/p3iHmJc340n2AT/WQdTuaL5Z3Bu4EbJDkqZNkVtWZNF2Nj6X5EDuFphW/V20r+8S9WKYlySuBG4Ej+sirqldW1bZt3oETlm194F/poRFiBf9N8+G7K01j1NsmzFsT2IymS+rLgE+2v4b04Sn00ADXeh7wkvb1eQltb6MJPRt4fpIf0nRDv37UgK738XH3nz4/G1aWOe4+NFfepPtPx3aPXY/myJy4Hs2ROVE9WvHzm+ZgYmx9fx+YR+Z7gW9X1Xf6yKyqZ9F8Vp4J7Ddh5oNoGnRGPTjrKuMraF6jPWjeO/+lh8x1gOuqanfgA8ChPWTOGmv/GZL5EuBRVbUN8GGaLvdj5QH3pPmR5h1JfgBcxQjfY6bxPXUemSPV9a68cev5XJlp5pgZu553lHPsut6ROVFdXypmqJEvE5pXr8gku9H86DHvHzkXe+PBRdyy1XKb9rYFp229/DRwRFV9pq/carrsfxPYe8KoBwD7JDmPZvjHQ5N8dMLM2V/hZ7spfZbmA2QSFwIXDrSyH0XTmDCpRwInV9UlPWQ9DDi3qn5dVTcAn6EZ6zeRqvpQVe1WVQ8CfkMzFrEPlyTZCqD9f0F2KUvyTOAxwP7tQVqfjmDE7pNz2JGmwejUdj/aBjg5yR0nCa2qS9ovYTM0H7x97EOfaXtk/oCmgXusSaYGpRmi8zjgyEmzWs+g2XegadSbdLupqp9W1SOqajeaL9c/H+XxQ97HJ9p/pvHZMCxz3H1oHmUcef/pKOPY9WhI5kT1aK7MSevRrIHP7/sDm+bmyePG+i7T4/eBoZlJXg3cnmZccy+Z7W030Xz3GOt9eCDzIcBdgXPa9+H1k5wzSRmrGb5S1Qz1+jBjvhetsN0XcnO9/Cxw7x4ySTNh4H2BL46Tt0LmI4FdBr5vHckY32VWeC6/X1V/WVX3pfmlc5TvMdP4njo0c8y63lnGMev5rTJpej9NUs/nLOeEdX3YtvdS1zWylfaKTLKM5gepl44SvNgbD04EdkozS/HaNC2aR6/iMt1K+6veh4Azq2rerbYdebdPO1N2kvWAhwM/nSSzql5RVdtU1Q40z+M3qmqiX8uTbJBko9nrNBN2TXQWi6paDlyQ5O7tTXsBZ0yS2erzF9NfAn+eZP32td+LpqV5Iknu0P6/Hc2X649Nmtk6muYLNu3/n+sptzdJ9qbpCrdPVV3TU+Zg17l9mXwf+klV3aGqdmj3owtpJltbPknu7IFp67FMuA/RjIN9SJt9N5pJRy+bMBOaRrOfVtWFPWRBM7b2we31hwITD4UY2IeWAf9GMzHdfB877H187P2n78+Grsxx96GOvLH3n5Vs91j1qCNz7HrUse2T1KO5Pr/PpDm4ekK72Lzr0TS+DwzLTPJ3wF8BT2kbMyfNPCvt7P3tc73PKGUfkvnDqrrjwPvwNVU13zMEDNvu2cbB0Px6N+/34I7X54/vwzT1c94H0St5zZ9AM1HddfPN68g8E9ik/Zxg4Laxyziw76xD86v2vPedaXxPHZY5bl2fKw942iT1fEgZbzduPe/IfOokdb3j9Rm7ri8l48x5kOSANMM9Zi+3GP6d5Gtpzgiy4uUW8/+1PxbM9YPB84FjRv28HfkUKQtJVd2Y5ECamc3XAA6tqtMnyUzycWBPYIs0Y7xeXVWTdpd9AM2YqZ/k5lNP/WtVHTNm3lbA4WkmS1kGfLKqejm1Ys+2BD7bvAexJvCxqhppjOQQLwCOaBuMfkEzk+vY2oaNhwP/r4eyUVUnJDkKOJmme/CPgEN6iP50ks2BG4B/qDEmipyrftOMYfxkkufQnCHgST1kXkHTne72wBeTnFJVfzVB3itour59ta1Px1fV309Yxke1jVAzNNs977xhmZO+Vwwp555pTpdUNLNJz7ueDsk7FDg0zSkMrweeMeKv0MO2e+w5Q4aU87nAO9P8GnsdMNKcKUMyN0zyD+0in6H5ZWW+5nwfZ7L9Z1jmOoy5/3Rkvovx9qFhec+ZYP/p+kwctx4NK+ck9WhY5k4T1KM5P7+TnAF8IsnraD4z5vteMizvhTSNRXcEfpzkmKr6uwkzb6R5rb/f1qHPVNVrx82k+XX8O2km+AvNGbOeN8+8oeUc4fHzykvyjSS3b8t4CqPV9WGZ/0fzPeYlwNU0cwtMlNne92RGmJdgHuV8Ls13jxmaHo/PnjDvLWm6ty+jGX76jTHKegsT1vVh3sf4df1WRaR5Lsat57elIyao68O8ifHr+pIxzhwGVXUIHccPVfWwYfcluSTJVlV1cYb3irw/zRxYzwc2BNZOcnVVdQ4HzwjfGSVJkiRJ0jz94w5PHvmA++3nfWLs+aiSvAW4vKrelOTlwGZVNfTMHGmGNe5eVSudv2ixD1uQJEmSJGlBuq1P1UjT4+PhSX5GMxzwTQBJdk8y0ek5F/WwBUmSJEmSFqo+zy06H1V1Oc2cayvefhJzDB2pqsOAw+aTbeOBJEmSJElTUAv3LOgjs/FAkiRJkqQpuK17HkyTjQeSJEmSJE3BjD0PJEmSJElSl6XTdODZFiRJ6kWSv0my88Dfr03SdR7m3ZO8awrleGaSO61kmQ8OlnWFx76n7zJJkrS6mqFGvixU9jyQJGlCSdYE/gb4AnAGQFW9qusx7azHJ02hOM8ETgN+1bHuW822LEmS+reU5jyw54EkSUCSHZL8NMkRSc5MclSS9ZO8KsmJSU5LckiStMsfl+Q/k5wE/AuwD/CWJKck2THJYUme0C67R5LvJTk1yQ+SbJRkzyRfaO8/KMlHknw/yc+SPLe9fcMkX09ycpKfJNl3oKxnJvlAktOTHJtkvXZ9uwNHtOVYb8i2Hpdk9/b6s5KcneQHwAOm+yxLkrR6qTH+LVQ2HkiSdLO7A++tqnsAVwLPB95TVXtU1b2A9YDHDCy/dlXtXlWvB44GXlZVu1bVz2cXSLI2cCTwoqraBXgYcO0c67438FDg/sCr2qEH1wGPrao/Ax4CvG228QLYCfivqron8Fvg8VV1FE1vhv3bcsy1nj9KshXwGppGgwcCtxrKIEmSxjczxmWhsvFAkqSbXVBV322vf5TmgPohSU5I8hOag/t7Dix/5Dwy7w5cXFUnAlTVlVV14xzLfa6qrq2qy4BvAvcFArwhyY+BrwFbA1u2y59bVae0138I7DDfjRxwP+C4qvp1VV0/z+2RJEnztJR6HjjngSRJN1vxE7uA9wK7V9UFSQ4C1h24//dTXvf+wO2B3arqhiTnDaz/DwPL3kTTK0KSJC0gC7knwajseSBJ0s22S3L/9vrfAv/XXr8syYbAEzoeexWw0Ry3nwVslWQPgHa+g7ka7/dNsm6SzYE9gROBTYBL24aDhwDbz2MbhpVjLicAD06yeZK1gCfO83GSJGkeZqpGvixU9jyQJOlmZwH/kORQmrMm/DdwO5qzFyynOaAf5hPAB5K8kIFGhqq6Psl+wLvbCQyvpZn3YEU/phmusAVwcFX9KskRwOfbIRMnAT+dxzYcBrwvybXA/bvmPaiqi9veFN+nmTfhlGHLSpKk1VtqAbdsSJJ0W0myA/CFdmLE23rdBwFXV9Vbb+t1S5Kk6Xnq9o8b+YD7o+d/Jitf6rZnzwNJkiRJkqZgZgFPgDgqGw8kSQKq6jzgNu910K77oGnkJvkscOcVbv6XqvrKNNYnSZJuaSGfPWFUNh5IkrREVdVjV3UZJElanS2lsy3YeCBJkiRJ0hQ4bEGSJEmSJHVy2IIkSZIkSerksAVJkiRJktSpyp4HkiRJkiSpg3MeSJIkSZKkTg5bkCRJkiRJnZwwUZIkSZIkdXLYgiRJkiRJ6uSEiZIkSZIkqZNzHkiSJEmSpE7OeSBJkiRJkjotpTkPlq3qAkiSJEmSpIXNngeSJEmSJE2BEyZKkiRJkqROS2nYgo0HkiRJkiRNgRMmSpIkSZKkTjMOW5AkSZIkSV2WTtOBjQeSJEmSJE2Fcx5IkiRJkqRONh5IkiRJkqROnqpRkiRJkiR1sueBJEmSJEnq5KkaJUmSJElSJ4ctSJIkSZKkTg5bkCRJkiRJnex5IEmSJEmSOtnzQJIkSZIkdXLCREmSJEmS1GlmCQ1bWLaqCyBJkiRJkiaXZLMkX03ys/b/2w1Z7j+SnJ7kzCTvSpKVZdt4IEmSJEnSFNQY/yb0cuDrVbUT8PX271tI8hfAA4B7A/cC9gAevLJgGw8kSZIkSZqCmaqRLxPaFzi8vX448DdzLFPAusDawDrAWsAlKwt2zgNJkiRJkqZgFUyYuGVVXdxeXw5sueICVfX9JN8ELgYCvKeqzlxZsI0HkiRJkiRNwTg9CZIcABwwcNMhVXXIwP1fA+44x0NfOfhHVVWSWxUgyV2BewDbtDd9NclfVtV3uspl44EkSZIkSVMwTs+DtqHgkI77HzbsviSXJNmqqi5OshVw6RyLPRY4vqqubh/zJeD+QGfjgXMeSJIkSZI0BatgzoOjgWe0158BfG6OZX4JPDjJmknWopkscaXDFmw8kCRJkiRpClbB2RbeBDw8yc+Ah7V/k2T3JB9slzkK+DnwE+BU4NSq+vzKglOTt2xIkiRJkqQV3HnzXUY+4D738lMzjbJMyjkPJEmSJEmagpnb/mwLU2PjgSRJkiRJU7CUevrbeCBJkiRJ0hTY80CSJEmSJHWy54EkSZIkSerUw6kXFwwbDyRJkiRJmoIeTr24YNh4IEmSJEnSFDhsQZIkSZIkdXLCREmSJEmS1Gkp9TxYtqoLIEmSJEmSFjZ7HkiSJEmSNAWebUGSJEmSJHVaSsMWbDyQJEmSJGkKnDBRkiRJkiR1sueBJEmSJEnq5JwHkiRJkiSpUzlsQZIkSZIkdbHngSRJkiRJ6uScB5IkSZIkqZPDFiRJkiRJUid7HkiSJEmSpE42HkiSJEmSpE5Lp+kAspRaQiRJkiRJUv+WreoCSJIkSZKkhc3GA0mSJEmS1MnGA0mSJEmS1MnGA0mSJEmS1MnGA0mSJEmS1MnGA0mSJEmS1On/A+5wdaadGjBzAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "affinities_plot(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "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.plot(x='timestep',y=['candidate_count','active_count','completed_count', 'killed_count', 'failed_count'],\n", + " kind='line')\n", + "plt.title('Proposal Status')\n", + "plt.ylabel('count of proposals')\n", + "plt.legend(ncol = 3,loc='upper center', bbox_to_anchor=(0.5, -0.15))" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "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.plot(x='timestep',y=['candidate_funds','active_funds','completed_funds', 'killed_funds', 'failed_funds'])\n", + "plt.title('Proposal Status weighted by funds requested')\n", + "plt.ylabel('Funds worth of proposals')\n", + "plt.legend(ncol = 3,loc='upper center', bbox_to_anchor=(0.5, -0.15))" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "nets = df.network.values" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "K = 0\n", + "N = 100\n", + "\n", + "#snap_plot(nets[K:N], size_scale = 1/10,savefigs=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "# Run the following code , without the #, in the images/snap folder to make a movie\n", + "# ffmpeg -r 10 -i %01d.png -vcodec mpeg4 -y movie.mp4" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%HTML\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conclusion\n", + "\n", + "We have created a simplified conviction voting model that illustrates the state objects, and provides descriptions of how the model fits together. In subsequent notebooks, we will expand the model to introduce additional complexity to more fit real world implementations. " + ] + } + ], + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/v2/Aragon_Conviction_Voting_Model.ipynb b/v2/Aragon_Conviction_Voting_Model.ipynb new file mode 100644 index 0000000..99841fe --- /dev/null +++ b/v2/Aragon_Conviction_Voting_Model.ipynb @@ -0,0 +1,1317 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Aragon Conviction Voting Model - Version 2\n", + "\n", + "New to this model are the following elements:\n", + "\n", + "* Influence - Participant social network where participants influence each others perception of a a proposal.\n", + "* Conflict - A network with the notion of supporting one proposal may mean going against an alternative proposal. For proposals with conflicts, an edge is created between them with a function to calculate the degree of conflict.\n", + "* Sentiment - Participant sentiment\n", + "* Updated trigger function to better represent 1Hive's implementation\n", + "* Updated plotting\n", + "* Updated affinity distribution to between -1, 1\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# An Introduction to Conviction Voting\n", + "\n", + "Conviction Voting is an approach to organizing a communities preferences into discrete decisions in the management of that communities resources. Strictly speaking conviction voting is less like voting and more like signal processing. Framing the approach and the initial algorithm design was done by Michael Zargham and published in a short research proposal [Social Sensor Fusion](https://github.com/BlockScience/conviction/blob/master/social-sensorfusion.pdf). This work is based on a dynamic resource allocation algorithm presented in Zargham's PhD Thesis.\n", + "\n", + "The work proceeded in collaboration with the Commons Stack, including expanding on the pythin implementation to makeup part of the Commons Simulator game. An implemention of Conviction Voting as a smart contract within the Aragon Framework was developed by 1hive.org and is currently being used for community decision making around allocations their community currency, Honey.\n", + "\n", + "\n", + "## The Word Problem\n", + "\n", + "Suppose a group of people want to coordinate to make a collective decision. Social dynamics such as discussions, signaling, and even changing ones mind based on feedback from others input play an important role in these processes. While the actual decision making process involves a lot of informal processes, in order to be fair the ultimate decision making process still requires a set of formal rules that the community collecively agrees to, which serves to functionally channel a plurality of preferences into a discrete outcomes. In our case we are interested in a procedure which supports asynchronous interactions, an provides visibility into likely outcomes prior to their resolution to serve as a driver of good faith, debate and healthy forms of coalition building. Furthermore, participations should be able to show support for multiple initiatives, and to vary the level of support shown. Participants a quantity of signaling power which may be fixed or variable, homogenous or heterogenous. For the purpose of this document, we'll focus on the case where the discrete decisions to be made are decisions to allocate funds from a shared funding pool towards projects of interest to the community.\n", + "\n", + "## Converting to a Math Problem\n", + "\n", + "Let's start taking these words and constructing a mathematical representation that supports a design that meets the description above. To start we need to define participants.\n", + "\n", + "### Participants\n", + "Let $\\mathcal{A}$ be the set of participants. Consider a participant $a\\in \\mathcal{A}$. Any participant $a$ has some capacity to participate in the voting process $h[a]$. In a fixed quantity, homogenous system $h[a] = h$ for all $a\\in \\mathcal{A}$ where $h$ is a constant. The access control process managing how one becomes a participant determines the total supply of \"votes\" $S = \\sum_{a\\in \\mathcal{A}} = n\\cdot h$ where the number of participants is $n = |\\mathcal{A}|$. In a smart contract setting, the set $\\mathcal{A}$ is a set of addresses, and $h[a]$ is a quantity of tokens held by each address $a\\in \\mathcal{A}$. \n", + "\n", + "### Proposals & Shares Resources\n", + "Next, we introduce the idea of proposals. Consider a proposal $i\\in \\mathcal{C}$. Any proposal $i$ is associated with a request for resources $r[i]$. Those requested resources would be allocated from a constrained pool of communal resources currently totaling $R$. The pool of resources may become depleted because when a proposal $i$ passes $R^+= R-r[i]$. Therefore it makes sense for us to consider what fraction of the shared resources are being request $\\mu_i = \\frac{r[i]}{R}$, which means that thre resource depletion from passing proposals can be bounded by requiring $\\mu_i < \\mu$ where $\\mu$ is a constant representing the maximum fraction of the shared resources which can be dispersed by any one proposal. In order for the system to be sustainable a source of new resources is required. In the case where $R$ is funding, new funding can come from revenues, donations, or in some DAO use cases minting tokens.\n", + "\n", + "### Participants Preferences for Proposals\n", + "\n", + "Most of the interesting information in this system is distributed amongst the participants and it manifests as preferences over the proposals. This can be thought of as a matrix $W\\in \\mathbb{R}^{n \\times m}$.\n", + "![Replace this later](https://i.imgur.com/vxKNtxi.png)\n", + "\n", + "These private hidden signals drive discussions and voting actions. Each participant individually decides how to allocate their votes across the available proposals. Participant $a$ supports proposal $i$ by setting $x[a,i]>0$ but they are limited by their capacity $\\sum_{k\\in \\mathcal{C}} x[a,k] \\le h[a]$. Assuming each participant chooses a subset of the proposals to support, a support graph is formed.\n", + "![](https://i.imgur.com/KRh8tKn.png)\n", + "\n", + "## Aggregating Information\n", + "\n", + "In order to break out of the synchronous voting model, a dynamical systems model of this system is introduced.\n", + "\n", + "### Participants Allocate Voting Power\n", + "![](https://i.imgur.com/DZRDwk6.png)\n", + "\n", + "### System Accounts Proposal Conviction\n", + "![](https://i.imgur.com/euAei5R.png)\n", + "\n", + "### Understanding Alpha\n", + "https://www.desmos.com/calculator/x9uc6w72lm\n", + "https://www.desmos.com/calculator/0lmtia9jql\n", + "\n", + "\n", + "## Converting Signals to Discrete Decisions\n", + "\n", + "Conviction as kinetic energy and Trigger function as required activation energy.\n", + "\n", + "### The Trigger Function\n", + "\n", + "https://www.desmos.com/calculator/yxklrjs5m3\n", + "\n", + "Below we show a sweep of the trigger function threshold:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/aclarkdata/anaconda3/lib/python3.7/site-packages/statsmodels/tools/_testing.py:19: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.\n", + " import pandas.util.testing as tm\n" + ] + } + ], + "source": [ + "from model.model.conviction_helper_functions import *\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "beta = .2 #later we should set this to be param so we can sweep it\n", + "# tuning param for the trigger function\n", + "rho = .001\n", + "alpha = 1 - 0.9999599" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "supply_sweep = trigger_sweep('effective_supply',trigger_threshold,beta,rho,alpha)\n", + "alpha_sweep = trigger_sweep('alpha',trigger_threshold,beta,rho,alpha)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "trigger_grid(supply_sweep, alpha_sweep)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Resolving Passed Proposals\n", + "\n", + "![](https://i.imgur.com/lmOl9HE.png)\n", + "\n", + "\n", + "## Social Systems Modeling\n", + "\n", + "Subjective, exploratory modeling of the social system interacting through the conviction voting algorithm.\n", + "\n", + "### Sentiment\n", + "\n", + "Global Sentiment -- the outside world appreciating the output of the community\n", + "Local Sentiment -- agents within the system feeling good about the community\n", + "\n", + "### Social Networks\n", + "\n", + "Preferences as mixing process (social influence)\n", + "\n", + "### Relationships between Proposals\n", + "\n", + "Some proposals are synergistic (passing one makes the other more desireable)\n", + "Some proposals are (parially) substitutable (passing one makes the other less desirable)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Schema of the states \n", + "The model consists of a temporal in memory graph database called *network* containing nodes of type **Participant** and type **Proposal**. Participants will have *holdings* and *sentiment* and Proposals will have *funds_required, status*(candidate or active), *conviction* Tthe model as three kinds of edges:\n", + "* (Participant, participant), we labeled this edge type \"influencer\" and it contains information about how the preferences and sentiment of one participant influence another \n", + "* (Proposal, Proposal), we labeled this edge type \"conflict\" and it contains information about how synergistic or anti-synergistic two proposals are; basically people are likely to support multiple things that have synergy (meaning once one is passed there is more utility from the other) but they are not likely to pass things that have antisynergy (meaning once one is passed there is less utility from the other).\n", + "* The edges between Participant and Proposal, which are described below.\n", + " \n", + "\n", + "Edges in the network go from nodes of type Participant to nodes of type Proposal with the edges having the key *type*, of which all will be set to *support*. Edges from participant $i$ to proposal $j$ will have the following additional characteristics:\n", + "* Each pairing (i,j) will have *affinity*, which determines how much $i$ likes or dislikes proposal $j$.\n", + "* Each participant $i$, assigns its $tokens$ over the edges (i,j) for all $j$ such that the summation of all $j$ such that ```Sum_j = network.edges[(i,j)]['tokens'] = network.nodes[i]['holdings']```. This value of tokens for participants on proposals must be less than or equal to the total number of tokens held by the participant.\n", + "* Each pairing (i,j) will have *conviction* local to that edge whose update at each timestep is computed using the value of *tokens* at that edge.\n", + "* Each proposal *j* will have a *conviction* which is equal to the sum of the conviction on its inbound edges: ```network.nodes[j]['conviction'] = Sum_i network.edges[(i,j)]['conviction']```. \n", + "\n", + "\n", + "The other state variable in the model is *funds*, which is a numpy floating point. \n", + "\n", + "The system consists of 100 time steps without a parameter sweep or monte carlo.\n", + "\n", + "\n", + "## Partial State Update Blocks\n", + "\n", + "Each partial state update block is kind of a like a phase in a phased based board game. Everyone decides what to do and it reconciles all decisions. One timestep is a full turn, with each block being a phase of a timestep or turn. We will walk through the individaul Partial State update blocks one by one below." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```\n", + "{\n", + "# system.py: \n", + "'policies': { \n", + " 'random': driving_process\n", + "},\n", + "'variables': {\n", + " 'network': update_network,\n", + " 'funds':increment_funds,\n", + "}\n", + "```\n", + "\n", + "To simulate the arrival of participants and proposal into the system, we have a driving process to represent the arrival of individual agents. We use a random uniform distribution generator, over [0, 1), to calculate the number of new participants. We then use an exponential distribution to calculate the particpant's tokens by using a loc of 0.0 and a scale of expected holdings, which is calculated by .1*supply/number of existing participants. We calculate the number of new proposals by \n", + "```\n", + "proposal_rate = 1/median_affinity * (1+total_funds_requested/funds)\n", + "rv2 = np.random.rand()\n", + "new_proposal = bool(rv2<1/proposal_rate)\n", + "```\n", + "The network state variable is updated to include the new participants and proposals, while the funds state variable is updated for the increase in system funds. \n", + "[To see the partial state update code, click here](model/model/system.py)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```\n", + "{\n", + " # participants.py \n", + " 'policies': {\n", + " 'completion': check_progress \n", + " },\n", + " 'variables': { \n", + " 'sentiment': update_sentiment_on_completion, #note completing decays sentiment, completing bumps it\n", + " 'network': complete_proposal\n", + " }\n", + "},\n", + "```\n", + "\n", + "In the next phase of the turn, [to see the logic code, click here](model/model/participants.py), the *check_progress* behavior checks for the completion of previously funded proposals. The code calculates the completion and failure rates as follows:\n", + "\n", + "```\n", + "likelihood = 1.0/(base_completion_rate+np.log(grant_size))\n", + "\n", + "failure_rate = 1.0/(base_failure_rate+np.log(grant_size))\n", + "if np.random.rand() < likelihood:\n", + " completed.append(j)\n", + "elif np.random.rand() < failure_rate:\n", + " failed.append(j)\n", + "```\n", + "With the base_completion_rate being 100 and the base_failure_rate as 200. \n", + "\n", + "The mechanism then updates the respective *network* nodes and updates the sentiment variable on proposal completion. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```\n", + " # proposals.py\n", + " 'policies': {\n", + " 'release': trigger_function \n", + " },\n", + " 'variables': { \n", + " 'funds': decrement_funds, \n", + " 'sentiment': update_sentiment_on_release, #releasing funds can bump sentiment\n", + " 'network': update_proposals \n", + " }\n", + "},\n", + " ```\n", + " \n", + "The [trigger release function](model/model/proposals.py) checks to see if each proposal passes or not. If a proposal passes, funds are decremented by the amount of the proposal, while the proposal's status is changed in the network object." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```\n", + "{ \n", + " # participants.py\n", + " 'policies': { \n", + " 'participants_act': participants_decisions\n", + " },\n", + " 'variables': {\n", + " 'network': update_tokens \n", + " }\n", + "}\n", + "```\n", + "\n", + "The Participants decide based on their affinity if which proposals they would like to support,[to see the logic code, click here](model/model/participants.py). Proposals that participants have high affinity for receive more support and pledged tokens than proposals with lower affinity and sentiment. We then update everyone's holdings and their conviction for each proposal.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model next steps\n", + "\n", + "The the model described above is the second iteration model that covers the core mechanisms of the Aragon Conviction Voting model. Below are next additional dynamics we can attend to enrich the model, and provide workstreams for subsequent iterations of this lab notebook.\n", + "\n", + "* Mixing of token holdings among participants\n", + "* Departure of participants\n", + "* Proposals which are good or no good together\n", + "* Multiple proposal stages such as killed, failed and completed\n", + "* Affects of outcomes on sentiment" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Simulation\n", + "\n", + "## cadCAD Overview\n", + "\n", + "In the cadCAD simulation [methodology](https://community.cadcad.org/t/differential-specification-syntax-key/31), we operate on four layers: **Policies, Mechanisms, States**, and **Metrics**. Information flows do not have explicit feedback loop unless noted. **Policies** determine the inputs into the system dynamics, and can come from user input, observations from the exogenous environment, or algorithms. **Mechanisms** are functions that take the policy decisions and update the States to reflect the policy level changes. **States** are variables that represent the system quantities at the given point in time, and **Metrics** are computed from state variables to assess the health of the system. Metrics can often be thought of as KPIs, or Key Performance Indicators. \n", + "\n", + "At a more granular level, to setup a model, there are system conventions and configurations that must be [followed.](https://community.cadcad.org/t/introduction-to-simulation-configurations/34)\n", + "\n", + "The way to think of cadCAD modeling is analogous to machine learning pipelines which normally consist of multiple steps when training and running a deployed model. There is preprocessing, which includes segregating features between continuous and categorical, transforming or imputing data, and then instantiating, training, and running a machine learning model with specified hyperparameters. cadCAD modeling can be thought of in the same way as states, roughly translating into features, are fed into pipelines that have built-in logic to direct traffic between different mechanisms, such as scaling and imputation. Accuracy scores, ROC, etc. are analogous to the metrics that can be configured on a cadCAD model, specifying how well a given model is doing in meeting its objectives. The parameter sweeping capability of cadCAD can be thought of as a grid search, or way to find the optimal hyperparameters for a system by running through alternative scenarios. A/B style testing that cadCAD enables is used in the same way machine learning models are A/B tested, except out of the box, in providing a side by side comparison of muliple different models to compare and contrast performance. Utilizing the field of Systems Identification, dynamical systems models can be used to \"online learn\" by providing a feedback loop to generative system mechanisms. \n", + "\n", + "\n", + "## Differential Specification \n", + "![](images/Aragon_v2.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Configuration\n", + "Let's factor out into its own notebook where we review the config object and its partial state update blocks." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from model import economyconfig" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# pull out configurations to illustrate\n", + "sim_config,genesis_states,seeds,partial_state_update_blocks = economyconfig.get_configs()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'N': 1, 'T': range(0, 100), 'M': [{}], 'simulation_id': 0, 'run_id': 0}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sim_config" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'policies': {'random': },\n", + " 'variables': {'network': ,\n", + " 'funds': }},\n", + " {'policies': {'completion': },\n", + " 'variables': {'sentiment': ,\n", + " 'network': }},\n", + " {'policies': {'release': },\n", + " 'variables': {'funds': ,\n", + " 'sentiment': ,\n", + " 'network': }},\n", + " {'policies': {'participants_act': },\n", + " 'variables': {'network': }}]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "partial_state_update_blocks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Initialization\n", + "To create the genesis_states, we create our in-memory graph database within networkx. \n", + "\n", + "\n", + "### Hyperparameters\n", + "* $\\beta$ = .2 # maximum share of funds a proposal can take\n", + "* $\\rho$ = 0.002 # tuning param for the trigger function\n", + "* $\\alpha$ = 1 - 0.9999599\n", + "* supply = 21706 # Honey supply balance as of 7-17-2020 \n", + "* initial_sentiment = .9\n", + "* n= 24 #initial participants\n", + "* m= 3 #initial proposals\n", + "* sensitivity = .75\n", + "* tmin = 7 #unit days; minimum periods passed before a proposal can pass\n", + "* min_supp = 50 #number of tokens that must be stake for a proposal to be a candidate\n", + "* base_completion_rate = 100\n", + "* base_failure_rate = 200 \n", + "* initial_funds = 48000 # in xDai" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# import libraries\n", + "import networkx as nx\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from model.model.conviction_helper_functions import * \n", + "\n", + "# Parameters\n", + "# maximum share of funds a proposal can take\n", + "beta = .2 #later we should set this to be param so we can sweep it\n", + "# tuning param for the trigger function\n", + "rho = 0.002\n", + "alpha = 1 - 0.9999599\n", + "supply = 21706 # Honey supply balance as of 7-17-2020 \n", + "initial_sentiment = .9\n", + "\n", + "\n", + "n= 24 #initial participants\n", + "m= 3 #initial proposals\n", + "\n", + "\n", + "sensitivity = .75\n", + "tmin = 7 #unit days; minimum periods passed before a proposal can pass\n", + "min_supp = 50 #number of tokens that must be stake for a proposal to be a candidate\n", + "base_completion_rate = 100\n", + "base_failure_rate = 200 \n", + "\n", + "initial_funds = 48000 # in xDai\n", + "\n", + "def initialize_network(n,m, inital_funds, supply):\n", + " '''\n", + " Definition:\n", + " Function to initialize network x object\n", + "\n", + " Parameters:\n", + "\n", + " Assumptions:\n", + "\n", + " Returns:\n", + "\n", + " Example:\n", + " '''\n", + " # initilize network x graph\n", + " network = nx.DiGraph()\n", + " # create participant nodes with type and token holding\n", + " for i in range(n):\n", + " network.add_node(i)\n", + " network.nodes[i]['type']= \"participant\"\n", + " \n", + " h_rv = expon.rvs(loc=0.0, scale= supply/n)\n", + " network.nodes[i]['holdings'] = h_rv # SOL check\n", + " \n", + " s_rv = np.random.rand() \n", + " network.nodes[i]['sentiment'] = s_rv\n", + " \n", + " participants = get_nodes_by_type(network, 'participant')\n", + " initial_supply = np.sum([ network.nodes[i]['holdings'] for i in participants])\n", + " \n", + " \n", + " # Generate initial proposals\n", + " for ind in range(m):\n", + " j = n+ind\n", + " network.add_node(j)\n", + " network.nodes[j]['type']=\"proposal\"\n", + " network.nodes[j]['conviction'] = 0\n", + " network.nodes[j]['status'] = 'candidate'\n", + " network.nodes[j]['age'] = 0\n", + " \n", + " r_rv = gamma.rvs(3,loc=0.001, scale=100)\n", + " network.nodes[j]['funds_requested'] = r_rv\n", + " \n", + " network.nodes[j]['trigger']= trigger_threshold(r_rv, initial_funds, initial_supply,beta,rho,alpha)\n", + " \n", + " for i in range(n):\n", + " network.add_edge(i, j)\n", + " \n", + " rv = np.random.rand()\n", + " a_rv = np.random.uniform(-1,1,1)[0]\n", + " network.edges[(i, j)]['affinity'] = a_rv\n", + " network.edges[(i, j)]['tokens'] = 0\n", + " network.edges[(i, j)]['conviction'] = 0\n", + " network.edges[(i, j)]['type'] = 'support'\n", + " \n", + " proposals = get_nodes_by_type(network, 'proposal')\n", + " total_requested = np.sum([ network.nodes[i]['funds_requested'] for i in proposals])\n", + " \n", + " network = initial_conflict_network(network, rate = .25)\n", + " network = initial_social_network(network, scale = 1)\n", + " \n", + " return network, initial_funds\n", + "#initializers\n", + "network, initial_funds = initialize_network(n,m,initial_funds,supply)\n", + "\n", + "\n", + "\n", + "# Create initial states\n", + "genesis_states = { \n", + " 'network':network,\n", + " 'funds':initial_funds,\n", + " 'sentiment':initial_sentiment,\n", + "\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'network': ,\n", + " 'funds': 48000,\n", + " 'sentiment': 0.9}" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "genesis_states" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Exploring the State Data Structure\n", + "\n", + "A graph is a type of temporal data structure that evolves over time. A graph $\\mathcal{G}(\\mathcal{V},\\mathcal{E})$ consists of vertices or nodes, $\\mathcal{V} = \\{1...\\mathcal{V}\\}$ and is connected by edges $\\mathcal{E} \\subseteq \\mathcal{V} \\times \\mathcal{V}$.\n", + "\n", + "See *Schema of the states* above for more details\n", + "\n", + "\n", + "Let's explore!" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# To explore our model prior to the simulation, we extract key components from our networkX object into lists.\n", + "proposals = get_nodes_by_type(network, 'proposal')\n", + "participants = get_nodes_by_type(network, 'participant')\n", + "supporters = get_edges_by_type(network, 'support')\n", + "influencers = get_edges_by_type(network, 'influence')\n", + "competitors = get_edges_by_type(network, 'conflict')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'type': 'participant',\n", + " 'holdings': 893.6452645743616,\n", + " 'sentiment': 0.102446375901169}" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#sample a participant\n", + "network.nodes[participants[0]]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Count of Participants')" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Let's look at the distribution of participant holdings at the start of the sim\n", + "plt.hist([ network.nodes[i]['holdings'] for i in participants])\n", + "plt.title('Histogram of Participants Token Holdings')\n", + "plt.xlabel('Amount of Honey')\n", + "plt.ylabel('Count of Participants')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Participants Social Network')" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nx.draw_kamada_kawai(network, nodelist = participants, edgelist=influencers)\n", + "plt.title('Participants Social Network')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'type': 'proposal',\n", + " 'conviction': 0,\n", + " 'status': 'candidate',\n", + " 'age': 0,\n", + " 'funds_requested': 533.7442840291636,\n", + " 'trigger': 862.188323033792}" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#lets look at proposals\n", + "network.nodes[proposals[0]]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Proposals initially start without any conviction, and with the status of a candidate. If the proposal's amount of conviction is greater than it's trigger, then the proposal moves to active and it's funds requested are granted. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All initial proposal start with 0 conviction and state 'candidate'we can simply examine the amounts of funds requested" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Amount of Honey requested')" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.bar( proposals, [ network.nodes[i]['funds_requested'] for i in proposals])\n", + "plt.title('Bar chart of Proposals Funds Requested')\n", + "plt.xlabel('Proposal identifier')\n", + "plt.ylabel('Amount of Honey requested')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Conviction is a concept that arises in the edges between participants and proposals in the initial conditions there are no votes yet so we can look at that later however, the voting choices are driven by underlying affinities which we can see now." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 104.1, 'participant_id')" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "affinities = np.empty((n,m))\n", + "for i_ind in range(n):\n", + " for j_ind in range(m):\n", + " i = participants[i_ind]\n", + " j = proposals[j_ind]\n", + " affinities[i_ind][j_ind] = network.edges[(i,j)]['affinity']\n", + "\n", + "dims = (20, 5)\n", + "fig, ax = plt.subplots(figsize=dims)\n", + "\n", + "sns.heatmap(affinities.T,\n", + " xticklabels=participants,\n", + " yticklabels=proposals,\n", + " square=True,\n", + " cbar=True,\n", + " ax=ax)\n", + "\n", + "plt.title('affinities between participants and proposals')\n", + "plt.ylabel('proposal_id')\n", + "plt.xlabel('participant_id')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run simulation\n", + "\n", + "Now we will create the final system configuration, append the genesis states we created, and run our simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "from cadCAD.configuration import append_configs\n", + "\n", + "# Create configuration\n", + "append_configs(\n", + " sim_configs=sim_config,\n", + " initial_state=genesis_states,\n", + " seeds=seeds,\n", + " partial_state_update_blocks=partial_state_update_blocks\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " ___________ ____\n", + " ________ __ ___/ / ____/ | / __ \\\n", + " / ___/ __` / __ / / / /| | / / / /\n", + "/ /__/ /_/ / /_/ / /___/ ___ |/ /_/ /\n", + "\\___/\\__,_/\\__,_/\\____/_/ |_/_____/\n", + "by cadCAD\n", + "\n", + "Execution Mode: local_proc\n", + "Configuration Count: 2\n", + "Dimensions of the first simulation: (Timesteps, Params, Runs, Vars) = (100, 1, 1, 3)\n", + "Execution Method: local_simulations\n", + "Execution Mode: parallelized\n", + "Total execution time: 9.99s\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from model.model.conviction_helper_functions import *\n", + "from model import run\n", + "from cadCAD import configs\n", + "pd.options.display.float_format = '{:.2f}'.format\n", + "\n", + "%matplotlib inline\n", + "\n", + "# Pass in configuration to run\n", + "df = run.run(configs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After the simulation has run successfully, we perform some postprocessing to extract node and edge values from the network object and add as columns to the pandas dataframe. For the rdf, we take only the values at the last substep of each timestep in the simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "df= run.postprocessing(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "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", + " \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", + " \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", + "
networkfundssentimentsimulationrunsubsteptimestepconvictioncandidate_countcandidate_funds...funds_requestedshare_of_funds_requestedshare_of_funds_requested_alltriggersconviction_share_of_triggerageage_allconviction_alltriggers_allconviction_share_of_trigger_all
785(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,...46982.840.9111496[]00.00...[533.7442840291636, 101.99039020309893, 681.00...[][0.011360408350392771, 0.002170800728349896, 0...[][][][96, 96, 96, 37][nan, nan, 0.0, nan][nan, nan, nan, nan][nan, nan, nan, nan]
789(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,...46991.860.9011497[]00.00...[533.7442840291636, 101.99039020309893, 681.00...[][0.01135822863874518, 0.002170384218706383, 0....[][][][97, 97, 97, 38][nan, nan, 0.0, nan][nan, nan, nan, nan][nan, nan, nan, nan]
793(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,...46997.550.9011498[]00.00...[533.7442840291636, 101.99039020309893, 681.00...[][0.0113568542037439, 0.002170121585145174, 0.0...[][][][98, 98, 98, 39][nan, nan, 0.0, nan][nan, nan, nan, nan][nan, nan, nan, nan]
797(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,...47001.320.8911499[]00.00...[533.7442840291636, 101.99039020309893, 681.00...[][0.011355942408387219, 0.0021699473549623024, ...[][][][99, 99, 99, 40][nan, nan, 0.0, nan][nan, nan, nan, nan][nan, nan, nan, nan]
801(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,...47002.120.88114100[]00.00...[533.7442840291636, 101.99039020309893, 681.00...[][0.011355749547503383, 0.0021699105021895683, ...[][][][100, 100, 100, 41][nan, nan, 0.0, nan][nan, nan, nan, nan][nan, nan, nan, nan]
\n", + "

5 rows × 29 columns

\n", + "
" + ], + "text/plain": [ + " network funds sentiment \\\n", + "785 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,... 46982.84 0.91 \n", + "789 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,... 46991.86 0.90 \n", + "793 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,... 46997.55 0.90 \n", + "797 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,... 47001.32 0.89 \n", + "801 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,... 47002.12 0.88 \n", + "\n", + " simulation run substep timestep conviction candidate_count \\\n", + "785 1 1 4 96 [] 0 \n", + "789 1 1 4 97 [] 0 \n", + "793 1 1 4 98 [] 0 \n", + "797 1 1 4 99 [] 0 \n", + "801 1 1 4 100 [] 0 \n", + "\n", + " candidate_funds ... funds_requested \\\n", + "785 0.00 ... [533.7442840291636, 101.99039020309893, 681.00... \n", + "789 0.00 ... [533.7442840291636, 101.99039020309893, 681.00... \n", + "793 0.00 ... [533.7442840291636, 101.99039020309893, 681.00... \n", + "797 0.00 ... [533.7442840291636, 101.99039020309893, 681.00... \n", + "801 0.00 ... [533.7442840291636, 101.99039020309893, 681.00... \n", + "\n", + " share_of_funds_requested \\\n", + "785 [] \n", + "789 [] \n", + "793 [] \n", + "797 [] \n", + "801 [] \n", + "\n", + " share_of_funds_requested_all triggers \\\n", + "785 [0.011360408350392771, 0.002170800728349896, 0... [] \n", + "789 [0.01135822863874518, 0.002170384218706383, 0.... [] \n", + "793 [0.0113568542037439, 0.002170121585145174, 0.0... [] \n", + "797 [0.011355942408387219, 0.0021699473549623024, ... [] \n", + "801 [0.011355749547503383, 0.0021699105021895683, ... [] \n", + "\n", + " conviction_share_of_trigger age age_all \\\n", + "785 [] [] [96, 96, 96, 37] \n", + "789 [] [] [97, 97, 97, 38] \n", + "793 [] [] [98, 98, 98, 39] \n", + "797 [] [] [99, 99, 99, 40] \n", + "801 [] [] [100, 100, 100, 41] \n", + "\n", + " conviction_all triggers_all \\\n", + "785 [nan, nan, 0.0, nan] [nan, nan, nan, nan] \n", + "789 [nan, nan, 0.0, nan] [nan, nan, nan, nan] \n", + "793 [nan, nan, 0.0, nan] [nan, nan, nan, nan] \n", + "797 [nan, nan, 0.0, nan] [nan, nan, nan, nan] \n", + "801 [nan, nan, 0.0, nan] [nan, nan, nan, nan] \n", + "\n", + " conviction_share_of_trigger_all \n", + "785 [nan, nan, nan, nan] \n", + "789 [nan, nan, nan, nan] \n", + "793 [nan, nan, nan, nan] \n", + "797 [nan, nan, nan, nan] \n", + "801 [nan, nan, nan, nan] \n", + "\n", + "[5 rows x 29 columns]" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.tail()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "affinities_plot(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "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.plot(x='timestep',y=['candidate_count','active_count','completed_count', 'killed_count', 'failed_count'],\n", + " kind='line')\n", + "plt.title('Proposal Status')\n", + "plt.ylabel('count of proposals')\n", + "plt.legend(ncol = 3,loc='upper center', bbox_to_anchor=(0.5, -0.15))" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "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.plot(x='timestep',y=['candidate_funds','active_funds','completed_funds', 'killed_funds', 'failed_funds'])\n", + "plt.title('Proposal Status weighted by funds requested')\n", + "plt.ylabel('Funds worth of proposals')\n", + "plt.legend(ncol = 3,loc='upper center', bbox_to_anchor=(0.5, -0.15))" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "nets = df.network.values" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "K = 0\n", + "N = 100\n", + "\n", + "#snap_plot(nets[K:N], size_scale = 1/10,savefigs=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "# Run the following code , without the #, in the images/snap folder to make a movie\n", + "# ffmpeg -r 10 -i %01d.png -vcodec mpeg4 -y movie.mp4" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%HTML\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conclusion\n", + "\n", + "We have created a simplified conviction voting model that illustrates the state objects, and provides descriptions of how the model fits together. In subsequent notebooks, we will expand the model to introduce additional complexity to more fit real world implementations. " + ] + } + ], + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/v2/images/Aragon_v2.png b/v2/images/Aragon_v2.png new file mode 100644 index 0000000..c4abf19 Binary files /dev/null and b/v2/images/Aragon_v2.png differ diff --git a/v2/images/bipartite_cv_compute.png b/v2/images/bipartite_cv_compute.png new file mode 100644 index 0000000..dd8e8fe Binary files /dev/null and b/v2/images/bipartite_cv_compute.png differ diff --git a/v2/images/cv_bipartite.png b/v2/images/cv_bipartite.png new file mode 100644 index 0000000..1db4dc9 Binary files /dev/null and b/v2/images/cv_bipartite.png differ diff --git a/v2/images/snap/0.png b/v2/images/snap/0.png new file mode 100644 index 0000000..890fa78 Binary files /dev/null and b/v2/images/snap/0.png differ diff --git a/v2/images/snap/1.png b/v2/images/snap/1.png new file mode 100644 index 0000000..1fc9246 Binary files /dev/null and b/v2/images/snap/1.png differ diff --git a/v2/images/snap/10.png b/v2/images/snap/10.png new file mode 100644 index 0000000..a371d10 Binary files /dev/null and b/v2/images/snap/10.png differ diff --git a/v2/images/snap/11.png b/v2/images/snap/11.png new file mode 100644 index 0000000..c0496b0 Binary files /dev/null and b/v2/images/snap/11.png differ diff --git a/v2/images/snap/12.png b/v2/images/snap/12.png new file mode 100644 index 0000000..220272c Binary files /dev/null and b/v2/images/snap/12.png differ diff --git a/v2/images/snap/13.png b/v2/images/snap/13.png new file mode 100644 index 0000000..3d5f657 Binary files /dev/null and b/v2/images/snap/13.png differ diff --git a/v2/images/snap/14.png b/v2/images/snap/14.png new file mode 100644 index 0000000..149d9cf Binary files /dev/null and b/v2/images/snap/14.png differ diff --git a/v2/images/snap/15.png b/v2/images/snap/15.png new file mode 100644 index 0000000..224fe4a Binary files /dev/null and b/v2/images/snap/15.png differ diff --git a/v2/images/snap/16.png b/v2/images/snap/16.png new file mode 100644 index 0000000..96f7ffe Binary files /dev/null and b/v2/images/snap/16.png differ diff --git a/v2/images/snap/17.png b/v2/images/snap/17.png new file mode 100644 index 0000000..b55fa79 Binary files /dev/null and b/v2/images/snap/17.png differ diff --git a/v2/images/snap/18.png b/v2/images/snap/18.png new file mode 100644 index 0000000..203334f Binary files /dev/null and b/v2/images/snap/18.png differ diff --git a/v2/images/snap/19.png b/v2/images/snap/19.png new file mode 100644 index 0000000..ee22162 Binary files /dev/null and b/v2/images/snap/19.png differ diff --git a/v2/images/snap/2.png b/v2/images/snap/2.png new file mode 100644 index 0000000..8aa6cf5 Binary files /dev/null and b/v2/images/snap/2.png differ diff --git a/v2/images/snap/20.png b/v2/images/snap/20.png new file mode 100644 index 0000000..faeb92a Binary files /dev/null and b/v2/images/snap/20.png differ diff --git a/v2/images/snap/21.png b/v2/images/snap/21.png new file mode 100644 index 0000000..5584ed4 Binary files /dev/null and b/v2/images/snap/21.png differ diff --git a/v2/images/snap/22.png b/v2/images/snap/22.png new file mode 100644 index 0000000..5d2cc8c Binary files /dev/null and b/v2/images/snap/22.png differ diff --git a/v2/images/snap/23.png b/v2/images/snap/23.png new file mode 100644 index 0000000..6ca0f15 Binary files /dev/null and b/v2/images/snap/23.png differ diff --git a/v2/images/snap/24.png b/v2/images/snap/24.png new file mode 100644 index 0000000..875ec46 Binary files /dev/null and b/v2/images/snap/24.png differ diff --git a/v2/images/snap/25.png b/v2/images/snap/25.png new file mode 100644 index 0000000..875ec46 Binary files /dev/null and b/v2/images/snap/25.png differ diff --git a/v2/images/snap/26.png b/v2/images/snap/26.png new file mode 100644 index 0000000..85a15d1 Binary files /dev/null and b/v2/images/snap/26.png differ diff --git a/v2/images/snap/27.png b/v2/images/snap/27.png new file mode 100644 index 0000000..421b8ba Binary files /dev/null and b/v2/images/snap/27.png differ diff --git a/v2/images/snap/28.png b/v2/images/snap/28.png new file mode 100644 index 0000000..d375ecb Binary files /dev/null and b/v2/images/snap/28.png differ diff --git a/v2/images/snap/29.png b/v2/images/snap/29.png new file mode 100644 index 0000000..19e3ef4 Binary files /dev/null and b/v2/images/snap/29.png differ diff --git a/v2/images/snap/3.png b/v2/images/snap/3.png new file mode 100644 index 0000000..bb8bae4 Binary files /dev/null and b/v2/images/snap/3.png differ diff --git a/v2/images/snap/30.png b/v2/images/snap/30.png new file mode 100644 index 0000000..6266b10 Binary files /dev/null and b/v2/images/snap/30.png differ diff --git a/v2/images/snap/31.png b/v2/images/snap/31.png new file mode 100644 index 0000000..56e7279 Binary files /dev/null and b/v2/images/snap/31.png differ diff --git a/v2/images/snap/32.png b/v2/images/snap/32.png new file mode 100644 index 0000000..58bf47e Binary files /dev/null and b/v2/images/snap/32.png differ diff --git a/v2/images/snap/33.png b/v2/images/snap/33.png new file mode 100644 index 0000000..8007fa5 Binary files /dev/null and b/v2/images/snap/33.png differ diff --git a/v2/images/snap/34.png b/v2/images/snap/34.png new file mode 100644 index 0000000..b9aac77 Binary files /dev/null and b/v2/images/snap/34.png differ diff --git a/v2/images/snap/35.png b/v2/images/snap/35.png new file mode 100644 index 0000000..0a7b383 Binary files /dev/null and b/v2/images/snap/35.png differ diff --git a/v2/images/snap/36.png b/v2/images/snap/36.png new file mode 100644 index 0000000..1aca26d Binary files /dev/null and b/v2/images/snap/36.png differ diff --git a/v2/images/snap/37.png b/v2/images/snap/37.png new file mode 100644 index 0000000..485265b Binary files /dev/null and b/v2/images/snap/37.png differ diff --git a/v2/images/snap/38.png b/v2/images/snap/38.png new file mode 100644 index 0000000..0c1bf0d Binary files /dev/null and b/v2/images/snap/38.png differ diff --git a/v2/images/snap/39.png b/v2/images/snap/39.png new file mode 100644 index 0000000..cb6ba2e Binary files /dev/null and b/v2/images/snap/39.png differ diff --git a/v2/images/snap/4.png b/v2/images/snap/4.png new file mode 100644 index 0000000..2d7a968 Binary files /dev/null and b/v2/images/snap/4.png differ diff --git a/v2/images/snap/40.png b/v2/images/snap/40.png new file mode 100644 index 0000000..9a4362e Binary files /dev/null and b/v2/images/snap/40.png differ diff --git a/v2/images/snap/41.png b/v2/images/snap/41.png new file mode 100644 index 0000000..de98b73 Binary files /dev/null and b/v2/images/snap/41.png differ diff --git a/v2/images/snap/42.png b/v2/images/snap/42.png new file mode 100644 index 0000000..f8ce93c Binary files /dev/null and b/v2/images/snap/42.png differ diff --git a/v2/images/snap/43.png b/v2/images/snap/43.png new file mode 100644 index 0000000..71b1849 Binary files /dev/null and b/v2/images/snap/43.png differ diff --git a/v2/images/snap/44.png b/v2/images/snap/44.png new file mode 100644 index 0000000..a80e912 Binary files /dev/null and b/v2/images/snap/44.png differ diff --git a/v2/images/snap/45.png b/v2/images/snap/45.png new file mode 100644 index 0000000..840aece Binary files /dev/null and b/v2/images/snap/45.png differ diff --git a/v2/images/snap/46.png b/v2/images/snap/46.png new file mode 100644 index 0000000..1b97c6e Binary files /dev/null and b/v2/images/snap/46.png differ diff --git a/v2/images/snap/47.png b/v2/images/snap/47.png new file mode 100644 index 0000000..1eb44c0 Binary files /dev/null and b/v2/images/snap/47.png differ diff --git a/v2/images/snap/48.png b/v2/images/snap/48.png new file mode 100644 index 0000000..adac6c2 Binary files /dev/null and b/v2/images/snap/48.png differ diff --git a/v2/images/snap/49.png b/v2/images/snap/49.png new file mode 100644 index 0000000..2d60628 Binary files /dev/null and b/v2/images/snap/49.png differ diff --git a/v2/images/snap/5.png b/v2/images/snap/5.png new file mode 100644 index 0000000..df241bf Binary files /dev/null and b/v2/images/snap/5.png differ diff --git a/v2/images/snap/50.png b/v2/images/snap/50.png new file mode 100644 index 0000000..19c184c Binary files /dev/null and b/v2/images/snap/50.png differ diff --git a/v2/images/snap/51.png b/v2/images/snap/51.png new file mode 100644 index 0000000..6a30176 Binary files /dev/null and b/v2/images/snap/51.png differ diff --git a/v2/images/snap/52.png b/v2/images/snap/52.png new file mode 100644 index 0000000..ef6ff90 Binary files /dev/null and b/v2/images/snap/52.png differ diff --git a/v2/images/snap/53.png b/v2/images/snap/53.png new file mode 100644 index 0000000..4bea336 Binary files /dev/null and b/v2/images/snap/53.png differ diff --git a/v2/images/snap/54.png b/v2/images/snap/54.png new file mode 100644 index 0000000..fa5937a Binary files /dev/null and b/v2/images/snap/54.png differ diff --git a/v2/images/snap/55.png b/v2/images/snap/55.png new file mode 100644 index 0000000..cd3a472 Binary files /dev/null and b/v2/images/snap/55.png differ diff --git a/v2/images/snap/56.png b/v2/images/snap/56.png new file mode 100644 index 0000000..81fb166 Binary files /dev/null and b/v2/images/snap/56.png differ diff --git a/v2/images/snap/57.png b/v2/images/snap/57.png new file mode 100644 index 0000000..8b09f92 Binary files /dev/null and b/v2/images/snap/57.png differ diff --git a/v2/images/snap/58.png b/v2/images/snap/58.png new file mode 100644 index 0000000..c4fbb56 Binary files /dev/null and b/v2/images/snap/58.png differ diff --git a/v2/images/snap/59.png b/v2/images/snap/59.png new file mode 100644 index 0000000..4e91b98 Binary files /dev/null and b/v2/images/snap/59.png differ diff --git a/v2/images/snap/6.png b/v2/images/snap/6.png new file mode 100644 index 0000000..cc463cd Binary files /dev/null and b/v2/images/snap/6.png differ diff --git a/v2/images/snap/60.png b/v2/images/snap/60.png new file mode 100644 index 0000000..9fa60f5 Binary files /dev/null and b/v2/images/snap/60.png differ diff --git a/v2/images/snap/61.png b/v2/images/snap/61.png new file mode 100644 index 0000000..021bdbc Binary files /dev/null and b/v2/images/snap/61.png differ diff --git a/v2/images/snap/62.png b/v2/images/snap/62.png new file mode 100644 index 0000000..57f11e0 Binary files /dev/null and b/v2/images/snap/62.png differ diff --git a/v2/images/snap/63.png b/v2/images/snap/63.png new file mode 100644 index 0000000..25dd4b7 Binary files /dev/null and b/v2/images/snap/63.png differ diff --git a/v2/images/snap/64.png b/v2/images/snap/64.png new file mode 100644 index 0000000..a3f18c4 Binary files /dev/null and b/v2/images/snap/64.png differ diff --git a/v2/images/snap/65.png b/v2/images/snap/65.png new file mode 100644 index 0000000..d478c51 Binary files /dev/null and b/v2/images/snap/65.png differ diff --git a/v2/images/snap/66.png b/v2/images/snap/66.png new file mode 100644 index 0000000..8e28bbc Binary files /dev/null and b/v2/images/snap/66.png differ diff --git a/v2/images/snap/67.png b/v2/images/snap/67.png new file mode 100644 index 0000000..4b07612 Binary files /dev/null and b/v2/images/snap/67.png differ diff --git a/v2/images/snap/68.png b/v2/images/snap/68.png new file mode 100644 index 0000000..d28209a Binary files /dev/null and b/v2/images/snap/68.png differ diff --git a/v2/images/snap/69.png b/v2/images/snap/69.png new file mode 100644 index 0000000..5a4a0ac Binary files /dev/null and b/v2/images/snap/69.png differ diff --git a/v2/images/snap/7.png b/v2/images/snap/7.png new file mode 100644 index 0000000..c8f37c2 Binary files /dev/null and b/v2/images/snap/7.png differ diff --git a/v2/images/snap/70.png b/v2/images/snap/70.png new file mode 100644 index 0000000..f7dc959 Binary files /dev/null and b/v2/images/snap/70.png differ diff --git a/v2/images/snap/71.png b/v2/images/snap/71.png new file mode 100644 index 0000000..8267312 Binary files /dev/null and b/v2/images/snap/71.png differ diff --git a/v2/images/snap/72.png b/v2/images/snap/72.png new file mode 100644 index 0000000..35b8c06 Binary files /dev/null and b/v2/images/snap/72.png differ diff --git a/v2/images/snap/73.png b/v2/images/snap/73.png new file mode 100644 index 0000000..8979c9d Binary files /dev/null and b/v2/images/snap/73.png differ diff --git a/v2/images/snap/74.png b/v2/images/snap/74.png new file mode 100644 index 0000000..a706a8c Binary files /dev/null and b/v2/images/snap/74.png differ diff --git a/v2/images/snap/75.png b/v2/images/snap/75.png new file mode 100644 index 0000000..69076a9 Binary files /dev/null and b/v2/images/snap/75.png differ diff --git a/v2/images/snap/76.png b/v2/images/snap/76.png new file mode 100644 index 0000000..99ef55e Binary files /dev/null and b/v2/images/snap/76.png differ diff --git a/v2/images/snap/77.png b/v2/images/snap/77.png new file mode 100644 index 0000000..d92acdf Binary files /dev/null and b/v2/images/snap/77.png differ diff --git a/v2/images/snap/78.png b/v2/images/snap/78.png new file mode 100644 index 0000000..98a4ab5 Binary files /dev/null and b/v2/images/snap/78.png differ diff --git a/v2/images/snap/79.png b/v2/images/snap/79.png new file mode 100644 index 0000000..877781c Binary files /dev/null and b/v2/images/snap/79.png differ diff --git a/v2/images/snap/8.png b/v2/images/snap/8.png new file mode 100644 index 0000000..150348b Binary files /dev/null and b/v2/images/snap/8.png differ diff --git a/v2/images/snap/80.png b/v2/images/snap/80.png new file mode 100644 index 0000000..3298751 Binary files /dev/null and b/v2/images/snap/80.png differ diff --git a/v2/images/snap/81.png b/v2/images/snap/81.png new file mode 100644 index 0000000..ae10758 Binary files /dev/null and b/v2/images/snap/81.png differ diff --git a/v2/images/snap/82.png b/v2/images/snap/82.png new file mode 100644 index 0000000..4e3c2ca Binary files /dev/null and b/v2/images/snap/82.png differ diff --git a/v2/images/snap/83.png b/v2/images/snap/83.png new file mode 100644 index 0000000..bcfde24 Binary files /dev/null and b/v2/images/snap/83.png differ diff --git a/v2/images/snap/84.png b/v2/images/snap/84.png new file mode 100644 index 0000000..3737f29 Binary files /dev/null and b/v2/images/snap/84.png differ diff --git a/v2/images/snap/85.png b/v2/images/snap/85.png new file mode 100644 index 0000000..a80f108 Binary files /dev/null and b/v2/images/snap/85.png differ diff --git a/v2/images/snap/86.png b/v2/images/snap/86.png new file mode 100644 index 0000000..7f0e156 Binary files /dev/null and b/v2/images/snap/86.png differ diff --git a/v2/images/snap/87.png b/v2/images/snap/87.png new file mode 100644 index 0000000..25b8ae3 Binary files /dev/null and b/v2/images/snap/87.png differ diff --git a/v2/images/snap/88.png b/v2/images/snap/88.png new file mode 100644 index 0000000..11712d8 Binary files /dev/null and b/v2/images/snap/88.png differ diff --git a/v2/images/snap/89.png b/v2/images/snap/89.png new file mode 100644 index 0000000..ff98d64 Binary files /dev/null and b/v2/images/snap/89.png differ diff --git a/v2/images/snap/9.png b/v2/images/snap/9.png new file mode 100644 index 0000000..b403e09 Binary files /dev/null and b/v2/images/snap/9.png differ diff --git a/v2/images/snap/90.png b/v2/images/snap/90.png new file mode 100644 index 0000000..7323f46 Binary files /dev/null and b/v2/images/snap/90.png differ diff --git a/v2/images/snap/91.png b/v2/images/snap/91.png new file mode 100644 index 0000000..d304c8b Binary files /dev/null and b/v2/images/snap/91.png differ diff --git a/v2/images/snap/92.png b/v2/images/snap/92.png new file mode 100644 index 0000000..dc98264 Binary files /dev/null and b/v2/images/snap/92.png differ diff --git a/v2/images/snap/93.png b/v2/images/snap/93.png new file mode 100644 index 0000000..f9fde40 Binary files /dev/null and b/v2/images/snap/93.png differ diff --git a/v2/images/snap/94.png b/v2/images/snap/94.png new file mode 100644 index 0000000..62759eb Binary files /dev/null and b/v2/images/snap/94.png differ diff --git a/v2/images/snap/95.png b/v2/images/snap/95.png new file mode 100644 index 0000000..4a3f506 Binary files /dev/null and b/v2/images/snap/95.png differ diff --git a/v2/images/snap/96.png b/v2/images/snap/96.png new file mode 100644 index 0000000..6976a15 Binary files /dev/null and b/v2/images/snap/96.png differ diff --git a/v2/images/snap/97.png b/v2/images/snap/97.png new file mode 100644 index 0000000..be3549c Binary files /dev/null and b/v2/images/snap/97.png differ diff --git a/v2/images/snap/98.png b/v2/images/snap/98.png new file mode 100644 index 0000000..45f5050 Binary files /dev/null and b/v2/images/snap/98.png differ diff --git a/v2/images/snap/99.png b/v2/images/snap/99.png new file mode 100644 index 0000000..ca1af60 Binary files /dev/null and b/v2/images/snap/99.png differ diff --git a/v2/images/snap/movie.mp4 b/v2/images/snap/movie.mp4 new file mode 100644 index 0000000..2da580d Binary files /dev/null and b/v2/images/snap/movie.mp4 differ diff --git a/v2/images/stockflow_cv_trigger.png b/v2/images/stockflow_cv_trigger.png new file mode 100644 index 0000000..447292d Binary files /dev/null and b/v2/images/stockflow_cv_trigger.png differ diff --git a/v2/model/__pycache__/economyconfig.cpython-36.pyc b/v2/model/__pycache__/economyconfig.cpython-36.pyc new file mode 100644 index 0000000..655f4d0 Binary files /dev/null and b/v2/model/__pycache__/economyconfig.cpython-36.pyc differ diff --git a/v2/model/__pycache__/economyconfig.cpython-37.pyc b/v2/model/__pycache__/economyconfig.cpython-37.pyc new file mode 100644 index 0000000..32179d6 Binary files /dev/null and b/v2/model/__pycache__/economyconfig.cpython-37.pyc differ diff --git a/v2/model/__pycache__/genesis_states.cpython-36.pyc b/v2/model/__pycache__/genesis_states.cpython-36.pyc new file mode 100644 index 0000000..6bfaa88 Binary files /dev/null and b/v2/model/__pycache__/genesis_states.cpython-36.pyc differ diff --git a/v2/model/__pycache__/genesis_states.cpython-37.pyc b/v2/model/__pycache__/genesis_states.cpython-37.pyc new file mode 100644 index 0000000..740039a Binary files /dev/null and b/v2/model/__pycache__/genesis_states.cpython-37.pyc differ diff --git a/v2/model/__pycache__/partial_state_update_block.cpython-36.pyc b/v2/model/__pycache__/partial_state_update_block.cpython-36.pyc new file mode 100644 index 0000000..144cd57 Binary files /dev/null and b/v2/model/__pycache__/partial_state_update_block.cpython-36.pyc differ diff --git a/v2/model/__pycache__/partial_state_update_block.cpython-37.pyc b/v2/model/__pycache__/partial_state_update_block.cpython-37.pyc new file mode 100644 index 0000000..40c12bc Binary files /dev/null and b/v2/model/__pycache__/partial_state_update_block.cpython-37.pyc differ diff --git a/v2/model/__pycache__/run.cpython-36.pyc b/v2/model/__pycache__/run.cpython-36.pyc new file mode 100644 index 0000000..e01b885 Binary files /dev/null and b/v2/model/__pycache__/run.cpython-36.pyc differ diff --git a/v2/model/__pycache__/run.cpython-37.pyc b/v2/model/__pycache__/run.cpython-37.pyc new file mode 100644 index 0000000..6b2a2e9 Binary files /dev/null and b/v2/model/__pycache__/run.cpython-37.pyc differ diff --git a/v2/model/economyconfig.py b/v2/model/economyconfig.py new file mode 100644 index 0000000..33f5719 --- /dev/null +++ b/v2/model/economyconfig.py @@ -0,0 +1,40 @@ +import math +from decimal import Decimal +from datetime import timedelta +import numpy as np +from typing import Dict, List + +from cadCAD.configuration import append_configs +from cadCAD.configuration.utils import bound_norm_random, ep_time_step, config_sim, access_block + +from .genesis_states import genesis_states +from .partial_state_update_block import partial_state_update_blocks + + +sim_config = config_sim({ + 'N': 1, + 'T': range(100), #day +}) + +seeds = { + 'p': np.random.RandomState(1), +} + + +append_configs( + sim_configs=sim_config, + initial_state=genesis_states, + seeds=seeds, + partial_state_update_blocks=partial_state_update_blocks +) + + + +def get_configs(): + ''' + Function to extract the configuration information for display in a notebook. + ''' + + sim_config,genesis_states,seeds,partial_state_update_blocks + + return sim_config,genesis_states,seeds,partial_state_update_blocks diff --git a/v2/model/genesis_states.py b/v2/model/genesis_states.py new file mode 100644 index 0000000..03cd4be --- /dev/null +++ b/v2/model/genesis_states.py @@ -0,0 +1,9 @@ +from .model.initialization import * + + +genesis_states = { + 'network':network, + 'funds':initial_funds, + 'sentiment': initial_sentiment + +} \ No newline at end of file diff --git a/v2/model/model/__pycache__/conviction_helper_functions.cpython-36.pyc b/v2/model/model/__pycache__/conviction_helper_functions.cpython-36.pyc new file mode 100644 index 0000000..4c3ea54 Binary files /dev/null and b/v2/model/model/__pycache__/conviction_helper_functions.cpython-36.pyc differ diff --git a/v2/model/model/__pycache__/conviction_helper_functions.cpython-37.pyc b/v2/model/model/__pycache__/conviction_helper_functions.cpython-37.pyc new file mode 100644 index 0000000..9975c8d Binary files /dev/null and b/v2/model/model/__pycache__/conviction_helper_functions.cpython-37.pyc differ diff --git a/v2/model/model/__pycache__/designed.cpython-36.pyc b/v2/model/model/__pycache__/designed.cpython-36.pyc new file mode 100644 index 0000000..3a90629 Binary files /dev/null and b/v2/model/model/__pycache__/designed.cpython-36.pyc differ diff --git a/v2/model/model/__pycache__/designed.cpython-37.pyc b/v2/model/model/__pycache__/designed.cpython-37.pyc new file mode 100644 index 0000000..99d2f46 Binary files /dev/null and b/v2/model/model/__pycache__/designed.cpython-37.pyc differ diff --git a/v2/model/model/__pycache__/exogenousProcesses.cpython-36.pyc b/v2/model/model/__pycache__/exogenousProcesses.cpython-36.pyc new file mode 100644 index 0000000..0359756 Binary files /dev/null and b/v2/model/model/__pycache__/exogenousProcesses.cpython-36.pyc differ diff --git a/v2/model/model/__pycache__/exogenousProcesses.cpython-37.pyc b/v2/model/model/__pycache__/exogenousProcesses.cpython-37.pyc new file mode 100644 index 0000000..a7ccb55 Binary files /dev/null and b/v2/model/model/__pycache__/exogenousProcesses.cpython-37.pyc differ diff --git a/v2/model/model/__pycache__/initialization.cpython-36.pyc b/v2/model/model/__pycache__/initialization.cpython-36.pyc new file mode 100644 index 0000000..f5fe346 Binary files /dev/null and b/v2/model/model/__pycache__/initialization.cpython-36.pyc differ diff --git a/v2/model/model/__pycache__/initialization.cpython-37.pyc b/v2/model/model/__pycache__/initialization.cpython-37.pyc new file mode 100644 index 0000000..90ea8e3 Binary files /dev/null and b/v2/model/model/__pycache__/initialization.cpython-37.pyc differ diff --git a/v2/model/model/__pycache__/kpis.cpython-36.pyc b/v2/model/model/__pycache__/kpis.cpython-36.pyc new file mode 100644 index 0000000..c490e1b Binary files /dev/null and b/v2/model/model/__pycache__/kpis.cpython-36.pyc differ diff --git a/v2/model/model/__pycache__/kpis.cpython-37.pyc b/v2/model/model/__pycache__/kpis.cpython-37.pyc new file mode 100644 index 0000000..76885e4 Binary files /dev/null and b/v2/model/model/__pycache__/kpis.cpython-37.pyc differ diff --git a/v2/model/model/__pycache__/operatorentity.cpython-37.pyc b/v2/model/model/__pycache__/operatorentity.cpython-37.pyc new file mode 100644 index 0000000..e74920f Binary files /dev/null and b/v2/model/model/__pycache__/operatorentity.cpython-37.pyc differ diff --git a/v2/model/model/__pycache__/participants.cpython-36.pyc b/v2/model/model/__pycache__/participants.cpython-36.pyc new file mode 100644 index 0000000..193c8e2 Binary files /dev/null and b/v2/model/model/__pycache__/participants.cpython-36.pyc differ diff --git a/v2/model/model/__pycache__/participants.cpython-37.pyc b/v2/model/model/__pycache__/participants.cpython-37.pyc new file mode 100644 index 0000000..1316a1c Binary files /dev/null and b/v2/model/model/__pycache__/participants.cpython-37.pyc differ diff --git a/v2/model/model/__pycache__/proposals.cpython-36.pyc b/v2/model/model/__pycache__/proposals.cpython-36.pyc new file mode 100644 index 0000000..24944e1 Binary files /dev/null and b/v2/model/model/__pycache__/proposals.cpython-36.pyc differ diff --git a/v2/model/model/__pycache__/proposals.cpython-37.pyc b/v2/model/model/__pycache__/proposals.cpython-37.pyc new file mode 100644 index 0000000..36451ea Binary files /dev/null and b/v2/model/model/__pycache__/proposals.cpython-37.pyc differ diff --git a/v2/model/model/__pycache__/subpopulation_clusters.cpython-37.pyc b/v2/model/model/__pycache__/subpopulation_clusters.cpython-37.pyc new file mode 100644 index 0000000..13c38d8 Binary files /dev/null and b/v2/model/model/__pycache__/subpopulation_clusters.cpython-37.pyc differ diff --git a/v2/model/model/__pycache__/supportingFunctions.cpython-37.pyc b/v2/model/model/__pycache__/supportingFunctions.cpython-37.pyc new file mode 100644 index 0000000..27b89f6 Binary files /dev/null and b/v2/model/model/__pycache__/supportingFunctions.cpython-37.pyc differ diff --git a/v2/model/model/__pycache__/system.cpython-36.pyc b/v2/model/model/__pycache__/system.cpython-36.pyc new file mode 100644 index 0000000..5ae2e26 Binary files /dev/null and b/v2/model/model/__pycache__/system.cpython-36.pyc differ diff --git a/v2/model/model/__pycache__/system.cpython-37.pyc b/v2/model/model/__pycache__/system.cpython-37.pyc new file mode 100644 index 0000000..b4aa8f4 Binary files /dev/null and b/v2/model/model/__pycache__/system.cpython-37.pyc differ diff --git a/v2/model/model/conviction_helper_functions.py b/v2/model/model/conviction_helper_functions.py new file mode 100644 index 0000000..3d21a3c --- /dev/null +++ b/v2/model/model/conviction_helper_functions.py @@ -0,0 +1,587 @@ +import networkx as nx +from scipy.stats import expon, gamma +import numpy as np +import matplotlib.pyplot as plt +import matplotlib.colors as colors +import matplotlib.cm as cmx +import seaborn as sns + +beta = .2 #later we should set this to be param so we can sweep it +# tuning param for the trigger function +rho = .001 +alpha = 1 - 0.9999599 + + +def trigger_threshold(requested, funds, supply, beta, rho, alpha): + ''' + Function that determines threshold for proposals being accepted. + ''' + share = requested/funds + if share < beta: + threshold = rho*supply/(beta-share)**2 * 1/(1-alpha) + return threshold + else: + return np.inf + +def initial_social_network(network, scale = 1, sigmas=3): + ''' + Function to initialize network x social network edges + ''' + participants = get_nodes_by_type(network, 'participant') + + for i in participants: + for j in participants: + if not(j==i): + influence_rv = expon.rvs(loc=0.0, scale=scale) + if influence_rv > scale+sigmas*scale**2: + network.add_edge(i,j) + network.edges[(i,j)]['influence'] = influence_rv + network.edges[(i,j)]['type'] = 'influence' + return network + +def initial_conflict_network(network, rate = .25): + ''' + Definition: + Function to initialize network x conflict edges + ''' + proposals = get_nodes_by_type(network, 'proposal') + + for i in proposals: + for j in proposals: + if not(j==i): + conflict_rv = np.random.rand() + if conflict_rv < rate : + network.add_edge(i,j) + network.edges[(i,j)]['conflict'] = 1-conflict_rv + network.edges[(i,j)]['type'] = 'conflict' + return network + +def gen_new_participant(network, new_participant_holdings): + ''' + Definition: + Driving processes for the arrival of participants. + + Parameters: + network: networkx object + new_participant_holdings: Tokens of new participants + + Assumptions: + Initialized network x object + + Returns: + Update network x object + ''' + + i = len([node for node in network.nodes]) + + network.add_node(i) + network.nodes[i]['type']="participant" + + s_rv = np.random.rand() + network.nodes[i]['sentiment'] = s_rv + network.nodes[i]['holdings']=new_participant_holdings + + for j in get_nodes_by_type(network, 'proposal'): + network.add_edge(i, j) + + a_rv = a_rv = np.random.uniform(-1,1,1)[0] + network.edges[(i, j)]['affinity'] = a_rv + network.edges[(i,j)]['tokens'] = a_rv*network.nodes[i]['holdings'] + network.edges[(i, j)]['conviction'] = 0 + network.edges[(i,j)]['type'] = 'support' + + return network + + + + +def gen_new_proposal(network, funds, supply, scale_factor = 1.0/100): + ''' + Definition: + Driving processes for the arrival of proposals. + + Parameters: + network: networkx object + funds: + supply: + + Assumptions: + Initialized network x object + + Returns: + Update network x object + ''' + j = len([node for node in network.nodes]) + network.add_node(j) + network.nodes[j]['type']="proposal" + + network.nodes[j]['conviction']=0 + network.nodes[j]['status']='candidate' + network.nodes[j]['age']=0 + + rescale = funds*scale_factor + r_rv = gamma.rvs(1.5,loc=0.001, scale=rescale) + network.nodes[j]['funds_requested'] = r_rv + + network.nodes[j]['trigger']= trigger_threshold(r_rv, funds, supply, beta, rho, alpha) + + participants = get_nodes_by_type(network, 'participant') + proposing_participant = np.random.choice(participants) + + for i in participants: + network.add_edge(i, j) + if i==proposing_participant: + network.edges[(i, j)]['affinity']=1 + else: + a_rv = np.random.uniform(-1,1,1)[0] + network.edges[(i, j)]['affinity'] = a_rv + + network.edges[(i, j)]['conviction'] = 0 + network.edges[(i,j)]['tokens'] = 0 + network.edges[(i,j)]['type'] = 'support' + + return network + + +def get_nodes_by_type(g, node_type_selection): + ''' + Definition: + Function to extract nodes based by named type + + Parameters: + g: network x object + node_type_selection: node type + + Assumptions: + + Returns: + List column of the desired information as: + + Example: + proposals = get_nodes_by_type(network, 'proposal') + + ''' + return [node for node in g.nodes if g.nodes[node]['type']== node_type_selection ] + +def get_sentimental(sentiment, force, decay=0): + ''' + ''' + mu = decay + sentiment = sentiment*(1-mu) + force + + if sentiment > 1: + sentiment = 1 + + return sentiment + +def get_edges_by_type(g, edge_type_selection): + ''' + Functions to extract edges based on type + ''' + return [edge for edge in g.edges if g.edges[edge]['type']== edge_type_selection ] + + +def conviction_order(network, proposals): + ''' + Function to sort conviction order + ''' + ordered = sorted(proposals, key=lambda j:network.nodes[j]['conviction'] , reverse=True) + + return ordered + + + +def social_links(network, participant, scale = 1): + ''' + ''' + + participants = get_nodes_by_type(network, 'participant') + + i = participant + for j in participants: + if not(j==i): + influence_rv = expon.rvs(loc=0.0, scale=scale) + if influence_rv > scale+scale**2: + network.add_edge(i,j) + network.edges[(i,j)]['influence'] = influence_rv + network.edges[(i,j)]['type'] = 'influence' + return network + + +def conflict_links(network,proposal ,rate = .25): + ''' + ''' + + proposals = get_nodes_by_type(network, 'proposal') + + i = proposal + for j in proposals: + if not(j==i): + conflict_rv = np.random.rand() + if conflict_rv < rate : + network.add_edge(i,j) + network.edges[(i,j)]['conflict'] = 1-conflict_rv + network.edges[(i,j)]['type'] = 'conflict' + return network + +def social_affinity_booster(network, proposal, participant): + ''' + ''' + + participants = get_nodes_by_type(network, 'participant') + influencers = get_edges_by_type(network, 'influence') + + j=proposal + i=participant + + i_tokens = network.nodes[i]['holdings'] + + influence = np.array([network.edges[(i,node)]['influence'] for node in participants if (i, node) in influencers ]) + #print(influence) + tokens = np.array([network.edges[(node,j)]['tokens'] for node in participants if (i, node) in influencers ]) + #print(tokens) + + + influence_sum = np.sum(influence) + + if influence_sum>0: + boosts = np.sum(tokens*influence)/(influence_sum*i_tokens) + else: + boosts = 0 + + return np.sum(boosts) + + +def snap_plot(nets, size_scale = 1/10, dims = (30,30), savefigs=False): + ''' + ''' + + last_net = nets[-1] + + last_props=get_nodes_by_type(last_net, 'proposal') + M = len(last_props) + last_parts=get_nodes_by_type(last_net, 'participant') + N = len(last_parts) + pos = {} + + for ind in range(N): + i = last_parts[ind] + pos[i] = np.array([0, 2*ind-N]) + + for ind in range(M): + j = last_props[ind] + pos[j] = np.array([1, 2*N/M *ind-N]) + + + if savefigs: + counter = 0 + length = 10 + + for net in nets: + edges = get_edges_by_type(net, 'support') + max_tok = np.max([net.edges[e]['tokens'] for e in edges]) + + E = len(edges) + + net_props = get_nodes_by_type(net, 'proposal') + net_parts = get_nodes_by_type(net, 'participant') + net_node_label ={} + + num_nodes = len([node for node in net.nodes]) + + node_color = np.empty((num_nodes,4)) + node_size = np.empty(num_nodes) + + edge_color = np.empty((E,4)) + cm = plt.get_cmap('Reds') + + cNorm = colors.Normalize(vmin=0, vmax=max_tok) + scalarMap = cmx.ScalarMappable(norm=cNorm, cmap=cm) + + net_cand = [j for j in net_props if net.nodes[j]['status']=='candidate'] + + for j in net_props: + node_size[j] = net.nodes[j]['funds_requested']*size_scale + if net.nodes[j]['status']=="candidate": + node_color[j] = colors.to_rgba('blue') + trigger = net.nodes[j]['trigger'] + conviction = net.nodes[j]['conviction'] + percent_of_trigger = " "+str(int(100*conviction/trigger))+'%' + net_node_label[j] = str(percent_of_trigger) + elif net.nodes[j]['status']=="active": + node_color[j] = colors.to_rgba('orange') + net_node_label[j] = '' + elif net.nodes[j]['status']=="completed": + node_color[j] = colors.to_rgba('green') + net_node_label[j] = '' + elif net.nodes[j]['status']=="failed": + node_color[j] = colors.to_rgba('gray') + net_node_label[j] = '' + elif net.nodes[j]['status']=="killed": + node_color[j] = colors.to_rgba('black') + net_node_label[j] = '' + + for i in net_parts: + node_size[i] = net.nodes[i]['holdings']*size_scale/10 + node_color[i] = colors.to_rgba('red') + net_node_label[i] = '' + + included_edges = [] + for ind in range(E): + e = edges[ind] + tokens = net.edges[e]['tokens'] + edge_color[ind] = scalarMap.to_rgba(tokens) + if e[1] in net_cand: + included_edges.append(e) + + + iE = len(included_edges) + included_edge_color = np.empty((iE,4)) + for ind in range(iE): + e = included_edges[ind] + tokens = net.edges[e]['tokens'] + included_edge_color[ind] = scalarMap.to_rgba(tokens) + + # nx.draw(net, + # pos=pos, + # node_size = node_size, + # node_color = node_color, + # edge_color = included_edge_color, + # edgelist=included_edges, + # labels = net_node_label) + # plt.title('Tokens Staked by Partipants to Proposals') + + + else: + plt.figure() + nx.draw(net, + pos=pos, + node_size = node_size, + node_color = node_color, + edge_color = included_edge_color, + edgelist=included_edges, + labels = net_node_label) + plt.title('Tokens Staked by Partipants to Proposals') + plt.tight_layout() + plt.axis('on') + plt.xticks([]) + plt.yticks([]) + if savefigs: + #plt.savefig('images/' + unique_id+'_fig'+str(counter)+'.png') + plt.savefig('images/snap/'+str(counter)+'.png',bbox_inches='tight') + + counter = counter+1 + plt.show() + +def pad(vec, length,fill=True): + ''' + ''' + + if fill: + padded = np.zeros(length,) + else: + padded = np.empty(length,) + padded[:] = np.nan + + for i in range(len(vec)): + padded[i]= vec[i] + + return padded + +def make2D(key, data, fill=False): + ''' + ''' + maxL = data[key].apply(len).max() + newkey = 'padded_'+key + data[newkey] = data[key].apply(lambda x: pad(x,maxL,fill)) + reshaped = np.array([a for a in data[newkey].values]) + + return reshaped + + +def quantile_plot(xkey, ykey, dataframe, dq=.1, logy=False, return_df = False): + ''' + ''' + qX = np.arange(0,1+dq,dq) + + data = dataframe[[xkey,ykey]].copy() + + qkeys = [] + for q in qX: + qkey= 'quantile'+str(int(100*q)) + #print(qkey) + data[qkey] = data[ykey].apply(lambda arr: np.quantile(arr,q) ) + #print(data[qkey].head()) + qkeys.append(qkey) + + data[[xkey]+qkeys].plot(x=xkey, logy=logy) + + plt.title(ykey + " Quantile Plot" ) + plt.ylabel(ykey) + labels = [str(int(100*q))+"$^{th}$ Percentile" for q in qX ] + + plt.legend(labels, ncol = 1,loc='center left', bbox_to_anchor=(1, .5)) + if return_df: + return data + +def affinities_plot(df): + ''' + ''' + last_net= df.network.values[-1] + last_props=get_nodes_by_type(last_net, 'proposal') + M = len(last_props) + last_parts=get_nodes_by_type(last_net, 'participant') + N = len(last_parts) + + affinities = np.empty((N,M)) + for i_ind in range(N): + for j_ind in range(M): + i = last_parts[i_ind] + j = last_props[j_ind] + affinities[i_ind][j_ind] = last_net.edges[(i,j)]['affinity'] + + dims = (20, 5) + fig, ax = plt.subplots(figsize=dims) + + sns.heatmap(affinities.T, + xticklabels=last_parts, + yticklabels=last_props, + square=True, + cbar=True, + ax=ax) + + plt.title('affinities between participants and proposals') + plt.ylabel('proposal_id') + plt.xlabel('participant_id') + + + + +def trigger_sweep(field, trigger_func,beta,rho,alpha,xmax=.2): + ''' + ''' + if field == 'effective_supply': + share_of_funds = np.arange(.001,xmax,.001) + total_supply = np.arange(0,10**9, 10**6) + demo_data_XY = np.outer(share_of_funds,total_supply) + + demo_data_Z0=np.empty(demo_data_XY.shape) + demo_data_Z1=np.empty(demo_data_XY.shape) + demo_data_Z2=np.empty(demo_data_XY.shape) + demo_data_Z3=np.empty(demo_data_XY.shape) + for sof_ind in range(len(share_of_funds)): + sof = share_of_funds[sof_ind] + for ts_ind in range(len(total_supply)): + ts = total_supply[ts_ind] + tc = ts /(1-alpha) + trigger = trigger_func(sof, 1, ts,beta,rho,alpha) + demo_data_Z0[sof_ind,ts_ind] = np.log10(trigger) + demo_data_Z1[sof_ind,ts_ind] = trigger + demo_data_Z2[sof_ind,ts_ind] = trigger/tc #share of maximum possible conviction + demo_data_Z3[sof_ind,ts_ind] = np.log10(trigger/tc) + return {'log10_trigger':demo_data_Z0, + 'trigger':demo_data_Z1, + 'share_of_max_conv': demo_data_Z2, + 'log10_share_of_max_conv':demo_data_Z3, + 'total_supply':total_supply, + 'share_of_funds':share_of_funds} + elif field == 'alpha': + alpha = np.arange(0,1,.001) + share_of_funds = np.arange(.001,xmax,.001) + total_supply = 10**9 + demo_data_XY = np.outer(share_of_funds,alpha) + + demo_data_Z4=np.empty(demo_data_XY.shape) + demo_data_Z5=np.empty(demo_data_XY.shape) + demo_data_Z6=np.empty(demo_data_XY.shape) + demo_data_Z7=np.empty(demo_data_XY.shape) + for sof_ind in range(len(share_of_funds)): + sof = share_of_funds[sof_ind] + for a_ind in range(len(alpha)): + ts = total_supply + a = alpha[a_ind] + tc = ts /(1-a) + trigger = trigger_func(sof, 1, ts, beta, rho, a) + demo_data_Z4[sof_ind,a_ind] = np.log10(trigger) + demo_data_Z5[sof_ind,a_ind] = trigger + demo_data_Z6[sof_ind,a_ind] = trigger/tc #share of maximum possible conviction + demo_data_Z7[sof_ind,a_ind] = np.log10(trigger/tc) + + return {'log10_trigger':demo_data_Z4, + 'trigger':demo_data_Z5, + 'share_of_max_conv': demo_data_Z6, + 'log10_share_of_max_conv':demo_data_Z7, + 'alpha':alpha, + 'share_of_funds':share_of_funds} + + else: + return "invalid field" + +def trigger_plotter(share_of_funds,Z, color_label,y, ylabel,cmap='jet'): + ''' + ''' + dims = (10, 5) + fig, ax = plt.subplots(figsize=dims) + + cf = plt.contourf(share_of_funds, y, Z.T, 100, cmap=cmap) + cbar=plt.colorbar(cf) + plt.axis([share_of_funds[0], share_of_funds[-1], y[0], y[-1]]) + #ax.set_xscale('log') + plt.ylabel(ylabel) + plt.xlabel('Share of Funds Requested') + plt.title('Trigger Function Map') + + cbar.ax.set_ylabel(color_label) + +def trigger_grid(supply_sweep, alpha_sweep): + + fig, axs = plt.subplots(nrows=2, ncols=2,figsize=(20,20)) + axs = axs.flatten() + + share_of_funds = alpha_sweep['share_of_funds'] + Z = alpha_sweep['log10_share_of_max_conv'] + y = alpha_sweep['alpha'] + ylabel = 'alpha' + + axs[0].contourf(share_of_funds, y, Z.T,100, cmap='jet', ) + #axs[0].colorbar(cf) + axs[0].axis([share_of_funds[0], share_of_funds[-1], y[0], y[-1]]) + axs[0].set_ylabel(ylabel) + axs[0].set_xlabel('Share of Funds Requested') + axs[0].set_title('Trigger Function Map - Alpha sweep') + + + share_of_funds = alpha_sweep['share_of_funds'] + Z = alpha_sweep['log10_trigger'] + y = alpha_sweep['alpha'] + ylabel = 'alpha' + + axs[1].contourf(share_of_funds, y, Z.T,100, cmap='jet', ) + axs[1].axis([share_of_funds[0], share_of_funds[-1], y[0], y[-1]]) + axs[1].set_ylabel(ylabel) + axs[1].set_xlabel('Share of Funds Requested') + axs[1].set_title('Trigger Function Map - Alpha sweep - Z: log10_trigger') + + share_of_funds = supply_sweep['share_of_funds'] + Z = supply_sweep['log10_share_of_max_conv'] + y = supply_sweep['total_supply'] + ylabel = 'Effective Supply' + + axs[2].contourf(share_of_funds, y, Z.T,100, cmap='jet', ) + axs[2].axis([share_of_funds[0], share_of_funds[-1], y[0], y[-1]]) + axs[2].set_ylabel(ylabel) + axs[2].set_xlabel('Share of Funds Requested') + axs[2].set_title('Trigger Function Map - Supply sweep - Z: share_of_max_conv') + + + share_of_funds = supply_sweep['share_of_funds'] + Z = supply_sweep['log10_trigger'] + y = supply_sweep['total_supply'] + ylabel = 'Effective Supply' + + axs[3].contourf(share_of_funds, y, Z.T,100, cmap='jet', ) + axs[3].axis([share_of_funds[0], share_of_funds[-1], y[0], y[-1]]) + axs[3].set_ylabel(ylabel) + axs[3].set_xlabel('Share of Funds Requested') + axs[3].set_title('Trigger Function Map - Supply sweep') + \ No newline at end of file diff --git a/v2/model/model/initialization.py b/v2/model/model/initialization.py new file mode 100644 index 0000000..0dcd7a9 --- /dev/null +++ b/v2/model/model/initialization.py @@ -0,0 +1,92 @@ + +# import libraries +import networkx as nx +import matplotlib.pyplot as plt +import numpy as np +from .conviction_helper_functions import * + +# Parameters +# maximum share of funds a proposal can take +beta = .2 #later we should set this to be param so we can sweep it +# tuning param for the trigger function +rho = .001 +alpha = 1 - 0.9999599 +supply = 21706 # Honey supply balance as of 7-17-2020 +initial_sentiment = .6 + + +n= 24 #initial participants +m= 3 #initial proposals + + +sensitivity = .75 +tmin = 7 #unit days; minimum periods passed before a proposal can pass +min_supp = 50 #number of tokens that must be stake for a proposal to be a candidate +# sentiment_decay = .01 #termed mu in the state update function +base_completion_rate = 100 +base_failure_rate = 200 + +initial_funds = 48000 # in xDai + +def initialize_network(n,m, inital_funds, supply): + ''' + Definition: + Function to initialize network x object + + Parameters: + + Assumptions: + + Returns: + + Example: + ''' + # initilize network x graph + network = nx.DiGraph() + # create participant nodes with type and token holding + for i in range(n): + network.add_node(i) + network.nodes[i]['type']= "participant" + + h_rv = expon.rvs(loc=0.0, scale= supply/n) + network.nodes[i]['holdings'] = h_rv # SOL check + + s_rv = np.random.rand() + network.nodes[i]['sentiment'] = s_rv + + participants = get_nodes_by_type(network, 'participant') + initial_supply = np.sum([ network.nodes[i]['holdings'] for i in participants]) + + + # Generate initial proposals + for ind in range(m): + j = n+ind + network.add_node(j) + network.nodes[j]['type']="proposal" + network.nodes[j]['conviction'] = 0 + network.nodes[j]['status'] = 'candidate' + network.nodes[j]['age'] = 0 + + r_rv = gamma.rvs(3,loc=0.001, scale=100) + network.nodes[j]['funds_requested'] = r_rv + + network.nodes[j]['trigger']= trigger_threshold(r_rv, initial_funds, initial_supply,beta,rho,alpha) + + for i in range(n): + network.add_edge(i, j) + + a_rv = np.random.uniform(-1,1,1)[0] + network.edges[(i, j)]['affinity'] = a_rv + network.edges[(i, j)]['tokens'] = 0 + network.edges[(i, j)]['conviction'] = 0 + network.edges[(i, j)]['type'] = 'support' + + proposals = get_nodes_by_type(network, 'proposal') + total_requested = np.sum([ network.nodes[i]['funds_requested'] for i in proposals]) + + network = initial_conflict_network(network, rate = .25) + network = initial_social_network(network, scale = 1) + + return network, initial_funds +#initializers +network, initial_funds = initialize_network(n,m,initial_funds,supply) diff --git a/v2/model/model/participants.py b/v2/model/model/participants.py new file mode 100644 index 0000000..0f28672 --- /dev/null +++ b/v2/model/model/participants.py @@ -0,0 +1,191 @@ + +import numpy as np +from .initialization import * +from .conviction_helper_functions import * +import networkx as nx + +# hyperparameters +mu = 0.01 + +# Phase 2 +# Behaviors +def check_progress(params, step, sL, s): + ''' + Driving processes: completion of previously funded proposals + ''' + + network = s['network'] + proposals = get_nodes_by_type(network, 'proposal') + + completed = [] + failed = [] + for j in proposals: + if network.nodes[j]['status'] == 'active': + grant_size = network.nodes[j]['funds_requested'] + likelihood = 1.0/(base_completion_rate+np.log(grant_size)) + + failure_rate = 1.0/(base_failure_rate+np.log(grant_size)) + if np.random.rand() < likelihood: + completed.append(j) + elif np.random.rand() < failure_rate: + failed.append(j) + + return({'completed':completed, 'failed':failed}) + + + +# Mechanisms +def complete_proposal(params, step, sL, s, _input): + ''' + Book-keeping of failed and completed proposals. Update network object + ''' + + network = s['network'] + participants = get_nodes_by_type(network, 'participant') + proposals = get_nodes_by_type(network, 'proposal') + competitors = get_edges_by_type(network, 'conflict') + + completed = _input['completed'] + for j in completed: + network.nodes[j]['status']='completed' + + for c in proposals: + if (j,c) in competitors: + conflict = network.edges[(j,c)]['conflict'] + for i in participants: + network.edges[(i,c)]['affinity'] = network.edges[(i,c)]['affinity'] *(1-conflict) + + for i in participants: + force = network.edges[(i,j)]['affinity'] + sentiment = network.nodes[i]['sentiment'] + network.nodes[i]['sentiment'] = get_sentimental(sentiment, force, decay=0) + + + + failed = _input['failed'] + for j in failed: + network.nodes[j]['status']='failed' + for i in participants: + force = -network.edges[(i,j)]['affinity'] + sentiment = network.nodes[i]['sentiment'] + network.nodes[i]['sentiment'] = get_sentimental(sentiment, force, decay=0) + + key = 'network' + value = network + + return (key, value) + +def update_sentiment_on_completion(params, step, sL, s, _input): + network = s['network'] + proposals = get_nodes_by_type(network, 'proposal') + completed = _input['completed'] + failed = _input['failed'] + + grants_outstanding = np.sum([network.nodes[j]['funds_requested'] for j in proposals if network.nodes[j]['status']=='active']) + + grants_completed = np.sum([network.nodes[j]['funds_requested'] for j in completed]) + grants_failed = np.sum([network.nodes[j]['funds_requested'] for j in failed]) + + sentiment = s['sentiment'] + + if grants_outstanding>0: + force = (grants_completed-grants_failed)/grants_outstanding + else: + force=1 + if (force >=0) and (force <=1): + sentiment = get_sentimental(sentiment, force, mu) + else: + sentiment = get_sentimental(sentiment, 0, mu) + + + key = 'sentiment' + value = sentiment + + return (key, value) + + +# Phase 3 +# Behaviors +def participants_decisions(params, step, sL, s): + ''' + High sentiment, high affinity =>buy + Low sentiment, low affinities => burn + Assign tokens to top affinities + ''' + network = s['network'] + participants = get_nodes_by_type(network, 'participant') + proposals = get_nodes_by_type(network, 'proposal') + candidates = [j for j in proposals if network.nodes[j]['status']=='candidate'] + #sensitivity = params['sensitivity'] + + gain = .01 + delta_holdings={} + proposals_supported ={} + for i in participants: + + engagement_rate = .3*network.nodes[i]['sentiment'] + if np.random.rand() cutoff: + support.append(j) + + proposals_supported[i] = support + else: + delta_holdings[i] = 0 + proposals_supported[i] = [j for j in candidates if network.edges[(i,j)]['tokens']>0 ] + + return({'delta_holdings':delta_holdings, 'proposals_supported':proposals_supported}) + +# Mechanisms +def update_tokens(params, step, sL, s, _input): + ''' + Description: + Udate everyones holdings and their conviction for each proposal + ''' + + network = s['network'] + delta_holdings = _input['delta_holdings'] + proposals = get_nodes_by_type(network, 'proposal') + candidates = [j for j in proposals if network.nodes[j]['status']=='candidate'] + proposals_supported = _input['proposals_supported'] + participants = get_nodes_by_type(network, 'participant') + + for i in participants: + network.nodes[i]['holdings'] = network.nodes[i]['holdings']+delta_holdings[i] + supported = proposals_supported[i] + total_affinity = np.sum([ network.edges[(i, j)]['affinity'] for j in supported]) + for j in candidates: + if j in supported: + normalized_affinity = network.edges[(i, j)]['affinity']/total_affinity + network.edges[(i, j)]['tokens'] = normalized_affinity*network.nodes[i]['holdings'] + else: + network.edges[(i, j)]['tokens'] = 0 + + prior_conviction = network.edges[(i, j)]['conviction'] + current_tokens = network.edges[(i, j)]['tokens'] + network.edges[(i, j)]['conviction'] =current_tokens+alpha*prior_conviction + + for j in candidates: + network.nodes[j]['conviction'] = np.sum([ network.edges[(i, j)]['conviction'] for i in participants]) + total_tokens = np.sum([network.edges[(i, j)]['tokens'] for i in participants ]) + if total_tokens < min_supp: + network.nodes[j]['status'] = 'killed' + + key = 'network' + value = network + + return (key, value) + + + diff --git a/v2/model/model/proposals.py b/v2/model/model/proposals.py new file mode 100644 index 0000000..a6f9c4b --- /dev/null +++ b/v2/model/model/proposals.py @@ -0,0 +1,132 @@ +import numpy as np +from .initialization import * +from .conviction_helper_functions import * +import networkx as nx + +# Behaviors +def trigger_function(params, step, sL, s): + ''' + This policy checks to see if each proposal passes or not. + ''' + network = s['network'] + funds = s['funds'] + #supply = s['supply'] + proposals = get_nodes_by_type(network, 'proposal') + + accepted = [] + triggers = {} + funds_to_be_released = 0 + for j in proposals: + if network.nodes[j]['status'] == 'candidate': + requested = network.nodes[j]['funds_requested'] + age = network.nodes[j]['age'] + threshold = trigger_threshold(requested, funds, supply, beta, rho, alpha) + if age > tmin: + conviction = network.nodes[j]['conviction'] + if conviction >threshold: + accepted.append(j) + funds_to_be_released = funds_to_be_released + requested + else: + threshold = np.nan + + triggers[j] = threshold + + #catch over release and keep the highest conviction results + if funds_to_be_released > funds: + + ordered = conviction_order(network, accepted) + accepted = [] + release = 0 + ind = 0 + while release + network.nodes[ordered[ind]]['funds_requested'] < funds: + accepted.append(ordered[ind]) + release= network.nodes[ordered[ind]]['funds_requested'] + ind=ind+1 + + + return({'accepted':accepted, 'triggers':triggers}) + +# Mechanisms +def decrement_funds(params, step, sL, s, _input): + ''' + If a proposal passes, funds are decremented by the amount of the proposal + ''' + + funds = s['funds'] + network = s['network'] + accepted = _input['accepted'] + + #decrement funds + for j in accepted: + funds = funds - network.nodes[j]['funds_requested'] + + key = 'funds' + value = funds + + return (key, value) + +def update_sentiment_on_release(params, step, sL, s, _input): + + network = s['network'] + proposals = get_nodes_by_type(network, 'proposal') + accepted = _input['accepted'] + + proposals_outstanding = np.sum([network.nodes[j]['funds_requested'] for j in proposals if network.nodes[j]['status']=='candidate']) + + proposals_accepted = np.sum([network.nodes[j]['funds_requested'] for j in accepted]) + + sentiment = s['sentiment'] + force = proposals_accepted/proposals_outstanding + if (force >=0) and (force <=1): + sentiment = get_sentimental(sentiment, force, False) + else: + sentiment = get_sentimental(sentiment, 0, False) + + key = 'sentiment' + value = sentiment + + return (key, value) + +def update_proposals(params, step, sL, s, _input): + ''' + If proposal passes, its status is changed in the network object. + ''' + + network = s['network'] + accepted = _input['accepted'] + triggers = _input['triggers'] + participants = get_nodes_by_type(network, 'participant') + proposals = get_nodes_by_type(network, 'proposals') + #sensitivity = params['sensitivity'] + + for j in proposals: + network.nodes[j]['trigger'] = triggers[j] + + #bookkeeping conviction and participant sentiment + for j in accepted: + network.nodes[j]['status']='active' + network.nodes[j]['conviction']=np.nan + #change status to active + for i in participants: + + #operating on edge = (i,j) + #reset tokens assigned to other candidates + network.edges[(i,j)]['tokens']=0 + network.edges[(i,j)]['conviction'] = np.nan + + #update participants sentiments (positive or negative) + affinities = [network.edges[(i,p)]['affinity'] for p in proposals if not(p in accepted)] + if len(affinities)>1: + max_affinity = np.max(affinities) + force = network.edges[(i,j)]['affinity']-sensitivity*max_affinity + else: + force = 0 + + #based on what their affinities to the accepted proposals + network.nodes[i]['sentiment'] = get_sentimental(network.nodes[i]['sentiment'], force, False) + + + key = 'network' + value = network + + return (key, value) \ No newline at end of file diff --git a/v2/model/model/system.py b/v2/model/model/system.py new file mode 100644 index 0000000..9244544 --- /dev/null +++ b/v2/model/model/system.py @@ -0,0 +1,112 @@ + +import numpy as np +import pandas as pd +from .initialization import * +from .conviction_helper_functions import * +import networkx as nx +from scipy.stats import expon, gamma + + + +# Behaviors +def driving_process(params, step, sL, s): + ''' + Driving process for adding new participants (their funds) and new proposals. + ''' + arrival_rate = 10/(1+s['sentiment']) + rv1 = np.random.rand() + new_participant = bool(rv1<1/arrival_rate) + supporters = get_edges_by_type(s['network'], 'support') + + len_parts = len(get_nodes_by_type(s['network'], 'participant')) + #supply = s['supply'] + expected_holdings = .1*supply/len_parts + if new_participant: + h_rv = expon.rvs(loc=0.0, scale=expected_holdings) + new_participant_holdings = h_rv + else: + new_participant_holdings = 0 + + network = s['network'] + affinities = [network.edges[e]['affinity'] for e in supporters ] + median_affinity = np.median(affinities) + + proposals = get_nodes_by_type(network, 'proposal') + fund_requests = [network.nodes[j]['funds_requested'] for j in proposals if network.nodes[j]['status']=='candidate'] + + funds = s['funds'] + total_funds_requested = np.sum(fund_requests) + + proposal_rate = 1/median_affinity * (1+total_funds_requested/funds) + rv2 = np.random.rand() + new_proposal = bool(rv2<1/proposal_rate) + + sentiment = s['sentiment'] + funds = s['funds'] + scale_factor = funds*sentiment**2/10000 + + if scale_factor <1: + scale_factor = 1 + + #this shouldn't happen but expon is throwing domain errors + if sentiment>.4: + funds_arrival = expon.rvs(loc = 0, scale = scale_factor ) + else: + funds_arrival = 0 + + return({'new_participant':new_participant, + 'new_participant_holdings':new_participant_holdings, + 'new_proposal':new_proposal, + 'funds_arrival':funds_arrival}) + + +# Mechanisms +def update_network(params, step, sL, s, _input): + ''' + Add new participants and proposals to network object + ''' + + network = s['network'] + funds = s['funds'] + #supply = s['supply'] + + new_participant = _input['new_participant'] + new_proposal = _input['new_proposal'] + + if new_participant: + new_participant_holdings = _input['new_participant_holdings'] + network = gen_new_participant(network, new_participant_holdings) + + if new_proposal: + network= gen_new_proposal(network,funds,supply) + + #update age of the existing proposals + proposals = get_nodes_by_type(network, 'proposal') + + for j in proposals: + network.nodes[j]['age'] = network.nodes[j]['age']+1 + if network.nodes[j]['status'] == 'candidate': + requested = network.nodes[j]['funds_requested'] + network.nodes[j]['trigger'] = trigger_threshold(requested, funds, supply, beta, rho, alpha) + else: + network.nodes[j]['trigger'] = np.nan + + key = 'network' + value = network + + return (key, value) + +def increment_funds(params, step, sL, s, _input): + ''' + Increase funds by the amount of the new particpant's funds. + ''' + funds = s['funds'] + funds_arrival = _input['funds_arrival'] + + #increment funds + funds = funds + funds_arrival + + key = 'funds' + value = funds + + return (key, value) \ No newline at end of file diff --git a/v2/model/partial_state_update_block.py b/v2/model/partial_state_update_block.py new file mode 100644 index 0000000..bda683c --- /dev/null +++ b/v2/model/partial_state_update_block.py @@ -0,0 +1,47 @@ +from .model.system import * +from .model.participants import * +from .model.proposals import * + +# The Partial State Update Blocks +partial_state_update_blocks = [ + { + # system.py: + 'policies': { + 'random': driving_process + }, + 'variables': { + 'network': update_network, + 'funds':increment_funds, + } + }, + { + # participants.py + 'policies': { + 'completion': check_progress + }, + 'variables': { + 'sentiment': update_sentiment_on_completion, #note completing decays sentiment, completing bumps it + 'network': complete_proposal + } + }, + { + # proposals.py + 'policies': { + 'release': trigger_function + }, + 'variables': { + 'funds': decrement_funds, + 'sentiment': update_sentiment_on_release, #releasing funds can bump sentiment + 'network': update_proposals + } + }, + { + # participants.py + 'policies': { + 'participants_act': participants_decisions + }, + 'variables': { + 'network': update_tokens + } + } +] \ No newline at end of file diff --git a/v2/model/run.py b/v2/model/run.py new file mode 100644 index 0000000..ce85fec --- /dev/null +++ b/v2/model/run.py @@ -0,0 +1,64 @@ +import pandas as pd +from .model.conviction_helper_functions import * +from model import economyconfig +from cadCAD.engine import ExecutionMode, ExecutionContext +exec_mode = ExecutionMode() +from cadCAD.engine import Executor +from cadCAD import configs + +def run(input_config=configs): + ''' + Definition: + Run simulation + + Parameters: + input_config: Optional way to pass in system configuration + ''' + exec_mode = ExecutionMode() + local_mode_ctx = ExecutionContext(context=exec_mode.local_mode) + + simulation = Executor(exec_context=local_mode_ctx, configs=input_config) + raw_system_events, tensor_field, sessions = simulation.execute() + # Result System Events DataFrame + df = pd.DataFrame(raw_system_events) + return df + +def postprocessing(df): + ''' + Function for postprocessing the simulation results to extract key information from the network object. + ''' + # subset to last substep of each simulation + df= df[df.substep==df.substep.max()] + df=df[df.simulation==df.simulation.max()] + + # Extract information from dataframe + df['conviction'] = df.network.apply(lambda g: np.array([g.nodes[j]['conviction'] for j in get_nodes_by_type(g, 'proposal') if g.nodes[j]['status']=='candidate'])) + df['candidate_count'] = df.network.apply(lambda g: len([j for j in get_nodes_by_type(g, 'proposal') if g.nodes[j]['status']=='candidate'])) + df['candidate_funds'] = df.network.apply(lambda g: np.sum([g.nodes[j]['funds_requested'] for j in get_nodes_by_type(g, 'proposal') if g.nodes[j]['status']=='candidate'])) + df['killed_count'] = df.network.apply(lambda g: len([j for j in get_nodes_by_type(g, 'proposal') if g.nodes[j]['status']=='killed'])) + df['killed_funds'] = df.network.apply(lambda g: np.sum([g.nodes[j]['funds_requested'] for j in get_nodes_by_type(g, 'proposal') if g.nodes[j]['status']=='killed'])) + df['candidate_funds_requested'] = df.network.apply(lambda g: np.array([g.nodes[j]['funds_requested'] for j in get_nodes_by_type(g, 'proposal') if g.nodes[j]['status']=='candidate'])) + df['active_count'] = df.network.apply(lambda g: len([j for j in get_nodes_by_type(g, 'proposal') if g.nodes[j]['status']=='active'])) + df['active_funds'] = df.network.apply(lambda g: np.sum([g.nodes[j]['funds_requested'] for j in get_nodes_by_type(g, 'proposal') if g.nodes[j]['status']=='active'])) + df['failed_count'] = df.network.apply(lambda g: len([j for j in get_nodes_by_type(g, 'proposal') if g.nodes[j]['status']=='failed'])) + df['failed_funds'] = df.network.apply(lambda g: np.sum([g.nodes[j]['funds_requested'] for j in get_nodes_by_type(g, 'proposal') if g.nodes[j]['status']=='failed'])) + df['completed_count'] = df.network.apply(lambda g: len([j for j in get_nodes_by_type(g, 'proposal') if g.nodes[j]['status']=='completed'])) + df['completed_funds'] = df.network.apply(lambda g: np.sum([g.nodes[j]['funds_requested'] for j in get_nodes_by_type(g, 'proposal') if g.nodes[j]['status']=='completed'])) + + df['funds_requested'] = df.network.apply(lambda g: np.array([g.nodes[j]['funds_requested'] for j in get_nodes_by_type(g, 'proposal')])) + df['share_of_funds_requested'] = df.candidate_funds_requested/df.funds + + df['share_of_funds_requested_all'] = df.funds_requested/df.funds + + df['triggers'] = df.network.apply(lambda g: np.array([g.nodes[j]['trigger'] for j in get_nodes_by_type(g, 'proposal') if g.nodes[j]['status']=='candidate' ])) + df['conviction_share_of_trigger'] = df.conviction/df.triggers + df['age'] = df.network.apply(lambda g: np.array([g.nodes[j]['age'] for j in get_nodes_by_type(g, 'proposal') if g.nodes[j]['status']=='candidate' ])) + + df['age_all'] = df.network.apply(lambda g: np.array([g.nodes[j]['age'] for j in get_nodes_by_type(g, 'proposal') ])) + df['conviction_all'] = df.network.apply(lambda g: np.array([g.nodes[j]['conviction'] for j in get_nodes_by_type(g, 'proposal') ])) + df['triggers_all'] = df.network.apply(lambda g: np.array([g.nodes[j]['trigger'] for j in get_nodes_by_type(g, 'proposal') ])) + + df['conviction_share_of_trigger_all'] = df.conviction_all/df.triggers_all + + + return df \ No newline at end of file