Plots_for_the_paper.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib as mpl\n",
    "import numpy as np\n",
    "import json\n",
    "\n",
    "font = {'size' : 8}\n",
    "mpl.rc('font', **font)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_filename(num_vars, canalyzing_depth):\n",
    "    return \"./data/num_vars=\" + str(num_vars) + \"_depth=\" + str(canalyzing_depth) + \".json\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The number and average size of attractors vs. depth (Fig 1)\n",
    "\n",
    "We plot how the empitical mean of the number of attractors and the average attractor size depends on the canalizing depth in the case $n = 15$.\n",
    "\n",
    "There are 50000 samples for each depth."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_statistics(function, num_vars):\n",
    "    mean = []\n",
    "    stddev = []\n",
    "    for can_depth in range(num_vars + 1):\n",
    "        with open(get_filename(num_vars, can_depth), \"r\") as file:\n",
    "            data = json.load(file)\n",
    "            #print(\"Num samples %d\" % len(data))\n",
    "            values = np.fromiter(map(function, data), float)\n",
    "        mean.append(np.mean(values))\n",
    "        stddev.append(np.std(values))\n",
    "    return {\"means\" : mean, \"stddev\": stddev}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def num_attractors(dds):\n",
    "    return len(dds) * 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def avg_attractor_size(dds):\n",
    "    return sum([att[0] for att in dds]) * 1. / len(dds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "funcs = {\"# of attractors\" : num_attractors, \"Avg attractor size\" : avg_attractor_size}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_vars = 15\n",
    "stats = dict()\n",
    "for name, f in funcs.items():\n",
    "    stats[name] = get_statistics(f, num_vars)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "yticks = {\"# of attractors\" : list(range(9)), \"Avg attractor size\" : list(range(0, 70, 10))}\n",
    "filename = {\"# of attractors\" : \"N_mean.pdf\", \"Avg attractor size\" : \"AS_mean.pdf\"}\n",
    "for name, st in stats.items():\n",
    "    plt.figure(figsize = (3, 2), dpi = 150)\n",
    "    plt.xlabel(\"Canalizing depth\")\n",
    "    plt.ylabel(name)\n",
    "    plt.yticks(yticks[name])\n",
    "    plt.xticks(range(0, num_vars + 1, 2))\n",
    "    plt.minorticks_on()\n",
    "    height = max(st[\"means\"]) + max(st[\"stddev\"])\n",
    "    (_, caps, _) = plt.errorbar([_ for _ in range(num_vars + 1)], st[\"means\"], st[\"stddev\"], \n",
    "             ecolor = 'black', color = 'g', errorevery = 2, marker = 'o', \n",
    "             markersize = 3, elinewidth = 0.5, capsize = 3)\n",
    "    for cap in caps:\n",
    "        cap.set_color('black')\n",
    "        cap.set_markeredgewidth(0.5)\n",
    "    plt.savefig(filename[name], bbox_inches = \"tight\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Distribution of the number and average size of attractors (Fig 2)\n",
    "We plot these distributions of the numer of variables $n = 12$ and canalizing depths 0, 1, 3, and 12."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_distribution(function, num_vars, can_depth):\n",
    "    with open(get_filename(num_vars, can_depth), \"r\") as file:\n",
    "        data = json.load(file)\n",
    "        values = np.fromiter(map(function, data), float)\n",
    "        dist = np.histogram(values, range(int(max(values))), density = True)\n",
    "    return (dist[1][:-1], dist[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_vars = 12\n",
    "depths = [0, 1, 3, 12]\n",
    "dists_all = dict()\n",
    "max_x = dict()\n",
    "for name, f in funcs.items():\n",
    "    dists_all[name] = dict()\n",
    "    for d in depths:\n",
    "        dists_all[name][d] = get_distribution(f, num_vars, d)\n",
    "    max_x[name] = min([len(dist[0]) for dist in dists_all[name].values()]) + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "yticks_step = {\"# of attractors\" : 2, \"Avg attractor size\" : 5}\n",
    "filename = {\"# of attractors\" : \"N_freq.pdf\", \"Avg attractor size\" : \"AS_freq.pdf\"}\n",
    "for name, dists in dists_all.items():\n",
    "    plt.figure(figsize = (3, 2), dpi = 150)\n",
    "    plt.xlabel(name)\n",
    "    plt.ylabel(\"Frequency\")\n",
    "    plt.xticks(range(0, max_x[name], yticks_step[name]))\n",
    "    plt.yticks([0.05 * i for i in range(0, 6)])\n",
    "    plt.minorticks_on()\n",
    "    for d, dist in dists.items():\n",
    "        plt.plot(dist[0][:max_x[name]], dist[1][:max_x[name]])\n",
    "\n",
    "    plt.legend([\"k = %d\" % d for d in depths])\n",
    "    plt.savefig(filename[name], bbox_inches = \"tight\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Relative decreases (Fig 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_relative_decrease(function, num_vars, depth):\n",
    "    values = []\n",
    "    for d in (0, depth):\n",
    "        with open(get_filename(num_vars, d), \"r\") as file:\n",
    "            data = json.load(file)\n",
    "            values.append(np.mean(np.fromiter(map(function, data), float)))\n",
    "    return values[1] / values[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nums_vars = list(range(4, 21))\n",
    "decreases = dict()\n",
    "depths = [1, 2, 3]\n",
    "for name, f in funcs.items():\n",
    "    decreases[name] = dict()\n",
    "    for d in depths:\n",
    "        decreases[name][d] = [compute_relative_decrease(f, n, d) for n in nums_vars]\n",
    "    decreases[name][\"n\"] = [compute_relative_decrease(f, n, n) for n in nums_vars]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "legend = {\n",
    "    \"# of attractors\" : [r'$N_1(n)$', r'$N_2(n)$', r'$N_3(n)$', r'$N_n(n)$'], \n",
    "    \"Avg attractor size\" : [r'$\\mathrm{AS}_1(n)$', r'$\\mathrm{AS}_2(n)$', r'$\\mathrm{AS}_3(n)$', r'$\\mathrm{AS}_n(n)$']\n",
    "}\n",
    "filename = {\"# of attractors\" : \"N_ratio.pdf\", \"Avg attractor size\" : \"AS_ratio.pdf\"}\n",
    "for name, data in decreases.items():\n",
    "    plt.figure(figsize = (3, 2.2), dpi = 150)\n",
    "    plt.xlabel(\"# of variables\")\n",
    "    plt.ylabel(\"Relative decrease\")\n",
    "    plt.ylim(0, 0.9)\n",
    "    plt.yticks([0.2 * i for i in range(5)])\n",
    "    plt.xticks(range(4, 22, 2))\n",
    "    plt.minorticks_on()\n",
    "    plt.plot(nums_vars, data[1])\n",
    "    plt.plot(nums_vars, data[2])\n",
    "    plt.plot(nums_vars, data[3])\n",
    "    plt.plot(nums_vars, data[\"n\"])\n",
    "    plt.legend(legend[name])\n",
    "    plt.savefig(filename[name], bbox_inches = \"tight\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Support for Theorem 7.1 (Fig 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def expectation_attractors_fixed_length(length, num_vars_min, num_vars_max):\n",
    "    result = []\n",
    "    for n in range(num_vars_min, num_vars_max):\n",
    "        with open(get_filename(n, 1), \"r\") as file:\n",
    "            data = json.load(file)\n",
    "            occurences = sum([sum([1 for att in dds if att[0] == length]) for dds in data])\n",
    "            result.append(occurences * 1. / len(data))\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nums_vars = list(range(4, 21))\n",
    "lengths = [1, 2, 3, 4]\n",
    "data = dict()\n",
    "for l in lengths:\n",
    "    data[l] = expectation_attractors_fixed_length(l, nums_vars[0], nums_vars[-1] + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "limits = {1 : 1, 2: 2. / 3, 3: 64. / 189, 4: 0.2856}\n",
    "for l in lengths:\n",
    "    lim = [limits[l] for _ in nums_vars]\n",
    "    plt.figure(figsize = (3, 2.2), dpi = 150)\n",
    "    plt.xlabel(\"# of variables\")\n",
    "    plt.ylabel(\"# of attractors of length %d\" % l)\n",
    "    plt.ylim(0, 1.1)\n",
    "    plt.yticks([0.2 * i for i in range(6)])\n",
    "    plt.xticks(range(4, 22, 2))\n",
    "    plt.minorticks_on()\n",
    "    plt.plot(nums_vars, data[l])\n",
    "    plt.plot(nums_vars, lim)\n",
    "    plt.savefig(\"lim\" + str(l) + \".pdf\", bbox_inches = \"tight\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}