agents_base.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2017-09-04T16:14:31.479433Z",
     "start_time": "2017-09-04T16:14:16.879992Z"
    }
   },
   "outputs": [],
   "source": [
    "# %load agents_base.py\n",
    "# =-----------------------------------------------------------------------------=\n",
    "# Agents Base: Implementation for the Entropic Learning Dynamics\n",
    "#              for Agents Societies\n",
    "# Version: 0.1.0\n",
    "# Author: Felippe Alves\n",
    "# E-Mail: flipgm@gmail.com\n",
    "# =-----------------------------------------------------------------------------=\n",
    "# This module contains the basic dynamics generator, the class for Entropic\n",
    "# Agents Societies (and the particular case of Teacher-Student learning\n",
    "# scenario), and some utility funtions used in the analysis of such\n",
    "# systems.\n",
    "#\n",
    "# I separated it in some sections:\n",
    "#  1. Simulation Interface\n",
    "#    1.1 Utility functions\n",
    "#    1.2 Dynamics Interface\n",
    "#  2. Agents Society Model\n",
    "#    2.1 Theory\n",
    "#    2.2 Model\n",
    "#  3. Teacher-Student Scenario\n",
    "#  4. Restricted Universe of Discorse Scenario\n",
    "#  5. Analysis Interface\n",
    "#\n",
    "# Everything is pretty straight forward, and should be no problem to understand\n",
    "# what the code does from reading it.\n",
    "\n",
    "import functools\n",
    "from itertools import count, islice\n",
    "from copy import deepcopy\n",
    "from collections import defaultdict\n",
    "from numpy import (cos, sin, sqrt, r_, ones, tile, vstack, array, ndindex, ndim,\n",
    "                   log, outer, sign, eye, infty as oo, einsum, zeros, stack,\n",
    "                   zeros_like, fill_diagonal, clip, pi, split, arange, empty, NaN,\n",
    "                   linspace)\n",
    "from numpy.random import choice, randn, rand\n",
    "from numpy.linalg import norm, qr\n",
    "from scipy.stats.distributions import norm as normal\n",
    "\n",
    "__all__ = ['triangle_indices', 'rand_sphere', 'random_at_angle',\n",
    "           'dynamics', 'n_steps', 'record_trajectory',\n",
    "           'random_from_cosine', 'HEODAgentSociety',\n",
    "           'TeacherStutdentScneario', 'RUDHEODAgentSociety',\n",
    "           'row_norm']\n",
    "\n",
    "# # Simulation Interface\n",
    "\n",
    "# ## Utility functions\n",
    "Phi = normal.cdf\n",
    "G = normal.pdf\n",
    "row_norm = functools.partial(norm, keepdims=True, axis=1)\n",
    "\n",
    "\n",
    "def triangle_indices(N):\n",
    "    \"\"\"Compute all triples of integer indices and, as consequence,\n",
    "    all the closed oriented triangles in a complete graph with N\n",
    "    vertices.\n",
    "    Input:\n",
    "    -----\n",
    "      N: int - the number of vertices in a complete graph\n",
    "\n",
    "    Output:\n",
    "    -------\n",
    "      N(N-1)(N-2) x 3 array where each line is a triple of\n",
    "      indices in a triangle\n",
    "    \"\"\"\n",
    "    tri_idx = array([(a, b, c) for\n",
    "                     (a, b, c) in ndindex((N, N, N))\n",
    "                     if (a!=b and a!=c and b!=c)])\n",
    "    return tri_idx\n",
    "\n",
    "\n",
    "def rand_sphere(K, size=1):\n",
    "    \"\"\"Computes K-dimensional vectors distributed uniformly\n",
    "    in the unit sphere.\n",
    "    Input:\n",
    "    ------\n",
    "      K: int - the dimension of the vector space\n",
    "      size (default 1): int - the number of vectors to sample\n",
    "    Output:\n",
    "    -------\n",
    "      array with shape (K,) if size==1 or (size, K) if size>1\n",
    "    \"\"\"\n",
    "    v = randn(size, K)\n",
    "    v /= row_norm(v)\n",
    "    if size == 1:\n",
    "        v = v.reshape(K)\n",
    "    return v\n",
    "\n",
    "\n",
    "def random_at_angle(B, theta):\n",
    "    \"\"\"Computes a random vector with angle theta from a vector B.\n",
    "    Input:\n",
    "    ------\n",
    "      B: 1d array - the reference vector\n",
    "      theta: float - the angle from the reference vector B\n",
    "    \"\"\"\n",
    "    K = B.shape[0]\n",
    "    B0, v = (qr(vstack([B, randn(K)]).T)[0]*r_[-1, 1]).T\n",
    "    w = cos(theta)*B0 + sin(theta)*v\n",
    "    w /= norm(w)\n",
    "    w *= sign(cos(theta)*w@B0)\n",
    "    return w\n",
    "\n",
    "\n",
    "def random_from_cosine(B, cosine):\n",
    "    \"\"\"Computes a random vector with a given cosine with the vector B.\n",
    "    Input:\n",
    "    ------\n",
    "      B: 1d array - the reference vector\n",
    "      cosine: float - the cosine with the reference vector B\n",
    "    \"\"\"\n",
    "    K = B.shape[0]\n",
    "    B0, v = (qr(vstack([B, randn(K)]).T)[0]).T\n",
    "    B0 *= sign(B0@B)\n",
    "    w = cosine*B0 + sin(arccos(cosine))*v\n",
    "    assert abs(norm(w)-1) < 1e-5\n",
    "    return w\n",
    "\n",
    "\n",
    "## Dynamics interface\n",
    "def dynamics(system, *, in_place=True, **params):\n",
    "    \"\"\"Generator to loop over systems (obejcts) with\n",
    "    a update and a get_state methods.\n",
    "    Input:\n",
    "    ------\n",
    "      system: any object with the following interface:\n",
    "        system.update(**params) - a method for updating the system state\n",
    "        system.get_state(**params) - a method to retrieve the system state\n",
    "      in_place (default False): bool - if True, the updates are done to the\n",
    "      system passed in the call. If false, a deepcopy is made before looping\n",
    "      **params: any other parameter to be passed to the system methods\n",
    "    Output:\n",
    "    -------\n",
    "      an iterator over the system dynamics\n",
    "    \"\"\"\n",
    "    if not in_place:\n",
    "        system = deepcopy(system)\n",
    "    for _ in count():\n",
    "        yield system.get_state(**params)\n",
    "        system.update(**params)\n",
    "\n",
    "\n",
    "def n_steps(infinite_iterator, n):\n",
    "    \"\"\"An alias to enumerate(itertools.islice(ifinite_iteretor, n))\"\"\"\n",
    "    return enumerate(islice(infinite_iterator, n))\n",
    "\n",
    "\n",
    "def record_trajectory(system, number_of_steps, *,\n",
    "                      record_step=lambda n: True, **params):\n",
    "    \"\"\"A simple materialization of the dynamics iterator for a finite\n",
    "    number of steps, possibly filtered.\n",
    "    Input:\n",
    "    ------\n",
    "      system: object following the dynamics interface\n",
    "      (see sas.dyamics docstring)\n",
    "      number_of_steps: int - the number of steps to iterate the dynamics\n",
    "      record_step: callable accepting an integer argument - funtion to\n",
    "      decide when to record a given interger step\n",
    "      **params: all other parameters to pass to system's methods\n",
    "    Output:\n",
    "    -------\n",
    "      array of type(system.get_state()) with shape (number_of_steps,)\n",
    "    \"\"\"\n",
    "    trajectory = [s for (n, s) in n_steps(dynamics(system, **params),\n",
    "                                          number_of_steps)\n",
    "                  if record_step(n)]\n",
    "    return array(trajectory)\n",
    "\n",
    "# # Agents Society Model\n",
    "\n",
    "# ## Theory\n",
    "\n",
    "def Z(phi_w, phi_mu):\n",
    "    \"\"\"Evidence for the Bayesian Opinion-Trust learning model\n",
    "    Input:\n",
    "    ------\n",
    "      phi_mu, phi_w: floats in [0,1] range\"\"\"\n",
    "    return phi_mu + phi_w - 2*phi_mu*phi_w\n",
    "\n",
    "\n",
    "def derivatives_lnZ(arg, const, z):\n",
    "    \"\"\"Compute the value of the first and second derivatives of ln(z) for a given `arg`, `const` and value of `z`\n",
    "    Input:\n",
    "    ------\n",
    "      arg: float - the argument in the derivative\n",
    "      const: float - the constant argument in the derivative\n",
    "      z: float - the value of Z(arg, const)\n",
    "    \"\"\"\n",
    "    dlnZ_darg =  (1-2*const)*G(arg)/z\n",
    "    d2lnZ_darg = -dlnZ_darg*(dlnZ_darg + arg)\n",
    "    return dlnZ_darg, d2lnZ_darg\n",
    "\n",
    "\n",
    "def compute_deltas_w_and_C(w, C, x, sigma, phi_mu_l, z):\n",
    "    gamma = sqrt(x@C@x)\n",
    "    hs_g = w @ x * sigma / gamma \n",
    "    dlnZ_dhs_g, d2lnZ_dhs_g = derivatives_lnZ(hs_g, phi, z)\n",
    "    dw = dlnZ_dhs_g*(C@x)*sigma/gamma/norm_x\n",
    "    dC = d2lnZ_dhs_g*C@outer(x, x)@C/(gamma*gamma)\n",
    "    return [dw, dC]\n",
    "\n",
    "\n",
    "def compute_deltas_mu_and_s2(mu, s2, phi_hs_g, z):\n",
    "    lmbda = sqrt(1+s2)\n",
    "    mu_l = mu/lmbda\n",
    "    dlnZ_dmu_l, d2lnZ_dmu_l = derivatives_lnZ(mu_l, phi_w, z)\n",
    "    dmu = dlnZ_dmu_l*s2/lmbda\n",
    "    ds2 = d2lnZ_dmu_l*s2*s2/(1+s2)\n",
    "    return [dmu, ds2]\n",
    "\n",
    "\n",
    "def compute_deltas(w, C, mu, s2, x, sigma):\n",
    "    \"\"\"Compute the update values for w, C, mu and s2 given the\n",
    "    example (x,sigma). The values correspond to the Bayesian\n",
    "    Opinion-Trust model optimal updates.\n",
    "    Input:\n",
    "    ------\n",
    "      w: array with shape (K,) - agent's opinion vector\n",
    "      C: array with shape (K, K) [positive definite] - agent's opinion\n",
    "      uncertainty\n",
    "      mu: float - agent's distrust value\n",
    "      s2: float [greater than 0] - agent's distrust uncertainty\n",
    "    Output:\n",
    "    -------\n",
    "      list with the update values for w, C, mu and s2\n",
    "    \"\"\"\n",
    "    K = w.shape[0]\n",
    "    h = x@w\n",
    "    gamma = sqrt(x@C@x)\n",
    "    lmbda = sqrt(1+s2)\n",
    "    hs_g = h*sigma/gamma\n",
    "    mu_l = mu/lmbda\n",
    "    phi_w = Phi(hs_g)\n",
    "    phi_mu = Phi(mu_l)\n",
    "    z = Z(phi_w, phi_mu)\n",
    "    dlnZ_dmu_l, d2lnZ_dmu_l = derivatives_lnZ(mu_l, phi_w, z)\n",
    "    dlnZ_dhs_g, d2lnZ_dhs_g = derivatives_lnZ(hs_g, phi_mu, z)\n",
    "    delta_mu = dlnZ_dmu_l*s2/lmbda\n",
    "    delta_s2 = d2lnZ_dmu_l*s2*s2/(1+s2)\n",
    "    delta_w = dlnZ_dhs_g*sigma*C@x/gamma\n",
    "    delta_C = d2lnZ_dhs_g*C@outer(x, x)@C/(gamma*gamma)\n",
    "    return [delta_w, delta_C, delta_mu, delta_s2]\n",
    "\n",
    "\n",
    "def learning_cost(w, C, mu, s2, x, sigma):\n",
    "    \"\"\"Compute the learning cost for w, C, mu and s2 given the\n",
    "    example (x,sigma). The values correspond to the Bayesian\n",
    "    Opinion-Trust model learning cost.\n",
    "    Input:\n",
    "    ------\n",
    "      w: array with shape (K,) - agent's opinion vector\n",
    "      C: array with shape (K, K) [positive definite] - agent's opinion\n",
    "      uncertainty\n",
    "      mu: float - agent's distrust value\n",
    "      s2: float [greater than 0] - agent's distrust uncertainty\n",
    "    Output:\n",
    "    -------\n",
    "      float value of learning cost\n",
    "    \"\"\"\n",
    "    h = x@w\n",
    "    gamma = sqrt(x@C@x)/norm(x)\n",
    "    lmbda = sqrt(1+s2)\n",
    "    phi_w = Phi(h*sigma/gamma)\n",
    "    phi_mu = Phi(mu/lmbda)\n",
    "    return -log(Z(phi_mu, phi_w))\n",
    "\n",
    "\n",
    "# ## Model\n",
    "class HEODAgentSociety(object):  \n",
    "    def __init__(self, w0, C0, mu0, s20, *args, **kwargs):\n",
    "        \"\"\"Society of \"Homo Entropicus\" Opinion-Distrust agents.\n",
    "        Input:\n",
    "        ------\n",
    "          w0: array with shape (N, K) - opinion vector with dimension K for\n",
    "          N agents - representing the opinion weight vector;\n",
    "          C0: array with shape (N, K, K) - opinion uncertainty for each \n",
    "          agent - representing the opinion uncertainty; \n",
    "          mu0: array with shape (N, N) - distrust array for each agent\n",
    "          - representing the distrust proxy;\n",
    "          s20: array with shape (N, N) - distrust uncertainty for each\n",
    "          agent - reprsenting the distrust uncertainty.\n",
    "        \"\"\"\n",
    "        self.w = w0.copy()\n",
    "        self.N, self.K = w0.shape\n",
    "        assert C0.shape == (self.N, self.K, self.K)\n",
    "        self.C = C0.copy()\n",
    "        assert mu0.shape == s20.shape == (self.N, self.N)\n",
    "        self.mu = mu0.copy()\n",
    "        self.s2 = s20.copy()\n",
    "        self._initial_state = [w0.copy(), C0.copy(), mu0.copy(), s20.copy()]\n",
    "        self._state_struct = [('w', 'f8', self.K),\n",
    "                              ('C', 'f8', (self.K, self.K)),\n",
    "                              ('mu', 'f8', self.N),\n",
    "                              ('s2', 'f8', self.N)]\n",
    "        self.interaction_counter = 0\n",
    "        \n",
    "    @classmethod\n",
    "    def random(cls, N, K, C0, s20, *args, **kwargs):\n",
    "        \"\"\"Provides a simple and random set of initial values for BOTAgentSociety.\n",
    "        Input:\n",
    "        ------\n",
    "        N: int - the number of agents\n",
    "        K: int - the agents internal dimension\n",
    "        \n",
    "        Output:\n",
    "        -------\n",
    "        list with initial values for w, C, mu, and s2\"\"\"\n",
    "        w0 = randn(N, K)\n",
    "        w0 /= row_norm(w0)\n",
    "        C0 = tile(C0*eye(K)/K, (N, 1, 1))\n",
    "        mu0 = randn(N, N)\n",
    "        fill_diagonal(mu0, -100)\n",
    "        s20 = s20*ones((N, N))\n",
    "        return cls(w0, C0, mu0, s20, *args, **kwargs)\n",
    "\n",
    "    def agent_answer(self, i, x, *, real_epsilon=0.0, **params):\n",
    "        sigma = sign(self.w[i]@x)*choice([-1, 1], p=[real_epsilon,\n",
    "                                                     1-real_epsilon])\n",
    "        return sigma\n",
    "\n",
    "    def learning_amplitude(self, i, j, x, *args, constants=(), scales=(1.,1.,1.,1.), **params):\n",
    "        wi, Ci, mui, s2i = self[i]\n",
    "        sigma_j = self.agent_answer(j, x, **params)\n",
    "        Dw, DC, Dmuij, Ds2ij = compute_deltas(wi, Ci, mui[j], s2i[j], x, sigma_j)\n",
    "        sw, sC, smuij, ss2ij = scales\n",
    "        if 'C' in constants:\n",
    "            DC[:] = 0.0\n",
    "        if 's2' in constants:\n",
    "            Ds2ij = 0.0\n",
    "        return [Dw/sw, DC/sC, (j, Dmuij/smuij, Ds2ij/ss2ij)]\n",
    "\n",
    "    def move_agent(self, i, deltas, *args, constants=(), **params):\n",
    "        self[i] = deltas\n",
    "        if 'norm' in constants:\n",
    "            self.normalize_agent_opinion(i, *args, **params)\n",
    "        if 'bounds' in constants:\n",
    "            self.normalize_agent_distrust(i, *args, **params)\n",
    "\n",
    "    def interaction(self, i, j, x, *args, symmetric=False, **params):\n",
    "        Deltas_i = self.learning_amplitude(i, j, x, *args, **params)\n",
    "        if symmetric:\n",
    "            Deltas_j = self.learning_amplitude(j, i, x, *args, **params)\n",
    "            self.move_agent(j, Deltas_j, *args, **params)\n",
    "        self.move_agent(i, Deltas_i, *args, **params)\n",
    "        self.interaction_counter += 1\n",
    "\n",
    "    def get_state(self, *args, **kwargs):\n",
    "        state = zeros(self.N, self._state_struct)\n",
    "        for n in state.dtype.names:\n",
    "            state[n] = getattr(self, n)[:]\n",
    "        return state\n",
    "\n",
    "    def normalize_agent_opinion(self, i, *, opinion_norm=1., **params):\n",
    "        self.w[i] *= opinion_norm/norm(self.w[i])\n",
    "\n",
    "    def normalize_agent_distrust(self, i, *, distrust_bound=1., **params):\n",
    "        clip(self.mu[i], -distrust_bound, distrust_bound, self.mu[i])\n",
    "\n",
    "    def __getitem__(self, i):\n",
    "        \"\"\"Just a convinience to access agents properties\"\"\"\n",
    "        values = self.w[i], self.C[i], self.mu[i], self.s2[i]\n",
    "        return values\n",
    "\n",
    "    def update(self, *args, **params):\n",
    "        x = rand_sphere(self.K)\n",
    "        i, j = choice(self, size=2, replace=False)\n",
    "        self.interaction(0, 1, x, *args, **params)\n",
    "\n",
    "    def __setitem__(self, i, deltas):\n",
    "        \"\"\"Conviniece to set agents properties values\"\"\"\n",
    "        Dw, DC, (j, Dmu, Ds2) = deltas\n",
    "        self.w[i] += Dw[:]\n",
    "        self.C[i] += DC[:]\n",
    "        self.mu[i, j] += Dmu\n",
    "        self.s2[i, j] += Ds2\n",
    "\n",
    "    def reset(self):\n",
    "        \"\"\"Convinience to restore the initial state\"\"\"\n",
    "        w0, C0, mu0, s20 = self._initial_state\n",
    "        self.w = w0.copy()\n",
    "        self.C = C0.copy()\n",
    "        self.mu = mu0.copy()\n",
    "        self.s2 = s20.copy()\n",
    "        self.interaction_counter = 0\n",
    "\n",
    "## Teacher-Student Scenario\n",
    "class TeacherStutdentScneario(HEODAgentSociety):\n",
    "    def __init__(self, teacher, theta_0, C0, mu0, s20, *args, opinion_norm=1., **kwargs):\n",
    "        \"\"\"Teacher/Student learning scenario\n",
    "        Input:\n",
    "        ------\n",
    "          teacher: array - the teacher vector\n",
    "          theta_0: flaot - initial angle between teacher and student\n",
    "          C0 - 2d array - initial student opinion uncertainty\n",
    "          mu0, s20: flaot, float > 0 - intial distrust and respective\n",
    "        uncertainty for the student.\n",
    "        \"\"\"\n",
    "        assert ndim(teacher) == 1\n",
    "        student = random_at_angle(teacher, theta_0)\n",
    "        w0 = vstack([student, teacher])\n",
    "        K = teacher.shape[0]\n",
    "        w0 *= opinion_norm/row_norm(w0)\n",
    "        super().__init__(w0, C0, mu0, s20, *args, **kwargs)\n",
    "\n",
    "    def update(self, *args, **params):\n",
    "        x = rand_sphere(self.K)\n",
    "        self.interaction(0, 1, x, *args, **params)\n",
    "\n",
    "\n",
    "## Restricted Universe of Discorse Scenario\n",
    "class RUDHEODAgentSociety(HEODAgentSociety):\n",
    "    \"\"\"Restricted Universe of Discourse for the \"Homo Entropicus\" Opinion-Distrust\n",
    "    Agent Society.\"\"\"\n",
    "    def pick_issue(self, *args, issue_list=None, **params):\n",
    "        if issue_list is not None:\n",
    "            k = choice(len(issue_list))\n",
    "            x = issue_list[k]\n",
    "        else:\n",
    "            x = rand_sphere(K)\n",
    "        return x\n",
    "\n",
    "    def pick_agents(self, *args, **params):\n",
    "        i, j = choice(self.N, size=2, replace=False)\n",
    "        return i, j\n",
    "\n",
    "    def update(self, *args, **params):\n",
    "        x = self.pick_issue(*args, **params)\n",
    "        i, j = self.pick_agents(*args, **params)\n",
    "        self.interaction(i, j, x, *args, **params)\n",
    "\n",
    "\n",
    "## Analysis Interface\n",
    "class HEODAgentSocietyTrajectory(object):\n",
    "    _observables = 'overlap distrust trust balance mean_balance frustration mean_frustration coherence coherence_mean'.split()\n",
    "\n",
    "    def __init__(self, trajectory_array):\n",
    "        self.w = trajectory_array['w']\n",
    "        self.C = trajectory_array['C']\n",
    "        self.mu = trajectory_array['mu']\n",
    "        self.s2 = trajectory_array['s2']\n",
    "        self.T, self.N, self.K = self.w.shape\n",
    "        self._trajectory_array = trajectory_array\n",
    "\n",
    "    @property\n",
    "    def triangle_indices(self):\n",
    "        if not hasattr(self, '_triangle_indices'):\n",
    "            self._triangle_indices = triangle_indices(self.N)\n",
    "        return self._triangle_indices.T\n",
    "\n",
    "    @property\n",
    "    def normalized_w(self):\n",
    "        return self.w/norm(self.w, axis=2, keepdims=True)\n",
    "\n",
    "    @property\n",
    "    def overlap(self):\n",
    "        \"\"\"Compute the normalized overlap between agents\"\"\"\n",
    "        u = self.normalized_w #self.w/norm(self.w, axis=2, keepdims=True)\n",
    "        return einsum('...ij,...kj->...ik', u, u)\n",
    "\n",
    "    @property\n",
    "    def distrust(self):\n",
    "        \"\"\"Compute the distrust estimate\"\"\"\n",
    "        return Phi(self.mu/sqrt(1+self.s2))\n",
    "\n",
    "    @property\n",
    "    def trust(self):\n",
    "        \"\"\"Compute the trust as 1 - 2*distrust\"\"\"\n",
    "        return 1-2*self.distrust\n",
    "\n",
    "    @property\n",
    "    def balance_naive(self):\n",
    "        t = self.trust\n",
    "        return einsum('...ij,...jk,...ik->...ijk', t, t, t)\n",
    "\n",
    "    @property\n",
    "    def balance(self):\n",
    "        I, J, K  = self.triangle_indices\n",
    "        return self.balance_naive[:, I, J, K]\n",
    "\n",
    "    @property\n",
    "    def mean_balance(self):\n",
    "        return self.balance.mean(axis=1)\n",
    "\n",
    "    @property\n",
    "    def frustration_naive(self):\n",
    "        o = self.overlap\n",
    "        return einsum('...ij,...jk,...ik->...ijk', o, o, o)\n",
    "\n",
    "    @property\n",
    "    def frustration(self):\n",
    "        I, J, K = self.triangle_indices\n",
    "        return self.frustration_naive[:, I, J, K]\n",
    "\n",
    "    @property\n",
    "    def mean_frustration(self):\n",
    "        return self.frustration.mean(axis=1)\n",
    "\n",
    "    @property\n",
    "    def coherence_naive(self):\n",
    "        c = (self.overlap * self.trust)\n",
    "        return einsum('...ij,...jk,...ik->...ijk', c, c, c)\n",
    "\n",
    "    @property\n",
    "    def coherence(self):\n",
    "        I, J, K = self.triangle_indices\n",
    "        return self.coherence_naive[:, I, J, K]\n",
    "\n",
    "    @property\n",
    "    def coherence_mean(self):\n",
    "        return self.coherence.mean(axis=1)\n",
    "\n",
    "    @property\n",
    "    def observables(self):\n",
    "        \"\"\"Creates the dict of observables\"\"\"\n",
    "        return {n: getattr(self, n) for n in self._observables}\n"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}