Crude Network Modeling.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook, I'll try to model out some understanding of a network structure. The supporter modeling notebook suggests that a market might have a sigmoidal response to increased patron funds. In this notebook, we'll try to understand how a ecosystem of data markets might benefit from the presence of a funding DAO at the network level. Let's start by introducing some simulation parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's assume there are some number of markets created\n",
    "NUM_MARKETS = 10\n",
    "# Let's say that each market has a cap\n",
    "# Note we're not using WHOLE. This makes numerical stability much nicer....\n",
    "MARKET_CAP = 100000\n",
    "# The number of patrons supporting the ecosystem\n",
    "NUM_PATRONS = 1000\n",
    "# The size of an average support\n",
    "SUPPORT_SIZE = 500\n",
    "# This is the point at which a market growth starts to saturate and further support becomes less helpful\n",
    "MARKET_SATURATION = 10000 # in ETH\n",
    "\n",
    "## The patronage parameters\n",
    "# Let's assume that each patron has a small chance of supporting a given market\n",
    "PROB_ONE_MARKET_SUPPORT = .02\n",
    "# Let's model in some market risk by assuming that each market has a chance of failing\n",
    "PROB_ONE_MARKET_FAIL = .0\n",
    "\n",
    "## The index fund parameters\n",
    "# Probability a patron supports the index fund\n",
    "PROB_INDEX_FUND = .10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We're modeling an ecosystem with `NUM_MARKETS` different data markets, each of which is assumed to have a possible size of `MARKET_CAP`. It's important to note this is a critical assumption of the current simulation. It's pretty nontrivial to bootstrap a lively market right now, so this simulation notebook is looking pretty far ahead. With that note our of the way, let's see what we can learn. We're going to assume that a market's response curve to patron funds is given by\n",
    "\n",
    "$y = \\text{MARKET_CAP} \\cdot \\text{sigmoid}(x / \\text{MARKET_SATURATION}) - (\\text{MARKET_CAP}/2)$\n",
    "\n",
    "Let's use this simple equation to create a mathematical model of the size of a market ecosystem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from scipy.special import expit\n",
    "\n",
    "# Define the response\n",
    "# https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.special.expit.html\n",
    "# expit is numerically stable which makes the simulations much nicer.\n",
    "def get_market_size(funds):\n",
    "    return MARKET_CAP * expit(funds / MARKET_SATURATION) - (MARKET_CAP / 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's build some basic understanding of the dynamics of this function by plotting it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fd264271fd0>]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "funding_levels = [1000 * i for i in range(2 * MARKET_SATURATION // 1000)]\n",
    "market_sizes = [get_market_size(funding_level) for funding_level in funding_levels]\n",
    "plt.title(\"Market Size Growth with Increased Patron Support\")\n",
    "plt.xlabel(\"Market Support\")\n",
    "plt.ylabel(\"Market Size\")\n",
    "plt.plot(funding_levels, market_sizes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average market support: 9997.500000\n",
      "Average market size: 22847.356127\n",
      "Average Network Size across reps: 228473.561270\n",
      "Standard deviation: 12442.880628\n"
     ]
    }
   ],
   "source": [
    "NUM_REPS = 20\n",
    "def run_basic_simulation():\n",
    "    total_market_cap = 0\n",
    "    total_market_size = 0\n",
    "    market_supports = []\n",
    "    market_sizes = []\n",
    "\n",
    "    for i in range(NUM_MARKETS):\n",
    "        market_support = 0\n",
    "        for j in range(NUM_PATRONS):\n",
    "            u = np.random.uniform()\n",
    "            if u < PROB_ONE_MARKET_SUPPORT:\n",
    "                market_support += SUPPORT_SIZE\n",
    "        market_supports.append(market_support)\n",
    "        # Now check if the market fails\n",
    "        f = np.random.uniform()\n",
    "        if f < PROB_ONE_MARKET_FAIL:\n",
    "            market_size = 0\n",
    "        else:\n",
    "            market_size = get_market_size(market_support)\n",
    "        market_sizes.append(market_size)\n",
    "        total_market_size += market_size\n",
    "    avg_market_support = np.mean(np.array(market_supports))\n",
    "    avg_market_size = np.mean(np.array(market_sizes))\n",
    "    return avg_market_support, avg_market_size, total_market_size\n",
    "\n",
    "network_sizes = []\n",
    "avg_market_supports = []\n",
    "avg_market_sizes = []\n",
    "for rep in range(NUM_REPS):\n",
    "    avg_market_support, avg_market_size, total_market_size = run_basic_simulation()\n",
    "    network_sizes.append(total_market_size)\n",
    "    avg_market_supports.append(avg_market_support)\n",
    "    avg_market_sizes.append(avg_market_size)\n",
    "\n",
    "avg_market_size = np.mean(np.array(network_sizes))\n",
    "std_deviation = np.std(np.array(network_sizes))\n",
    "print(\"Average market support: %f\" % np.mean(np.array(avg_market_supports)))\n",
    "print(\"Average market size: %f\" % np.mean(np.array(avg_market_sizes)))\n",
    "print(\"Average Network Size across reps: %f\" % avg_market_size)\n",
    "print(\"Standard deviation: %f\" % std_deviation)\n",
    "basic_avg_network_size = avg_market_size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's assume a simple network structure. There exists a DAO which acts as an \"index fund\" of datasets. The simulation structure is the same as above, but we'll assume that there's a probability the patron chooses to support the index fund."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Index Fund Size: 46000\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Let's find the size of the index fund\n",
    "total_index_fund_size = 0\n",
    "for j in range(NUM_PATRONS):\n",
    "    u = np.random.uniform()\n",
    "    if u < PROB_INDEX_FUND:\n",
    "        total_index_fund_size += SUPPORT_SIZE\n",
    "print(\"Total Index Fund Size: %d\" % total_index_fund_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's say that this index fund's sole purpose is to support the community, so it takes its total funds and splits it across all markets. Let's add this on top of the existing support code as above to see what the benefit is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average market support: 14762.500000\n",
      "Average market size: 31184.922756\n",
      "Average Network Size across reps: 311849.227564\n",
      "Standard deviation: 11845.915982\n"
     ]
    }
   ],
   "source": [
    "NUM_REPS = 20\n",
    "\n",
    "def run_index_fund_simulation():\n",
    "    total_market_cap = 0\n",
    "    total_market_size = 0\n",
    "    index_fund_support = total_index_fund_size / NUM_MARKETS\n",
    "    market_supports = []\n",
    "    market_sizes = []\n",
    "\n",
    "    for i in range(NUM_MARKETS):\n",
    "        market_support = 0\n",
    "        for j in range(NUM_PATRONS):\n",
    "            u = np.random.uniform()\n",
    "            if u < PROB_ONE_MARKET_SUPPORT:\n",
    "                market_support += SUPPORT_SIZE\n",
    "        market_support += index_fund_support\n",
    "        market_supports.append(market_support)\n",
    "        # Now check if the market fails\n",
    "        f = np.random.uniform()\n",
    "        if f < PROB_ONE_MARKET_FAIL:\n",
    "            market_size = 0\n",
    "        else:\n",
    "            market_size = get_market_size(market_support)\n",
    "        market_sizes.append(market_size)\n",
    "        total_market_size += market_size\n",
    "    avg_market_support = np.mean(np.array(market_supports))\n",
    "    avg_market_size = np.mean(np.array(market_sizes))\n",
    "    return avg_market_support, avg_market_size, total_market_size\n",
    "\n",
    "network_sizes = []\n",
    "avg_market_supports = []\n",
    "avg_market_sizes = []\n",
    "for rep in range(NUM_REPS):\n",
    "    avg_market_support, avg_market_size, total_market_size = run_index_fund_simulation()\n",
    "    avg_market_supports.append(avg_market_support)\n",
    "    avg_market_sizes.append(avg_market_size)\n",
    "    network_sizes.append(total_market_size)\n",
    "avg_market_size = np.mean(np.array(network_sizes))\n",
    "std_deviation = np.std(np.array(network_sizes))\n",
    "print(\"Average market support: %f\" % np.mean(np.array(avg_market_supports)))\n",
    "print(\"Average market size: %f\" % np.mean(np.array(avg_market_sizes)))\n",
    "print(\"Average Network Size across reps: %f\" % avg_market_size)\n",
    "print(\"Standard deviation: %f\" % std_deviation)\n",
    "index_avg_network_size = avg_market_size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This crude analysis suggests that the presence of a network-wide index fund allows for a some boost in the total network outcome."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Basic Network Size: 228473.56\n",
      "Total size index fund: 46000.00\n",
      "Index Network Size: 311849.23\n",
      "Index Effect: 83375.67\n",
      "Index Return Percent: 81.251448%\n"
     ]
    }
   ],
   "source": [
    "print(\"Basic Network Size: %.2f\" % basic_avg_network_size)\n",
    "print(\"Total size index fund: %.2f\" % total_index_fund_size)\n",
    "print(\"Index Network Size: %.2f\" % index_avg_network_size)\n",
    "print(\"Index Effect: %.2f\" % (index_avg_network_size - basic_avg_network_size))\n",
    "\n",
    "index_return = ((index_avg_network_size - basic_avg_network_size) / total_index_fund_size - 1) * 100\n",
    "print(\"Index Return Percent: %f%%\" % index_return)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that this model only provides returns because the markets are in the middle of their growth phase so the presence of the index fund makes a noticeable difference in their outcomes. In general, the index fund would need some intelligence to understand "
   ]
  }
 ],
 "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.5.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}