From 7440c602c6e251dff370cf64bf16cf22ce2555d7 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Tue, 15 Mar 2022 19:54:29 +0100 Subject: [PATCH 001/232] initial commit for jax implementation --- .gitignore | 2 +- examples/model_inversion.ipynb | 961 +++++++++++++++++++++++++++++++++ pymdp/jax/__init__.py | 0 pymdp/jax/agent.py | 461 ++++++++++++++++ pymdp/jax/control.py | 571 ++++++++++++++++++++ pymdp/jax/inference.py | 243 +++++++++ pymdp/jax/learning.py | 355 ++++++++++++ 7 files changed, 2592 insertions(+), 1 deletion(-) create mode 100644 examples/model_inversion.ipynb create mode 100644 pymdp/jax/__init__.py create mode 100644 pymdp/jax/agent.py create mode 100644 pymdp/jax/control.py create mode 100644 pymdp/jax/inference.py create mode 100644 pymdp/jax/learning.py diff --git a/.gitignore b/.gitignore index 778d69dd..9c555589 100644 --- a/.gitignore +++ b/.gitignore @@ -7,4 +7,4 @@ __pycache__ .ipynb_checkpoints/ .pytest_cache env/ -pymdp.egg-info \ No newline at end of file +*.egg-info diff --git a/examples/model_inversion.ipynb b/examples/model_inversion.ipynb new file mode 100644 index 00000000..e77b81b0 --- /dev/null +++ b/examples/model_inversion.ipynb @@ -0,0 +1,961 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Active Inference model inversion: T-Maze Environment" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import jax\n", + "import jax.numpy as jnp\n", + "\n", + "import numpy as np\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "import copy\n", + "\n", + "from pymdp.agent import Agent\n", + "from pymdp import utils\n", + "from pymdp.envs import TMazeEnv" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Auxiliary Functions\n", + "\n", + "Define some utility functions that will be helpful for plotting." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_beliefs(belief_dist, title=\"\"):\n", + " plt.grid(zorder=0)\n", + " plt.bar(range(belief_dist.shape[0]), belief_dist, color='r', zorder=3)\n", + " plt.xticks(range(belief_dist.shape[0]))\n", + " plt.title(title)\n", + " plt.show()\n", + " \n", + "def plot_likelihood(A, title=\"\"):\n", + " ax = sns.heatmap(A, cmap=\"OrRd\", linewidth=2.5)\n", + " plt.xticks(range(A.shape[1]))\n", + " plt.yticks(range(A.shape[0]))\n", + " plt.title(title)\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Environment\n", + "\n", + "Here we consider an agent navigating a three-armed 'T-maze,' with the agent starting in a central location of the maze. The bottom arm of the maze contains an informative cue, which signals in which of the two top arms ('Left' or 'Right', the ends of the 'T') a reward is likely to be found. \n", + "\n", + "At each timestep, the environment is described by the joint occurrence of two qualitatively-different 'kinds' of states (hereafter referred to as _hidden state factors_). These hidden state factors are independent of one another.\n", + "\n", + "We represent the first hidden state factor (`Location`) as a $ 1 \\ x \\ 4 $ vector that encodes the current position of the agent, and can take the following values: {`CENTER`, `RIGHT ARM`, `LEFT ARM`, or `CUE LOCATION`}. For example, if the agent is in the `CUE LOCATION`, the current state of this factor would be $s_1 = [0 \\ 0 \\ 0 \\ 1]$.\n", + "\n", + "We represent the second hidden state factor (`Reward Condition`) as a $ 1 \\ x \\ 2 $ vector that encodes the reward condition of the trial: {`Reward on Right`, or `Reward on Left`}. A trial where the condition is reward is `Reward on Left` is thus encoded as the state $s_2 = [0 \\ 1]$.\n", + "\n", + "The environment is designed such that when the agent is located in the `RIGHT ARM` and the reward condition is `Reward on Right`, the agent has a specified probability $a$ (where $a > 0.5$) of receiving a reward, and a low probability $b = 1 - a$ of receiving a 'loss' (we can think of this as an aversive or unpreferred stimulus). If the agent is in the `LEFT ARM` for the same reward condition, the reward probabilities are swapped, and the agent experiences loss with probability $a$, and reward with lower probability $b = 1 - a$. These reward contingencies are intuitively swapped for the `Reward on Left` condition. \n", + "\n", + "For instance, we can encode the state of the environment at the first time step in a `Reward on Right` trial with the following pair of hidden state vectors: $s_1 = [1 \\ 0 \\ 0 \\ 0]$, $s_2 = [1 \\ 0]$, where we assume the agent starts sitting in the central location. If the agent moved to the right arm, then the corresponding hidden state vectors would now be $s_1 = [0 \\ 1 \\ 0 \\ 0]$, $s_2 = [1 \\ 0]$. This highlights the _independence_ of the two hidden state factors -- the location of the agent ($s_1$) can change without affecting the identity of the reward condition ($s_2$).\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1. Initialize environment\n", + "Now we can initialize the T-maze environment using the built-in `TMazeEnv` class from the `pymdp.envs` module." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Choose reward probabilities $a$ and $b$, where $a$ and $b$ are the probabilities of reward / loss in the 'correct' arm, and the probabilities of loss / reward in the 'incorrect' arm. Which arm counts as 'correct' vs. 'incorrect' depends on the reward condition (state of the 2nd hidden state factor)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "reward_probabilities = [0.98, 0.02] # probabilities used in the original SPM T-maze demo" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Initialize an instance of the T-maze environment" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "env = TMazeEnv(reward_probs = reward_probabilities)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Structure of the state --> outcome mapping\n", + "We can 'peer into' the rules encoded by the environment (also known as the _generative process_ ) by looking at the probability distributions that map from hidden states to observations. Following the SPM version of active inference, we refer to this collection of probabilistic relationships as the `A` array. In the case of the true rules of the environment, we refer to this array as `A_gp` (where the suffix `_gp` denotes the generative process). \n", + "\n", + "It is worth outlining what constitute the agent's observations in this task. In this T-maze demo, we have three sensory channels or observation modalities: `Location`, `Reward`, and `Cue`. \n", + "\n", + ">The `Location` observation values are identical to the `Location` hidden state values. In this case, the agent always unambiguously observes its own state - if the agent is in `RIGHT ARM`, it receives a `RIGHT ARM` observation in the corresponding modality. This might be analogized to a 'proprioceptive' sense of one's own place.\n", + "\n", + ">The `Reward` observation modality assumes the values `No Reward`, `Reward` or `Loss`. The `No Reward` (index 0) observation is observed whenever the agent isn't occupying one of the two T-maze arms (the right or left arms). The `Reward` (index 1) and `Loss` (index 2) observations are observed in the right and left arms of the T-maze, with associated probabilities that depend on the reward condition (i.e. on the value of the second hidden state factor).\n", + "\n", + "> The `Cue` observation modality assumes the values `Cue Right`, `Cue Left`. This observation unambiguously signals the reward condition of the trial, and therefore in which arm the `Reward` observation is more probable. When the agent occupies the other arms, the `Cue` observation will be `Cue Right` or `Cue Left` with equal probability. However (as we'll see below when we intialise the agent), the agent's beliefs about the likelihood mapping render these observations uninformative and irrelevant to state inference.\n", + "\n", + "In `pymdp`, we store the set of probability distributions encoding the conditional probabilities of observations, under different configurations of hidden states, as a set of matrices referred to as the likelihood mapping or `A` array (this is a convention borrowed from SPM). The likelihood mapping _for a single modality_ is stored as a single matrix `A[i]` with the larger likelihood array, where `i` is the index of the corresponding modality. Each modality-specific A matrix has `n_observations[i]` rows, and as many lagging dimensions (e.g. columns, 'slices' and higher-order dimensions) as there are hidden state factors. `n_observations[i]` tells you the number of observation values for observation modality `i`, and is usually stored as a property of the `Env` class (e.g. `env.n_observations`).\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "A_gp = env.get_likelihood_dist()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_likelihood(A_gp[1][:, :, 0],'Reward Right')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_likelihood(A_gp[1][:, :, 1],'Reward Left')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_likelihood(A_gp[2][:, 3, :],'Cue Mapping')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Transition Dynamics\n", + "\n", + "We represent the dynamics of the environment (e.g. changes in the location of the agent and changes to the reward condition) as conditional probability distributions that encode the likelihood of transitions between the states of a given hidden state factor. These distributions are collected into the so-called `B` array, also known as _transition likelihoods_ or _transition distribution_ . As with the `A` array, we denote the true probabilities describing the environmental dynamics as `B_gp`. Each sub-matrix `B_gp[f]` of the larger array encodes the transition probabilities between state-values of a given hidden state factor with index `f`. These matrices encode dynamics as Markovian transition probabilities, such that the entry $i,j$ of a given matrix encodes the probability of transition to state $i$ at time $t+1$, given state $j$ at $t$. " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "B_gp = env.get_transition_dist()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For example, we can inspect the 'dynamics' of the `Reward Condition` factor by indexing into the appropriate sub-matrix of `B_gp`" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_likelihood(B_gp[1][:, :, 0],'Reward Condition Transitions')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The above transition array is the 'trivial' identity matrix, meaning that the reward condition doesn't change over time (it's mapped from whatever it's current value is to the same value at the next timestep)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### (Controllable-) Transition Dynamics\n", + "\n", + "Importantly, some hidden state factors are _controllable_ by the agent, meaning that the probability of being in state $i$ at $t+1$ isn't merely a function of the state at $t$, but also of actions (or from the agent's perspective, _control states_ ). So now each transition likelihood encodes conditional probability distributions over states at $t+1$, where the conditioning variables are both the states at $t-1$ _and_ the actions at $t-1$. This extra conditioning on actions is encoded via an optional third dimension to each factor-specific `B` matrix.\n", + "\n", + "For example, in our case the first hidden state factor (`Location`) is under the control of the agent, which means the corresponding transition likelihoods `B[0]` are index-able by both previous state and action." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_likelihood(B_gp[0][:,:,0],'Transition likelihood for \"Move to Center\"')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_likelihood(B_gp[0][:,:,1],'Transition likelihood for \"Move to Right Arm\"')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_likelihood(B_gp[0][:,:,2],'Transition likelihood for \"Move to Left Arm\"')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_likelihood(B_gp[0][:,:,3],'Transition likelihood for \"Move to Cue Location\"')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The generative model\n", + "Now we can move onto setting up the generative model of the agent - namely, the agent's beliefs about how hidden states give rise to observations, and how hidden states transition among eachother.\n", + "\n", + "In almost all MDPs, the critical building blocks of this generative model are the agent's representation of the observation likelihood, which we'll refer to as `A_gm`, and its representation of the transition likelihood, or `B_gm`. \n", + "\n", + "Here, we assume the agent has a veridical representation of the rules of the T-maze (namely, how hidden states cause observations) as well as its ability to control its own movements with certain consequences (i.e. 'noiseless' transitions)." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "A_gm = copy.deepcopy(A_gp) # make a copy of the true observation likelihood to initialize the observation model\n", + "B_gm = copy.deepcopy(B_gp) # make a copy of the true transition likelihood to initialize the transition model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Note !\n", + "It is not necessary, or even in many cases _important_ , that the generative model is a veridical representation of the generative process. This distinction between generative model (essentially, beliefs entertained by the agent and its interaction with the world) and the generative process (the actual dynamical system 'out there' generating sensations) is of crucial importance to the active inference formalism and (in our experience) often overlooked in code.\n", + "\n", + "It is for notational and computational convenience that we encode the generative process using `A` and `B` matrices. By doing so, it simply puts the rules of the environment in a data structure that can easily be converted into the Markovian-style conditional distributions useful for encoding the agent's generative model.\n", + "\n", + "Strictly speaking, however, all the generative process needs to do is generate observations and be 'perturbable' by actions. The way in which it does so can be arbitrarily complex, non-linear, and unaccessible by the agent." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Introducing the `Agent()` class\n", + "\n", + "In `pymdp`, we have abstracted much of the computations required for active inference into the `Agent()` class, a flexible object that can be used to store necessary aspects of the generative model, the agent's instantaneous observations and actions, and perform action / perception using functions like `Agent.infer_states` and `Agent.infer_policies`. \n", + "\n", + "An instance of `Agent` is straightforwardly initialized with a call to `Agent()` with a list of optional arguments.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In our call to `Agent()`, we need to constrain the default behavior with some of our T-Maze-specific needs. For example, we want to make sure that the agent's beliefs about transitions are constrained by the fact that it can only control the `Location` factor - _not_ the `Reward Condition` (which we assumed stationary across an epoch of time). Therefore we specify this using a list of indices that will be passed as the `control_fac_idx` argument of the `Agent()` constructor. \n", + "\n", + "Each element in the list specifies a hidden state factor (in terms of its index) that is controllable by the agent. Hidden state factors whose indices are _not_ in this list are assumed to be uncontrollable." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "controllable_indices = [0] # this is a list of the indices of the hidden state factors that are controllable" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can construct our agent..." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "agent = Agent(A=A_gm, B=B_gm, control_fac_idx=controllable_indices)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can inspect properties (and change) of the agent as we see fit. Let's look at the initial beliefs the agent has about its starting location and reward condition, encoded in the prior over hidden states $P(s)$, known in SPM-lingo as the `D` array." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_beliefs(agent.D[0],\"Beliefs about initial location\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_beliefs(agent.D[1],\"Beliefs about reward condition\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's make it so that agent starts with precise and accurate prior beliefs about its starting location." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "agent.D[0] = utils.onehot(0, agent.num_states[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And now confirm that our agent knows (i.e. has accurate beliefs about) its initial state by visualizing its priors again." + ] + }, + { + "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": [ + "plot_beliefs(agent.D[0],\"Beliefs about initial location\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Another thing we want to do in this case is make sure the agent has a 'sense' of reward / loss and thus a motivation to be in the 'correct' arm (the arm that maximizes the probability of getting the reward outcome).\n", + "\n", + "We can do this by changing the prior beliefs about observations, the `C` array (also known as the _prior preferences_ ). This is represented as a collection of distributions over observations for each modality. It is initialized by default to be all 0s. This means agent has no preference for particular outcomes. Since the second modality (index `1` of the `C` array) is the `Reward` modality, with the index of the `Reward` outcome being `1`, and that of the `Loss` outcome being `2`, we populate the corresponding entries with values whose relative magnitudes encode the preference for one outcome over another (technically, this is encoded directly in terms of relative log-probabilities). \n", + "\n", + "Our ability to make the agent's prior beliefs that it tends to observe the outcome with index `1` in the `Reward` modality, more often than the outcome with index `2`, is what makes this modality a Reward modality in the first place -- otherwise, it would just be an arbitrary observation with no extrinsic value _per se_. " + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "agent.C[1][1] = 3.0\n", + "agent.C[1][2] = -3.0" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_beliefs(agent.C[1],\"Prior beliefs about observations\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Active Inference\n", + "Now we can start off the T-maze with an initial observation and run active inference via a loop over a desired time interval." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " === Starting experiment === \n", + " Reward condition: Left, Observation: [CENTER, No reward, Cue Left]\n", + "[Step 0] Action: [Move to LEFT ARM]\n", + "[Step 0] Observation: [LEFT ARM, Reward!, Cue Right]\n", + "[Step 1] Action: [Move to LEFT ARM]\n", + "[Step 1] Observation: [LEFT ARM, Reward!, Cue Right]\n", + "[Step 2] Action: [Move to LEFT ARM]\n", + "[Step 2] Observation: [LEFT ARM, Reward!, Cue Left]\n", + "[Step 3] Action: [Move to LEFT ARM]\n", + "[Step 3] Observation: [LEFT ARM, Reward!, Cue Right]\n", + "[Step 4] Action: [Move to LEFT ARM]\n", + "[Step 4] Observation: [LEFT ARM, Reward!, Cue Left]\n" + ] + } + ], + "source": [ + "T = 5 # number of timesteps\n", + "\n", + "obs = env.reset() # reset the environment and get an initial observation\n", + "\n", + "# these are useful for displaying read-outs during the loop over time\n", + "reward_conditions = [\"Right\", \"Left\"]\n", + "location_observations = ['CENTER','RIGHT ARM','LEFT ARM','CUE LOCATION']\n", + "reward_observations = ['No reward','Reward!','Loss!']\n", + "cue_observations = ['Cue Right','Cue Left']\n", + "msg = \"\"\" === Starting experiment === \\n Reward condition: {}, Observation: [{}, {}, {}]\"\"\"\n", + "print(msg.format(reward_conditions[env.reward_condition], location_observations[obs[0]], reward_observations[obs[1]], cue_observations[obs[2]]))\n", + "\n", + "measurments = {'actions': [], 'outcomes': [jnp.array(obs)]}\n", + "for t in range(T):\n", + " qx = agent.infer_states(obs)\n", + "\n", + " q_pi, efe = agent.infer_policies()\n", + "\n", + " action = agent.sample_action()\n", + " measurments[\"actions\"].append( jnp.array(action) )\n", + "\n", + " msg = \"\"\"[Step {}] Action: [Move to {}]\"\"\"\n", + " print(msg.format(t, location_observations[int(action[0])]))\n", + "\n", + " obs = env.step(action)\n", + " measurments[\"outcomes\"].append(jnp.array(obs))\n", + "\n", + " msg = \"\"\"[Step {}] Observation: [{}, {}, {}]\"\"\"\n", + " print(msg.format(t, location_observations[obs[0]], reward_observations[obs[1]], cue_observations[obs[2]]))\n", + " \n", + "measurments['actions'] = jnp.stack(measurments['actions'])\n", + "measurments['outcomes'] = jnp.stack(measurments['outcomes'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The agent begins by moving to the `CUE LOCATION` to resolve its uncertainty about the reward condition - this is because it knows it will get an informative cue in this location, which will signal the true reward condition unambiguously. At the beginning of the next timestep, the agent then uses this observaiton to update its posterior beliefs about states `qx[1]` to reflect the true reward condition. Having resolved its uncertainty about the reward condition, the agent then moves to `RIGHT ARM` to maximize utility and continues to do so, given its (correct) beliefs about the reward condition and the mapping between hidden states and reward observations. \n", + "\n", + "Notice, perhaps confusingly, that the agent continues to receive observations in the 3rd modality (i.e. samples from `A_gp[2]`). These are observations of the form `Cue Right` or `Cue Left`. However, these 'cue' observations are random and totally umambiguous unless the agent is in the `CUE LOCATION` - this is reflected by totally entropic distributions in the corresponding columns of `A_gp[2]` (and the agents beliefs about this ambiguity, reflected in `A_gm[2]`. See below." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_likelihood(A_gp[2][:,:,0],'Cue Observations when condition is Reward on Right, for Different Locations')" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_likelihood(A_gp[2][:,:,1],'Cue Observations when condition is Reward on Left, for Different Locations')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The final column on the right side of these matrices represents the distribution over cue observations, conditioned on the agent being in `CUE LOCATION` and the appropriate Reward Condition. This demonstrates that cue observations are uninformative / lacking epistemic value for the agent, _unless_ they are in `CUE LOCATION.`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can inspect the agent's final beliefs about the reward condition characterizing the 'trial,' having undergone 10 timesteps of active inference." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_beliefs(qx[1],\"Final posterior beliefs about reward condition\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Model inversion\n", + "Define model likelihood given the observed sequence of actions and outcomes" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "from pymdp.jax.agent import Agent\n", + "\n", + "def scan(step_fn, init, iterator):\n", + " carry = init\n", + " for itr in iterator:\n", + " carry = step_fn(carry, itr)\n", + " \n", + " return carry[-1]\n", + " \n", + "def model_log_likelihood(T, data, params):\n", + " agent = Agent(params['A'], params['B'], C=params['C'], D=params['D'], control_fac_idx=controllable_indices) \n", + " \n", + " def step_fn(carry, obs):\n", + " t, log_prob = carry\n", + " qx = agent.infer_states(obs)\n", + " q_pi, _ = agent.infer_policies()\n", + " \n", + " print('q_pi', type(q_pi))\n", + " \n", + " nc = agent.num_controls\n", + " num_factors = len(nc)\n", + " \n", + " # marginal can be list and it still works\n", + " marginal = list(utils.obj_array_zeros(agent.num_controls))\n", + " print('marginal', type(marginal))\n", + " print('agent.policies', type(agent.policies))\n", + " \n", + " # explicit for loop has to be removed for this to be differentiable\n", + " for pol_idx, policy in enumerate(agent.policies):\n", + " print(f'policy {pol_idx}', type(policy))\n", + " for factor_i, action_i in enumerate(policy[0, :]):\n", + " marginal[factor_i][action_i] += q_pi[pol_idx]\n", + " print(marginal)\n", + " for factor_idx, m in enumerate(marginal):\n", + " log_prob += jnp.sum(jnp.log(m) * jax.nn.one_hot(action[factor_idx], nc[factor_idx]))\n", + " \n", + " agent.action = data['actions'][t]\n", + " \n", + " return (t + 1, log_prob)\n", + " \n", + " log_prob = 0.\n", + " init = (data['actions'][0], 0, log_prob)\n", + " return scan(step_fn, init, data['outcomes'][:-1])" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "q_pi \n", + "marginal \n", + "agent.policies \n", + "policy 0 \n", + "policy 1 \n", + "policy 2 \n", + "policy 3 \n", + "[array([1.07708275e-05, 1.47056773e-01, 1.47056773e-01, 7.05875683e-01]), array([1.])]\n", + "q_pi \n", + "marginal \n", + "agent.policies \n", + "policy 0 \n", + "policy 1 \n", + "policy 2 \n", + "policy 3 \n", + "[array([3.40439691e-08, 1.40201800e-07, 9.98237134e-01, 1.76269178e-03]), array([1.])]\n", + "q_pi \n", + "marginal \n", + "agent.policies \n", + "policy 0 \n", + "policy 1 \n", + "policy 2 \n", + "policy 3 \n", + "[array([3.40439691e-08, 1.40201800e-07, 9.98237134e-01, 1.76269178e-03]), array([1.])]\n", + "q_pi \n", + "marginal \n", + "agent.policies \n", + "policy 0 \n", + "policy 1 \n", + "policy 2 \n", + "policy 3 \n", + "[array([3.40439691e-08, 1.40201800e-07, 9.98237134e-01, 1.76269178e-03]), array([1.])]\n", + "q_pi \n", + "marginal \n", + "agent.policies \n", + "policy 0 \n", + "policy 1 \n", + "policy 2 \n", + "policy 3 \n", + "[array([3.40439691e-08, 1.40201800e-07, 9.98237134e-01, 1.76269178e-03]), array([1.])]\n" + ] + }, + { + "data": { + "text/plain": [ + "DeviceArray(-1.9239942, dtype=float32)" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# the following grad computation has to work for the Agent class to be differentiable and hence invertible\n", + "from functools import partial\n", + "\n", + "# for now this has to work\n", + "params = {\n", + " 'A': A_gp,\n", + " 'B': B_gp,\n", + " 'C': agent.C,\n", + " 'D': agent.D\n", + "}\n", + "\n", + "partial(model_log_likelihood, T, measurments)(params)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "A matrix must be a numpy array", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [32]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m params \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m 3\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mA\u001b[39m\u001b[38;5;124m'\u001b[39m: [jnp\u001b[38;5;241m.\u001b[39marray(x) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mlist\u001b[39m(A_gp)],\n\u001b[1;32m 4\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mB\u001b[39m\u001b[38;5;124m'\u001b[39m: [jnp\u001b[38;5;241m.\u001b[39marray(x) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mlist\u001b[39m(B_gp)],\n\u001b[1;32m 5\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mC\u001b[39m\u001b[38;5;124m'\u001b[39m: [jnp\u001b[38;5;241m.\u001b[39marray(x) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mlist\u001b[39m(agent\u001b[38;5;241m.\u001b[39mC)],\n\u001b[1;32m 6\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mD\u001b[39m\u001b[38;5;124m'\u001b[39m: [jnp\u001b[38;5;241m.\u001b[39marray(x) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mlist\u001b[39m(agent\u001b[38;5;241m.\u001b[39mD)]\n\u001b[1;32m 7\u001b[0m }\n\u001b[1;32m 9\u001b[0m \u001b[38;5;66;03m# grad computation cannot work \u001b[39;00m\n\u001b[0;32m---> 10\u001b[0m \u001b[43mjax\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgrad\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpartial\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel_log_likelihood\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mT\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmeasurments\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\n", + " \u001b[0;31m[... skipping hidden 10 frame]\u001b[0m\n", + "Input \u001b[0;32mIn [29]\u001b[0m, in \u001b[0;36mmodel_log_likelihood\u001b[0;34m(T, data, params)\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mmodel_log_likelihood\u001b[39m(T, data, params):\n\u001b[0;32m----> 9\u001b[0m agent \u001b[38;5;241m=\u001b[39m \u001b[43mAgent\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparams\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mA\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparams\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mB\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mC\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mC\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mD\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mD\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcontrol_fac_idx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcontrollable_indices\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 11\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mstep_fn\u001b[39m(carry, obs):\n\u001b[1;32m 12\u001b[0m action, t, log_prob \u001b[38;5;241m=\u001b[39m carry\n", + "File \u001b[0;32m/run/media/dima/data/Dropbox/development/python/pymdp/pymdp/agent.py:72\u001b[0m, in \u001b[0;36mAgent.__init__\u001b[0;34m(self, A, B, C, D, E, pA, pB, pD, num_controls, policy_len, inference_horizon, control_fac_idx, policies, gamma, use_utility, use_states_info_gain, use_param_info_gain, action_selection, inference_algo, inference_params, modalities_to_learn, lr_pA, factors_to_learn, lr_pB, lr_pD, use_BMA, policy_sep_prior, save_belief_hist)\u001b[0m\n\u001b[1;32m 70\u001b[0m \u001b[38;5;124;03m\"\"\" Initialise observation model (A matrices) \"\"\"\u001b[39;00m\n\u001b[1;32m 71\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(A, np\u001b[38;5;241m.\u001b[39mndarray):\n\u001b[0;32m---> 72\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\n\u001b[1;32m 73\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mA matrix must be a numpy array\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 74\u001b[0m )\n\u001b[1;32m 76\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mA \u001b[38;5;241m=\u001b[39m utils\u001b[38;5;241m.\u001b[39mto_obj_array(A)\n\u001b[1;32m 78\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m utils\u001b[38;5;241m.\u001b[39mis_normalized(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mA), \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mA matrix is not normalized (i.e. A.sum(axis = 0) must all equal 1.0\u001b[39m\u001b[38;5;124m\"\u001b[39m\n", + "\u001b[0;31mTypeError\u001b[0m: A matrix must be a numpy array" + ] + } + ], + "source": [ + "# parameters have to be jax arrays, lists or dictionaries of jax arrays\n", + "params = {\n", + " 'A': [jnp.array(x) for x in list(A_gp)],\n", + " 'B': [jnp.array(x) for x in list(B_gp)],\n", + " 'C': [jnp.array(x) for x in list(agent.C)],\n", + " 'D': [jnp.array(x) for x in list(agent.D)]\n", + "}\n", + "\n", + "# grad computation cannot work \n", + "jax.grad(partial(model_log_likelihood, T, measurments))(params)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "interpreter": { + "hash": "24ee14d9f6452059a99d44b6cbd71d1bb479b0539b0360a6a17428ecea9f0810" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/pymdp/jax/__init__.py b/pymdp/jax/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py new file mode 100644 index 00000000..1fcb4799 --- /dev/null +++ b/pymdp/jax/agent.py @@ -0,0 +1,461 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +""" Agent Class + +__author__: Conor Heins, Alexander Tschantz, Daphne Demekas, Brennan Klein + +""" + +import warnings +import numpy as np +from pymdp import inference, control, learning +from pymdp import utils, maths +import copy + +class Agent(object): + """ + The Agent class, the highest-level API that wraps together processes for action, perception, and learning under active inference. + + The basic usage is as follows: + + >>> my_agent = Agent(A = A, B = C, ) + >>> observation = env.step(initial_action) + >>> qs = my_agent.infer_states(observation) + >>> q_pi, G = my_agent.infer_policies() + >>> next_action = my_agent.sample_action() + >>> next_observation = env.step(next_action) + + This represents one timestep of an active inference process. Wrapping this step in a loop with an ``Env()`` class that returns + observations and takes actions as inputs, would entail a dynamic agent-environment interaction. + """ + + def __init__( + self, + A, + B, + C=None, + D=None, + E = None, + pA=None, + pB = None, + pD = None, + num_controls=None, + policy_len=1, + inference_horizon=1, + control_fac_idx=None, + policies=None, + gamma=16.0, + use_utility=True, + use_states_info_gain=True, + use_param_info_gain=False, + action_selection="deterministic", + inference_algo="VANILLA", + inference_params=None, + modalities_to_learn="all", + lr_pA=1.0, + factors_to_learn="all", + lr_pB=1.0, + lr_pD=1.0, + use_BMA = True, + policy_sep_prior = False, + save_belief_hist = False + ): + + ### Constant parameters ### + + # policy parameters + self.policy_len = policy_len + self.gamma = gamma + self.action_selection = action_selection + self.use_utility = use_utility + self.use_states_info_gain = use_states_info_gain + self.use_param_info_gain = use_param_info_gain + + # learning parameters + self.modalities_to_learn = modalities_to_learn + self.lr_pA = lr_pA + self.factors_to_learn = factors_to_learn + self.lr_pB = lr_pB + self.lr_pD = lr_pD + + self.A = A + + # self.A = pytree.map(utils.normalized, A) + + """ Determine number of observation modalities and their respective dimensions """ + self.num_obs = [self.A[m].shape[0] for m in range(len(self.A))] + self.num_modalities = len(self.num_obs) + + """ Assigning prior parameters on observation model (pA matrices) """ + self.pA = pA + + # self.B = map( utils.normalized, B) + self.B = B + + # Determine number of hidden state factors and their dimensionalities + self.num_states = [self.B[f].shape[0] for f in range(len(self.B))] + self.num_factors = len(self.num_states) + + """ Assigning prior parameters on transition model (pB matrices) """ + self.pB = pB + + # If no `num_controls` are given, then this is inferred from the shapes of the input B matrices + self.num_controls = [self.B[f].shape[2] for f in range(self.num_factors)] + + # Users have the option to make only certain factors controllable. + # default behaviour is to make all hidden state factors controllable + # (i.e. self.num_states == self.num_controls) + self.control_fac_idx = control_fac_idx + self.policies = policies + + self.C = C + + """ Construct prior over hidden states (uniform if not specified) """ + self.D = D + + """ Assigning prior parameters on initial hidden states (pD vectors) """ + self.pD = pD + + """ Construct prior over policies (uniform if not specified) """ + + self.E = E + + self.prev_obs = [] + self.reset() + + self.action = None + self.prev_actions = None + + def reset(self, init_qs=None): + """ + Resets the posterior beliefs about hidden states of the agent to a uniform distribution, and resets time to first timestep of the simulation's temporal horizon. + Returns the posterior beliefs about hidden states. + + Returns + --------- + qs: ``numpy.ndarray`` of dtype object + Initialized posterior over hidden states. Depending on the inference algorithm chosen and other parameters (such as the parameters stored within ``edge_handling_paramss), + the resulting ``qs`` variable will have additional sub-structure to reflect whether beliefs are additionally conditioned on timepoint and policy. + For example, in case the ``self.inference_algo == 'MMP' `, the indexing structure of ``qs`` is policy->timepoint-->factor, so that + ``qs[p_idx][t_idx][f_idx]`` refers to beliefs about marginal factor ``f_idx`` expected under policy ``p_idx`` + at timepoint ``t_idx``. In this case, the returned ``qs`` will only have entries filled out for the first timestep, i.e. for ``q[p_idx][0]``, for all + policy-indices ``p_idx``. Subsequent entries ``q[:][1, 2, ...]`` will be initialized to empty ``numpy.ndarray`` objects. + """ + + self.curr_timestep = 0 + + self.qs = utils.list_array_uniform(self.num_states) + + return self.qs + + def step_time(self): + """ + Advances time by one step. This involves updating the ``self.prev_actions``, and in the case of a moving + inference horizon, this also shifts the history of post-dictive beliefs forward in time (using ``self.set_latest_beliefs()``), + so that the penultimate belief before the beginning of the horizon is correctly indexed. + + Returns + --------- + curr_timestep: ``int`` + The index in absolute simulation time of the current timestep. + """ + + if self.prev_actions is None: + self.prev_actions = [self.action] + else: + self.prev_actions.append(self.action) + + self.curr_timestep += 1 + + if self.inference_algo == "MMP" and (self.curr_timestep - self.inference_horizon) >= 0: + self.set_latest_beliefs() + + return self.curr_timestep + + def set_latest_beliefs(self,last_belief=None): + """ + Both sets and returns the penultimate belief before the first timestep of the backwards inference horizon. + In the case that the inference horizon includes the first timestep of the simulation, then the ``latest_belief`` is + simply the first belief of the whole simulation, or the prior (``self.D``). The particular structure of the ``latest_belief`` + depends on the value of ``self.edge_handling_params['use_BMA']``. + + Returns + --------- + latest_belief: ``numpy.ndarray`` of dtype object + Penultimate posterior beliefs over hidden states at the timestep just before the first timestep of the inference horizon. + Depending on the value of ``self.edge_handling_params['use_BMA']``, the shape of this output array will differ. + If ``self.edge_handling_params['use_BMA'] == True``, then ``latest_belief`` will be a Bayesian model average + of beliefs about hidden states, where the average is taken with respect to posterior beliefs about policies. + Otherwise, `latest_belief`` will be the full, policy-conditioned belief about hidden states, and will have indexing structure + policies->factors, such that ``latest_belief[p_idx][f_idx]`` refers to the penultimate belief about marginal factor ``f_idx`` + under policy ``p_idx``. + """ + + if last_belief is None: + last_belief = utils.obj_array(len(self.policies)) + for p_i, _ in enumerate(self.policies): + last_belief[p_i] = copy.deepcopy(self.qs[p_i][0]) + + begin_horizon_step = self.curr_timestep - self.inference_horizon + if self.edge_handling_params['use_BMA'] and (begin_horizon_step >= 0): + if hasattr(self, "q_pi_hist"): + self.latest_belief = inference.average_states_over_policies(last_belief, self.q_pi_hist[begin_horizon_step]) # average the earliest marginals together using contemporaneous posterior over policies (`self.q_pi_hist[0]`) + else: + self.latest_belief = inference.average_states_over_policies(last_belief, self.q_pi) # average the earliest marginals together using posterior over policies (`self.q_pi`) + else: + self.latest_belief = last_belief + + return self.latest_belief + + def get_future_qs(self): + """ + Returns the last ``self.policy_len`` timesteps of each policy-conditioned belief + over hidden states. This is a step of pre-processing that needs to be done before computing + the expected free energy of policies. We do this to avoid computing the expected free energy of + policies using beliefs about hidden states in the past (so-called "post-dictive" beliefs). + + Returns + --------- + future_qs_seq: ``numpy.ndarray`` of dtype object + Posterior beliefs over hidden states under a policy, in the future. This is a nested ``numpy.ndarray`` object array, with one + sub-array ``future_qs_seq[p_idx]`` for each policy. The indexing structure is policy->timepoint-->factor, so that + ``future_qs_seq[p_idx][t_idx][f_idx]`` refers to beliefs about marginal factor ``f_idx`` expected under policy ``p_idx`` + at future timepoint ``t_idx``, relative to the current timestep. + """ + + future_qs_seq = utils.obj_array(len(self.qs)) + for p_idx in range(len(self.qs)): + future_qs_seq[p_idx] = self.qs[p_idx][-(self.policy_len+1):] # this grabs only the last `policy_len`+1 beliefs about hidden states, under each policy + + return future_qs_seq + + + def infer_states(self, observation): + """ + Update approximate posterior over hidden states by solving variational inference problem, given an observation. + + Parameters + ---------- + observation: ``list`` or ``tuple`` of ints + The observation input. Each entry ``observation[m]`` stores the index of the discrete + observation for modality ``m``. + + Returns + --------- + qs: ``numpy.ndarray`` of dtype object + Posterior beliefs over hidden states. Depending on the inference algorithm chosen, the resulting ``qs`` variable will have additional sub-structure to reflect whether + beliefs are additionally conditioned on timepoint and policy. + For example, in case the ``self.inference_algo == 'MMP' `` indexing structure is policy->timepoint-->factor, so that + ``qs[p_idx][t_idx][f_idx]`` refers to beliefs about marginal factor ``f_idx`` expected under policy ``p_idx`` + at timepoint ``t_idx``. + """ + + observation = tuple(observation) + + if self.action is not None: + empirical_prior = control.get_expected_states( + self.qs, self.B, self.action.reshape(1, -1) #type: ignore + )[0] + else: + empirical_prior = self.D + qs = inference.update_posterior_states( + self.A, + observation, + empirical_prior, + **self.inference_params + ) + + self.qs = qs + + return qs + + def infer_policies(self): + """ + Perform policy inference by optimizing a posterior (categorical) distribution over policies. + This distribution is computed as the softmax of ``G * gamma + lnE`` where ``G`` is the negative expected + free energy of policies, ``gamma`` is a policy precision and ``lnE`` is the (log) prior probability of policies. + This function returns the posterior over policies as well as the negative expected free energy of each policy. + + Returns + ---------- + q_pi: 1D ``numpy.ndarray`` + Posterior beliefs over policies, i.e. a vector containing one posterior probability per policy. + G: 1D ``numpy.ndarray`` + Negative expected free energies of each policy, i.e. a vector containing one negative expected free energy per policy. + """ + + q_pi, G = control.update_posterior_policies( + self.qs, + self.A, + self.B, + self.C, + self.policies, + self.use_utility, + self.use_states_info_gain, + self.use_param_info_gain, + self.pA, + self.pB, + E = self.E, + gamma = self.gamma + ) + + self.q_pi = q_pi + self.G = G + return q_pi, G + + def sample_action(self): + """ + Sample or select a discrete action from the posterior over control states. + This function both sets or cachés the action as an internal variable with the agent and returns it. + This function also updates time variable (and thus manages consequences of updating the moving reference frame of beliefs) + using ``self.step_time()``. + + Returns + ---------- + action: 1D ``numpy.ndarray`` + Vector containing the indices of the actions for each control factor + """ + + action = control.sample_action( + self.q_pi, self.policies, self.num_controls, self.action_selection + ) + + self.action = action + + self.step_time() + + return action + + def update_A(self, obs): + """ + Update approximate posterior beliefs about Dirichlet parameters that parameterise the observation likelihood or ``A`` array. + + Parameters + ---------- + observation: ``list`` or ``tuple`` of ints + The observation input. Each entry ``observation[m]`` stores the index of the discrete + observation for modality ``m``. + + Returns + ----------- + qA: ``numpy.ndarray`` of dtype object + Posterior Dirichlet parameters over observation model (same shape as ``A``), after having updated it with observations. + """ + + qA = learning.update_obs_likelihood_dirichlet( + self.pA, + self.A, + obs, + self.qs, + self.lr_pA, + self.modalities_to_learn + ) + + self.pA = qA # set new prior to posterior + self.A = utils.norm_dist_obj_arr(qA) # take expected value of posterior Dirichlet parameters to calculate posterior over A array + + return qA + + def update_B(self, qs_prev): + """ + Update posterior beliefs about Dirichlet parameters that parameterise the transition likelihood + + Parameters + ----------- + qs_prev: 1D ``numpy.ndarray`` or ``numpy.ndarray`` of dtype object + Marginal posterior beliefs over hidden states at previous timepoint. + + Returns + ----------- + qB: ``numpy.ndarray`` of dtype object + Posterior Dirichlet parameters over transition model (same shape as ``B``), after having updated it with state beliefs and actions. + """ + + pB_updated = learning.update_state_likelihood_dirichlet( + self.pB, + self.B, + self.action, + self.qs, + qs_prev, + self.lr_pB, + self.factors_to_learn + ) + + self.pB = qB # set new prior to posterior + self.B = utils.norm_dist_obj_arr(qB) # take expected value of posterior Dirichlet parameters to calculate posterior over B array + + return qB + + def update_D(self, qs_t0 = None): + """ + Update Dirichlet parameters of the initial hidden state distribution + (prior beliefs about hidden states at the beginning of the inference window). + + Parameters + ----------- + qs_t0: 1D ``numpy.ndarray``, ``numpy.ndarray`` of dtype object, or ``None`` + Marginal posterior beliefs over hidden states at current timepoint. If ``None``, the + value of ``qs_t0`` is set to ``self.qs_hist[0]`` (i.e. the initial hidden state beliefs at the first timepoint). + If ``self.inference_algo == "MMP"``, then ``qs_t0`` is set to be the Bayesian model average of beliefs about hidden states + at the first timestep of the backwards inference horizon, where the average is taken with respect to posterior beliefs about policies. + + Returns + ----------- + qD: ``numpy.ndarray`` of dtype object + Posterior Dirichlet parameters over initial hidden state prior (same shape as ``qs_t0``), after having updated it with state beliefs. + """ + + if self.inference_algo == "VANILLA": + + if qs_t0 is None: + + try: + qs_t0 = self.qs_hist[0] + except ValueError: + print("qs_t0 must either be passed as argument to `update_D` or `save_belief_hist` must be set to True!") + + elif self.inference_algo == "MMP": + + if self.edge_handling_params['use_BMA']: + qs_t0 = self.latest_belief + elif self.edge_handling_params['policy_sep_prior']: + + qs_pi_t0 = self.latest_belief + + # get beliefs about policies at the time at the beginning of the inference horizon + if hasattr(self, "q_pi_hist"): + begin_horizon_step = max(0, self.curr_timestep - self.inference_horizon) + q_pi_t0 = np.copy(self.q_pi_hist[begin_horizon_step]) + else: + q_pi_t0 = np.copy(self.q_pi) + + qs_t0 = inference.average_states_over_policies(qs_pi_t0,q_pi_t0) # beliefs about hidden states at the first timestep of the inference horizon + + qD = learning.update_state_prior_dirichlet(self.pD, qs_t0, self.lr_pD, factors = self.factors_to_learn) + + self.pD = qD # set new prior to posterior + self.D = utils.norm_dist_obj_arr(qD) # take expected value of posterior Dirichlet parameters to calculate posterior over D array + + return qD + + def _get_default_params(self): + method = self.inference_algo + default_params = None + if method == "VANILLA": + default_params = {"num_iter": 10, "dF": 1.0, "dF_tol": 0.001} + elif method == "MMP": + default_params = {"num_iter": 10, "grad_descent": True, "tau": 0.25} + elif method == "VMP": + raise NotImplementedError("VMP is not implemented") + elif method == "BP": + raise NotImplementedError("BP is not implemented") + elif method == "EP": + raise NotImplementedError("EP is not implemented") + elif method == "CV": + raise NotImplementedError("CV is not implemented") + + return default_params + + + diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py new file mode 100644 index 00000000..656b6f33 --- /dev/null +++ b/pymdp/jax/control.py @@ -0,0 +1,571 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# pylint: disable=no-member +# pylint: disable=not-an-iterable + +import itertools +import numpy as np +from pymdp.maths import softmax, softmax_obj_arr, spm_dot, spm_wnorm, spm_MDP_G, spm_log_single, spm_log_obj_array +from pymdp import utils +import copy + +def update_posterior_policies_full( + qs_seq_pi, + A, + B, + C, + policies, + use_utility=True, + use_states_info_gain=True, + use_param_info_gain=False, + prior=None, + pA=None, + pB=None, + F = None, + E = None, + gamma=16.0 +): + """ + Update posterior beliefs about policies by computing expected free energy of each policy and integrating that + with the variational free energy of policies ``F`` and prior over policies ``E``. This is intended to be used in conjunction + with the ``update_posterior_states_full`` method of ``inference.py``, since the full posterior over future timesteps, under all policies, is + assumed to be provided in the input array ``qs_seq_pi``. + + Parameters + ---------- + qs_seq_pi: ``numpy.ndarray`` of dtype object + Posterior beliefs over hidden states for each policy. Nesting structure is policies, timepoints, factors, + where e.g. ``qs_seq_pi[p][t][f]`` stores the marginal belief about factor ``f`` at timepoint ``t`` under policy ``p``. + A: ``numpy.ndarray`` of dtype object + Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of + stores an ``numpy.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store + the probability of observation level ``i`` given hidden state levels ``j, k, ...`` + B: ``numpy.ndarray`` of dtype object + Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. + Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability + of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. + C: ``numpy.ndarray`` of dtype object + Prior over observations or 'prior preferences', storing the "value" of each outcome in terms of relative log probabilities. + This is softmaxed to form a proper probability distribution before being used to compute the expected utility term of the expected free energy. + policies: ``list`` of 2D ``numpy.ndarray`` + ``list`` that stores each policy in ``policies[p_idx]``. Shape of ``policies[p_idx]`` is ``(num_timesteps, num_factors)`` where `num_timesteps` is the temporal + depth of the policy and ``num_factors`` is the number of control factors. + use_utility: ``Bool``, default ``True`` + Boolean flag that determines whether expected utility should be incorporated into computation of EFE. + use_states_info_gain: ``Bool``, default ``True`` + Boolean flag that determines whether state epistemic value (info gain about hidden states) should be incorporated into computation of EFE. + use_param_info_gain: ``Bool``, default ``False`` + Boolean flag that determines whether parameter epistemic value (info gain about generative model parameters) should be incorporated into computation of EFE. + prior: ``numpy.ndarray`` of dtype object, default ``None`` + If provided, this is a ``numpy`` object array with one sub-array per hidden state factor, that stores the prior beliefs about initial states. + If ``None``, this defaults to a flat (uninformative) prior over hidden states. + pA: ``numpy.ndarray`` of dtype object, default ``None`` + Dirichlet parameters over observation model (same shape as ``A``) + pB: ``numpy.ndarray`` of dtype object, default ``None`` + Dirichlet parameters over transition model (same shape as ``B``) + F: 1D ``numpy.ndarray``, default ``None`` + Vector of variational free energies for each policy + E: 1D ``numpy.ndarray``, default ``None`` + Vector of prior probabilities of each policy (what's referred to in the active inference literature as "habits"). If ``None``, this defaults to a flat (uninformative) prior over policies. + gamma: ``float``, default 16.0 + Prior precision over policies, scales the contribution of the expected free energy to the posterior over policies + + Returns + ---------- + q_pi: 1D ``numpy.ndarray`` + Posterior beliefs over policies, i.e. a vector containing one posterior probability per policy. + G: 1D ``numpy.ndarray`` + Negative expected free energies of each policy, i.e. a vector containing one negative expected free energy per policy. + """ + + num_obs, num_states, num_modalities, num_factors = utils.get_model_dimensions(A, B) + horizon = len(qs_seq_pi[0]) + num_policies = len(qs_seq_pi) + + qo_seq = utils.obj_array(horizon) + for t in range(horizon): + qo_seq[t] = utils.obj_array_zeros(num_obs) + + # initialise expected observations + qo_seq_pi = utils.obj_array(num_policies) + + # initialize (negative) expected free energies for all policies + G = np.zeros(num_policies) + + if F is None: + F = spm_log_single(np.ones(num_policies) / num_policies) + + if E is None: + lnE = spm_log_single(np.ones(num_policies) / num_policies) + else: + lnE = spm_log_single(E) + + + for p_idx, policy in enumerate(policies): + + qo_seq_pi[p_idx] = get_expected_obs(qs_seq_pi[p_idx], A) + + if use_utility: + G[p_idx] += calc_expected_utility(qo_seq_pi[p_idx], C) + + if use_states_info_gain: + G[p_idx] += calc_states_info_gain(A, qs_seq_pi[p_idx]) + + if use_param_info_gain: + if pA is not None: + G[p_idx] += calc_pA_info_gain(pA, qo_seq_pi[p_idx], qs_seq_pi[p_idx]) + if pB is not None: + G[p_idx] += calc_pB_info_gain(pB, qs_seq_pi[p_idx], prior, policy) + + q_pi = softmax(G * gamma - F + lnE) + + return q_pi, G + + +def update_posterior_policies( + qs, + A, + B, + C, + policies, + use_utility=True, + use_states_info_gain=True, + use_param_info_gain=False, + pA=None, + pB=None, + E = None, + gamma=16.0 +): + """ + Update posterior beliefs about policies by computing expected free energy of each policy and integrating that + with the prior over policies ``E``. This is intended to be used in conjunction + with the ``update_posterior_states`` method of the ``inference`` module, since only the posterior about the hidden states at the current timestep + ``qs`` is assumed to be provided, unconditional on policies. The predictive posterior over hidden states under all policies Q(s, pi) is computed + using the starting posterior about states at the current timestep ``qs`` and the generative model (e.g. ``A``, ``B``, ``C``) + + Parameters + ---------- + qs: ``numpy.ndarray`` of dtype object + Marginal posterior beliefs over hidden states at current timepoint (unconditioned on policies) + A: ``numpy.ndarray`` of dtype object + Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of + stores an ``numpy.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store + the probability of observation level ``i`` given hidden state levels ``j, k, ...`` + B: ``numpy.ndarray`` of dtype object + Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. + Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability + of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. + C: ``numpy.ndarray`` of dtype object + Prior over observations or 'prior preferences', storing the "value" of each outcome in terms of relative log probabilities. + This is softmaxed to form a proper probability distribution before being used to compute the expected utility term of the expected free energy. + policies: ``list`` of 2D ``numpy.ndarray`` + ``list`` that stores each policy in ``policies[p_idx]``. Shape of ``policies[p_idx]`` is ``(num_timesteps, num_factors)`` where `num_timesteps` is the temporal + depth of the policy and ``num_factors`` is the number of control factors. + use_utility: ``Bool``, default ``True`` + Boolean flag that determines whether expected utility should be incorporated into computation of EFE. + use_states_info_gain: ``Bool``, default ``True`` + Boolean flag that determines whether state epistemic value (info gain about hidden states) should be incorporated into computation of EFE. + use_param_info_gain: ``Bool``, default ``False`` + Boolean flag that determines whether parameter epistemic value (info gain about generative model parameters) should be incorporated into computation of EFE. + pA: ``numpy.ndarray`` of dtype object, optional + Dirichlet parameters over observation model (same shape as ``A``) + pB: ``numpy.ndarray`` of dtype object, optional + Dirichlet parameters over transition model (same shape as ``B``) + E: 1D ``numpy.ndarray``, optional + Vector of prior probabilities of each policy (what's referred to in the active inference literature as "habits") + gamma: float, default 16.0 + Prior precision over policies, scales the contribution of the expected free energy to the posterior over policies + + Returns + ---------- + q_pi: 1D ``numpy.ndarray`` + Posterior beliefs over policies, i.e. a vector containing one posterior probability per policy. + G: 1D ``numpy.ndarray`` + Negative expected free energies of each policy, i.e. a vector containing one negative expected free energy per policy. + """ + + n_policies = len(policies) + G = np.zeros(n_policies) + q_pi = np.zeros((n_policies, 1)) + + if E is None: + lnE = spm_log_single(np.ones(n_policies) / n_policies) + else: + lnE = spm_log_single(E) + + for idx, policy in enumerate(policies): + qs_pi = get_expected_states(qs, B, policy) + qo_pi = get_expected_obs(qs_pi, A) + + if use_utility: + G[idx] += calc_expected_utility(qo_pi, C) + + if use_states_info_gain: + G[idx] += calc_states_info_gain(A, qs_pi) + + if use_param_info_gain: + if pA is not None: + G[idx] += calc_pA_info_gain(pA, qo_pi, qs_pi) + if pB is not None: + G[idx] += calc_pB_info_gain(pB, qs_pi, qs, policy) + + q_pi = softmax(G * gamma + lnE) + + return q_pi, G + +def get_expected_states(qs, B, policy): + """ + Compute the expected states under a policy, also known as the posterior predictive density over states + + Parameters + ---------- + qs: ``numpy.ndarray`` of dtype object + Marginal posterior beliefs over hidden states at a given timepoint. + B: ``numpy.ndarray`` of dtype object + Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. + Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability + of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. + policy: 2D ``numpy.ndarray`` + Array that stores actions entailed by a policy over time. Shape is ``(num_timesteps, num_factors)`` where ``num_timesteps`` is the temporal + depth of the policy and ``num_factors`` is the number of control factors. + + Returns + ------- + qs_pi: ``list`` of ``numpy.ndarray`` of dtype object + Predictive posterior beliefs over hidden states expected under the policy, where ``qs_pi[t]`` stores the beliefs about + hidden states expected under the policy at time ``t`` + """ + n_steps = policy.shape[0] + n_factors = policy.shape[1] + + # initialise posterior predictive density as a list of beliefs over time, including current posterior beliefs about hidden states as the first element + qs_pi = [qs] + [utils.obj_array(n_factors) for t in range(n_steps)] + + # get expected states over time + for t in range(n_steps): + for control_factor, action in enumerate(policy[t,:]): + qs_pi[t+1][control_factor] = B[control_factor][:,:,int(action)].dot(qs_pi[t][control_factor]) + + return qs_pi[1:] + + +def get_expected_obs(qs_pi, A): + """ + Compute the expected observations under a policy, also known as the posterior predictive density over observations + + Parameters + ---------- + qs_pi: ``list`` of ``numpy.ndarray`` of dtype object + Predictive posterior beliefs over hidden states expected under the policy, where ``qs_pi[t]`` stores the beliefs about + hidden states expected under the policy at time ``t`` + A: ``numpy.ndarray`` of dtype object + Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of + stores an ``numpy.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store + the probability of observation level ``i`` given hidden state levels ``j, k, ...`` + + Returns + ------- + qo_pi: ``list`` of ``numpy.ndarray`` of dtype object + Predictive posterior beliefs over observations expected under the policy, where ``qo_pi[t]`` stores the beliefs about + observations expected under the policy at time ``t`` + """ + + n_steps = len(qs_pi) # each element of the list is the PPD at a different timestep + + # initialise expected observations + qo_pi = [] + + for t in range(n_steps): + qo_pi_t = utils.obj_array(len(A)) + qo_pi.append(qo_pi_t) + + # compute expected observations over time + for t in range(n_steps): + for modality, A_m in enumerate(A): + qo_pi[t][modality] = spm_dot(A_m, qs_pi[t]) + + return qo_pi + +def calc_expected_utility(qo_pi, C): + """ + Computes the expected utility of a policy, using the observation distribution expected under that policy and a prior preference vector. + + Parameters + ---------- + qo_pi: ``list`` of ``numpy.ndarray`` of dtype object + Predictive posterior beliefs over observations expected under the policy, where ``qo_pi[t]`` stores the beliefs about + observations expected under the policy at time ``t`` + C: ``numpy.ndarray`` of dtype object + Prior over observations or 'prior preferences', storing the "value" of each outcome in terms of relative log probabilities. + This is softmaxed to form a proper probability distribution before being used to compute the expected utility. + + Returns + ------- + expected_util: float + Utility (reward) expected under the policy in question + """ + n_steps = len(qo_pi) + + # initialise expected utility + expected_util = 0 + + # loop over time points and modalities + num_modalities = len(C) + + # reformat C to be tiled across timesteps, if it's not already + modalities_to_tile = [modality_i for modality_i in range(num_modalities) if C[modality_i].ndim == 1] + + # make a deepcopy of C where it has been tiled across timesteps + C_tiled = copy.deepcopy(C) + for modality in modalities_to_tile: + C_tiled[modality] = np.tile(C[modality][:,None], (1, n_steps) ) + + C_prob = softmax_obj_arr(C_tiled) # convert relative log probabilities into proper probability distribution + + for t in range(n_steps): + for modality in range(num_modalities): + + lnC = spm_log_single(C_prob[modality][:, t]) + expected_util += qo_pi[t][modality].dot(lnC) + + return expected_util + + +def calc_states_info_gain(A, qs_pi): + """ + Computes the Bayesian surprise or information gain about states of a policy, + using the observation model and the hidden state distribution expected under that policy. + + Parameters + ---------- + A: ``numpy.ndarray`` of dtype object + Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of + stores an ``numpy.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store + the probability of observation level ``i`` given hidden state levels ``j, k, ...`` + qs_pi: ``list`` of ``numpy.ndarray`` of dtype object + Predictive posterior beliefs over hidden states expected under the policy, where ``qs_pi[t]`` stores the beliefs about + hidden states expected under the policy at time ``t`` + + Returns + ------- + states_surprise: float + Bayesian surprise (about states) or salience expected under the policy in question + """ + + n_steps = len(qs_pi) + + states_surprise = 0 + for t in range(n_steps): + states_surprise += spm_MDP_G(A, qs_pi[t]) + + return states_surprise + + +def calc_pA_info_gain(pA, qo_pi, qs_pi): + """ + Compute expected Dirichlet information gain about parameters ``pA`` under a policy + + Parameters + ---------- + pA: ``numpy.ndarray`` of dtype object + Dirichlet parameters over observation model (same shape as ``A``) + qo_pi: ``list`` of ``numpy.ndarray`` of dtype object + Predictive posterior beliefs over observations expected under the policy, where ``qo_pi[t]`` stores the beliefs about + observations expected under the policy at time ``t`` + qs_pi: ``list`` of ``numpy.ndarray`` of dtype object + Predictive posterior beliefs over hidden states expected under the policy, where ``qs_pi[t]`` stores the beliefs about + hidden states expected under the policy at time ``t`` + + Returns + ------- + infogain_pA: float + Surprise (about Dirichlet parameters) expected under the policy in question + """ + + n_steps = len(qo_pi) + + num_modalities = len(pA) + wA = utils.obj_array(num_modalities) + for modality, pA_m in enumerate(pA): + wA[modality] = spm_wnorm(pA[modality]) + + pA_infogain = 0 + + for modality in range(num_modalities): + wA_modality = wA[modality] * (pA[modality] > 0).astype("float") + for t in range(n_steps): + pA_infogain -= qo_pi[t][modality].dot(spm_dot(wA_modality, qs_pi[t])[:, np.newaxis]) + + return pA_infogain + + +def calc_pB_info_gain(pB, qs_pi, qs_prev, policy): + """ + Compute expected Dirichlet information gain about parameters ``pB`` under a given policy + + Parameters + ---------- + pB: ``numpy.ndarray`` of dtype object + Dirichlet parameters over transition model (same shape as ``B``) + qs_pi: ``list`` of ``numpy.ndarray`` of dtype object + Predictive posterior beliefs over hidden states expected under the policy, where ``qs_pi[t]`` stores the beliefs about + hidden states expected under the policy at time ``t`` + qs_prev: ``numpy.ndarray`` of dtype object + Posterior over hidden states at beginning of trajectory (before receiving observations) + policy: 2D ``numpy.ndarray`` + Array that stores actions entailed by a policy over time. Shape is ``(num_timesteps, num_factors)`` where ``num_timesteps`` is the temporal + depth of the policy and ``num_factors`` is the number of control factors. + + Returns + ------- + infogain_pB: float + Surprise (about dirichlet parameters) expected under the policy in question + """ + + n_steps = len(qs_pi) + + num_factors = len(pB) + wB = utils.obj_array(num_factors) + for factor, pB_f in enumerate(pB): + wB[factor] = spm_wnorm(pB_f) + + pB_infogain = 0 + + for t in range(n_steps): + # the 'past posterior' used for the information gain about pB here is the posterior + # over expected states at the timestep previous to the one under consideration + # if we're on the first timestep, we just use the latest posterior in the + # entire action-perception cycle as the previous posterior + if t == 0: + previous_qs = qs_prev + # otherwise, we use the expected states for the timestep previous to the timestep under consideration + else: + previous_qs = qs_pi[t - 1] + + # get the list of action-indices for the current timestep + policy_t = policy[t, :] + for factor, a_i in enumerate(policy_t): + wB_factor_t = wB[factor][:, :, int(a_i)] * (pB[factor][:, :, int(a_i)] > 0).astype("float") + pB_infogain -= qs_pi[t][factor].dot(wB_factor_t.dot(previous_qs[factor])) + + return pB_infogain + +def construct_policies(num_states, num_controls = None, policy_len=1, control_fac_idx=None): + """ + Generate a ``list`` of policies. The returned array ``policies`` is a ``list`` that stores one policy per entry. + A particular policy (``policies[i]``) has shape ``(num_timesteps, num_factors)`` + where ``num_timesteps`` is the temporal depth of the policy and ``num_factors`` is the number of control factors. + + Parameters + ---------- + num_states: ``list`` of ``int`` + ``list`` of the dimensionalities of each hidden state factor + num_controls: ``list`` of ``int``, default ``None`` + ``list`` of the dimensionalities of each control state factor. If ``None``, then is automatically computed as the dimensionality of each hidden state factor that is controllable + policy_len: ``int``, default 1 + temporal depth ("planning horizon") of policies + control_fac_idx: ``list`` of ``int`` + ``list`` of indices of the hidden state factors that are controllable (i.e. those state factors ``i`` where ``num_controls[i] > 1``) + + Returns + ---------- + policies: ``list`` of 2D ``numpy.ndarray`` + ``list`` that stores each policy as a 2D array in ``policies[p_idx]``. Shape of ``policies[p_idx]`` + is ``(num_timesteps, num_factors)`` where ``num_timesteps`` is the temporal + depth of the policy and ``num_factors`` is the number of control factors. + """ + + num_factors = len(num_states) + if control_fac_idx is None: + if num_controls is not None: + control_fac_idx = [f for f, n_c in enumerate(num_controls) if n_c > 1] + else: + control_fac_idx = list(range(num_factors)) + + if num_controls is None: + num_controls = [num_states[c_idx] if c_idx in control_fac_idx else 1 for c_idx in range(num_factors)] + + x = num_controls * policy_len + policies = list(itertools.product(*[list(range(i)) for i in x])) + for pol_i in range(len(policies)): + policies[pol_i] = np.array(policies[pol_i]).reshape(policy_len, num_factors) + + return policies + +def get_num_controls_from_policies(policies): + """ + Calculates the ``list`` of dimensionalities of control factors (``num_controls``) + from the ``list`` or array of policies. This assumes a policy space such that for each control factor, there is at least + one policy that entails taking the action with the maximum index along that control factor. + + Parameters + ---------- + policies: ``list`` of 2D ``numpy.ndarray`` + ``list`` that stores each policy as a 2D array in ``policies[p_idx]``. Shape of ``policies[p_idx]`` + is ``(num_timesteps, num_factors)`` where ``num_timesteps`` is the temporal + depth of the policy and ``num_factors`` is the number of control factors. + + Returns + ---------- + num_controls: ``list`` of ``int`` + ``list`` of the dimensionalities of each control state factor, computed here automatically from a ``list`` of policies. + """ + + return list(np.max(np.vstack(policies), axis = 0) + 1) + + +def sample_action(q_pi, policies, num_controls, action_selection="deterministic", alpha = 16.0): + """ + Computes the marginal posterior over actions and then samples an action from it, one action per control factor. + + Parameters + ---------- + q_pi: 1D ``numpy.ndarray`` + Posterior beliefs over policies, i.e. a vector containing one posterior probability per policy. + policies: ``list`` of 2D ``numpy.ndarray`` + ``list`` that stores each policy as a 2D array in ``policies[p_idx]``. Shape of ``policies[p_idx]`` + is ``(num_timesteps, num_factors)`` where ``num_timesteps`` is the temporal + depth of the policy and ``num_factors`` is the number of control factors. + num_controls: ``list`` of ``int`` + ``list`` of the dimensionalities of each control state factor. + action_selection: string, default "deterministic" + String indicating whether whether the selected action is chosen as the maximum of the posterior over actions, + or whether it's sampled from the posterior marginal over actions + alpha: float, default 16.0 + Action selection precision -- the inverse temperature of the softmax that is used to scale the + action marginals before sampling. This is only used if ``action_selection`` argument is "stochastic" + + Returns + ---------- + selected_policy: 1D ``numpy.ndarray`` + Vector containing the indices of the actions for each control factor + """ + + num_factors = len(num_controls) + + action_marginals = utils.obj_array_zeros(num_controls) + + # weight each action according to its integrated posterior probability over policies and timesteps + # for pol_idx, policy in enumerate(policies): + # for t in range(policy.shape[0]): + # for factor_i, action_i in enumerate(policy[t, :]): + # action_marginals[factor_i][action_i] += q_pi[pol_idx] + + # weight each action according to its integrated posterior probability under all policies at the current timestep + for pol_idx, policy in enumerate(policies): + for factor_i, action_i in enumerate(policy[0, :]): + action_marginals[factor_i][action_i] += q_pi[pol_idx] + + action_marginals = utils.norm_dist_obj_arr(action_marginals) + + selected_policy = np.zeros(num_factors) + for factor_i in range(num_factors): + + # Either you do this: + if action_selection == 'deterministic': + selected_policy[factor_i] = np.argmax(action_marginals[factor_i]) + elif action_selection == 'stochastic': + p_actions = softmax(action_marginals[factor_i] * alpha) + selected_policy[factor_i] = utils.sample(p_actions) + + return selected_policy diff --git a/pymdp/jax/inference.py b/pymdp/jax/inference.py new file mode 100644 index 00000000..8a77e74c --- /dev/null +++ b/pymdp/jax/inference.py @@ -0,0 +1,243 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# pylint: disable=no-member + +import numpy as np + +from pymdp import utils +from pymdp.maths import get_joint_likelihood_seq +from pymdp.algos import run_vanilla_fpi, run_mmp, _run_mmp_testing + +VANILLA = "VANILLA" +VMP = "VMP" +MMP = "MMP" +BP = "BP" +EP = "EP" +CV = "CV" + +def update_posterior_states_full( + A, + B, + prev_obs, + policies, + prev_actions=None, + prior=None, + policy_sep_prior = True, + **kwargs, +): + """ + Update posterior over hidden states using marginal message passing + + Parameters + ---------- + A: ``numpy.ndarray`` of dtype object + Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of + stores an ``numpy.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store + the probability of observation level ``i`` given hidden state levels ``j, k, ...`` + B: ``numpy.ndarray`` of dtype object + Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. + Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability + of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. + prev_obs: ``list`` + List of observations over time. Each observation in the list can be an ``int``, a ``list`` of ints, a ``tuple`` of ints, a one-hot vector or an object array of one-hot vectors. + policies: ``list`` of 2D ``numpy.ndarray`` + List that stores each policy in ``policies[p_idx]``. Shape of ``policies[p_idx]`` is ``(num_timesteps, num_factors)`` where `num_timesteps` is the temporal + depth of the policy and ``num_factors`` is the number of control factors. + prior: ``numpy.ndarray`` of dtype object, default ``None`` + If provided, this a ``numpy.ndarray`` of dtype object, with one sub-array per hidden state factor, that stores the prior beliefs about initial states. + If ``None``, this defaults to a flat (uninformative) prior over hidden states. + policy_sep_prior: ``Bool``, default ``True`` + Flag determining whether the prior beliefs from the past are unconditioned on policy, or separated by /conditioned on the policy variable. + **kwargs: keyword arguments + Optional keyword arguments for the function ``algos.mmp.run_mmp`` + + Returns + --------- + qs_seq_pi: ``numpy.ndarray`` of dtype object + Posterior beliefs over hidden states for each policy. Nesting structure is policies, timepoints, factors, + where e.g. ``qs_seq_pi[p][t][f]`` stores the marginal belief about factor ``f`` at timepoint ``t`` under policy ``p``. + F: 1D ``numpy.ndarray`` + Vector of variational free energies for each policy + """ + + num_obs, num_states, num_modalities, num_factors = utils.get_model_dimensions(A, B) + + prev_obs = utils.process_observation_seq(prev_obs, num_modalities, num_obs) + + lh_seq = get_joint_likelihood_seq(A, prev_obs, num_states) + + if prev_actions is not None: + prev_actions = np.stack(prev_actions,0) + + qs_seq_pi = utils.obj_array(len(policies)) + F = np.zeros(len(policies)) # variational free energy of policies + + for p_idx, policy in enumerate(policies): + + # get sequence and the free energy for policy + qs_seq_pi[p_idx], F[p_idx] = run_mmp( + lh_seq, + B, + policy, + prev_actions=prev_actions, + prior= prior[p_idx] if policy_sep_prior else prior, + **kwargs + ) + + return qs_seq_pi, F + +def _update_posterior_states_full_test( + A, + B, + prev_obs, + policies, + prev_actions=None, + prior=None, + policy_sep_prior = True, + **kwargs, +): + """ + Update posterior over hidden states using marginal message passing (TEST VERSION, with extra returns for benchmarking). + + Parameters + ---------- + A: ``numpy.ndarray`` of dtype object + Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of + stores an ``np.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store + the probability of observation level ``i`` given hidden state levels ``j, k, ...`` + B: ``numpy.ndarray`` of dtype object + Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. + Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability + of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. + prev_obs: list + List of observations over time. Each observation in the list can be an ``int``, a ``list`` of ints, a ``tuple`` of ints, a one-hot vector or an object array of one-hot vectors. + prior: ``numpy.ndarray`` of dtype object, default None + If provided, this a ``numpy.ndarray`` of dtype object, with one sub-array per hidden state factor, that stores the prior beliefs about initial states. + If ``None``, this defaults to a flat (uninformative) prior over hidden states. + policy_sep_prior: Bool, default True + Flag determining whether the prior beliefs from the past are unconditioned on policy, or separated by /conditioned on the policy variable. + **kwargs: keyword arguments + Optional keyword arguments for the function ``algos.mmp.run_mmp`` + + Returns + -------- + qs_seq_pi: ``numpy.ndarray`` of dtype object + Posterior beliefs over hidden states for each policy. Nesting structure is policies, timepoints, factors, + where e.g. ``qs_seq_pi[p][t][f]`` stores the marginal belief about factor ``f`` at timepoint ``t`` under policy ``p``. + F: 1D ``numpy.ndarray`` + Vector of variational free energies for each policy + xn_seq_pi: ``numpy.ndarray`` of dtype object + Posterior beliefs over hidden states for each policy, for each iteration of marginal message passing. + Nesting structure is policy, iteration, factor, so ``xn_seq_p[p][itr][f]`` stores the ``num_states x infer_len`` + array of beliefs about hidden states at different time points of inference horizon. + vn_seq_pi: `numpy.ndarray`` of dtype object + Prediction errors over hidden states for each policy, for each iteration of marginal message passing. + Nesting structure is policy, iteration, factor, so ``vn_seq_p[p][itr][f]`` stores the ``num_states x infer_len`` + array of beliefs about hidden states at different time points of inference horizon. + """ + + num_obs, num_states, num_modalities, num_factors = utils.get_model_dimensions(A, B) + + prev_obs = utils.process_observation_seq(prev_obs, num_modalities, num_obs) + + lh_seq = get_joint_likelihood_seq(A, prev_obs, num_states) + + if prev_actions is not None: + prev_actions = np.stack(prev_actions,0) + + qs_seq_pi = utils.obj_array(len(policies)) + xn_seq_pi = utils.obj_array(len(policies)) + vn_seq_pi = utils.obj_array(len(policies)) + F = np.zeros(len(policies)) # variational free energy of policies + + for p_idx, policy in enumerate(policies): + + # get sequence and the free energy for policy + qs_seq_pi[p_idx], F[p_idx], xn_seq_pi[p_idx], vn_seq_pi[p_idx] = _run_mmp_testing( + lh_seq, + B, + policy, + prev_actions=prev_actions, + prior=prior[p_idx] if policy_sep_prior else prior, + **kwargs + ) + + return qs_seq_pi, F, xn_seq_pi, vn_seq_pi + +def average_states_over_policies(qs_pi, q_pi): + """ + This function computes a expected posterior over hidden states with respect to the posterior over policies, + also known as the 'Bayesian model average of states with respect to policies'. + + Parameters + ---------- + qs_pi: ``numpy.ndarray`` of dtype object + Posterior beliefs over hidden states for each policy. Nesting structure is policies, factors, + where e.g. ``qs_pi[p][f]`` stores the marginal belief about factor ``f`` under policy ``p``. + q_pi: ``numpy.ndarray`` of dtype object + Posterior beliefs about policies where ``len(q_pi) = num_policies`` + + Returns + --------- + qs_bma: ``numpy.ndarray`` of dtype object + Marginal posterior over hidden states for the current timepoint, + averaged across policies according to their posterior probability given by ``q_pi`` + """ + + num_factors = len(qs_pi[0]) # get the number of hidden state factors using the shape of the first-policy-conditioned posterior + num_states = [qs_f.shape[0] for qs_f in qs_pi[0]] # get the dimensionalities of each hidden state factor + + qs_bma = utils.obj_array(num_factors) + for f in range(num_factors): + qs_bma[f] = np.zeros(num_states[f]) + + for p_idx, policy_weight in enumerate(q_pi): + + for f in range(num_factors): + + qs_bma[f] += qs_pi[p_idx][f] * policy_weight + + return qs_bma + +def update_posterior_states(A, obs, prior=None, **kwargs): + """ + Update marginal posterior over hidden states using mean-field fixed point iteration + FPI or Fixed point iteration. + + See the following links for details: + http://www.cs.cmu.edu/~guestrin/Class/10708/recitations/r9/VI-view.pdf, slides 13- 18, and http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.137.221&rep=rep1&type=pdf, slides 24 - 38. + + Parameters + ---------- + A: ``numpy.ndarray`` of dtype object + Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of + stores an ``np.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store + the probability of observation level ``i`` given hidden state levels ``j, k, ...`` + obs: 1D ``numpy.ndarray``, ``numpy.ndarray`` of dtype object, int or tuple + The observation (generated by the environment). If single modality, this can be a 1D ``np.ndarray`` + (one-hot vector representation) or an ``int`` (observation index) + If multi-modality, this can be ``np.ndarray`` of dtype object whose entries are 1D one-hot vectors, + or a tuple (of ``int``) + prior: 1D ``numpy.ndarray`` or ``numpy.ndarray`` of dtype object, default None + Prior beliefs about hidden states, to be integrated with the marginal likelihood to obtain + a posterior distribution. If not provided, prior is set to be equal to a flat categorical distribution (at the level of + the individual inference functions). + **kwargs: keyword arguments + List of keyword/parameter arguments corresponding to parameter values for the fixed-point iteration + algorithm ``algos.fpi.run_vanilla_fpi.py`` + + Returns + ---------- + qs: 1D ``numpy.ndarray`` or ``numpy.ndarray`` of dtype object + Marginal posterior beliefs over hidden states at current timepoint + """ + + num_obs, num_states, num_modalities, num_factors = utils.get_model_dimensions(A = A) + + obs = utils.process_observation(obs, num_modalities, num_obs) + + if prior is not None: + prior = utils.to_obj_array(prior) + + return run_vanilla_fpi(A, obs, num_obs, num_states, prior, **kwargs) + diff --git a/pymdp/jax/learning.py b/pymdp/jax/learning.py new file mode 100644 index 00000000..bd694a6d --- /dev/null +++ b/pymdp/jax/learning.py @@ -0,0 +1,355 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# pylint: disable=no-member + +import numpy as np +from pymdp import utils, maths +import copy + +def update_obs_likelihood_dirichlet(pA, A, obs, qs, lr=1.0, modalities="all"): + """ + Update Dirichlet parameters of the observation likelihood distribution. + + Parameters + ----------- + pA: ``numpy.ndarray`` of dtype object + Prior Dirichlet parameters over observation model (same shape as ``A``) + A: ``numpy.ndarray`` of dtype object + Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of + stores an ``numpy.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store + the probability of observation level ``i`` given hidden state levels ``j, k, ...`` + obs: 1D ``numpy.ndarray``, ``numpy.ndarray`` of dtype object, ``int`` or ``tuple`` + The observation (generated by the environment). If single modality, this can be a 1D ``numpy.ndarray`` + (one-hot vector representation) or an ``int`` (observation index) + If multi-modality, this can be ``numpy.ndarray`` of dtype object whose entries are 1D one-hot vectors, + or a ``tuple`` (of ``int``) + qs: 1D ``numpy.ndarray`` or ``numpy.ndarray`` of dtype object, default None + Marginal posterior beliefs over hidden states at current timepoint. + lr: float, default 1.0 + Learning rate, scale of the Dirichlet pseudo-count update. + modalities: ``list``, default "all" + Indices (ranging from 0 to ``n_modalities - 1``) of the observation modalities to include + in learning. Defaults to "all", meaning that modality-specific sub-arrays of ``pA`` + are all updated using the corresponding observations. + + Returns + ----------- + qA: ``numpy.ndarray`` of dtype object + Posterior Dirichlet parameters over observation model (same shape as ``A``), after having updated it with observations. + """ + + + num_modalities = len(pA) + num_observations = [pA[modality].shape[0] for modality in range(num_modalities)] + + obs_processed = utils.process_observation(obs, num_modalities, num_observations) + obs = utils.to_obj_array(obs_processed) + + if modalities == "all": + modalities = list(range(num_modalities)) + + qA = copy.deepcopy(pA) + + for modality in modalities: + dfda = maths.spm_cross(obs[modality], qs) + dfda = dfda * (A[modality] > 0).astype("float") + qA[modality] = qA[modality] + (lr * dfda) + + return qA + +def update_state_likelihood_dirichlet( + pB, B, actions, qs, qs_prev, lr=1.0, factors="all" +): + """ + Update Dirichlet parameters of the transition distribution. + + Parameters + ----------- + pB: ``numpy.ndarray`` of dtype object + Prior Dirichlet parameters over transition model (same shape as ``B``) + B: ``numpy.ndarray`` of dtype object + Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. + Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability + of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. + actions: 1D ``numpy.ndarray`` + A vector with length equal to the number of control factors, where each element contains the index of the action (for that control factor) performed at + a given timestep. + qs: 1D ``numpy.ndarray`` or ``numpy.ndarray`` of dtype object + Marginal posterior beliefs over hidden states at current timepoint. + qs_prev: 1D ``numpy.ndarray`` or ``numpy.ndarray`` of dtype object + Marginal posterior beliefs over hidden states at previous timepoint. + lr: float, default ``1.0`` + Learning rate, scale of the Dirichlet pseudo-count update. + factors: ``list``, default "all" + Indices (ranging from 0 to ``n_factors - 1``) of the hidden state factors to include + in learning. Defaults to "all", meaning that factor-specific sub-arrays of ``pB`` + are all updated using the corresponding hidden state distributions and actions. + + Returns + ----------- + qB: ``numpy.ndarray`` of dtype object + Posterior Dirichlet parameters over transition model (same shape as ``B``), after having updated it with state beliefs and actions. + """ + + num_factors = len(pB) + + qB = copy.deepcopy(pB) + + if factors == "all": + factors = list(range(num_factors)) + + for factor in factors: + dfdb = maths.spm_cross(qs[factor], qs_prev[factor]) + dfdb *= (B[factor][:, :, actions[factor]] > 0).astype("float") + qB[factor][:,:,int(actions[factor])] += (lr*dfdb) + + return qB + +def update_state_prior_dirichlet( + pD, qs, lr=1.0, factors="all" +): + """ + Update Dirichlet parameters of the initial hidden state distribution + (prior beliefs about hidden states at the beginning of the inference window). + + Parameters + ----------- + pD: ``numpy.ndarray`` of dtype object + Prior Dirichlet parameters over initial hidden state prior (same shape as ``qs``) + qs: 1D ``numpy.ndarray`` or ``numpy.ndarray`` of dtype object + Marginal posterior beliefs over hidden states at current timepoint + lr: float, default ``1.0`` + Learning rate, scale of the Dirichlet pseudo-count update. + factors: ``list``, default "all" + Indices (ranging from 0 to ``n_factors - 1``) of the hidden state factors to include + in learning. Defaults to "all", meaning that factor-specific sub-vectors of ``pD`` + are all updated using the corresponding hidden state distributions. + + Returns + ----------- + qD: ``numpy.ndarray`` of dtype object + Posterior Dirichlet parameters over initial hidden state prior (same shape as ``qs``), after having updated it with state beliefs. + """ + + num_factors = len(pD) + + qD = copy.deepcopy(pD) + + if factors == "all": + factors = list(range(num_factors)) + + for factor in factors: + idx = pD[factor] > 0 # only update those state level indices that have some prior probability + qD[factor][idx] += (lr * qs[factor][idx]) + + return qD + +def _prune_prior(prior, levels_to_remove, dirichlet = False): + """ + Function for pruning a prior Categorical distribution (e.g. C, D) + + Parameters + ----------- + prior: 1D ``numpy.ndarray`` or ``numpy.ndarray`` of dtype object + The vector(s) containing the priors over hidden states of a generative model, e.g. the prior over hidden states (``D`` vector). + levels_to_remove: ``list`` of ``int``, ``list`` of ``list`` + A ``list`` of the levels (indices of the support) to remove. If the prior in question has multiple hidden state factors / multiple observation modalities, + then this will be a ``list`` of ``list``, where each sub-list within ``levels_to_remove`` will contain the levels to prune for a particular hidden state factor or modality + dirichlet: ``Bool``, default ``False`` + A Boolean flag indicating whether the input vector(s) is/are a Dirichlet distribution, and therefore should not be normalized at the end. + @TODO: Instead, the dirichlet parameters from the pruned levels should somehow be re-distributed among the remaining levels + + Returns + ----------- + reduced_prior: 1D ``numpy.ndarray`` or ``numpy.ndarray`` of dtype object + The prior vector(s), after pruning, that lacks the hidden state or modality levels indexed by ``levels_to_remove`` + """ + + if utils.is_obj_array(prior): # in case of multiple hidden state factors + + assert all([type(levels) == list for levels in levels_to_remove]) + + num_factors = len(prior) + + reduced_prior = utils.obj_array(num_factors) + + factors_to_remove = [] + for f, s_i in enumerate(prior): # loop over factors (or modalities) + + ns = len(s_i) + levels_to_keep = list(set(range(ns)) - set(levels_to_remove[f])) + if len(levels_to_keep) == 0: + print(f'Warning... removing ALL levels of factor {f} - i.e. the whole hidden state factor is being removed\n') + factors_to_remove.append(f) + else: + if not dirichlet: + reduced_prior[f] = utils.norm_dist(s_i[levels_to_keep]) + else: + raise(NotImplementedError("Need to figure out how to re-distribute concentration parameters from pruned levels, across remaining levels")) + + + if len(factors_to_remove) > 0: + factors_to_keep = list(set(range(num_factors)) - set(factors_to_remove)) + reduced_prior = reduced_prior[factors_to_keep] + + else: # in case of one hidden state factor + + assert all([type(level_i) == int for level_i in levels_to_remove]) + + ns = len(prior) + levels_to_keep = list(set(range(ns)) - set(levels_to_remove)) + + if not dirichlet: + reduced_prior = utils.norm_dist(prior[levels_to_keep]) + else: + raise(NotImplementedError("Need to figure out how to re-distribute concentration parameters from pruned levels, across remaining levels")) + + return reduced_prior + +def _prune_A(A, obs_levels_to_prune, state_levels_to_prune, dirichlet = False): + """ + Function for pruning a observation likelihood model (with potentially multiple hidden state factors) + :meta private: + Parameters + ----------- + A: ``numpy.ndarray`` with ``ndim >= 2``, or ``numpy.ndarray`` of dtype object + Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of + stores an ``numpy.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store + the probability of observation level ``i`` given hidden state levels ``j, k, ...`` + obs_levels_to_prune: ``list`` of int or ``list`` of ``list``: + A ``list`` of the observation levels to remove. If the likelihood in question has multiple observation modalities, + then this will be a ``list`` of ``list``, where each sub-list within ``obs_levels_to_prune`` will contain the observation levels + to remove for a particular observation modality + state_levels_to_prune: ``list`` of ``int`` + A ``list`` of the hidden state levels to remove (this will be the same across modalities) + dirichlet: ``Bool``, default ``False`` + A Boolean flag indicating whether the input array(s) is/are a Dirichlet distribution, and therefore should not be normalized at the end. + @TODO: Instead, the dirichlet parameters from the pruned columns should somehow be re-distributed among the remaining columns + + Returns + ----------- + reduced_A: ``numpy.ndarray`` with ndim >= 2, or ``numpy.ndarray ``of dtype object + The observation model, after pruning, which lacks the observation or hidden state levels given by the arguments ``obs_levels_to_prune`` and ``state_levels_to_prune`` + """ + + columns_to_keep_list = [] + if utils.is_obj_array(A): + num_states = A[0].shape[1:] + for f, ns in enumerate(num_states): + indices_f = np.array( list(set(range(ns)) - set(state_levels_to_prune[f])), dtype = np.intp) + columns_to_keep_list.append(indices_f) + else: + num_states = A.shape[1] + indices = np.array( list(set(range(num_states)) - set(state_levels_to_prune)), dtype = np.intp ) + columns_to_keep_list.append(indices) + + if utils.is_obj_array(A): # in case of multiple observation modality + + assert all([type(o_m_levels) == list for o_m_levels in obs_levels_to_prune]) + + num_modalities = len(A) + + reduced_A = utils.obj_array(num_modalities) + + for m, A_i in enumerate(A): # loop over modalities + + no = A_i.shape[0] + rows_to_keep = np.array(list(set(range(no)) - set(obs_levels_to_prune[m])), dtype = np.intp) + + reduced_A[m] = A_i[np.ix_(rows_to_keep, *columns_to_keep_list)] + if not dirichlet: + reduced_A = utils.norm_dist_obj_arr(reduced_A) + else: + raise(NotImplementedError("Need to figure out how to re-distribute concentration parameters from pruned rows/columns, across remaining rows/columns")) + else: # in case of one observation modality + + assert all([type(o_levels_i) == int for o_levels_i in obs_levels_to_prune]) + + no = A.shape[0] + rows_to_keep = np.array(list(set(range(no)) - set(obs_levels_to_prune)), dtype = np.intp) + + reduced_A = A[np.ix_(rows_to_keep, *columns_to_keep_list)] + + if not dirichlet: + reduced_A = utils.norm_dist(reduced_A) + else: + raise(NotImplementedError("Need to figure out how to re-distribute concentration parameters from pruned rows/columns, across remaining rows/columns")) + + return reduced_A + +def _prune_B(B, state_levels_to_prune, action_levels_to_prune, dirichlet = False): + """ + Function for pruning a transition likelihood model (with potentially multiple hidden state factors) + + Parameters + ----------- + B: ``numpy.ndarray`` of ``ndim == 3`` or ``numpy.ndarray`` of dtype object + Dynamics likelihood mapping or 'transition model', mapping from hidden states at `t` to hidden states at `t+1`, given some control state `u`. + Each element B[f] of this object array stores a 3-D tensor for hidden state factor `f`, whose entries `B[f][s, v, u] store the probability + of hidden state level `s` at the current time, given hidden state level `v` and action `u` at the previous time. + state_levels_to_prune: ``list`` of ``int`` or ``list`` of ``list`` + A ``list`` of the state levels to remove. If the likelihood in question has multiple hidden state factors, + then this will be a ``list`` of ``list``, where each sub-list within ``state_levels_to_prune`` will contain the state levels + to remove for a particular hidden state factor + action_levels_to_prune: ``list`` of ``int`` or ``list`` of ``list`` + A ``list`` of the control state or action levels to remove. If the likelihood in question has multiple control state factors, + then this will be a ``list`` of ``list``, where each sub-list within ``action_levels_to_prune`` will contain the control state levels + to remove for a particular control state factor + dirichlet: ``Bool``, default ``False`` + A Boolean flag indicating whether the input array(s) is/are a Dirichlet distribution, and therefore should not be normalized at the end. + @TODO: Instead, the dirichlet parameters from the pruned rows/columns should somehow be re-distributed among the remaining rows/columns + + Returns + ----------- + reduced_B: ``numpy.ndarray`` of `ndim == 3` or ``numpy.ndarray`` of dtype object + The transition model, after pruning, which lacks the hidden state levels/action levels given by the arguments ``state_levels_to_prune`` and ``action_levels_to_prune`` + """ + + slices_to_keep_list = [] + + if utils.is_obj_array(B): + + num_controls = [B_arr.shape[2] for _, B_arr in enumerate(B)] + + for c, nc in enumerate(num_controls): + indices_c = np.array( list(set(range(nc)) - set(action_levels_to_prune[c])), dtype = np.intp) + slices_to_keep_list.append(indices_c) + else: + num_controls = B.shape[2] + slices_to_keep = np.array( list(set(range(num_controls)) - set(action_levels_to_prune)), dtype = np.intp ) + + if utils.is_obj_array(B): # in case of multiple hidden state factors + + assert all([type(ns_f_levels) == list for ns_f_levels in state_levels_to_prune]) + + num_factors = len(B) + + reduced_B = utils.obj_array(num_factors) + + for f, B_f in enumerate(B): # loop over modalities + + ns = B_f.shape[0] + states_to_keep = np.array(list(set(range(ns)) - set(state_levels_to_prune[f])), dtype = np.intp) + + reduced_B[f] = B_f[np.ix_(states_to_keep, states_to_keep, slices_to_keep_list[f])] + + if not dirichlet: + reduced_B = utils.norm_dist_obj_arr(reduced_B) + else: + raise(NotImplementedError("Need to figure out how to re-distribute concentration parameters from pruned rows/columns, across remaining rows/columns")) + + else: # in case of one hidden state factor + + assert all([type(state_level_i) == int for state_level_i in state_levels_to_prune]) + + ns = B.shape[0] + states_to_keep = np.array(list(set(range(ns)) - set(state_levels_to_prune)), dtype = np.intp) + + reduced_B = B[np.ix_(states_to_keep, states_to_keep, slices_to_keep)] + + if not dirichlet: + reduced_B = utils.norm_dist(reduced_B) + else: + raise(NotImplementedError("Need to figure out how to re-distribute concentration parameters from pruned rows/columns, across remaining rows/columns")) + + return reduced_B From a3d23c5d8d8c3698a0337a100f384f18e18159a9 Mon Sep 17 00:00:00 2001 From: conorheins Date: Wed, 16 Mar 2022 00:42:51 +0100 Subject: [PATCH 002/232] first steps of implementing fixed point iteration in `jax`. log-likelihood computation using jax functions complete --- pymdp/jax/algos.py | 8 ++ pymdp/jax/inference.py | 237 +---------------------------------------- pymdp/jax/maths.py | 18 ++++ 3 files changed, 29 insertions(+), 234 deletions(-) create mode 100644 pymdp/jax/algos.py create mode 100644 pymdp/jax/maths.py diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py new file mode 100644 index 00000000..aff1d167 --- /dev/null +++ b/pymdp/jax/algos.py @@ -0,0 +1,8 @@ +from maths import compute_likelihood + +def run_vanilla_fpi(A, obs, prior): + """ Vanilla fixed point iteration (jaxified) """ + + likelihood = compute_likelihood(obs, A) + + pass \ No newline at end of file diff --git a/pymdp/jax/inference.py b/pymdp/jax/inference.py index 8a77e74c..e48dfb50 100644 --- a/pymdp/jax/inference.py +++ b/pymdp/jax/inference.py @@ -4,240 +4,9 @@ import numpy as np -from pymdp import utils -from pymdp.maths import get_joint_likelihood_seq -from pymdp.algos import run_vanilla_fpi, run_mmp, _run_mmp_testing +from jax.algos import run_vanilla_fpi, run_mmp, _run_mmp_testing -VANILLA = "VANILLA" -VMP = "VMP" -MMP = "MMP" -BP = "BP" -EP = "EP" -CV = "CV" +def update_posterior_states(A, obs, prior=None): -def update_posterior_states_full( - A, - B, - prev_obs, - policies, - prev_actions=None, - prior=None, - policy_sep_prior = True, - **kwargs, -): - """ - Update posterior over hidden states using marginal message passing - - Parameters - ---------- - A: ``numpy.ndarray`` of dtype object - Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of - stores an ``numpy.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store - the probability of observation level ``i`` given hidden state levels ``j, k, ...`` - B: ``numpy.ndarray`` of dtype object - Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. - Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability - of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. - prev_obs: ``list`` - List of observations over time. Each observation in the list can be an ``int``, a ``list`` of ints, a ``tuple`` of ints, a one-hot vector or an object array of one-hot vectors. - policies: ``list`` of 2D ``numpy.ndarray`` - List that stores each policy in ``policies[p_idx]``. Shape of ``policies[p_idx]`` is ``(num_timesteps, num_factors)`` where `num_timesteps` is the temporal - depth of the policy and ``num_factors`` is the number of control factors. - prior: ``numpy.ndarray`` of dtype object, default ``None`` - If provided, this a ``numpy.ndarray`` of dtype object, with one sub-array per hidden state factor, that stores the prior beliefs about initial states. - If ``None``, this defaults to a flat (uninformative) prior over hidden states. - policy_sep_prior: ``Bool``, default ``True`` - Flag determining whether the prior beliefs from the past are unconditioned on policy, or separated by /conditioned on the policy variable. - **kwargs: keyword arguments - Optional keyword arguments for the function ``algos.mmp.run_mmp`` - - Returns - --------- - qs_seq_pi: ``numpy.ndarray`` of dtype object - Posterior beliefs over hidden states for each policy. Nesting structure is policies, timepoints, factors, - where e.g. ``qs_seq_pi[p][t][f]`` stores the marginal belief about factor ``f`` at timepoint ``t`` under policy ``p``. - F: 1D ``numpy.ndarray`` - Vector of variational free energies for each policy - """ - - num_obs, num_states, num_modalities, num_factors = utils.get_model_dimensions(A, B) - - prev_obs = utils.process_observation_seq(prev_obs, num_modalities, num_obs) - - lh_seq = get_joint_likelihood_seq(A, prev_obs, num_states) - - if prev_actions is not None: - prev_actions = np.stack(prev_actions,0) - - qs_seq_pi = utils.obj_array(len(policies)) - F = np.zeros(len(policies)) # variational free energy of policies - - for p_idx, policy in enumerate(policies): - - # get sequence and the free energy for policy - qs_seq_pi[p_idx], F[p_idx] = run_mmp( - lh_seq, - B, - policy, - prev_actions=prev_actions, - prior= prior[p_idx] if policy_sep_prior else prior, - **kwargs - ) - - return qs_seq_pi, F - -def _update_posterior_states_full_test( - A, - B, - prev_obs, - policies, - prev_actions=None, - prior=None, - policy_sep_prior = True, - **kwargs, -): - """ - Update posterior over hidden states using marginal message passing (TEST VERSION, with extra returns for benchmarking). - - Parameters - ---------- - A: ``numpy.ndarray`` of dtype object - Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of - stores an ``np.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store - the probability of observation level ``i`` given hidden state levels ``j, k, ...`` - B: ``numpy.ndarray`` of dtype object - Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. - Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability - of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. - prev_obs: list - List of observations over time. Each observation in the list can be an ``int``, a ``list`` of ints, a ``tuple`` of ints, a one-hot vector or an object array of one-hot vectors. - prior: ``numpy.ndarray`` of dtype object, default None - If provided, this a ``numpy.ndarray`` of dtype object, with one sub-array per hidden state factor, that stores the prior beliefs about initial states. - If ``None``, this defaults to a flat (uninformative) prior over hidden states. - policy_sep_prior: Bool, default True - Flag determining whether the prior beliefs from the past are unconditioned on policy, or separated by /conditioned on the policy variable. - **kwargs: keyword arguments - Optional keyword arguments for the function ``algos.mmp.run_mmp`` - - Returns - -------- - qs_seq_pi: ``numpy.ndarray`` of dtype object - Posterior beliefs over hidden states for each policy. Nesting structure is policies, timepoints, factors, - where e.g. ``qs_seq_pi[p][t][f]`` stores the marginal belief about factor ``f`` at timepoint ``t`` under policy ``p``. - F: 1D ``numpy.ndarray`` - Vector of variational free energies for each policy - xn_seq_pi: ``numpy.ndarray`` of dtype object - Posterior beliefs over hidden states for each policy, for each iteration of marginal message passing. - Nesting structure is policy, iteration, factor, so ``xn_seq_p[p][itr][f]`` stores the ``num_states x infer_len`` - array of beliefs about hidden states at different time points of inference horizon. - vn_seq_pi: `numpy.ndarray`` of dtype object - Prediction errors over hidden states for each policy, for each iteration of marginal message passing. - Nesting structure is policy, iteration, factor, so ``vn_seq_p[p][itr][f]`` stores the ``num_states x infer_len`` - array of beliefs about hidden states at different time points of inference horizon. - """ - - num_obs, num_states, num_modalities, num_factors = utils.get_model_dimensions(A, B) - - prev_obs = utils.process_observation_seq(prev_obs, num_modalities, num_obs) - - lh_seq = get_joint_likelihood_seq(A, prev_obs, num_states) - - if prev_actions is not None: - prev_actions = np.stack(prev_actions,0) - - qs_seq_pi = utils.obj_array(len(policies)) - xn_seq_pi = utils.obj_array(len(policies)) - vn_seq_pi = utils.obj_array(len(policies)) - F = np.zeros(len(policies)) # variational free energy of policies - - for p_idx, policy in enumerate(policies): - - # get sequence and the free energy for policy - qs_seq_pi[p_idx], F[p_idx], xn_seq_pi[p_idx], vn_seq_pi[p_idx] = _run_mmp_testing( - lh_seq, - B, - policy, - prev_actions=prev_actions, - prior=prior[p_idx] if policy_sep_prior else prior, - **kwargs - ) - - return qs_seq_pi, F, xn_seq_pi, vn_seq_pi - -def average_states_over_policies(qs_pi, q_pi): - """ - This function computes a expected posterior over hidden states with respect to the posterior over policies, - also known as the 'Bayesian model average of states with respect to policies'. - - Parameters - ---------- - qs_pi: ``numpy.ndarray`` of dtype object - Posterior beliefs over hidden states for each policy. Nesting structure is policies, factors, - where e.g. ``qs_pi[p][f]`` stores the marginal belief about factor ``f`` under policy ``p``. - q_pi: ``numpy.ndarray`` of dtype object - Posterior beliefs about policies where ``len(q_pi) = num_policies`` - - Returns - --------- - qs_bma: ``numpy.ndarray`` of dtype object - Marginal posterior over hidden states for the current timepoint, - averaged across policies according to their posterior probability given by ``q_pi`` - """ - - num_factors = len(qs_pi[0]) # get the number of hidden state factors using the shape of the first-policy-conditioned posterior - num_states = [qs_f.shape[0] for qs_f in qs_pi[0]] # get the dimensionalities of each hidden state factor - - qs_bma = utils.obj_array(num_factors) - for f in range(num_factors): - qs_bma[f] = np.zeros(num_states[f]) - - for p_idx, policy_weight in enumerate(q_pi): - - for f in range(num_factors): - - qs_bma[f] += qs_pi[p_idx][f] * policy_weight - - return qs_bma - -def update_posterior_states(A, obs, prior=None, **kwargs): - """ - Update marginal posterior over hidden states using mean-field fixed point iteration - FPI or Fixed point iteration. - - See the following links for details: - http://www.cs.cmu.edu/~guestrin/Class/10708/recitations/r9/VI-view.pdf, slides 13- 18, and http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.137.221&rep=rep1&type=pdf, slides 24 - 38. - - Parameters - ---------- - A: ``numpy.ndarray`` of dtype object - Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of - stores an ``np.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store - the probability of observation level ``i`` given hidden state levels ``j, k, ...`` - obs: 1D ``numpy.ndarray``, ``numpy.ndarray`` of dtype object, int or tuple - The observation (generated by the environment). If single modality, this can be a 1D ``np.ndarray`` - (one-hot vector representation) or an ``int`` (observation index) - If multi-modality, this can be ``np.ndarray`` of dtype object whose entries are 1D one-hot vectors, - or a tuple (of ``int``) - prior: 1D ``numpy.ndarray`` or ``numpy.ndarray`` of dtype object, default None - Prior beliefs about hidden states, to be integrated with the marginal likelihood to obtain - a posterior distribution. If not provided, prior is set to be equal to a flat categorical distribution (at the level of - the individual inference functions). - **kwargs: keyword arguments - List of keyword/parameter arguments corresponding to parameter values for the fixed-point iteration - algorithm ``algos.fpi.run_vanilla_fpi.py`` - - Returns - ---------- - qs: 1D ``numpy.ndarray`` or ``numpy.ndarray`` of dtype object - Marginal posterior beliefs over hidden states at current timepoint - """ - - num_obs, num_states, num_modalities, num_factors = utils.get_model_dimensions(A = A) - - obs = utils.process_observation(obs, num_modalities, num_obs) - - if prior is not None: - prior = utils.to_obj_array(prior) - - return run_vanilla_fpi(A, obs, num_obs, num_states, prior, **kwargs) + return run_vanilla_fpi(A, obs,prior) diff --git a/pymdp/jax/maths.py b/pymdp/jax/maths.py new file mode 100644 index 00000000..5923c800 --- /dev/null +++ b/pymdp/jax/maths.py @@ -0,0 +1,18 @@ +from jax import tree_util +import jax.numpy as jnp + +def compute_likelihood_single_modality(o_m, A_m): + """ Compute observation likelihood for a single modality (observation and likelihood)""" + expanded_obs = jnp.expand_dims(o_m, tuple(range(1,A_m.ndim))) + likelihood = (expanded_obs * A_m).sum(axis=0, keepdims=True).squeeze() + # return jnp.log(likelihood) + return likelihood + +def compute_likelihood(obs, A): + """ Compute likelihood over hidden states across observations from different modalities """ + result = tree_util.tree_map(compute_likelihood_single_modality, obs, A) + + # log_likelihood = jnp.stack(result, axis = 0).sum(axis=0) # if likelihoods were already logged at the single modality level + likelihood = jnp.prod(jnp.stack(result, axis = 0), axis=0) # if no-logging + + return likelihood From c96d5228d38c54d7b125dc0db490c22142937473 Mon Sep 17 00:00:00 2001 From: dimarkov Date: Mon, 28 Mar 2022 18:25:07 +0200 Subject: [PATCH 003/232] fpi implementation with jax --- pymdp/jax/algos.py | 54 ++++++++++++++++++++++++++++++++++++++++++---- pymdp/jax/maths.py | 30 +++++++++++++++++--------- 2 files changed, 70 insertions(+), 14 deletions(-) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index aff1d167..e6c65e89 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -1,8 +1,54 @@ -from maths import compute_likelihood +import jax.numpy as jnp +from jax import tree_util, jit, lax, nn -def run_vanilla_fpi(A, obs, prior): +from pymdp.jax.maths import compute_log_likelihood, log + +def add(x, y): + return x + y + +def marginal_log_likelihood(qs, log_likelihood, i): + x = qs[0] + for q in qs[1:]: + x = x[:, None] * q + + joint = log_likelihood * x + dims = (f for f in range(len(qs)) if f != i) + return joint.sum(dims)/qs[i] + +def run_vanilla_fpi(A, obs, prior, K=16): """ Vanilla fixed point iteration (jaxified) """ - likelihood = compute_likelihood(obs, A) + nf = len(prior) + factors = list(range(nf)) + # Step 1: Compute log likelihoods for each factor + ll = compute_log_likelihood(obs, A) + log_likelihoods = [ll] * nf + + # Step 2: Map prior to log space and create initial log-posterior + log_prior = tree_util.tree_map(log, prior) + log_q = tree_util.tree_map(jnp.zeros_like, prior) + + # Step 3: Iterate until convergence + def scan_fn(carry, t): + log_q = carry + q = tree_util.tree_map(nn.softmax, log_q) + mll = tree_util.Partial(marginal_log_likelihood, q) + marginal_ll = tree_util.tree_map(mll, log_likelihoods, factors) + + log_q = tree_util.tree_map(add, marginal_ll, log_prior) + + return log_q, None + + res, _ = lax.scan(scan_fn, log_q, jnp.arange(K)) + + # Step 4: Map result to factorised posterior + qs = tree_util.tree_map(nn.softmax, res) + return qs + +if __name__ == "__main__": + obs = [0, 1, 2] + A = [jnp.ones((3, 2, 2))/3] * 3 + prior = [jnp.ones(2)/2] * 2 + + print(jit(run_vanilla_fpi)(A, obs, prior)) - pass \ No newline at end of file diff --git a/pymdp/jax/maths.py b/pymdp/jax/maths.py index 5923c800..26aafc76 100644 --- a/pymdp/jax/maths.py +++ b/pymdp/jax/maths.py @@ -1,18 +1,28 @@ -from jax import tree_util +from jax import tree_util, nn, jit import jax.numpy as jnp -def compute_likelihood_single_modality(o_m, A_m): +MIN_VAL = -100 + +def log(x): + + return jnp.where(x > 0, jnp.log(x), MIN_VAL) + +def compute_log_likelihood_single_modality(o_m, A_m): """ Compute observation likelihood for a single modality (observation and likelihood)""" - expanded_obs = jnp.expand_dims(o_m, tuple(range(1,A_m.ndim))) + expanded_obs = jnp.expand_dims(nn.one_hot(o_m, A_m.shape[0]), tuple(range(1,A_m.ndim))) likelihood = (expanded_obs * A_m).sum(axis=0, keepdims=True).squeeze() - # return jnp.log(likelihood) - return likelihood + return log(likelihood) -def compute_likelihood(obs, A): +def compute_log_likelihood(obs, A): """ Compute likelihood over hidden states across observations from different modalities """ - result = tree_util.tree_map(compute_likelihood_single_modality, obs, A) + result = tree_util.tree_map(compute_log_likelihood_single_modality, obs, A) + + ll = jnp.sum(jnp.stack(result), 0) # if no-logging - # log_likelihood = jnp.stack(result, axis = 0).sum(axis=0) # if likelihoods were already logged at the single modality level - likelihood = jnp.prod(jnp.stack(result, axis = 0), axis=0) # if no-logging + return ll - return likelihood +if __name__ == '__main__': + obs = [0, 1, 2] + A = [jnp.ones((3, 2)) / 3] * 3 + res = jit(compute_log_likelihood)(obs, A) + print(res) \ No newline at end of file From 2dee7b1934fe0e1774a753f8f5ee5fa1e2c9b901 Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 1 Apr 2022 23:09:26 +0200 Subject: [PATCH 004/232] compute_log_likelihood already assumes onehot observations --- pymdp/jax/maths.py | 22 +++++++++++++--------- 1 file changed, 13 insertions(+), 9 deletions(-) diff --git a/pymdp/jax/maths.py b/pymdp/jax/maths.py index 26aafc76..c973b89e 100644 --- a/pymdp/jax/maths.py +++ b/pymdp/jax/maths.py @@ -3,26 +3,30 @@ MIN_VAL = -100 -def log(x): +def log_stable(x): return jnp.where(x > 0, jnp.log(x), MIN_VAL) def compute_log_likelihood_single_modality(o_m, A_m): """ Compute observation likelihood for a single modality (observation and likelihood)""" - expanded_obs = jnp.expand_dims(nn.one_hot(o_m, A_m.shape[0]), tuple(range(1,A_m.ndim))) + # expanded_obs = jnp.expand_dims(nn.one_hot(o_m, A_m.shape[0]), tuple(range(1,A_m.ndim))) + expanded_obs = jnp.expand_dims(o_m, tuple(range(1,A_m.ndim))) likelihood = (expanded_obs * A_m).sum(axis=0, keepdims=True).squeeze() - return log(likelihood) + return log_stable(likelihood) def compute_log_likelihood(obs, A): """ Compute likelihood over hidden states across observations from different modalities """ result = tree_util.tree_map(compute_log_likelihood_single_modality, obs, A) - ll = jnp.sum(jnp.stack(result), 0) # if no-logging + ll = jnp.sum(jnp.stack(result), 0) return ll -if __name__ == '__main__': - obs = [0, 1, 2] - A = [jnp.ones((3, 2)) / 3] * 3 - res = jit(compute_log_likelihood)(obs, A) - print(res) \ No newline at end of file +# if __name__ == '__main__': +# obs = [0, 1, 2] +# A = [jnp.ones((3, 2)) / 3] * 3 +# # obs_vec = [nn.one_hot(o_m, A[m].shape[0]) for m, o_m in enumerate(obs)] +# # res = jit(compute_log_likelihood)(obs_vec, A) +# res = jit(compute_log_likelihood)(obs, A) + +# print(res) \ No newline at end of file From 3a8995433f6d33ad55fee1b57feea006cfbd063d Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 1 Apr 2022 23:09:46 +0200 Subject: [PATCH 005/232] some variable renaming --- pymdp/jax/algos.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index e6c65e89..963b339c 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -1,7 +1,7 @@ import jax.numpy as jnp from jax import tree_util, jit, lax, nn -from pymdp.jax.maths import compute_log_likelihood, log +from pymdp.jax.maths import compute_log_likelihood, log_stable def add(x, y): return x + y @@ -15,7 +15,7 @@ def marginal_log_likelihood(qs, log_likelihood, i): dims = (f for f in range(len(qs)) if f != i) return joint.sum(dims)/qs[i] -def run_vanilla_fpi(A, obs, prior, K=16): +def run_vanilla_fpi(A, obs, prior, num_iter=16): """ Vanilla fixed point iteration (jaxified) """ nf = len(prior) @@ -25,7 +25,7 @@ def run_vanilla_fpi(A, obs, prior, K=16): log_likelihoods = [ll] * nf # Step 2: Map prior to log space and create initial log-posterior - log_prior = tree_util.tree_map(log, prior) + log_prior = tree_util.tree_map(log_stable, prior) log_q = tree_util.tree_map(jnp.zeros_like, prior) # Step 3: Iterate until convergence @@ -39,7 +39,7 @@ def scan_fn(carry, t): return log_q, None - res, _ = lax.scan(scan_fn, log_q, jnp.arange(K)) + res, _ = lax.scan(scan_fn, log_q, jnp.arange(num_iter)) # Step 4: Map result to factorised posterior qs = tree_util.tree_map(nn.softmax, res) @@ -49,6 +49,7 @@ def scan_fn(carry, t): obs = [0, 1, 2] A = [jnp.ones((3, 2, 2))/3] * 3 prior = [jnp.ones(2)/2] * 2 - - print(jit(run_vanilla_fpi)(A, obs, prior)) + obs_vec = [nn.one_hot(o_m, A[m].shape[0]) for m, o_m in enumerate(obs)] + print(jit(run_vanilla_fpi)(A, obs_vec, prior)) + # print(jit(run_vanilla_fpi)(A, obs, prior)) From e89a2fb36463c980f7f14ade03609d33081b9ca8 Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 1 Apr 2022 23:10:07 +0200 Subject: [PATCH 006/232] unit test comparing JAX accelerated fixed-point iteration vs standard numpy version --- pymdp/jax/__init__.py | 1 + test/test_inference_jax.py | 59 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 60 insertions(+) create mode 100644 test/test_inference_jax.py diff --git a/pymdp/jax/__init__.py b/pymdp/jax/__init__.py index e69de29b..d5094bc6 100644 --- a/pymdp/jax/__init__.py +++ b/pymdp/jax/__init__.py @@ -0,0 +1 @@ +from . import algos diff --git a/test/test_inference_jax.py b/test/test_inference_jax.py new file mode 100644 index 00000000..b9c133ef --- /dev/null +++ b/test/test_inference_jax.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +""" Unit Tests +__author__: Dimitrije Markovic, Conor Heins +""" + +import os +import unittest + +import numpy as np +import jax.numpy as jnp + +from pymdp.jax.algos import run_vanilla_fpi as fpi_jax +from pymdp.algos import run_vanilla_fpi as fpi_numpy +from pymdp import utils, maths + +class TestInferenceJax(unittest.TestCase): + + def test_fixed_point_iteration(self): + """ + Tests the jax-ified version of mean-field fixed-point iteration against the original numpy version + """ + + ''' Create a random generative model with a desired number/dimensionality of hidden state factors and observation modalities''' + + # fpi_jax throws an error (some broadcasting dimension mistmatch in `fpi_jax`) + num_states = [2, 2, 5] + num_obs = [5, 10] + + # fpi_jax executes and returns an answer, but it is numerically incorrect + # num_states = [2, 2, 2] + # num_obs = [5, 10] + + # this works and returns the right answer + # num_states = [4, 4] + # num_obs = [5, 10, 6] + + # numpy version + prior = utils.random_single_categorical(num_states) + A = utils.random_A_matrix(num_obs, num_states) + + obs_idx = [utils.sample(maths.spm_dot(a_m, prior)) for a_m in A] + obs = utils.process_observation(obs_idx, len(num_obs), num_obs) + + qs_numpy = fpi_numpy(A, obs, num_obs, num_states, prior=prior, num_iter=16, dF=1.0, dF_tol=-1.0) # set dF_tol to negative number so FPI never stops due to convergence + + # jax version + prior = [jnp.array(prior_f) for prior_f in prior] + A = [jnp.array(a_m) for a_m in A] + obs = [jnp.array(o_m) for o_m in obs] + + qs_jax = fpi_jax(A, obs, prior, num_iter=16) + + for f, _ in enumerate(qs_jax): + self.assertTrue(np.allclose(qs_numpy[f], qs_jax[f])) + +if __name__ == "__main__": + unittest.main() \ No newline at end of file From 894652ccb4084c45bcc72db7b36cee94bf5ad19a Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Tue, 5 Apr 2022 20:06:50 +0200 Subject: [PATCH 007/232] fixed fpi and corrected numerics of the gradient --- examples/model_inversion.ipynb | 163 ++++----- pymdp/jax/agent.py | 30 +- pymdp/jax/algos.py | 26 +- pymdp/jax/control.py | 9 +- pymdp/jax/inference.py | 6 +- pymdp/jax/maths.py | 21 +- pymdp/jax/utils.py | 615 +++++++++++++++++++++++++++++++++ 7 files changed, 738 insertions(+), 132 deletions(-) create mode 100644 pymdp/jax/utils.py diff --git a/examples/model_inversion.ipynb b/examples/model_inversion.ipynb index e77b81b0..dcb5ab6a 100644 --- a/examples/model_inversion.ipynb +++ b/examples/model_inversion.ipynb @@ -602,7 +602,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 24, "metadata": { "scrolled": false }, @@ -612,15 +612,15 @@ "output_type": "stream", "text": [ " === Starting experiment === \n", - " Reward condition: Left, Observation: [CENTER, No reward, Cue Left]\n", - "[Step 0] Action: [Move to LEFT ARM]\n", - "[Step 0] Observation: [LEFT ARM, Reward!, Cue Right]\n", + " Reward condition: Left, Observation: [CENTER, No reward, Cue Right]\n", + "[Step 0] Action: [Move to CUE LOCATION]\n", + "[Step 0] Observation: [CUE LOCATION, No reward, Cue Left]\n", "[Step 1] Action: [Move to LEFT ARM]\n", - "[Step 1] Observation: [LEFT ARM, Reward!, Cue Right]\n", + "[Step 1] Observation: [LEFT ARM, Reward!, Cue Left]\n", "[Step 2] Action: [Move to LEFT ARM]\n", "[Step 2] Observation: [LEFT ARM, Reward!, Cue Left]\n", "[Step 3] Action: [Move to LEFT ARM]\n", - "[Step 3] Observation: [LEFT ARM, Reward!, Cue Right]\n", + "[Step 3] Observation: [LEFT ARM, Reward!, Cue Left]\n", "[Step 4] Action: [Move to LEFT ARM]\n", "[Step 4] Observation: [LEFT ARM, Reward!, Cue Left]\n" ] @@ -677,7 +677,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 25, "metadata": { "scrolled": false }, @@ -701,7 +701,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -737,7 +737,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -767,10 +767,11 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ + "import pymdp.jax.utils as jutil\n", "from pymdp.jax.agent import Agent\n", "\n", "def scan(step_fn, init, iterator):\n", @@ -783,9 +784,11 @@ "def model_log_likelihood(T, data, params):\n", " agent = Agent(params['A'], params['B'], C=params['C'], D=params['D'], control_fac_idx=controllable_indices) \n", " \n", - " def step_fn(carry, obs):\n", - " t, log_prob = carry\n", - " qx = agent.infer_states(obs)\n", + " def step_fn(carry, t):\n", + " agent, log_prob = carry\n", + " outcome = list(data['outcomes'][t])\n", + " qx = agent.infer_states(outcome)\n", + " print('qx', qx)\n", " q_pi, _ = agent.infer_policies()\n", " \n", " print('q_pi', type(q_pi))\n", @@ -794,7 +797,7 @@ " num_factors = len(nc)\n", " \n", " # marginal can be list and it still works\n", - " marginal = list(utils.obj_array_zeros(agent.num_controls))\n", + " marginal = jutil.list_array_zeros(agent.num_controls)\n", " print('marginal', type(marginal))\n", " print('agent.policies', type(agent.policies))\n", " \n", @@ -804,116 +807,87 @@ " for factor_i, action_i in enumerate(policy[0, :]):\n", " marginal[factor_i][action_i] += q_pi[pol_idx]\n", " print(marginal)\n", + " \n", + " action = data['actions'][t]\n", " for factor_idx, m in enumerate(marginal):\n", " log_prob += jnp.sum(jnp.log(m) * jax.nn.one_hot(action[factor_idx], nc[factor_idx]))\n", - " \n", - " agent.action = data['actions'][t]\n", - " \n", - " return (t + 1, log_prob)\n", + " \n", + " agent.action = action\n", + " \n", + " return (agent, log_prob)\n", " \n", " log_prob = 0.\n", - " init = (data['actions'][0], 0, log_prob)\n", - " return scan(step_fn, init, data['outcomes'][:-1])" + " init = (agent, log_prob)\n", + " return scan(step_fn, init, np.arange(T))" ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 29, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "q_pi \n", - "marginal \n", - "agent.policies \n", - "policy 0 \n", - "policy 1 \n", - "policy 2 \n", - "policy 3 \n", - "[array([1.07708275e-05, 1.47056773e-01, 1.47056773e-01, 7.05875683e-01]), array([1.])]\n", - "q_pi \n", - "marginal \n", - "agent.policies \n", - "policy 0 \n", - "policy 1 \n", - "policy 2 \n", - "policy 3 \n", - "[array([3.40439691e-08, 1.40201800e-07, 9.98237134e-01, 1.76269178e-03]), array([1.])]\n", - "q_pi \n", - "marginal \n", - "agent.policies \n", - "policy 0 \n", - "policy 1 \n", - "policy 2 \n", - "policy 3 \n", - "[array([3.40439691e-08, 1.40201800e-07, 9.98237134e-01, 1.76269178e-03]), array([1.])]\n", - "q_pi \n", - "marginal \n", - "agent.policies \n", - "policy 0 \n", - "policy 1 \n", - "policy 2 \n", - "policy 3 \n", - "[array([3.40439691e-08, 1.40201800e-07, 9.98237134e-01, 1.76269178e-03]), array([1.])]\n", - "q_pi \n", - "marginal \n", - "agent.policies \n", - "policy 0 \n", - "policy 1 \n", - "policy 2 \n", - "policy 3 \n", - "[array([3.40439691e-08, 1.40201800e-07, 9.98237134e-01, 1.76269178e-03]), array([1.])]\n" - ] - }, { "data": { "text/plain": [ - "DeviceArray(-1.9239942, dtype=float32)" + "{'actions': DeviceArray([[3., 0.],\n", + " [2., 0.],\n", + " [2., 0.],\n", + " [2., 0.],\n", + " [2., 0.]], dtype=float32),\n", + " 'outcomes': DeviceArray([[0, 0, 0],\n", + " [3, 0, 1],\n", + " [2, 1, 1],\n", + " [2, 1, 1],\n", + " [2, 1, 1],\n", + " [2, 1, 1]], dtype=int32)}" ] }, - "execution_count": 30, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# the following grad computation has to work for the Agent class to be differentiable and hence invertible\n", - "from functools import partial\n", - "\n", - "# for now this has to work\n", - "params = {\n", - " 'A': A_gp,\n", - " 'B': B_gp,\n", - " 'C': agent.C,\n", - " 'D': agent.D\n", - "}\n", - "\n", - "partial(model_log_likelihood, T, measurments)(params)" + "measurments" ] }, { "cell_type": "code", - "execution_count": 32, - "metadata": {}, + "execution_count": 30, + "metadata": { + "scrolled": true + }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "first step\n", + "[DeviceArray([1., 0., 0., 0.], dtype=float32), DeviceArray([0.5, 0.5], dtype=float32)]\n", + "qx [DeviceArray([1., 0., 0., 0.], dtype=float32), DeviceArray([9.9999988e-01, 1.1253516e-07], dtype=float32)]\n" + ] + }, { "ename": "TypeError", - "evalue": "A matrix must be a numpy array", + "evalue": "object of type 'NoneType' has no len()", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "Input \u001b[0;32mIn [32]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m params \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m 3\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mA\u001b[39m\u001b[38;5;124m'\u001b[39m: [jnp\u001b[38;5;241m.\u001b[39marray(x) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mlist\u001b[39m(A_gp)],\n\u001b[1;32m 4\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mB\u001b[39m\u001b[38;5;124m'\u001b[39m: [jnp\u001b[38;5;241m.\u001b[39marray(x) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mlist\u001b[39m(B_gp)],\n\u001b[1;32m 5\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mC\u001b[39m\u001b[38;5;124m'\u001b[39m: [jnp\u001b[38;5;241m.\u001b[39marray(x) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mlist\u001b[39m(agent\u001b[38;5;241m.\u001b[39mC)],\n\u001b[1;32m 6\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mD\u001b[39m\u001b[38;5;124m'\u001b[39m: [jnp\u001b[38;5;241m.\u001b[39marray(x) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mlist\u001b[39m(agent\u001b[38;5;241m.\u001b[39mD)]\n\u001b[1;32m 7\u001b[0m }\n\u001b[1;32m 9\u001b[0m \u001b[38;5;66;03m# grad computation cannot work \u001b[39;00m\n\u001b[0;32m---> 10\u001b[0m \u001b[43mjax\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgrad\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpartial\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel_log_likelihood\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mT\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmeasurments\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\n", - " \u001b[0;31m[... skipping hidden 10 frame]\u001b[0m\n", - "Input \u001b[0;32mIn [29]\u001b[0m, in \u001b[0;36mmodel_log_likelihood\u001b[0;34m(T, data, params)\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mmodel_log_likelihood\u001b[39m(T, data, params):\n\u001b[0;32m----> 9\u001b[0m agent \u001b[38;5;241m=\u001b[39m \u001b[43mAgent\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparams\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mA\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparams\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mB\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mC\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mC\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mD\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparams\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mD\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcontrol_fac_idx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcontrollable_indices\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 11\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mstep_fn\u001b[39m(carry, obs):\n\u001b[1;32m 12\u001b[0m action, t, log_prob \u001b[38;5;241m=\u001b[39m carry\n", - "File \u001b[0;32m/run/media/dima/data/Dropbox/development/python/pymdp/pymdp/agent.py:72\u001b[0m, in \u001b[0;36mAgent.__init__\u001b[0;34m(self, A, B, C, D, E, pA, pB, pD, num_controls, policy_len, inference_horizon, control_fac_idx, policies, gamma, use_utility, use_states_info_gain, use_param_info_gain, action_selection, inference_algo, inference_params, modalities_to_learn, lr_pA, factors_to_learn, lr_pB, lr_pD, use_BMA, policy_sep_prior, save_belief_hist)\u001b[0m\n\u001b[1;32m 70\u001b[0m \u001b[38;5;124;03m\"\"\" Initialise observation model (A matrices) \"\"\"\u001b[39;00m\n\u001b[1;32m 71\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(A, np\u001b[38;5;241m.\u001b[39mndarray):\n\u001b[0;32m---> 72\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\n\u001b[1;32m 73\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mA matrix must be a numpy array\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 74\u001b[0m )\n\u001b[1;32m 76\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mA \u001b[38;5;241m=\u001b[39m utils\u001b[38;5;241m.\u001b[39mto_obj_array(A)\n\u001b[1;32m 78\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m utils\u001b[38;5;241m.\u001b[39mis_normalized(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mA), \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mA matrix is not normalized (i.e. A.sum(axis = 0) must all equal 1.0\u001b[39m\u001b[38;5;124m\"\u001b[39m\n", - "\u001b[0;31mTypeError\u001b[0m: A matrix must be a numpy array" + "Input \u001b[0;32mIn [30]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m# parameters have to be jax arrays, lists or dictionaries of jax arrays\u001b[39;00m\n\u001b[1;32m 5\u001b[0m params \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m 6\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mA\u001b[39m\u001b[38;5;124m'\u001b[39m: [jnp\u001b[38;5;241m.\u001b[39marray(x) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mlist\u001b[39m(A_gp)],\n\u001b[1;32m 7\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mB\u001b[39m\u001b[38;5;124m'\u001b[39m: [jnp\u001b[38;5;241m.\u001b[39marray(x) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mlist\u001b[39m(B_gp)],\n\u001b[1;32m 8\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mC\u001b[39m\u001b[38;5;124m'\u001b[39m: [jnp\u001b[38;5;241m.\u001b[39marray(x) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mlist\u001b[39m(agent\u001b[38;5;241m.\u001b[39mC)],\n\u001b[1;32m 9\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mD\u001b[39m\u001b[38;5;124m'\u001b[39m: [jnp\u001b[38;5;241m.\u001b[39marray(x) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mlist\u001b[39m(agent\u001b[38;5;241m.\u001b[39mD)]\n\u001b[1;32m 10\u001b[0m }\n\u001b[0;32m---> 12\u001b[0m \u001b[43mpartial\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel_log_likelihood\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mT\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmeasurments\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\n", + "Input \u001b[0;32mIn [28]\u001b[0m, in \u001b[0;36mmodel_log_likelihood\u001b[0;34m(T, data, params)\u001b[0m\n\u001b[1;32m 46\u001b[0m log_prob \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0.\u001b[39m\n\u001b[1;32m 47\u001b[0m init \u001b[38;5;241m=\u001b[39m (agent, log_prob)\n\u001b[0;32m---> 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mscan\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstep_fn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minit\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43marange\u001b[49m\u001b[43m(\u001b[49m\u001b[43mT\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n", + "Input \u001b[0;32mIn [28]\u001b[0m, in \u001b[0;36mscan\u001b[0;34m(step_fn, init, iterator)\u001b[0m\n\u001b[1;32m 5\u001b[0m carry \u001b[38;5;241m=\u001b[39m init\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m itr \u001b[38;5;129;01min\u001b[39;00m iterator:\n\u001b[0;32m----> 7\u001b[0m carry \u001b[38;5;241m=\u001b[39m \u001b[43mstep_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcarry\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mitr\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 9\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m carry[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\n", + "Input \u001b[0;32mIn [28]\u001b[0m, in \u001b[0;36mmodel_log_likelihood..step_fn\u001b[0;34m(carry, t)\u001b[0m\n\u001b[1;32m 17\u001b[0m qx \u001b[38;5;241m=\u001b[39m agent\u001b[38;5;241m.\u001b[39minfer_states(outcome)\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mqx\u001b[39m\u001b[38;5;124m'\u001b[39m, qx)\n\u001b[0;32m---> 19\u001b[0m q_pi, _ \u001b[38;5;241m=\u001b[39m \u001b[43magent\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minfer_policies\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 21\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mq_pi\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;28mtype\u001b[39m(q_pi))\n\u001b[1;32m 23\u001b[0m nc \u001b[38;5;241m=\u001b[39m agent\u001b[38;5;241m.\u001b[39mnum_controls\n", + "File \u001b[0;32m/run/media/dima/data/Dropbox/development/python/pymdp/pymdp/jax/agent.py:294\u001b[0m, in \u001b[0;36mAgent.infer_policies\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 279\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21minfer_policies\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 280\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 281\u001b[0m \u001b[38;5;124;03m Perform policy inference by optimizing a posterior (categorical) distribution over policies.\u001b[39;00m\n\u001b[1;32m 282\u001b[0m \u001b[38;5;124;03m This distribution is computed as the softmax of ``G * gamma + lnE`` where ``G`` is the negative expected\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 291\u001b[0m \u001b[38;5;124;03m Negative expected free energies of each policy, i.e. a vector containing one negative expected free energy per policy.\u001b[39;00m\n\u001b[1;32m 292\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 294\u001b[0m q_pi, G \u001b[38;5;241m=\u001b[39m \u001b[43mcontrol\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mupdate_posterior_policies\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 295\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mqs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 296\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mA\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 297\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mB\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 298\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mC\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 299\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpolicies\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 300\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43muse_utility\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 301\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43muse_states_info_gain\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 302\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43muse_param_info_gain\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 303\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpA\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 304\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpB\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 305\u001b[0m \u001b[43m \u001b[49m\u001b[43mE\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mE\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 306\u001b[0m \u001b[43m \u001b[49m\u001b[43mgamma\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgamma\u001b[49m\n\u001b[1;32m 307\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 309\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mq_pi \u001b[38;5;241m=\u001b[39m q_pi\n\u001b[1;32m 310\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mG \u001b[38;5;241m=\u001b[39m G\n", + "File \u001b[0;32m/run/media/dima/data/Dropbox/development/python/pymdp/pymdp/jax/control.py:186\u001b[0m, in \u001b[0;36mupdate_posterior_policies\u001b[0;34m(qs, A, B, C, policies, use_utility, use_states_info_gain, use_param_info_gain, pA, pB, E, gamma)\u001b[0m\n\u001b[1;32m 124\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mupdate_posterior_policies\u001b[39m(\n\u001b[1;32m 125\u001b[0m qs,\n\u001b[1;32m 126\u001b[0m A,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 136\u001b[0m gamma\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m16.0\u001b[39m\n\u001b[1;32m 137\u001b[0m ):\n\u001b[1;32m 138\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 139\u001b[0m \u001b[38;5;124;03m Update posterior beliefs about policies by computing expected free energy of each policy and integrating that\u001b[39;00m\n\u001b[1;32m 140\u001b[0m \u001b[38;5;124;03m with the prior over policies ``E``. This is intended to be used in conjunction\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 183\u001b[0m \u001b[38;5;124;03m Negative expected free energies of each policy, i.e. a vector containing one negative expected free energy per policy.\u001b[39;00m\n\u001b[1;32m 184\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 186\u001b[0m n_policies \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mpolicies\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 187\u001b[0m G \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mzeros(n_policies)\n\u001b[1;32m 188\u001b[0m q_pi \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mzeros((n_policies, \u001b[38;5;241m1\u001b[39m))\n", + "\u001b[0;31mTypeError\u001b[0m: object of type 'NoneType' has no len()" ] } ], "source": [ + "# the following grad computation has to work for the Agent class to be differentiable and hence invertible\n", + "from functools import partial\n", + "\n", "# parameters have to be jax arrays, lists or dictionaries of jax arrays\n", "params = {\n", " 'A': [jnp.array(x) for x in list(A_gp)],\n", @@ -922,7 +896,16 @@ " 'D': [jnp.array(x) for x in list(agent.D)]\n", "}\n", "\n", - "# grad computation cannot work \n", + "partial(model_log_likelihood, T, measurments)(params)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# grad computation cannot work until everything is jaxified\n", "jax.grad(partial(model_log_likelihood, T, measurments))(params)" ] }, diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 1fcb4799..1a51d2eb 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -1,17 +1,15 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- -""" Agent Class +""" Agent Class iplementation in Jax -__author__: Conor Heins, Alexander Tschantz, Daphne Demekas, Brennan Klein +__author__: Conor Heins, Dimitrije Markovic, Alexander Tschantz, Daphne Demekas, Brennan Klein """ -import warnings -import numpy as np -from pymdp import inference, control, learning -from pymdp import utils, maths -import copy +import jax.numpy as jnp +from jax import nn +from . import inference, control, learning, utils, maths class Agent(object): """ @@ -231,7 +229,7 @@ def get_future_qs(self): return future_qs_seq - def infer_states(self, observation): + def infer_states(self, observations): """ Update approximate posterior over hidden states by solving variational inference problem, given an observation. @@ -251,7 +249,7 @@ def infer_states(self, observation): at timepoint ``t_idx``. """ - observation = tuple(observation) + # replace this if statement with self.empirical_prior = self.D if self.action is not None: empirical_prior = control.get_expected_states( @@ -259,17 +257,23 @@ def infer_states(self, observation): )[0] else: empirical_prior = self.D + + + o_vec = [nn.one_hot(o, self.A[i].shape[0]) for i, o in enumerate(observations)] qs = inference.update_posterior_states( - self.A, - observation, - empirical_prior, - **self.inference_params + self.A, + o_vec, + prior=empirical_prior ) self.qs = qs return qs + def get_expected_states(self, action): + # update self.empirical_prior + pass + def infer_policies(self): """ Perform policy inference by optimizing a posterior (categorical) distribution over policies. diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index 963b339c..b6907fe9 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -1,5 +1,5 @@ import jax.numpy as jnp -from jax import tree_util, jit, lax, nn +from jax import tree_util, jit, grad, lax, nn from pymdp.jax.maths import compute_log_likelihood, log_stable @@ -9,13 +9,13 @@ def add(x, y): def marginal_log_likelihood(qs, log_likelihood, i): x = qs[0] for q in qs[1:]: - x = x[:, None] * q + x = jnp.expand_dims(x, -1) * q joint = log_likelihood * x dims = (f for f in range(len(qs)) if f != i) return joint.sum(dims)/qs[i] -def run_vanilla_fpi(A, obs, prior, num_iter=16): +def run_vanilla_fpi(A, obs, prior, num_iter=1): """ Vanilla fixed point iteration (jaxified) """ nf = len(prior) @@ -46,10 +46,18 @@ def scan_fn(carry, t): return qs if __name__ == "__main__": - obs = [0, 1, 2] - A = [jnp.ones((3, 2, 2))/3] * 3 - prior = [jnp.ones(2)/2] * 2 - obs_vec = [nn.one_hot(o_m, A[m].shape[0]) for m, o_m in enumerate(obs)] - print(jit(run_vanilla_fpi)(A, obs_vec, prior)) - # print(jit(run_vanilla_fpi)(A, obs, prior)) + prior = [jnp.ones(2)/2, jnp.ones(2)/2, nn.softmax(jnp.array([0, -80., -80., -80, -80.]))] + obs = [0, 5] + A = [jnp.ones((5, 2, 2, 5))/5, jnp.ones((10, 2, 2, 5))/10] + + qs = jit(run_vanilla_fpi)(A, obs, prior) + print(qs) + + # test if differentiable + from functools import partial + def sum_prod(prior): + qs = jnp.concatenate(run_vanilla_fpi(A, obs, prior)) + return (qs * log_stable(qs)).sum() + + print(jit(grad(sum_prod))(prior)) diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index 656b6f33..aa40cd67 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -4,10 +4,9 @@ # pylint: disable=not-an-iterable import itertools -import numpy as np -from pymdp.maths import softmax, softmax_obj_arr, spm_dot, spm_wnorm, spm_MDP_G, spm_log_single, spm_log_obj_array -from pymdp import utils -import copy +import jax.numpy as jnp +from .maths import * +from . import utils def update_posterior_policies_full( qs_seq_pi, @@ -243,7 +242,7 @@ def get_expected_states(qs, B, policy): # get expected states over time for t in range(n_steps): - for control_factor, action in enumerate(policy[t,:]): + for control_factor, action in enumerate(policy[t]): qs_pi[t+1][control_factor] = B[control_factor][:,:,int(action)].dot(qs_pi[t][control_factor]) return qs_pi[1:] diff --git a/pymdp/jax/inference.py b/pymdp/jax/inference.py index e48dfb50..9865b34d 100644 --- a/pymdp/jax/inference.py +++ b/pymdp/jax/inference.py @@ -2,11 +2,9 @@ # -*- coding: utf-8 -*- # pylint: disable=no-member -import numpy as np - -from jax.algos import run_vanilla_fpi, run_mmp, _run_mmp_testing +from .algos import run_vanilla_fpi def update_posterior_states(A, obs, prior=None): - return run_vanilla_fpi(A, obs,prior) + return run_vanilla_fpi(A, obs, prior) diff --git a/pymdp/jax/maths.py b/pymdp/jax/maths.py index c973b89e..4f6134c3 100644 --- a/pymdp/jax/maths.py +++ b/pymdp/jax/maths.py @@ -1,7 +1,7 @@ from jax import tree_util, nn, jit import jax.numpy as jnp -MIN_VAL = -100 +MIN_VAL = -64 def log_stable(x): @@ -9,9 +9,9 @@ def log_stable(x): def compute_log_likelihood_single_modality(o_m, A_m): """ Compute observation likelihood for a single modality (observation and likelihood)""" - # expanded_obs = jnp.expand_dims(nn.one_hot(o_m, A_m.shape[0]), tuple(range(1,A_m.ndim))) - expanded_obs = jnp.expand_dims(o_m, tuple(range(1,A_m.ndim))) + expanded_obs = jnp.expand_dims(o_m, tuple(range(1, A_m.ndim))) likelihood = (expanded_obs * A_m).sum(axis=0, keepdims=True).squeeze() + return log_stable(likelihood) def compute_log_likelihood(obs, A): @@ -22,11 +22,10 @@ def compute_log_likelihood(obs, A): return ll -# if __name__ == '__main__': -# obs = [0, 1, 2] -# A = [jnp.ones((3, 2)) / 3] * 3 -# # obs_vec = [nn.one_hot(o_m, A[m].shape[0]) for m, o_m in enumerate(obs)] -# # res = jit(compute_log_likelihood)(obs_vec, A) -# res = jit(compute_log_likelihood)(obs, A) - -# print(res) \ No newline at end of file +if __name__ == '__main__': + obs = [0, 1, 2] + obs_vec = [ nn.one_hot(o, 3) for o in obs] + A = [jnp.ones((3, 2)) / 3] * 3 + res = jit(compute_log_likelihood)(obs_vec, A) + + print(res) \ No newline at end of file diff --git a/pymdp/jax/utils.py b/pymdp/jax/utils.py new file mode 100644 index 00000000..253f5a94 --- /dev/null +++ b/pymdp/jax/utils.py @@ -0,0 +1,615 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +""" Utility functions + +__author__: Conor Heins, Alexander Tschantz, Brennan Klein +""" + +import numpy as np + +import jax.numpy as jnp + +from typing import (Any, Callable, List, NamedTuple, Optional, Sequence, Union, Tuple) + +Tensor = Any # maybe jnp.ndarray, but typing seems not to be well defined for jax +Vector = List[Tensor] +Shape = Sequence[int] +ShapeList = list[Shape] + +EPS_VAL = 1e-16 # global constant for use in norm_dist() + +# def sample(probabilities): +# sample_onehot = np.random.multinomial(1, probabilities.squeeze()) +# return np.where(sample_onehot == 1)[0][0] + +# def sample_obj_array(arr): +# """ +# Sample from set of Categorical distributions, stored in the sub-arrays of an object array +# """ + +# samples = [sample(arr_i) for arr_i in arr] + +# return samples + +# def obj_array(num_arr): +# """ +# Creates a generic object array with the desired number of sub-arrays, given by `num_arr` +# """ +# return np.empty(num_arr, dtype=object) + +# def obj_array_zeros(shape_list): +# """ +# Creates a numpy object array whose sub-arrays are 1-D vectors +# filled with zeros, with shapes given by shape_list[i] +# """ +# arr = obj_array(len(shape_list)) +# for i, shape in enumerate(shape_list): +# arr[i] = np.zeros(shape) +# return arr + +def list_array_uniform(shape_list: ShapeList) -> Vector: + """ + Creates a numpy object array whose sub-arrays are uniform Categorical + distributions with shapes given by shape_list[i]. The shapes (elements of shape_list) + can either be tuples or lists. + """ + arr = [] + for shape in shape_list: + arr.append( norm_dist(jnp.ones(shape)) ) + return arr + +# def obj_array_ones(shape_list, scale = 1.0): +# arr = obj_array(len(shape_list)) +# for i, shape in enumerate(shape_list): +# arr[i] = scale * np.ones(shape) + +# return arr + +# def onehot(value, num_values): +# arr = np.zeros(num_values) +# arr[value] = 1.0 +# return arr + +# def random_A_matrix(num_obs, num_states): +# if type(num_obs) is int: +# num_obs = [num_obs] +# if type(num_states) is int: +# num_states = [num_states] +# num_modalities = len(num_obs) + +# A = obj_array(num_modalities) +# for modality, modality_obs in enumerate(num_obs): +# modality_shape = [modality_obs] + num_states +# modality_dist = np.random.rand(*modality_shape) +# A[modality] = norm_dist(modality_dist) +# return A + +# def random_B_matrix(num_states, num_controls): +# if type(num_states) is int: +# num_states = [num_states] +# if type(num_controls) is int: +# num_controls = [num_controls] +# num_factors = len(num_states) +# assert len(num_controls) == len(num_states) + +# B = obj_array(num_factors) +# for factor in range(num_factors): +# factor_shape = (num_states[factor], num_states[factor], num_controls[factor]) +# factor_dist = np.random.rand(*factor_shape) +# B[factor] = norm_dist(factor_dist) +# return B + +# def random_single_categorical(shape_list): +# """ +# Creates a random 1-D categorical distribution (or set of 1-D categoricals, e.g. multiple marginals of different factors) and returns them in an object array +# """ + +# num_sub_arrays = len(shape_list) + +# out = obj_array(num_sub_arrays) + +# for arr_idx, shape_i in enumerate(shape_list): +# out[arr_idx] = norm_dist(np.random.rand(shape_i)) + +# return out + +# def construct_controllable_B(num_states, num_controls): +# """ +# Generates a fully controllable transition likelihood array, where each +# action (control state) corresponds to a move to the n-th state from any +# other state, for each control factor +# """ + +# num_factors = len(num_states) + +# B = obj_array(num_factors) +# for factor, c_dim in enumerate(num_controls): +# tmp = np.eye(c_dim)[:, :, np.newaxis] +# tmp = np.tile(tmp, (1, 1, c_dim)) +# B[factor] = tmp.transpose(1, 2, 0) + +# return B + +# def dirichlet_like(template_categorical, scale = 1.0): +# """ +# Helper function to construct a Dirichlet distribution based on an existing Categorical distribution +# """ + +# if not is_obj_array(template_categorical): +# warnings.warn( +# "Input array is not an object array...\ +# Casting the input to an object array" +# ) +# template_categorical = to_obj_array(template_categorical) + +# n_sub_arrays = len(template_categorical) + +# dirichlet_out = obj_array(n_sub_arrays) + +# for i, arr in enumerate(template_categorical): +# dirichlet_out[i] = scale * arr + +# return dirichlet_out + +# def get_model_dimensions(A=None, B=None): + +# if A is None and B is None: +# raise ValueError( +# "Must provide either `A` or `B`" +# ) + +# if A is not None: +# num_obs = [a.shape[0] for a in A] if is_obj_array(A) else [A.shape[0]] +# num_modalities = len(num_obs) +# else: +# num_obs, num_modalities = None, None + +# if B is not None: +# num_states = [b.shape[0] for b in B] if is_obj_array(B) else [B.shape[0]] +# num_factors = len(num_states) +# else: +# if A is not None: +# num_states = list(A[0].shape[1:]) if is_obj_array(A) else list(A.shape[1:]) +# num_factors = len(num_states) +# else: +# num_states, num_factors = None, None + +# return num_obs, num_states, num_modalities, num_factors + +# def get_model_dimensions_from_labels(model_labels): + +# modalities = model_labels['observations'] +# num_modalities = len(modalities.keys()) +# num_obs = [len(modalities[modality]) for modality in modalities.keys()] + +# factors = model_labels['states'] +# num_factors = len(factors.keys()) +# num_states = [len(factors[factor]) for factor in factors.keys()] + +# if 'actions' in model_labels.keys(): + +# controls = model_labels['actions'] +# num_control_fac = len(controls.keys()) +# num_controls = [len(controls[cfac]) for cfac in controls.keys()] + +# return num_obs, num_modalities, num_states, num_factors, num_controls, num_control_fac +# else: +# return num_obs, num_modalities, num_states, num_factors + + +def norm_dist(dist: Tensor) -> Tensor: + """ Normalizes a Categorical probability distribution""" + return dist/dist.sum(0) + +# def norm_dist_obj_arr(obj_arr): + +# normed_obj_array = obj_array(len(obj_arr)) +# for i, arr in enumerate(obj_arr): +# normed_obj_array[i] = norm_dist(arr) + +# return normed_obj_array + +# def is_normalized(dist): +# """ +# Utility function for checking whether a single distribution or set of conditional categorical distributions is normalized. +# Returns True if all distributions integrate to 1.0 +# """ + +# if is_obj_array(dist): +# normed_arrays = [] +# for i, arr in enumerate(dist): +# column_sums = arr.sum(axis=0) +# normed_arrays.append(np.allclose(column_sums, np.ones_like(column_sums))) +# out = all(normed_arrays) +# else: +# column_sums = dist.sum(axis=0) +# out = np.allclose(column_sums, np.ones_like(column_sums)) + +# return out + +# def is_obj_array(arr): +# return arr.dtype == "object" + +# def to_obj_array(arr): +# if is_obj_array(arr): +# return arr +# obj_array_out = obj_array(1) +# obj_array_out[0] = arr.squeeze() +# return obj_array_out + +# def obj_array_from_list(list_input): +# """ +# Takes a list of `numpy.ndarray` and converts them to a `numpy.ndarray` of `dtype = object` +# """ +# return np.array(list_input, dtype = object) + +# def process_observation_seq(obs_seq, n_modalities, n_observations): +# """ +# Helper function for formatting observations + +# Observations can either be `int` (converted to one-hot) +# or `tuple` (obs for each modality), or `list` (obs for each modality) +# If list, the entries could be object arrays of one-hots, in which +# case this function returns `obs_seq` as is. +# """ +# proc_obs_seq = obj_array(len(obs_seq)) +# for t, obs_t in enumerate(obs_seq): +# proc_obs_seq[t] = process_observation(obs_t, n_modalities, n_observations) +# return proc_obs_seq + +# def process_observation(obs, num_modalities, num_observations): +# """ +# Helper function for formatting observations +# USAGE NOTES: +# - If `obs` is a 1D numpy array, it must be a one-hot vector, where one entry (the entry of the observation) is 1.0 +# and all other entries are 0. This therefore assumes it's a single modality observation. If these conditions are met, then +# this function will return `obs` unchanged. Otherwise, it'll throw an error. +# - If `obs` is an int, it assumes this is a single modality observation, whose observation index is given by the value of `obs`. This function will convert +# it to be a one hot vector. +# - If `obs` is a list, it assumes this is a multiple modality observation, whose len is equal to the number of observation modalities, +# and where each entry `obs[m]` is the index of the observation, for that modality. This function will convert it into an object array +# of one-hot vectors. +# - If `obs` is a tuple, same logic as applies for list (see above). +# - if `obs` is a numpy object array (array of arrays), this function will return `obs` unchanged. +# """ + +# if isinstance(obs, np.ndarray) and not is_obj_array(obs): +# assert num_modalities == 1, "If `obs` is a 1D numpy array, `num_modalities` must be equal to 1" +# assert len(np.where(obs)[0]) == 1, "If `obs` is a 1D numpy array, it must be a one hot vector (e.g. np.array([0.0, 1.0, 0.0, ....]))" + +# if isinstance(obs, (int, np.integer)): +# obs = onehot(obs, num_observations[0]) + +# if isinstance(obs, tuple) or isinstance(obs,list): +# obs_arr_arr = obj_array(num_modalities) +# for m in range(num_modalities): +# obs_arr_arr[m] = onehot(obs[m], num_observations[m]) +# obs = obs_arr_arr + +# return obs + +# def convert_observation_array(obs, num_obs): +# """ +# Converts from SPM-style observation array to infer-actively one-hot object arrays. + +# Parameters +# ---------- +# - 'obs' [numpy 2-D nd.array]: +# SPM-style observation arrays are of shape (num_modalities, T), where each row +# contains observation indices for a different modality, and columns indicate +# different timepoints. Entries store the indices of the discrete observations +# within each modality. + +# - 'num_obs' [list]: +# List of the dimensionalities of the observation modalities. `num_modalities` +# is calculated as `len(num_obs)` in the function to determine whether we're +# dealing with a single- or multi-modality +# case. + +# Returns +# ---------- +# - `obs_t`[list]: +# A list with length equal to T, where each entry of the list is either a) an object +# array (in the case of multiple modalities) where each sub-array is a one-hot vector +# with the observation for the correspond modality, or b) a 1D numpy array (in the case +# of one modality) that is a single one-hot vector encoding the observation for the +# single modality. +# """ + +# T = obs.shape[1] +# num_modalities = len(num_obs) + +# # Initialise the output +# obs_t = [] +# # Case of one modality +# if num_modalities == 1: +# for t in range(T): +# obs_t.append(onehot(obs[0, t] - 1, num_obs[0])) +# else: +# for t in range(T): +# obs_AoA = obj_array(num_modalities) +# for g in range(num_modalities): +# # Subtract obs[g,t] by 1 to account for MATLAB vs. Python indexing +# # (MATLAB is 1-indexed) +# obs_AoA[g] = onehot(obs[g, t] - 1, num_obs[g]) +# obs_t.append(obs_AoA) + +# return obs_t + +# def insert_multiple(s, indices, items): +# for idx in range(len(items)): +# s.insert(indices[idx], items[idx]) +# return s + +# def reduce_a_matrix(A): +# """ +# Utility function for throwing away dimensions (lagging dimensions, hidden state factors) +# of a particular A matrix that are independent of the observation. +# Parameters: +# ========== +# - `A` [np.ndarray]: +# The A matrix or likelihood array that encodes probabilistic relationship +# of the generative model between hidden state factors (lagging dimensions, columns, slices, etc...) +# and observations (leading dimension, rows). +# Returns: +# ========= +# - `A_reduced` [np.ndarray]: +# The reduced A matrix, missing the lagging dimensions that correspond to hidden state factors +# that are statistically independent of observations +# - `original_factor_idx` [list]: +# List of the indices (in terms of the original dimensionality) of the hidden state factors +# that are maintained in the A matrix (and thus have an informative / non-degenerate relationship to observations +# """ + +# o_dim, num_states = A.shape[0], A.shape[1:] +# idx_vec_s = [slice(0, o_dim)] + [slice(ns) for _, ns in enumerate(num_states)] + +# original_factor_idx = [] +# excluded_factor_idx = [] # the indices of the hidden state factors that are independent of the observation and thus marginalized away +# for factor_i, ns in enumerate(num_states): + +# level_counter = 0 +# break_flag = False +# while level_counter < ns and break_flag is False: +# idx_vec_i = idx_vec_s.copy() +# idx_vec_i[factor_i+1] = slice(level_counter,level_counter+1,None) +# if not np.isclose(A.mean(axis=factor_i+1), A[tuple(idx_vec_i)].squeeze()).all(): +# break_flag = True # this means they're not independent +# original_factor_idx.append(factor_i) +# else: +# level_counter += 1 + +# if break_flag is False: +# excluded_factor_idx.append(factor_i+1) + +# A_reduced = A.mean(axis=tuple(excluded_factor_idx)).squeeze() + +# return A_reduced, original_factor_idx + +# def construct_full_a(A_reduced, original_factor_idx, num_states): +# """ +# Utility function for reconstruction a full A matrix from a reduced A matrix, using known factor indices +# to tile out the reduced A matrix along the 'non-informative' dimensions +# Parameters: +# ========== +# - `A_reduced` [np.ndarray]: +# The reduced A matrix or likelihood array that encodes probabilistic relationship +# of the generative model between hidden state factors (lagging dimensions, columns, slices, etc...) +# and observations (leading dimension, rows). +# - `original_factor_idx` [list]: +# List of hidden state indices in terms of the full hidden state factor list, that comprise +# the lagging dimensions of `A_reduced` +# - `num_states` [list]: +# The list of all the dimensionalities of hidden state factors in the full generative model. +# `A_reduced.shape[1:]` should be equal to `num_states[original_factor_idx]` +# Returns: +# ========= +# - `A` [np.ndarray]: +# The full A matrix, containing all the lagging dimensions that correspond to hidden state factors, including +# those that are statistically independent of observations + +# @ NOTE: This is the "inverse" of the reduce_a_matrix function, +# i.e. `reduce_a_matrix(construct_full_a(A_reduced, original_factor_idx, num_states)) == A_reduced, original_factor_idx` +# """ + +# o_dim = A_reduced.shape[0] # dimensionality of the support of the likelihood distribution (i.e. the number of observation levels) +# full_dimensionality = [o_dim] + num_states # full dimensionality of the output (`A`) +# fill_indices = [0] + [f+1 for f in original_factor_idx] # these are the indices of the dimensions we need to fill for this modality +# fill_dimensions = np.delete(full_dimensionality, fill_indices) + +# original_factor_dims = [num_states[f] for f in original_factor_idx] # dimensionalities of the relevant factors +# prefilled_slices = [slice(0, o_dim)] + [slice(0, ns) for ns in original_factor_dims] # these are the slices that are filled out by the provided `A_reduced` + +# A = np.zeros(full_dimensionality) + +# for item in itertools.product(*[list(range(d)) for d in fill_dimensions]): +# slice_ = list(item) +# A_indices = insert_multiple(slice_, fill_indices, prefilled_slices) #here we insert the correct values for the fill indices for this slice +# A[tuple(A_indices)] = A_reduced + +# return A + +# def create_A_matrix_stub(model_labels): + +# num_obs, _, num_states, _= get_model_dimensions_from_labels(model_labels) + +# obs_labels, state_labels = model_labels['observations'], model_labels['states'] + +# state_combinations = pd.MultiIndex.from_product(list(state_labels.values()), names=list(state_labels.keys())) +# num_state_combos = np.prod(num_states) +# # num_rows = (np.array(num_obs) * num_state_combos).sum() +# num_rows = sum(num_obs) + +# cell_values = np.zeros((num_rows, len(state_combinations))) + +# obs_combinations = [] +# for modality in obs_labels.keys(): +# levels_to_combine = [[modality]] + [obs_labels[modality]] +# # obs_combinations += num_state_combos * list(itertools.product(*levels_to_combine)) +# obs_combinations += list(itertools.product(*levels_to_combine)) + + +# obs_combinations = pd.MultiIndex.from_tuples(obs_combinations, names = ["Modality", "Level"]) + +# A_matrix = pd.DataFrame(cell_values, index = obs_combinations, columns=state_combinations) + +# return A_matrix + +# def create_B_matrix_stubs(model_labels): + +# _, _, num_states, _, num_controls, _ = get_model_dimensions_from_labels(model_labels) + +# state_labels = model_labels['states'] +# action_labels = model_labels['actions'] + +# B_matrices = {} + +# for f_idx, factor in enumerate(state_labels.keys()): + +# control_fac_name = list(action_labels)[f_idx] +# factor_list = [state_labels[factor]] + [action_labels[control_fac_name]] + +# prev_state_action_combos = pd.MultiIndex.from_product(factor_list, names=[factor, list(action_labels.keys())[f_idx]]) + +# num_state_action_combos = num_states[f_idx] * num_controls[f_idx] + +# num_rows = num_states[f_idx] + +# cell_values = np.zeros((num_rows, num_state_action_combos)) + +# next_state_list = state_labels[factor] + +# B_matrix_f = pd.DataFrame(cell_values, index = next_state_list, columns=prev_state_action_combos) + +# B_matrices[factor] = B_matrix_f + +# return B_matrices + +# def read_A_matrix(path, num_hidden_state_factors): +# raw_table = pd.read_excel(path, header=None) +# level_counts = { +# "index": raw_table.iloc[0, :].dropna().index[0] + 1, +# "header": raw_table.iloc[0, :].dropna().index[0] + num_hidden_state_factors - 1, +# } +# return pd.read_excel( +# path, +# index_col=list(range(level_counts["index"])), +# header=list(range(level_counts["header"])) +# ).astype(np.float64) + +# def read_B_matrices(path): + +# all_sheets = pd.read_excel(path, sheet_name = None, header=None) + +# level_counts = {} +# for sheet_name, raw_table in all_sheets.items(): + +# level_counts[sheet_name] = { +# "index": raw_table.iloc[0, :].dropna().index[0]+1, +# "header": raw_table.iloc[0, :].dropna().index[0]+2, +# } + +# stub_dict = {} +# for sheet_name, level_counts_sheet in level_counts.items(): +# sheet_f = pd.read_excel( +# path, +# sheet_name = sheet_name, +# index_col=list(range(level_counts_sheet["index"])), +# header=list(range(level_counts_sheet["header"])) +# ).astype(np.float64) +# stub_dict[sheet_name] = sheet_f + +# return stub_dict + +# def convert_A_stub_to_ndarray(A_stub, model_labels): +# """ +# This function converts a multi-index pandas dataframe `A_stub` into an object array of different +# A matrices, one per observation modality. +# """ + +# num_obs, num_modalities, num_states, num_factors = get_model_dimensions_from_labels(model_labels) + +# A = obj_array(num_modalities) + +# for g, modality_name in enumerate(model_labels['observations'].keys()): +# A[g] = A_stub.loc[modality_name].to_numpy().reshape(num_obs[g], *num_states) +# assert (A[g].sum(axis=0) == 1.0).all(), 'A matrix not normalized! Check your initialization....\n' + +# return A + +# def convert_B_stubs_to_ndarray(B_stubs, model_labels): +# """ +# This function converts a list of multi-index pandas dataframes `B_stubs` into an object array +# of different B matrices, one per hidden state factor +# """ + +# _, _, num_states, num_factors, num_controls, num_control_fac = get_model_dimensions_from_labels(model_labels) + +# B = obj_array(num_factors) + +# for f, factor_name in enumerate(B_stubs.keys()): + +# B[f] = B_stubs[factor_name].to_numpy().reshape(num_states[f], num_states[f], num_controls[f]) +# assert (B[f].sum(axis=0) == 1.0).all(), 'B matrix not normalized! Check your initialization....\n' + +# return B + +# def build_belief_array(qx): + +# """ +# This function constructs array-ified (not nested) versions +# of the posterior belief arrays, that are separated +# by policy, timepoint, and hidden state factor +# """ + +# num_policies = len(qx) +# num_timesteps = len(qx[0]) +# num_factors = len(qx[0][0]) + +# if num_factors > 1: +# belief_array = utils.obj_array(num_factors) +# for factor in range(num_factors): +# belief_array[factor] = np.zeros( (num_policies, qx[0][0][factor].shape[0], num_timesteps) ) +# for policy_i in range(num_policies): +# for timestep in range(num_timesteps): +# for factor in range(num_factors): +# belief_array[factor][policy_i, :, timestep] = qx[policy_i][timestep][factor] +# else: +# num_states = qx[0][0][0].shape[0] +# belief_array = np.zeros( (num_policies, num_states, num_timesteps) ) +# for policy_i in range(num_policies): +# for timestep in range(num_timesteps): +# belief_array[policy_i, :, timestep] = qx[policy_i][timestep][0] + +# return belief_array + +# def build_xn_vn_array(xn): + +# """ +# This function constructs array-ified (not nested) versions +# of the posterior xn (beliefs) or vn (prediction error) arrays, that are separated +# by iteration, hidden state factor, timepoint, and policy +# """ + +# num_policies = len(xn) +# num_itr = len(xn[0]) +# num_factors = len(xn[0][0]) + +# if num_factors > 1: +# xn_array = utils.obj_array(num_factors) +# for factor in range(num_factors): +# num_states, infer_len = xn[0][0][f].shape +# xn_array[factor] = np.zeros( (num_itr, num_states, infer_len, num_policies) ) +# for policy_i in range(num_policies): +# for itr in range(num_itr): +# for factor in range(num_factors): +# xn_array[factor][itr,:,:,policy_i] = xn[policy_i][itr][factor] +# else: +# num_states, infer_len = xn[0][0][0].shape +# xn_array = np.zeros( (num_itr, num_states, infer_len, num_policies) ) +# for policy_i in range(num_policies): +# for itr in range(num_itr): +# xn_array[itr,:,:,policy_i] = xn[policy_i][itr][0] + +# return xn_array From b509d898c63d46cb5f7cbedba25a3a328dc608d2 Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 22 Apr 2022 17:56:54 +0200 Subject: [PATCH 008/232] - wrote jittable-version of update_posterior_policies using vmap / in JAX Co-authored-by: Dimitrije Markovic --- pymdp/jax/control.py | 621 +++++++------------------------------------ 1 file changed, 103 insertions(+), 518 deletions(-) diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index aa40cd67..3cd9d1b7 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -5,566 +5,151 @@ import itertools import jax.numpy as jnp -from .maths import * -from . import utils +from functools import partial +from jax import lax, vmap, nn +from maths import * +from itertools import chain +# import pymdp.jax.utils as utils -def update_posterior_policies_full( - qs_seq_pi, - A, - B, - C, - policies, - use_utility=True, - use_states_info_gain=True, - use_param_info_gain=False, - prior=None, - pA=None, - pB=None, - F = None, - E = None, - gamma=16.0 -): - """ - Update posterior beliefs about policies by computing expected free energy of each policy and integrating that - with the variational free energy of policies ``F`` and prior over policies ``E``. This is intended to be used in conjunction - with the ``update_posterior_states_full`` method of ``inference.py``, since the full posterior over future timesteps, under all policies, is - assumed to be provided in the input array ``qs_seq_pi``. - - Parameters - ---------- - qs_seq_pi: ``numpy.ndarray`` of dtype object - Posterior beliefs over hidden states for each policy. Nesting structure is policies, timepoints, factors, - where e.g. ``qs_seq_pi[p][t][f]`` stores the marginal belief about factor ``f`` at timepoint ``t`` under policy ``p``. - A: ``numpy.ndarray`` of dtype object - Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of - stores an ``numpy.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store - the probability of observation level ``i`` given hidden state levels ``j, k, ...`` - B: ``numpy.ndarray`` of dtype object - Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. - Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability - of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. - C: ``numpy.ndarray`` of dtype object - Prior over observations or 'prior preferences', storing the "value" of each outcome in terms of relative log probabilities. - This is softmaxed to form a proper probability distribution before being used to compute the expected utility term of the expected free energy. - policies: ``list`` of 2D ``numpy.ndarray`` - ``list`` that stores each policy in ``policies[p_idx]``. Shape of ``policies[p_idx]`` is ``(num_timesteps, num_factors)`` where `num_timesteps` is the temporal - depth of the policy and ``num_factors`` is the number of control factors. - use_utility: ``Bool``, default ``True`` - Boolean flag that determines whether expected utility should be incorporated into computation of EFE. - use_states_info_gain: ``Bool``, default ``True`` - Boolean flag that determines whether state epistemic value (info gain about hidden states) should be incorporated into computation of EFE. - use_param_info_gain: ``Bool``, default ``False`` - Boolean flag that determines whether parameter epistemic value (info gain about generative model parameters) should be incorporated into computation of EFE. - prior: ``numpy.ndarray`` of dtype object, default ``None`` - If provided, this is a ``numpy`` object array with one sub-array per hidden state factor, that stores the prior beliefs about initial states. - If ``None``, this defaults to a flat (uninformative) prior over hidden states. - pA: ``numpy.ndarray`` of dtype object, default ``None`` - Dirichlet parameters over observation model (same shape as ``A``) - pB: ``numpy.ndarray`` of dtype object, default ``None`` - Dirichlet parameters over transition model (same shape as ``B``) - F: 1D ``numpy.ndarray``, default ``None`` - Vector of variational free energies for each policy - E: 1D ``numpy.ndarray``, default ``None`` - Vector of prior probabilities of each policy (what's referred to in the active inference literature as "habits"). If ``None``, this defaults to a flat (uninformative) prior over policies. - gamma: ``float``, default 16.0 - Prior precision over policies, scales the contribution of the expected free energy to the posterior over policies - - Returns - ---------- - q_pi: 1D ``numpy.ndarray`` - Posterior beliefs over policies, i.e. a vector containing one posterior probability per policy. - G: 1D ``numpy.ndarray`` - Negative expected free energies of each policy, i.e. a vector containing one negative expected free energy per policy. - """ - - num_obs, num_states, num_modalities, num_factors = utils.get_model_dimensions(A, B) - horizon = len(qs_seq_pi[0]) - num_policies = len(qs_seq_pi) +def update_posterior_policies(policy_matrix, qs_init, A, B, log_C, gamma = 16.0): + # policy --> n_levels_factor_f x 1 + # factor --> n_levels_factor_f x n_policies + ## vmap across policies + compute_G_fixed_states = partial(compute_G_policy, qs_init, A, B, log_C) - qo_seq = utils.obj_array(horizon) - for t in range(horizon): - qo_seq[t] = utils.obj_array_zeros(num_obs) + # only in the case of policy-dependent qs_inits + # in_axes_list = (1,) * n_factors + # all_efe_of_policies = vmap(compute_G_policy, in_axes=(in_axes_list, 0))(qs_init_pi, policy_matrix) - # initialise expected observations - qo_seq_pi = utils.obj_array(num_policies) + neg_efe_all_policies = vmap(compute_G_fixed_states)(policy_matrix) + # policies needs to be an NDarray of shape (n_policies, n_timepoints, n_control_factors) - # initialize (negative) expected free energies for all policies - G = np.zeros(num_policies) + # @TODO: convert negative EFE of each policy into a posterior probability - if F is None: - F = spm_log_single(np.ones(num_policies) / num_policies) + return nn.softmax(gamma * neg_efe_all_policies), neg_efe_all_policies - if E is None: - lnE = spm_log_single(np.ones(num_policies) / num_policies) - else: - lnE = spm_log_single(E) - - - for p_idx, policy in enumerate(policies): - - qo_seq_pi[p_idx] = get_expected_obs(qs_seq_pi[p_idx], A) - - if use_utility: - G[p_idx] += calc_expected_utility(qo_seq_pi[p_idx], C) - - if use_states_info_gain: - G[p_idx] += calc_states_info_gain(A, qs_seq_pi[p_idx]) +def compute_expected_state(qs_prior, B, u_t): + """ + Compute posterior over next state, given belief about previous state, transition model and action... + """ + qs_next = [] + for qs_f, B_f, u_f in zip(qs_prior, B, u_t): + qs_next.append( B_f[..., u_f].dot(qs_f) ) - if use_param_info_gain: - if pA is not None: - G[p_idx] += calc_pA_info_gain(pA, qo_seq_pi[p_idx], qs_seq_pi[p_idx]) - if pB is not None: - G[p_idx] += calc_pB_info_gain(pB, qs_seq_pi[p_idx], prior, policy) + return qs_next - q_pi = softmax(G * gamma - F + lnE) +def factor_dot(A, qs): + """ Dot product of a multidimensional array with `x`. - return q_pi, G - - -def update_posterior_policies( - qs, - A, - B, - C, - policies, - use_utility=True, - use_states_info_gain=True, - use_param_info_gain=False, - pA=None, - pB=None, - E = None, - gamma=16.0 -): - """ - Update posterior beliefs about policies by computing expected free energy of each policy and integrating that - with the prior over policies ``E``. This is intended to be used in conjunction - with the ``update_posterior_states`` method of the ``inference`` module, since only the posterior about the hidden states at the current timestep - ``qs`` is assumed to be provided, unconditional on policies. The predictive posterior over hidden states under all policies Q(s, pi) is computed - using the starting posterior about states at the current timestep ``qs`` and the generative model (e.g. ``A``, ``B``, ``C``) - Parameters ---------- - qs: ``numpy.ndarray`` of dtype object - Marginal posterior beliefs over hidden states at current timepoint (unconditioned on policies) - A: ``numpy.ndarray`` of dtype object - Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of - stores an ``numpy.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store - the probability of observation level ``i`` given hidden state levels ``j, k, ...`` - B: ``numpy.ndarray`` of dtype object - Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. - Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability - of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. - C: ``numpy.ndarray`` of dtype object - Prior over observations or 'prior preferences', storing the "value" of each outcome in terms of relative log probabilities. - This is softmaxed to form a proper probability distribution before being used to compute the expected utility term of the expected free energy. - policies: ``list`` of 2D ``numpy.ndarray`` - ``list`` that stores each policy in ``policies[p_idx]``. Shape of ``policies[p_idx]`` is ``(num_timesteps, num_factors)`` where `num_timesteps` is the temporal - depth of the policy and ``num_factors`` is the number of control factors. - use_utility: ``Bool``, default ``True`` - Boolean flag that determines whether expected utility should be incorporated into computation of EFE. - use_states_info_gain: ``Bool``, default ``True`` - Boolean flag that determines whether state epistemic value (info gain about hidden states) should be incorporated into computation of EFE. - use_param_info_gain: ``Bool``, default ``False`` - Boolean flag that determines whether parameter epistemic value (info gain about generative model parameters) should be incorporated into computation of EFE. - pA: ``numpy.ndarray`` of dtype object, optional - Dirichlet parameters over observation model (same shape as ``A``) - pB: ``numpy.ndarray`` of dtype object, optional - Dirichlet parameters over transition model (same shape as ``B``) - E: 1D ``numpy.ndarray``, optional - Vector of prior probabilities of each policy (what's referred to in the active inference literature as "habits") - gamma: float, default 16.0 - Prior precision over policies, scales the contribution of the expected free energy to the posterior over policies - - Returns - ---------- - q_pi: 1D ``numpy.ndarray`` - Posterior beliefs over policies, i.e. a vector containing one posterior probability per policy. - G: 1D ``numpy.ndarray`` - Negative expected free energies of each policy, i.e. a vector containing one negative expected free energy per policy. - """ - - n_policies = len(policies) - G = np.zeros(n_policies) - q_pi = np.zeros((n_policies, 1)) - - if E is None: - lnE = spm_log_single(np.ones(n_policies) / n_policies) - else: - lnE = spm_log_single(E) - - for idx, policy in enumerate(policies): - qs_pi = get_expected_states(qs, B, policy) - qo_pi = get_expected_obs(qs_pi, A) - - if use_utility: - G[idx] += calc_expected_utility(qo_pi, C) - - if use_states_info_gain: - G[idx] += calc_states_info_gain(A, qs_pi) - - if use_param_info_gain: - if pA is not None: - G[idx] += calc_pA_info_gain(pA, qo_pi, qs_pi) - if pB is not None: - G[idx] += calc_pB_info_gain(pB, qs_pi, qs, policy) - - q_pi = softmax(G * gamma + lnE) - - return q_pi, G - -def get_expected_states(qs, B, policy): - """ - Compute the expected states under a policy, also known as the posterior predictive density over states - - Parameters - ---------- - qs: ``numpy.ndarray`` of dtype object - Marginal posterior beliefs over hidden states at a given timepoint. - B: ``numpy.ndarray`` of dtype object - Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. - Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability - of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. - policy: 2D ``numpy.ndarray`` - Array that stores actions entailed by a policy over time. Shape is ``(num_timesteps, num_factors)`` where ``num_timesteps`` is the temporal - depth of the policy and ``num_factors`` is the number of control factors. - - Returns - ------- - qs_pi: ``list`` of ``numpy.ndarray`` of dtype object - Predictive posterior beliefs over hidden states expected under the policy, where ``qs_pi[t]`` stores the beliefs about - hidden states expected under the policy at time ``t`` - """ - n_steps = policy.shape[0] - n_factors = policy.shape[1] - - # initialise posterior predictive density as a list of beliefs over time, including current posterior beliefs about hidden states as the first element - qs_pi = [qs] + [utils.obj_array(n_factors) for t in range(n_steps)] + - `x` [1D numpy.ndarray] - either vector or array of arrays + The alternative array to perform the dot product with - # get expected states over time - for t in range(n_steps): - for control_factor, action in enumerate(policy[t]): - qs_pi[t+1][control_factor] = B[control_factor][:,:,int(action)].dot(qs_pi[t][control_factor]) - - return qs_pi[1:] - - -def get_expected_obs(qs_pi, A): - """ - Compute the expected observations under a policy, also known as the posterior predictive density over observations - - Parameters - ---------- - qs_pi: ``list`` of ``numpy.ndarray`` of dtype object - Predictive posterior beliefs over hidden states expected under the policy, where ``qs_pi[t]`` stores the beliefs about - hidden states expected under the policy at time ``t`` - A: ``numpy.ndarray`` of dtype object - Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of - stores an ``numpy.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store - the probability of observation level ``i`` given hidden state levels ``j, k, ...`` - - Returns + Returns ------- - qo_pi: ``list`` of ``numpy.ndarray`` of dtype object - Predictive posterior beliefs over observations expected under the policy, where ``qo_pi[t]`` stores the beliefs about - observations expected under the policy at time ``t`` + - `Y` [1D numpy.ndarray] - the result of the dot product """ - - n_steps = len(qs_pi) # each element of the list is the PPD at a different timestep - - # initialise expected observations - qo_pi = [] - - for t in range(n_steps): - qo_pi_t = utils.obj_array(len(A)) - qo_pi.append(qo_pi_t) - - # compute expected observations over time - for t in range(n_steps): - for modality, A_m in enumerate(A): - qo_pi[t][modality] = spm_dot(A_m, qs_pi[t]) - - return qo_pi - -def calc_expected_utility(qo_pi, C): - """ - Computes the expected utility of a policy, using the observation distribution expected under that policy and a prior preference vector. - - Parameters - ---------- - qo_pi: ``list`` of ``numpy.ndarray`` of dtype object - Predictive posterior beliefs over observations expected under the policy, where ``qo_pi[t]`` stores the beliefs about - observations expected under the policy at time ``t`` - C: ``numpy.ndarray`` of dtype object - Prior over observations or 'prior preferences', storing the "value" of each outcome in terms of relative log probabilities. - This is softmaxed to form a proper probability distribution before being used to compute the expected utility. - - Returns - ------- - expected_util: float - Utility (reward) expected under the policy in question - """ - n_steps = len(qo_pi) - - # initialise expected utility - expected_util = 0 - - # loop over time points and modalities - num_modalities = len(C) - - # reformat C to be tiled across timesteps, if it's not already - modalities_to_tile = [modality_i for modality_i in range(num_modalities) if C[modality_i].ndim == 1] - - # make a deepcopy of C where it has been tiled across timesteps - C_tiled = copy.deepcopy(C) - for modality in modalities_to_tile: - C_tiled[modality] = np.tile(C[modality][:,None], (1, n_steps) ) - C_prob = softmax_obj_arr(C_tiled) # convert relative log probabilities into proper probability distribution - - for t in range(n_steps): - for modality in range(num_modalities): + dims = list(range(A.ndim - len(qs),len(qs)+A.ndim - len(qs))) - lnC = spm_log_single(C_prob[modality][:, t]) - expected_util += qo_pi[t][modality].dot(lnC) + arg_list = [A, list(range(A.ndim))] + list(chain(*([qs[f],[dims[f]]] for f in range(len(qs))))) + [[0]] - return expected_util + res = jnp.einsum(*arg_list) + return res -def calc_states_info_gain(A, qs_pi): - """ - Computes the Bayesian surprise or information gain about states of a policy, - using the observation model and the hidden state distribution expected under that policy. - +def factor_dot_2(A, qs): + """ Dot product of a multidimensional array with `x`. + Parameters ---------- - A: ``numpy.ndarray`` of dtype object - Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of - stores an ``numpy.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store - the probability of observation level ``i`` given hidden state levels ``j, k, ...`` - qs_pi: ``list`` of ``numpy.ndarray`` of dtype object - Predictive posterior beliefs over hidden states expected under the policy, where ``qs_pi[t]`` stores the beliefs about - hidden states expected under the policy at time ``t`` - - Returns + - `x` [1D numpy.ndarray] - either vector or array of arrays + The alternative array to perform the dot product with + + Returns ------- - states_surprise: float - Bayesian surprise (about states) or salience expected under the policy in question + - `Y` [1D numpy.ndarray] - the result of the dot product """ - n_steps = len(qs_pi) - - states_surprise = 0 - for t in range(n_steps): - states_surprise += spm_MDP_G(A, qs_pi[t]) + x = qs[0] + for q in qs[1:]: + x = jnp.expand_dims(x, -1) * q - return states_surprise + joint = A * x + dim = joint.shape[0] + return joint.reshape(dim, -1).sum(-1) +def compute_expected_obs(qs, A): -def calc_pA_info_gain(pA, qo_pi, qs_pi): - """ - Compute expected Dirichlet information gain about parameters ``pA`` under a policy + qo = [] + for A_m in A: + qo.append( factor_dot(A_m, qs) ) + # qo.append( factor_dot_2(A_m, qs) ) - Parameters - ---------- - pA: ``numpy.ndarray`` of dtype object - Dirichlet parameters over observation model (same shape as ``A``) - qo_pi: ``list`` of ``numpy.ndarray`` of dtype object - Predictive posterior beliefs over observations expected under the policy, where ``qo_pi[t]`` stores the beliefs about - observations expected under the policy at time ``t`` - qs_pi: ``list`` of ``numpy.ndarray`` of dtype object - Predictive posterior beliefs over hidden states expected under the policy, where ``qs_pi[t]`` stores the beliefs about - hidden states expected under the policy at time ``t`` - - Returns - ------- - infogain_pA: float - Surprise (about Dirichlet parameters) expected under the policy in question - """ + return qo - n_steps = len(qo_pi) +def compute_info_gain(qs, qo, A): - num_modalities = len(pA) - wA = utils.obj_array(num_modalities) - for modality, pA_m in enumerate(pA): - wA[modality] = spm_wnorm(pA[modality]) - - pA_infogain = 0 + x = qs[0] + for q in qs[1:]: + x = jnp.expand_dims(x, -1) * q + + qs_H_A = 0 # expected entropy of the likelihood, under Q(s) + H_qo = 0 # marginal entropy of Q(o) + for a, o in zip(A, qo): + qs_H_A -= (a * log_stable(a)).sum(0) + H_qo -= (o * log_stable(o)).sum() - for modality in range(num_modalities): - wA_modality = wA[modality] * (pA[modality] > 0).astype("float") - for t in range(n_steps): - pA_infogain -= qo_pi[t][modality].dot(spm_dot(wA_modality, qs_pi[t])[:, np.newaxis]) - - return pA_infogain - - -def calc_pB_info_gain(pB, qs_pi, qs_prev, policy): - """ - Compute expected Dirichlet information gain about parameters ``pB`` under a given policy - - Parameters - ---------- - pB: ``numpy.ndarray`` of dtype object - Dirichlet parameters over transition model (same shape as ``B``) - qs_pi: ``list`` of ``numpy.ndarray`` of dtype object - Predictive posterior beliefs over hidden states expected under the policy, where ``qs_pi[t]`` stores the beliefs about - hidden states expected under the policy at time ``t`` - qs_prev: ``numpy.ndarray`` of dtype object - Posterior over hidden states at beginning of trajectory (before receiving observations) - policy: 2D ``numpy.ndarray`` - Array that stores actions entailed by a policy over time. Shape is ``(num_timesteps, num_factors)`` where ``num_timesteps`` is the temporal - depth of the policy and ``num_factors`` is the number of control factors. + return H_qo - (qs_H_A * x).sum() - Returns - ------- - infogain_pB: float - Surprise (about dirichlet parameters) expected under the policy in question - """ - - n_steps = len(qs_pi) - - num_factors = len(pB) - wB = utils.obj_array(num_factors) - for factor, pB_f in enumerate(pB): - wB[factor] = spm_wnorm(pB_f) - - pB_infogain = 0 - - for t in range(n_steps): - # the 'past posterior' used for the information gain about pB here is the posterior - # over expected states at the timestep previous to the one under consideration - # if we're on the first timestep, we just use the latest posterior in the - # entire action-perception cycle as the previous posterior - if t == 0: - previous_qs = qs_prev - # otherwise, we use the expected states for the timestep previous to the timestep under consideration - else: - previous_qs = qs_pi[t - 1] - - # get the list of action-indices for the current timestep - policy_t = policy[t, :] - for factor, a_i in enumerate(policy_t): - wB_factor_t = wB[factor][:, :, int(a_i)] * (pB[factor][:, :, int(a_i)] > 0).astype("float") - pB_infogain -= qs_pi[t][factor].dot(wB_factor_t.dot(previous_qs[factor])) +def compute_expected_utility(qo, log_C): + + util = 0. + for o_m, log_C_m in zip(qo, log_C): + util += (o_m * log_C_m).sum() + + return util - return pB_infogain +def compute_G_policy(qs_init, A, B, C, policy_i): -def construct_policies(num_states, num_controls = None, policy_len=1, control_fac_idx=None): - """ - Generate a ``list`` of policies. The returned array ``policies`` is a ``list`` that stores one policy per entry. - A particular policy (``policies[i]``) has shape ``(num_timesteps, num_factors)`` - where ``num_timesteps`` is the temporal depth of the policy and ``num_factors`` is the number of control factors. + qs = qs_init + neg_G = 0. + for t_step in range(policy_i.shape[0]): - Parameters - ---------- - num_states: ``list`` of ``int`` - ``list`` of the dimensionalities of each hidden state factor - num_controls: ``list`` of ``int``, default ``None`` - ``list`` of the dimensionalities of each control state factor. If ``None``, then is automatically computed as the dimensionality of each hidden state factor that is controllable - policy_len: ``int``, default 1 - temporal depth ("planning horizon") of policies - control_fac_idx: ``list`` of ``int`` - ``list`` of indices of the hidden state factors that are controllable (i.e. those state factors ``i`` where ``num_controls[i] > 1``) + qs = compute_expected_state(qs, B, policy_i[t_step]) + qo = compute_expected_obs(qs, A) - Returns - ---------- - policies: ``list`` of 2D ``numpy.ndarray`` - ``list`` that stores each policy as a 2D array in ``policies[p_idx]``. Shape of ``policies[p_idx]`` - is ``(num_timesteps, num_factors)`` where ``num_timesteps`` is the temporal - depth of the policy and ``num_factors`` is the number of control factors. - """ + info_gain = compute_info_gain(qs, qo, A) + utility = compute_expected_utility(qo, C) - num_factors = len(num_states) - if control_fac_idx is None: - if num_controls is not None: - control_fac_idx = [f for f, n_c in enumerate(num_controls) if n_c > 1] - else: - control_fac_idx = list(range(num_factors)) - - if num_controls is None: - num_controls = [num_states[c_idx] if c_idx in control_fac_idx else 1 for c_idx in range(num_factors)] + # if we're doing scan we'll need some of those control-flow workarounds from lax + # jnp.where(conditition, f_eval_if_true, 0) + # calculate pA info gain + # calculate pB info gain - x = num_controls * policy_len - policies = list(itertools.product(*[list(range(i)) for i in x])) - for pol_i in range(len(policies)): - policies[pol_i] = np.array(policies[pol_i]).reshape(policy_len, num_factors) + # Q(s, A) = E_{Q(o)}[D_KL(Q(s|o, \pi) Q(A| o, pi)|| Q(s|pi) Q(A))] - return policies - -def get_num_controls_from_policies(policies): - """ - Calculates the ``list`` of dimensionalities of control factors (``num_controls``) - from the ``list`` or array of policies. This assumes a policy space such that for each control factor, there is at least - one policy that entails taking the action with the maximum index along that control factor. + neg_G += info_gain + utility - Parameters - ---------- - policies: ``list`` of 2D ``numpy.ndarray`` - ``list`` that stores each policy as a 2D array in ``policies[p_idx]``. Shape of ``policies[p_idx]`` - is ``(num_timesteps, num_factors)`` where ``num_timesteps`` is the temporal - depth of the policy and ``num_factors`` is the number of control factors. - - Returns - ---------- - num_controls: ``list`` of ``int`` - ``list`` of the dimensionalities of each control state factor, computed here automatically from a ``list`` of policies. - """ - - return list(np.max(np.vstack(policies), axis = 0) + 1) - + return neg_G -def sample_action(q_pi, policies, num_controls, action_selection="deterministic", alpha = 16.0): - """ - Computes the marginal posterior over actions and then samples an action from it, one action per control factor. - - Parameters - ---------- - q_pi: 1D ``numpy.ndarray`` - Posterior beliefs over policies, i.e. a vector containing one posterior probability per policy. - policies: ``list`` of 2D ``numpy.ndarray`` - ``list`` that stores each policy as a 2D array in ``policies[p_idx]``. Shape of ``policies[p_idx]`` - is ``(num_timesteps, num_factors)`` where ``num_timesteps`` is the temporal - depth of the policy and ``num_factors`` is the number of control factors. - num_controls: ``list`` of ``int`` - ``list`` of the dimensionalities of each control state factor. - action_selection: string, default "deterministic" - String indicating whether whether the selected action is chosen as the maximum of the posterior over actions, - or whether it's sampled from the posterior marginal over actions - alpha: float, default 16.0 - Action selection precision -- the inverse temperature of the softmax that is used to scale the - action marginals before sampling. This is only used if ``action_selection`` argument is "stochastic" - Returns - ---------- - selected_policy: 1D ``numpy.ndarray`` - Vector containing the indices of the actions for each control factor - """ +if __name__ == '__main__': - num_factors = len(num_controls) + from jax import random + key = random.PRNGKey(1) + num_obs = [3, 4] - action_marginals = utils.obj_array_zeros(num_controls) - - # weight each action according to its integrated posterior probability over policies and timesteps - # for pol_idx, policy in enumerate(policies): - # for t in range(policy.shape[0]): - # for factor_i, action_i in enumerate(policy[t, :]): - # action_marginals[factor_i][action_i] += q_pi[pol_idx] - - # weight each action according to its integrated posterior probability under all policies at the current timestep - for pol_idx, policy in enumerate(policies): - for factor_i, action_i in enumerate(policy[0, :]): - action_marginals[factor_i][action_i] += q_pi[pol_idx] + A = [random.uniform(key, shape = (no, 2, 2)) for no in num_obs] + B = [random.uniform(key, shape = (2, 2, 2)), random.uniform(key, shape = (2, 2, 2))] + log_C = [log_stable(jnp.array([0.8, 0.1, 0.1])), log_stable(jnp.ones(4)/4)] + policy_1 = jnp.array([[0, 1], + [1, 1]]) + policy_2 = jnp.array([[1, 0], + [0, 0]]) + policy_matrix = jnp.stack([policy_1, policy_2]) # 2 x 2 x 2 tensor - action_marginals = utils.norm_dist_obj_arr(action_marginals) - - selected_policy = np.zeros(num_factors) - for factor_i in range(num_factors): - - # Either you do this: - if action_selection == 'deterministic': - selected_policy[factor_i] = np.argmax(action_marginals[factor_i]) - elif action_selection == 'stochastic': - p_actions = softmax(action_marginals[factor_i] * alpha) - selected_policy[factor_i] = utils.sample(p_actions) - - return selected_policy + qs_init = [jnp.ones(2)/2, jnp.ones(2)/2] + neg_G_all_policies = jit(update_posterior_policies)(policy_matrix, qs_init, A, B, log_C) + print(neg_G_all_policies) From b2aaf2895214ac507b41465d7c7740ff7d6bc192 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Fri, 29 Apr 2022 10:18:32 +0200 Subject: [PATCH 009/232] updated the notebook --- examples/model_inversion.ipynb | 24 +++++++++++------------- 1 file changed, 11 insertions(+), 13 deletions(-) diff --git a/examples/model_inversion.ipynb b/examples/model_inversion.ipynb index dcb5ab6a..b1427048 100644 --- a/examples/model_inversion.ipynb +++ b/examples/model_inversion.ipynb @@ -612,17 +612,17 @@ "output_type": "stream", "text": [ " === Starting experiment === \n", - " Reward condition: Left, Observation: [CENTER, No reward, Cue Right]\n", + " Reward condition: Left, Observation: [CENTER, No reward, Cue Left]\n", "[Step 0] Action: [Move to CUE LOCATION]\n", "[Step 0] Observation: [CUE LOCATION, No reward, Cue Left]\n", "[Step 1] Action: [Move to LEFT ARM]\n", "[Step 1] Observation: [LEFT ARM, Reward!, Cue Left]\n", "[Step 2] Action: [Move to LEFT ARM]\n", - "[Step 2] Observation: [LEFT ARM, Reward!, Cue Left]\n", + "[Step 2] Observation: [LEFT ARM, Reward!, Cue Right]\n", "[Step 3] Action: [Move to LEFT ARM]\n", - "[Step 3] Observation: [LEFT ARM, Reward!, Cue Left]\n", + "[Step 3] Observation: [LEFT ARM, Reward!, Cue Right]\n", "[Step 4] Action: [Move to LEFT ARM]\n", - "[Step 4] Observation: [LEFT ARM, Reward!, Cue Left]\n" + "[Step 4] Observation: [LEFT ARM, Reward!, Cue Right]\n" ] } ], @@ -834,12 +834,12 @@ " [2., 0.],\n", " [2., 0.],\n", " [2., 0.]], dtype=float32),\n", - " 'outcomes': DeviceArray([[0, 0, 0],\n", + " 'outcomes': DeviceArray([[0, 0, 1],\n", " [3, 0, 1],\n", " [2, 1, 1],\n", - " [2, 1, 1],\n", - " [2, 1, 1],\n", - " [2, 1, 1]], dtype=int32)}" + " [2, 1, 0],\n", + " [2, 1, 0],\n", + " [2, 1, 0]], dtype=int32)}" ] }, "execution_count": 29, @@ -862,9 +862,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "first step\n", - "[DeviceArray([1., 0., 0., 0.], dtype=float32), DeviceArray([0.5, 0.5], dtype=float32)]\n", - "qx [DeviceArray([1., 0., 0., 0.], dtype=float32), DeviceArray([9.9999988e-01, 1.1253516e-07], dtype=float32)]\n" + "qx [DeviceArray([1., 0., 0., 0.], dtype=float32), DeviceArray([1.1253516e-07, 9.9999988e-01], dtype=float32)]\n" ] }, { @@ -878,7 +876,7 @@ "Input \u001b[0;32mIn [28]\u001b[0m, in \u001b[0;36mmodel_log_likelihood\u001b[0;34m(T, data, params)\u001b[0m\n\u001b[1;32m 46\u001b[0m log_prob \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0.\u001b[39m\n\u001b[1;32m 47\u001b[0m init \u001b[38;5;241m=\u001b[39m (agent, log_prob)\n\u001b[0;32m---> 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mscan\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstep_fn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minit\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43marange\u001b[49m\u001b[43m(\u001b[49m\u001b[43mT\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n", "Input \u001b[0;32mIn [28]\u001b[0m, in \u001b[0;36mscan\u001b[0;34m(step_fn, init, iterator)\u001b[0m\n\u001b[1;32m 5\u001b[0m carry \u001b[38;5;241m=\u001b[39m init\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m itr \u001b[38;5;129;01min\u001b[39;00m iterator:\n\u001b[0;32m----> 7\u001b[0m carry \u001b[38;5;241m=\u001b[39m \u001b[43mstep_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcarry\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mitr\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 9\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m carry[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\n", "Input \u001b[0;32mIn [28]\u001b[0m, in \u001b[0;36mmodel_log_likelihood..step_fn\u001b[0;34m(carry, t)\u001b[0m\n\u001b[1;32m 17\u001b[0m qx \u001b[38;5;241m=\u001b[39m agent\u001b[38;5;241m.\u001b[39minfer_states(outcome)\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mqx\u001b[39m\u001b[38;5;124m'\u001b[39m, qx)\n\u001b[0;32m---> 19\u001b[0m q_pi, _ \u001b[38;5;241m=\u001b[39m \u001b[43magent\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minfer_policies\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 21\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mq_pi\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;28mtype\u001b[39m(q_pi))\n\u001b[1;32m 23\u001b[0m nc \u001b[38;5;241m=\u001b[39m agent\u001b[38;5;241m.\u001b[39mnum_controls\n", - "File \u001b[0;32m/run/media/dima/data/Dropbox/development/python/pymdp/pymdp/jax/agent.py:294\u001b[0m, in \u001b[0;36mAgent.infer_policies\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 279\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21minfer_policies\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 280\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 281\u001b[0m \u001b[38;5;124;03m Perform policy inference by optimizing a posterior (categorical) distribution over policies.\u001b[39;00m\n\u001b[1;32m 282\u001b[0m \u001b[38;5;124;03m This distribution is computed as the softmax of ``G * gamma + lnE`` where ``G`` is the negative expected\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 291\u001b[0m \u001b[38;5;124;03m Negative expected free energies of each policy, i.e. a vector containing one negative expected free energy per policy.\u001b[39;00m\n\u001b[1;32m 292\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 294\u001b[0m q_pi, G \u001b[38;5;241m=\u001b[39m \u001b[43mcontrol\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mupdate_posterior_policies\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 295\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mqs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 296\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mA\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 297\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mB\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 298\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mC\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 299\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpolicies\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 300\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43muse_utility\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 301\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43muse_states_info_gain\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 302\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43muse_param_info_gain\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 303\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpA\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 304\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpB\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 305\u001b[0m \u001b[43m \u001b[49m\u001b[43mE\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mE\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 306\u001b[0m \u001b[43m \u001b[49m\u001b[43mgamma\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgamma\u001b[49m\n\u001b[1;32m 307\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 309\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mq_pi \u001b[38;5;241m=\u001b[39m q_pi\n\u001b[1;32m 310\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mG \u001b[38;5;241m=\u001b[39m G\n", + "File \u001b[0;32m/run/media/dima/data/Dropbox/development/python/pymdp/pymdp/jax/agent.py:292\u001b[0m, in \u001b[0;36mAgent.infer_policies\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 277\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21minfer_policies\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 278\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 279\u001b[0m \u001b[38;5;124;03m Perform policy inference by optimizing a posterior (categorical) distribution over policies.\u001b[39;00m\n\u001b[1;32m 280\u001b[0m \u001b[38;5;124;03m This distribution is computed as the softmax of ``G * gamma + lnE`` where ``G`` is the negative expected\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 289\u001b[0m \u001b[38;5;124;03m Negative expected free energies of each policy, i.e. a vector containing one negative expected free energy per policy.\u001b[39;00m\n\u001b[1;32m 290\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 292\u001b[0m q_pi, G \u001b[38;5;241m=\u001b[39m \u001b[43mcontrol\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mupdate_posterior_policies\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 293\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mqs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 294\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mA\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 295\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mB\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 296\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mC\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 297\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpolicies\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 298\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43muse_utility\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 299\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43muse_states_info_gain\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 300\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43muse_param_info_gain\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 301\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpA\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 302\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpB\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 303\u001b[0m \u001b[43m \u001b[49m\u001b[43mE\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mE\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 304\u001b[0m \u001b[43m \u001b[49m\u001b[43mgamma\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgamma\u001b[49m\n\u001b[1;32m 305\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 307\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mq_pi \u001b[38;5;241m=\u001b[39m q_pi\n\u001b[1;32m 308\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mG \u001b[38;5;241m=\u001b[39m G\n", "File \u001b[0;32m/run/media/dima/data/Dropbox/development/python/pymdp/pymdp/jax/control.py:186\u001b[0m, in \u001b[0;36mupdate_posterior_policies\u001b[0;34m(qs, A, B, C, policies, use_utility, use_states_info_gain, use_param_info_gain, pA, pB, E, gamma)\u001b[0m\n\u001b[1;32m 124\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mupdate_posterior_policies\u001b[39m(\n\u001b[1;32m 125\u001b[0m qs,\n\u001b[1;32m 126\u001b[0m A,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 136\u001b[0m gamma\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m16.0\u001b[39m\n\u001b[1;32m 137\u001b[0m ):\n\u001b[1;32m 138\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 139\u001b[0m \u001b[38;5;124;03m Update posterior beliefs about policies by computing expected free energy of each policy and integrating that\u001b[39;00m\n\u001b[1;32m 140\u001b[0m \u001b[38;5;124;03m with the prior over policies ``E``. This is intended to be used in conjunction\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 183\u001b[0m \u001b[38;5;124;03m Negative expected free energies of each policy, i.e. a vector containing one negative expected free energy per policy.\u001b[39;00m\n\u001b[1;32m 184\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 186\u001b[0m n_policies \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mpolicies\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 187\u001b[0m G \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mzeros(n_policies)\n\u001b[1;32m 188\u001b[0m q_pi \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mzeros((n_policies, \u001b[38;5;241m1\u001b[39m))\n", "\u001b[0;31mTypeError\u001b[0m: object of type 'NoneType' has no len()" ] @@ -936,7 +934,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.9.12" } }, "nbformat": 4, From 8d5a4aa472c44cbc4d1ce6232de9acd54ed15ca4 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Fri, 29 Apr 2022 12:59:49 +0200 Subject: [PATCH 010/232] jitable agent class and response likelihood --- examples/model_inversion.ipynb | 268 +++++++++++++++++++++++---------- pymdp/jax/agent.py | 29 +--- pymdp/jax/algos.py | 2 +- pymdp/jax/control.py | 51 ++----- pymdp/jax/utils.py | 63 +++----- 5 files changed, 231 insertions(+), 182 deletions(-) diff --git a/examples/model_inversion.ipynb b/examples/model_inversion.ipynb index b1427048..ae28b2c3 100644 --- a/examples/model_inversion.ipynb +++ b/examples/model_inversion.ipynb @@ -449,6 +449,27 @@ "agent = Agent(A=A_gm, B=B_gm, control_fac_idx=controllable_indices)" ] }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(4, 1, 2)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "policies = jnp.stack(agent.policies)\n", + "policies.shape" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -458,7 +479,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "metadata": { "scrolled": true }, @@ -482,7 +503,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "metadata": { "scrolled": false }, @@ -513,7 +534,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -529,7 +550,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -562,7 +583,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -572,7 +593,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -602,7 +623,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "metadata": { "scrolled": false }, @@ -612,17 +633,17 @@ "output_type": "stream", "text": [ " === Starting experiment === \n", - " Reward condition: Left, Observation: [CENTER, No reward, Cue Left]\n", + " Reward condition: Right, Observation: [CENTER, No reward, Cue Left]\n", "[Step 0] Action: [Move to CUE LOCATION]\n", - "[Step 0] Observation: [CUE LOCATION, No reward, Cue Left]\n", - "[Step 1] Action: [Move to LEFT ARM]\n", - "[Step 1] Observation: [LEFT ARM, Reward!, Cue Left]\n", - "[Step 2] Action: [Move to LEFT ARM]\n", - "[Step 2] Observation: [LEFT ARM, Reward!, Cue Right]\n", - "[Step 3] Action: [Move to LEFT ARM]\n", - "[Step 3] Observation: [LEFT ARM, Reward!, Cue Right]\n", - "[Step 4] Action: [Move to LEFT ARM]\n", - "[Step 4] Observation: [LEFT ARM, Reward!, Cue Right]\n" + "[Step 0] Observation: [CUE LOCATION, No reward, Cue Right]\n", + "[Step 1] Action: [Move to RIGHT ARM]\n", + "[Step 1] Observation: [RIGHT ARM, Reward!, Cue Right]\n", + "[Step 2] Action: [Move to RIGHT ARM]\n", + "[Step 2] Observation: [RIGHT ARM, Reward!, Cue Left]\n", + "[Step 3] Action: [Move to RIGHT ARM]\n", + "[Step 3] Observation: [RIGHT ARM, Reward!, Cue Right]\n", + "[Step 4] Action: [Move to RIGHT ARM]\n", + "[Step 4] Observation: [RIGHT ARM, Reward!, Cue Right]\n" ] } ], @@ -657,7 +678,7 @@ " msg = \"\"\"[Step {}] Observation: [{}, {}, {}]\"\"\"\n", " print(msg.format(t, location_observations[obs[0]], reward_observations[obs[1]], cue_observations[obs[2]]))\n", " \n", - "measurments['actions'] = jnp.stack(measurments['actions'])\n", + "measurments['actions'] = jnp.stack(measurments['actions']).astype(jnp.int32)\n", "measurments['outcomes'] = jnp.stack(measurments['outcomes'])" ] }, @@ -677,7 +698,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 26, "metadata": { "scrolled": false }, @@ -701,7 +722,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -737,12 +758,12 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 28, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEICAYAAABPgw/pAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAVQElEQVR4nO3dfbRldX3f8feHGUBEBCM6lQEZAmgDXbqiA9gmyPUh8pAHrEujaEPBh5GuELNa20BSa7FqmjRJo0R0MrGUskxAbawhySQkXXohFlEgC1FQXCMqMwwIyIPOKKGj3/6x99Q9h3PvPXM5M3f4zfu11l3r7P377b2/Z+99Pmef37nnnFQVkqQnvn2WugBJ0nQY6JLUCANdkhphoEtSIwx0SWqEgS5JjTDQRyTZkuTHp7Cei5J8ZBo17U5Jbk0yM6V1nZPkM9NYdmeOS5J/leRb/TJPX8z2x6xzJsmmaayrJUkuS/KeJa5hNsmb+9tvSPI38/Q9Ocntu6+63WuvDfQk30jy/f5Bv/3vsKp6SlXdsdT1LUaSSnLM41lHVR1fVbNTKmlqJj0uSfYF/ivwin6Zb+/66h6fYSDp8amqP66qV2yfHn1MVNXfVdVzl6a6XW+vDfTez/cP+u1/m5e6oKWSZPlSLj9FK4AnAbcudSG7ylLt6yTLlmK7mtzeHuiPMXxG719OXpLkL5N8N8nnkhw96Pv+JBuTfCfJTUlOnnAbM0k2JfmNJPf3rxbeMGg/OMnlSe5L8s0k70iyT992TJJrkjzcL/vRfv61/eJf6F9tvLaf/3NJbk7yUJLrkjxvsJ1vJLkgyS3A1iTL+3kv79v3T/K+JJv7v/cl2X/kPlyQ5B7gv899d/MHfb1fSfKykfv535LcneSuJO+ZKzRGjsv+SX43yZ390MraJAckeQ6w/eX0Q0k+lc7vJ7m3r+GWJP9kjm2cm+TL/bG+I8lbx/RZzDHbYfgtyar+/ixP8l7gZOAD/XH7wJhtbu//piR3Ap/q57+xr/fBJFcnObKf/64kf9Df3jfJ1iT/pZ8+IMkjSZ7WT388yT39vrk2yfGD7V6W5ENJ1ifZCrwkyU8m+ft+H32U7slzTkneMtintyV5QT//J9K9Mnko3TDfL4xsd77H3c/059LD/f7KoO3/D9VlzGMiI0Nnj6eOPVJV7ZV/wDeAl4+ZX8Ax/e3LgAeAE4HlwB8DVw76/gvg6X3b24F7gCf1bRcBH5lj2zPANrqhgf2BU4CtwHP79suBPwMOAlYBXwXe1LddAfx7uifjJwE/Pa72fvoFwL3AScAy4F/293v/wT64GTgCOGB0vwD/CbgeeCbwDOA64N0j9+G3+/twwJj7eU7f518D+wKvBR4Gfqxv/yTwh8CB/TY+D7x1sOxn5jgu7wOuAn6s30d/Dvznvm1V33d5P30qcBNwCN0D/yeAZ81xXH4WOLrvdwrwPeAFUzhmFzE4F8bUOAu8eZ5zdXv/y/t9dQDwSmBDf3+WA+8Aruv7vxT4Yn/7nwFfAz43aPvCYN1v7Gvev9+vNw/aLuuP10/RnW9PBb45OJ6vBv4v8J456n4NcBdwQr9PjwGO7JfdAPwGsF9f03cH+/Iy5njcAYcC3+m3vW9fy7bt+495zpvBcdzU3150HXvq35IXsGR3vAuuLcBD/d8nR0+A/oB+eLDMGcBX5lnng8Dz+9sXsXCgHziY9zHgP9AF7z8Axw3a3grM9rcvB9YBh49Z7+jJ+yH6AB7Mux04ZbAP3jhmv2wP9K8BZwzaTgW+MbgPj9I/gc1xP88BNgMZzPs88Et0QyP/wOCJADgL+PRg2cc8MOmCYStw9KDtnwJf72+vYsewfClduL4I2Gcnz5FPAr86hWO2w7kwpsZZJgv0Hx/M+yv6J4x+eh+6J6Aj6QL/EbqLjQvpAmsT8BTgXcDFc2znkH47Bw/O/8sH7S8eczyvY+5Av3r7/huZfzLdxc8+g3lXABct9LgDzgauH7Slv2+LCfRF17Gn/u3tQy6vrKpD+r9XztHnnsHt79E9KABI8vb+5eTDSR4CDqa7gpjEg1W1dTD9TeCwfvn9+ulh28r+9q/RncSf718ivnGebRwJvL1/OflQX+MR/Xa22zjP8oeNqWO47H1V9cg8ywPcVf2jYWQd26/U7h7U9od0V+rzeQbwZOCmwXJ/3c9/jKr6FPAB4BLgW0nWJXnquL5JTk9yfZIH+vWewY7Hc7HHbFqGx+pI4P2DffAA3Xmxsqq+D9xI9yrixcA1dMH7U/28a6AbE0/yW0m+luQ7dE/msON9Hm7zMMYfz7kcQXdRMOowYGNV/XBkPcP9Ndfj7rBhTX0t853D83k8deyR9vZAX7R04+UXAL8IPK2qDqF7eZr5lht4WpIDB9PPprv6uZ/uZeyRI213AVTVPVX1lqo6jO4q8IOZ+z9bNgLvHTxpHVJVT66qKwZ9ao5l6esZrWP4xvF8y263Mslwn2xfx0a6q9pDB7U9taqOH7uWH7kf+D5w/GC5g6tqzgdaVV1cVS8EjgeeA/y70T7p3hv4U+B3gRX98VzPjsdzUceM7hXFkwdt/2i0xLlqn6ffRrrhqeGxPaCqruvbr6F7dfKTwA399Kl0wwfbx5ZfD5wJvJzuYmRVP394n4fbvJvxx3MuG+mGsEZtBo7Y/h7DYD13jek76m66J4qu0K6WI+buPq/HU8ceyUBfvIPoXoLfByxP8k66Mcad8a4k+/VPDj8HfLyqfkD3Uv69SQ7q3+j6N8BHAJK8Jsnh/fIP0j3gftBPfwsY/q/2HwHnJTkpnQOT/GySgyas7wrgHUmekeRQ4J3b69gJzwTe1r859xq6Md/1VXU38DfA7yV5apJ9khyd5JT5VtZfTf0R8PtJngmQZGWSU8f1T3JCf//3pQvWR/jR/hraj24c+T5gW5LTgVeM6bfTx4zufYoXJ3l2koOBXx9Z5+hxm8Ra4NfTv4mZ7k3Z1wzar6Ebnritqh6lH9ahG5q6r+9zEN2T6rfpnnB+c4FtfpbunH9bujd0X0X3BDGXDwP/NskL+/PvmH7ffI7uWPxaf17MAD8PXDnB/f5L4Pgkr0r33z5v47FPkEPz7dvHU8ceyUBfvKvpxjG/Svcy7RF27qXfPXSBvJnuzZbzquorfduv0J1odwCfAf4EuLRvOwH4XJItdG8M/mpVfb1vuwj4H/3L8F+sqhuBt9ANOTxI9wbQOTtR43voXrrfAnwR+Pt+3s74HHAs3VXse4FX14/+N/xsuiC9ra/vfwLPmmCdF9Ddl+v7oYL/Dcz1v8VPpXsCeJDuOH2b7ip8B1X1Xbpw+Fjf9/V0+3doUcesqv4W+CjdfrwJ+IuR9b4feHW6/1a5eOG7D1X1v+jekL6y3wdfAk4fdLmObix9+9X4bXTn6LWDPpfT7ZO7+vbrF9jmo8Cr6M6hB+ne5P7EPP0/TnfM/4TuzcZP0r0h/ijwC3299wMfBM4e7Mv5arif7s3W36I7lscC/2eeRS5i8JgYc38WVceeKjsOh2l36K8EPlJVhy/QVZIm5hW6JDXCQJekRjjkIkmN8ApdkhqxZF+odOihh9aqVauWavNN2bp1KwceeODCHaUl4jk6PTfddNP9VTX2g3RLFuirVq3ixhtvXKrNN2V2dpaZmZmlLkOak+fo9CSZ89O5DrlIUiMMdElqhIEuSY0w0CWpEQa6JDXCQJekRiwY6EkuTfd7jF+aoz1JLk6yId3vNb5g+mVKkhYyyRX6ZcBp87SfTvcVlscCa+h+9kyStJstGOhVdS3dz1vN5Uy63x2sqroeOCTJJN9pLUmaoml8UnQlO/6ww6Z+3t2jHZOsobuKZ8WKFczOzi5qgzMvecmilmvVzFIXsIeZ/fSnl7oEjdiyZcuiH++a3DQCfdxvaI79CseqWkf3i/WsXr26/CiwdgXPqz2PH/3fPabxXy6b2PFHWg9nxx8SliTtBtMI9KuAs/v/dnkR8HD/A8CSpN1owSGXJFfQDdMemmQT8B+BfQGqai2wHjiD7kd7vwecu6uKlSTNbcFAr6qzFmgv4JenVpEkaVH8pKgkNcJAl6RGGOiS1AgDXZIaYaBLUiMMdElqhIEuSY0w0CWpEQa6JDXCQJekRhjoktQIA12SGmGgS1IjDHRJaoSBLkmNMNAlqREGuiQ1wkCXpEYY6JLUCANdkhphoEtSIwx0SWqEgS5JjTDQJakRBrokNcJAl6RGGOiS1AgDXZIaYaBLUiMMdElqhIEuSY0w0CWpERMFepLTktyeZEOSC8e0H5zkz5N8IcmtSc6dfqmSpPksGOhJlgGXAKcDxwFnJTlupNsvA7dV1fOBGeD3kuw35VolSfOY5Ar9RGBDVd1RVY8CVwJnjvQp4KAkAZ4CPABsm2qlkqR5LZ+gz0pg42B6E3DSSJ8PAFcBm4GDgNdW1Q9HV5RkDbAGYMWKFczOzi6i5O4lgDSXxZ5X2nW2bNnicdkNJgn0jJlXI9OnAjcDLwWOBv42yd9V1Xd2WKhqHbAOYPXq1TUzM7Oz9UoL8rza88zOznpcdoNJhlw2AUcMpg+nuxIfOhf4RHU2AF8H/vF0SpQkTWKSQL8BODbJUf0bna+jG14ZuhN4GUCSFcBzgTumWagkaX4LDrlU1bYk5wNXA8uAS6vq1iTn9e1rgXcDlyX5It0QzQVVdf8urFuSNGKSMXSqaj2wfmTe2sHtzcArpluaJGln+ElRSWqEgS5JjTDQJakRBrokNcJAl6RGGOiS1AgDXZIaYaBLUiMMdElqhIEuSY0w0CWpEQa6JDXCQJekRhjoktQIA12SGmGgS1IjDHRJaoSBLkmNMNAlqREGuiQ1wkCXpEYY6JLUCANdkhphoEtSIwx0SWqEgS5JjTDQJakRBrokNcJAl6RGGOiS1AgDXZIaYaBLUiMmCvQkpyW5PcmGJBfO0Wcmyc1Jbk1yzXTLlCQtZPlCHZIsAy4BfgbYBNyQ5Kqqum3Q5xDgg8BpVXVnkmfuonolSXOY5Ar9RGBDVd1RVY8CVwJnjvR5PfCJqroToKrunW6ZkqSFTBLoK4GNg+lN/byh5wBPSzKb5KYkZ0+rQEnSZBYccgEyZl6NWc8LgZcBBwCfTXJ9VX11hxUla4A1ACtWrGB2dnanCwaYWdRS2lss9rzSrrNlyxaPy24wSaBvAo4YTB8ObB7T5/6q2gpsTXIt8Hxgh0CvqnXAOoDVq1fXzMzMIsuW5uZ5teeZnZ31uOwGkwy53AAcm+SoJPsBrwOuGunzZ8DJSZYneTJwEvDl6ZYqSZrPglfoVbUtyfnA1cAy4NKqujXJeX372qr6cpK/Bm4Bfgh8uKq+tCsLlyTtaJIhF6pqPbB+ZN7akenfAX5neqVJknaGnxSVpEYY6JLUCANdkhphoEtSIwx0SWqEgS5JjTDQJakRBrokNcJAl6RGGOiS1AgDXZIaYaBLUiMMdElqhIEuSY0w0CWpEQa6JDXCQJekRhjoktQIA12SGmGgS1IjDHRJaoSBLkmNMNAlqREGuiQ1wkCXpEYY6JLUCANdkhphoEtSIwx0SWqEgS5JjTDQJakRBrokNcJAl6RGTBToSU5LcnuSDUkunKffCUl+kOTV0ytRkjSJBQM9yTLgEuB04DjgrCTHzdHvt4Grp12kJGlhk1yhnwhsqKo7qupR4ErgzDH9fgX4U+DeKdYnSZrQ8gn6rAQ2DqY3AScNOyRZCfxz4KXACXOtKMkaYA3AihUrmJ2d3clyOzOLWkp7i8WeV9p1tmzZ4nHZDSYJ9IyZVyPT7wMuqKofJOO69wtVrQPWAaxevbpmZmYmq1LaCZ5Xe57Z2VmPy24wSaBvAo4YTB8ObB7psxq4sg/zQ4Ezkmyrqk9Oo0hJ0sImCfQbgGOTHAXcBbwOeP2wQ1Udtf12ksuAvzDMJWn3WjDQq2pbkvPp/ntlGXBpVd2a5Ly+fe0urlGSNIFJrtCpqvXA+pF5Y4O8qs55/GVJknaWnxSVpEYY6JLUCANdkhphoEtSIwx0SWqEgS5JjTDQJakRBrokNcJAl6RGGOiS1AgDXZIaYaBLUiMMdElqhIEuSY0w0CWpEQa6JDXCQJekRhjoktQIA12SGmGgS1IjDHRJaoSBLkmNMNAlqREGuiQ1wkCXpEYY6JLUCANdkhphoEtSIwx0SWqEgS5JjTDQJakRBrokNWKiQE9yWpLbk2xIcuGY9jckuaX/uy7J86dfqiRpPgsGepJlwCXA6cBxwFlJjhvp9nXglKp6HvBuYN20C5UkzW+SK/QTgQ1VdUdVPQpcCZw57FBV11XVg/3k9cDh0y1TkrSQ5RP0WQlsHExvAk6ap/+bgL8a15BkDbAGYMWKFczOzk5W5YiZRS2lvcVizyvtOlu2bPG47AaTBHrGzKuxHZOX0AX6T49rr6p19MMxq1evrpmZmcmqlHaC59WeZ3Z21uOyG0wS6JuAIwbThwObRzsleR7wYeD0qvr2dMqTJE1qkjH0G4BjkxyVZD/gdcBVww5Jng18Avilqvrq9MuUJC1kwSv0qtqW5HzgamAZcGlV3ZrkvL59LfBO4OnAB5MAbKuq1buubEnSqEmGXKiq9cD6kXlrB7ffDLx5uqVJknaGnxSVpEYY6JLUCANdkhphoEtSIwx0SWqEgS5JjTDQJakRBrokNcJAl6RGGOiS1AgDXZIaYaBLUiMMdElqhIEuSY0w0CWpEQa6JDXCQJekRhjoktQIA12SGmGgS1IjDHRJaoSBLkmNMNAlqREGuiQ1wkCXpEYY6JLUCANdkhphoEtSIwx0SWqEgS5JjTDQJakRBrokNcJAl6RGTBToSU5LcnuSDUkuHNOeJBf37bckecH0S5UkzWfBQE+yDLgEOB04DjgryXEj3U4Hju3/1gAfmnKdkqQFTHKFfiKwoaruqKpHgSuBM0f6nAlcXp3rgUOSPGvKtUqS5rF8gj4rgY2D6U3ASRP0WQncPeyUZA3dFTzAliS371S1msuhwP1LXcQeI1nqCvRYnqPTc+RcDZME+rhHRy2iD1W1Dlg3wTa1E5LcWFWrl7oOaS6eo7vHJEMum4AjBtOHA5sX0UeStAtNEug3AMcmOSrJfsDrgKtG+lwFnN3/t8uLgIer6u7RFUmSdp0Fh1yqaluS84GrgWXApVV1a5Lz+va1wHrgDGAD8D3g3F1XssZwGEt7Os/R3SBVjxnqliQ9AflJUUlqhIEuSY0w0J/AFvpKBmmpJbk0yb1JvrTUtewNDPQnqAm/kkFaapcBpy11EXsLA/2Ja5KvZJCWVFVdCzyw1HXsLQz0J665vm5B0l7KQH/imujrFiTtPQz0Jy6/bkHSDgz0J65JvpJB0l7EQH+CqqptwPavZPgy8LGqunVpq5J2lOQK4LPAc5NsSvKmpa6pZX70X5Ia4RW6JDXCQJekRhjoktQIA12SGmGgS1IjDHRJaoSBLkmN+H+fZ2NcIefdMwAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -767,11 +788,12 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 48, "metadata": {}, "outputs": [], "source": [ "import pymdp.jax.utils as jutil\n", + "import pymdp.jax.maths as jmaths\n", "from pymdp.jax.agent import Agent\n", "\n", "def scan(step_fn, init, iterator):\n", @@ -782,67 +804,59 @@ " return carry[-1]\n", " \n", "def model_log_likelihood(T, data, params):\n", - " agent = Agent(params['A'], params['B'], C=params['C'], D=params['D'], control_fac_idx=controllable_indices) \n", - " \n", + " agent = Agent(params['A'], params['B'], C=params['C'], D=params['D'], policies=policies, gamma=1) \n", " def step_fn(carry, t):\n", - " agent, log_prob = carry\n", + " log_prob = carry\n", " outcome = list(data['outcomes'][t])\n", " qx = agent.infer_states(outcome)\n", - " print('qx', qx)\n", " q_pi, _ = agent.infer_policies()\n", " \n", - " print('q_pi', type(q_pi))\n", - " \n", " nc = agent.num_controls\n", - " num_factors = len(nc)\n", - " \n", - " # marginal can be list and it still works\n", - " marginal = jutil.list_array_zeros(agent.num_controls)\n", - " print('marginal', type(marginal))\n", - " print('agent.policies', type(agent.policies))\n", + " num_factors = len(agent.num_controls)\n", " \n", - " # explicit for loop has to be removed for this to be differentiable\n", - " for pol_idx, policy in enumerate(agent.policies):\n", - " print(f'policy {pol_idx}', type(policy))\n", - " for factor_i, action_i in enumerate(policy[0, :]):\n", - " marginal[factor_i][action_i] += q_pi[pol_idx]\n", - " print(marginal)\n", + " marginal = []\n", + " for factor_i in range(num_factors):\n", + " m = []\n", + " actions = agent.policies[:, 0, factor_i]\n", + " for a in range(nc[factor_i]):\n", + " m.append( jnp.where(actions==a, q_pi, 0).sum() )\n", + " marginal.append(jnp.stack(m))\n", " \n", " action = data['actions'][t]\n", " for factor_idx, m in enumerate(marginal):\n", - " log_prob += jnp.sum(jnp.log(m) * jax.nn.one_hot(action[factor_idx], nc[factor_idx]))\n", + " log_prob += jmaths.log_stable(m[action[factor_idx]])\n", " \n", - " agent.action = action\n", + " agent.update_empirical_prior(action)\n", " \n", - " return (agent, log_prob)\n", + " return log_prob, None\n", " \n", " log_prob = 0.\n", - " init = (agent, log_prob)\n", - " return scan(step_fn, init, np.arange(T))" + " init = (log_prob)\n", + " return jax.lax.scan(step_fn, init, np.arange(T))" ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 49, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'actions': DeviceArray([[3., 0.],\n", - " [2., 0.],\n", - " [2., 0.],\n", - " [2., 0.],\n", - " [2., 0.]], dtype=float32),\n", + "{'actions': DeviceArray([[3, 0],\n", + " [1, 0],\n", + " [1, 0],\n", + " [1, 0],\n", + " [1, 0]], dtype=int32),\n", " 'outcomes': DeviceArray([[0, 0, 1],\n", - " [3, 0, 1],\n", - " [2, 1, 1],\n", - " [2, 1, 0],\n", - " [2, 1, 0],\n", - " [2, 1, 0]], dtype=int32)}" + " [3, 0, 0],\n", + " [1, 1, 0],\n", + " [1, 1, 1],\n", + " [1, 1, 0],\n", + " [1, 1, 0]], dtype=int32)}" ] }, - "execution_count": 29, + "execution_count": 49, "metadata": {}, "output_type": "execute_result" } @@ -853,33 +867,20 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 50, "metadata": { "scrolled": true }, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "qx [DeviceArray([1., 0., 0., 0.], dtype=float32), DeviceArray([1.1253516e-07, 9.9999988e-01], dtype=float32)]\n" - ] - }, - { - "ename": "TypeError", - "evalue": "object of type 'NoneType' has no len()", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "Input \u001b[0;32mIn [30]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m# parameters have to be jax arrays, lists or dictionaries of jax arrays\u001b[39;00m\n\u001b[1;32m 5\u001b[0m params \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m 6\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mA\u001b[39m\u001b[38;5;124m'\u001b[39m: [jnp\u001b[38;5;241m.\u001b[39marray(x) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mlist\u001b[39m(A_gp)],\n\u001b[1;32m 7\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mB\u001b[39m\u001b[38;5;124m'\u001b[39m: [jnp\u001b[38;5;241m.\u001b[39marray(x) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mlist\u001b[39m(B_gp)],\n\u001b[1;32m 8\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mC\u001b[39m\u001b[38;5;124m'\u001b[39m: [jnp\u001b[38;5;241m.\u001b[39marray(x) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mlist\u001b[39m(agent\u001b[38;5;241m.\u001b[39mC)],\n\u001b[1;32m 9\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mD\u001b[39m\u001b[38;5;124m'\u001b[39m: [jnp\u001b[38;5;241m.\u001b[39marray(x) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mlist\u001b[39m(agent\u001b[38;5;241m.\u001b[39mD)]\n\u001b[1;32m 10\u001b[0m }\n\u001b[0;32m---> 12\u001b[0m \u001b[43mpartial\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel_log_likelihood\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mT\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmeasurments\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\n", - "Input \u001b[0;32mIn [28]\u001b[0m, in \u001b[0;36mmodel_log_likelihood\u001b[0;34m(T, data, params)\u001b[0m\n\u001b[1;32m 46\u001b[0m log_prob \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0.\u001b[39m\n\u001b[1;32m 47\u001b[0m init \u001b[38;5;241m=\u001b[39m (agent, log_prob)\n\u001b[0;32m---> 48\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mscan\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstep_fn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minit\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43marange\u001b[49m\u001b[43m(\u001b[49m\u001b[43mT\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n", - "Input \u001b[0;32mIn [28]\u001b[0m, in \u001b[0;36mscan\u001b[0;34m(step_fn, init, iterator)\u001b[0m\n\u001b[1;32m 5\u001b[0m carry \u001b[38;5;241m=\u001b[39m init\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m itr \u001b[38;5;129;01min\u001b[39;00m iterator:\n\u001b[0;32m----> 7\u001b[0m carry \u001b[38;5;241m=\u001b[39m \u001b[43mstep_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcarry\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mitr\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 9\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m carry[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\n", - "Input \u001b[0;32mIn [28]\u001b[0m, in \u001b[0;36mmodel_log_likelihood..step_fn\u001b[0;34m(carry, t)\u001b[0m\n\u001b[1;32m 17\u001b[0m qx \u001b[38;5;241m=\u001b[39m agent\u001b[38;5;241m.\u001b[39minfer_states(outcome)\n\u001b[1;32m 18\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mqx\u001b[39m\u001b[38;5;124m'\u001b[39m, qx)\n\u001b[0;32m---> 19\u001b[0m q_pi, _ \u001b[38;5;241m=\u001b[39m \u001b[43magent\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minfer_policies\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 21\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mq_pi\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;28mtype\u001b[39m(q_pi))\n\u001b[1;32m 23\u001b[0m nc \u001b[38;5;241m=\u001b[39m agent\u001b[38;5;241m.\u001b[39mnum_controls\n", - "File \u001b[0;32m/run/media/dima/data/Dropbox/development/python/pymdp/pymdp/jax/agent.py:292\u001b[0m, in \u001b[0;36mAgent.infer_policies\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 277\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21minfer_policies\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 278\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 279\u001b[0m \u001b[38;5;124;03m Perform policy inference by optimizing a posterior (categorical) distribution over policies.\u001b[39;00m\n\u001b[1;32m 280\u001b[0m \u001b[38;5;124;03m This distribution is computed as the softmax of ``G * gamma + lnE`` where ``G`` is the negative expected\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 289\u001b[0m \u001b[38;5;124;03m Negative expected free energies of each policy, i.e. a vector containing one negative expected free energy per policy.\u001b[39;00m\n\u001b[1;32m 290\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 292\u001b[0m q_pi, G \u001b[38;5;241m=\u001b[39m \u001b[43mcontrol\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mupdate_posterior_policies\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 293\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mqs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 294\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mA\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 295\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mB\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 296\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mC\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 297\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpolicies\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 298\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43muse_utility\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 299\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43muse_states_info_gain\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 300\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43muse_param_info_gain\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 301\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpA\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 302\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpB\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 303\u001b[0m \u001b[43m \u001b[49m\u001b[43mE\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mE\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 304\u001b[0m \u001b[43m \u001b[49m\u001b[43mgamma\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgamma\u001b[49m\n\u001b[1;32m 305\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 307\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mq_pi \u001b[38;5;241m=\u001b[39m q_pi\n\u001b[1;32m 308\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mG \u001b[38;5;241m=\u001b[39m G\n", - "File \u001b[0;32m/run/media/dima/data/Dropbox/development/python/pymdp/pymdp/jax/control.py:186\u001b[0m, in \u001b[0;36mupdate_posterior_policies\u001b[0;34m(qs, A, B, C, policies, use_utility, use_states_info_gain, use_param_info_gain, pA, pB, E, gamma)\u001b[0m\n\u001b[1;32m 124\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mupdate_posterior_policies\u001b[39m(\n\u001b[1;32m 125\u001b[0m qs,\n\u001b[1;32m 126\u001b[0m A,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 136\u001b[0m gamma\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m16.0\u001b[39m\n\u001b[1;32m 137\u001b[0m ):\n\u001b[1;32m 138\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 139\u001b[0m \u001b[38;5;124;03m Update posterior beliefs about policies by computing expected free energy of each policy and integrating that\u001b[39;00m\n\u001b[1;32m 140\u001b[0m \u001b[38;5;124;03m with the prior over policies ``E``. This is intended to be used in conjunction\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 183\u001b[0m \u001b[38;5;124;03m Negative expected free energies of each policy, i.e. a vector containing one negative expected free energy per policy.\u001b[39;00m\n\u001b[1;32m 184\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 186\u001b[0m n_policies \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mpolicies\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 187\u001b[0m G \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mzeros(n_policies)\n\u001b[1;32m 188\u001b[0m q_pi \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mzeros((n_policies, \u001b[38;5;241m1\u001b[39m))\n", - "\u001b[0;31mTypeError\u001b[0m: object of type 'NoneType' has no len()" - ] + "data": { + "text/plain": [ + "(DeviceArray(-6.4587955, dtype=float32), None)" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -899,12 +900,113 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "DeviceArray(-6.39336, dtype=float32)" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "jax.jit(partial(model_log_likelihood, T, measurments))(params)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'A': [DeviceArray([[[nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan]],\n", + " \n", + " [[nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan]],\n", + " \n", + " [[nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan]],\n", + " \n", + " [[nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan]]], dtype=float32),\n", + " DeviceArray([[[nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan]],\n", + " \n", + " [[nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan]],\n", + " \n", + " [[nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan]]], dtype=float32),\n", + " DeviceArray([[[nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan]],\n", + " \n", + " [[nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan]]], dtype=float32)],\n", + " 'B': [DeviceArray([[[nan, nan, nan, nan],\n", + " [nan, nan, nan, nan],\n", + " [nan, nan, nan, nan],\n", + " [nan, nan, nan, nan]],\n", + " \n", + " [[nan, nan, nan, nan],\n", + " [nan, nan, nan, nan],\n", + " [nan, nan, nan, nan],\n", + " [nan, nan, nan, nan]],\n", + " \n", + " [[nan, nan, nan, nan],\n", + " [nan, nan, nan, nan],\n", + " [nan, nan, nan, nan],\n", + " [nan, nan, nan, nan]],\n", + " \n", + " [[nan, nan, nan, nan],\n", + " [nan, nan, nan, nan],\n", + " [nan, nan, nan, nan],\n", + " [nan, nan, nan, nan]]], dtype=float32),\n", + " DeviceArray([[[nan],\n", + " [nan]],\n", + " \n", + " [[nan],\n", + " [nan]]], dtype=float32)],\n", + " 'C': [DeviceArray([-0.12114858, 0.2657091 , -0.1199896 , -0.02457093], dtype=float32),\n", + " DeviceArray([-0.14571951, 0.14826588, -0.0025464 ], dtype=float32),\n", + " DeviceArray([-0.06224434, 0.06224432], dtype=float32)],\n", + " 'D': [DeviceArray([nan, nan, nan, nan], dtype=float32),\n", + " DeviceArray([nan, nan], dtype=float32)]}" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# grad computation cannot work until everything is jaxified\n", - "jax.grad(partial(model_log_likelihood, T, measurments))(params)" + "jax.grad(jax.jit(partial(model_log_likelihood, T, measurments)))(params)" ] }, { diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 1a51d2eb..c319093d 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -110,7 +110,8 @@ def __init__( self.C = C """ Construct prior over hidden states (uniform if not specified) """ - self.D = D + self.D = D + self.empirical_prior = D """ Assigning prior parameters on initial hidden states (pD vectors) """ self.pD = pD @@ -249,30 +250,22 @@ def infer_states(self, observations): at timepoint ``t_idx``. """ - # replace this if statement with self.empirical_prior = self.D - - if self.action is not None: - empirical_prior = control.get_expected_states( - self.qs, self.B, self.action.reshape(1, -1) #type: ignore - )[0] - else: - empirical_prior = self.D - - o_vec = [nn.one_hot(o, self.A[i].shape[0]) for i, o in enumerate(observations)] qs = inference.update_posterior_states( self.A, o_vec, - prior=empirical_prior + prior=self.empirical_prior ) self.qs = qs return qs - def get_expected_states(self, action): + def update_empirical_prior(self, action): # update self.empirical_prior - pass + self.empirical_prior = control.compute_expected_state( + self.qs, self.B, action + ) def infer_policies(self): """ @@ -290,17 +283,11 @@ def infer_policies(self): """ q_pi, G = control.update_posterior_policies( + self.policies, self.qs, self.A, self.B, self.C, - self.policies, - self.use_utility, - self.use_states_info_gain, - self.use_param_info_gain, - self.pA, - self.pB, - E = self.E, gamma = self.gamma ) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index b6907fe9..7927b3d2 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -47,7 +47,7 @@ def scan_fn(carry, t): if __name__ == "__main__": prior = [jnp.ones(2)/2, jnp.ones(2)/2, nn.softmax(jnp.array([0, -80., -80., -80, -80.]))] - obs = [0, 5] + obs = [nn.one_hot(0, 5), nn.one_hot(5, 10)] A = [jnp.ones((5, 2, 2, 5))/5, jnp.ones((10, 2, 2, 5))/10] qs = jit(run_vanilla_fpi)(A, obs, prior) diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index 3cd9d1b7..8d16aec4 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -3,35 +3,35 @@ # pylint: disable=no-member # pylint: disable=not-an-iterable -import itertools import jax.numpy as jnp from functools import partial -from jax import lax, vmap, nn -from maths import * +from jax import lax, jit, vmap, nn from itertools import chain + +from pymdp.jax.maths import * # import pymdp.jax.utils as utils -def update_posterior_policies(policy_matrix, qs_init, A, B, log_C, gamma = 16.0): + +def update_posterior_policies(policy_matrix, qs_init, A, B, C, gamma = 16.0): # policy --> n_levels_factor_f x 1 # factor --> n_levels_factor_f x n_policies ## vmap across policies - compute_G_fixed_states = partial(compute_G_policy, qs_init, A, B, log_C) + compute_G_fixed_states = partial(compute_G_policy, qs_init, A, B, C) # only in the case of policy-dependent qs_inits # in_axes_list = (1,) * n_factors # all_efe_of_policies = vmap(compute_G_policy, in_axes=(in_axes_list, 0))(qs_init_pi, policy_matrix) - neg_efe_all_policies = vmap(compute_G_fixed_states)(policy_matrix) # policies needs to be an NDarray of shape (n_policies, n_timepoints, n_control_factors) - - # @TODO: convert negative EFE of each policy into a posterior probability + neg_efe_all_policies = vmap(compute_G_fixed_states)(policy_matrix) return nn.softmax(gamma * neg_efe_all_policies), neg_efe_all_policies def compute_expected_state(qs_prior, B, u_t): """ Compute posterior over next state, given belief about previous state, transition model and action... - """ + """ + assert len(u_t) == len(B) qs_next = [] for qs_f, B_f, u_f in zip(qs_prior, B, u_t): qs_next.append( B_f[..., u_f].dot(qs_f) ) @@ -59,33 +59,11 @@ def factor_dot(A, qs): return res -def factor_dot_2(A, qs): - """ Dot product of a multidimensional array with `x`. - - Parameters - ---------- - - `x` [1D numpy.ndarray] - either vector or array of arrays - The alternative array to perform the dot product with - - Returns - ------- - - `Y` [1D numpy.ndarray] - the result of the dot product - """ - - x = qs[0] - for q in qs[1:]: - x = jnp.expand_dims(x, -1) * q - - joint = A * x - dim = joint.shape[0] - return joint.reshape(dim, -1).sum(-1) - def compute_expected_obs(qs, A): qo = [] for A_m in A: qo.append( factor_dot(A_m, qs) ) - # qo.append( factor_dot_2(A_m, qs) ) return qo @@ -103,11 +81,11 @@ def compute_info_gain(qs, qo, A): return H_qo - (qs_H_A * x).sum() -def compute_expected_utility(qo, log_C): +def compute_expected_utility(qo, C): util = 0. - for o_m, log_C_m in zip(qo, log_C): - util += (o_m * log_C_m).sum() + for o_m, C_m in zip(qo, C): + util += (o_m * C_m).sum() return util @@ -118,6 +96,7 @@ def compute_G_policy(qs_init, A, B, C, policy_i): for t_step in range(policy_i.shape[0]): qs = compute_expected_state(qs, B, policy_i[t_step]) + qo = compute_expected_obs(qs, A) info_gain = compute_info_gain(qs, qo, A) @@ -143,7 +122,7 @@ def compute_G_policy(qs_init, A, B, C, policy_i): A = [random.uniform(key, shape = (no, 2, 2)) for no in num_obs] B = [random.uniform(key, shape = (2, 2, 2)), random.uniform(key, shape = (2, 2, 2))] - log_C = [log_stable(jnp.array([0.8, 0.1, 0.1])), log_stable(jnp.ones(4)/4)] + C = [log_stable(jnp.array([0.8, 0.1, 0.1])), log_stable(jnp.ones(4)/4)] policy_1 = jnp.array([[0, 1], [1, 1]]) policy_2 = jnp.array([[1, 0], @@ -151,5 +130,5 @@ def compute_G_policy(qs_init, A, B, C, policy_i): policy_matrix = jnp.stack([policy_1, policy_2]) # 2 x 2 x 2 tensor qs_init = [jnp.ones(2)/2, jnp.ones(2)/2] - neg_G_all_policies = jit(update_posterior_policies)(policy_matrix, qs_init, A, B, log_C) + neg_G_all_policies = jit(update_posterior_policies)(policy_matrix, qs_init, A, B, C) print(neg_G_all_policies) diff --git a/pymdp/jax/utils.py b/pymdp/jax/utils.py index 253f5a94..12bbc461 100644 --- a/pymdp/jax/utils.py +++ b/pymdp/jax/utils.py @@ -6,8 +6,6 @@ __author__: Conor Heins, Alexander Tschantz, Brennan Klein """ -import numpy as np - import jax.numpy as jnp from typing import (Any, Callable, List, NamedTuple, Optional, Sequence, Union, Tuple) @@ -17,40 +15,13 @@ Shape = Sequence[int] ShapeList = list[Shape] -EPS_VAL = 1e-16 # global constant for use in norm_dist() - -# def sample(probabilities): -# sample_onehot = np.random.multinomial(1, probabilities.squeeze()) -# return np.where(sample_onehot == 1)[0][0] - -# def sample_obj_array(arr): -# """ -# Sample from set of Categorical distributions, stored in the sub-arrays of an object array -# """ - -# samples = [sample(arr_i) for arr_i in arr] - -# return samples - -# def obj_array(num_arr): -# """ -# Creates a generic object array with the desired number of sub-arrays, given by `num_arr` -# """ -# return np.empty(num_arr, dtype=object) - -# def obj_array_zeros(shape_list): -# """ -# Creates a numpy object array whose sub-arrays are 1-D vectors -# filled with zeros, with shapes given by shape_list[i] -# """ -# arr = obj_array(len(shape_list)) -# for i, shape in enumerate(shape_list): -# arr[i] = np.zeros(shape) -# return arr +def norm_dist(dist: Tensor) -> Tensor: + """ Normalizes a Categorical probability distribution""" + return dist/dist.sum(0) def list_array_uniform(shape_list: ShapeList) -> Vector: """ - Creates a numpy object array whose sub-arrays are uniform Categorical + Creates a list of jax arrays representing uniform Categorical distributions with shapes given by shape_list[i]. The shapes (elements of shape_list) can either be tuples or lists. """ @@ -59,12 +30,24 @@ def list_array_uniform(shape_list: ShapeList) -> Vector: arr.append( norm_dist(jnp.ones(shape)) ) return arr -# def obj_array_ones(shape_list, scale = 1.0): -# arr = obj_array(len(shape_list)) -# for i, shape in enumerate(shape_list): -# arr[i] = scale * np.ones(shape) +def list_array_zeros(shape_list: ShapeList) -> Vector: + """ + Creates a list of 1-D jax arrays filled with zeros, with shapes given by shape_list[i] + """ + arr = [] + for shape in shape_list: + arr.append( jnp.zeros(shape) ) + return arr + +def list_array_scaled(shape_list: ShapeList, scale: float=1.0) -> Vector: + """ + Creates a list of 1-D jax arrays filled with scale, with shapes given by shape_list[i] + """ + arr = [] + for shape in shape_list: + arr.append( scale * jnp.ones(shape) ) -# return arr + return arr # def onehot(value, num_values): # arr = np.zeros(num_values) @@ -198,9 +181,7 @@ def list_array_uniform(shape_list: ShapeList) -> Vector: # return num_obs, num_modalities, num_states, num_factors -def norm_dist(dist: Tensor) -> Tensor: - """ Normalizes a Categorical probability distribution""" - return dist/dist.sum(0) + # def norm_dist_obj_arr(obj_arr): From 261665ddee788e3f43261608f3b47077a66d5cdf Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Fri, 29 Apr 2022 13:00:33 +0200 Subject: [PATCH 011/232] notebook example for computing gradients with respect to model parameters --- examples/model_inversion.ipynb | 33 +++++++++++++++++---------------- 1 file changed, 17 insertions(+), 16 deletions(-) diff --git a/examples/model_inversion.ipynb b/examples/model_inversion.ipynb index ae28b2c3..1acebbd5 100644 --- a/examples/model_inversion.ipynb +++ b/examples/model_inversion.ipynb @@ -788,7 +788,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 61, "metadata": {}, "outputs": [], "source": [ @@ -804,7 +804,7 @@ " return carry[-1]\n", " \n", "def model_log_likelihood(T, data, params):\n", - " agent = Agent(params['A'], params['B'], C=params['C'], D=params['D'], policies=policies, gamma=1) \n", + " agent = Agent(params['A'], params['B'], C=params['C'], D=params['D'], policies=policies, gamma=1.)\n", " def step_fn(carry, t):\n", " log_prob = carry\n", " outcome = list(data['outcomes'][t])\n", @@ -832,12 +832,13 @@ " \n", " log_prob = 0.\n", " init = (log_prob)\n", - " return jax.lax.scan(step_fn, init, np.arange(T))" + " log_prob, _ = jax.lax.scan(step_fn, init, np.arange(T))\n", + " return log_prob" ] }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 58, "metadata": {}, "outputs": [ { @@ -856,7 +857,7 @@ " [1, 1, 0]], dtype=int32)}" ] }, - "execution_count": 49, + "execution_count": 58, "metadata": {}, "output_type": "execute_result" } @@ -867,7 +868,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 62, "metadata": { "scrolled": true }, @@ -875,10 +876,10 @@ { "data": { "text/plain": [ - "(DeviceArray(-6.4587955, dtype=float32), None)" + "DeviceArray(-9.186155, dtype=float32)" ] }, - "execution_count": 50, + "execution_count": 62, "metadata": {}, "output_type": "execute_result" } @@ -900,16 +901,16 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 63, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "DeviceArray(-6.39336, dtype=float32)" + "DeviceArray(-9.186155, dtype=float32)" ] }, - "execution_count": 32, + "execution_count": 63, "metadata": {}, "output_type": "execute_result" } @@ -920,7 +921,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 64, "metadata": {}, "outputs": [ { @@ -992,14 +993,14 @@ " \n", " [[nan],\n", " [nan]]], dtype=float32)],\n", - " 'C': [DeviceArray([-0.12114858, 0.2657091 , -0.1199896 , -0.02457093], dtype=float32),\n", - " DeviceArray([-0.14571951, 0.14826588, -0.0025464 ], dtype=float32),\n", - " DeviceArray([-0.06224434, 0.06224432], dtype=float32)],\n", + " 'C': [DeviceArray([-0.25163049, 1.3047824 , -1.8015202 , 0.748369 ], dtype=float32),\n", + " DeviceArray([ 0.4967385, -1.4332426, 0.9365047], dtype=float32),\n", + " DeviceArray([-0.5251627, 0.5251632], dtype=float32)],\n", " 'D': [DeviceArray([nan, nan, nan, nan], dtype=float32),\n", " DeviceArray([nan, nan], dtype=float32)]}" ] }, - "execution_count": 37, + "execution_count": 64, "metadata": {}, "output_type": "execute_result" } From b35d580da7d6f1cd573568301db6a66ed811b365 Mon Sep 17 00:00:00 2001 From: conorheins Date: Wed, 7 Sep 2022 14:07:30 +0200 Subject: [PATCH 012/232] added jax and jaxlib to requirements.txt and setup.py files --- requirements.txt | 2 ++ setup.py | 4 +++- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index d09a154b..7443de46 100644 --- a/requirements.txt +++ b/requirements.txt @@ -24,3 +24,5 @@ xlsxwriter>=1.4.3 sphinx-rtd-theme>=0.4 myst-nb>=0.13.1 autograd>=1.3 +jax>=0.3 +jaxlib>=0.3 \ No newline at end of file diff --git a/setup.py b/setup.py index 352877a4..525f4c39 100644 --- a/setup.py +++ b/setup.py @@ -35,7 +35,9 @@ 'xlsxwriter>=1.4.3', 'sphinx-rtd-theme>=0.4', 'myst-nb>=0.13.1', - 'autograd>=1.3' + 'autograd>=1.3', + 'jax>=0.3', + 'jaxlib>=0.3' ], packages=[ "pymdp", From edfa5ee8e5c8e0cd09775b71b3038d45d9e7e12d Mon Sep 17 00:00:00 2001 From: conorheins Date: Wed, 7 Sep 2022 14:07:45 +0200 Subject: [PATCH 013/232] added more combinatorics of unit-tests to `test_inference_jax.py` --- test/test_inference_jax.py | 172 +++++++++++++++++++++++++++++++------ 1 file changed, 147 insertions(+), 25 deletions(-) diff --git a/test/test_inference_jax.py b/test/test_inference_jax.py index b9c133ef..69b0004d 100644 --- a/test/test_inference_jax.py +++ b/test/test_inference_jax.py @@ -17,43 +17,165 @@ class TestInferenceJax(unittest.TestCase): - def test_fixed_point_iteration(self): + def test_fixed_point_iteration_singlestate_singleobs(self): """ - Tests the jax-ified version of mean-field fixed-point iteration against the original numpy version + Tests the jax-ified version of mean-field fixed-point iteration against the original numpy version. + In this version there is one hidden state factor and one observation modality """ - ''' Create a random generative model with a desired number/dimensionality of hidden state factors and observation modalities''' + num_states_list = [ + [1], + [5], + [10] + ] - # fpi_jax throws an error (some broadcasting dimension mistmatch in `fpi_jax`) - num_states = [2, 2, 5] - num_obs = [5, 10] + num_obs_list = [ + [5], + [1], + [2] + ] - # fpi_jax executes and returns an answer, but it is numerically incorrect - # num_states = [2, 2, 2] - # num_obs = [5, 10] + for (num_states, num_obs) in zip(num_states_list, num_obs_list): - # this works and returns the right answer - # num_states = [4, 4] - # num_obs = [5, 10, 6] + # numpy version + prior = utils.random_single_categorical(num_states) + A = utils.random_A_matrix(num_obs, num_states) - # numpy version - prior = utils.random_single_categorical(num_states) - A = utils.random_A_matrix(num_obs, num_states) + obs_idx = [utils.sample(maths.spm_dot(a_m, prior)) for a_m in A] + obs = utils.process_observation(obs_idx, len(num_obs), num_obs) - obs_idx = [utils.sample(maths.spm_dot(a_m, prior)) for a_m in A] - obs = utils.process_observation(obs_idx, len(num_obs), num_obs) + qs_numpy = fpi_numpy(A, obs, num_obs, num_states, prior=prior, num_iter=16, dF=1.0, dF_tol=-1.0) # set dF_tol to negative number so numpy version of FPI never stops early due to convergence - qs_numpy = fpi_numpy(A, obs, num_obs, num_states, prior=prior, num_iter=16, dF=1.0, dF_tol=-1.0) # set dF_tol to negative number so FPI never stops due to convergence + # jax version + prior = [jnp.array(prior_f) for prior_f in prior] + A = [jnp.array(a_m) for a_m in A] + obs = [jnp.array(o_m) for o_m in obs] - # jax version - prior = [jnp.array(prior_f) for prior_f in prior] - A = [jnp.array(a_m) for a_m in A] - obs = [jnp.array(o_m) for o_m in obs] + qs_jax = fpi_jax(A, obs, prior, num_iter=16) - qs_jax = fpi_jax(A, obs, prior, num_iter=16) + for f, _ in enumerate(qs_jax): + self.assertTrue(np.allclose(qs_numpy[f], qs_jax[f])) + + def test_fixed_point_iteration_singlestate_multiobs(self): + """ + Tests the jax-ified version of mean-field fixed-point iteration against the original numpy version. + In this version there is one hidden state factor and multiple observation modalities + """ + + num_states_list = [ + [1], + [5], + [10] + ] + + num_obs_list = [ + [5, 2], + [1, 8, 9], + [2, 2, 2] + ] + + for (num_states, num_obs) in zip(num_states_list, num_obs_list): + + # numpy version + prior = utils.random_single_categorical(num_states) + A = utils.random_A_matrix(num_obs, num_states) + + obs_idx = [utils.sample(maths.spm_dot(a_m, prior)) for a_m in A] + obs = utils.process_observation(obs_idx, len(num_obs), num_obs) + + qs_numpy = fpi_numpy(A, obs, num_obs, num_states, prior=prior, num_iter=16, dF=1.0, dF_tol=-1.0) # set dF_tol to negative number so numpy version of FPI never stops early due to convergence + + # jax version + prior = [jnp.array(prior_f) for prior_f in prior] + A = [jnp.array(a_m) for a_m in A] + obs = [jnp.array(o_m) for o_m in obs] + + qs_jax = fpi_jax(A, obs, prior, num_iter=16) + + for f, _ in enumerate(qs_jax): + self.assertTrue(np.allclose(qs_numpy[f], qs_jax[f])) + + def test_fixed_point_iteration_multistate_singleobs(self): + """ + Tests the jax-ified version of mean-field fixed-point iteration against the original numpy version. + In this version there are multiple hidden state factors and a single observation modality + """ + + num_states_list = [ + [1, 10, 2], + [5, 5, 10, 2], + [10, 2] + ] + + num_obs_list = [ + [5], + [1], + [10] + ] + + for (num_states, num_obs) in zip(num_states_list, num_obs_list): + + # numpy version + prior = utils.random_single_categorical(num_states) + A = utils.random_A_matrix(num_obs, num_states) + + obs_idx = [utils.sample(maths.spm_dot(a_m, prior)) for a_m in A] + obs = utils.process_observation(obs_idx, len(num_obs), num_obs) + + qs_numpy = fpi_numpy(A, obs, num_obs, num_states, prior=prior, num_iter=16, dF=1.0, dF_tol=-1.0) # set dF_tol to negative number so numpy version of FPI never stops early due to convergence + + # jax version + prior = [jnp.array(prior_f) for prior_f in prior] + A = [jnp.array(a_m) for a_m in A] + obs = [jnp.array(o_m) for o_m in obs] + + qs_jax = fpi_jax(A, obs, prior, num_iter=16) + + for f, _ in enumerate(qs_jax): + self.assertTrue(np.allclose(qs_numpy[f], qs_jax[f])) + + + def test_fixed_point_iteration_multistate_multiobs(self): + """ + Tests the jax-ified version of mean-field fixed-point iteration against the original numpy version. + In this version there are multiple hidden state factors and multiple observation modalities + """ + + ''' Start by creating a collection of random generative models with different + cardinalities and dimensionalities of hidden state factors and observation modalities''' + + num_states_list = [ + [2, 2, 5], + [2, 2, 2], + [4, 4] + ] + + num_obs_list = [ + [5, 10], + [4, 3, 2], + [5, 10, 6] + ] + + for (num_states, num_obs) in zip(num_states_list, num_obs_list): + + # numpy version + prior = utils.random_single_categorical(num_states) + A = utils.random_A_matrix(num_obs, num_states) + + obs_idx = [utils.sample(maths.spm_dot(a_m, prior)) for a_m in A] + obs = utils.process_observation(obs_idx, len(num_obs), num_obs) + + qs_numpy = fpi_numpy(A, obs, num_obs, num_states, prior=prior, num_iter=16, dF=1.0, dF_tol=-1.0) # set dF_tol to negative number so numpy version of FPI never stops early due to convergence + + # jax version + prior = [jnp.array(prior_f) for prior_f in prior] + A = [jnp.array(a_m) for a_m in A] + obs = [jnp.array(o_m) for o_m in obs] + + qs_jax = fpi_jax(A, obs, prior, num_iter=16) - for f, _ in enumerate(qs_jax): - self.assertTrue(np.allclose(qs_numpy[f], qs_jax[f])) + for f, _ in enumerate(qs_jax): + self.assertTrue(np.allclose(qs_numpy[f], qs_jax[f])) if __name__ == "__main__": unittest.main() \ No newline at end of file From dd4330e59f4629e0ee4e005becccc90d5b75cde8 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Wed, 7 Sep 2022 18:29:19 +0200 Subject: [PATCH 014/232] updated notebook with a minimial example for model inversion --- examples/model_inversion.ipynb | 507 ++++++++++++++++++++++----------- pymdp/jax/agent.py | 6 +- pymdp/jax/control.py | 2 +- 3 files changed, 337 insertions(+), 178 deletions(-) diff --git a/examples/model_inversion.ipynb b/examples/model_inversion.ipynb index 1acebbd5..c820bf18 100644 --- a/examples/model_inversion.ipynb +++ b/examples/model_inversion.ipynb @@ -150,14 +150,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -174,14 +172,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -198,14 +194,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAesAAAGiCAYAAADHpO4FAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAg+ElEQVR4nO3dfWxUZf738c+00CmCrUq1UPRXCouKEtzQLthqBUSroKwYDSX440kgdJUlpSvRUhcKC8z6uOgKBaRAjIgoik9b0Sao4FIT6V1Rgai7IA3Y0rRGCipTWs79h6G3w0xhpvdQzuX1fiXnDy+u80SCn/l+r3NmPI7jOAIAAK4Vc74vAAAAnBlhDQCAyxHWAAC4HGENAIDLEdYAALgcYQ0AgMsR1gAAuBxhDQCAyxHWAAC4HGGNDvf5559rypQpSktLU3x8vLp166ZBgwbp8ccf1/fff9/h1zNs2DB5PB716dNHob7Qb9u2bfJ4PPJ4PFq3bl2HX19bevfurcmTJ5/vywDQATqd7wuAXZ5//nk98MADuuqqqzRnzhxdc801OnHihHbu3KkVK1aooqJCmzdv7vDruvDCC7V//35t3bpVI0aMCPizNWvWKCEhQY2NjR1+XWeyefNmJSQknO/LANABPHw3ODpKRUWFsrOzdeutt+qNN96Q1+sN+POmpiZt2bJFf/zjHzv0uoYNG6b6+npdeOGF6tOnj9avX9/6Z0ePHlWPHj1033336fnnn9fatWupZgF0ONrg6DBLliyRx+PRqlWrgoJakuLi4gKC2uPxqLi4OGheqPZvbW2tZsyYocsvv1xxcXFKS0vTggUL1NzcHPb13X///Xr99df1ww8/tI69/PLLkqRx48YFzf/Pf/6jKVOmqF+/frrgggvUq1cvjR49Wl988UXAvA8//FAej0cvvviiCgoK1KNHD3Xp0kVDhw5VVVVVwNzJkyerW7du2r17t0aMGKGuXbvq0ksv1cyZM/XTTz+d8e/h1Hk2bNigoqIipaSkKCEhQbfccou++uqrgH0dx9GSJUuUmpqq+Ph4ZWRkqLy8XMOGDdOwYcPC/jsD0DEIa3SIlpYWbd26Venp6briiiuieuza2loNHjxY7733nubNm6d3331XU6dOlc/n0/Tp08M+zrhx4xQbG6sNGza0jpWWluree+8N2W7+7rvv1L17d/3973/Xli1btGzZMnXq1ElDhgwJCkdJmjt3rvbt26fVq1dr9erV+u677zRs2DDt27cvYN6JEyc0atQojRgxQm+88YZmzpyplStXKjc3N6z7mDt3rg4cOKDVq1dr1apV+uabbzR69Gi1tLS0zikqKlJRUZFuv/12vfnmm8rLy9O0adP09ddfh/vXBaAjOUAHqK2tdSQ548aNC3sfSc78+fODxlNTU51Jkya1/veMGTOcbt26OQcOHAiY9+STTzqSnN27d5/xPEOHDnWuvfZax3EcZ9KkSU5GRobjOI6ze/duR5Lz4YcfOp9++qkjyVm7dm2bx2lubnaampqcfv36ObNnz24d/+CDDxxJzqBBg5yTJ0+2jn/77bdO586dnWnTprWOTZo0yZHkPPPMMwHHXrx4sSPJ+fjjj9v8ezh1nlGjRgXs+8orrziSnIqKCsdxHOf77793vF6vk5ubGzCvoqLCkeQMHTr0DH9bAM4HKmsY75133tHw4cOVkpKi5ubm1m3kyJGSpI8++ijsY91///3auXOnvvjiC5WWlqpv37666aabQs5tbm7WkiVLdM011yguLk6dOnVSXFycvvnmG+3duzdo/vjx4+XxeFr/OzU1VVlZWfrggw+C5t53331B+0oKOfd0p6/5Dxw4UJJ04MABSdInn3wiv9+vsWPHBsy7/vrr1bt377MeH0DH42lwdIikpCRdcMEF2r9/f9SPffjwYb399tvq3LlzyD+vr68P+1g33XST+vXrp5UrV+qVV15Rfn5+QMD+WkFBgZYtW6aHH35YQ4cO1cUXX6yYmBhNmzZNP//8c9D8Hj16hBzbtWtXwFinTp3UvXv3kPs2NDSc9R5O3/fU8wGnrunUMZKTk4P2DTUG4PwjrNEhYmNjNWLECL377rs6ePCgLr/88rPu4/V65ff7g8ZPD6ykpCQNHDhQixcvDnmclJSUiK51ypQpevTRR+XxeDRp0qQ257344ouaOHGilixZEjBeX1+viy66KGh+bW1tyLHTw7W5uVkNDQ0B46f2PX1ue5w6xuHDh0NeD9U14D60wdFhCgsL5TiOpk+frqampqA/P3HihN5+++3W/+7du7c+//zzgDlbt27VsWPHAsbuvPNOffnll+rbt68yMjKCtkjDetKkSRo9erTmzJmjXr16tTnP4/EEPdX+r3/9S4cOHQo5f8OGDQFfunLgwAHt2LEj5NPXv359TJJeeuklSYrKk9pDhgyR1+vVxo0bA8Y/+eST1lY5AHehskaHyczMVElJiR544AGlp6frT3/6k6699lqdOHFCVVVVWrVqlQYMGKDRo0dLkiZMmKC//vWvmjdvnoYOHao9e/boueeeU2JiYsBxFy5cqPLycmVlZWnWrFm66qqrdPz4cX377bcqKyvTihUrwqrkT0lJSdEbb7xx1nl33nmn1q1bp6uvvloDBw5UZWWlnnjiiTbPVVdXp7vvvlvTp0/XkSNHNH/+fMXHx6uwsDBgXlxcnJ566ikdO3ZMf/jDH7Rjxw4tWrRII0eO1I033hj2fbTlkksuUUFBgXw+ny6++GLdfffdOnjwoBYsWKCePXsqJobP8IDbENboUNOnT9fgwYP1j3/8Q4899phqa2vVuXNnXXnllRo/frxmzpzZOnfOnDlqbGzUunXr9OSTT2rw4MF65ZVXdNdddwUcs2fPntq5c6f+9re/6YknntDBgwd14YUXKi0tTbfffrsuvvjic3IvzzzzjDp37iyfz6djx45p0KBBev311/Xoo4+GnL9kyRJ9+umnmjJlihobGzV48GC9/PLL6tu3b8C8zp0765133tGsWbO0aNEidenSRdOnT9cTTzwRtWtfvHixunbtqhUrVmjt2rW6+uqrVVJSoqKiopAtfADnF99gBpxjH374oYYPH65XX31V99577xnnTp48WZs2bQpq9XeE/fv36+qrr9b8+fM1d+7cDj8/gLZRWQMW2rVrlzZs2KCsrCwlJCToq6++0uOPP66EhARNnTr1fF8egNMQ1oCFunbtqp07d6q0tFQ//PCDEhMTNWzYMC1evJjXtwAXog0OAIDL8dgnAABh2rZtm0aPHq2UlBR5PJ6w3hz56KOPlJ6ervj4ePXp00crVqyI+LyENQAAYfrxxx913XXX6bnnngtr/v79+zVq1ChlZ2erqqpKc+fO1axZs/Taa69FdF7a4AAAtIPH49HmzZs1ZsyYNuc8/PDDeuuttwJ+LyAvL0+7du1SRUVF2OcK+YCZ3+8P+ppHr9cb8jeIAQAw2bnMvIqKCuXk5ASM3XbbbSotLdWJEyfa/E2D04UMa5/PpwULFgSMzZ8/X8XFxe27WgAAoqy4jR/Zidj8+ecs82pra4PesEhOTlZzc7Pq6+vVs2fPsI4TMqwLCwtVUFAQMEZVDQBwk2g9dPXwOc6803+579Tqc1u/6BdKyLCm5Q0AsMW5zLwePXoE/eJeXV1dyJ/CPZN2fSlK1FoPgKGKQz2XefzsvzUN/ObF////jGu4TEiizMzMgF8TlKT3339fGRkZYa9XS7y6BQAwVEyUtkgcO3ZMn332mT777DNJv7ya9dlnn6m6ulrSL8vIEydObJ2fl5enAwcOqKCgQHv37tWaNWtUWlqqhx56KKLz8nWjAACEaefOnRo+fHjrf59a6540aZLWrVunmpqa1uCWpLS0NJWVlWn27NlatmyZUlJS9Oyzz+qee+6J6Lztes+aNjhsRxscaEMHtsF9UcqiQgO+boTKGgBgJJvKRtasAQBwOSprAICRbKo2CWsAgJFsaoMT1gAAI9lUWdt0rwAAGInKGgBgJJuqTcIaAGAkm9asbfpgAgCAkaisAQBGsqnaJKwBAEayKaxtulcAAIxEZQ0AMJJND5gR1gAAI9nUGrbpXgEAMBKVNQDASLTBAQBwOZtaw4Q1AMBINoW1TfcKAICRqKwBAEZizRoAAJezqTVs070CAGAkKmsAgJFsqjYJawCAkWxas7bpgwkAAEaisgYAGMmmapOwBgAYyaawtuleAQAwEpU1AMBINj1gRlgDAIxkU2uYsAYAGMmmytqmDyYAABiJyhoAYCSbqk3CGgBgJJvC2qZ7BQDASFTWAAAj2fSAGWENADCSTa1hm+4VAAAjUVkDAIxkU7VJWAMAjGTTmrVNH0wAADASlTUAwEieGHtqa8IaAGAkj4ewBgDA1WIsqqxZswYAwOWorAEARqINDgCAy9n0gBltcAAAXI7KGgBgJNrgAAC4HG1wAADgGlTWAAAj0QYHAMDlaIMDAADXoLIGABiJNjgAAC5n03eDE9YAACPZVFmzZg0AgMtRWQMAjGTT0+CENQDASLTBAQCAa1BZAwCMRBscAACXow0OAADatHz5cqWlpSk+Pl7p6enavn37GeevX79e1113nS644AL17NlTU6ZMUUNDQ9jnI6wBAEbyxHiiskVq48aNys/PV1FRkaqqqpSdna2RI0equro65PyPP/5YEydO1NSpU7V79269+uqr+vTTTzVt2rSwz0lYAwCM5PF4orJF6umnn9bUqVM1bdo09e/fX0uXLtUVV1yhkpKSkPM/+eQT9e7dW7NmzVJaWppuvPFGzZgxQzt37gz7nIQ1AMBqfr9fjY2NAZvf7w85t6mpSZWVlcrJyQkYz8nJ0Y4dO0Luk5WVpYMHD6qsrEyO4+jw4cPatGmT7rjjjrCvkbAGABgpJsYTlc3n8ykxMTFg8/l8Ic9ZX1+vlpYWJScnB4wnJyertrY25D5ZWVlav369cnNzFRcXpx49euiiiy7SP//5z/DvNfy/FgAA3CNabfDCwkIdOXIkYCssLDzruX/NcZw2W+p79uzRrFmzNG/ePFVWVmrLli3av3+/8vLywr5XXt0CABgpWu9Ze71eeb3esOYmJSUpNjY2qIquq6sLqrZP8fl8uuGGGzRnzhxJ0sCBA9W1a1dlZ2dr0aJF6tmz51nPS2UNAECY4uLilJ6ervLy8oDx8vJyZWVlhdznp59+UkxMYNzGxsZK+qUiDweVNQDASOfrS1EKCgo0YcIEZWRkKDMzU6tWrVJ1dXVrW7uwsFCHDh3SCy+8IEkaPXq0pk+frpKSEt12222qqalRfn6+Bg8erJSUlLDOSVgDAIzkOU+94dzcXDU0NGjhwoWqqanRgAEDVFZWptTUVElSTU1NwDvXkydP1tGjR/Xcc8/pL3/5iy666CLdfPPNeuyxx8I+p8cJtwb/lWKLvuINCKU41D+b4+F/GxHwmxXfvcNO9X9+F3qNOFKD/nM4Ksc5l6isAQBGsum7wQlrAICRbPrVLZ4GBwDA5aisAQBGiqENDgCAu9EGBwAArkFlDQAwEk+DAwDgcja1wQlrAICRbKqsWbMGAMDlqKwBAEaiDQ4AgMvRBgcAAK5BZQ0AMJInxp56k7AGABjJpjVrez6WAABgKCprAICZLHrAjLAGABiJNjgAAHANKmsAgJF4GhwAAJez6UtRCGsAgJlYswYAAG5BZQ0AMBJr1gAAuJxNa9b2fCwBAMBQVNYAACPZ9KUohDUAwEwWhTVtcAAAXI7KGgBgJI/HnnqTsAYAGMmmNWt7PpYAAGAoKmsAgJFsqqwJawCAmVizBgDA3WyqrO35WAIAgKGorAEARrKpsiasAQBG4oc8AACAa1BZAwDMxO9ZAwDgbjatWdvzsQQAAENRWQMAjGTTA2aENQDASB6L1qztuVMAAAxFZQ0AMJJND5gR1gAAM7FmDQCAu9lUWbNmDQCAy1FZAwCMZNPT4IQ1AMBINr1nbc/HEgAADEVlDQAwk0UPmBHWAAAj2bRmbc+dAgBgKCprAICRbHrAjLAGABiJL0UBAACuQWUNADATbXAAANzNpjY4YQ0AMJM9Wc2aNQAAbkdlDQAwk0Vr1lTWAAAjeTzR2dpj+fLlSktLU3x8vNLT07V9+/Yzzvf7/SoqKlJqaqq8Xq/69u2rNWvWhH0+KmsAACKwceNG5efna/ny5brhhhu0cuVKjRw5Unv27NH//M//hNxn7NixOnz4sEpLS/W73/1OdXV1am5uDvucHsdxnEgvtNii1gMQSnGofzbHGzr+QgC3ie/eYadq/POdUTlOwj/fiWj+kCFDNGjQIJWUlLSO9e/fX2PGjJHP5wuav2XLFo0bN0779u3TJZdc0q5rpA0OADBStNrgfr9fjY2NAZvf7w95zqamJlVWVionJydgPCcnRzt27Ai5z1tvvaWMjAw9/vjj6tWrl6688ko99NBD+vnnn8O+V8IaAGA1n8+nxMTEgC1UhSxJ9fX1amlpUXJycsB4cnKyamtrQ+6zb98+ffzxx/ryyy+1efNmLV26VJs2bdKDDz4Y9jWyZg0AMFOUlmQLCwtVUFAQMOb1es9y6sBzO47T5g+LnDx5Uh6PR+vXr1diYqIk6emnn9a9996rZcuWqUuXLme9RsIaAGCmKPWGvV7vWcP5lKSkJMXGxgZV0XV1dUHV9ik9e/ZUr169WoNa+mWN23EcHTx4UP369TvreWmDAwCM5PF4orJFIi4uTunp6SovLw8YLy8vV1ZWVsh9brjhBn333Xc6duxY69jXX3+tmJgYXX755WGdl7AGACACBQUFWr16tdasWaO9e/dq9uzZqq6uVl5enqRf2uoTJ05snT9+/Hh1795dU6ZM0Z49e7Rt2zbNmTNH999/f1gtcIk2OADAVOfpNeLc3Fw1NDRo4cKFqqmp0YABA1RWVqbU1FRJUk1Njaqrq1vnd+vWTeXl5frzn/+sjIwMde/eXWPHjtWiRYvCPifvWQPtwHvWQBs68D3rHx+6KyrH6frkm1E5zrlEGxwAAJejDQ4AMBO/Zw0AgMvZk9W0wQEAcDsqawCAkSJ9R9pkhDUAwEz2ZDVtcAAA3I7KGgBgJA9PgwMA4HL2ZDVhDQAwlEUPmLFmDQCAy1FZAwCMZFFhTVgDAAxl0QNmtMEBAHA5KmsAgJFogwMA4HYWpTVtcAAAXI7KGgBgJIsKa8IaAGAongYHAABuQWUNADCTRX1wwhoAYCSLspqwBgAYyqK0Zs0aAACXo7IGABjJY1G5SVgDAMxEGxwAALgFlTUAwEz2FNbtC+tix4n2dQDmi+9+vq8AsIrHojZ4yLD2+/3y+/0BY16vV16vt0MuCgAA/D8h16x9Pp8SExMDNp/P19HXBgBA22I80dkM4HGc4J42lTUAwO1alv5vVI4Tm/9iVI5zLoVsgxPMAAC4R/ueBj/eEOXLAAwT4mGyYosedgHa0qEPIBvSwo4GXt0CAJjJoq8wI6wBAGayqJtlz8cSAAAMRWUNADATa9YAALicRWvW9twpAACGorIGAJiJNjgAAC7H0+AAAMAtqKwBAGaKsafeJKwBAGaiDQ4AANyCyhoAYCba4AAAuJxFbXDCGgBgJovC2p4eAgAAhqKyBgCYiTVrAABcjjY4AABwCyprAICRPPyQBwAALsfvWQMAALegsgYAmIk2OAAALsfT4AAAwC2orAEAZuJLUQAAcDmL2uCENQDATBaFtT09BAAADEVYAwDMFBMTna0dli9frrS0NMXHxys9PV3bt28Pa79///vf6tSpk37/+99HdD7CGgBgJo8nOluENm7cqPz8fBUVFamqqkrZ2dkaOXKkqqurz7jfkSNHNHHiRI0YMSLicxLWAABE4Omnn9bUqVM1bdo09e/fX0uXLtUVV1yhkpKSM+43Y8YMjR8/XpmZmRGfk7AGAJgpxhOVze/3q7GxMWDz+/0hT9nU1KTKykrl5OQEjOfk5GjHjh1tXuratWv13//+V/Pnz2/frbZrLwAAzjdPTFQ2n8+nxMTEgM3n84U8ZX19vVpaWpScnBwwnpycrNra2pD7fPPNN3rkkUe0fv16derUvpeweHULAGC1wsJCFRQUBIx5vd4z7uM5ba3bcZygMUlqaWnR+PHjtWDBAl155ZXtvkbCGgBgpij9kIfX6z1rOJ+SlJSk2NjYoCq6rq4uqNqWpKNHj2rnzp2qqqrSzJkzJUknT56U4zjq1KmT3n//fd18881nPS9hDQAw03n4UpS4uDilp6ervLxcd999d+t4eXm57rrrrqD5CQkJ+uKLLwLGli9frq1bt2rTpk1KS0sL67yENQAAESgoKNCECROUkZGhzMxMrVq1StXV1crLy5P0S1v90KFDeuGFFxQTE6MBAwYE7H/ZZZcpPj4+aPxMCGsAgJnO0w955ObmqqGhQQsXLlRNTY0GDBigsrIypaamSpJqamrO+s51pDyO4zgR73W8IaoXARgnvnvQULFF31MMtKW4HZHSXiff/1tUjhOT89eoHOdcorIGAJjJog/IvGcNAIDLUVkDAMzksafeJKwBAGaypwtOGxwAALejsgYAmMmiB8wIawCAmSwKa9rgAAC4HJU1AMBMFlXWhDUAwFD2hDVtcAAAXI7KGgBgJnsKa8IaAGAo1qwBAHA5i8KaNWsAAFyOyhoAYCaLKmvCGgBgKHvCmjY4AAAuR2UNADCTPYU1YQ0AMJRFa9a0wQEAcDkqawCAmSyqrAlrAICh7Alr2uAAALgclTUAwEy0wQEAcDnCGgAAl7Mnq1mzBgDA7aisAQBmog0OAIDb2RPWtMEBAHA5KmsAgJlogwMA4HIWhTVtcAAAXI7KGgBgJnsKa8IaAGAo2uAAAMAtqKwBAIayp7ImrAEAZrKoDU5YAwDMZFFYs2YNAIDLUVkDAMxEZQ0AANyCsAYAwOVogwMAzGRRG5ywBgCYyaKwpg0OAIDLUVkDAMxkUWVNWAMADGVPWNMGBwDA5aisAQBmog0OAIDLeexpDhPWAABD2VNZ2/OxBAAAQ1FZAwDMxJo1AAAuZ9GatT13CgCAoaisAQCGog0OAIC7WbRmTRscAACXo7IGABjKnnqTsAYAmIk2OAAAcAvCGgBgJo8nOls7LF++XGlpaYqPj1d6erq2b9/e5tzXX39dt956qy699FIlJCQoMzNT7733XkTnI6wBAIbyRGmLzMaNG5Wfn6+ioiJVVVUpOztbI0eOVHV1dcj527Zt06233qqysjJVVlZq+PDhGj16tKqqqsK/U8dxnIiv9HhDxLsAvynx3YOGii1aPwPaUtyOSGmvk/99IyrHiek7JqL5Q4YM0aBBg1RSUtI61r9/f40ZM0Y+ny+sY1x77bXKzc3VvHnzwrvGiK4QAIDfGL/fr8bGxoDN7/eHnNvU1KTKykrl5OQEjOfk5GjHjh1hne/kyZM6evSoLrnkkrCvkbAGAJgpSmvWPp9PiYmJAVtbFXJ9fb1aWlqUnJwcMJ6cnKza2tqwLvupp57Sjz/+qLFjx4Z9q7y6BQAwVHSWngoLC1VQUBAw5vV6z3zm05a9HMcJGgtlw4YNKi4u1ptvvqnLLrss7GskrAEAVvN6vWcN51OSkpIUGxsbVEXX1dUFVdun27hxo6ZOnapXX31Vt9xyS0TXSBscAGAmT0x0tgjExcUpPT1d5eXlAePl5eXKyspqc78NGzZo8uTJeumll3THHXdEfKtU1gAAI4XTdj4XCgoKNGHCBGVkZCgzM1OrVq1SdXW18vLyJP3SVj906JBeeOEFSb8E9cSJE/XMM8/o+uuvb63Ku3TposTExLDOSVgDABCB3NxcNTQ0aOHChaqpqdGAAQNUVlam1NRUSVJNTU3AO9crV65Uc3OzHnzwQT344IOt45MmTdK6devCOifvWQPtwXvWQEgd+Z61821ZVI7j6T0qKsc5l6isAQBminC92WT23CkAAIaisgYAGMqepSfCGgBgJoueEyGsAQBmYs0aAAC4BZU1AMBQtMEBAHA3i9asaYMDAOByVNYAADNZ9IAZYQ0AMBRtcAAA4BJU1gAAM1n0gBlhDQAwlD3NYXvuFAAAQ1FZAwDMRBscAACXI6wBAHA7e1Zy7blTAAAMRWUNADATbXAAANzOnrCmDQ4AgMtRWQMAzEQbHAAAt7MnrGmDAwDgclTWAAAz0QYHAMDt7GkO23OnAAAYisoaAGAm2uAAALgdYQ0AgLtZVFmzZg0AgMtRWQMADGVPZU1YAwDMRBscAAC4BZU1AMBQ9lTWhDUAwEy0wQEAgFtQWQMADGVPvUlYAwDMRBscAAC4BZU1AMBQ9lTWhDUAwFCENQAAruZhzRoAALgFlTUAwFD2VNaENQDATLTBAQCAW1BZAwAMZU9lTVgDAMzksac5bM+dAgBgKCprAIChaIMDAOBuPA0OAADcgsoaAGAoeyprwhoAYCaL2uCENQDAUPaENWvWAAC4HJU1AMBMtMEBAHA7e8KaNjgAAC5HZQ0AMBPfDQ4AgNt5orRFbvny5UpLS1N8fLzS09O1ffv2M87/6KOPlJ6ervj4ePXp00crVqyI6HyENQAAEdi4caPy8/NVVFSkqqoqZWdna+TIkaqurg45f//+/Ro1apSys7NVVVWluXPnatasWXrttdfCPqfHcRwn4is93hDxLsBvSnz3oKFii55MBdpS3I5Iabfj9dE5TnxSRNOHDBmiQYMGqaSkpHWsf//+GjNmjHw+X9D8hx9+WG+99Zb27t3bOpaXl6ddu3apoqIirHO2b806xP+oANt16P+kAOh8PA3e1NSkyspKPfLIIwHjOTk52rFjR8h9KioqlJOTEzB22223qbS0VCdOnFDnzp3Pel4eMAMAWM3v98vv9weMeb1eeb3eoLn19fVqaWlRcnJywHhycrJqa2tDHr+2tjbk/ObmZtXX16tnz55nvcaw1qz9fr+Ki4uDbgawGf8ugPMsvntUNp/Pp8TExIAtVDv71zynLXs5jhM0drb5ocbbEnZYL1iwgP8pAb/Cvwvgt6GwsFBHjhwJ2AoLC0POTUpKUmxsbFAVXVdXF1Q9n9KjR4+Q8zt16qTu3cNbVuZpcACA1bxerxISEgK2UC1wSYqLi1N6errKy8sDxsvLy5WVlRVyn8zMzKD577//vjIyMsJar5YIawAAIlJQUKDVq1drzZo12rt3r2bPnq3q6mrl5eVJ+qVSnzhxYuv8vLw8HThwQAUFBdq7d6/WrFmj0tJSPfTQQ2GfkwfMAACIQG5urhoaGrRw4ULV1NRowIABKisrU2pqqiSppqYm4J3rtLQ0lZWVafbs2Vq2bJlSUlL07LPP6p577gn7nGG9Z+33++Xz+VRYWNhmawCwDf8uAHSU9n0pCgAA6DCsWQMA4HKENQAALkdYAwDgcoQ1AAAuR1gDAOByhDUAAC5HWAMA4HKENQAALkdYAwDgcoQ1AAAuR1gDAOBy/xeNIPH0pFoBpAAAAABJRU5ErkJggg==", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -247,14 +241,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -289,14 +281,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -311,14 +301,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -333,14 +321,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -355,14 +341,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -486,14 +470,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -510,14 +492,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -555,14 +535,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -598,14 +576,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -633,17 +609,17 @@ "output_type": "stream", "text": [ " === Starting experiment === \n", - " Reward condition: Right, Observation: [CENTER, No reward, Cue Left]\n", + " Reward condition: Left, Observation: [CENTER, No reward, Cue Left]\n", "[Step 0] Action: [Move to CUE LOCATION]\n", - "[Step 0] Observation: [CUE LOCATION, No reward, Cue Right]\n", - "[Step 1] Action: [Move to RIGHT ARM]\n", - "[Step 1] Observation: [RIGHT ARM, Reward!, Cue Right]\n", - "[Step 2] Action: [Move to RIGHT ARM]\n", - "[Step 2] Observation: [RIGHT ARM, Reward!, Cue Left]\n", - "[Step 3] Action: [Move to RIGHT ARM]\n", - "[Step 3] Observation: [RIGHT ARM, Reward!, Cue Right]\n", - "[Step 4] Action: [Move to RIGHT ARM]\n", - "[Step 4] Observation: [RIGHT ARM, Reward!, Cue Right]\n" + "[Step 0] Observation: [CUE LOCATION, No reward, Cue Left]\n", + "[Step 1] Action: [Move to LEFT ARM]\n", + "[Step 1] Observation: [LEFT ARM, Reward!, Cue Right]\n", + "[Step 2] Action: [Move to LEFT ARM]\n", + "[Step 2] Observation: [LEFT ARM, Reward!, Cue Right]\n", + "[Step 3] Action: [Move to LEFT ARM]\n", + "[Step 3] Observation: [LEFT ARM, Reward!, Cue Right]\n", + "[Step 4] Action: [Move to LEFT ARM]\n", + "[Step 4] Observation: [LEFT ARM, Reward!, Cue Left]\n" ] } ], @@ -705,14 +681,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -727,14 +701,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -763,14 +735,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -788,7 +758,7 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ @@ -825,9 +795,9 @@ " action = data['actions'][t]\n", " for factor_idx, m in enumerate(marginal):\n", " log_prob += jmaths.log_stable(m[action[factor_idx]])\n", - " \n", + " \n", + " # action = npyro.sample('action', dist.CategoricalProbs(marginal), obs=action)\n", " agent.update_empirical_prior(action)\n", - " \n", " return log_prob, None\n", " \n", " log_prob = 0.\n", @@ -838,26 +808,26 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'actions': DeviceArray([[3, 0],\n", - " [1, 0],\n", - " [1, 0],\n", - " [1, 0],\n", - " [1, 0]], dtype=int32),\n", + " [2, 0],\n", + " [2, 0],\n", + " [2, 0],\n", + " [2, 0]], dtype=int32),\n", " 'outcomes': DeviceArray([[0, 0, 1],\n", - " [3, 0, 0],\n", - " [1, 1, 0],\n", - " [1, 1, 1],\n", - " [1, 1, 0],\n", - " [1, 1, 0]], dtype=int32)}" + " [3, 0, 1],\n", + " [2, 1, 0],\n", + " [2, 1, 0],\n", + " [2, 1, 0],\n", + " [2, 1, 1]], dtype=int32)}" ] }, - "execution_count": 58, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } @@ -868,7 +838,7 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 31, "metadata": { "scrolled": true }, @@ -876,10 +846,10 @@ { "data": { "text/plain": [ - "DeviceArray(-9.186155, dtype=float32)" + "DeviceArray(-20.578611, dtype=float32)" ] }, - "execution_count": 62, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } @@ -889,8 +859,9 @@ "from functools import partial\n", "\n", "# parameters have to be jax arrays, lists or dictionaries of jax arrays\n", + "e = 1e-10\n", "params = {\n", - " 'A': [jnp.array(x) for x in list(A_gp)],\n", + " 'A': [jnp.array((x + e)/(x + e).sum(0) ) for x in list(A_gp)],\n", " 'B': [jnp.array(x) for x in list(B_gp)],\n", " 'C': [jnp.array(x) for x in list(agent.C)],\n", " 'D': [jnp.array(x) for x in list(agent.D)]\n", @@ -901,16 +872,37 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "DeviceArray(-9.186155, dtype=float32)" + "[DeviceArray([1., 0., 0., 0.], dtype=float32),\n", + " DeviceArray([0.5, 0.5], dtype=float32)]" ] }, - "execution_count": 63, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "params['D']" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DeviceArray(-20.578611, dtype=float32)" + ] + }, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -921,86 +913,102 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 69, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'A': [DeviceArray([[[nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan]],\n", + "{'A': [DeviceArray([[[ 5.7870839e-03, -5.7870746e-03],\n", + " [ 5.7870840e+07, -5.7870744e+07],\n", + " [ 5.7870840e+07, -5.7870744e+07],\n", + " [ 5.7870840e+07, -5.7870744e+07]],\n", " \n", - " [[nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan]],\n", + " [[ 0.0000000e+00, -1.1920929e-07],\n", + " [ 0.0000000e+00, 0.0000000e+00],\n", + " [-5.7183206e-06, 0.0000000e+00],\n", + " [ 2.3283064e-10, 0.0000000e+00]],\n", " \n", - " [[nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan]],\n", + " [[-2.5848984e+08, 2.5849042e+08],\n", + " [-2.5848984e+08, 2.5849042e+08],\n", + " [-2.5848985e-02, 2.5849041e-02],\n", + " [-2.5848984e+08, 2.5849042e+08]],\n", " \n", - " [[nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan]]], dtype=float32),\n", - " DeviceArray([[[nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan]],\n", + " [[-4.3367730e+06, 4.3366850e+06],\n", + " [-4.3367730e+06, 4.3366850e+06],\n", + " [-4.3367730e+06, 4.3366850e+06],\n", + " [-4.3367731e-04, 4.3366849e-04]]], dtype=float32),\n", + " DeviceArray([[[ 5.35340654e-03, -5.35340607e-03],\n", + " [ 5.35340680e+07, -5.35340600e+07],\n", + " [ 5.35340680e+07, -5.35340600e+07],\n", + " [ 5.35340654e-03, -5.35340607e-03]],\n", " \n", - " [[nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan]],\n", + " [[-2.58489840e+08, 2.58490416e+08],\n", + " [-8.06309986e+00, 1.28330505e+00],\n", + " [ 7.23502064e+00, -2.27407408e+00],\n", + " [-2.58489840e+08, 2.58490416e+08]],\n", " \n", - " [[nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan]]], dtype=float32),\n", - " DeviceArray([[[nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan]],\n", + " [[ 4.54609841e-01, 3.03870082e-01],\n", + " [ 8.40551758e+00, 1.11163985e-02],\n", + " [-8.93804359e+00, 2.40763760e+00],\n", + " [ 4.54941571e-01, -2.68013167e+00]]], dtype=float32),\n", + " DeviceArray([[[-5.1697962e-02, 5.1698081e-02],\n", + " [-5.1697969e-02, 5.1698081e-02],\n", + " [-5.1697969e-02, 5.1698077e-02],\n", + " [-1.0056265e-02, 2.5849040e+08]],\n", " \n", - " [[nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan]]], dtype=float32)],\n", - " 'B': [DeviceArray([[[nan, nan, nan, nan],\n", - " [nan, nan, nan, nan],\n", - " [nan, nan, nan, nan],\n", - " [nan, nan, nan, nan]],\n", + " [[ 1.0706819e-02, -1.0706808e-02],\n", + " [ 1.0706813e-02, -1.0706812e-02],\n", + " [ 1.0706813e-02, -1.0706816e-02],\n", + " [ 5.3534068e+07, -5.3447243e-03]]], dtype=float32)],\n", + " 'B': [DeviceArray([[[ 7.5848001e-01, -1.1582707e+02, 9.4778961e+01,\n", + " 1.6476847e+01],\n", + " [ 1.0218215e-19, -2.5950433e-17, 2.8914750e-17,\n", + " -7.7291948e-19],\n", + " [ 1.0218187e-09, -2.5950365e-07, 2.8914673e-07,\n", + " -7.7291737e-09],\n", + " [ 4.8658388e-24, -4.0379652e-24, 1.4519616e-22,\n", + " -3.6805861e-23]],\n", " \n", - " [[nan, nan, nan, nan],\n", - " [nan, nan, nan, nan],\n", - " [nan, nan, nan, nan],\n", - " [nan, nan, nan, nan]],\n", + " [[-1.1004541e+01, 3.7408698e-01, 6.2804016e+01,\n", + " 3.0473413e+01],\n", + " [-1.5605089e-18, 7.6312736e-20, 1.7781013e-17,\n", + " -1.6702473e-18],\n", + " [-1.5605048e-08, 7.6312540e-10, 1.7780965e-07,\n", + " -1.6702430e-08],\n", + " [-6.5026783e-23, 5.4871828e-25, 6.9984117e-23,\n", + " -7.0052571e-23]],\n", " \n", - " [[nan, nan, nan, nan],\n", - " [nan, nan, nan, nan],\n", - " [nan, nan, nan, nan],\n", - " [nan, nan, nan, nan]],\n", + " [[-1.0715122e+01, -5.5861778e+01, -1.7399567e+01,\n", + " 3.6492748e+01],\n", + " [-1.3655559e-18, -1.2508033e-17, -3.9292204e-18,\n", + " -1.4710969e-18],\n", + " [-1.3655523e-08, -1.2507999e-07, -3.9292100e-08,\n", + " -1.4710931e-08],\n", + " [-7.4310293e-23, -2.4831308e-24, -4.2698068e-25,\n", + " -7.9535960e-23]],\n", " \n", - " [[nan, nan, nan, nan],\n", - " [nan, nan, nan, nan],\n", - " [nan, nan, nan, nan],\n", - " [nan, nan, nan, nan]]], dtype=float32),\n", - " DeviceArray([[[nan],\n", - " [nan]],\n", + " [[-5.2383151e+00, -1.1769194e+02, 9.6304901e+01,\n", + " -2.2093873e+00],\n", + " [-7.0570387e-19, -2.6368245e-17, 2.9380284e-17,\n", + " 1.0364109e-19],\n", + " [-7.0570199e-09, -2.6368178e-07, 2.9380206e-07,\n", + " 1.0364081e-09],\n", + " [-3.3605105e-23, -4.1029776e-24, 1.4753386e-22,\n", + " 4.9353130e-24]]], dtype=float32),\n", + " DeviceArray([[[-16.28082 ],\n", + " [ 4.493703 ]],\n", " \n", - " [[nan],\n", - " [nan]]], dtype=float32)],\n", - " 'C': [DeviceArray([-0.25163049, 1.3047824 , -1.8015202 , 0.748369 ], dtype=float32),\n", - " DeviceArray([ 0.4967385, -1.4332426, 0.9365047], dtype=float32),\n", - " DeviceArray([-0.5251627, 0.5251632], dtype=float32)],\n", - " 'D': [DeviceArray([nan, nan, nan, nan], dtype=float32),\n", - " DeviceArray([nan, nan], dtype=float32)]}" + " [[ 16.497871 ],\n", + " [ -2.1955678]]], dtype=float32)],\n", + " 'C': [DeviceArray([-0.2528267 , -2.6904182 , 2.2015145 , 0.74172956], dtype=float32),\n", + " DeviceArray([ 0.48890284, -3.3255424 , 2.8366387 ], dtype=float32),\n", + " DeviceArray([-0.5225125, 0.5225114], dtype=float32)],\n", + " 'D': [DeviceArray([ 0., nan, nan, nan], dtype=float32),\n", + " DeviceArray([-0.16396463, 0.16396508], dtype=float32)]}" ] }, - "execution_count": 64, + "execution_count": 69, "metadata": {}, "output_type": "execute_result" } @@ -1010,6 +1018,155 @@ "jax.grad(jax.jit(partial(model_log_likelihood, T, measurments)))(params)" ] }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [], + "source": [ + "import numpyro as npyro\n", + "import numpyro.distributions as dist\n", + "from jax import nn, lax\n", + "\n", + "def trans_params(z):\n", + "\n", + " a = nn.sigmoid(z[0])\n", + " lam = nn.softplus(z[1])\n", + " d = z[2:]\n", + "\n", + " A = lax.stop_gradient([jnp.array(x) for x in list(A_gp)])\n", + "\n", + " middle_matrix1 = jnp.array([[0.0, 0.0], [a, 1-a], [1-a, a]])\n", + " middle_matrix2 = jnp.array([[0.0, 0.0], [1-a, a], [a, 1-a]])\n", + "\n", + " side_vector = jnp.stack([jnp.array([1.0, 0.0, 0.0]), jnp.array([1.0, 0.0, 0.0])], -1)\n", + "\n", + " # A[1] = jnp.stack([side_vector, middle_matrix1, middle_matrix2, side_vector], -2)\n", + " \n", + " C = lax.stop_gradient([jnp.array(x) for x in list(agent.C)])\n", + " C[1] = lam * jnp.array([0., -1., 1.])\n", + "\n", + " D = [nn.one_hot(0, 4), d]\n", + "\n", + " params = {\n", + " 'A': A,\n", + " 'B': lax.stop_gradient([jnp.array(x) for x in list(B_gp)]),\n", + " 'C': C,\n", + " 'D': D\n", + " }\n", + "\n", + " return params\n", + "\n", + "def model(data, T, n_pars=3):\n", + " z = npyro.sample('z', dist.Normal(0., 1.).expand([n_pars]))\n", + "\n", + " params = trans_params(z)\n", + "\n", + " log_prob = model_log_likelihood(T, data, params)\n", + " npyro.factor('log_prob', log_prob)\n", + "\n", + " return log_prob" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DeviceArray([ 0. , -0.10822758, nan, nan], dtype=float32)" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "jax.grad(lambda x: model_log_likelihood(T, measurments, trans_params(x)))(jnp.ones(4)/2)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[DeviceArray([[0., 0., 0.],\n", + " [0., 0., 0.],\n", + " [0., 0., 0.],\n", + " [0., 0., 0.]], dtype=float32),\n", + " DeviceArray([[ 0. , 0. , 0.19661196],\n", + " [ 0. , 0. , -0.19661196]], dtype=float32)]" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "out = jax.jacobian(trans_params)(jnp.ones(3))\n", + "out['D']" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-7.0516567\n" + ] + } + ], + "source": [ + "with npyro.handlers.seed(rng_seed=101111):\n", + " lp = model(measurments, T)\n", + " print(lp)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "ename": "RuntimeError", + "evalue": "Cannot find valid initial parameters. Please check your model again.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn [43], line 8\u001b[0m\n\u001b[1;32m 5\u001b[0m kernel \u001b[38;5;241m=\u001b[39m NUTS(model, init_strategy\u001b[38;5;241m=\u001b[39minit_to_feasible)\n\u001b[1;32m 7\u001b[0m mcmc \u001b[38;5;241m=\u001b[39m MCMC(kernel, num_warmup\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m10\u001b[39m, num_samples\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m10\u001b[39m)\n\u001b[0;32m----> 8\u001b[0m samples \u001b[38;5;241m=\u001b[39m \u001b[43mmcmc\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrandom\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mPRNGKey\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmeasurments\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mT\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/mcmc.py:593\u001b[0m, in \u001b[0;36mMCMC.run\u001b[0;34m(self, rng_key, extra_fields, init_params, *args, **kwargs)\u001b[0m\n\u001b[1;32m 591\u001b[0m map_args \u001b[39m=\u001b[39m (rng_key, init_state, init_params)\n\u001b[1;32m 592\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mnum_chains \u001b[39m==\u001b[39m \u001b[39m1\u001b[39m:\n\u001b[0;32m--> 593\u001b[0m states_flat, last_state \u001b[39m=\u001b[39m partial_map_fn(map_args)\n\u001b[1;32m 594\u001b[0m states \u001b[39m=\u001b[39m tree_map(\u001b[39mlambda\u001b[39;00m x: x[jnp\u001b[39m.\u001b[39mnewaxis, \u001b[39m.\u001b[39m\u001b[39m.\u001b[39m\u001b[39m.\u001b[39m], states_flat)\n\u001b[1;32m 595\u001b[0m \u001b[39melse\u001b[39;00m:\n", + "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/mcmc.py:381\u001b[0m, in \u001b[0;36mMCMC._single_chain_mcmc\u001b[0;34m(self, init, args, kwargs, collect_fields)\u001b[0m\n\u001b[1;32m 379\u001b[0m rng_key, init_state, init_params \u001b[39m=\u001b[39m init\n\u001b[1;32m 380\u001b[0m \u001b[39mif\u001b[39;00m init_state \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 381\u001b[0m init_state \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msampler\u001b[39m.\u001b[39;49minit(\n\u001b[1;32m 382\u001b[0m rng_key,\n\u001b[1;32m 383\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mnum_warmup,\n\u001b[1;32m 384\u001b[0m init_params,\n\u001b[1;32m 385\u001b[0m model_args\u001b[39m=\u001b[39;49margs,\n\u001b[1;32m 386\u001b[0m model_kwargs\u001b[39m=\u001b[39;49mkwargs,\n\u001b[1;32m 387\u001b[0m )\n\u001b[1;32m 388\u001b[0m sample_fn, postprocess_fn \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_get_cached_fns()\n\u001b[1;32m 389\u001b[0m diagnostics \u001b[39m=\u001b[39m (\n\u001b[1;32m 390\u001b[0m \u001b[39mlambda\u001b[39;00m x: \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msampler\u001b[39m.\u001b[39mget_diagnostics_str(x[\u001b[39m0\u001b[39m])\n\u001b[1;32m 391\u001b[0m \u001b[39mif\u001b[39;00m rng_key\u001b[39m.\u001b[39mndim \u001b[39m==\u001b[39m \u001b[39m1\u001b[39m\n\u001b[1;32m 392\u001b[0m \u001b[39melse\u001b[39;00m \u001b[39m\"\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 393\u001b[0m ) \u001b[39m# noqa: E731\u001b[39;00m\n", + "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/hmc.py:706\u001b[0m, in \u001b[0;36mHMC.init\u001b[0;34m(self, rng_key, num_warmup, init_params, model_args, model_kwargs)\u001b[0m\n\u001b[1;32m 701\u001b[0m \u001b[39m# vectorized\u001b[39;00m\n\u001b[1;32m 702\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 703\u001b[0m rng_key, rng_key_init_model \u001b[39m=\u001b[39m jnp\u001b[39m.\u001b[39mswapaxes(\n\u001b[1;32m 704\u001b[0m vmap(random\u001b[39m.\u001b[39msplit)(rng_key), \u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m\n\u001b[1;32m 705\u001b[0m )\n\u001b[0;32m--> 706\u001b[0m init_params \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_init_state(\n\u001b[1;32m 707\u001b[0m rng_key_init_model, model_args, model_kwargs, init_params\n\u001b[1;32m 708\u001b[0m )\n\u001b[1;32m 709\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_potential_fn \u001b[39mand\u001b[39;00m init_params \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 710\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[1;32m 711\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mValid value of `init_params` must be provided with\u001b[39m\u001b[39m\"\u001b[39m \u001b[39m\"\u001b[39m\u001b[39m `potential_fn`.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 712\u001b[0m )\n", + "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/hmc.py:652\u001b[0m, in \u001b[0;36mHMC._init_state\u001b[0;34m(self, rng_key, model_args, model_kwargs, init_params)\u001b[0m\n\u001b[1;32m 650\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_init_state\u001b[39m(\u001b[39mself\u001b[39m, rng_key, model_args, model_kwargs, init_params):\n\u001b[1;32m 651\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_model \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 652\u001b[0m init_params, potential_fn, postprocess_fn, model_trace \u001b[39m=\u001b[39m initialize_model(\n\u001b[1;32m 653\u001b[0m rng_key,\n\u001b[1;32m 654\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_model,\n\u001b[1;32m 655\u001b[0m dynamic_args\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m,\n\u001b[1;32m 656\u001b[0m init_strategy\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_init_strategy,\n\u001b[1;32m 657\u001b[0m model_args\u001b[39m=\u001b[39;49mmodel_args,\n\u001b[1;32m 658\u001b[0m model_kwargs\u001b[39m=\u001b[39;49mmodel_kwargs,\n\u001b[1;32m 659\u001b[0m forward_mode_differentiation\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_forward_mode_differentiation,\n\u001b[1;32m 660\u001b[0m )\n\u001b[1;32m 661\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_init_fn \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 662\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_init_fn, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_sample_fn \u001b[39m=\u001b[39m hmc(\n\u001b[1;32m 663\u001b[0m potential_fn_gen\u001b[39m=\u001b[39mpotential_fn,\n\u001b[1;32m 664\u001b[0m kinetic_fn\u001b[39m=\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_kinetic_fn,\n\u001b[1;32m 665\u001b[0m algo\u001b[39m=\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_algo,\n\u001b[1;32m 666\u001b[0m )\n", + "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/util.py:698\u001b[0m, in \u001b[0;36minitialize_model\u001b[0;34m(rng_key, model, init_strategy, dynamic_args, model_args, model_kwargs, forward_mode_differentiation, validate_grad)\u001b[0m\n\u001b[1;32m 685\u001b[0m w\u001b[39m.\u001b[39mmessage\u001b[39m.\u001b[39margs \u001b[39m=\u001b[39m (\n\u001b[1;32m 686\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mSite \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m: \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m\"\u001b[39m\u001b[39m.\u001b[39mformat(\n\u001b[1;32m 687\u001b[0m site[\u001b[39m\"\u001b[39m\u001b[39mname\u001b[39m\u001b[39m\"\u001b[39m], w\u001b[39m.\u001b[39mmessage\u001b[39m.\u001b[39margs[\u001b[39m0\u001b[39m]\n\u001b[1;32m 688\u001b[0m ),\n\u001b[1;32m 689\u001b[0m ) \u001b[39m+\u001b[39m w\u001b[39m.\u001b[39mmessage\u001b[39m.\u001b[39margs[\u001b[39m1\u001b[39m:]\n\u001b[1;32m 690\u001b[0m warnings\u001b[39m.\u001b[39mshowwarning(\n\u001b[1;32m 691\u001b[0m w\u001b[39m.\u001b[39mmessage,\n\u001b[1;32m 692\u001b[0m w\u001b[39m.\u001b[39mcategory,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 696\u001b[0m line\u001b[39m=\u001b[39mw\u001b[39m.\u001b[39mline,\n\u001b[1;32m 697\u001b[0m )\n\u001b[0;32m--> 698\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mRuntimeError\u001b[39;00m(\n\u001b[1;32m 699\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mCannot find valid initial parameters. Please check your model again.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 700\u001b[0m )\n\u001b[1;32m 701\u001b[0m \u001b[39mreturn\u001b[39;00m ModelInfo(\n\u001b[1;32m 702\u001b[0m ParamInfo(init_params, pe, grad), potential_fn, postprocess_fn, model_trace\n\u001b[1;32m 703\u001b[0m )\n", + "\u001b[0;31mRuntimeError\u001b[0m: Cannot find valid initial parameters. Please check your model again." + ] + } + ], + "source": [ + "# change this to SVI and autoguides\n", + "from numpyro.infer import NUTS, MCMC\n", + "from numpyro.infer import init_to_feasible, init_to_sample\n", + "from jax import random\n", + "\n", + "kernel = NUTS(model, init_strategy=init_to_feasible)\n", + "\n", + "mcmc = MCMC(kernel, num_warmup=10, num_samples=10)\n", + "samples = mcmc.run(random.PRNGKey(0), measurments, T)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -1019,11 +1176,8 @@ } ], "metadata": { - "interpreter": { - "hash": "24ee14d9f6452059a99d44b6cbd71d1bb479b0539b0360a6a17428ecea9f0810" - }, "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3.9.12 ('pymdp')", "language": "python", "name": "python3" }, @@ -1037,7 +1191,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.12" + "version": "3.9.13" + }, + "vscode": { + "interpreter": { + "hash": "4e1a08fe767a14203a671ee5de76a8a25ed3badbbf81ba1baf234489164a8ba4" + } } }, "nbformat": 4, diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index c319093d..6e1c3bed 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -363,7 +363,7 @@ def update_B(self, qs_prev): Posterior Dirichlet parameters over transition model (same shape as ``B``), after having updated it with state beliefs and actions. """ - pB_updated = learning.update_state_likelihood_dirichlet( + qB = learning.update_state_likelihood_dirichlet( self.pB, self.B, self.action, @@ -417,9 +417,9 @@ def update_D(self, qs_t0 = None): # get beliefs about policies at the time at the beginning of the inference horizon if hasattr(self, "q_pi_hist"): begin_horizon_step = max(0, self.curr_timestep - self.inference_horizon) - q_pi_t0 = np.copy(self.q_pi_hist[begin_horizon_step]) + q_pi_t0 = self.q_pi_hist[begin_horizon_step].copy() else: - q_pi_t0 = np.copy(self.q_pi) + q_pi_t0 = self.q_pi.copy() qs_t0 = inference.average_states_over_policies(qs_pi_t0,q_pi_t0) # beliefs about hidden states at the first timestep of the inference horizon diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index 8d16aec4..cb0f8f9c 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -12,7 +12,7 @@ # import pymdp.jax.utils as utils -def update_posterior_policies(policy_matrix, qs_init, A, B, C, gamma = 16.0): +def update_posterior_policies(policy_matrix, qs_init, A, B, C, gamma=16.0): # policy --> n_levels_factor_f x 1 # factor --> n_levels_factor_f x n_policies ## vmap across policies From 475d1f892af65dc8a8a091e295dc159036a4f005 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Mon, 19 Sep 2022 13:43:33 +0200 Subject: [PATCH 015/232] added examples for mcmc and svi posterior estimates --- examples/model_inversion.ipynb | 437 +++++++++++++++++++-------------- 1 file changed, 253 insertions(+), 184 deletions(-) diff --git a/examples/model_inversion.ipynb b/examples/model_inversion.ipynb index c820bf18..d6f63b58 100644 --- a/examples/model_inversion.ipynb +++ b/examples/model_inversion.ipynb @@ -150,7 +150,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -172,7 +172,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -194,7 +194,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAesAAAGiCAYAAADHpO4FAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAg+ElEQVR4nO3dfWxUZf738c+00CmCrUq1UPRXCouKEtzQLthqBUSroKwYDSX440kgdJUlpSvRUhcKC8z6uOgKBaRAjIgoik9b0Sao4FIT6V1Rgai7IA3Y0rRGCipTWs79h6G3w0xhpvdQzuX1fiXnDy+u80SCn/l+r3NmPI7jOAIAAK4Vc74vAAAAnBlhDQCAyxHWAAC4HGENAIDLEdYAALgcYQ0AgMsR1gAAuBxhDQCAyxHWAAC4HGGNDvf5559rypQpSktLU3x8vLp166ZBgwbp8ccf1/fff9/h1zNs2DB5PB716dNHob7Qb9u2bfJ4PPJ4PFq3bl2HX19bevfurcmTJ5/vywDQATqd7wuAXZ5//nk98MADuuqqqzRnzhxdc801OnHihHbu3KkVK1aooqJCmzdv7vDruvDCC7V//35t3bpVI0aMCPizNWvWKCEhQY2NjR1+XWeyefNmJSQknO/LANABPHw3ODpKRUWFsrOzdeutt+qNN96Q1+sN+POmpiZt2bJFf/zjHzv0uoYNG6b6+npdeOGF6tOnj9avX9/6Z0ePHlWPHj1033336fnnn9fatWupZgF0ONrg6DBLliyRx+PRqlWrgoJakuLi4gKC2uPxqLi4OGheqPZvbW2tZsyYocsvv1xxcXFKS0vTggUL1NzcHPb13X///Xr99df1ww8/tI69/PLLkqRx48YFzf/Pf/6jKVOmqF+/frrgggvUq1cvjR49Wl988UXAvA8//FAej0cvvviiCgoK1KNHD3Xp0kVDhw5VVVVVwNzJkyerW7du2r17t0aMGKGuXbvq0ksv1cyZM/XTTz+d8e/h1Hk2bNigoqIipaSkKCEhQbfccou++uqrgH0dx9GSJUuUmpqq+Ph4ZWRkqLy8XMOGDdOwYcPC/jsD0DEIa3SIlpYWbd26Venp6briiiuieuza2loNHjxY7733nubNm6d3331XU6dOlc/n0/Tp08M+zrhx4xQbG6sNGza0jpWWluree+8N2W7+7rvv1L17d/3973/Xli1btGzZMnXq1ElDhgwJCkdJmjt3rvbt26fVq1dr9erV+u677zRs2DDt27cvYN6JEyc0atQojRgxQm+88YZmzpyplStXKjc3N6z7mDt3rg4cOKDVq1dr1apV+uabbzR69Gi1tLS0zikqKlJRUZFuv/12vfnmm8rLy9O0adP09ddfh/vXBaAjOUAHqK2tdSQ548aNC3sfSc78+fODxlNTU51Jkya1/veMGTOcbt26OQcOHAiY9+STTzqSnN27d5/xPEOHDnWuvfZax3EcZ9KkSU5GRobjOI6ze/duR5Lz4YcfOp9++qkjyVm7dm2bx2lubnaampqcfv36ObNnz24d/+CDDxxJzqBBg5yTJ0+2jn/77bdO586dnWnTprWOTZo0yZHkPPPMMwHHXrx4sSPJ+fjjj9v8ezh1nlGjRgXs+8orrziSnIqKCsdxHOf77793vF6vk5ubGzCvoqLCkeQMHTr0DH9bAM4HKmsY75133tHw4cOVkpKi5ubm1m3kyJGSpI8++ijsY91///3auXOnvvjiC5WWlqpv37666aabQs5tbm7WkiVLdM011yguLk6dOnVSXFycvvnmG+3duzdo/vjx4+XxeFr/OzU1VVlZWfrggw+C5t53331B+0oKOfd0p6/5Dxw4UJJ04MABSdInn3wiv9+vsWPHBsy7/vrr1bt377MeH0DH42lwdIikpCRdcMEF2r9/f9SPffjwYb399tvq3LlzyD+vr68P+1g33XST+vXrp5UrV+qVV15Rfn5+QMD+WkFBgZYtW6aHH35YQ4cO1cUXX6yYmBhNmzZNP//8c9D8Hj16hBzbtWtXwFinTp3UvXv3kPs2NDSc9R5O3/fU8wGnrunUMZKTk4P2DTUG4PwjrNEhYmNjNWLECL377rs6ePCgLr/88rPu4/V65ff7g8ZPD6ykpCQNHDhQixcvDnmclJSUiK51ypQpevTRR+XxeDRp0qQ257344ouaOHGilixZEjBeX1+viy66KGh+bW1tyLHTw7W5uVkNDQ0B46f2PX1ue5w6xuHDh0NeD9U14D60wdFhCgsL5TiOpk+frqampqA/P3HihN5+++3W/+7du7c+//zzgDlbt27VsWPHAsbuvPNOffnll+rbt68yMjKCtkjDetKkSRo9erTmzJmjXr16tTnP4/EEPdX+r3/9S4cOHQo5f8OGDQFfunLgwAHt2LEj5NPXv359TJJeeuklSYrKk9pDhgyR1+vVxo0bA8Y/+eST1lY5AHehskaHyczMVElJiR544AGlp6frT3/6k6699lqdOHFCVVVVWrVqlQYMGKDRo0dLkiZMmKC//vWvmjdvnoYOHao9e/boueeeU2JiYsBxFy5cqPLycmVlZWnWrFm66qqrdPz4cX377bcqKyvTihUrwqrkT0lJSdEbb7xx1nl33nmn1q1bp6uvvloDBw5UZWWlnnjiiTbPVVdXp7vvvlvTp0/XkSNHNH/+fMXHx6uwsDBgXlxcnJ566ikdO3ZMf/jDH7Rjxw4tWrRII0eO1I033hj2fbTlkksuUUFBgXw+ny6++GLdfffdOnjwoBYsWKCePXsqJobP8IDbENboUNOnT9fgwYP1j3/8Q4899phqa2vVuXNnXXnllRo/frxmzpzZOnfOnDlqbGzUunXr9OSTT2rw4MF65ZVXdNdddwUcs2fPntq5c6f+9re/6YknntDBgwd14YUXKi0tTbfffrsuvvjic3IvzzzzjDp37iyfz6djx45p0KBBev311/Xoo4+GnL9kyRJ9+umnmjJlihobGzV48GC9/PLL6tu3b8C8zp0765133tGsWbO0aNEidenSRdOnT9cTTzwRtWtfvHixunbtqhUrVmjt2rW6+uqrVVJSoqKiopAtfADnF99gBpxjH374oYYPH65XX31V99577xnnTp48WZs2bQpq9XeE/fv36+qrr9b8+fM1d+7cDj8/gLZRWQMW2rVrlzZs2KCsrCwlJCToq6++0uOPP66EhARNnTr1fF8egNMQ1oCFunbtqp07d6q0tFQ//PCDEhMTNWzYMC1evJjXtwAXog0OAIDL8dgnAABh2rZtm0aPHq2UlBR5PJ6w3hz56KOPlJ6ervj4ePXp00crVqyI+LyENQAAYfrxxx913XXX6bnnngtr/v79+zVq1ChlZ2erqqpKc+fO1axZs/Taa69FdF7a4AAAtIPH49HmzZs1ZsyYNuc8/PDDeuuttwJ+LyAvL0+7du1SRUVF2OcK+YCZ3+8P+ppHr9cb8jeIAQAw2bnMvIqKCuXk5ASM3XbbbSotLdWJEyfa/E2D04UMa5/PpwULFgSMzZ8/X8XFxe27WgAAoqy4jR/Zidj8+ecs82pra4PesEhOTlZzc7Pq6+vVs2fPsI4TMqwLCwtVUFAQMEZVDQBwk2g9dPXwOc6803+579Tqc1u/6BdKyLCm5Q0AsMW5zLwePXoE/eJeXV1dyJ/CPZN2fSlK1FoPgKGKQz2XefzsvzUN/ObF////jGu4TEiizMzMgF8TlKT3339fGRkZYa9XS7y6BQAwVEyUtkgcO3ZMn332mT777DNJv7ya9dlnn6m6ulrSL8vIEydObJ2fl5enAwcOqKCgQHv37tWaNWtUWlqqhx56KKLz8nWjAACEaefOnRo+fHjrf59a6540aZLWrVunmpqa1uCWpLS0NJWVlWn27NlatmyZUlJS9Oyzz+qee+6J6Lztes+aNjhsRxscaEMHtsF9UcqiQgO+boTKGgBgJJvKRtasAQBwOSprAICRbKo2CWsAgJFsaoMT1gAAI9lUWdt0rwAAGInKGgBgJJuqTcIaAGAkm9asbfpgAgCAkaisAQBGsqnaJKwBAEayKaxtulcAAIxEZQ0AMJJND5gR1gAAI9nUGrbpXgEAMBKVNQDASLTBAQBwOZtaw4Q1AMBINoW1TfcKAICRqKwBAEZizRoAAJezqTVs070CAGAkKmsAgJFsqjYJawCAkWxas7bpgwkAAEaisgYAGMmmapOwBgAYyaawtuleAQAwEpU1AMBINj1gRlgDAIxkU2uYsAYAGMmmytqmDyYAABiJyhoAYCSbqk3CGgBgJJvC2qZ7BQDASFTWAAAj2fSAGWENADCSTa1hm+4VAAAjUVkDAIxkU7VJWAMAjGTTmrVNH0wAADASlTUAwEieGHtqa8IaAGAkj4ewBgDA1WIsqqxZswYAwOWorAEARqINDgCAy9n0gBltcAAAXI7KGgBgJNrgAAC4HG1wAADgGlTWAAAj0QYHAMDlaIMDAADXoLIGABiJNjgAAC5n03eDE9YAACPZVFmzZg0AgMtRWQMAjGTT0+CENQDASLTBAQCAa1BZAwCMRBscAACXow0OAADatHz5cqWlpSk+Pl7p6enavn37GeevX79e1113nS644AL17NlTU6ZMUUNDQ9jnI6wBAEbyxHiiskVq48aNys/PV1FRkaqqqpSdna2RI0equro65PyPP/5YEydO1NSpU7V79269+uqr+vTTTzVt2rSwz0lYAwCM5PF4orJF6umnn9bUqVM1bdo09e/fX0uXLtUVV1yhkpKSkPM/+eQT9e7dW7NmzVJaWppuvPFGzZgxQzt37gz7nIQ1AMBqfr9fjY2NAZvf7w85t6mpSZWVlcrJyQkYz8nJ0Y4dO0Luk5WVpYMHD6qsrEyO4+jw4cPatGmT7rjjjrCvkbAGABgpJsYTlc3n8ykxMTFg8/l8Ic9ZX1+vlpYWJScnB4wnJyertrY25D5ZWVlav369cnNzFRcXpx49euiiiy7SP//5z/DvNfy/FgAA3CNabfDCwkIdOXIkYCssLDzruX/NcZw2W+p79uzRrFmzNG/ePFVWVmrLli3av3+/8vLywr5XXt0CABgpWu9Ze71eeb3esOYmJSUpNjY2qIquq6sLqrZP8fl8uuGGGzRnzhxJ0sCBA9W1a1dlZ2dr0aJF6tmz51nPS2UNAECY4uLilJ6ervLy8oDx8vJyZWVlhdznp59+UkxMYNzGxsZK+qUiDweVNQDASOfrS1EKCgo0YcIEZWRkKDMzU6tWrVJ1dXVrW7uwsFCHDh3SCy+8IEkaPXq0pk+frpKSEt12222qqalRfn6+Bg8erJSUlLDOSVgDAIzkOU+94dzcXDU0NGjhwoWqqanRgAEDVFZWptTUVElSTU1NwDvXkydP1tGjR/Xcc8/pL3/5iy666CLdfPPNeuyxx8I+p8cJtwb/lWKLvuINCKU41D+b4+F/GxHwmxXfvcNO9X9+F3qNOFKD/nM4Ksc5l6isAQBGsum7wQlrAICRbPrVLZ4GBwDA5aisAQBGiqENDgCAu9EGBwAArkFlDQAwEk+DAwDgcja1wQlrAICRbKqsWbMGAMDlqKwBAEaiDQ4AgMvRBgcAAK5BZQ0AMJInxp56k7AGABjJpjVrez6WAABgKCprAICZLHrAjLAGABiJNjgAAHANKmsAgJF4GhwAAJez6UtRCGsAgJlYswYAAG5BZQ0AMBJr1gAAuJxNa9b2fCwBAMBQVNYAACPZ9KUohDUAwEwWhTVtcAAAXI7KGgBgJI/HnnqTsAYAGMmmNWt7PpYAAGAoKmsAgJFsqqwJawCAmVizBgDA3WyqrO35WAIAgKGorAEARrKpsiasAQBG4oc8AACAa1BZAwDMxO9ZAwDgbjatWdvzsQQAAENRWQMAjGTTA2aENQDASB6L1qztuVMAAAxFZQ0AMJJND5gR1gAAM7FmDQCAu9lUWbNmDQCAy1FZAwCMZNPT4IQ1AMBINr1nbc/HEgAADEVlDQAwk0UPmBHWAAAj2bRmbc+dAgBgKCprAICRbHrAjLAGABiJL0UBAACuQWUNADATbXAAANzNpjY4YQ0AMJM9Wc2aNQAAbkdlDQAwk0Vr1lTWAAAjeTzR2dpj+fLlSktLU3x8vNLT07V9+/Yzzvf7/SoqKlJqaqq8Xq/69u2rNWvWhH0+KmsAACKwceNG5efna/ny5brhhhu0cuVKjRw5Unv27NH//M//hNxn7NixOnz4sEpLS/W73/1OdXV1am5uDvucHsdxnEgvtNii1gMQSnGofzbHGzr+QgC3ie/eYadq/POdUTlOwj/fiWj+kCFDNGjQIJWUlLSO9e/fX2PGjJHP5wuav2XLFo0bN0779u3TJZdc0q5rpA0OADBStNrgfr9fjY2NAZvf7w95zqamJlVWVionJydgPCcnRzt27Ai5z1tvvaWMjAw9/vjj6tWrl6688ko99NBD+vnnn8O+V8IaAGA1n8+nxMTEgC1UhSxJ9fX1amlpUXJycsB4cnKyamtrQ+6zb98+ffzxx/ryyy+1efNmLV26VJs2bdKDDz4Y9jWyZg0AMFOUlmQLCwtVUFAQMOb1es9y6sBzO47T5g+LnDx5Uh6PR+vXr1diYqIk6emnn9a9996rZcuWqUuXLme9RsIaAGCmKPWGvV7vWcP5lKSkJMXGxgZV0XV1dUHV9ik9e/ZUr169WoNa+mWN23EcHTx4UP369TvreWmDAwCM5PF4orJFIi4uTunp6SovLw8YLy8vV1ZWVsh9brjhBn333Xc6duxY69jXX3+tmJgYXX755WGdl7AGACACBQUFWr16tdasWaO9e/dq9uzZqq6uVl5enqRf2uoTJ05snT9+/Hh1795dU6ZM0Z49e7Rt2zbNmTNH999/f1gtcIk2OADAVOfpNeLc3Fw1NDRo4cKFqqmp0YABA1RWVqbU1FRJUk1Njaqrq1vnd+vWTeXl5frzn/+sjIwMde/eXWPHjtWiRYvCPifvWQPtwHvWQBs68D3rHx+6KyrH6frkm1E5zrlEGxwAAJejDQ4AMBO/Zw0AgMvZk9W0wQEAcDsqawCAkSJ9R9pkhDUAwEz2ZDVtcAAA3I7KGgBgJA9PgwMA4HL2ZDVhDQAwlEUPmLFmDQCAy1FZAwCMZFFhTVgDAAxl0QNmtMEBAHA5KmsAgJFogwMA4HYWpTVtcAAAXI7KGgBgJIsKa8IaAGAongYHAABuQWUNADCTRX1wwhoAYCSLspqwBgAYyqK0Zs0aAACXo7IGABjJY1G5SVgDAMxEGxwAALgFlTUAwEz2FNbtC+tix4n2dQDmi+9+vq8AsIrHojZ4yLD2+/3y+/0BY16vV16vt0MuCgAA/D8h16x9Pp8SExMDNp/P19HXBgBA22I80dkM4HGc4J42lTUAwO1alv5vVI4Tm/9iVI5zLoVsgxPMAAC4R/ueBj/eEOXLAAwT4mGyYosedgHa0qEPIBvSwo4GXt0CAJjJoq8wI6wBAGayqJtlz8cSAAAMRWUNADATa9YAALicRWvW9twpAACGorIGAJiJNjgAAC7H0+AAAMAtqKwBAGaKsafeJKwBAGaiDQ4AANyCyhoAYCba4AAAuJxFbXDCGgBgJovC2p4eAgAAhqKyBgCYiTVrAABcjjY4AABwCyprAICRPPyQBwAALsfvWQMAALegsgYAmIk2OAAALsfT4AAAwC2orAEAZuJLUQAAcDmL2uCENQDATBaFtT09BAAADEVYAwDMFBMTna0dli9frrS0NMXHxys9PV3bt28Pa79///vf6tSpk37/+99HdD7CGgBgJo8nOluENm7cqPz8fBUVFamqqkrZ2dkaOXKkqqurz7jfkSNHNHHiRI0YMSLicxLWAABE4Omnn9bUqVM1bdo09e/fX0uXLtUVV1yhkpKSM+43Y8YMjR8/XpmZmRGfk7AGAJgpxhOVze/3q7GxMWDz+/0hT9nU1KTKykrl5OQEjOfk5GjHjh1tXuratWv13//+V/Pnz2/frbZrLwAAzjdPTFQ2n8+nxMTEgM3n84U8ZX19vVpaWpScnBwwnpycrNra2pD7fPPNN3rkkUe0fv16derUvpeweHULAGC1wsJCFRQUBIx5vd4z7uM5ba3bcZygMUlqaWnR+PHjtWDBAl155ZXtvkbCGgBgpij9kIfX6z1rOJ+SlJSk2NjYoCq6rq4uqNqWpKNHj2rnzp2qqqrSzJkzJUknT56U4zjq1KmT3n//fd18881nPS9hDQAw03n4UpS4uDilp6ervLxcd999d+t4eXm57rrrrqD5CQkJ+uKLLwLGli9frq1bt2rTpk1KS0sL67yENQAAESgoKNCECROUkZGhzMxMrVq1StXV1crLy5P0S1v90KFDeuGFFxQTE6MBAwYE7H/ZZZcpPj4+aPxMCGsAgJnO0w955ObmqqGhQQsXLlRNTY0GDBigsrIypaamSpJqamrO+s51pDyO4zgR73W8IaoXARgnvnvQULFF31MMtKW4HZHSXiff/1tUjhOT89eoHOdcorIGAJjJog/IvGcNAIDLUVkDAMzksafeJKwBAGaypwtOGxwAALejsgYAmMmiB8wIawCAmSwKa9rgAAC4HJU1AMBMFlXWhDUAwFD2hDVtcAAAXI7KGgBgJnsKa8IaAGAo1qwBAHA5i8KaNWsAAFyOyhoAYCaLKmvCGgBgKHvCmjY4AAAuR2UNADCTPYU1YQ0AMJRFa9a0wQEAcDkqawCAmSyqrAlrAICh7Alr2uAAALgclTUAwEy0wQEAcDnCGgAAl7Mnq1mzBgDA7aisAQBmog0OAIDb2RPWtMEBAHA5KmsAgJlogwMA4HIWhTVtcAAAXI7KGgBgJnsKa8IaAGAo2uAAAMAtqKwBAIayp7ImrAEAZrKoDU5YAwDMZFFYs2YNAIDLUVkDAMxEZQ0AANyCsAYAwOVogwMAzGRRG5ywBgCYyaKwpg0OAIDLUVkDAMxkUWVNWAMADGVPWNMGBwDA5aisAQBmog0OAIDLeexpDhPWAABD2VNZ2/OxBAAAQ1FZAwDMxJo1AAAuZ9GatT13CgCAoaisAQCGog0OAIC7WbRmTRscAACXo7IGABjKnnqTsAYAmIk2OAAAcAvCGgBgJo8nOls7LF++XGlpaYqPj1d6erq2b9/e5tzXX39dt956qy699FIlJCQoMzNT7733XkTnI6wBAIbyRGmLzMaNG5Wfn6+ioiJVVVUpOztbI0eOVHV1dcj527Zt06233qqysjJVVlZq+PDhGj16tKqqqsK/U8dxnIiv9HhDxLsAvynx3YOGii1aPwPaUtyOSGmvk/99IyrHiek7JqL5Q4YM0aBBg1RSUtI61r9/f40ZM0Y+ny+sY1x77bXKzc3VvHnzwrvGiK4QAIDfGL/fr8bGxoDN7/eHnNvU1KTKykrl5OQEjOfk5GjHjh1hne/kyZM6evSoLrnkkrCvkbAGAJgpSmvWPp9PiYmJAVtbFXJ9fb1aWlqUnJwcMJ6cnKza2tqwLvupp57Sjz/+qLFjx4Z9q7y6BQAwVHSWngoLC1VQUBAw5vV6z3zm05a9HMcJGgtlw4YNKi4u1ptvvqnLLrss7GskrAEAVvN6vWcN51OSkpIUGxsbVEXX1dUFVdun27hxo6ZOnapXX31Vt9xyS0TXSBscAGAmT0x0tgjExcUpPT1d5eXlAePl5eXKyspqc78NGzZo8uTJeumll3THHXdEfKtU1gAAI4XTdj4XCgoKNGHCBGVkZCgzM1OrVq1SdXW18vLyJP3SVj906JBeeOEFSb8E9cSJE/XMM8/o+uuvb63Ku3TposTExLDOSVgDABCB3NxcNTQ0aOHChaqpqdGAAQNUVlam1NRUSVJNTU3AO9crV65Uc3OzHnzwQT344IOt45MmTdK6devCOifvWQPtwXvWQEgd+Z61821ZVI7j6T0qKsc5l6isAQBminC92WT23CkAAIaisgYAGMqepSfCGgBgJoueEyGsAQBmYs0aAAC4BZU1AMBQtMEBAHA3i9asaYMDAOByVNYAADNZ9IAZYQ0AMBRtcAAA4BJU1gAAM1n0gBlhDQAwlD3NYXvuFAAAQ1FZAwDMRBscAACXI6wBAHA7e1Zy7blTAAAMRWUNADATbXAAANzOnrCmDQ4AgMtRWQMAzEQbHAAAt7MnrGmDAwDgclTWAAAz0QYHAMDt7GkO23OnAAAYisoaAGAm2uAAALgdYQ0AgLtZVFmzZg0AgMtRWQMADGVPZU1YAwDMRBscAAC4BZU1AMBQ9lTWhDUAwEy0wQEAgFtQWQMADGVPvUlYAwDMRBscAAC4BZU1AMBQ9lTWhDUAwFCENQAAruZhzRoAALgFlTUAwFD2VNaENQDATLTBAQCAW1BZAwAMZU9lTVgDAMzksac5bM+dAgBgKCprAIChaIMDAOBuPA0OAADcgsoaAGAoeyprwhoAYCaL2uCENQDAUPaENWvWAAC4HJU1AMBMtMEBAHA7e8KaNjgAAC5HZQ0AMBPfDQ4AgNt5orRFbvny5UpLS1N8fLzS09O1ffv2M87/6KOPlJ6ervj4ePXp00crVqyI6HyENQAAEdi4caPy8/NVVFSkqqoqZWdna+TIkaqurg45f//+/Ro1apSys7NVVVWluXPnatasWXrttdfCPqfHcRwn4is93hDxLsBvSnz3oKFii55MBdpS3I5Iabfj9dE5TnxSRNOHDBmiQYMGqaSkpHWsf//+GjNmjHw+X9D8hx9+WG+99Zb27t3bOpaXl6ddu3apoqIirHO2b806xP+oANt16P+kAOh8PA3e1NSkyspKPfLIIwHjOTk52rFjR8h9KioqlJOTEzB22223qbS0VCdOnFDnzp3Pel4eMAMAWM3v98vv9weMeb1eeb3eoLn19fVqaWlRcnJywHhycrJqa2tDHr+2tjbk/ObmZtXX16tnz55nvcaw1qz9fr+Ki4uDbgawGf8ugPMsvntUNp/Pp8TExIAtVDv71zynLXs5jhM0drb5ocbbEnZYL1iwgP8pAb/Cvwvgt6GwsFBHjhwJ2AoLC0POTUpKUmxsbFAVXVdXF1Q9n9KjR4+Q8zt16qTu3cNbVuZpcACA1bxerxISEgK2UC1wSYqLi1N6errKy8sDxsvLy5WVlRVyn8zMzKD577//vjIyMsJar5YIawAAIlJQUKDVq1drzZo12rt3r2bPnq3q6mrl5eVJ+qVSnzhxYuv8vLw8HThwQAUFBdq7d6/WrFmj0tJSPfTQQ2GfkwfMAACIQG5urhoaGrRw4ULV1NRowIABKisrU2pqqiSppqYm4J3rtLQ0lZWVafbs2Vq2bJlSUlL07LPP6p577gn7nGG9Z+33++Xz+VRYWNhmawCwDf8uAHSU9n0pCgAA6DCsWQMA4HKENQAALkdYAwDgcoQ1AAAuR1gDAOByhDUAAC5HWAMA4HKENQAALkdYAwDgcoQ1AAAuR1gDAOBy/xeNIPH0pFoBpAAAAABJRU5ErkJggg==", + "image/png": "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\n", "text/plain": [ "
" ] @@ -241,7 +241,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -281,7 +281,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAesAAAGiCAYAAADHpO4FAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAtN0lEQVR4nO3deXhUVZrH8V8lIZUNAiQQVkO0R0HZmtBgoBkFJMo24oCidLPjYxSbgYiDyEgIMta4NEO3TUBGFrEj0m6gkIcmtAsguLFoy6KNImk1IRBFVgtIzvzBk2qKqkAlVsi9fb+f57l/cDh1z7l1q/LW+95zq1zGGCMAAGBZEXU9AQAAcHEEawAALI5gDQCAxRGsAQCwOII1AAAWR7AGAMDiCNYAAFgcwRoAAIsjWAMAYHGWDNYulyuk7e23367rqfq8/fbbAXMqKCjQrFmzgvZv06aNxowZc1nmdr5g85w1a5ZcLpdfvzZt2mjQoEFhGXPZsmVyuVz66quvfG1jxoxRmzZt/Pq5XC7df//9YRkzHII9V1VZuXKlrrvuOsXGxsrlcmnnzp21Pq+vvvpKX331VZXnMyIiQl9++WXA40+cOKEGDRrI5XLVyWswVC+88ILmzZtXa/t/4403NHjwYKWkpCg6OlqNGzdW3759lZ+frzNnztTauLt379asWbP83g/hNGvWLN97q/K9B/uzZLDeunWr3zZgwADFxsYGtHfp0qWup+rTpUuXgDkVFBQoNzc3aP/XXntNjzzyyOWa3kVNmDBBW7duvaxjPvLII3rttdcu65i15dChQxo5cqSuuuoqrVu3Tlu3btXVV19d19NSQkKCli5dGtD+0ksv6cyZM6pXr14dzCp0tRWsjTEaO3as/u3f/k0VFRWaO3euNmzYoOeee06dOnXSfffdp7y8vLCPW2n37t3Kzc2ttWCNf05RdT2BYK6//nq/fzdp0kQREREB7Rc6efKk4uLianNqVWrQoMEl53e+n//857U4m+pp1aqVWrVqdVnHvOqqqy7reLXp888/15kzZ/TrX/9aN9xwQ1j2GY7X8vDhw/Xcc88pNzdXERH/+Fy+ePFi3XbbbXr99dd/6jRt6cknn9SyZcuUm5urmTNn+v3f4MGD9Z//+Z/at29fHc2u5ury7x9qnyUz61DceOONat++vTZu3KgePXooLi5O48aNk3SuJJmZmanmzZsrNjZW7dq100MPPaQTJ0747WPMmDFKSEjQvn37NGDAACUkJKh169Z64IEH5PV6/fouWLBAnTp1UkJCgurXr6+2bdvq4Ycf9v3/hSXTMWPGaP78+ZL8y/qVn6aDlcGLior061//Wk2bNpXb7Va7du3029/+VhUVFb4+lWXPp556SnPnzlVaWpoSEhKUkZGh9957r0bPZbAyeDB5eXmKiopSTk6Or23Dhg3q27evGjRooLi4OPXs2VN/+ctfLrmvYGXwSs8//7zatWunuLg4derUSWvWrAnos3nzZvXt21f169dXXFycevToobVr1wb0+/TTT3XrrbeqUaNGiomJUefOnfXcc88F9Nu7d69uueUWxcXFKTk5WVlZWTp27FhIx/HLX/5S0rng6HK5dOONN/r+//XXX1dGRobi4uJUv3599evXL6CKUfn8b9++XcOGDVOjRo3C8mFm3Lhx+vvf/67CwkJf2+eff67Nmzf73isXutRr8MyZM2ratKlGjhwZ8NgjR44oNjZW2dnZvrajR49q6tSpSktLU3R0tFq2bKnJkycHvBcvdOONN2rt2rU6cOCA3/un0nfffaf77rtPLVu2VHR0tK688krNmDEj4H17oTNnzujxxx9X27Ztq6xsNWvWzHdOJen06dOaM2eO2rZtK7fbrSZNmmjs2LE6dOiQ3+MqLx2tW7dOXbp0UWxsrNq2baslS5b4+ixbtky33367JKl3796+41q2bJmvTyjvqdp6zcDCjA2MHj3axMfH+7XdcMMNpnHjxqZ169bm6aefNm+99ZZ55513jDHGPProo+Z///d/zdq1a83bb79tFi5caNLS0kzv3r0D9hsdHW3atWtnnnrqKbNhwwYzc+ZM43K5TG5urq/fihUrjCTzm9/8xqxfv95s2LDBLFy40EyaNMnX56233jKSzFtvvWWMMWbfvn1m2LBhRpLZunWrb/vxxx+NMcakpqaa0aNH+x5fWlpqWrZsaZo0aWIWLlxo1q1bZ+6//34jydx7772+fvv37zeSTJs2bcwtt9xiVq1aZVatWmU6dOhgGjVqZI4cOXLR5/LCeRpjTE5OjrnwpZCammoGDhxojDGmoqLCPPDAA6ZevXpm6dKlvj7PP/+8cblcZsiQIebVV181b7zxhhk0aJCJjIw0GzZs8PVbunSpkWT279/v99ynpqb6jVl5XN26dTN/+tOfTEFBgbnxxhtNVFSU+eKLL3z93n77bVOvXj2Tnp5uVq5caVatWmUyMzONy+UyL774oq/f3r17Tf369c1VV11lli9fbtauXWvuuusuI8k8/vjjvn4lJSWmadOmpmXLlmbp0qWmoKDA/OpXvzJXXHFFwHN1oX379pn58+cbSeaxxx4zW7duNbt27TLGGJOfn28kmczMTLNq1SqzcuVKk56ebqKjo82mTZsCnv/U1FQzbdo0U1hYaFatWlXlmJdSub9Dhw6ZXr16mTvuuMP3f9OmTTNt2rQxFRUVJj4+vkavwSlTppjY2Fjzww8/+I2bl5dnJJlPPvnEGGPMiRMnTOfOnU1ycrKZO3eu2bBhg/nd735nEhMTTZ8+fUxFRUWVx7Br1y7Ts2dP06xZM7/3jzHGnDp1ynTs2NHEx8ebp556yqxfv9488sgjJioqygwYMOCiz82WLVuMJDNt2rSQnsvy8nJzyy23mPj4eJObm2sKCwvNs88+a1q2bGmuvfZac/LkSV/f1NRU06pVK3Pttdea5cuXmz//+c/m9ttvN5J8f5tKS0vNY489ZiSZ+fPn+46rtLTUGBP6eyrcrxlYn62DtSTzl7/85aKPraioMGfOnDHvvPOOkWQ+/vhjv/1KMn/605/8HjNgwABzzTXX+P59//33m4YNG150nGBBcOLEiQFBsNKFwfqhhx4yksz777/v1+/ee+81LpfLfPbZZ8aYfwTrDh06mLNnz/r6ffDBB0aSWbFiRbXnebFgffLkSTN06FCTmJjo98fixIkTpnHjxmbw4MF+jysvLzedOnUy3bp187VVJ1inpKSYo0eP+tpKSkpMRESE8Xg8vrbrr7/eNG3a1Bw7dszXdvbsWdO+fXvTqlUrXxC48847jdvtNkVFRX7j9O/f38TFxfk+2EybNs24XC6zc+dOv379+vW7ZLA25h/P6UsvveT3PLRo0cJ06NDBlJeX+9qPHTtmmjZtanr06OFrq3z+Z86cedFxQnV+sF66dKlxu92mrKzMnD171jRv3tzMmjXLGGMCgnWor8FPPvnESDKLFi3y69etWzeTnp7u+7fH4zERERHmww8/9Ov38ssvG0mmoKDgoscxcODAgNeIMcYsXLgw6Pv28ccfN5LM+vXrq9zniy++aCSZhQsXXnTsSpUf1F955RW/9g8//NBIMnl5eb621NRUExMTYw4cOOBrO3XqlGncuLG55557fG0vvfRS0NdVdd5T4X7NwPpsWwaXpEaNGqlPnz4B7V9++aVGjBihZs2aKTIyUvXq1fNdS9yzZ49fX5fLpcGDB/u1dezYUQcOHPD9u1u3bjpy5IjuuusurV69WocPHw77sbz55pu69tpr1a1bN7/2MWPGyBijN99806994MCBioyM9JuzJL95/1RlZWXq06ePPvjgA1/ZudKWLVv03XffafTo0Tp79qxvq6io0C233KIPP/zwkqXOYHr37q369ev7/p2SkqKmTZv6juvEiRN6//33NWzYMCUkJPj6RUZGauTIkfr666/12WefSTr3nPbt21etW7f2G2PMmDE6efKkrxz91ltv6brrrlOnTp38+o0YMaLa86/02Wef6dtvv9XIkSP9rhcnJCRo6NCheu+993Ty5Em/xwwdOrTG41Xl9ttvV3R0tPLz81VQUKCSkpIqV4CH+hrs0KGD0tPT/Rav7dmzRx988IFfeX3NmjVq3769Onfu7Pcaufnmm3/S3Rxvvvmm4uPjNWzYsIB5SgrpMkyo1qxZo4YNG2rw4MF+x9C5c2c1a9Ys4Bg6d+6sK664wvfvmJgYXX311SG9L2vynqqN1wysyZILzELVvHnzgLbjx4+rV69eiomJ0Zw5c3T11VcrLi5Of//73/Xv//7vOnXqlF//uLg4xcTE+LW53W79+OOPvn+PHDlSZ8+e1f/93/9p6NChqqio0C9+8QvNmTNH/fr1C8uxlJWVBb2G26JFC9//ny8pKSlgzpICju+n+Pzzz/X999/r7rvvVvv27f3+7+DBg5IU8AfzfN99953i4+OrNeaFxyWdO7bK4/r+++9ljAl67i98rsrKykLul5aWFtCvWbNm1Zr7+Sr3XdX4FRUV+v777/0WBAXr+1PFx8dr+PDhWrJkiVJTU3XTTTcpNTW1yjmH+hocN26cJk6cqL1796pt27ZaunSp3G637rrrLl+fgwcPat++fVWuOq/ph96ysjI1a9YsYJ1F06ZNFRUVFfBeOV9lIN2/f39IYx08eFBHjhxRdHR00P+/8Bgu9fq91FhS9d5TtfGagTXZOlgHWxT15ptv6ttvv9Xbb7/ttzL3yJEjP2mssWPHauzYsTpx4oQ2btyonJwcDRo0SJ9//nmVf/yqIykpScXFxQHt3377rSQpOTn5J49RXRkZGbr99ts1fvx4SecW2VVmiZXzefrpp6tcBZ+SkhL2OTVq1EgREREhPVehPqdJSUkqKSkJ6BesLVSVf7SrGj8iIkKNGjXya6+t+2HHjRunZ599Vp988ony8/Or7Fed1+Bdd92l7OxsLVu2TP/93/+t559/XkOGDPE7puTkZMXGxvotsDpfTV/TSUlJev/992WM8XvOSktLdfbs2Yvut2vXrmrcuLFWr14tj8dzyec8OTlZSUlJWrduXdD/P78K9FPV5D3FPdTOYesyeDCVL97KTLPSM888E5b9x8fHq3///poxY4ZOnz6tXbt2Vdm3Otlu3759tXv3bm3fvt2vffny5XK5XOrdu/dPm3gNjR49Wi+++KKWLl2qUaNGqby8XJLUs2dPNWzYULt371bXrl2DblVlIz9FfHy8unfvrldffdXvea2oqNAf//hHtWrVynePc9++fX0f3s63fPlyxcXF+f4g9u7dW7t27dLHH3/s1++FF16o8TyvueYatWzZUi+88IKMMb72EydO6JVXXvGtEL8cMjIyNG7cON1222267bbbquxXnddgo0aNNGTIEC1fvlxr1qxRSUlJwArzQYMG6YsvvlBSUlLQ10dVdwNUqioj7du3r44fP65Vq1YFzLPy/6tSr149TZs2TXv37tWjjz4atE9paaneffdd3zGUlZWpvLw86DFcc801Fz2Gqo5LCvy7UFfvKdiDrTPrYHr06KFGjRopKytLOTk5qlevnvLz8wP+EFfH3XffrdjYWPXs2VPNmzdXSUmJPB6PEhMT9Ytf/KLKx3Xo0EGS9Pjjj6t///6KjIxUx44dg77hpkyZouXLl2vgwIGaPXu2UlNTtXbtWuXl5enee++t0y/ZGDZsmOLi4jRs2DCdOnVKK1asUEJCgp5++mmNHj1a3333nYYNG6amTZvq0KFD+vjjj3Xo0CEtWLCgVubj8XjUr18/9e7dW1OnTlV0dLTy8vL06aefasWKFb4PbDk5OVqzZo169+6tmTNnqnHjxsrPz9fatWv1xBNPKDExUZI0efJkLVmyRAMHDtScOXOUkpKi/Px87d27t8ZzjIiI0BNPPKFf/epXGjRokO655x55vV49+eSTOnLkiP7nf/4nLM9FqBYvXnzJPtV9DY4bN04rV67U/fffr1atWummm27y+//JkyfrlVde0b/+679qypQp6tixoyoqKlRUVKT169frgQceUPfu3aucT4cOHfTqq69qwYIFSk9PV0REhLp27apRo0Zp/vz5Gj16tL766it16NBBmzdv1mOPPaYBAwYEzONCDz74oPbs2aOcnBx98MEHGjFihFq3bq0ffvhBGzdu1KJFi5Sbm6uePXvqzjvvVH5+vgYMGKD/+I//ULdu3VSvXj19/fXXeuutt3Trrbde9ANQMJWXlBYtWqT69esrJiZGaWlpSkpKqrP3FGygTpe3haiq1eDXXXdd0P5btmwxGRkZJi4uzjRp0sRMmDDBbN++3Ujyu/Uo2H6NCVwd/dxzz5nevXublJQUEx0dbVq0aGHuuOMO3y0qxgRfZe31es2ECRNMkyZNjMvl8lsRfeFqcGOMOXDggBkxYoRJSkoy9erVM9dcc4158skn/VYTV64Gf/LJJwPmLcnk5OQEfU4uNs9L3bp1/mMTEhLMLbfc4rtl5Z133jEDBw40jRs3NvXq1TMtW7Y0AwcO9FsZXZ3V4BMnTgyYc7DnatOmTaZPnz4mPj7exMbGmuuvv9688cYbAY/961//agYPHmwSExNNdHS06dSpk99roNLu3btNv379TExMjGncuLEZP368Wb16dY1Xg1datWqV6d69u4mJiTHx8fGmb9++5t133/Xrc/7q7XAIdX8XrgY3JrTXYKXy8nLTunVrI8nMmDEj6BjHjx83//Vf/2WuueYaEx0dbRITE02HDh3MlClTTElJyUXn991335lhw4aZhg0b+t4/lcrKykxWVpZp3ry5iYqKMqmpqWb69Om+WyNDsXr1ajNw4EDTpEkTExUVZRo1amR69+5tFi5caLxer6/fmTNnzFNPPWU6depkYmJiTEJCgmnbtq255557zN/+9jdfv2DvGWPO/a264YYb/NrmzZtn0tLSTGRkZMDfpVDeU+F+zcD6XMacV6MDAACW8093zRoAgH82BGsAACyOYA0AgMURrAEACNHGjRs1ePBgtWjRQi6XK+AWwmDeeecdpaenKyYmRldeeaUWLlxY7XEJ1gAAhOjEiRPq1KmT/vCHP4TUf//+/RowYIB69eqlHTt26OGHH9akSZP0yiuvVGtcVoMDAFADLpdLr732moYMGVJln2nTpun111/3+12KrKwsffzxxwE/l3sxQb8Uxev1BvwurNvtDvhWMAAA7K42Y97WrVuVmZnp13bzzTdr8eLFOnPmTJXfnX+hoMHa4/EoNzfXry0nJ0ezZs2q2WwBAAizWeH6bvScnFqLeSUlJQHf6Z6SkqKzZ8/q8OHDIf8YS9BgPX36dGVnZ/u1kVUDAKwkXIuuptVyzLvwB1cqrz5X54dYggZrSt4AAKeozZjXrFmzgF/wKy0tVVRUVNCfVK1KjX7II2ylB1TLrCBrATkXdYNzYS2cD+sIdi5qix3OcEZGht544w2/tvXr16tr164hX6+WuHULAGBTEWHaquP48ePauXOndu7cKencrVk7d+5UUVGRpHOXkUeNGuXrn5WVpQMHDig7O1t79uzRkiVLtHjxYk2dOrVa4/7T/UQmAAC15aOPPvL7bffKa92jR4/WsmXLVFxc7AvckpSWlqaCggJNmTJF8+fPV4sWLfT73/9eQ4cOrda4BGsAgC3VRWn4xhtv1MW+nmTZsmUBbTfccIO2b9/+k8YlWAMAbMkO16zDhWvWAABYHJk1AMCWnJRtEqwBALbkpDI4wRoAYEtOyqyddKwAANgSmTUAwJaclG0SrAEAtuSka9ZO+mACAIAtkVkDAGzJSdkmwRoAYEtOCtZOOlYAAGyJzBoAYEtOWmBGsAYA2JKTSsNOOlYAAGyJzBoAYEuUwQEAsDgnlYYJ1gAAW3JSsHbSsQIAYEtk1gAAW+KaNQAAFuek0rCTjhUAAFsiswYA2JKTsk2CNQDAlpx0zdpJH0wAALAlMmsAgC05KdskWAMAbMlJwdpJxwoAgC2RWQMAbMlJC8wI1gAAW3JSaZhgDQCwJSdl1k76YAIAgC2RWQMAbMlJ2SbBGgBgS04K1k46VgAAbInMGgBgS05aYEawBgDYkpNKw046VgAAbInMGgBgS07KNgnWAABbctI1ayd9MAEAwJbIrAEAtuSKcE5uTbAGANiSy0WwBgDA0iIclFlzzRoAAIsjswYA2BJlcAAALM5JC8wogwMAYHFk1gAAW6IMDgCAxVEGBwAAlkFmDQCwJcrgAABYHGVwAABgGWTWAABbogwOAIDFOem7wQnWAABbclJmzTVrAAAsjswaAGBLTloNTrAGANgSZXAAAGAZZNYAAFuiDA4AgMVRBgcAAFXKy8tTWlqaYmJilJ6erk2bNl20f35+vjp16qS4uDg1b95cY8eOVVlZWcjjEawBALbkinCFZauulStXavLkyZoxY4Z27NihXr16qX///ioqKgraf/PmzRo1apTGjx+vXbt26aWXXtKHH36oCRMmhDwmwRoAYEsulyssW3XNnTtX48eP14QJE9SuXTvNmzdPrVu31oIFC4L2f++999SmTRtNmjRJaWlp+uUvf6l77rlHH330UchjEqwBAI7m9Xp19OhRv83r9Qbte/r0aW3btk2ZmZl+7ZmZmdqyZUvQx/To0UNff/21CgoKZIzRwYMH9fLLL2vgwIEhz5FgDQCwpYgIV1g2j8ejxMREv83j8QQd8/DhwyovL1dKSopfe0pKikpKSoI+pkePHsrPz9fw4cMVHR2tZs2aqWHDhnr66adDP9bQnxYAAKwjXGXw6dOn64cffvDbpk+ffsmxz2eMqbKkvnv3bk2aNEkzZ87Utm3btG7dOu3fv19ZWVkhHyu3bgEAbClc91m73W653e6Q+iYnJysyMjIgiy4tLQ3Itit5PB717NlTDz74oCSpY8eOio+PV69evTRnzhw1b978kuOSWQMAEKLo6Gilp6ersLDQr72wsFA9evQI+piTJ08qIsI/3EZGRko6l5GHgswaAGBLdfWlKNnZ2Ro5cqS6du2qjIwMLVq0SEVFRb6y9vTp0/XNN99o+fLlkqTBgwfr7rvv1oIFC3TzzTeruLhYkydPVrdu3dSiRYuQxiRYAwBsyVVHteHhw4errKxMs2fPVnFxsdq3b6+CggKlpqZKkoqLi/3uuR4zZoyOHTumP/zhD3rggQfUsGFD9enTR48//njIY7pMqDn4eWY56CverGRWkFPFuagbnAtr4XxYR7BzUVu2/yz4NeLq6rLvYFj2U5vIrAEAtuSk7wYnWAMAbMlJv7rFanAAACyOzBoAYEsRlMEBALA2yuAAAMAyyKwBALbEanAAACzOSWVwgjUAwJaclFnX6BvMAACoa7s7XhGW/Vz7SdGlO9WxoJm11+uV1+v1a6vOT4gBAFDbnFQGD7oa3OPxKDEx0W/zeDyXe24AAFTJ5XKFZbODoGVwMmsAgNXt/XmbsOyn7Y6vwrKf2hS0DE5gBgBYnSvCOV8VUrPV4D+WhXkaCElMUmAb56JucC6shfNhHcHORS1x/DVrAABgHdxnDQCwJ5ssDgsHgjUAwJYogwMAAMsgswYA2BKrwQEAsDi7fKFJOBCsAQD2xDVrAABgFWTWAABb4po1AAAW56Rr1s75WAIAgE2RWQMAbMlJX4pCsAYA2JODgjVlcAAALI7MGgBgSy6Xc/JNgjUAwJacdM3aOR9LAACwKTJrAIAtOSmzJlgDAOyJa9YAAFibkzJr53wsAQDApsisAQC25KTMmmANALAlfsgDAABYBpk1AMCe+D1rAACszUnXrJ3zsQQAAJsiswYA2JKTFpgRrAEAtuRy0DVr5xwpAAA2RWYNALAlJy0wI1gDAOyJa9YAAFibkzJrrlkDAGBxZNYAAFty0mpwgjUAwJacdJ+1cz6WAABgU2TWAAB7ctACM4I1AMCWnHTN2jlHCgCATZFZAwBsyUkLzAjWAABb4ktRAACAZZBZAwDsiTI4AADW5qQyOMEaAGBPzonVXLMGAMDqyKwBAPbkoGvWZNYAAFtyucKz1UReXp7S0tIUExOj9PR0bdq06aL9vV6vZsyYodTUVLndbl111VVasmRJyOORWQMAUA0rV67U5MmTlZeXp549e+qZZ55R//79tXv3bl1xxRVBH3PHHXfo4MGDWrx4sX72s5+ptLRUZ8+eDXlMlzHGVHumP5ZV+yEIg5ikwDbORd3gXFgL58M6gp2LWnL0N4PCsp8GT6+pVv/u3burS5cuWrBgga+tXbt2GjJkiDweT0D/devW6c4779SXX36pxo0b12iOlMEBALYUrjK41+vV0aNH/Tav1xt0zNOnT2vbtm3KzMz0a8/MzNSWLVuCPub1119X165d9cQTT6hly5a6+uqrNXXqVJ06dSrkYyVYAwAczePxKDEx0W8LliFL0uHDh1VeXq6UlBS/9pSUFJWUlAR9zJdffqnNmzfr008/1WuvvaZ58+bp5Zdf1sSJE0OeI9esAQD2FKbV4NOnT1d2drZfm9vtvsTQ/mMbY6r8YZGKigq5XC7l5+crMTFRkjR37lwNGzZM8+fPV2xs7CXnSLAGANhTmGrDbrf7ksG5UnJysiIjIwOy6NLS0oBsu1Lz5s3VsmVLX6CWzl3jNsbo66+/1r/8y79cclzK4AAAW3K5XGHZqiM6Olrp6ekqLCz0ay8sLFSPHj2CPqZnz5769ttvdfz4cV/b559/roiICLVq1SqkcQnWAABUQ3Z2tp599lktWbJEe/bs0ZQpU1RUVKSsrCxJ58rqo0aN8vUfMWKEkpKSNHbsWO3evVsbN27Ugw8+qHHjxoVUApcogwMA7KqOvsFs+PDhKisr0+zZs1VcXKz27duroKBAqampkqTi4mIVFRX5+ickJKiwsFC/+c1v1LVrVyUlJemOO+7QnDlzQh6T+6zthHtJrYNzYS2cD+u4jPdZn5h6a1j2E//U6rDspzZRBgcAwOIogwMA7InfswYAwOKcE6spgwMAYHVk1gAAW6ruPdJ2RrAGANiTc2I1ZXAAAKyOzBoAYEsuVoMDAGBxzonVBGsAgE05aIEZ16wBALA4MmsAgC05KLEmWAMAbMpBC8wogwMAYHFk1gAAW6IMDgCA1TkoWlMGBwDA4sisAQC25KDEmmANALApVoMDAACrILMGANiTg+rgBGsAgC05KFYTrAEANuWgaM01awAALI7MGgBgSy4HpZsEawCAPVEGBwAAVkFmDQCwJ+ck1jUM1jFJYZ4GaoxzYR2cC2vhfPzTczmoDB40WHu9Xnm9Xr82t9stt9t9WSYFAAD+Ieg1a4/Ho8TERL/N4/Fc7rkBAFC1CFd4NhtwGWPMhY1k1gAAqyuf9+uw7Cdy8h/Dsp/aFLQMTmAGAMA6arbA7MeyME8DIQm2YIZzUTc4F9bC+bCOy7mwzyYl7HDg1i0AgD056CvMCNYAAHty0K1bzvlYAgCATZFZAwDsiWvWAABYnIOuWTvnSAEAsCkyawCAPVEGBwDA4lgNDgAArILMGgBgTxHOyTcJ1gAAe6IMDgAArILMGgBgT5TBAQCwOAeVwQnWAAB7clCwdk4NAQAAmyKzBgDYE9esAQCwOMrgAADAKsisAQC25OKHPAAAsDh+zxoAAFgFmTUAwJ4ogwMAYHGsBgcAAFZBZg0AsCe+FAUAAItzUBmcYA0AsCcHBWvn1BAAALApgjUAwJ4iIsKz1UBeXp7S0tIUExOj9PR0bdq0KaTHvfvuu4qKilLnzp2rNR7BGgBgTy5XeLZqWrlypSZPnqwZM2Zox44d6tWrl/r376+ioqKLPu6HH37QqFGj1Ldv32qPSbAGAKAa5s6dq/Hjx2vChAlq166d5s2bp9atW2vBggUXfdw999yjESNGKCMjo9pjEqwBAPYU4QrL5vV6dfToUb/N6/UGHfL06dPatm2bMjMz/dozMzO1ZcuWKqe6dOlSffHFF8rJyanZodboUQAA1DVXRFg2j8ejxMREv83j8QQd8vDhwyovL1dKSopfe0pKikpKSoI+5m9/+5seeugh5efnKyqqZjdhcesWAMDRpk+fruzsbL82t9t90ce4LrjWbYwJaJOk8vJyjRgxQrm5ubr66qtrPEeCNQDAnsL0Qx5ut/uSwblScnKyIiMjA7Lo0tLSgGxbko4dO6aPPvpIO3bs0P333y9JqqiokDFGUVFRWr9+vfr06XPJcQnWAAB7qoMvRYmOjlZ6eroKCwt12223+doLCwt16623BvRv0KCB/vrXv/q15eXl6c0339TLL7+stLS0kMYlWAMAUA3Z2dkaOXKkunbtqoyMDC1atEhFRUXKysqSdK6s/s0332j58uWKiIhQ+/bt/R7ftGlTxcTEBLRfDMEaAGBPdfRDHsOHD1dZWZlmz56t4uJitW/fXgUFBUpNTZUkFRcXX/Ke6+pyGWNMtR/1Y1lYJ4EQxSQFtnEu6gbnwlo4H9YR7FzUkor1j4ZlPxGZj4RlP7WJzBoAYE/8kAcAALAKMmsAgD25nJNvEqwBAPbknCo4ZXAAAKyOzBoAYE8OWmBGsAYA2JODgjVlcAAALI7MGgBgTw7KrAnWAACbck6wpgwOAIDFkVkDAOzJOYk1wRoAYFNcswYAwOIcFKy5Zg0AgMWRWQMA7MlBmTXBGgBgU84J1pTBAQCwODJrAIA9OSexJlgDAGzKQdesKYMDAGBxZNYAAHtyUGZNsAYA2JRzgjVlcAAALI7MGgBgT5TBAQCwOII1AAAW55xYzTVrAACsjswaAGBPlMEBALA65wRryuAAAFgcmTUAwJ4ogwMAYHEOCtaUwQEAsDgyawCAPTknsSZYAwBsijI4AACwCjJrAIBNOSezJlgDAOzJQWVwgjUAwJ4cFKy5Zg0AgMWRWQMA7InMGgAAWAXBGgAAi6MMDgCwJweVwQnWAAB7IlhfQkxSmKeBGuNcWAfnwlo4H/gnEjRYe71eeb1evza32y23231ZJgUAwCU5KLMOusDM4/EoMTHRb/N4PJd7bgAAXIQrTJv1uYwx5sJGMmsAgNVV7FoWlv1EXDcmLPupTUHL4ARmAIDlOagMXrMFZj+WhXkaCEmwBTOci7rBubAWzod1XM6FfS7nfFUIt24BAGzKOZm1cz6WAABgU2TWAAB74po1AAAW56Br1s45UgAAbIrMGgBgU5TBAQCwNgdds6YMDgCAxZFZAwBsyjn5JsEaAGBPlMEBAIBVEKwBAPbkcoVnq4G8vDylpaUpJiZG6enp2rRpU5V9X331VfXr109NmjRRgwYNlJGRoT//+c/VGo9gDQCwqbr5PeuVK1dq8uTJmjFjhnbs2KFevXqpf//+KioqCtp/48aN6tevnwoKCrRt2zb17t1bgwcP1o4dO0I/0mC/Z31J/JpN3eCXhayDc2EtnA/ruIy/ulXxxaqw7CfiqiHV6t+9e3d16dJFCxYs8LW1a9dOQ4YMkcfjCWkf1113nYYPH66ZM2eGNsdqzRAAgH8yXq9XR48e9du8Xm/QvqdPn9a2bduUmZnp156ZmaktW7aENF5FRYWOHTumxo0bhzxHgjUAwJ7CdM3a4/EoMTHRb6sqQz58+LDKy8uVkpLi156SkqKSkpKQpv3b3/5WJ06c0B133BHyoXLrFgDApsJz69b06dOVnZ3t1+Z2uy8+8gUL04wxAW3BrFixQrNmzdLq1avVtGnTkOdIsAYAOJrb7b5kcK6UnJysyMjIgCy6tLQ0INu+0MqVKzV+/Hi99NJLuummm6o1R8rgAAB7ckWEZ6uG6Ohopaenq7Cw0K+9sLBQPXr0qPJxK1as0JgxY/TCCy9o4MCB1T5UMmsAgC2FUnauDdnZ2Ro5cqS6du2qjIwMLVq0SEVFRcrKypJ0rqz+zTffaPny5ZLOBepRo0bpd7/7na6//npfVh4bG6vExMSQxiRYAwBQDcOHD1dZWZlmz56t4uJitW/fXgUFBUpNTZUkFRcX+91z/cwzz+js2bOaOHGiJk6c6GsfPXq0li1bFtKY3GdtJ9xLah2cC2vhfFjHZbzP2nxVEJb9uNoMCMt+ahOZNQDAnqp5vdnOnHOkAADYFJk1AMCmnPMTmQRrAIA9Oej3rAnWAAB74po1AACwCjJrAIBNUQYHAMDaHHTNmjI4AAAWR2YNALAnBy0wI1gDAGyKMjgAALAIMmsAgD05aIEZwRoAYFPOKQ4750gBALApMmsAgD1RBgcAwOII1gAAWJ1zruQ650gBALApMmsAgD1RBgcAwOqcE6wpgwMAYHFk1gAAe6IMDgCA1TknWFMGBwDA4sisAQD2RBkcAACrc05x2DlHCgCATZFZAwDsiTI4AABWR7AGAMDaHJRZc80aAACLI7MGANiUczJrgjUAwJ4ogwMAAKsgswYA2JRzMmuCNQDAniiDAwAAqyCzBgDYlHPyTYI1AMCeKIMDAACrILMGANiUczJrgjUAwKYI1gAAWJqLa9YAAMAqyKwBADblnMyaYA0AsCfK4AAAwCrIrAEANuWczJpgDQCwJ5dzisPOOVIAAGyKzBoAYFOUwQEAsDZWgwMAAKsgswYA2JRzMmuCNQDAnhxUBidYAwBsyjnBmmvWAABYHJk1AMCeKIMDAGB1zgnWlMEBALA4MmsAgD3x3eAAAFidK0xb9eXl5SktLU0xMTFKT0/Xpk2bLtr/nXfeUXp6umJiYnTllVdq4cKF1RqPYA0AQDWsXLlSkydP1owZM7Rjxw716tVL/fv3V1FRUdD++/fv14ABA9SrVy/t2LFDDz/8sCZNmqRXXnkl5DFdxhhT7Zn+WFbthyAMYpIC2zgXdYNzYS2cD+sIdi5qy4+Hw7OfmORqde/evbu6dOmiBQsW+NratWunIUOGyOPxBPSfNm2aXn/9de3Zs8fXlpWVpY8//lhbt24NacyaXbO+nCcDF8e5sA7OhbVwPhzg8q8GP336tLZt26aHHnrIrz0zM1NbtmwJ+pitW7cqMzPTr+3mm2/W4sWLdebMGdWrV++S47LADADgaF6vV16v16/N7XbL7XYH9D18+LDKy8uVkpLi156SkqKSkpKg+y8pKQna/+zZszp8+LCaN29+yTmGdM3a6/Vq1qxZAQeDy49zYR2cC2vhfDhQTFJYNo/Ho8TERL8tWDn7fK4LvpDFGBPQdqn+wdqrEnKwzs3N5U1gAZwL6+BcWAvnAzU1ffp0/fDDD37b9OnTg/ZNTk5WZGRkQBZdWloakD1XatasWdD+UVFRSkoK7XINq8EBAI7mdrvVoEEDvy1YCVySoqOjlZ6ersLCQr/2wsJC9ejRI+hjMjIyAvqvX79eXbt2Del6tUSwBgCgWrKzs/Xss89qyZIl2rNnj6ZMmaKioiJlZWVJOpepjxo1ytc/KytLBw4cUHZ2tvbs2aMlS5Zo8eLFmjp1ashjssAMAIBqGD58uMrKyjR79mwVFxerffv2KigoUGpqqiSpuLjY757rtLQ0FRQUaMqUKZo/f75atGih3//+9xo6dGjIY4YUrN1ut3JycqosC+Dy4VxYB+fCWjgfuJzuu+8+3XfffUH/b9myZQFtN9xwg7Zv317j8Wr2pSgAAOCy4Zo1AAAWR7AGAMDiCNYAAFgcwRoAAIsjWAMAYHEEawAALI5gDQCAxRGsAQCwOII1AAAWR7AGAMDiCNYAAFjc/wOwZX41nPhm/QAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -301,7 +301,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -321,7 +321,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -341,7 +341,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -470,7 +470,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -492,7 +492,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGxCAYAAACwbLZkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAArMUlEQVR4nO3deXSUVYL+8afIUiFAAiQQthjSNEtkJxFIGGwQSJtgGlCOCDMsDnSTEdvBwDgsCgSw47GxpfvYiTKyNEbojEdUlPRIoaBxQtuYCT3SjTT0EMKSgAlCoWg23t8fnNTPorJUYeIN4fs5J0ffy33ve9+3cque3Hcpm2VZlgAAAAxpY7oDAADg9kYYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGEGLsm3bNtlsNrefLl26aNy4cXrnnXduut1x48Zp3LhxbmU2m01r1qy5qfaKioo0efJkde7cWTabTYsXL77pvvnCZrPp0Ucf/V62daMdO3Zo48aNRrbdUsybN0+9e/c23Q2fFBUVyWazadu2ba6yNWvWyGazudXLzMx0q9PQ+kBT8zfdAaAuW7du1YABA2RZlkpLS/XCCy8oJSVFu3fvVkpKSpNs4+DBg+rVq9dNrfv444/r448/1pYtW9StWzd17969SfrUku3YsUNHjhz53oIXms+CBQt07733upVlZmYqPDxc8+bNcyvv3r27Dh48qD59+nyPPcTthjCCFmnQoEGKi4tzLd97773q1KmTdu7c2WRhZPTo0Te97pEjRzRy5EhNnTq1Sfpyu/j666/Vtm1b092oV1VVlWw2m/z9W/dbY69evbwO4na7/TuNFcAbnKbBLSEoKEiBgYEKCAhwK6+srNT69es1YMAA2e12denSRQ8//LA+//zzRtus6zRNaWmpFi5cqF69eikwMFDR0dFKT09XdXW1JOnAgQOy2Ww6ceKE/vCHP7hOJRUVFenatWtav369+vfvr7Zt26pjx44aMmSIfv3rXzfYj2+++UZLlizRsGHDFBoaqs6dOys+Pl5vvfVWveu89NJL6tevn+x2u+688079/ve/96hz5MgRTZkyRZ06dVJQUJCGDRum3/3ud251ak+LFRUVuZXX7ueBAwckXT/NtWfPHp06dcrtFFpDevfurfvuu0+7du3S8OHDFRQUpPT0dK+OsyTdddddmjx5slubgwcPls1m06FDh1xlu3btks1m06effipJOnHihB5++GH17dtXwcHB6tmzp1JSUlz/fuM+vvLKK1qyZIl69uwpu92uEydOuI5N//79ZbfbFRMTo+3btze4vzfasWOH4uPj1b59e7Vv317Dhg3T5s2b3eps2bJFQ4cOVVBQkDp37qxp06bp6NGjbnXmzZun9u3b68SJE0pOTlb79u0VGRmpJUuWqKKiwq3uuXPn9OCDD6pDhw4KDQ3VjBkzVFpa6tG3G0/T9O7dW3/5y1/0wQcfuF7b2tNR9Z2m+eijjzRhwgR16NBBwcHBSkhI0J49e9zq1P5+7d+/X//yL/+i8PBwhYWF6f7779e5c+d8Op5o3Vp3/Mctq6amRtXV1bIsS+fPn9cvf/lLffXVV5o1a5arzrVr1zRlyhTl5eXpiSeeUEJCgk6dOqXVq1dr3Lhx+uSTT3z6K7y0tFQjR45UmzZttGrVKvXp00cHDx7U+vXrVVRUpK1bt2rEiBE6ePCgpk2bpj59+mjDhg2Srk9lP/vss1qzZo2efPJJ3X333aqqqtJnn32mS5cuNbjdiooKXbx4UUuXLlXPnj1VWVmpffv26f7779fWrVs1Z84ct/q7d+/W/v37tXbtWrVr106ZmZmaOXOm/P39NX36dEnSsWPHlJCQoK5du+o3v/mNwsLClJ2drXnz5un8+fN64oknvD4u0vUp/J/97Gf6+9//rjfeeMPr9f7nf/5HR48e1ZNPPqno6Gi1a9fOq+MsSRMnTtQLL7ygqqoqBQQE6Pz58zpy5Ijatm0rh8Ohu+66S5K0b98+RUREaPDgwZKufyCHhYXpmWeeUZcuXXTx4kX97ne/06hRo1RYWKj+/fu79XH58uWKj4/Xiy++qDZt2qhr167atm2bHn74YU2ZMkXPPfecLl++rDVr1qiiokJt2jT+N9yqVau0bt063X///VqyZIlCQ0N15MgRnTp1ylUnIyNDK1as0MyZM5WRkaHy8nKtWbNG8fHxOnTokPr27euqW1VVpZ/85CeaP3++lixZog8//FDr1q1TaGioVq1aJen6rNPEiRN17tw5ZWRkqF+/ftqzZ49mzJjRaH/feOMNTZ8+XaGhocrMzJR0fUakPh988IEmTZqkIUOGaPPmzbLb7crMzFRKSop27tzpsc0FCxZo8uTJ2rFjh06fPq1/+7d/0z/90z/p/fffb7RvuE1YQAuydetWS5LHj91utzIzM93q7ty505Jkvf76627lhw4dsiS51f/Rj35k/ehHP3KrJ8lavXq1a3nhwoVW+/btrVOnTrnV27BhgyXJ+stf/uIqi4qKsiZPnuxW77777rOGDRt2M7vtprq62qqqqrLmz59vDR8+3KPPbdu2tUpLS93qDxgwwPrhD3/oKnvooYcsu91uFRcXu62flJRkBQcHW5cuXbIs6/8f75MnT7rV279/vyXJ2r9/v6ts8uTJVlRUlNf7ERUVZfn5+VnHjh1zK/f2OO/bt8+SZH344YeWZVlWdna21aFDB+uRRx6xxo8f71qvb9++1qxZs+rtR3V1tVVZWWn17dvXevzxxz328e6773arX1NTY/Xo0cMaMWKEde3aNVd5UVGRFRAQ0Ogx+L//+z/Lz8/P+sd//Md663zxxRdW27ZtreTkZLfy4uJiy263u+3P3LlzLUnWf/7nf7rVTU5Otvr37+9azsrKsiRZb731llu9n/70p5Yka+vWra6y1atXWze+/Q8cONBjjFiWZZ08edJj/dGjR1tdu3a1rly54iqrrq62Bg0aZPXq1ct13Gp/vx555BG3Np999llLklVSUlLH0cHtiNM0aJG2b9+uQ4cO6dChQ/rDH/6guXPnatGiRXrhhRdcdd555x117NhRKSkpqq6udv0MGzZM3bp1c51i8NY777yj8ePHq0ePHm7tJSUlSbr+12BDRo4cqT//+c965JFH9O6778rpdHq97ddee01jxoxR+/bt5e/vr4CAAG3evNljyl6SJkyYoIiICNeyn5+fZsyYoRMnTujMmTOSpPfff18TJkxQZGSk27rz5s3T1atXdfDgQa/79l0MGTJE/fr1cyvz9jiPGTNGQUFB2rdvnyTJ4XBo3Lhxuvfee5Wfn6+rV6/q9OnTOn78uCZOnOhqv7q6Wr/4xS905513KjAwUP7+/goMDNTx48frPJ4PPPCA2/KxY8d07tw5zZo1y+1URlRUlBISEhrdZ4fDoZqaGi1atKjeOgcPHtTXX3/tcbFoZGSk7rnnHr333ntu5TabzeNaqSFDhrjNtOzfv18dOnTQT37yE7d6355NbApfffWVPv74Y02fPl3t27d3lfv5+Wn27Nk6c+aMjh075rbOjX0aMmSIJLn1H7c3wghapJiYGMXFxSkuLk733nuvXnrpJSUmJuqJJ55wnfY4f/68Ll265LqW5Ns/paWlKisr82mb58+f19tvv+3R1sCBAyWp0faWL1+uDRs26I9//KOSkpIUFhamCRMm6JNPPmlwvV27dunBBx9Uz549lZ2drYMHD+rQoUP653/+Z33zzTce9bt161ZvWXl5ueu/dd3h06NHD7d6za2uPnh7nIOCgjRmzBhXGHnvvfc0adIkjRs3TjU1NcrLy5PD4ZAktzCSlpamp556SlOnTtXbb7+tjz/+WIcOHdLQoUP19ddfN9rH2mPT0HFuSO31Sg1dIFq7jfpeoxtfn+DgYAUFBbmV2e12t9+P8vJyt5DqS5998cUXX8iyLJ9+v8LCwtyWa08B1fV64PbENSO4ZQwZMkTvvvuu/va3v2nkyJGui+H+67/+q876HTp08Kn98PBwDRkyRE8//XSd/177Rlsff39/paWlKS0tTZcuXdK+ffu0YsUK/fjHP9bp06cVHBxc53rZ2dmKjo5WTk6O21/iN16cWKuuCxJry2rf9MPCwlRSUuJRr/aiwfDwcElyfcDduC1fg1x96rrI1ZfjPGHCBK1atUp/+tOfdObMGU2aNEkdOnTQXXfdJYfDoXPnzqlfv35uM0DZ2dmaM2eOfvGLX3jsU8eOHRvtY+0xbOg4N6RLly6SpDNnznjMTN24jfpeo9rXxxdhYWH605/+5FHuTZ990alTJ7Vp08ar3y/AW8yM4JZx+PBhSf//zf6+++5TeXm5ampqXLMo3/658ULFxtx33306cuSI+vTpU2d7jYWRb+vYsaOmT5+uRYsW6eLFix53q3ybzWZTYGCg24diaWlpvXfTvPfeezp//rxruaamRjk5OerTp4/rr/EJEybo/fff97hjYfv27QoODnbdqll7x8T//u//utXbvXu3x3btdnuT/CXry3GeOHGiqqur9dRTT6lXr14aMGCAq3zfvn16//333WZFpOvH88aLL/fs2aOzZ8961b/+/fure/fu2rlzpyzLcpWfOnVK+fn5ja6fmJgoPz8/ZWVl1VsnPj5ebdu2VXZ2tlv5mTNnXKfYfDV+/HhduXLF47XbsWOHV+t7+/q2a9dOo0aN0q5du9zqX7t2TdnZ2erVq5fHqTmgMcyMoEU6cuSI6zbP8vJy7dq1Sw6HQ9OmTVN0dLQk6aGHHtKrr76q5ORk/eu//qtGjhypgIAAnTlzRvv379eUKVM0bdo0r7e5du1aORwOJSQk6LHHHlP//v31zTffqKioSLm5uXrxxRcbnHpPSUlxPR+lS5cuOnXqlDZu3KioqCi3OyNuVHv76yOPPKLp06fr9OnTWrdunbp3767jx4971A8PD9c999yjp556ynU3zWeffeZ2e+/q1atd12asWrVKnTt31quvvqo9e/bo2WefVWhoqKTrt8/2799fS5cuVXV1tTp16qQ33nhDH330kcd2Bw8erF27dikrK0uxsbFq06aN27NgvOXLcY6NjVWnTp20d+9ePfzww642Jk6cqHXr1rn+/8bjuW3bNg0YMEBDhgxRQUGBfvnLX3r9XI02bdpo3bp1WrBggaZNm6af/vSnunTpktasWePVKY/evXtrxYoVWrdunb7++mvNnDlToaGh+utf/6qysjKlp6erY8eOeuqpp7RixQrNmTNHM2fOVHl5udLT0xUUFKTVq1d7ezhd5syZo+eff15z5szR008/rb59+yo3N1fvvvuuV+sPHjxYv//975WTk6Mf/OAHCgoKct2hdKOMjAxNmjRJ48eP19KlSxUYGKjMzEwdOXJEO3fubPS2b8CD6StogW+r626a0NBQa9iwYdavfvUr65tvvnGrX1VVZW3YsMEaOnSoFRQUZLVv394aMGCAtXDhQuv48eOuet7cTWNZlvX5559bjz32mBUdHW0FBARYnTt3tmJjY62VK1daX375pateXXfTPPfcc1ZCQoIVHh5uBQYGWnfccYc1f/58q6ioqNH9fuaZZ6zevXtbdrvdiomJsf7jP/6jzjseJFmLFi2yMjMzrT59+lgBAQHWgAEDrFdffdWjzU8//dRKSUmxQkNDrcDAQGvo0KFud0TU+tvf/mYlJiZaISEhVpcuXayf//zn1p49ezzuprl48aI1ffp0q2PHjpbNZvPo243qOka1vD3OlmVZ06ZNsyS57WNlZaXVrl07q02bNtYXX3zhVv+LL76w5s+fb3Xt2tUKDg62/uEf/sHKy8vz+B2ovZvmtddeq7OPL7/8stW3b18rMDDQ6tevn7VlyxZr7ty5Xt9RtH37duuuu+5y/V4OHz7c4/i//PLL1pAhQ6zAwEArNDTUmjJlittdW5Z1/W6adu3aebRf1+/HmTNnrAceeMBq37691aFDB+uBBx6w8vPzvbqbpqioyEpMTLQ6dOhgSXLtZ11301iWZeXl5Vn33HOP1a5dO6tt27bW6NGjrbffftutTu14PnTokFt5XXdr4fZms6xvzUMCAAB8z7hmBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABG3RIPPbt27ZrOnTunDh068DAdAABuEZZl6cqVK+rRo4fatKl//uOWCCPnzp2r9zseAABAy3b69OkGn4J8S4SR2i88O336tEJCQgz3Bs2pqqpKe/fuVWJiogICAkx3B0AzYJzfPpxOpyIjIxv94tJbIozUnpoJCQkhjLRyVVVVCg4OVkhICG9SQCvFOL/9NHaJBRewAgAAowgjAADAKMIIAAAwijACAACMIowAAACjCCMAAMAowggAADCKMAIAAIwijAAAAKMIIwAAwKibCiOZmZmKjo5WUFCQYmNjlZeXV2/dAwcOyGazefx89tlnN91pAADQevgcRnJycrR48WKtXLlShYWFGjt2rJKSklRcXNzgeseOHVNJSYnrp2/fvjfdaQAA0Hr4HEZ+9atfaf78+VqwYIFiYmK0ceNGRUZGKisrq8H1unbtqm7durl+/Pz8brrTAACg9fDpW3srKytVUFCgZcuWuZUnJiYqPz+/wXWHDx+ub775RnfeeaeefPJJjR8/vt66FRUVqqiocC07nU5J17/psaqqypcu4xZT+/ryOgOtF+P89uHta+xTGCkrK1NNTY0iIiLcyiMiIlRaWlrnOt27d9emTZsUGxuriooKvfLKK5owYYIOHDigu+++u851MjIylJ6e7lG+d+9eBQcH+9LlRk2ZOrVJ28N3EyBpiulOwM1bb75pugtNgrHecjDOW57mGudXr171qp7NsizL20bPnTunnj17Kj8/X/Hx8a7yp59+Wq+88orXF6WmpKTIZrNp9+7ddf57XTMjkZGRKisrU0hIiLfd9UpAYGCTtge0NlWVlaa70CQY60D9mmucO51OhYeH6/Llyw1+fvs0MxIeHi4/Pz+PWZALFy54zJY0ZPTo0crOzq733+12u+x2u0d5QECAAgICvO8wgO+MMQe0fs01zr1t16cLWAMDAxUbGyuHw+FW7nA4lJCQ4HU7hYWF6t69uy+bBgAArZRPMyOSlJaWptmzZysuLk7x8fHatGmTiouLlZqaKklavny5zp49q+3bt0uSNm7cqN69e2vgwIGqrKxUdna2Xn/9db3++utNuycAAOCW5HMYmTFjhsrLy7V27VqVlJRo0KBBys3NVVRUlCSppKTE7ZkjlZWVWrp0qc6ePau2bdtq4MCB2rNnj5KTk5tuLwAAwC3LpwtYTXE6nQoNDW30ApibYrM1bXtAa9Py3yK8w1gH6tdM49zbz2++mwYAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGDUTYWRzMxMRUdHKygoSLGxscrLy/Nqvf/+7/+Wv7+/hg0bdjObBQAArZDPYSQnJ0eLFy/WypUrVVhYqLFjxyopKUnFxcUNrnf58mXNmTNHEyZMuOnOAgCA1sdmWZblywqjRo3SiBEjlJWV5SqLiYnR1KlTlZGRUe96Dz30kPr27Ss/Pz+9+eabOnz4sNfbdDqdCg0N1eXLlxUSEuJLdxtnszVte0Br49tbRMvFWAfq10zj3NvPb39fGq2srFRBQYGWLVvmVp6YmKj8/Px619u6dav+/ve/Kzs7W+vXr290OxUVFaqoqHAtO51OSVJVVZWqqqp86XKjApq0NaD1aeoxZwpjHahfc41zb9v1KYyUlZWppqZGERERbuUREREqLS2tc53jx49r2bJlysvLk7+/d5vLyMhQenq6R/nevXsVHBzsS5cbNaVJWwNan9zcXNNdaBKMdaB+zTXOr1696lU9n8JILdsN052WZXmUSVJNTY1mzZql9PR09evXz+v2ly9frrS0NNey0+lUZGSkEhMTm/40DYAGJScnm+4CgGbWXOO89sxGY3wKI+Hh4fLz8/OYBblw4YLHbIkkXblyRZ988okKCwv16KOPSpKuXbsmy7Lk7++vvXv36p577vFYz263y263e5QHBAQoIIDJVuD7xJgDWr/mGufetuvT3TSBgYGKjY2Vw+FwK3c4HEpISPCoHxISok8//VSHDx92/aSmpqp///46fPiwRo0a5cvmAQBAK+TzaZq0tDTNnj1bcXFxio+P16ZNm1RcXKzU1FRJ10+xnD17Vtu3b1ebNm00aNAgt/W7du2qoKAgj3IAAHB78jmMzJgxQ+Xl5Vq7dq1KSko0aNAg5ebmKioqSpJUUlLS6DNHAAAAavn8nBETeM4IYFDLf4vwDmMdqJ/h54zw3TQAAMAowggAADCKMAIAAIwijAAAAKMIIwAAwCjCCAAAMIowAgAAjCKMAAAAowgjAADAKMIIAAAwijACAACMIowAAACjCCMAAMAowggAADCKMAIAAIwijAAAAKMIIwAAwCjCCAAAMIowAgAAjCKMAAAAowgjAADAKMIIAAAwijACAACMIowAAACjCCMAAMAowggAADCKMAIAAIwijAAAAKMIIwAAwCjCCAAAMIowAgAAjCKMAAAAowgjAADAKMIIAAAwijACAACMIowAAACjCCMAAMAowggAADCKMAIAAIwijAAAAKMIIwAAwCjCCAAAMIowAgAAjCKMAAAAowgjAADAKMIIAAAwijACAACMIowAAACjCCMAAMAowggAADCKMAIAAIwijAAAAKMIIwAAwCjCCAAAMIowAgAAjCKMAAAAowgjAADAKMIIAAAwijACAACMuqkwkpmZqejoaAUFBSk2NlZ5eXn11v3oo480ZswYhYWFqW3bthowYICef/75m+4wAABoXfx9XSEnJ0eLFy9WZmamxowZo5deeklJSUn661//qjvuuMOjfrt27fToo49qyJAhateunT766CMtXLhQ7dq1089+9rMm2QkAAHDrslmWZfmywqhRozRixAhlZWW5ymJiYjR16lRlZGR41cb999+vdu3a6ZVXXvGqvtPpVGhoqC5fvqyQkBBfuts4m61p2wNaG9/eIlouxjpQv2Ya595+fvs0M1JZWamCggItW7bMrTwxMVH5+fletVFYWKj8/HytX7++3joVFRWqqKhwLTudTklSVVWVqqqqfOlyowKatDWg9WnqMWcKYx2oX3ONc2/b9SmMlJWVqaamRhEREW7lERERKi0tbXDdXr166fPPP1d1dbXWrFmjBQsW1Fs3IyND6enpHuV79+5VcHCwL11u1JQmbQ1ofXJzc013oUkw1oH6Ndc4v3r1qlf1fL5mRJJsN0x3WpblUXajvLw8ffnll/rjH/+oZcuW6Yc//KFmzpxZZ93ly5crLS3Ntex0OhUZGanExMSmP00DoEHJycmmuwCgmTXXOK89s9EYn8JIeHi4/Pz8PGZBLly44DFbcqPo6GhJ0uDBg3X+/HmtWbOm3jBit9tlt9s9ygMCAhQQwGQr8H1izAGtX3ONc2/b9enW3sDAQMXGxsrhcLiVOxwOJSQkeN2OZVlu14QAAIDbl8+nadLS0jR79mzFxcUpPj5emzZtUnFxsVJTUyVdP8Vy9uxZbd++XZL029/+VnfccYcGDBgg6fpzRzZs2KCf//znTbgbAADgVuVzGJkxY4bKy8u1du1alZSUaNCgQcrNzVVUVJQkqaSkRMXFxa76165d0/Lly3Xy5En5+/urT58+euaZZ7Rw4cKm2wsAAHDL8vk5IybwnBHAoJb/FuEdxjpQP8PPGeG7aQAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEbdVBjJzMxUdHS0goKCFBsbq7y8vHrr7tq1S5MmTVKXLl0UEhKi+Ph4vfvuuzfdYQAA0Lr4HEZycnK0ePFirVy5UoWFhRo7dqySkpJUXFxcZ/0PP/xQkyZNUm5urgoKCjR+/HilpKSosLDwO3ceAADc+myWZVm+rDBq1CiNGDFCWVlZrrKYmBhNnTpVGRkZXrUxcOBAzZgxQ6tWrarz3ysqKlRRUeFadjqdioyMVFlZmUJCQnzpbqMCAgObtD2gtamqrDTdhSbBWAfq11zj3Ol0Kjw8XJcvX27w89vfl0YrKytVUFCgZcuWuZUnJiYqPz/fqzauXbumK1euqHPnzvXWycjIUHp6ukf53r17FRwc7EuXGzWlSVsDWp/c3FzTXWgSjHWgfs01zq9evepVPZ/CSFlZmWpqahQREeFWHhERodLSUq/aeO655/TVV1/pwQcfrLfO8uXLlZaW5lqunRlJTExs8pkRAA1LTk423QUAzay5xrnT6fSqnk9hpJbNZnNbtizLo6wuO3fu1Jo1a/TWW2+pa9eu9daz2+2y2+0e5QEBAQoICPC9wwBuGmMOaP2aa5x7265PYSQ8PFx+fn4esyAXLlzwmC25UU5OjubPn6/XXntNEydO9GWzAACgFfPpbprAwEDFxsbK4XC4lTscDiUkJNS73s6dOzVv3jzt2LFDkydPvrmeAgCAVsnn0zRpaWmaPXu24uLiFB8fr02bNqm4uFipqamSrl/vcfbsWW3fvl3S9SAyZ84c/frXv9bo0aNdsypt27ZVaGhoE+4KAAC4FfkcRmbMmKHy8nKtXbtWJSUlGjRokHJzcxUVFSVJKikpcXvmyEsvvaTq6motWrRIixYtcpXPnTtX27Zt++57AAAAbmk+P2fEBKfTqdDQ0EbvU74pXlx4C9zWWv5bhHcY60D9mmmce/v5zXfTAAAAowgjAADAKMIIAAAwijACAACMIowAAACjCCMAAMAowggAADCKMAIAAIwijAAAAKMIIwAAwCjCCAAAMIowAgAAjCKMAAAAowgjAADAKMIIAAAwijACAACMIowAAACjCCMAAMAowggAADCKMAIAAIwijAAAAKMIIwAAwCjCCAAAMIowAgAAjCKMAAAAowgjAADAKMIIAAAwijACAACMIowAAACjCCMAAMAowggAADCKMAIAAIwijAAAAKMIIwAAwCjCCAAAMIowAgAAjCKMAAAAowgjAADAKMIIAAAwijACAACMIowAAACjCCMAAMAowggAADCKMAIAAIwijAAAAKMIIwAAwCjCCAAAMIowAgAAjCKMAAAAowgjAADAKMIIAAAwijACAACMIowAAACjCCMAAMAowggAADCKMAIAAIwijAAAAKMIIwAAwCjCCAAAMOqmwkhmZqaio6MVFBSk2NhY5eXl1Vu3pKREs2bNUv/+/dWmTRstXrz4ZvsKAABaIZ/DSE5OjhYvXqyVK1eqsLBQY8eOVVJSkoqLi+usX1FRoS5dumjlypUaOnTod+4wAABoXWyWZVm+rDBq1CiNGDFCWVlZrrKYmBhNnTpVGRkZDa47btw4DRs2TBs3bvSpk06nU6Ghobp8+bJCQkJ8WrdRNlvTtge0Nr69RbRcjHWgfs00zr39/Pb3pdHKykoVFBRo2bJlbuWJiYnKz8+/uZ7WoaKiQhUVFa5lp9MpSaqqqlJVVVWTbUeSApq0NaD1aeoxZwpjHahfc41zb9v1KYyUlZWppqZGERERbuUREREqLS31pakGZWRkKD093aN87969Cg4ObrLtSNKUJm0NaH1yc3NNd6FJMNaB+jXXOL969apX9XwKI7VsN0x3WpblUfZdLF++XGlpaa5lp9OpyMhIJSYmNv1pGgANSk5ONt0FAM2sucZ57ZmNxvgURsLDw+Xn5+cxC3LhwgWP2ZLvwm63y263e5QHBAQoIIDJVuD7xJgDWr/mGufetuvT3TSBgYGKjY2Vw+FwK3c4HEpISPClKQAAAEk3cZomLS1Ns2fPVlxcnOLj47Vp0yYVFxcrNTVV0vVTLGfPntX27dtd6xw+fFiS9OWXX+rzzz/X4cOHFRgYqDvvvLNp9gIAANyyfA4jM2bMUHl5udauXauSkhINGjRIubm5ioqKknT9IWc3PnNk+PDhrv8vKCjQjh07FBUVpaKiou/WewAAcMvz+TkjJvCcEcCglv8W4R3GOlA/w88Z4btpAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGHVTYSQzM1PR0dEKCgpSbGys8vLyGqz/wQcfKDY2VkFBQfrBD36gF1988aY6CwAAWh+fw0hOTo4WL16slStXqrCwUGPHjlVSUpKKi4vrrH/y5EklJydr7NixKiws1IoVK/TYY4/p9ddf/86dBwAAtz6bZVmWLyuMGjVKI0aMUFZWlqssJiZGU6dOVUZGhkf9f//3f9fu3bt19OhRV1lqaqr+/Oc/6+DBg15t0+l0KjQ0VJcvX1ZISIgv3W2czda07QGtjW9vES0XYx2oXzONc28/v/19abSyslIFBQVatmyZW3liYqLy8/PrXOfgwYNKTEx0K/vxj3+szZs3q6qqSgEBAR7rVFRUqKKiwrV8+fJlSdLFixdVVVXlS5cbFdakrQGtT3l5uekuNAnGOlC/5hrnV65ckSQ1Nu/hUxgpKytTTU2NIiIi3MojIiJUWlpa5zqlpaV11q+urlZZWZm6d+/usU5GRobS09M9yqOjo33pLoCmEB5uugcAmlszj/MrV64oNDS03n/3KYzUst0w3WlZlkdZY/XrKq+1fPlypaWluZavXbumixcvKiwsrMHt4NbndDoVGRmp06dPN/0pOQAtAuP89mFZlq5cuaIePXo0WM+nMBIeHi4/Pz+PWZALFy54zH7U6tatW531/f39FRZW98Sp3W6X3W53K+vYsaMvXcUtLiQkhDcpoJVjnN8eGpoRqeXT3TSBgYGKjY2Vw+FwK3c4HEpISKhznfj4eI/6e/fuVVxcXJ3XiwAAgNuLz7f2pqWl6eWXX9aWLVt09OhRPf744youLlZqaqqk66dY5syZ46qfmpqqU6dOKS0tTUePHtWWLVu0efNmLV26tOn2AgAA3LJ8vmZkxowZKi8v19q1a1VSUqJBgwYpNzdXUVFRkqSSkhK3Z45ER0crNzdXjz/+uH7729+qR48e+s1vfqMHHnig6fYCrYbdbtfq1as9TtMBaD0Y57iRz88ZAQAAaEp8Nw0AADCKMAIAAIwijAAAAKMIIwAAwCjCCAAAMIowghYjMzNT0dHRCgoKUmxsrPLy8kx3CUAT+vDDD5WSkqIePXrIZrPpzTffNN0ltBCEEbQIOTk5Wrx4sVauXKnCwkKNHTtWSUlJbs+sAXBr++qrrzR06FC98MILpruCFobnjKBFGDVqlEaMGKGsrCxXWUxMjKZOnaqMjAyDPQPQHGw2m9544w1NnTrVdFfQAjAzAuMqKytVUFCgxMREt/LExETl5+cb6hUA4PtCGIFxZWVlqqmp8fjm54iICI9vfAYAtD6EEbQYNpvNbdmyLI8yAEDrQxiBceHh4fLz8/OYBblw4YLHbAkAoPUhjMC4wMBAxcbGyuFwuJU7HA4lJCQY6hUA4Pvib7oDgCSlpaVp9uzZiouLU3x8vDZt2qTi4mKlpqaa7hqAJvLll1/qxIkTruWTJ0/q8OHD6ty5s+644w6DPYNp3NqLFiMzM1PPPvusSkpKNGjQID3//PO6++67TXcLQBM5cOCAxo8f71E+d+5cbdu27fvvEFoMwggAADCKa0YAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAY9f8A4G8fYFpRSg4AAAAASUVORK5CYII=", + "image/png": "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\n", "text/plain": [ "
" ] @@ -535,7 +535,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -576,7 +576,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -609,17 +609,17 @@ "output_type": "stream", "text": [ " === Starting experiment === \n", - " Reward condition: Left, Observation: [CENTER, No reward, Cue Left]\n", + " Reward condition: Right, Observation: [CENTER, No reward, Cue Left]\n", "[Step 0] Action: [Move to CUE LOCATION]\n", - "[Step 0] Observation: [CUE LOCATION, No reward, Cue Left]\n", - "[Step 1] Action: [Move to LEFT ARM]\n", - "[Step 1] Observation: [LEFT ARM, Reward!, Cue Right]\n", - "[Step 2] Action: [Move to LEFT ARM]\n", - "[Step 2] Observation: [LEFT ARM, Reward!, Cue Right]\n", - "[Step 3] Action: [Move to LEFT ARM]\n", - "[Step 3] Observation: [LEFT ARM, Reward!, Cue Right]\n", - "[Step 4] Action: [Move to LEFT ARM]\n", - "[Step 4] Observation: [LEFT ARM, Reward!, Cue Left]\n" + "[Step 0] Observation: [CUE LOCATION, No reward, Cue Right]\n", + "[Step 1] Action: [Move to RIGHT ARM]\n", + "[Step 1] Observation: [RIGHT ARM, Reward!, Cue Left]\n", + "[Step 2] Action: [Move to RIGHT ARM]\n", + "[Step 2] Observation: [RIGHT ARM, Reward!, Cue Right]\n", + "[Step 3] Action: [Move to RIGHT ARM]\n", + "[Step 3] Observation: [RIGHT ARM, Reward!, Cue Left]\n", + "[Step 4] Action: [Move to RIGHT ARM]\n", + "[Step 4] Observation: [RIGHT ARM, Reward!, Cue Left]\n" ] } ], @@ -681,7 +681,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -701,7 +701,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -735,7 +735,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -815,16 +815,16 @@ "data": { "text/plain": [ "{'actions': DeviceArray([[3, 0],\n", - " [2, 0],\n", - " [2, 0],\n", - " [2, 0],\n", - " [2, 0]], dtype=int32),\n", + " [1, 0],\n", + " [1, 0],\n", + " [1, 0],\n", + " [1, 0]], dtype=int32),\n", " 'outcomes': DeviceArray([[0, 0, 1],\n", - " [3, 0, 1],\n", - " [2, 1, 0],\n", - " [2, 1, 0],\n", - " [2, 1, 0],\n", - " [2, 1, 1]], dtype=int32)}" + " [3, 0, 0],\n", + " [1, 1, 1],\n", + " [1, 1, 0],\n", + " [1, 1, 1],\n", + " [1, 1, 1]], dtype=int32)}" ] }, "execution_count": 30, @@ -846,7 +846,7 @@ { "data": { "text/plain": [ - "DeviceArray(-20.578611, dtype=float32)" + "DeviceArray(-14.946159, dtype=float32)" ] }, "execution_count": 31, @@ -859,9 +859,9 @@ "from functools import partial\n", "\n", "# parameters have to be jax arrays, lists or dictionaries of jax arrays\n", - "e = 1e-10\n", + "e = 1e-15\n", "params = {\n", - " 'A': [jnp.array((x + e)/(x + e).sum(0) ) for x in list(A_gp)],\n", + " 'A': [jnp.array(x) for x in list(A_gp)],\n", " 'B': [jnp.array(x) for x in list(B_gp)],\n", " 'C': [jnp.array(x) for x in list(agent.C)],\n", " 'D': [jnp.array(x) for x in list(agent.D)]\n", @@ -899,7 +899,7 @@ { "data": { "text/plain": [ - "DeviceArray(-20.578611, dtype=float32)" + "DeviceArray(-14.946159, dtype=float32)" ] }, "execution_count": 33, @@ -913,102 +913,102 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'A': [DeviceArray([[[ 5.7870839e-03, -5.7870746e-03],\n", - " [ 5.7870840e+07, -5.7870744e+07],\n", - " [ 5.7870840e+07, -5.7870744e+07],\n", - " [ 5.7870840e+07, -5.7870744e+07]],\n", + "{'A': [DeviceArray([[[ 4.8202928e-08, -5.9604645e-08],\n", + " [-1.1346479e-13, 7.1054274e-15],\n", + " [ 0.0000000e+00, 0.0000000e+00],\n", + " [-5.6843419e-14, 0.0000000e+00]],\n", " \n", - " [[ 0.0000000e+00, -1.1920929e-07],\n", + " [[ 0.0000000e+00, 0.0000000e+00],\n", + " [ 5.1783339e-08, -2.9082368e-09],\n", " [ 0.0000000e+00, 0.0000000e+00],\n", - " [-5.7183206e-06, 0.0000000e+00],\n", - " [ 2.3283064e-10, 0.0000000e+00]],\n", + " [-5.6843419e-14, 0.0000000e+00]],\n", " \n", - " [[-2.5848984e+08, 2.5849042e+08],\n", - " [-2.5848984e+08, 2.5849042e+08],\n", - " [-2.5848985e-02, 2.5849041e-02],\n", - " [-2.5848984e+08, 2.5849042e+08]],\n", + " [[ 0.0000000e+00, 0.0000000e+00],\n", + " [-1.1346479e-13, 7.1054274e-15],\n", + " [ 0.0000000e+00, 0.0000000e+00],\n", + " [-5.6843419e-14, 0.0000000e+00]],\n", " \n", - " [[-4.3367730e+06, 4.3366850e+06],\n", - " [-4.3367730e+06, 4.3366850e+06],\n", - " [-4.3367730e+06, 4.3366850e+06],\n", - " [-4.3367731e-04, 4.3366849e-04]]], dtype=float32),\n", - " DeviceArray([[[ 5.35340654e-03, -5.35340607e-03],\n", - " [ 5.35340680e+07, -5.35340600e+07],\n", - " [ 5.35340680e+07, -5.35340600e+07],\n", - " [ 5.35340654e-03, -5.35340607e-03]],\n", + " [[ 0.0000000e+00, 0.0000000e+00],\n", + " [-1.1346479e-13, 7.1054274e-15],\n", + " [ 0.0000000e+00, 0.0000000e+00],\n", + " [ 0.0000000e+00, -2.9082159e-09]]], dtype=float32),\n", + " DeviceArray([[[ 4.8202928e-08, -6.2512861e-08],\n", + " [-1.1346479e-13, 7.1054274e-15],\n", + " [ 0.0000000e+00, 0.0000000e+00],\n", + " [ 4.8202928e-08, -6.2512861e-08]],\n", " \n", - " [[-2.58489840e+08, 2.58490416e+08],\n", - " [-8.06309986e+00, 1.28330505e+00],\n", - " [ 7.23502064e+00, -2.27407408e+00],\n", - " [-2.58489840e+08, 2.58490416e+08]],\n", + " [[-3.0195665e-01, -4.5293498e-01],\n", + " [ 6.2086362e-01, 5.9745731e+00],\n", + " [-1.6947640e-02, -8.0687037e+00],\n", + " [-3.0195662e-01, 2.5470653e+00]],\n", " \n", - " [[ 4.54609841e-01, 3.03870082e-01],\n", - " [ 8.40551758e+00, 1.11163985e-02],\n", - " [-8.93804359e+00, 2.40763760e+00],\n", - " [ 4.54941571e-01, -2.68013167e+00]]], dtype=float32),\n", - " DeviceArray([[[-5.1697962e-02, 5.1698081e-02],\n", - " [-5.1697969e-02, 5.1698081e-02],\n", - " [-5.1697969e-02, 5.1698077e-02],\n", - " [-1.0056265e-02, 2.5849040e+08]],\n", + " [[ 3.0195665e-01, 4.5293498e-01],\n", + " [-6.2086368e-01, -5.9745741e+00],\n", + " [ 1.6950233e-02, 8.0687046e+00],\n", + " [ 3.0195662e-01, -2.5470653e+00]]], dtype=float32),\n", + " DeviceArray([[[ 1.3877788e-17, -1.1632905e-08],\n", + " [ 8.6736174e-19, -1.1632905e-08],\n", + " [-6.6613381e-16, -1.1632905e-08],\n", + " [ 1.5639502e-07, -4.7767704e+01]],\n", " \n", - " [[ 1.0706819e-02, -1.0706808e-02],\n", - " [ 1.0706813e-02, -1.0706812e-02],\n", - " [ 1.0706813e-02, -1.0706816e-02],\n", - " [ 5.3534068e+07, -5.3447243e-03]]], dtype=float32)],\n", - " 'B': [DeviceArray([[[ 7.5848001e-01, -1.1582707e+02, 9.4778961e+01,\n", - " 1.6476847e+01],\n", - " [ 1.0218215e-19, -2.5950433e-17, 2.8914750e-17,\n", - " -7.7291948e-19],\n", - " [ 1.0218187e-09, -2.5950365e-07, 2.8914673e-07,\n", - " -7.7291737e-09],\n", - " [ 4.8658388e-24, -4.0379652e-24, 1.4519616e-22,\n", - " -3.6805861e-23]],\n", + " [[ 1.9997253e-07, -1.1920929e-07],\n", + " [ 1.9997253e-07, -1.1920929e-07],\n", + " [ 1.9997253e-07, -1.1920929e-07],\n", + " [ 5.6628981e+00, -7.8145462e-08]]], dtype=float32)],\n", + " 'B': [DeviceArray([[[ 3.01956534e-01, 1.47320042e+01, -1.31633423e+02,\n", + " 7.21276321e+01],\n", + " [ 4.52934682e-01, 3.07049377e+02, -2.62853363e+02,\n", + " -1.21084452e+01],\n", + " [ 4.52937736e-33, 3.07051425e-30, -2.62855113e-30,\n", + " -1.21085252e-31],\n", + " [ 3.01955963e-17, 3.02909273e-15, -8.26975670e-17,\n", + " -8.07228275e-16]],\n", " \n", - " [[-1.1004541e+01, 3.7408698e-01, 6.2804016e+01,\n", - " 3.0473413e+01],\n", - " [-1.5605089e-18, 7.6312736e-20, 1.7781013e-17,\n", - " -1.6702473e-18],\n", - " [-1.5605048e-08, 7.6312540e-10, 1.7780965e-07,\n", - " -1.6702430e-08],\n", - " [-6.5026783e-23, 5.4871828e-25, 6.9984117e-23,\n", - " -7.0052571e-23]],\n", + " [[-1.47221327e+01, 4.19397838e-03, -6.52539444e+01,\n", + " 1.36325211e+02],\n", + " [-2.19382572e+01, -1.17391949e+01, -1.30286682e+02,\n", + " -2.32241726e+01],\n", + " [-2.19384039e-31, -1.17392718e-31, -1.30287534e-30,\n", + " -2.32243289e-31],\n", + " [-1.50119840e-15, -2.48344952e-18, -4.42394456e-17,\n", + " -1.58692597e-15]],\n", " \n", - " [[-1.0715122e+01, -5.5861778e+01, -1.7399567e+01,\n", - " 3.6492748e+01],\n", - " [-1.3655559e-18, -1.2508033e-17, -3.9292204e-18,\n", - " -1.4710969e-18],\n", - " [-1.3655523e-08, -1.2507999e-07, -3.9292100e-08,\n", - " -1.4710931e-08],\n", - " [-7.4310293e-23, -2.4831308e-24, -4.2698068e-25,\n", - " -7.9535960e-23]],\n", + " [[-1.47221327e+01, 7.28492451e+00, 1.24194115e-01,\n", + " 1.42085220e+02],\n", + " [-2.22281361e+01, 1.63661453e+02, 2.31776506e-01,\n", + " -2.35140514e+01],\n", + " [-2.22282831e-31, 1.63662555e-30, 2.31778062e-33,\n", + " -2.35142081e-31],\n", + " [-1.44322280e-15, 1.50122159e-15, 3.32224416e-18,\n", + " -1.52895037e-15]],\n", " \n", - " [[-5.2383151e+00, -1.1769194e+02, 9.6304901e+01,\n", - " -2.2093873e+00],\n", - " [-7.0570387e-19, -2.6368245e-17, 2.9380284e-17,\n", - " 1.0364109e-19],\n", - " [-7.0570199e-09, -2.6368178e-07, 2.9380206e-07,\n", - " 1.0364081e-09],\n", - " [-3.3605105e-23, -4.1029776e-24, 1.4753386e-22,\n", - " 4.9353130e-24]]], dtype=float32),\n", - " DeviceArray([[[-16.28082 ],\n", - " [ 4.493703 ]],\n", + " [[-7.28478909e+00, 1.48017712e+01, -1.32256821e+02,\n", + " -2.69804382e+00],\n", + " [-1.09271812e+01, 3.08503510e+02, -2.64098145e+02,\n", + " 4.52934802e-01],\n", + " [-1.09272544e-31, 3.08505540e-30, -2.64099914e-30,\n", + " 4.52937810e-33],\n", + " [-7.28477557e-16, 3.04343787e-15, -8.30892073e-17,\n", + " 3.01956029e-17]]], dtype=float32),\n", + " DeviceArray([[[ 0.6123013],\n", + " [ 26.513119 ]],\n", " \n", - " [[ 16.497871 ],\n", - " [ -2.1955678]]], dtype=float32)],\n", - " 'C': [DeviceArray([-0.2528267 , -2.6904182 , 2.2015145 , 0.74172956], dtype=float32),\n", - " DeviceArray([ 0.48890284, -3.3255424 , 2.8366387 ], dtype=float32),\n", - " DeviceArray([-0.5225125, 0.5225114], dtype=float32)],\n", - " 'D': [DeviceArray([ 0., nan, nan, nan], dtype=float32),\n", - " DeviceArray([-0.16396463, 0.16396508], dtype=float32)]}" + " [[ -1.7142805],\n", + " [-13.481548 ]]], dtype=float32)],\n", + " 'C': [DeviceArray([-0.25163043, 2.1984794 , -2.6952178 , 0.7483697 ], dtype=float32),\n", + " DeviceArray([ 0.49673927, -2.3932436 , 1.8965049 ], dtype=float32),\n", + " DeviceArray([-0.47483674, 0.47483736], dtype=float32)],\n", + " 'D': [DeviceArray([0., 0., 0., 0.], dtype=float32),\n", + " DeviceArray([ 7.9989013e-07, -5.2336878e-07], dtype=float32)]}" ] }, - "execution_count": 69, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } @@ -1020,9 +1020,18 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 62, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-7.6029861e-01 -4.9739015e-01 1.3287575e-07]\n", + "-6.935675\n" + ] + } + ], "source": [ "import numpyro as npyro\n", "import numpyro.distributions as dist\n", @@ -1030,23 +1039,23 @@ "\n", "def trans_params(z):\n", "\n", - " a = nn.sigmoid(z[0])\n", - " lam = nn.softplus(z[1])\n", - " d = z[2:]\n", + " a = npyro.deterministic('a', nn.sigmoid(z[0]))\n", + " lam = npyro.deterministic('lambda', nn.softplus(z[1]))\n", + " d = npyro.deterministic('d', nn.sigmoid(z[2]))\n", "\n", " A = lax.stop_gradient([jnp.array(x) for x in list(A_gp)])\n", "\n", - " middle_matrix1 = jnp.array([[0.0, 0.0], [a, 1-a], [1-a, a]])\n", - " middle_matrix2 = jnp.array([[0.0, 0.0], [1-a, a], [a, 1-a]])\n", + " middle_matrix1 = jnp.array([[0., 0.], [a, 1-a], [1-a, a]])\n", + " middle_matrix2 = jnp.array([[0., 0.], [1-a, a], [a, 1-a]])\n", "\n", - " side_vector = jnp.stack([jnp.array([1.0, 0.0, 0.0]), jnp.array([1.0, 0.0, 0.0])], -1)\n", + " side_vector = jnp.stack([jnp.array([1.0, 0., 0.]), jnp.array([1.0, 0., 0.])], -1)\n", "\n", - " # A[1] = jnp.stack([side_vector, middle_matrix1, middle_matrix2, side_vector], -2)\n", + " A[1] = jnp.stack([side_vector, middle_matrix1, middle_matrix2, side_vector], -2)\n", " \n", " C = lax.stop_gradient([jnp.array(x) for x in list(agent.C)])\n", " C[1] = lam * jnp.array([0., -1., 1.])\n", "\n", - " D = [nn.one_hot(0, 4), d]\n", + " D = [lax.stop_gradient(nn.one_hot(0, 4)), jnp.array([d, 1-d])]\n", "\n", " params = {\n", " 'A': A,\n", @@ -1058,126 +1067,186 @@ " return params\n", "\n", "def model(data, T, n_pars=3):\n", - " z = npyro.sample('z', dist.Normal(0., 1.).expand([n_pars]))\n", + " z = npyro.sample('z', dist.Normal(0., 1.).expand([n_pars]).to_event(1))\n", + " x = trans_params(z)\n", + " log_prob = model_log_likelihood(T, data, x)\n", + " npyro.factor('log_prob', log_prob)\n", "\n", - " params = trans_params(z)\n", + " return log_prob\n", "\n", - " log_prob = model_log_likelihood(T, data, params)\n", - " npyro.factor('log_prob', log_prob)\n", + "print(jax.grad(lambda x: model_log_likelihood(T, measurments, trans_params(x)))(jnp.ones(3)))\n", "\n", - " return log_prob" + "with npyro.handlers.seed(rng_seed=101111):\n", + " lp = model(measurments, T)\n", + " print(lp)" ] }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 85, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "DeviceArray([ 0. , -0.10822758, nan, nan], dtype=float32)" - ] - }, - "execution_count": 68, - "metadata": {}, - "output_type": "execute_result" + "name": "stderr", + "output_type": "stream", + "text": [ + "sample: 100%|███████████████████████████████████████████████████████████████| 1250/1250 [00:20<00:00, 60.32it/s]\n" + ] } ], "source": [ - "jax.grad(lambda x: model_log_likelihood(T, measurments, trans_params(x)))(jnp.ones(4)/2)" + "# inference with NUTS and MCMC\n", + "from numpyro.infer import NUTS, MCMC\n", + "from numpyro.infer import init_to_feasible, init_to_sample\n", + "from jax import random\n", + "\n", + "rng_key = random.PRNGKey(0)\n", + "kernel = NUTS(model, init_strategy=init_to_feasible)\n", + "\n", + "num_chains=4\n", + "mcmc = MCMC(kernel, num_warmup=1000, num_samples=250, num_chains=num_chains, chain_method='vectorized')\n", + "\n", + "rng_key, _rng_key = random.split(rng_key)\n", + "mcmc.run(_rng_key, measurments, T)\n", + "samples = mcmc.get_samples()" ] }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 98, "metadata": {}, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "[DeviceArray([[0., 0., 0.],\n", - " [0., 0., 0.],\n", - " [0., 0., 0.],\n", - " [0., 0., 0.]], dtype=float32),\n", - " DeviceArray([[ 0. , 0. , 0.19661196],\n", - " [ 0. , 0. , -0.19661196]], dtype=float32)]" + "
" ] }, - "execution_count": 64, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "out = jax.jacobian(trans_params)(jnp.ones(3))\n", - "out['D']" + "import arviz as az\n", + "az.style.use('arviz-darkgrid')\n", + "\n", + "coords = {\n", + " 'vars': jnp.arange(3), \n", + "}\n", + "dims = {'z': [\"vars\"], 'd': [], 'lambda': [], 'a': []}\n", + "data_kwargs = {\n", + " \"dims\": dims,\n", + " \"coords\": coords,\n", + " \"num_chains\": num_chains\n", + "}\n", + "data_mcmc = az.from_numpyro(posterior=mcmc, posterior_predictive=samples)\n", + "az.plot_trace(data_mcmc, kind=\"rank_bars\", var_names=['~z']);\n", + "\n", + "#TODO: maybe plot real values on top of samples from the posterior" ] }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 122, "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "-7.0516567\n" + "100%|████████████████████| 1000/1000 [00:04<00:00, 248.11it/s, init loss: 14.4783, avg. loss [951-1000]: 7.1074]\n" ] } ], "source": [ - "with npyro.handlers.seed(rng_seed=101111):\n", - " lp = model(measurments, T)\n", - " print(lp)" + "# inferenace with SVI and autoguides\n", + "import optax\n", + "from numpyro.infer import SVI, Trace_ELBO, Predictive\n", + "from numpyro.infer.autoguide import AutoMultivariateNormal\n", + "\n", + "num_iters = 1000\n", + "guide = AutoMultivariateNormal(model)\n", + "optimizer = npyro.optim.optax_to_numpyro(optax.chain(optax.adabelief(1e-3)))\n", + "svi = SVI(model, guide, optimizer, Trace_ELBO(num_particles=10))\n", + "rng_key, _rng_key = random.split(rng_key)\n", + "svi_res = svi.run(_rng_key, num_iters, measurments, T)" ] }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 123, "metadata": {}, "outputs": [ { - "ename": "RuntimeError", - "evalue": "Cannot find valid initial parameters. Please check your model again.", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn [43], line 8\u001b[0m\n\u001b[1;32m 5\u001b[0m kernel \u001b[38;5;241m=\u001b[39m NUTS(model, init_strategy\u001b[38;5;241m=\u001b[39minit_to_feasible)\n\u001b[1;32m 7\u001b[0m mcmc \u001b[38;5;241m=\u001b[39m MCMC(kernel, num_warmup\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m10\u001b[39m, num_samples\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m10\u001b[39m)\n\u001b[0;32m----> 8\u001b[0m samples \u001b[38;5;241m=\u001b[39m \u001b[43mmcmc\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrandom\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mPRNGKey\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmeasurments\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mT\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/mcmc.py:593\u001b[0m, in \u001b[0;36mMCMC.run\u001b[0;34m(self, rng_key, extra_fields, init_params, *args, **kwargs)\u001b[0m\n\u001b[1;32m 591\u001b[0m map_args \u001b[39m=\u001b[39m (rng_key, init_state, init_params)\n\u001b[1;32m 592\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mnum_chains \u001b[39m==\u001b[39m \u001b[39m1\u001b[39m:\n\u001b[0;32m--> 593\u001b[0m states_flat, last_state \u001b[39m=\u001b[39m partial_map_fn(map_args)\n\u001b[1;32m 594\u001b[0m states \u001b[39m=\u001b[39m tree_map(\u001b[39mlambda\u001b[39;00m x: x[jnp\u001b[39m.\u001b[39mnewaxis, \u001b[39m.\u001b[39m\u001b[39m.\u001b[39m\u001b[39m.\u001b[39m], states_flat)\n\u001b[1;32m 595\u001b[0m \u001b[39melse\u001b[39;00m:\n", - "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/mcmc.py:381\u001b[0m, in \u001b[0;36mMCMC._single_chain_mcmc\u001b[0;34m(self, init, args, kwargs, collect_fields)\u001b[0m\n\u001b[1;32m 379\u001b[0m rng_key, init_state, init_params \u001b[39m=\u001b[39m init\n\u001b[1;32m 380\u001b[0m \u001b[39mif\u001b[39;00m init_state \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 381\u001b[0m init_state \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msampler\u001b[39m.\u001b[39;49minit(\n\u001b[1;32m 382\u001b[0m rng_key,\n\u001b[1;32m 383\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mnum_warmup,\n\u001b[1;32m 384\u001b[0m init_params,\n\u001b[1;32m 385\u001b[0m model_args\u001b[39m=\u001b[39;49margs,\n\u001b[1;32m 386\u001b[0m model_kwargs\u001b[39m=\u001b[39;49mkwargs,\n\u001b[1;32m 387\u001b[0m )\n\u001b[1;32m 388\u001b[0m sample_fn, postprocess_fn \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_get_cached_fns()\n\u001b[1;32m 389\u001b[0m diagnostics \u001b[39m=\u001b[39m (\n\u001b[1;32m 390\u001b[0m \u001b[39mlambda\u001b[39;00m x: \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msampler\u001b[39m.\u001b[39mget_diagnostics_str(x[\u001b[39m0\u001b[39m])\n\u001b[1;32m 391\u001b[0m \u001b[39mif\u001b[39;00m rng_key\u001b[39m.\u001b[39mndim \u001b[39m==\u001b[39m \u001b[39m1\u001b[39m\n\u001b[1;32m 392\u001b[0m \u001b[39melse\u001b[39;00m \u001b[39m\"\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 393\u001b[0m ) \u001b[39m# noqa: E731\u001b[39;00m\n", - "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/hmc.py:706\u001b[0m, in \u001b[0;36mHMC.init\u001b[0;34m(self, rng_key, num_warmup, init_params, model_args, model_kwargs)\u001b[0m\n\u001b[1;32m 701\u001b[0m \u001b[39m# vectorized\u001b[39;00m\n\u001b[1;32m 702\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 703\u001b[0m rng_key, rng_key_init_model \u001b[39m=\u001b[39m jnp\u001b[39m.\u001b[39mswapaxes(\n\u001b[1;32m 704\u001b[0m vmap(random\u001b[39m.\u001b[39msplit)(rng_key), \u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m\n\u001b[1;32m 705\u001b[0m )\n\u001b[0;32m--> 706\u001b[0m init_params \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_init_state(\n\u001b[1;32m 707\u001b[0m rng_key_init_model, model_args, model_kwargs, init_params\n\u001b[1;32m 708\u001b[0m )\n\u001b[1;32m 709\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_potential_fn \u001b[39mand\u001b[39;00m init_params \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 710\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[1;32m 711\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mValid value of `init_params` must be provided with\u001b[39m\u001b[39m\"\u001b[39m \u001b[39m\"\u001b[39m\u001b[39m `potential_fn`.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 712\u001b[0m )\n", - "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/hmc.py:652\u001b[0m, in \u001b[0;36mHMC._init_state\u001b[0;34m(self, rng_key, model_args, model_kwargs, init_params)\u001b[0m\n\u001b[1;32m 650\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_init_state\u001b[39m(\u001b[39mself\u001b[39m, rng_key, model_args, model_kwargs, init_params):\n\u001b[1;32m 651\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_model \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 652\u001b[0m init_params, potential_fn, postprocess_fn, model_trace \u001b[39m=\u001b[39m initialize_model(\n\u001b[1;32m 653\u001b[0m rng_key,\n\u001b[1;32m 654\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_model,\n\u001b[1;32m 655\u001b[0m dynamic_args\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m,\n\u001b[1;32m 656\u001b[0m init_strategy\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_init_strategy,\n\u001b[1;32m 657\u001b[0m model_args\u001b[39m=\u001b[39;49mmodel_args,\n\u001b[1;32m 658\u001b[0m model_kwargs\u001b[39m=\u001b[39;49mmodel_kwargs,\n\u001b[1;32m 659\u001b[0m forward_mode_differentiation\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_forward_mode_differentiation,\n\u001b[1;32m 660\u001b[0m )\n\u001b[1;32m 661\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_init_fn \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 662\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_init_fn, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_sample_fn \u001b[39m=\u001b[39m hmc(\n\u001b[1;32m 663\u001b[0m potential_fn_gen\u001b[39m=\u001b[39mpotential_fn,\n\u001b[1;32m 664\u001b[0m kinetic_fn\u001b[39m=\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_kinetic_fn,\n\u001b[1;32m 665\u001b[0m algo\u001b[39m=\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_algo,\n\u001b[1;32m 666\u001b[0m )\n", - "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/util.py:698\u001b[0m, in \u001b[0;36minitialize_model\u001b[0;34m(rng_key, model, init_strategy, dynamic_args, model_args, model_kwargs, forward_mode_differentiation, validate_grad)\u001b[0m\n\u001b[1;32m 685\u001b[0m w\u001b[39m.\u001b[39mmessage\u001b[39m.\u001b[39margs \u001b[39m=\u001b[39m (\n\u001b[1;32m 686\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mSite \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m: \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m\"\u001b[39m\u001b[39m.\u001b[39mformat(\n\u001b[1;32m 687\u001b[0m site[\u001b[39m\"\u001b[39m\u001b[39mname\u001b[39m\u001b[39m\"\u001b[39m], w\u001b[39m.\u001b[39mmessage\u001b[39m.\u001b[39margs[\u001b[39m0\u001b[39m]\n\u001b[1;32m 688\u001b[0m ),\n\u001b[1;32m 689\u001b[0m ) \u001b[39m+\u001b[39m w\u001b[39m.\u001b[39mmessage\u001b[39m.\u001b[39margs[\u001b[39m1\u001b[39m:]\n\u001b[1;32m 690\u001b[0m warnings\u001b[39m.\u001b[39mshowwarning(\n\u001b[1;32m 691\u001b[0m w\u001b[39m.\u001b[39mmessage,\n\u001b[1;32m 692\u001b[0m w\u001b[39m.\u001b[39mcategory,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 696\u001b[0m line\u001b[39m=\u001b[39mw\u001b[39m.\u001b[39mline,\n\u001b[1;32m 697\u001b[0m )\n\u001b[0;32m--> 698\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mRuntimeError\u001b[39;00m(\n\u001b[1;32m 699\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mCannot find valid initial parameters. Please check your model again.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 700\u001b[0m )\n\u001b[1;32m 701\u001b[0m \u001b[39mreturn\u001b[39;00m ModelInfo(\n\u001b[1;32m 702\u001b[0m ParamInfo(init_params, pe, grad), potential_fn, postprocess_fn, model_trace\n\u001b[1;32m 703\u001b[0m )\n", - "\u001b[0;31mRuntimeError\u001b[0m: Cannot find valid initial parameters. Please check your model again." - ] + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "# change this to SVI and autoguides\n", - "from numpyro.infer import NUTS, MCMC\n", - "from numpyro.infer import init_to_feasible, init_to_sample\n", - "from jax import random\n", + "plt.figure(figsize=(16,5))\n", + "plt.plot(svi_res.losses)\n", + "plt.ylabel('ELBO');\n", + "plt.xlabel('iter step');" + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "metadata": {}, + "outputs": [], + "source": [ + "rng_key, _rng_key = random.split(rng_key)\n", + "pred = Predictive(\n", + " model, \n", + " guide=guide, \n", + " parallel=svi_res.params, \n", + " num_samples=1000, \n", + " return_sites=[\"z\", \"d\", \"a\", \"lambda\"]\n", + ")\n", + "post_sample = pred(_rng_key, measurments, T)\n", "\n", - "kernel = NUTS(model, init_strategy=init_to_feasible)\n", + "for key in post_sample:\n", + " post_sample[key] = np.expand_dims(post_sample[key], 0)\n", "\n", - "mcmc = MCMC(kernel, num_warmup=10, num_samples=10)\n", - "samples = mcmc.run(random.PRNGKey(0), measurments, T)" + "data_svi = az.convert_to_inference_data(post_sample, group=\"posterior\", **data_kwargs)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 125, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "axes = az.plot_forest([data_mcmc, data_svi],\n", + " model_names = [\"nuts\", \"svi\"],\n", + " kind='forestplot',\n", + " var_names=[\"~z\"],\n", + " combined=True,\n", + " figsize=(20, 6))" + ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3.9.12 ('pymdp')", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, From 27806a59ee57e7116392d76b6cdd12dd685af623 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Mon, 19 Sep 2022 13:44:01 +0200 Subject: [PATCH 016/232] corrected stable_log for better grad estimate --- pymdp/jax/agent.py | 5 +---- pymdp/jax/maths.py | 4 ++-- 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 6e1c3bed..7c2ea277 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -446,7 +446,4 @@ def _get_default_params(self): elif method == "CV": raise NotImplementedError("CV is not implemented") - return default_params - - - + return default_params \ No newline at end of file diff --git a/pymdp/jax/maths.py b/pymdp/jax/maths.py index 4f6134c3..13629cec 100644 --- a/pymdp/jax/maths.py +++ b/pymdp/jax/maths.py @@ -1,11 +1,11 @@ from jax import tree_util, nn, jit import jax.numpy as jnp -MIN_VAL = -64 +MIN_VAL = 1e-32 def log_stable(x): - return jnp.where(x > 0, jnp.log(x), MIN_VAL) + return jnp.log(jnp.where(x >= MIN_VAL, x, MIN_VAL)) def compute_log_likelihood_single_modality(o_m, A_m): """ Compute observation likelihood for a single modality (observation and likelihood)""" From a605525d0b95d6f1dd9ae70805d330aaf9b87d27 Mon Sep 17 00:00:00 2001 From: conorheins Date: Mon, 19 Sep 2022 15:41:45 +0200 Subject: [PATCH 017/232] added VFE computation and @dimarkov's change to log_stable function (to avoid merge conflict, i commit it myself) --- pymdp/jax/maths.py | 36 ++++++++++++++++++++++++++++++++++-- 1 file changed, 34 insertions(+), 2 deletions(-) diff --git a/pymdp/jax/maths.py b/pymdp/jax/maths.py index 4f6134c3..1d0c3ecb 100644 --- a/pymdp/jax/maths.py +++ b/pymdp/jax/maths.py @@ -1,11 +1,11 @@ from jax import tree_util, nn, jit import jax.numpy as jnp -MIN_VAL = -64 +MIN_VAL = 1e-32 def log_stable(x): - return jnp.where(x > 0, jnp.log(x), MIN_VAL) + return jnp.log(jnp.where(x >= MIN_VAL, x, MIN_VAL)) def compute_log_likelihood_single_modality(o_m, A_m): """ Compute observation likelihood for a single modality (observation and likelihood)""" @@ -22,6 +22,38 @@ def compute_log_likelihood(obs, A): return ll +def compute_accuracy(qs, obs, A): + """ Compute the accuracy portion of the variational free energy (expected log likelihood under the variational posterior) """ + + ll = compute_log_likelihood(obs, A) + + x = qs[0] + for q in qs[1:]: + x = jnp.expand_dims(x, -1) * q + + joint = log_likelihood * x + return joint.sum() + +def compute_free_energy(qs, prior, obs, A): + """ + Calculate variational free energy by breaking its computation down into three steps: + 1. computation of the negative entropy of the posterior -H[Q(s)] + 2. computation of the cross entropy of the posterior with the prior H_{Q(s)}[P(s)] + 3. computation of the accuracy E_{Q(s)}[lnP(o|s)] + + Then add them all together -- except subtract the accuracy + """ + + vfe = 0.0 # initialize variational free energy + for q, p in zip(qs, prior): + negH_qs = q.dot(log_stable(q)) + xH_qp = -q.dot(log_stable(p)) + vfe += (negH_qs + xH_qp) + + vfe -= compute_accuracy(qs, obs, A) + + return vfe + if __name__ == '__main__': obs = [0, 1, 2] obs_vec = [ nn.one_hot(o, 3) for o in obs] From f39fca2e6420b0b4525fc187bcd2556379ac5d8c Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Mon, 19 Sep 2022 18:12:18 +0200 Subject: [PATCH 018/232] sketch of the AgentDist --- examples/model_inversion.ipynb | 327 +++++++++++++++++++-------------- 1 file changed, 192 insertions(+), 135 deletions(-) diff --git a/examples/model_inversion.ipynb b/examples/model_inversion.ipynb index d6f63b58..f83ccd89 100644 --- a/examples/model_inversion.ipynb +++ b/examples/model_inversion.ipynb @@ -150,7 +150,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -172,7 +172,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAesAAAGiCAYAAADHpO4FAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAhyElEQVR4nO3de3QU9f3/8deGJBuuEYgkATEGvJAWFUkUwqUCQhCUgmCJpcql4CFHLIWISsQS4Gu71FoPFU2AwyXlnGgRqKJtSgkWFSW2AoFTSmy9UHOADTFpFRRYcpnfH/zYds1CdnEh8+k8H+fMH34yM5/PZGXfeb8/n5lxWZZlCQAA2FZUSw8AAABcGMEaAACbI1gDAGBzBGsAAGyOYA0AgM0RrAEAsDmCNQAANkewBgDA5gjWAADYHMEaLaqoqEgul8u/RUdHKzk5Wffdd58+/PDDlh5exFxzzTWaOnVqs/u5XC49/PDDEenzzJkzysnJUXJyslq1aqU+ffro6NGjWrRokfbt2xeRPgBcHtEtPQBAktatW6devXrp9OnTevfdd/XTn/5UO3bs0AcffKCOHTu29PCMVFhYqJUrV2r58uVKT09Xu3btdPToUS1evFjXXHON+vTp09JDBBAigjVsoXfv3srIyJAkDRkyRA0NDcrPz9err76qadOmtfDomnfy5Em1adOmpYcR4MCBA2rdunVApr579+4WHBGAi0UZHLZ0LnAfO3YsoH337t367ne/q06dOikuLk633HKLXn75Zf/Pjx8/rujoaP3iF7/wt9XU1CgqKkrx8fGqr6/3t8+ePVtXXnmlzr3LprS0VGPHjtVVV12luLg4XXvttZo5c6ZqamoCxrBo0SK5XC7t3btX9957rzp27KiePXtKkurq6vTYY48pKSlJbdq00aBBg/SXv/wlor+bM2fO6KmnnlKvXr3kdrt15ZVXatq0afrss8/8+7hcLq1evVqnTp3yTzEUFRXp1ltvlSRNmzbN375o0aKIjg9A5BGsYUuHDh2SJF1//fX+th07dmjgwIH6/PPPtWLFCm3ZskV9+vRRdna2ioqKJEkdOnTQrbfequ3bt/uPe+ONN+R2u3XixImAwLl9+3YNGzZMLpdLkvTxxx8rMzNThYWF2rZtmxYuXKg///nPGjRokOrq6pqMcfz48br22mu1ceNGrVixQpL04IMP6plnntHkyZO1ZcsWTZgwQePHj9e///3viPxeGhsbNXbsWC1dulSTJk3S73//ey1dulSlpaUaMmSITp06JUkqKyvT6NGj1bp1a5WVlamsrExDhw7VunXrJElPPvmkv33GjBkRGRuAS8gCWtC6dessSdZ7771n1dXVWSdOnLC2bt1qJSUlWd/5znesuro6/769evWybrnlloA2y7Ksu+++20pOTrYaGhosy7KsJ5980mrdurV1+vRpy7Isa8aMGdadd95p3XTTTdbixYsty7KsI0eOWJKsVatWBR1XY2OjVVdXZ3366aeWJGvLli3+n+Xn51uSrIULFwYcU1FRYUmy5s6dG9BeXFxsSbKmTJnS7O9DkjVr1qzz/vyll16yJFmbN28OaH///fctSVZBQYG/bcqUKVbbtm2D7rdu3bpmxwLAPsisYQv9+/dXTEyM2rdvrzvvvFMdO3bUli1bFB19dlnFRx99pA8++EA/+MEPJEn19fX+bfTo0fJ6vfr73/8uSbrjjjt06tQp7dq1S9LZDHrEiBEaPny4SktL/W2SNHz4cP8YqqurlZOTo+7duys6OloxMTFKSUmRJFVUVDQZ84QJEwL+e8eOHZLkH+M5EydO9F/HN/W73/1OV1xxhcaMGRPwO+jTp4+SkpL05ptvRqQfAPbCAjPYwvr165WWlqYTJ05ow4YNWrlypb7//e/rD3/4g6T/zF3PmzdP8+bNC3qOc3PLAwYMUJs2bbR9+3Z1795d//znPzVixAgdPnxYy5cv15dffqnt27erR48eSk1NlXS2vJyVlaWjR4/qJz/5iW688Ua1bdtWjY2N6t+/v7+8/N+Sk5MD/ru2tlaSlJSUFNAeHR2tzp07f4Pfzn8cO3ZMn3/+uWJjY4P+/Ovz6wD+NxCsYQtpaWn+RWVDhw5VQ0ODVq9erU2bNunee+9VQkKCJCkvL0/jx48Peo4bbrhBkhQbG6tBgwZp+/btuuqqq5SUlKQbb7xRPXr0kCS9+eabeuONN3T33Xf7jz1w4ID279+voqIiTZkyxd/+0UcfnXfM5+a6zzkXkKuqqtStWzd/e319vT+Qf1MJCQnq3Lmztm7dGvTn7du3j0g/AOyFYA1bevrpp7V582YtXLhQ48eP1w033KDrrrtO+/fv189+9rNmjx8+fLjy8vLUvn17f6m7bdu26t+/v5YvX66jR48GlMDPBV632x1wnpUrV4Y85iFDhkiSiouLlZ6e7m9/+eWXA1ahfxN33323fvOb36ihoUH9+vUL+/hz1xesUgDAvgjWsKWOHTsqLy9Pjz32mF588UXdf//9WrlypUaNGqWRI0dq6tSp6tatm/71r3+poqJCe/fu1caNG/3H33HHHWpoaNAbb7yhX//61/724cOHKz8/Xy6XS8OGDfO39+rVSz179tT8+fNlWZY6deqk119/3T/HHYq0tDTdf//9WrZsmWJiYjR8+HAdOHBAzzzzjDp06BDyeT7++GNt2rSpSfu3vvUt3XfffSouLtbo0aP14x//WLfddptiYmJ0+PBh7dixQ2PHjtU999xz3nP37NlTrVu3VnFxsdLS0tSuXTt17dpVXbt2DXl8AFpAS69wg7OdWw3+/vvvN/nZqVOnrKuvvtq67rrrrPr6esuyLGv//v3WxIkTrS5dulgxMTFWUlKSNWzYMGvFihUBxzY2NloJCQmWJOvIkSP+9nfffdeSZPXt27dJfwcPHrRGjBhhtW/f3urYsaP1ve99z6qsrLQkWfn5+f79zq0G/+yzz5qcw+fzWY888ojVpUsXKy4uzurfv79VVlZmpaSkhLwa/HzbuTHU1dVZzzzzjHXzzTdbcXFxVrt27axevXpZM2fOtD788EP/uYKtBressyvKe/XqZcXExDS5NgD25LKs//9ECAAAYEvcugUAgM0RrAEAsDmCNQAANkewBgAgRG+//bbGjBmjrl27yuVy6dVXX232mLfeekvp6emKi4tTjx49/O8SCAfBGgCAEH311Ve6+eab9fzzz4e0/6FDhzR69GgNHjxY5eXleuKJJzR79mxt3rw5rH5ZDQ4AwEVwuVx65ZVXNG7cuPPu8/jjj+u1114LeL9ATk6O9u/fr7KyspD7CvpQFJ/PJ5/PF9DmdrubPN0JAADTXcqYV1ZWpqysrIC2kSNHas2aNaqrq1NMTExI5wkarD0ejxYvXhzQlp+fz0vqAQC2sehrz+e/aPn5lyzmVVVVKTExMaAtMTFR9fX1qqmpafJCoPMJGqzz8vKUm5sb0EZWDQCwk0gtunr8Ese8r7/059zs89fbLyRosKbkDQBwiksZ85KSklRVVRXQVl1dHfarcy/qRR4RKz0gLIuCrQU8HZlXLyJMcUH+kfFZtJwgnwffUy0j6PfUJWLCJ5yZmanXX389oG3btm3KyMgIeb5a4tYtAIChoiK0hePLL7/Uvn37tG/fPklnb83at2+fKisrJZ2dRp48ebJ//5ycHH366afKzc1VRUWF1q5dqzVr1mjevHlh9csrMgEACNHu3bs1dOhQ/3+fm+ueMmWKioqK5PV6/YFbklJTU1VSUqK5c+fqhRdeUNeuXfXcc89pwoQJYfVLsAYAGKklSsNDhgzRhR5PUlRU1KTt9ttv1969e79RvwRrAICRTJizjhTmrAEAsDkyawCAkZyUbRKsAQBGclIZnGANADCSkzJrJ10rAABGIrMGABjJSdkmwRoAYCQnzVk76Q8TAACMRGYNADCSk7JNgjUAwEhOCtZOulYAAIxEZg0AMJKTFpgRrAEARnJSadhJ1woAgJHIrAEARqIMDgCAzTmpNEywBgAYyUnB2knXCgCAkcisAQBGYs4aAACbc1Jp2EnXCgCAkcisAQBGclK2SbAGABjJSXPWTvrDBAAAI5FZAwCM5KRsk2ANADCSk4K1k64VAAAjkVkDAIzkpAVmBGsAgJGcVBomWAMAjOSkzNpJf5gAAGAkMmsAgJGclG0SrAEARnJSsHbStQIAYCQyawCAkZy0wIxgDQAwkpNKw066VgAAjERmDQAwkpOyTYI1AMBITpqzdtIfJgAAGInMGgBgJFeUc3JrgjUAwEguF8EaAABbi3JQZs2cNQAANkdmDQAwEmVwAABszkkLzCiDAwBgc2TWAAAjUQYHAMDmKIMDAADbILMGABiJMjgAADZHGRwAANgGmTUAwEiUwQEAsDknPRucYA0AMJKTMmvmrAEAsDkyawCAkZy0GpxgDQAwEmVwAABgG2TWAAAjUQYHAMDmKIMDAIDzKigoUGpqquLi4pSenq6dO3decP/i4mLdfPPNatOmjZKTkzVt2jTV1taG3B/BGgBgJFeUKyJbuDZs2KA5c+ZowYIFKi8v1+DBgzVq1ChVVlYG3f+dd97R5MmTNX36dP3tb3/Txo0b9f7772vGjBkh90mwBgAYyeVyRWQL17PPPqvp06drxowZSktL07Jly9S9e3cVFhYG3f+9997TNddco9mzZys1NVWDBg3SzJkztXv37pD7JFgDABzN5/Pp+PHjAZvP5wu675kzZ7Rnzx5lZWUFtGdlZWnXrl1BjxkwYIAOHz6skpISWZalY8eOadOmTbrrrrtCHiPBGgBgpKgoV0Q2j8ej+Pj4gM3j8QTts6amRg0NDUpMTAxoT0xMVFVVVdBjBgwYoOLiYmVnZys2NlZJSUm64oortHz58tCvNfRfCwAA9hGpMnheXp6++OKLgC0vL6/Zvv+bZVnnLakfPHhQs2fP1sKFC7Vnzx5t3bpVhw4dUk5OTsjXyq1bAAAjReo+a7fbLbfbHdK+CQkJatWqVZMsurq6ukm2fY7H49HAgQP16KOPSpJuuukmtW3bVoMHD9ZTTz2l5OTkZvslswYAIESxsbFKT09XaWlpQHtpaakGDBgQ9JiTJ08qKiow3LZq1UrS2Yw8FGTWAAAjtdRDUXJzc/XAAw8oIyNDmZmZWrVqlSorK/1l7by8PB05ckTr16+XJI0ZM0YPPvigCgsLNXLkSHm9Xs2ZM0e33XabunbtGlKfBGsAgJFcLVQbzs7OVm1trZYsWSKv16vevXurpKREKSkpkiSv1xtwz/XUqVN14sQJPf/883rkkUd0xRVXaNiwYfr5z38ecp8uK9Qc/L8sctAj3uxkUbCP6nToT8BBBMV1btrGZ9FygnwefE+1jKDfU5fI3muDzxGHq+9HxyJynkuJzBoAYCQnPRucYA0AMJKT3rrFanAAAGyOzBoAYKQoyuAAANgbZXAAAGAbZNYAACOxGhwAAJtzUhmcYA0AMJKTMmvmrAEAsDkyawCAkSiDAwBgc5TBAQCAbZBZAwCM5IpyTr5JsAYAGMlJc9bO+bMEAABDkVkDAMzkoAVmBGsAgJEogwMAANsgswYAGInV4AAA2JyTHopCsAYAmIk5awAAYBdk1gAAIzFnDQCAzTlpzto5f5YAAGAoMmsAgJGc9FAUgjUAwEwOCtaUwQEAsDkyawCAkVwu5+SbBGsAgJGcNGftnD9LAAAwFJk1AMBITsqsCdYAADMxZw0AgL05KbN2zp8lAAAYiswaAGAkJ2XWBGsAgJF4kQcAALANMmsAgJl4n/WFLbKsSI8DFyuuc0uPAOfwWdgK31P/+xw/Z+3z+eTz+QLa3G633G73ZRkUAAD4j6A1BI/Ho/j4+IDN4/Fc7rEBAHBeLpcrIpsJXJbVtFZEZg0AsLtjEwdH5DyJL++MyHkupaBlcAIzAAD2cXGrwU/XRngYCEmwBUwnvZd/HJDaJDdpWmpIOe1/0fxgi8n4nmoZl3GhpeMXmAEAYHsO+gOZYA0AMJKTMmvn3FEOAIChyKwBAEZy8QQzAADszZR7pCPBOX+WAABgKDJrAICZHLTAjGANADCSk+asnXOlAAAYiswaAGAkJy0wI1gDAIzEQ1EAAIBtkFkDAMxEGRwAAHtzUhmcYA0AMJNzYjVz1gAA2B2ZNQDATA6asyazBgAYyeWKzHYxCgoKlJqaqri4OKWnp2vnzp0X3N/n82nBggVKSUmR2+1Wz549tXbt2pD7I7MGACAMGzZs0Jw5c1RQUKCBAwdq5cqVGjVqlA4ePKirr7466DETJ07UsWPHtGbNGl177bWqrq5WfX19yH26LMuywh7p6dqwD0EExHVu2nbSe/nHAalNcpOmpQ4qydnN/GBfY3xPtYxg31OXyPEf3R2R83RY/ruw9u/Xr5/69u2rwsJCf1taWprGjRsnj8fTZP+tW7fqvvvu0yeffKJOnTpd1BgpgwMAjBSpMrjP59Px48cDNp/PF7TPM2fOaM+ePcrKygpoz8rK0q5du4Ie89prrykjI0NPP/20unXrpuuvv17z5s3TqVOnQr5WgjUAwNE8Ho/i4+MDtmAZsiTV1NSooaFBiYmJAe2JiYmqqqoKeswnn3yid955RwcOHNArr7yiZcuWadOmTZo1a1bIY2TOGgBgpghNPeXl5Sk3Nzegze12N9N1YN+WZZ33xSKNjY1yuVwqLi5WfHy8JOnZZ5/VvffeqxdeeEGtW7dudowEawCAmSJUG3a73c0G53MSEhLUqlWrJll0dXV1k2z7nOTkZHXr1s0fqKWzc9yWZenw4cO67rrrmu2XMjgAwEgulysiWzhiY2OVnp6u0tLSgPbS0lINGDAg6DEDBw7U0aNH9eWXX/rb/vGPfygqKkpXXXVVSP0SrAEACENubq5Wr16ttWvXqqKiQnPnzlVlZaVycnIknS2rT5482b//pEmT1LlzZ02bNk0HDx7U22+/rUcffVQ//OEPQyqBS5TBAQCmaqHbJbOzs1VbW6slS5bI6/Wqd+/eKikpUUpKiiTJ6/WqsrLSv3+7du1UWlqqH/3oR8rIyFDnzp01ceJEPfXUUyH3yX3WJuE+a/vgPmtb4T5rG7mM91l/NW9sRM7T9pktETnPpUQZHAAAm6MMDgAwE++zBgDA5pwTqymDAwBgd2TWAAAjhXuPtMkI1gAAMzknVlMGBwDA7sisAQBGcrEaHAAAm3NOrCZYAwAM5aAFZsxZAwBgc2TWAAAjOSixJlgDAAzloAVmlMEBALA5MmsAgJEogwMAYHcOitaUwQEAsDkyawCAkRyUWBOsAQCGYjU4AACwCzJrAICZHFQHJ1gDAIzkoFhNsAYAGMpB0Zo5awAAbI7MGgBgJJeD0k2CNQDATJTBAQCAXZBZAwDM5JzEmmANADCTizI4AACwCzJrAICZHPRscII1AMBMlMEBAIBdkFkDAMxEGRwAAJtz0CPMCNYAADMxZw0AAOyCzBoAYCbmrAEAsDkHzVk750oBADAUmTUAwEyUwQEAsDlWgwMAALsgswYAmCnKOfkmwRoAYCbK4AAAwC7IrAEAZqIMDgCAzTmoDE6wBgCYyUHB2jk1BAAADEVmDQAwE3PWAADYHGVwAABgF2TWAAAjuXiRBwAANsf7rAEAgF2QWQMAzEQZHAAAm2M1OAAAsAsyawCAmXgoCgAANuegMjjBGgBgJgcFa+fUEAAAMBTBGgBgpqioyGwXoaCgQKmpqYqLi1N6erp27twZ0nHvvvuuoqOj1adPn7D6I1gDAMzkckVmC9OGDRs0Z84cLViwQOXl5Ro8eLBGjRqlysrKCx73xRdfaPLkybrjjjvC7pNgDQBAGJ599llNnz5dM2bMUFpampYtW6bu3bursLDwgsfNnDlTkyZNUmZmZth9EqwBAGaKckVk8/l8On78eMDm8/mCdnnmzBnt2bNHWVlZAe1ZWVnatWvXeYe6bt06ffzxx8rPz7+4S72oowAAaGmuqIhsHo9H8fHxAZvH4wnaZU1NjRoaGpSYmBjQnpiYqKqqqqDHfPjhh5o/f76Ki4sVHX1xN2Fx6xYAwNHy8vKUm5sb0OZ2uy94jOtrc92WZTVpk6SGhgZNmjRJixcv1vXXX3/RYyRYAwDMFKEXebjd7maD8zkJCQlq1apVkyy6urq6SbYtSSdOnNDu3btVXl6uhx9+WJLU2Ngoy7IUHR2tbdu2adiwYc32S7AGAJipBR6KEhsbq/T0dJWWluqee+7xt5eWlmrs2LFN9u/QoYP++te/BrQVFBToT3/6kzZt2qTU1NSQ+iVYAwAQhtzcXD3wwAPKyMhQZmamVq1apcrKSuXk5Eg6W1Y/cuSI1q9fr6ioKPXu3Tvg+C5duiguLq5J+4UQrAEAZmqhF3lkZ2ertrZWS5YskdfrVe/evVVSUqKUlBRJktfrbfae63C5LMuywj7qdG1EB4EQxXVu2nbSe/nHAalNcpOmpQ56TrHdzA/2Ncb3VMsI9j11iTRu+7+InCcq6ycROc+lRGYNADCTg/5A5j5rAABsjswaAGAml3PyTYI1AMBMzqmCUwYHAMDuyKwBAGZy0AIzgjUAwEwOCtaUwQEAsDkyawCAmRyUWROsAQCGck6wpgwOAIDNkVkDAMzknMSaYA0AMBRz1gAA2JyDgjVz1gAA2NzFZdaX8X2laEaQ9yqjZQR9pzJaDt9T//sclFkHDdY+n08+ny+gze12y+12X5ZBAQDQPOcE66BlcI/Ho/j4+IDN4/Fc7rEBAABJLstqWrsjswYA2F3ju89G5DxRA3Mjcp5LKWgZnMAMALA9p89ZN+t0bYSHgZAEWTCz1EH/s9pJ0MVkJ72XfyA4K9hCS76nWgYL+y4J7rMGAJjJQckKwRoAYCjnBGseigIAgM2RWQMAzEQZHAAAmyNYAwBgc86J1cxZAwBgd2TWAAAzUQYHAMDunBOsKYMDAGBzZNYAADNRBgcAwOYcFKwpgwMAYHNk1gAAMzknsSZYAwAMRRkcAADYBZk1AMBQzsmsCdYAADM5qAxOsAYAmMlBwZo5awAAbI7MGgBgJjJrAABgFwRrAABsjjI4AMBMDiqDE6wBAGZyULCmDA4AgM2RWQMAzOSgzJpgDQAwlHOCNWVwAABsjswaAGAmyuAAANicyznFYYI1AMBQzsmsnfNnCQAAhiKzBgCYiTlrAABszkFz1s65UgAADEVmDQAwFGVwAADszUFz1pTBAQCwOTJrAIChnJNvEqwBAGaiDA4AAOyCYA0AMJPLFZntIhQUFCg1NVVxcXFKT0/Xzp07z7vvb3/7W40YMUJXXnmlOnTooMzMTP3xj38Mqz+CNQDAUK4IbeHZsGGD5syZowULFqi8vFyDBw/WqFGjVFlZGXT/t99+WyNGjFBJSYn27NmjoUOHasyYMSovLw/9Si3LssIe6enasA9BBMR1btK01EFzNnYyP9g/m5Peyz8QnNUmuWkb31MtI8j31KXS+PGrETlPVM9xYe3fr18/9e3bV4WFhf62tLQ0jRs3Th6PJ6RzfPvb31Z2drYWLlwY2hjDGiEAAP9jfD6fjh8/HrD5fL6g+545c0Z79uxRVlZWQHtWVpZ27doVUn+NjY06ceKEOnXqFPIYCdYAADNFaM7a4/EoPj4+YDtfhlxTU6OGhgYlJiYGtCcmJqqqqiqkYf/yl7/UV199pYkTJ4Z8qdy6BQAwVGSmAfPy8pSbmxvQ5na7L9zz16YgLctq0hbMSy+9pEWLFmnLli3q0qVLyGMkWAMAHM3tdjcbnM9JSEhQq1atmmTR1dXVTbLtr9uwYYOmT5+ujRs3avjw4WGNkTI4AMBMrqjIbGGIjY1Venq6SktLA9pLS0s1YMCA8x730ksvaerUqXrxxRd11113hX2pZNYAACOFUna+FHJzc/XAAw8oIyNDmZmZWrVqlSorK5WTkyPpbFn9yJEjWr9+vaSzgXry5Mn61a9+pf79+/uz8tatWys+Pj6kPgnWAACEITs7W7W1tVqyZIm8Xq969+6tkpISpaSkSJK8Xm/APdcrV65UfX29Zs2apVmzZvnbp0yZoqKiopD65D5rk3CftW1wn7XNcJ+1fVzG+6ytf5ZE5Dyua0ZH5DyXEpk1AMBMYc43m8w5VwoAgKHIrAEAhnLONCDBGgBgJget2SFYAwDMxJw1AACwCzJrAIChKIMDAGBvDpqzpgwOAIDNkVkDAMzkoAVmBGsAgKEogwMAAJsgswYAmMlBC8wI1gAAQzmnOOycKwUAwFBk1gAAM1EGBwDA5gjWAADYnXNmcp1zpQAAGIrMGgBgJsrgAADYnXOCNWVwAABsjswaAGAmyuAAANidc4I1ZXAAAGyOzBoAYCbK4AAA2J1zisPOuVIAAAxFZg0AMBNlcAAA7I5gDQCAvTkos2bOGgAAmyOzBgAYyjmZNcEaAGAmyuAAAMAuyKwBAIZyTmZNsAYAmIkyOAAAsAsyawCAoZyTbxKsAQBmogwOAADsgswaAGAo52TWBGsAgKEI1gAA2JqLOWsAAGAXZNYAAEM5J7MmWAMAzEQZHAAA2AWZNQDAUM7JrAnWAAAzuZxTHHbOlQIAYCgyawCAoSiDAwBgb6wGBwAAdkFmDQAwlHMya4I1AMBMDiqDE6wBAIZyTrBmzhoAAJsjswYAmIkyOAAAduecYE0ZHAAAmyOzBgCYiWeDAwBgd64IbeErKChQamqq4uLilJ6erp07d15w/7feekvp6emKi4tTjx49tGLFirD6I1gDABCGDRs2aM6cOVqwYIHKy8s1ePBgjRo1SpWVlUH3P3TokEaPHq3BgwervLxcTzzxhGbPnq3NmzeH3KfLsiwr7JGerg37EERAXOcmTUsdtBrSTuYH+2dz0nv5B4Kz2iQ3beN7qmUE+Z66ZE7XROY8cQlh7d6vXz/17dtXhYWF/ra0tDSNGzdOHo+nyf6PP/64XnvtNVVUVPjbcnJytH//fpWVlYXU58XNWV/ODwMXFDRooGUECxhoOXxPOcDlT1bOnDmjPXv2aP78+QHtWVlZ2rVrV9BjysrKlJWVFdA2cuRIrVmzRnV1dYqJiWm2XxaYAQAczefzyefzBbS53W653e4m+9bU1KihoUGJiYkB7YmJiaqqqgp6/qqqqqD719fXq6amRsnJzf+hH9Kctc/n06JFi5pcDC4/Pgv74LOwFz4PB4rrHJHN4/EoPj4+YAtWzv5vrq9NQVqW1aStuf2DtZ9PyMF68eLF/COwAT4L++CzsBc+D1ysvLw8ffHFFwFbXl5e0H0TEhLUqlWrJll0dXV1k+z5nKSkpKD7R0dHq3Pn0KZrWA0OAHA0t9utDh06BGzBSuCSFBsbq/T0dJWWlga0l5aWasCAAUGPyczMbLL/tm3blJGREdJ8tUSwBgAgLLm5uVq9erXWrl2riooKzZ07V5WVlcrJyZF0NlOfPHmyf/+cnBx9+umnys3NVUVFhdauXas1a9Zo3rx5IffJAjMAAMKQnZ2t2tpaLVmyRF6vV71791ZJSYlSUlIkSV6vN+Ce69TUVJWUlGju3Ll64YUX1LVrVz333HOaMGFCyH2GFKzdbrfy8/PPWxbA5cNnYR98FvbC54HL6aGHHtJDDz0U9GdFRUVN2m6//Xbt3bv3ovu7uIeiAACAy4Y5awAAbI5gDQCAzRGsAQCwOYI1AAA2R7AGAMDmCNYAANgcwRoAAJsjWAMAYHMEawAAbI5gDQCAzRGsAQCwuf8HYmMTHK6Bj88AAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -194,7 +194,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -241,7 +241,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAesAAAGiCAYAAADHpO4FAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAoGUlEQVR4nO3de3hV1Z3/8c/J7YRr5CLhJiFYBToBR5IKiVLKLQhU8cIQy3BT6BDF8kCKlpQpBNQ5j2h5sJaAPIAMU2RAVLxlKOGiooAiII8U6lQLZMTEmFguohxIsn5/8Muph5zASTiEvbrfr+fZf2Rl7bPX3rl8z/e71t7HY4wxAgAAjhV1tQcAAAAujmANAIDDEawBAHA4gjUAAA5HsAYAwOEI1gAAOBzBGgAAhyNYAwDgcARrAAAcjmDdAFauXCmPxxPYYmJi1K5dO9133336y1/+crWHFzGdO3fWhAkTwup78uRJPfHEE0pLS1Pz5s3l9XrVuXNnPfDAA9q7d++VHWgtLhz/W2+9JY/Ho7feeivQVlBQoLy8vLD2bwidO3cO+t2qbVu5cmWDjutijhw5UmNMO3bsUF5eno4fP16j/09+8hP95Cc/abDxAU4Uc7UH4CbPP/+8unXrpjNnzui9997TE088oW3btunPf/6zWrRocbWH12A+++wzZWZmqrS0VNnZ2Zo7d66aNm2qI0eOaN26dUpNTdXx48eVkJBwVcfZq1cv7dy5Uz/84Q8DbQUFBVq0aFHIgP3KK6+oefPmDTjC88f0+/2Br5ctW6bly5dr48aNQdfv+uuvb9BxXUy7du20c+fOoDHt2LFDc+fO1YQJE3TNNdcE9c/Pz2/gEQLOQ7BuQCkpKUpLS5N0PluorKzUnDlztGHDBt1///1XeXSX9u2336px48aX9RqVlZW6++67VVZWpp07dyolJSXwvX79+mn8+PH6n//5H8XGxl7ucC9b8+bN1adPn7D733zzzVdwNOEdc+PGjZKk1NRUtW7dutb9IvGzrC+v11un6/r9N0uAW1EGv4qqA/eXX34Z1P7hhx/qzjvvVMuWLRUfH6+bb75Z69atC3z/5MmTiomJ0VNPPRVoKysrU1RUlBISElRRURFonzp1qq699lpVf15LYWGhRowYoY4dOyo+Pl4/+MEPNHnyZJWVlQWNIS8vTx6PR3v37tXIkSPVokWLQCZ07tw5Pfroo2rbtq0aN26s2267TR988EFY57xhwwZ9/PHHys3NDQrU3zd06NCgQPLuu+9q4MCBatasmRo3bqyMjAy9+eabQftUTzVs27ZNDz74oFq3bq1WrVrpnnvu0RdffBHUN9zxX1gGnzBhghYtWiRJQSXmI0eOSApdBi8qKtKYMWPUpk0beb1ede/eXb/97W9VVVUV6FNdFn766ae1YMECJScnq2nTpkpPT9euXbvCuq4XM2HCBDVt2lQff/yxMjMz1axZMw0cOFBS3X8f/vSnP+lnP/uZEhISlJiYqAceeEAnTpwI6vviiy+qd+/eSkhIUOPGjdWlSxc98MADNc63ugyel5enRx55RJKUnJwcuK7V1z1UGfzrr7/WQw89pA4dOiguLk5dunTRrFmzgqoM0vmf08MPP6z/+q//Uvfu3dW4cWPddNNNeuONN4L6ffXVV/q3f/s3XXfddfJ6vbr22mt16623avPmzfW65kCkkVlfRYcPH5Yk3XjjjYG2bdu26fbbb1fv3r21ZMkSJSQk6L//+7+VlZWlb7/9VhMmTFDz5s31ox/9SJs3bw78k9uyZYu8Xq9OnTqlDz74QBkZGZKkzZs3a8CAAfJ4PJLOl6DT09M1adIkJSQk6MiRI1qwYIFuu+02ffzxxzUy2nvuuUf33XefsrOzdfr0aUnSz3/+c61atUozZszQ4MGDdeDAAd1zzz06derUJc9506ZNkqS77rorrGv09ttva/DgwerZs6eWL18ur9er/Px83XHHHVqzZo2ysrKC+k+aNEnDhw/XCy+8oP/7v//TI488ojFjxmjr1q2BPvUd/29+8xudPn1a69ev186dOwPt7dq1C9n/q6++UkZGhs6ePavHHntMnTt31htvvKEZM2bos88+q1HeXbRokbp166aFCxcGjjds2DAdPnz4sqcEzp49qzvvvFOTJ0/WzJkzA2/o6vr7cO+99yorK0sTJ04MvOmSpBUrVkiSdu7cqaysLGVlZSkvL0/x8fE6evRo0PW/0KRJk/T111/r2Wef1csvvxy4nrVl1GfOnFH//v312Wefae7cuerZs6e2b98un8+njz76qMYbuTfffFO7d+/WvHnz1LRpU82fP1933323PvnkE3Xp0kWSNHbsWO3du1dPPPGEbrzxRh0/flx79+5VeXl5Pa42cAUYXHHPP/+8kWR27dplzp07Z06dOmU2btxo2rZta3784x+bc+fOBfp269bN3HzzzUFtxhjz05/+1LRr185UVlYaY4z593//d9OoUSNz5swZY4wxkyZNMrfffrvp2bOnmTt3rjHGmGPHjhlJZunSpSHHVVVVZc6dO2eOHj1qJJlXX3018L05c+YYSWb27NlB+xw6dMhIMtOnTw9qX716tZFkxo8ff9FrcfvttxtJgXFfSp8+fUybNm3MqVOnAm0VFRUmJSXFdOzY0VRVVRlj/n6NH3rooaD958+fbySZ4uLiOo9/27ZtRpLZtm1boG3KlCmmtj+bpKSkoP1nzpxpJJn3338/qN+DDz5oPB6P+eSTT4wxxhw+fNhIMj169DAVFRWBfh988IGRZNasWXOJq/R31T+3r776KtA2fvx4I8msWLHiovuG8/swf/78oH0eeughEx8fH/g5PP3000aSOX78eK3HqT7f559/PtD21FNPGUnm8OHDNfr369fP9OvXL/D1kiVLjCSzbt26oH5PPvmkkWQ2bdoUaJNkEhMTzcmTJwNtJSUlJioqyvh8vkBb06ZNzbRp02odM3C1UQZvQH369FFsbKyaNWum22+/XS1atNCrr76qmJjzBY5PP/1Uf/7zn/Wv//qvkqSKiorANmzYMBUXF+uTTz6RJA0cOFDfffedduzYIel8Bj148GANGjRIhYWFgTZJGjRoUGAM1Yu6rrvuOsXExCg2NlZJSUmSpEOHDtUY87333hv09bZt2yQpMMZqo0aNCpxHpJw+fVrvv/++Ro4cqaZNmwbao6OjNXbsWH3++eeB61HtzjvvDPq6Z8+ekqSjR482+Pi3bt2qH/7wh7rllluC2idMmCBjTI1sc/jw4YqOjq517Jfrwp+lVPffh1DX98yZMyotLZUk/ehHP5J0/nquW7dOx44di8jYv2/r1q1q0qSJRo4cGdRePQWxZcuWoPb+/furWbNmga8TExPVpk2boOt6yy23aOXKlXr88ce1a9cunTt3LuLjBi4HwboBrVq1Srt379bWrVs1efJkHTp0SD/72c8C36+eu54xY4ZiY2ODtoceekiSAnOJGRkZaty4sTZv3qxPP/1UR44cCQTr999/X9988402b96sLl26KDk5WZJUVVWlzMxMvfzyy3r00Ue1ZcsWffDBB4F50e+++67GmC8s8VaXBdu2bRvUHhMTo1atWl3yGnTq1EnS36cALuZvf/ubjDEhy8zt27cPGk+1C8fg9Xol/f3cLnf8dVFeXh7RsV+Oxo0b11ipXp/fh0uN8cc//rE2bNigiooKjRs3Th07dlRKSorWrFlz2edQrby8XG3btg1M7VRr06aNYmJiLnldq8f9/fNbu3atxo8fr2XLlik9PV0tW7bUuHHjVFJSErFxA5eDOesG1L1798Cisv79+6uyslLLli3T+vXrNXLkyMDq3dzcXN1zzz0hX6Nr166SpLi4ON12223avHmzOnbsqLZt26pHjx6BObi33npLW7Zs0U9/+tPAvgcOHND+/fu1cuVKjR8/PtD+6aef1jrmC/8hVv/jKykpUYcOHQLtFRUVYc3vDRkyREuXLtWGDRs0c+bMi/Zt0aKFoqKiVFxcXON71YvGLrbiOZTLHX9djxXJsV+OC3+OUv1+H8IxYsQIjRgxQn6/X7t27ZLP59Po0aPVuXNnpaenX9ZrS+ev6/vvvy9jTNB5lZaWqqKiol7XtXXr1lq4cKEWLlyooqIivfbaa5o5c6ZKS0sDK+yBq4nM+iqaP3++WrRoodmzZ6uqqkpdu3bVDTfcoP379ystLS3k9v1y3qBBg7Rnzx699NJLgVJ3kyZN1KdPHz377LP64osvgkrg1f/YqrOhas8991zYY65elbt69eqg9nXr1gWtQq/NiBEj1KNHD/l8Ph04cCBknz/+8Y/69ttv1aRJE/Xu3Vsvv/xyUBZUVVWlP/zhD+rYsWPQ4ryGGH9dst2BAwfq4MGDNR7ysmrVKnk8HvXv3z/MUV8Zkfh9uBiv16t+/frpySeflCTt27fvon2l8K/rN998ow0bNgS1r1q1KvD9y9GpUyc9/PDDGjx48FV7QA9wITLrq6hFixbKzc3Vo48+qhdeeEFjxozRc889p6FDh2rIkCGaMGGCOnTooK+//lqHDh3S3r179eKLLwb2HzhwoCorK7Vlyxb953/+Z6B90KBBmjNnjjwejwYMGBBo79atm66//nrNnDlTxhi1bNlSr7/+emCOOxzdu3fXmDFjtHDhQsXGxmrQoEE6cOCAnn766bAeCBIdHa1XXnlFmZmZSk9P14MPPqj+/furSZMmOnr0qNavX6/XX39df/vb3yRJPp9PgwcPVv/+/TVjxgzFxcUpPz9fBw4c0Jo1a0JmjFdy/D169JAkPfnkkxo6dKiio6PVs2dPxcXF1eg7ffp0rVq1SsOHD9e8efOUlJSkN998U/n5+XrwwQfr/EYj0iLx+3Ch2bNn6/PPP9fAgQPVsWNHHT9+XM8884xiY2PVr1+/Wvervq7PPPOMxo8fr9jYWHXt2jXozWm1cePGadGiRRo/fryOHDmiHj166N1339V//Md/aNiwYUFvUMNx4sQJ9e/fX6NHj1a3bt3UrFkz7d69Wxs3bqy1wgU0uKu6vM0lqlcq7969u8b3vvvuO9OpUydzww03BFYC79+/34waNcq0adPGxMbGmrZt25oBAwaYJUuWBO1bVVVlWrdubSSZY8eOBdrfe+89I8n06tWrxvEOHjxoBg8ebJo1a2ZatGhh/uVf/sUUFRUZSWbOnDmBfqFWFVfz+/3ml7/8pWnTpo2Jj483ffr0MTt37qyxGvpijh8/bh577DHTq1cv07RpUxMbG2s6depkxowZY957772gvtu3bzcDBgwwTZo0MY0aNTJ9+vQxr7/+elCf2q5xqBXd4Y6/tn0nTZpkrr32WuPxeIJWMIc6/6NHj5rRo0ebVq1amdjYWNO1a1fz1FNPBVb1G/P31dFPPfVUjet04c/lUmpbDd6kSZOQ/S/396H6uldfgzfeeMMMHTrUdOjQwcTFxZk2bdqYYcOGme3bt9c43++vBjfGmNzcXNO+fXsTFRUVdN0vXA1ujDHl5eUmOzvbtGvXzsTExJikpCSTm5tb4y4DSWbKlCk1zvv7P6szZ86Y7Oxs07NnT9O8eXPTqFEj07VrVzNnzhxz+vTpkNcNaGgeY/7/0zIAAIAjMWcNAIDDEawBAHA4gjUAAA5HsAYAIEzvvPOO7rjjDrVv314ej6fGLYShvP3220pNTVV8fLy6dOmiJUuW1Pm4BGsAAMJ0+vRp3XTTTfr9738fVv/Dhw9r2LBh6tu3r/bt26df//rXmjp1ql566aU6HZfV4AAA1IPH49Err7xy0U8R/NWvfqXXXnst6Fn72dnZ2r9/f9Cn911KyIei+P3+Gp8L6/V6azzpCAAA213JmLdz505lZmYGtQ0ZMkTLly/XuXPnanwMbW1CBmufz6e5c+cGtc2ZM0d5eXn1Gy0AABGWV8cnGNZqzpwrFvNKSkqUmJgY1JaYmKiKigqVlZWF/LCfUEIG69zcXOXk5AS1kVUDAJwkUouufnWFY96Fj0Wunn2uy+OSQwZrSt4AALe4kjGvbdu2NT5qtbS0tM4fy1uvD/KIWOkBsFReqHWZZyL7EZuAleIj+7nwF2NDJEpPT9frr78e1LZp0yalpaWFPV8tcesWAMBSURHa6uKbb77RRx99pI8++kjS+VuzPvroIxUVFUk6P408bty4QP/s7GwdPXpUOTk5OnTokFasWKHly5drxowZdTouH5EJAECYPvzww6DPoq+e6x4/frxWrlyp4uLiQOCWpOTkZBUUFGj69OlatGiR2rdvr9/97ne6995763Tcet1nTRkcbkcZHKhFA5bBfRGKRbkWPG6EzBoAYCU3pY3MWQMA4HBk1gAAK7kp2yRYAwCs5KYyOMEaAGAlN2XWbjpXAACsRGYNALCSm7JNgjUAwEpumrN20xsTAACsRGYNALCSm7JNgjUAwEpuCtZuOlcAAKxEZg0AsJKbFpgRrAEAVnJTadhN5woAgJXIrAEAVqIMDgCAw7mpNEywBgBYyU3B2k3nCgCAlcisAQBWYs4aAACHc1Np2E3nCgCAlcisAQBWclO2SbAGAFjJTXPWbnpjAgCAlcisAQBWclO2SbAGAFjJTcHaTecKAICVyKwBAFZy0wIzgjUAwEpuKg0TrAEAVnJTZu2mNyYAAFiJzBoAYCU3ZZsEawCAldwUrN10rgAAWInMGgBgJTctMCNYAwCs5KbSsJvOFQAAK5FZAwCs5KZsk2ANALCSm+as3fTGBAAAK5FZAwCs5IlyT25NsAYAWMnjIVgDAOBoUS7KrJmzBgDA4cisAQBWogwOAIDDuWmBGWVwAAAcjswaAGAlyuAAADgcZXAAAOAYZNYAACtRBgcAwOEogwMAAMcgswYAWIkyOAAADuemZ4MTrAEAVnJTZs2cNQAADkdmDQCwkptWgxOsAQBWogwOAAAcg8waAGAlyuAAADgcZXAAAFCr/Px8JScnKz4+Xqmpqdq+fftF+69evVo33XSTGjdurHbt2un+++9XeXl52McjWAMArOSJ8kRkq6u1a9dq2rRpmjVrlvbt26e+fftq6NChKioqCtn/3Xff1bhx4zRx4kT96U9/0osvvqjdu3dr0qRJYR+TYA0AsJLH44nIVlcLFizQxIkTNWnSJHXv3l0LFy7Uddddp8WLF4fsv2vXLnXu3FlTp05VcnKybrvtNk2ePFkffvhh2MckWAMAXM3v9+vkyZNBm9/vD9n37Nmz2rNnjzIzM4PaMzMztWPHjpD7ZGRk6PPPP1dBQYGMMfryyy+1fv16DR8+POwxEqwBAFaKivJEZPP5fEpISAjafD5fyGOWlZWpsrJSiYmJQe2JiYkqKSkJuU9GRoZWr16trKwsxcXFqW3btrrmmmv07LPPhn+u4V8WAACcI1Jl8NzcXJ04cSJoy83NveSxv88YU2tJ/eDBg5o6dapmz56tPXv2aOPGjTp8+LCys7PDPldu3QIAWClS91l7vV55vd6w+rZu3VrR0dE1sujS0tIa2XY1n8+nW2+9VY888ogkqWfPnmrSpIn69u2rxx9/XO3atbvkccmsAQAIU1xcnFJTU1VYWBjUXlhYqIyMjJD7fPvtt4qKCg630dHRks5n5OEgswYAWOlqPRQlJydHY8eOVVpamtLT07V06VIVFRUFytq5ubk6duyYVq1aJUm644479POf/1yLFy/WkCFDVFxcrGnTpumWW25R+/btwzomwRoAYCXPVaoNZ2Vlqby8XPPmzVNxcbFSUlJUUFCgpKQkSVJxcXHQPdcTJkzQqVOn9Pvf/16//OUvdc0112jAgAF68sknwz6mx4Sbg39Pnose8QaEkhfqz+ZM+E8jAv5hxbdqsEPt/UHoOeK66vXplxF5nSuJzBoAYCU3PRucYA0AsJKbPnWL1eAAADgcmTUAwEpRlMEBAHA2yuAAAMAxyKwBAFZiNTgAAA7npjI4wRoAYCU3ZdbMWQMA4HBk1gAAK1EGBwDA4SiDAwAAxyCzBgBYyRPlnnyTYA0AsJKb5qzd87YEAABLkVkDAOzkogVmBGsAgJUogwMAAMcgswYAWInV4AAAOJybHopCsAYA2Ik5awAA4BRk1gAAKzFnDQCAw7lpzto9b0sAALAUmTUAwEpueigKwRoAYCcXBWvK4AAAOByZNQDASh6Pe/JNgjUAwEpumrN2z9sSAAAsRWYNALCSmzJrgjUAwE7MWQMA4Gxuyqzd87YEAABLkVkDAKzkpsyaYA0AsBIf5AEAAByDzBoAYCc+zxoAAGdz05y1e96WAABgKTJrAICV3LTAjGANALCSx0Vz1u45UwAALEVmDQCwkpsWmBGsAQB2Ys4aAABnc1NmzZw1AAAOR2YNALCSm1aDE6wBAFZy033W7nlbAgCApcisAQB2ctECM4I1AMBKbpqzds+ZAgBgKTJrAICV3LTAjGANALASD0UBAACOQWYNALATZXAAAJzNTWVwgjUAwE7uidXMWQMA4HRk1gAAO7lozprMGgBgJY8nMlt95OfnKzk5WfHx8UpNTdX27dsv2t/v92vWrFlKSkqS1+vV9ddfrxUrVoR9PDJrAADqYO3atZo2bZry8/N166236rnnntPQoUN18OBBderUKeQ+o0aN0pdffqnly5frBz/4gUpLS1VRURH2MT3GGFPXgea5qPQAhJIX6s/mTHnDDwRwmvhWDXaok7/4aURep/mzb9Spf+/evdWrVy8tXrw40Na9e3fddddd8vl8Nfpv3LhR9913n/7617+qZcuW9RojZXAAgJUiVQb3+/06efJk0Ob3+0Me8+zZs9qzZ48yMzOD2jMzM7Vjx46Q+7z22mtKS0vT/Pnz1aFDB914442aMWOGvvvuu7DPlWANAHA1n8+nhISEoC1UhixJZWVlqqysVGJiYlB7YmKiSkpKQu7z17/+Ve+++64OHDigV155RQsXLtT69es1ZcqUsMfInDUAwE4RmpLNzc1VTk5OUJvX673EoYOPbYyp9YNFqqqq5PF4tHr1aiUkJEiSFixYoJEjR2rRokVq1KjRJcdIsAYA2ClCtWGv13vJ4FytdevWio6OrpFFl5aW1si2q7Vr104dOnQIBGrp/By3MUaff/65brjhhkselzI4AMBKHo8nIltdxMXFKTU1VYWFhUHthYWFysjICLnPrbfeqi+++ELffPNNoO1///d/FRUVpY4dO4Z1XII1AAB1kJOTo2XLlmnFihU6dOiQpk+frqKiImVnZ0s6X1YfN25coP/o0aPVqlUr3X///Tp48KDeeecdPfLII3rggQfCKoFLlMEBALa6SrcRZ2Vlqby8XPPmzVNxcbFSUlJUUFCgpKQkSVJxcbGKiooC/Zs2barCwkL94he/UFpamlq1aqVRo0bp8ccfD/uY3GcN1AP3WQO1aMD7rE/PGBGR12ny9KsReZ0riTI4AAAORxkcAGAnPs8aAACHc0+spgwOAIDTkVkDAKxU13ukbUawBgDYyT2xmjI4AABOR2YNALCSh9XgAAA4nHtiNcEaAGApFy0wY84aAACHI7MGAFjJRYk1wRoAYCkXLTCjDA4AgMORWQMArEQZHAAAp3NRtKYMDgCAw5FZAwCs5KLEmmANALAUq8EBAIBTkFkDAOzkojo4wRoAYCUXxWqCNQDAUi6K1sxZAwDgcGTWAAAreVyUbhKsAQB2ogwOAACcgswaAGAn9yTW9QvWecZEehyA/eJbXe0RAK7icVEZPGSw9vv98vv9QW1er1der7dBBgUAAP4u5Jy1z+dTQkJC0Obz+Rp6bAAA1C7KE5nNAh5jata0yawBAE5XuXBMRF4netofIvI6V1LIMjiBGQAA56jfavAz5REeBmCZEIvJ8ly02AWoTYMuQLakhB0J3LoFALCTix5hRrAGANjJRdUs97wtAQDAUmTWAAA7MWcNAIDDuWjO2j1nCgCApcisAQB2ogwOAIDDsRocAAA4BZk1AMBOUe7JNwnWAAA7UQYHAABOQWYNALATZXAAABzORWVwgjUAwE4uCtbuqSEAAGApMmsAgJ2YswYAwOEogwMAAKcgswYAWMnDB3kAAOBwfJ41AABwCjJrAICdKIMDAOBwrAYHAABOQWYNALATD0UBAMDhXFQGJ1gDAOzkomDtnhoCAACWIlgDAOwUFRWZrR7y8/OVnJys+Ph4paamavv27WHt99577ykmJkb//M//XKfjEawBAHbyeCKz1dHatWs1bdo0zZo1S/v27VPfvn01dOhQFRUVXXS/EydOaNy4cRo4cGCdj0mwBgCgDhYsWKCJEydq0qRJ6t69uxYuXKjrrrtOixcvvuh+kydP1ujRo5Wenl7nYxKsAQB2ivJEZPP7/Tp58mTQ5vf7Qx7y7Nmz2rNnjzIzM4PaMzMztWPHjlqH+vzzz+uzzz7TnDlz6neq9doLAICrzRMVkc3n8ykhISFo8/l8IQ9ZVlamyspKJSYmBrUnJiaqpKQk5D5/+ctfNHPmTK1evVoxMfW7CYtbtwAArpabm6ucnJygNq/Xe9F9PBfMdRtjarRJUmVlpUaPHq25c+fqxhtvrPcYCdYAADtF6IM8vF7vJYNztdatWys6OrpGFl1aWloj25akU6dO6cMPP9S+ffv08MMPS5KqqqpkjFFMTIw2bdqkAQMGXPK4BGsAgJ2uwkNR4uLilJqaqsLCQt19992B9sLCQo0YMaJG/+bNm+vjjz8OasvPz9fWrVu1fv16JScnh3VcgjUAAHWQk5OjsWPHKi0tTenp6Vq6dKmKioqUnZ0t6XxZ/dixY1q1apWioqKUkpIStH+bNm0UHx9fo/1iCNYAADtdpQ/yyMrKUnl5uebNm6fi4mKlpKSooKBASUlJkqTi4uJL3nNdVx5jjKnzXmfKIzoIwDrxrWo05bnoOcVAbfLqEVLqq2rTYxF5najM30Tkda4kMmsAgJ1c9AaZ+6wBAHA4MmsAgJ087sk3CdYAADu5pwpOGRwAAKcjswYA2MlFC8wI1gAAO7koWFMGBwDA4cisAQB2clFmTbAGAFjKPcGaMjgAAA5HZg0AsJN7EmuCNQDAUsxZAwDgcC4K1sxZAwDgcGTWAAA7uSizJlgDACzlnmBNGRwAAIcjswYA2Mk9iTXBGgBgKRfNWVMGBwDA4cisAQB2clFmTbAGAFjKPcGaMjgAAA5HZg0AsBNlcAAAHI5gDQCAw7knVjNnDQCA05FZAwDsRBkcAACnc0+wpgwOAIDDkVkDAOxEGRwAAIdzUbCmDA4AgMORWQMA7OSexJpgDQCwFGVwAADgFGTWAABLuSezJlgDAOzkojI4wRoAYCcXBWvmrAEAcDgyawCAncisAQCAUxCsAQBwOMrgAAA7uagMTrAGANjJRcGaMjgAAA5HZg0AsJOLMmuCNQDAUu4J1pTBAQBwODJrAICdKIMDAOBwHvcUhwnWAABLuSezds/bEgAALEVmDQCwE3PWAAA4nIvmrN1zpgAAWIrMGgBgKcrgAAA4m4vmrCmDAwDgcGTWAABLuSffJFgDAOxEGRwAADgFwRoAYCePJzJbPeTn5ys5OVnx8fFKTU3V9u3ba+378ssva/Dgwbr22mvVvHlzpaen649//GOdjkewBgBYyhOhrW7Wrl2radOmadasWdq3b5/69u2roUOHqqioKGT/d955R4MHD1ZBQYH27Nmj/v3764477tC+ffvCP1NjjKnzSM+U13kX4B9KfKsaTXkumj8DapNXj5BSX1WfbYjI60Rdf1ed+vfu3Vu9evXS4sWLA23du3fXXXfdJZ/PF9Zr/NM//ZOysrI0e/bs8MZYpxECAPAPxu/36+TJk0Gb3+8P2ffs2bPas2ePMjMzg9ozMzO1Y8eOsI5XVVWlU6dOqWXLlmGPkWANALBThOasfT6fEhISgrbaMuSysjJVVlYqMTExqD0xMVElJSVhDfu3v/2tTp8+rVGjRoV9qty6BQCwVGSmnnJzc5WTkxPU5vV6L37kC6a9jDE12kJZs2aN8vLy9Oqrr6pNmzZhj5FgDQBwNa/Xe8ngXK1169aKjo6ukUWXlpbWyLYvtHbtWk2cOFEvvviiBg0aVKcxUgYHANjJExWZrQ7i4uKUmpqqwsLCoPbCwkJlZGTUut+aNWs0YcIEvfDCCxo+fHidT5XMGgBgpXDKzldCTk6Oxo4dq7S0NKWnp2vp0qUqKipSdna2pPNl9WPHjmnVqlWSzgfqcePG6ZlnnlGfPn0CWXmjRo2UkJAQ1jEJ1gAA1EFWVpbKy8s1b948FRcXKyUlRQUFBUpKSpIkFRcXB91z/dxzz6miokJTpkzRlClTAu3jx4/XypUrwzom91kD9cF91kBIDXmftTlSEJHX8XQeFpHXuZLIrAEAdqrjfLPN3HOmAABYiswaAGAp90w9EawBAHZy0ToRgjUAwE7MWQMAAKcgswYAWIoyOAAAzuaiOWvK4AAAOByZNQDATi5aYEawBgBYijI4AABwCDJrAICdXLTAjGANALCUe4rD7jlTAAAsRWYNALATZXAAAByOYA0AgNO5ZybXPWcKAIClyKwBAHaiDA4AgNO5J1hTBgcAwOHIrAEAdqIMDgCA07knWFMGBwDA4cisAQB2ogwOAIDTuac47J4zBQDAUmTWAAA7UQYHAMDpCNYAADibizJr5qwBAHA4MmsAgKXck1kTrAEAdqIMDgAAnILMGgBgKfdk1gRrAICdKIMDAACnILMGAFjKPfkmwRoAYCfK4AAAwCnIrAEAlnJPZk2wBgBYimANAICjeZizBgAATkFmDQCwlHsya4I1AMBOlMEBAIBTkFkDACzlnsyaYA0AsJPHPcVh95wpAACWIrMGAFiKMjgAAM7GanAAAOAUZNYAAEu5J7MmWAMA7OSiMjjBGgBgKfcEa+asAQBwODJrAICdKIMDAOB07gnWlMEBAHA4MmsAgJ14NjgAAE7nidBWd/n5+UpOTlZ8fLxSU1O1ffv2i/Z/++23lZqaqvj4eHXp0kVLliyp0/EI1gAA1MHatWs1bdo0zZo1S/v27VPfvn01dOhQFRUVhex/+PBhDRs2TH379tW+ffv061//WlOnTtVLL70U9jE9xhhT55GeKa/zLsA/lPhWNZryXLQyFahNXj1CSr2dKYvM68S3rlP33r17q1evXlq8eHGgrXv37rrrrrvk8/lq9P/Vr36l1157TYcOHQq0ZWdna//+/dq5c2dYx6zfnHWIf1SA2zXoPykAuhqrwc+ePas9e/Zo5syZQe2ZmZnasWNHyH127typzMzMoLYhQ4Zo+fLlOnfunGJjYy95XBaYAQBcze/3y+/3B7V5vV55vd4afcvKylRZWanExMSg9sTERJWUlIR8/ZKSkpD9KyoqVFZWpnbt2l1yjGHNWfv9fuXl5dU4GcDN+LsArrL4VhHZfD6fEhISgrZQ5ezv81ww7WWMqdF2qf6h2msTdrCeO3cu/5SA7+HvAvjHkJubqxMnTgRtubm5Ifu2bt1a0dHRNbLo0tLSGtlztbZt24bsHxMTo1atwptWZjU4AMDVvF6vmjdvHrSFKoFLUlxcnFJTU1VYWBjUXlhYqIyMjJD7pKen1+i/adMmpaWlhTVfLRGsAQCok5ycHC1btkwrVqzQoUOHNH36dBUVFSk7O1vS+Ux93Lhxgf7Z2dk6evSocnJydOjQIa1YsULLly/XjBkzwj4mC8wAAKiDrKwslZeXa968eSouLlZKSooKCgqUlJQkSSouLg665zo5OVkFBQWaPn26Fi1apPbt2+t3v/ud7r333rCPGdZ91n6/Xz6fT7m5ubWWBgC34e8CQEOp30NRAABAg2HOGgAAhyNYAwDgcARrAAAcjmANAIDDEawBAHA4gjUAAA5HsAYAwOEI1gAAOBzBGgAAhyNYAwDgcARrAAAc7v8BdLU1s0mzbDUAAAAASUVORK5CYII=\n", + "image/png": "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", "text/plain": [ "
" ] @@ -281,7 +281,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -301,7 +301,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -321,7 +321,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAesAAAGiCAYAAADHpO4FAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAs6UlEQVR4nO3deXRUZZrH8V8lkMoCBAgQ1g7RHm2GADahwQQZBSTKdsQBoaWbHY9RbE+IeDAyyqJtjUszdCsBHQmIHeioLCLk0MSFrcENEJVFhlZMK4lIVMCgBSTv/MFJNUVVQiVWyL19v59z7h95c+ve99ZbyVPP8763ymWMMQIAAJYV0dAdAAAANSNYAwBgcQRrAAAsjmANAIDFEawBALA4gjUAABZHsAYAwOII1gAAWBzBGgAAi2uwYO1yuULaNm/e3FBdDLB58+aAPhUWFmrOnDlB9+/cubMmTpx4Wfp2oWD9nDNnjlwul99+nTt31rBhw8JyzmXLlsnlcunIkSO+tokTJ6pz585++7lcLt1zzz1hOWc4BHuuqlNQUKCuXbsqJiZGLpdLH3zwQb3368iRIzpy5Ei14xkREaFPP/004PHl5eVq1qyZXC5Xg7wGQ7VixQotWLAg7MedOHGimjRpErbjBRv73NxcLVu2rNbHOnv2rNq2bSuXy6VXXnklbH0M1cSJE3XDDTdIOv86uvhvFNbUYMF6586dftuQIUMUExMT0N6zZ8+G6mKAnj17BvSpsLBQc+fODbr/mjVr9NBDD12u7tVo6tSp2rlz52U950MPPaQ1a9Zc1nPWl6+//lrjxo3TlVdeqY0bN2rnzp266qqrGrpbatKkiZYuXRrQ/vLLL+vs2bNq3LhxA/QqdPUVrMOpurGva7Bev369vvrqK0nSkiVLwtxb/Ktq1FAnvvbaa/1+bt26tSIiIgLaL3b69GnFxsbWZ9eq1axZs0v270K//OUv67E3tdOxY0d17Njxsp7zyiuvvKznq0+HDh3S2bNn9dvf/lbXX399WI4ZjtfymDFj9MILL2ju3LmKiPjne+8lS5bo1ltv1bp1635qNx0v3GO/ZMkSRUVF6frrr9emTZv0xRdfhPS32ZD/+9DwLD1nfcMNNyglJUVbt25Venq6YmNjNXnyZEnny1IZGRlq166dYmJi1KVLFz3wwAMqLy/3O0ZVOezw4cMaMmSImjRpok6dOum+++6T1+v123fRokXq0aOHmjRpoqZNm+oXv/iFHnzwQd/vLy6ZTpw4UQsXLpTkX9avKgUHK4MXFxfrt7/9rdq0aSO3260uXbroD3/4gyorK337VJU9n3rqKc2fP1/Jyclq0qSJ0tLS9Pbbb9fpuQxWBg8mNzdXjRo10uzZs31tr7/+ugYOHKhmzZopNjZWffv21RtvvHHJYwUrg1d58cUX1aVLF8XGxqpHjx5av359wD7bt2/XwIED1bRpU8XGxio9PV0bNmwI2O/jjz/WLbfcohYtWig6OlrXXHONXnjhhYD9Dh48qJtvvlmxsbFq1aqVMjMzderUqZCu47rrrpN0Pji6XC5fGVGS1q1bp7S0NMXGxqpp06YaNGhQQBWj6vnfvXu3Ro0apRYtWoTlzczkyZP1j3/8Q0VFRb62Q4cOafv27b6/lYtd6jV49uxZtWnTRuPGjQt47HfffaeYmBhlZ2f72k6ePKkZM2YoOTlZUVFR6tChg7KysgL+Fi92ww03aMOGDfr888/9/n6qfPPNN7r77rvVoUMHRUVF6YorrtCsWbMC/m5/iku9tqsb+86dO2vfvn3asmWLr9+hlJOPHj2qjRs3avjw4br//vtVWVkZNDuv+r/10UcfKSMjQ02bNtXAgQMl/XMqaenSpbr66qsVExOjXr166e2335YxRk8++aTvf8aAAQN0+PDhsDxXaGDGIiZMmGDi4uL82q6//nrTsmVL06lTJ/P000+bt956y2zZssUYY8wjjzxi/ud//sds2LDBbN682SxevNgkJyeb/v37Bxw3KirKdOnSxTz11FPm9ddfNw8//LBxuVxm7ty5vv1WrlxpJJnf/e53ZtOmTeb11183ixcvNvfee69vn7feestIMm+99ZYxxpjDhw+bUaNGGUlm586dvu3HH380xhiTlJRkJkyY4Hv8sWPHTIcOHUzr1q3N4sWLzcaNG80999xjJJm77rrLt99nn31mJJnOnTubm2++2axdu9asXbvWdOvWzbRo0cJ89913NT6XF/fTGGNmz55tLh7upKQkM3ToUGOMMZWVlea+++4zjRs3NkuXLvXt8+KLLxqXy2VGjBhhVq9ebV577TUzbNgwExkZaV5//XXffkuXLjWSzGeffeb33CclJfmds+q6evfubV566SVTWFhobrjhBtOoUSPz97//3bff5s2bTePGjU1qaqopKCgwa9euNRkZGcblcpm//OUvvv0OHjxomjZtaq688kqzfPlys2HDBnP77bcbSebxxx/37VdaWmratGljOnToYJYuXWoKCwvNb37zG/Ozn/0s4Lm62OHDh83ChQuNJPPYY4+ZnTt3mn379hljjMnPzzeSTEZGhlm7dq0pKCgwqampJioqymzbti3g+U9KSjIzZ840RUVFZu3atdWe81Kqjvf111+bfv36mdGjR/t+N3PmTNO5c2dTWVlp4uLi6vQanD59uomJiTEnTpzwO29ubq6RZD788ENjjDHl5eXmmmuuMa1atTLz5883r7/+uvnjH/9o4uPjzYABA0xlZWW117Bv3z7Tt29f07ZtW7+/H2OM+eGHH0z37t1NXFyceeqpp8ymTZvMQw89ZBo1amSGDBlyyecn2P+Ti4Xy2q5u7Hfv3m2uuOIK88tf/tLX7927d1+yX7///e+NJLNhwwZTWVlpkpKSTHJycsDzNGHCBNO4cWPTuXNn4/F4zBtvvGH++te/GmOM73WUnp5uVq9ebdasWWOuuuoq07JlSzN9+nRzyy23mPXr15v8/HyTmJhounfvXuM4wB4sH6wlmTfeeKPGx1ZWVpqzZ8+aLVu2GElm7969fseVZF566SW/xwwZMsRcffXVvp/vuece07x58xrPEywITps2LSAIVrk4WD/wwANGknnnnXf89rvrrruMy+Uyn3zyiTHmn8G6W7du5ty5c7793n33XSPJrFy5stb9rClYnz592owcOdLEx8f7BeDy8nLTsmVLM3z4cL/HVVRUmB49epjevXv72moTrBMTE83Jkyd9baWlpSYiIsJ4PB5f27XXXmvatGljTp065Ws7d+6cSUlJMR07dvT98/n1r39t3G63KS4u9jvP4MGDTWxsrO+NzcyZM43L5TIffPCB336DBg26ZLA25p/P6csvv+z3PLRv395069bNVFRU+NpPnTpl2rRpY9LT031tVc//ww8/XON5QnVhsF66dKlxu92mrKzMnDt3zrRr187MmTPHGGMCgnWor8EPP/zQSDLPPfec3369e/c2qampvp89Ho+JiIgw7733nt9+r7zyipFkCgsLa7yOoUOHBrxGjDFm8eLFQf9uH3/8cSPJbNq0qcbjXipY1+a1HWzsjTGma9eu5vrrr6+xHxeqrKw0P//5z02HDh18f9dV43jx/7iq/1t5eXkBx5Fk2rZta77//ntf29q1a40kc8011/gF5gULFvi9uYJ9WboMLkktWrTQgAEDAto//fRTjR07Vm3btlVkZKQaN27sm086cOCA374ul0vDhw/3a+vevbs+//xz38+9e/fWd999p9tvv12vvvqqjh8/HvZrefPNN/Xv//7v6t27t1/7xIkTZYzRm2++6dc+dOhQRUZG+vVZkl+/f6qysjINGDBA7777rq/sXGXHjh365ptvNGHCBJ07d863VVZW6uabb9Z77713yVJnMP3791fTpk19PycmJqpNmza+6yovL9c777yjUaNG+a3ojYyM1Lhx4/TFF1/ok08+kXT+OR04cKA6derkd46JEyfq9OnTvnL0W2+9pa5du6pHjx5++40dO7bW/a/yySef6OjRoxo3bpzffHGTJk00cuRIvf322zp9+rTfY0aOHFnn81XntttuU1RUlPLz81VYWKjS0tJqV4CH+hrs1q2bUlNT/RavHThwQO+++65feX39+vVKSUnRNddc4/cauemmm37S3Rxvvvmm4uLiNGrUqIB+SgppGqYm9fXarsmWLVt0+PBhTZgwwfd3PWnSJLlcLuXl5QV9THWvl/79+ysuLs73c5cuXSRJgwcP9ptKqGoP5/8MNIwGW2AWqnbt2gW0ff/99+rXr5+io6P16KOP6qqrrlJsbKz+8Y9/6D//8z/1ww8/+O0fGxur6Ohovza3260ff/zR9/O4ceN07tw5/e///q9GjhypyspK/epXv9Kjjz6qQYMGheVaysrKgs5rtW/f3vf7CyUkJAT0WVLA9f0Uhw4d0rfffqs77rhDKSkpfr+rWrF68T/MC33zzTd+/zRCcfF1Seevreq6vv32Wxljgo79xc9VWVlZyPslJycH7Ne2bdta9f1CVceu7vyVlZX69ttv/RYFBdv3p4qLi9OYMWOUl5enpKQk3XjjjUpKSqq2z6G+BidPnqxp06bp4MGD+sUvfqGlS5fK7Xbr9ttv9+3z1Vdf6fDhw9WuOq/rm96ysjLf7U0XatOmjRo1ahTwt1Jb9fXarknVyu9bb71V3333nSQpPj5e1113nVatWqVnnnlGzZs39+0fGxurZs2aBT1Wy5Yt/X6Oioqqsf3C/3WwJ8sH62CLot58800dPXpUmzdv9ludWfUHUFeTJk3SpEmTVF5erq1bt2r27NkaNmyYDh06VO0/v9pISEhQSUlJQPvRo0clSa1atfrJ56ittLQ03XbbbZoyZYqk84vsqrLEqv48/fTT1a6CT0xMDHufWrRooYiIiJCeq1Cf04SEBJWWlgbsF6wtVFVvOqo7f0REhFq0aOHXHsoiv7qYPHmynn/+eX344YfKz8+vdr/avAZvv/12ZWdna9myZfr973+vF198USNGjPC7platWikmJqbazLCur+mEhAS98847Msb4PWfHjh3TuXPnfvLfyuV+bZ84cUKrVq2SJP3qV78Kus+KFSt09913+36ur9cK7MnywTqYqhdxVaZZ5dlnnw3L8ePi4jR48GCdOXNGI0aM0L59+6oN1hdmuzExMTUed+DAgfJ4PNq9e7ffvdrLly+Xy+VS//79w9L/2powYYLi4uI0duxYlZeX64UXXlBkZKT69u2r5s2ba//+/Zf1g0zi4uLUp08frV69Wk899ZTvea2srNSf//xndezY0XeP88CBA7VmzRodPXrUlx1K55/T2NhY3z/i/v3764knntDevXv9SuErVqyocz+vvvpqdejQQStWrNCMGTN8r8vy8nKtWrXKt0L8ckhLS9PkyZN14sQJ3XrrrdXuV5vXYIsWLTRixAgtX75caWlpKi0tDVhhPmzYMD322GNKSEgIWrm4lAsrKhf386WXXtLatWv9rmf58uW+3/8U4XhtV9f3YFasWKEffvhBjzzyiG91+YVuu+025eXl+QVr4EK2DNbp6elq0aKFMjMzNXv2bDVu3Fj5+fnau3dvnY95xx13KCYmRn379lW7du1UWloqj8ej+Pj4at8JS+fn9iTp8ccf1+DBgxUZGanu3bv7yk8Xmj59upYvX66hQ4dq3rx5SkpK0oYNG5Sbm6u77rqrQT9kY9SoUYqNjdWoUaP0ww8/aOXKlWrSpImefvppTZgwQd98841GjRqlNm3a6Ouvv9bevXv19ddfa9GiRfXSH4/Ho0GDBql///6aMWOGoqKilJubq48//lgrV670BcbZs2dr/fr16t+/vx5++GG1bNlS+fn52rBhg5544gnFx8dLkrKyspSXl6ehQ4fq0UcfVWJiovLz83Xw4ME69zEiIkJPPPGEfvOb32jYsGG688475fV69eSTT+q7777Tf//3f4fluQhVKB+wUdvX4OTJk1VQUKB77rlHHTt21I033uj3+6ysLK1atUr/8R//oenTp6t79+6qrKxUcXGxNm3apPvuu099+vSptj/dunXT6tWrtWjRIqWmpioiIkK9evXS+PHjtXDhQk2YMEFHjhxRt27dtH37dj322GMaMmRIQD+CqaioCPoJYVVvxn/qa7tbt276y1/+ooKCAl1xxRWKjo72/T+42JIlS9SiRQvNmDEjYEpOksaPH6/58+cHvJkEfBp2fds/VbcavGvXrkH337Fjh0lLSzOxsbGmdevWZurUqWb37t1Gkt+tR9WtCr14dfQLL7xg+vfvbxITE01UVJRp3769GT16tN8qymCrrL1er5k6dapp3bq1cblcfiuiL14Nbowxn3/+uRk7dqxJSEgwjRs3NldffbV58skn/VYTV60Gf/LJJwP6LcnMnj076HNSUz8vdevWhY9t0qSJufnmm83p06eNMcZs2bLFDB061LRs2dI0btzYdOjQwQwdOtRvdWxtVoNPmzYtoM/Bnqtt27aZAQMGmLi4OBMTE2OuvfZa89prrwU89qOPPjLDhw838fHxJioqyvTo0cPvNVBl//79ZtCgQSY6Otq0bNnSTJkyxbz66qt1Xg1eZe3ataZPnz4mOjraxMXFmYEDB5q//e1vfvtcuHo7HEI93sWrwY0J7TVYpaKiwnTq1MlIMrNmzQp6ju+//97813/9l7n66qtNVFSUiY+PN926dTPTp083paWlNfbvm2++MaNGjTLNmzf3/f1UKSsrM5mZmaZdu3amUaNGJikpyeTk5PhujaxJ1WrqYNuFr8lQXtvVjf2RI0dMRkaGadq0acBxL7R3714jyWRlZVXb34MHD/puHa3qf3Wr2YP9DVX3P6Om1y3sxWWMMZflXQEAAKgTy9+6BQCA0xGsAQCwOII1AAAWR7AGACBEW7du1fDhw9W+fXu5XC6tXbv2ko/ZsmWLUlNTFR0drSuuuEKLFy+u9XkJ1gAAhKi8vFw9evTQM888E9L+n332mYYMGaJ+/fppz549evDBB3Xvvff6PiQnVKwGBwCgDlwul9asWaMRI0ZUu8/MmTO1bt06v++syMzM1N69ewO+SrcmQT8Uxev1BnxnrNvtDvjEMAAA7K4+Y97OnTuVkZHh13bTTTdpyZIlOnv2bLWfq3+xoMHa4/Fo7ty5fm2zZ8/WnDlz6tZbAADCbE64Pj999ux6i3mlpaUBnzOfmJioc+fO6fjx4yF/uU/QYJ2Tk6Ps7Gy/NrJqAICVhGvR1cx6jnkXfylL1exzbb6sJWiwpuQNAHCK+ox5bdu2Dfh2v2PHjqlRo0ZBvy64OnX7Io8ff9p3yaKOooMMLGPRMBgLa2E8rCPYWNQTO3yJaFpaml577TW/tk2bNqlXr14hz1dL3LoFALCpiDBttfH999/rgw8+0AcffCDp/K1ZH3zwgYqLiyWdn0YeP368b//MzEx9/vnnys7O1oEDB5SXl6clS5ZoxowZtTqvLb8iEwCAhvD+++/7fe971Vz3hAkTtGzZMpWUlPgCtyQlJyersLBQ06dP18KFC9W+fXv96U9/0siRI2t13rrdZ015qWFQ6rMOxsJaGA/ruIxlcE+YVoPn2ODjRsisAQC2ZIc563BhzhoAAIsjswYA2JKTsk2CNQDAlpxUBidYAwBsyUmZtZOuFQAAWyKzBgDYkpOyTYI1AMCWnDRn7aQ3JgAA2BKZNQDAlpyUbRKsAQC25KRg7aRrBQDAlsisAQC25KQFZgRrAIAtOak07KRrBQDAlsisAQC2RBkcAACLc1JpmGANALAlJwVrJ10rAAC2RGYNALAl5qwBALA4J5WGnXStAADYEpk1AMCWnJRtEqwBALbkpDlrJ70xAQDAlsisAQC25KRsk2ANALAlJwVrJ10rAAC2RGYNALAlJy0wI1gDAGzJSaVhgjUAwJaclFk76Y0JAAC2RGYNALAlJ2WbBGsAgC05KVg76VoBALAlMmsAgC05aYEZwRoAYEtOKg076VoBALAlMmsAgC05KdskWAMAbMlJc9ZOemMCAIAtkVkDAGzJFeGc3JpgDQCwJZeLYA0AgKVFOCizZs4aAACLI7MGANgSZXAAACzOSQvMKIMDAGBxZNYAAFuiDA4AgMVRBgcAAJZBZg0AsCXK4AAAWBxlcAAAYBlk1gAAW6IMDgCAxTnps8EJ1gAAW3JSZs2cNQAAFkdmDQCwJSetBidYAwBsiTI4AACwDDJrAIAtUQYHAMDiKIMDAIBq5ebmKjk5WdHR0UpNTdW2bdtq3D8/P189evRQbGys2rVrp0mTJqmsrCzk8xGsAQC25IpwhWWrrYKCAmVlZWnWrFnas2eP+vXrp8GDB6u4uDjo/tu3b9f48eM1ZcoU7du3Ty+//LLee+89TZ06NeRzEqwBALbkcrnCstXW/PnzNWXKFE2dOlVdunTRggUL1KlTJy1atCjo/m+//bY6d+6se++9V8nJybruuut055136v333w/5nARrAICjeb1enTx50m/zer1B9z1z5ox27dqljIwMv/aMjAzt2LEj6GPS09P1xRdfqLCwUMYYffXVV3rllVc0dOjQkPtIsAYA2FJEhCssm8fjUXx8vN/m8XiCnvP48eOqqKhQYmKiX3tiYqJKS0uDPiY9PV35+fkaM2aMoqKi1LZtWzVv3lxPP/106Nca+tMCAIB1hKsMnpOToxMnTvhtOTk5lzz3hYwx1ZbU9+/fr3vvvVcPP/ywdu3apY0bN+qzzz5TZmZmyNfKrVsAAFsK133Wbrdbbrc7pH1btWqlyMjIgCz62LFjAdl2FY/Ho759++r++++XJHXv3l1xcXHq16+fHn30UbVr1+6S5yWzBgAgRFFRUUpNTVVRUZFfe1FRkdLT04M+5vTp04qI8A+3kZGRks5n5KEgswYA2FJDfShKdna2xo0bp169eiktLU3PPfeciouLfWXtnJwcffnll1q+fLkkafjw4brjjju0aNEi3XTTTSopKVFWVpZ69+6t9u3bh3ROgjUAwJZcDVQbHjNmjMrKyjRv3jyVlJQoJSVFhYWFSkpKkiSVlJT43XM9ceJEnTp1Ss8884zuu+8+NW/eXAMGDNDjjz8e8jldJtQc/EI/hv6pKwij6ITANsaiYTAW1sJ4WEewsagnu38efI64tnoe/iosx6lPZNYAAFty0meDE6wBALbkpG/dYjU4AAAWR2YNALClCMrgAABYG2VwAABgGWTWAABbYjU4AAAW56QyOMEaAGBLZNaXchk/oQaXwFhYB2NhLYwH/oUEDdZer1der9evrTZfIQYAQH1zUhk86Gpwj8ej+Ph4v83j8VzuvgEAUC2XyxWWzQ6CfpEHmTUAwOoO/rJzWI7ziz1HwnKc+hS0DE5gBgBYnSvCOR8VUrcFZnz1XMPgawCtg7GwFsbDOi7jwj7Hz1kDAADr4D5rAIA92WRxWDgQrAEAtkQZHAAAWAaZNQDAllgNDgCAxdnlA03CgWANALAn5qwBAIBVkFkDAGyJOWsAACzOSXPWznlbAgCATZFZAwBsyUkfikKwBgDYk4OCNWVwAAAsjswaAGBLLpdz8k2CNQDAlpw0Z+2ctyUAANgUmTUAwJaclFkTrAEA9sScNQAA1uakzNo5b0sAALApMmsAgC05KbMmWAMAbIkv8gAAAJZBZg0AsCe+zxoAAGtz0py1c96WAABgU2TWAABbctICM4I1AMCWXA6as3bOlQIAYFNk1gAAW3LSAjOCNQDAnpizBgDA2pyUWTNnDQCAxZFZAwBsyUmrwQnWAABbctJ91s55WwIAgE2RWQMA7MlBC8wI1gAAW3LSnLVzrhQAAJsiswYA2JKTFpgRrAEAtsSHogAAAMsgswYA2BNlcAAArM1JZXCCNQDAnpwTq5mzBgDA6sisAQD25KA5azJrAIAtuVzh2eoiNzdXycnJio6OVmpqqrZt21bj/l6vV7NmzVJSUpLcbreuvPJK5eXlhXw+MmsAAGqhoKBAWVlZys3NVd++ffXss89q8ODB2r9/v372s58Ffczo0aP11VdfacmSJfr5z3+uY8eO6dy5cyGf02WMMbXu6Y9ltX4IwiA6IbCNsWgYjIW1MB7WEWws6snJ3w0Ly3GaPb2+Vvv36dNHPXv21KJFi3xtXbp00YgRI+TxeAL237hxo37961/r008/VcuWLevUR8rgAABbClcZ3Ov16uTJk36b1+sNes4zZ85o165dysjI8GvPyMjQjh07gj5m3bp16tWrl5544gl16NBBV111lWbMmKEffvgh5GslWAMAHM3j8Sg+Pt5vC5YhS9Lx48dVUVGhxMREv/bExESVlpYGfcynn36q7du36+OPP9aaNWu0YMECvfLKK5o2bVrIfWTOGgBgT2FaDZ6Tk6Ps7Gy/NrfbfYlT+5/bGFPtF4tUVlbK5XIpPz9f8fHxkqT58+dr1KhRWrhwoWJiYi7ZR4I1AMCewlQbdrvdlwzOVVq1aqXIyMiALPrYsWMB2XaVdu3aqUOHDr5ALZ2f4zbG6IsvvtC//du/XfK8lMEBALbkcrnCstVGVFSUUlNTVVRU5NdeVFSk9PT0oI/p27evjh49qu+//97XdujQIUVERKhjx44hnZdgDQBALWRnZ+v5559XXl6eDhw4oOnTp6u4uFiZmZmSzpfVx48f79t/7NixSkhI0KRJk7R//35t3bpV999/vyZPnhxSCVyiDA4AsKsG+gSzMWPGqKysTPPmzVNJSYlSUlJUWFiopKQkSVJJSYmKi4t9+zdp0kRFRUX63e9+p169eikhIUGjR4/Wo48+GvI5uc/aTriX1DoYC2thPKzjMt5nXT7jlrAcJ+6pV8NynPpEGRwAAIujDA4AsCe+zxoAAItzTqymDA4AgNWRWQMAbKm290jbGcEaAGBPzonVlMEBALA6MmsAgC25WA0OAIDFOSdWE6wBADbloAVmzFkDAGBxZNYAAFtyUGJNsAYA2JSDFphRBgcAwOLIrAEAtkQZHAAAq3NQtKYMDgCAxZFZAwBsyUGJNcEaAGBTrAYHAABWQWYNALAnB9XBCdYAAFtyUKwmWAMAbMpB0Zo5awAALI7MGgBgSy4HpZsEawCAPVEGBwAAVkFmDQCwJ+ck1nUM1tEJYe4G6oyxsA7GwloYj395LgeVwYMGa6/XK6/X69fmdrvldrsvS6cAAMA/BZ2z9ng8io+P99s8Hs/l7hsAANWLcIVnswGXMcZc3EhmDQCwuooFvw3LcSKz/hyW49SnoGVwAjMAANZRpwVmcxw0qW8lcwKLIIxFA2EsrIXxsI5gY1FvbFLCDgdu3QIA2JODPsKMYA0AsCcHVU+c87YEAACbIrMGANgTc9YAAFicg+asnXOlAADYFJk1AMCeKIMDAGBxrAYHAABWQWYNALCnCOfkmwRrAIA9UQYHAABWQWYNALAnyuAAAFicg8rgBGsAgD05KFg7p4YAAIBNkVkDAOyJOWsAACyOMjgAALAKMmsAgC25+CIPAAAsju+zBgAAVkFmDQCwJ8rgAABYHKvBAQCAVZBZAwDsiQ9FAQDA4hxUBidYAwDsyUHB2jk1BAAAbIpgDQCwp4iI8Gx1kJubq+TkZEVHRys1NVXbtm0L6XF/+9vf1KhRI11zzTW1Oh/BGgBgTy5XeLZaKigoUFZWlmbNmqU9e/aoX79+Gjx4sIqLi2t83IkTJzR+/HgNHDiw1uckWAMAUAvz58/XlClTNHXqVHXp0kULFixQp06dtGjRohofd+edd2rs2LFKS0ur9TkJ1gAAe4pwhWXzer06efKk3+b1eoOe8syZM9q1a5cyMjL82jMyMrRjx45qu7p06VL9/e9/1+zZs+t2qXV6FAAADc0VEZbN4/EoPj7eb/N4PEFPefz4cVVUVCgxMdGvPTExUaWlpUEf83//93964IEHlJ+fr0aN6nYTFrduAQAcLScnR9nZ2X5tbre7xse4LprrNsYEtElSRUWFxo4dq7lz5+qqq66qcx8J1gAAewrTF3m43e5LBucqrVq1UmRkZEAWfezYsYBsW5JOnTql999/X3v27NE999wjSaqsrJQxRo0aNdKmTZs0YMCAS56XYA0AsKcG+FCUqKgopaamqqioSLfeequvvaioSLfcckvA/s2aNdNHH33k15abm6s333xTr7zyipKTk0M6L8EaAIBayM7O1rhx49SrVy+lpaXpueeeU3FxsTIzMyWdL6t/+eWXWr58uSIiIpSSkuL3+DZt2ig6OjqgvSYEawCAPTXQF3mMGTNGZWVlmjdvnkpKSpSSkqLCwkIlJSVJkkpKSi55z3VtuYwxprYPmuOgz2O1kjlBhoqxaBiMhbUwHtYRbCzqS+WmR8JynIiMh8JynPpEZg0AsCcHvSHjPmsAACyOzBoAYE8u5+SbBGsAgD05pwpOGRwAAKsjswYA2JODFpgRrAEA9uSgYE0ZHAAAiyOzBgDYk4Mya4I1AMCmnBOsKYMDAGBxZNYAAHtyTmJNsAYA2BRz1gAAWJyDgjVz1gAAWByZNQDAnhyUWROsAQA25ZxgTRkcAACLI7MGANiTcxJrgjUAwKYcNGdNGRwAAIsjswYA2JODMmuCNQDAppwTrCmDAwBgcWTWAAB7ogwOAIDFEawBALA458Rq5qwBALA6MmsAgD1RBgcAwOqcE6wpgwMAYHFk1gAAe6IMDgCAxTkoWFMGBwDA4sisAQD25JzEmmANALApyuAAAMAqyKwBADblnMyaYA0AsCcHlcEJ1gAAe3JQsGbOGgAAiyOzBgDYE5k1AACwCoI1AAAWRxkcAGBPDiqDE6wBAPbkoGDtMsaYhu4EAAC1VflxXliOE5EyOSzHqU9BM2uv1yuv1+vX5na75Xa7L0unAAC4JAdl1kEXmHk8HsXHx/ttHo/ncvcNAIAauMK0WV/QMjiZNQDA6ir3LQvLcSK6TgzLcepT0DI4gRkAYHkOKoPXbTX4j2Vh7gZCEp0Q2MZYNAzGwloYD+sINhb1xeWcjwrh1i0AgE05J7N2ztsSAABsiswaAGBPzFkDAGBxDpqzds6VAgBgU2TWAACbogwOAIC1OWjOmjI4AAAWR2YNALAp5+SbBGsAgD1RBgcAAFZBsAYA2JPLFZ6tDnJzc5WcnKzo6GilpqZq27Zt1e67evVqDRo0SK1bt1azZs2Ulpamv/71r7U6H8EaAGBTDfN91gUFBcrKytKsWbO0Z88e9evXT4MHD1ZxcXHQ/bdu3apBgwapsLBQu3btUv/+/TV8+HDt2bMn9CsN9n3Wl8S32TQMvlnIOhgLa2E8rOMyfutW5d/XhuU4EVeOqNX+ffr0Uc+ePbVo0SJfW5cuXTRixAh5PJ6QjtG1a1eNGTNGDz/8cGh9rFUPAQD4F+P1enXy5Em/zev1Bt33zJkz2rVrlzIyMvzaMzIytGPHjpDOV1lZqVOnTqlly5Yh95FgDQCwpzDNWXs8HsXHx/tt1WXIx48fV0VFhRITE/3aExMTVVpaGlK3//CHP6i8vFyjR48O+VK5dQsAYFPhuXUrJydH2dnZfm1ut7vmM1+0MM0YE9AWzMqVKzVnzhy9+uqratOmTch9JFgDABzN7XZfMjhXadWqlSIjIwOy6GPHjgVk2xcrKCjQlClT9PLLL+vGG2+sVR8pgwMA7MkVEZ6tFqKiopSamqqioiK/9qKiIqWnp1f7uJUrV2rixIlasWKFhg4dWutLJbMGANhSKGXn+pCdna1x48apV69eSktL03PPPafi4mJlZmZKOl9W//LLL7V8+XJJ5wP1+PHj9cc//lHXXnutLyuPiYlRfHx8SOckWAMAUAtjxoxRWVmZ5s2bp5KSEqWkpKiwsFBJSUmSpJKSEr97rp999lmdO3dO06ZN07Rp03ztEyZM0LJly0I6J/dZ2wn3kloHY2EtjId1XMb7rM2RwrAcx9V5SFiOU5/IrAEA9lTL+WY7c86VAgBgU2TWAACbcs5XZBKsAQD25KDvsyZYAwDsiTlrAABgFWTWAACbogwOAIC1OWjOmjI4AAAWR2YNALAnBy0wI1gDAGyKMjgAALAIMmsAgD05aIEZwRoAYFPOKQ4750oBALApMmsAgD1RBgcAwOII1gAAWJ1zZnKdc6UAANgUmTUAwJ4ogwMAYHXOCdaUwQEAsDgyawCAPVEGBwDA6pwTrCmDAwBgcWTWAAB7ogwOAIDVOac47JwrBQDApsisAQD2RBkcAACrI1gDAGBtDsqsmbMGAMDiyKwBADblnMyaYA0AsCfK4AAAwCrIrAEANuWczJpgDQCwJ8rgAADAKsisAQA25Zx8k2ANALAnyuAAAMAqyKwBADblnMyaYA0AsCmCNQAAluZizhoAAFgFmTUAwKack1kTrAEA9kQZHAAAWAWZNQDAppyTWROsAQD25HJOcdg5VwoAgE2RWQMAbIoyOAAA1sZqcAAAYBVk1gAAm3JOZk2wBgDYk4PK4ARrAIBNOSdYM2cNAIDFkVkDAOyJMjgAAFbnnGBNGRwAAIsjswYA2BOfDQ4AgNW5wrTVXm5urpKTkxUdHa3U1FRt27atxv23bNmi1NRURUdH64orrtDixYtrdT6CNQAAtVBQUKCsrCzNmjVLe/bsUb9+/TR48GAVFxcH3f+zzz7TkCFD1K9fP+3Zs0cPPvig7r33Xq1atSrkc7qMMabWPf2xrNYPQRhEJwS2MRYNg7GwFsbDOoKNRX358Xh4jhPdqla79+nTRz179tSiRYt8bV26dNGIESPk8XgC9p85c6bWrVunAwcO+NoyMzO1d+9e7dy5M6Rz1m3O+nIOBmrGWFgHY2EtjIcDXP7V4GfOnNGuXbv0wAMP+LVnZGRox44dQR+zc+dOZWRk+LXddNNNWrJkic6ePavGjRtf8rwsMAMAOJrX65XX6/Vrc7vdcrvdAfseP35cFRUVSkxM9GtPTExUaWlp0OOXlpYG3f/cuXM6fvy42rVrd8k+hjRn7fV6NWfOnICLweXHWFgHY2EtjIcDRSeEZfN4PIqPj/fbgpWzL+S66ANZjDEBbZfaP1h7dUIO1nPnzuWPwAIYC+tgLKyF8UBd5eTk6MSJE35bTk5O0H1btWqlyMjIgCz62LFjAdlzlbZt2wbdv1GjRkpICG26htXgAABHc7vdatasmd8WrAQuSVFRUUpNTVVRUZFfe1FRkdLT04M+Ji0tLWD/TZs2qVevXiHNV0sEawAAaiU7O1vPP/+88vLydODAAU2fPl3FxcXKzMyUdD5THz9+vG//zMxMff7558rOztaBAweUl5enJUuWaMaMGSGfkwVmAADUwpgxY1RWVqZ58+appKREKSkpKiwsVFJSkiSppKTE757r5ORkFRYWavr06Vq4cKHat2+vP/3pTxo5cmTI5wwpWLvdbs2ePbvasgAuH8bCOhgLa2E8cDndfffduvvuu4P+btmyZQFt119/vXbv3l3n89XtQ1EAAMBlw5w1AAAWR7AGAMDiCNYAAFgcwRoAAIsjWAMAYHEEawAALI5gDQCAxRGsAQCwOII1AAAWR7AGAMDiCNYAAFjc/wP34zr2WeOb4AAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -341,7 +341,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -470,7 +470,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -492,7 +492,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -535,7 +535,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -576,7 +576,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -609,17 +609,17 @@ "output_type": "stream", "text": [ " === Starting experiment === \n", - " Reward condition: Right, Observation: [CENTER, No reward, Cue Left]\n", + " Reward condition: Left, Observation: [CENTER, No reward, Cue Right]\n", "[Step 0] Action: [Move to CUE LOCATION]\n", - "[Step 0] Observation: [CUE LOCATION, No reward, Cue Right]\n", - "[Step 1] Action: [Move to RIGHT ARM]\n", - "[Step 1] Observation: [RIGHT ARM, Reward!, Cue Left]\n", - "[Step 2] Action: [Move to RIGHT ARM]\n", - "[Step 2] Observation: [RIGHT ARM, Reward!, Cue Right]\n", - "[Step 3] Action: [Move to RIGHT ARM]\n", - "[Step 3] Observation: [RIGHT ARM, Reward!, Cue Left]\n", - "[Step 4] Action: [Move to RIGHT ARM]\n", - "[Step 4] Observation: [RIGHT ARM, Reward!, Cue Left]\n" + "[Step 0] Observation: [CUE LOCATION, No reward, Cue Left]\n", + "[Step 1] Action: [Move to LEFT ARM]\n", + "[Step 1] Observation: [LEFT ARM, Reward!, Cue Right]\n", + "[Step 2] Action: [Move to LEFT ARM]\n", + "[Step 2] Observation: [LEFT ARM, Reward!, Cue Left]\n", + "[Step 3] Action: [Move to LEFT ARM]\n", + "[Step 3] Observation: [LEFT ARM, Reward!, Cue Right]\n", + "[Step 4] Action: [Move to LEFT ARM]\n", + "[Step 4] Observation: [LEFT ARM, Reward!, Cue Left]\n" ] } ], @@ -681,7 +681,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -701,7 +701,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoUAAAGiCAYAAACRaLzHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA7U0lEQVR4nO3dfZhN5f7H8c+eGbPnAeNhxjBiTCpESuOoIY0hpOjUyUE6nqIT6jiMOiWVh8ocPbimFPJDjhNy6AkpZkp6MJVE/UKpjpqjBqGQGGZ8f3+4Zv9se8+YYbPW4f26rnVd5t5rr3Wvda+99tf3vte9PWZmAgAAwDktzOkKAAAAwHkEhQAAACAoBAAAAEEhAAAARFAIAAAAERQCAABABIUAAAAQQSEAAABEUAgAAACdZFD4+eefa8CAAUpJSVFUVJQqV66syy+/XI899ph2794d6jqWy+HDhzV16lSlpaUpLi5O0dHRatKkie677z7t2rUrYP0GDRqoa9euDtT0zPjxxx81duxYrV+/PuC1sWPHyuPxnPlKnUb9+/dX5cqVna6Ga82ePVsej0ffffedr6xdu3Zq166d7+/ffvtNY8eO1TvvvFOu958px9fzVHg8Hr+latWqat26tebPnx+S7buB2z7f7dq1U7NmzUK2vcmTJ+uCCy5QZGSkPB6PfvnlF02YMEGvvvrqKW/7gQceUP369RUREaFq1aqd8vbKUtJOJUtMTIzOO+88de7cWZMnT9a+ffsC3tO/f381aNDAr2z37t3q1auXatWqJY/HoxtvvFGS9N133+n6669XjRo15PF4NHz48NN6PKdi3rx5ys7OLvf6ob6mQmXjxo0aO3Zs0PtksLZzJaug6dOnW0REhDVt2tSeffZZW7lypa1YscImTJhgKSkpduONN1Z0k6ds//79lp6ebuHh4TZkyBB7/fXX7e2337ZHH33UqlevbvXq1bMvv/zS7z3Jycl2/fXXn/G6nilr1qwxSfb8888HvPaf//zH8vLyznylTqN+/fpZbGys09Vwreeff94k2ZYtW3xlGzZssA0bNvj+/umnn0ySjRkzJuD9O3bssLy8PDt48OAZqK2/4+t5KiRZ9+7dLS8vz1avXm1z5861pk2bmiSbO3duSPbhtDFjxthJ3NpPm/T0dGvatGlItrVu3TqTZIMGDbL33nvP8vLyrKioyGJjY61fv36ntO1XX33VJNno0aPt/ffftzVr1oSkzqUpaac333zT8vLybNWqVTZ//nwbNGiQRUVFWb169Wz9+vV+7/nmm2/s008/9SsbPny4RUZG2gsvvGB5eXn21VdfmZnZjTfeaDVr1rRXXnnF8vLy7Lvvvjutx3Mqrr/+ektOTi73+qG8pkJp4cKFJslWrlwZ8FqwtnOjiIoEkHl5eRoyZIg6duyoV199VV6v1/dax44dNXLkSL355pshClfLb8SIEVq1apVefPFF9ezZ01eekZGh7t27q1WrVrr55pv12WefKTw8/IzXryyHDx+Wx+NRRESFmuKUnHfeeTrvvPPO2P7gThdffHG5101ISFBCQsJprE3pKlLP8khMTNSVV14pSUpLS1ObNm3UoEEDPffcc+rdu3dI93U6FBcXq6ioyO/+e67YsGGDJOn2229Xq1atQrrtL774QpI0bNgw1apVKyTb/O233xQTE1PmOqmpqYqPj/f93atXL911111KT0/XDTfcoM2bN/vaumHDhkHr3bBhQ916660B5a1atfJlDk+VmengwYOKjo4OyfbONcHazpUqEkF27drVIiIiLD8/v1zrq5SsQ3JycsD/6goKCuzPf/6z1a1b1ypVqmQNGjSwsWPH2uHDh8vcR0FBgUVERFjnzp1LXWfChAkmyRYtWuRXh+uvv95efvllu+SSS8zr9VpKSoo99dRTfu8tLi62hx9+2C666CKLioqyuLg4u+SSSyw7O9tvvc2bN9stt9xiCQkJFhkZaY0bN7ZnnnnGb52VK1eaJJszZ45lZmZaUlKSeTweW79+vUmyGTNmBNR92bJlJslee+01MzP7+uuvrX///nbBBRdYdHS0JSUlWdeuXe3zzz8P2M/xS0lbBMskFBcX28SJE61Ro0YWGRlpCQkJ1qdPH/vPf/7jt17J/9A+/vhju+qqqyw6OtpSUlIsKyvLiouLK3zejnXkyBGrVauWDR061FdWVFRk1apVM4/HY9u2bfOVP/nkkxYeHm4///yzmf1/pvDrr7+2Ll26WGxsrJ133nmWmZkZkN0qLCy0hx9+2Hes8fHx1r9/f9uxY4ffeiXXyBtvvGEtWrSwqKgoa9Sokc2cObPUYzjWwYMHbdy4cda4cWPzer1Wo0YNa9eunX3wwQe+dQ4cOGD33XefNWjQwCpVqmRJSUk2dOhQ33GdTF3y8vKsdevW5vV6rU6dOnbffffZ9OnTAzKF6enplp6ebmZmW7ZsCXrNlHxOg2UazcxmzpxpzZs3N6/Xa9WrV7cbb7zRNm7c6LdORdommGPrWWLKlCnWvHlzi42NtcqVK1ujRo1s1KhRJ9yWJLvzzjsDyhMSEqxRo0Z+ZXv27LGRI0f6tc1f//pX+/XXX33rdO/e3S6++GK/93Xt2tUk2b/+9S9f2dq1a02SLV682MyOZl6HDBliTZo0sdjYWEtISLCMjAx79913/bZV0i4TJ060hx9+2Bo0aGDh4eH2xhtvmJnZ0qVL7dJLL7XIyEhr0KCBPf744xXKFJ6p9itPVufFF1+0K6+80mJiYiw2NtY6derkl1lJT08Pen0Gu26Pv15OJDk5udT7ZUXvjatWrbK0tDSLjo62nj17lrrPknb66aefgr7+2GOPmST7xz/+4Svr16+fL6NW2me2tPt/yWe3PNe12f9/VqZOnWqNGze2SpUq2dSpU82sYt938+bNs/vvv9/q1KljVapUsQ4dOvj13AVr1xNdv+W5psrbbmZmb7zxhrVv396qVq1q0dHR1rhxY5swYYLv9TVr1ljPnj0tOTnZoqKiLDk52Xr16uWXfS25Rx6/lPTWHdt2JUJ9/9+/f7+vbUs+06mpqTZv3rwyz9Wxyh0UFhUVWUxMjF1xxRXl33g5g8KCggKrV6+eJScn23PPPWe5ubn28MMPm9frtf79+5e5j3nz5pkk38UazMaNG02S3XHHHX51qFu3rtWvX99mzZply5Yts1tvvdUk2eOPP+5bLysry8LDw23MmDH21ltv2ZtvvmnZ2dk2duxY3zobNmzwBT1z5syxFStW2MiRIy0sLMxvvZIPSd26da179+62ePFiW7p0qe3atctatGhhbdq0Cah7jx49rFatWr7geNWqVTZy5EhbtGiRrVq1yl555RW78cYbLTo62vdB27Nnj+8CfeCBBywvL8/y8vJ8H4ZgXxp//vOfTZLddddd9uabb9q0adMsISHB6tWr53fTSk9Pt5o1a9qFF15o06ZNs5ycHBs6dGjAzas85y2YXr162UUXXeT7+8MPPzRJFh0d7de916VLF2vVqpXv7379+llkZKQ1adLEnnjiCcvNzbWHHnrIPB6PjRs3zrdecXGxXXvttRYbG2vjxo2znJwcmzFjhtWtW9cuvvhi++2333zrJicn23nnnWcXX3yxzZkzx5YvX25//OMfTZKtWrWqzOM4fPiwZWRkWEREhN199922bNkyW7x4sd1///02f/58MzsaBHfu3NkiIiLswQcftBUrVtgTTzxhsbGx1qJFC78v3PLWZcOGDRYTE2MXX3yxzZ8/31577TXr3Lmz1a9fv8yg8ODBg/bmm2+aJBs4cKDvmvnmm2/MLHhQWPKfrVtuucVef/11mzNnjp1//vkWFxdnmzdvrnDblOb4oHD+/Pkmyf7yl7/YihUrLDc316ZNm2bDhg074baCBYW//PKLhYeHW7du3Xxl+/fvt8suu8zi4+Nt0qRJlpuba0899ZTFxcVZ+/bt7ciRI2ZmNm3aNJNkP/74o5kdbfcqVapYdHS03X777b7tTZw40SIiImzv3r1mZvbll1/akCFD7MUXX7R33nnHli5dagMHDrSwsDC/rqeSL/66detaRkaGLVq0yFasWGFbtmyx3NxcCw8Pt6uuuspefvllW7hwof3ud7/ztfWJnMn2O9EX+KOPPmoej8duu+02W7p0qb388suWlpZmsbGxvqEDGzZssAceeMD3RVtyfebl5Vl0dLRdd911vuu2osMNPv30Uxs4cKBfd27J/bIi98YaNWpYvXr1bPLkybZy5coy7xMnCgq//PJL3+exxLGBxcGDBy0vL89atGhh559/vu/Y9+zZY3l5eVa7dm1r06aNr/zgwYPlvq7NzHfdNW/e3ObNm2dvv/22ffHFFxX+vmvQoIHdeuut9vrrr9v8+fOtfv36duGFF1pRUZGvXdu0aWO1a9f21fVEw5vKc02Vt91mzJhhHo/H2rVrZ/PmzbPc3FybMmWKX3Ji4cKF9tBDD9krr7xiq1atshdffNHS09MtISHBt60dO3b4PlPPPvus7zhKkg3HB4Wn4/5/xx13WExMjE2aNMlWrlxpS5cutb///e82efLkMs/VscodFG7bts0kWa9evcq/8XIGhXfccYdVrlzZvv/+e7/1nnjiCZNU5gf873//u++DXJoDBw6YJOvSpYtfHUqydMfq2LGjVa1a1fbv329mR//Xf9lll5V1mNa5c2c777zzbM+ePX7ld911l0VFRdnu3bvN7P8/JFdffXXANp5++mmT5BsPYma2e/du83q9NnLkyFL3XVRUZIcOHbILL7zQRowY4Ssva0zh8UHhpk2bTJLfh8DM7KOPPjJJdv/99/vKSv5X99FHH/mte/HFF/tla8tz3oKZMWOGSfJlox955BFr3Lix3XDDDTZgwAAzMzt06JDFxsb61askY3BsdsbM7LrrrvPLAJUEFC+99JLfeiXna8qUKb6ykv8VHntdHjhwwGrUqOH3H4xg5syZY5Lsf/7nf0pdpyQIe+yxx/zKFyxYYJJs+vTpFa5Lz549LTo62i+rWlRUZI0bNy4zKDQre0zh8UHhzz//7PsiPlZ+fr55vV7r3bu3r6y8bVOa4+t51113WbVq1U74vmBKrvPDhw/boUOHbPPmzXbDDTdYlSpV7JNPPvGtl5WVZWFhYQHjyhYtWmSSbNmyZWZ2dJxQSfbfzOz99983Sfa3v/3NUlJSfO/r2LGjtW7dutR6FRUV2eHDh61Dhw520003+cpLgsKGDRvaoUOH/N5zxRVXWFJSkh04cMBXtnfvXqtRo8YJg8Iz3X5lfYHn5+dbRESE/eUvf/Er37dvn9WuXdt69OjhKyu5Do9vl1CMKQwWpJ3MvfGtt9466f0dK9j3VrBsU2nnN9i4+fJe12ZHPytxcXG+768SFf2+O/4a+9e//mWS/AK/UI8pLG+77du3z6pWrWpXXXWVX0B8IkVFRfbrr79abGysX+9iWWMKj2+703H/b9as2Sk/1+GKKWmWLl2qjIwMJSUlqaioyLd06dJFkrRq1aqQ7Of4J/KaNm2qSy+91K+sd+/e2rt3rz799FNJUqtWrfTZZ59p6NChWr58ufbu3eu3/sGDB/XWW2/ppptuUkxMjF/9r7vuOh08eFAffvih33tuvvnmgLrdeuut8nq9mj17tq9s/vz5Kiws1IABA3xlRUVFmjBhgi6++GJFRkYqIiJCkZGR+vrrr7Vp06aTOi8rV66UdPTpqGO1atVKTZo00VtvveVXXrt27YDxPM2bN9f333/v996yzltprrnmGklSbm6uJCknJ0cdO3bUNddco5ycHElHx7bu37/ft24Jj8ejbt26lVmvpUuXqlq1aurWrZtfW1122WWqXbt2wJO3l112merXr+/7OyoqShdddJHfNoN54403FBUVpdtuu63Udd5++21Jgef9j3/8o2JjYwPOe3nqsnLlSnXo0EGJiYm+svDwcL+xtqGQl5enAwcOBNS9Xr16at++fUDdy9M25dWqVSv98ssvuuWWW/Taa69p586dFXr/lClTVKlSJUVGRuqiiy7SG2+8ofnz5ys1NdW3ztKlS9WsWTNddtllftdJ586d5fF4fNdJw4YN1aBBA7/r9ZJLLtGf/vQnbdmyRd9++60KCwv1/vvvB1yv06ZN0+WXX66oqChFRESoUqVKeuutt4J+jm+44QZVqlTJ9/f+/fu1Zs0a/eEPf1BUVJSvvEqVKgHnORgn2+94y5cvV1FRkfr27et3rqOiopSenh70afgzpaL3xurVq6t9+/Yh2beZhWQ7xyrvdV2iffv2ql69uu/vk/m+u+GGG/z+bt68uSSF5NopTXnbbfXq1dq7d6+GDh1a5hP7v/76q+69915dcMEFioiIUEREhCpXrqz9+/ef9Pfu6bj/t2rVSm+88Ybuu+8+vfPOOzpw4ECF61XuoDA+Pl4xMTHasmVLhXdyItu3b9eSJUtUqVIlv6Vp06aSVOZNv+QklVWvktfq1avnV167du2AdUvKSqaxGTVqlJ544gl9+OGH6tKli2rWrKkOHTrok08+8a1XVFSkyZMnB9T/uuuuC1r/OnXqBOy3Ro0auuGGGzRnzhwVFxdLOjoNSKtWrXznQZIyMzP14IMP6sYbb9SSJUv00Ucfac2aNbr00ktP6gI49liD1SspKSlgSp+aNWsGrOf1ev32f6LzVprk5GQ1bNhQubm5+u2335SXl+cLCrdu3aqvvvpKubm5io6OVuvWrf3eGxMT4/cFWVKvgwcP+v7evn27fvnlF0VGRga017Zt2wLaqjzHGsxPP/2kpKQkhYWV/hHbtWuXIiIiAh7g8Hg8ql279kmd9127dpV5XYdKRa+Z8rRNefXp00ezZs3S999/r5tvvlm1atXSFVdc4ftPw4n06NFDa9as0erVq/Xcc8+pSpUq6tWrl77++mvfOtu3b9fnn38ecI1UqVJFZuZ3nXTo0MF3A8/NzVXHjh11ySWXKDExUbm5ufrggw904MABv6Bw0qRJGjJkiK644gq99NJL+vDDD7VmzRpde+21Qa+t48/zzz//rCNHjpx0WzvZfsfbvn27JOl3v/tdwPlesGBBhYP+UKroeQq23skq+bJPSkoK2TYrcl1LgcdzMt93x9+3Sh6aOdnvq/Iob7v99NNPknTCBy979+6tZ555RoMGDdLy5cv18ccfa82aNUpISDil791Q3/+ffvpp3XvvvXr11VeVkZGhGjVq6MYbb/S7t51IuR95DQ8PV4cOHfTGG29o69at5Xp61ev1qrCwMKD8+IONj49X8+bN9eijjwbdTlkfioyMDEVEROjVV1/V4MGDg65TMn9Vx44d/cq3bdsWsG5JWUkDREREKDMzU5mZmfrll1+Um5ur+++/X507d9Z//vMfVa9eXeHh4erTp4/uvPPOoPtPSUnx+7u0/5EMGDBACxcuVE5OjurXr681a9Zo6tSpfuu88MIL6tu3ryZMmOBXvnPnzpOeV6vkWAsKCgLa9ccff/R7Mq68TnTeynoir0OHDnrttde0atUqHTlyRO3atVOVKlWUlJSknJwc5ebmqm3btif19GV8fLxq1qxZ6lPyVapUqfA2g0lISND777+vI0eOlBoY1qxZU0VFRfrpp5/8bgxmpm3btul3v/tdhfdbs2bNMq/rUDn2mjneyV4zFTFgwAANGDBA+/fv17vvvqsxY8aoa9eu2rx5s5KTk8t8b0JCglq2bCnp6NPHTZo0UXp6ukaMGKGlS5dKOnqdREdHa9asWUG3cezxdejQQTNnztTHH3+sjz76SA888ICko1mWnJwcff/996pcubLviWfp6Oe4Xbt2AZ/vYHPTSYH3jOrVq8vj8Zx0Wzvdfscq2deiRYtO2HZnWkXvjaGcH3Lx4sWSFLI5OqWKXddS8Ouuot93Tihvu5Xcd7du3Vrqtvbs2aOlS5dqzJgxuu+++3zlhYWFpzQv8+m4/8fGxmrcuHEaN26ctm/f7ssaduvWTV9++WW5tlGh7uNRo0bJzHT77bfr0KFDAa8fPnxYS5Ys8f3doEEDff75537rvP322/r111/9yrp27ep7rL5ly5YBS1lBYe3atXXbbbdp+fLlWrBgQcDrmzdv1sSJE9W0adOAR/M3bNigzz77zK9s3rx5qlKlii6//PKAbVWrVk3du3fXnXfeqd27d+u7775TTEyMMjIytG7dOjVv3jxo/YNF+MF06tRJdevW1fPPP6/nn39eUVFRuuWWW/zW8Xg8AcHQ66+/rh9++MGvrCL/Gyvp7njhhRf8ytesWaNNmzapQ4cO5ap/aYKdt7Jcc8012r59u7Kzs3XllVf6ArUOHTrolVde0Zo1awK64sqra9eu2rVrl4qLi4O2VaNGjU5qu8fr0qWLDh486Dcc4Hgl5/X48/7SSy9p//79J3XeMzIy9NZbb/myL9LRKUyCfTaOV5FrJi0tTdHR0QF137p1q95+++1TvmbKKzY2Vl26dNHo0aN16NAh35QlFdG2bVv17dtXr7/+uvLy8iQdvU6+/fZb1axZM+h1cuwktB06dJDH49GDDz6osLAwXX311ZKOXscrV65UTk6Orr76ar/u32Cf488//9y3//Icd6tWrfTyyy/7Zev27dvndw8ujVvaT5I6d+6siIgIffvtt0HPdUkAX5byZO9Pxum+N5bms88+04QJE9SgQQP16NEjZNutyHUdTCi/744V6vYrb7u1bt1acXFxmjZtWqnd9R6PR2YW8HmdMWOGr1evREXuoafj/n+sxMRE9e/fX7fccou++uor/fbbb+V6X4Umx0tLS9PUqVM1dOhQpaamasiQIWratKkOHz6sdevWafr06WrWrJlv7EmfPn304IMP6qGHHlJ6ero2btyoZ555RnFxcX7bHT9+vHJyctS6dWsNGzZMjRo10sGDB/Xdd99p2bJlmjZtWpmZyUmTJumrr77Sn/70J7377rvq1q2bvF6vPvzwQz3xxBOqUqWKXnrppYA5CpOSknTDDTdo7NixqlOnjl544QXl5ORo4sSJvkxWt27d1KxZM7Vs2VIJCQn6/vvvlZ2dreTkZF144YWSpKeeekpXXXWV2rZtqyFDhqhBgwbat2+fvvnmGy1ZssQ3duBEwsPD1bdvX02aNElVq1bVH/7wh4Bz1bVrV82ePVuNGzdW8+bNtXbtWj3++OMB56dhw4aKjo7W3Llz1aRJE1WuXFlJSUlBA+xGjRrpz3/+syZPnqywsDB16dJF3333nR588EHVq1dPI0aMKFf9j1We81aa9u3by+PxaMWKFRo3bpyv/JprrlG/fv18/z4ZvXr10ty5c3Xdddfpr3/9q1q1aqVKlSpp69atWrlypX7/+9/rpptuOqltH+uWW27R888/r8GDB+urr75SRkaGjhw5oo8++khNmjRRr1691LFjR3Xu3Fn33nuv9u7dqzZt2ujzzz/XmDFj1KJFC/Xp06fC+33ggQe0ePFitW/fXg899JBiYmL07LPPav/+/Sd8b5UqVZScnKzXXntNHTp0UI0aNRQfHx/0i6JatWp68MEHdf/996tv37665ZZbtGvXLo0bN05RUVEaM2ZMheteXrfffruio6PVpk0b1alTR9u2bVNWVpbi4uJO6n/XkvTwww9rwYIFevDBB5Wbm6vhw4frpZde0tVXX60RI0aoefPmOnLkiPLz87VixQqNHDlSV1xxhSSpVq1aatasmVasWKGMjAzfveOaa67R7t27tXv3bk2aNMlvf127dtXDDz+sMWPGKD09XV999ZXGjx+vlJQUFRUVlbvO1157rW+O2OLiYk2cOFGxsbEnzGCc6fbbu3evFi1aFFCekJCg9PR0jR8/XqNHj9a///1vXXvttapevbq2b9+ujz/+2Jf9KMsll1yid955R0uWLFGdOnVUpUoV33/wSq7fk/k1ntNxbzze2rVrFRcXp8OHD+vHH3/UW2+9pX/+85+qVauWlixZosjIyFPeR4mKXNelCdX33bEuueQSvfzyy5o6dapSU1MVFhZ2wv8MnOiaKk+7Va5cWU8++aQGDRqka665RrfffrsSExP1zTff6LPPPtMzzzyjqlWr6uqrr9bjjz/uux+uWrVKM2fODOidK/mVlenTp6tKlSqKiopSSkpK0ED5dNz/r7jiCnXt2lXNmzdX9erVtWnTJv3zn/9UWlraCefL9DmZp1PWr19v/fr1s/r161tkZKTvEeqHHnrIb663wsJC+9vf/mb16tWz6OhoS09Pt/Xr1wedp/Cnn36yYcOGWUpKilWqVMlq1KhhqampNnr06ID5k4I5dOiQPfvss3bFFVdY5cqVzev1WqNGjexvf/ub7dy5M2D9kiezFi1aZE2bNvXN8zVp0iS/9Z588klr3bq1xcfHW2RkpNWvX98GDhwYMDv8li1b7LbbbvPNs5iQkGCtW7e2Rx55xLdOydNYCxcuLPU4Nm/e7JvfKCcnJ+D1n3/+2QYOHGi1atWymJgYu+qqq+y9994LOpfb/PnzffNLSeWbp/Ciiy6ySpUqWXx8vP3pT38qdS6u4x3/ZFV5z1tpWrRoYZL85vT74YcfTJLVrFkz4Emx0n7RJNixHj582J544gm79NJLLSoqyipXrmyNGze2O+64w77++mvfeqX96k2wcx3MgQMH7KGHHrILL7zQIiMjrWbNmta+fXtbvXq13zr33nuvJScnW6VKlaxOnTo2ZMiQUuepKk9dPvjgA7vyyivN6/Va7dq17Z577jnhPIUlcnNzrUWLFub1ek068TyFM2bMsObNm1tkZKTFxcXZ73//+4DZAirSNsEcX89//OMflpGRYYmJiRYZGWlJSUnWo0cPv7k6S6MgU9KUuOeee/ymePj111/tgQce8M1zVjINx4gRI/ye7jYzGzFihEmyRx991K/8wgsvNEkBdSssLLS7777b6tata1FRUXb55Zfbq6++GvA5Knn6+Nhpso61ePFi3/mvX7++/f3vf6/QPIVnqv1K7mnHL8e266uvvmoZGRlWtWpV83q9lpycbN27d7fc3FzfOqU9fbx+/Xpr06aNxcTEBGw3Pj7errzyyhPWs7SngU/13nii/ZUsJfOKdurUyZ566inf9EXHOtWnj83Kf12X9Vk5le+7kmv62Jkxdu/ebd27d/fNSXui66o811R5283s6HzA6enpFhsb65vSa+LEib7Xt27dajfffLNVr17dqlSpYtdee6198cUXQWOZ7OxsS0lJsfDwcL/jLG2ewlDe/++77z5r2bKlVa9e3bxer51//vk2YsSIoDFQaTxmp+ERJwAAHLZx40Y1bdpUS5cu1fXXX+90dQDXc8WUNAAAhNrKlSuVlpZGQAiUE5lCAAAAkCkEAAAAQSEAADgHlcxWkpSUJI/H45vTuCyrVq1SamqqoqKidP7552vatGmnv6JnEEEhAAA45+zfv1+XXnqpnnnmmXKtv2XLFl133XVq27at1q1bp/vvv1/Dhg3TSy+9dJpreuYwphAAAJzTPB6PXnnllYAfuTjWvffeq8WLF/v93vHgwYP12WeflXvieber0OTV+O9TWFgY8FODXq/3pH4iDgAANzud33l5eXnq1KmTX1nnzp01c+ZMHT582O9Xi/5bERSe5bKysgJ+DWDMmDEaO3asMxUCAOAYY0P4m9EaM+a0fedt27ZNiYmJfmWJiYkqKirSzp07VadOnVPeh9MICs9yo0aNUmZmpl8ZWUIAgFuE8uGGe0/zd57nuAC2ZATe8eX/rQgKz3J0FQMAzhWn8zuvdu3a2rZtm1/Zjh07FBEREfT3jf8bERSe44qf7O10Fc5J4SPnBZTRFs6gLdwjWFvo4K4zXxFIUWcuyPlvybGlpaVpyZIlfmUrVqxQy5Ytz4rxhBJT0gAAAAeFhXCpiF9//VXr16/X+vXrJR2dcmb9+vXKz8+XdHT4Vd++fX3rDx48WN9//70yMzO1adMmzZo1SzNnztTdd999UsftRmQKAQDAOeeTTz5RRkaG7++SsYj9+vXT7NmzVVBQ4AsQJSklJUXLli3TiBEj9OyzzyopKUlPP/20br755jNe99OFoBAAADjGqS7Ldu3aqaypmmfPnh1Qlp6erk8//fQ01spZBIUAAMAx/y1jCs8FjCkEAAAAmUIAAOAcslPuQVAIAAAcQ/exexAUAgAAx5ApdA/aAgAAAGQKAQCAc8hOuQdBIQAAcAxjCt2DAB0AAABkCgEAgHPITrkHQSEAAHAMQaF70BYAAAAgUwgAAJzDgybuQVAIAAAcQ5ele9AWAAAAIFMIAACcQ/exexAUAgAAx9Bl6R4EhQAAwDEEhe5BWwAAAIBMIQAAcA5jCt2DoBAAADiGLkv3oC0AAABAphAAADiH7JR7EBQCAADHMKbQPQjQAQAAQKYQAAA4h+yUexAUAgAAxxAUugdtAQAAADKFAADAOTxo4h4EhQAAwDF0WboHQSEAAHAMmUL3IEAHAAAAmUIAAOAcslPuQVAIAAAcQ1DoHrQFAAAAyBQCAADn8KCJexAUAgAAx9Bl6R60BQAAAMgUAgAA55Cdcg+CQgAA4BjGFLoHAToAAADIFAIAAOd4wsgVugVBIQAAcIzHQ1DoFgSFAADAMWFkCl2DMYUAAAAgUwgAAJxD97F7EBQCAADH8KCJe9B9DAAAADKFAADAOXQfuwdBIQAAcAzdx+5B9zEAAADIFAIAAOfQfeweBIUAAMAxdB+7B93HAAAAIFMIAACcQ/exexAUAgAAx/Dbx+5BUAgAABxDptA9GFMIAAAAMoUAAMA5PH3sHgSFAADAMXQfuwfdxwAAACBTCAAAnEP3sXsQFAIAAMfQfewedB8DAIBz0pQpU5SSkqKoqCilpqbqvffeK3P9uXPn6tJLL1VMTIzq1KmjAQMGaNeuXWeotqcfQSEAAHCMJ8wTsqUiFixYoOHDh2v06NFat26d2rZtqy5duig/Pz/o+u+//7769u2rgQMHasOGDVq4cKHWrFmjQYMGheI0uAJBIQAAcIzH4wnZUhGTJk3SwIEDNWjQIDVp0kTZ2dmqV6+epk6dGnT9Dz/8UA0aNNCwYcOUkpKiq666SnfccYc++eSTUJwGVyAoBAAAZ4XCwkLt3bvXbyksLAxY79ChQ1q7dq06derkV96pUyetXr066LZbt26trVu3atmyZTIzbd++XYsWLdL1119/Wo7FCQSFAADAMWFhnpAtWVlZiouL81uysrIC9rlz504VFxcrMTHRrzwxMVHbtm0LWs/WrVtr7ty56tmzpyIjI1W7dm1Vq1ZNkydPPi3nxQkEhQAAwDGh7D4eNWqU9uzZ47eMGjWqzH0fy8xK7YbeuHGjhg0bpoceekhr167Vm2++qS1btmjw4MEhPR9OYkoaAADgmFDOU+j1euX1ek+4Xnx8vMLDwwOygjt27AjIHpbIyspSmzZtdM8990iSmjdvrtjYWLVt21aPPPKI6tSpc+oH4DAyhQAA4JwSGRmp1NRU5eTk+JXn5OSodevWQd/z22+/KSzMP2wKDw+XdDTDeDYgUwgAABzj1OTVmZmZ6tOnj1q2bKm0tDRNnz5d+fn5vu7gUaNG6YcfftCcOXMkSd26ddPtt9+uqVOnqnPnziooKNDw4cPVqlUrJSUlOXIMoUZQCAAAHONxqM+yZ8+e2rVrl8aPH6+CggI1a9ZMy5YtU3JysiSpoKDAb87C/v37a9++fXrmmWc0cuRIVatWTe3bt9fEiROdOYDTwGNnS84TJ6X4yd5OV+GcFD5yXkAZbeEM2sI9grWFDp49vxbxXyWq5hnb1acXBB/DdzIu/2Z7yLZ1LiJTCAAAHMNvH7sHQSEAAHBMKJ8+xqnh6WMAAACQKQQAAM4Jo/vYNQgKAQCAY+g+dg+6jwEAAECmEAAAOIenj92DoBAAADiG7mP3ICgEAACOIVPoHowpBAAAAJlCAADgHLqP3YOgEAAAOIbuY/eg+xgAAABkCgEAgHM8YeSn3IKgEAAAOIYxhe5BeA4AAAAyhQAAwEE8aOIaBIUAAMAxdB+7B93HAAAAIFMIAACcw9PH7kFQCAAAHMPk1e5BUAgAAJzDmELXIGcLAAAAMoUAAMA5jCl0D4JCAADgGMYUugfhOQAAAMgUAgAA5zB5tXsQFAIAAOcQFLoG3ccAAAAgUwgAAJzj8ZCfcguCQgAA4BjGFLoH4TkAAADIFAIAAOeQKXQPgkIAAOAcxhS6BkEhAABwDJlC9yA8BwAAAJlCAADgHDKF7kFQCAAAHOPxEBS6Bd3HAAAAIFMIAAAcFEZ+yi0ICgEAgGMYU+gehOcAAAAgUwgAAJzDgybuQVAIAAAc42FMoWvQEgAAACBTCAAAnMODJu5BUAgAAJzDmELXICgEAACOIVPoHowpBAAAAJlCAADgHJ4+dg+CQgAA4BjmKXQPwnMAAACQKQQAAA7iQRPXICgEAACOYUyhe9ASAAAAIFMIAACcw4Mm7kFQCAAAHMPk1e5B9zEAAADIFAIAAAfRfewaBIUAAMAxdB+7B0EhAABwDjGhazCmEAAAAGQKAQCAgxhT6BpkCgEAgGM8ntAtFTVlyhSlpKQoKipKqampeu+998pcv7CwUKNHj1ZycrK8Xq8aNmyoWbNmneSRuw+ZQgAAcM5ZsGCBhg8frilTpqhNmzZ67rnn1KVLF23cuFH169cP+p4ePXpo+/btmjlzpi644ALt2LFDRUVFZ7jmpw9BIQAAcI5DTx9PmjRJAwcO1KBBgyRJ2dnZWr58uaZOnaqsrKyA9d98802tWrVK//73v1WjRg1JUoMGDc5klU87uo8BAIBjQtl9XFhYqL179/othYWFAfs8dOiQ1q5dq06dOvmVd+rUSatXrw5az8WLF6tly5Z67LHHVLduXV100UW6++67deDAgdNyXpxAUAgAAM4KWVlZiouL81uCZf127typ4uJiJSYm+pUnJiZq27ZtQbf973//W++//76++OILvfLKK8rOztaiRYt05513npZjcQLdxwAAwDkhfPp41KhRyszM9Cvzer1l7Np/32YWUFbiyJEj8ng8mjt3ruLi4iQd7YLu3r27nn32WUVHR59i7Z1HUAgAAJwTwj5Lr9dbZhBYIj4+XuHh4QFZwR07dgRkD0vUqVNHdevW9QWEktSkSROZmbZu3aoLL7zw1CrvAnQfAwAAx3g8npAt5RUZGanU1FTl5OT4lefk5Kh169ZB39OmTRv9+OOP+vXXX31lmzdvVlhYmM4777yTO3iXISgEAADnnMzMTM2YMUOzZs3Spk2bNGLECOXn52vw4MGSjnZF9+3b17d+7969VbNmTQ0YMEAbN27Uu+++q3vuuUe33XbbWdF1LNF9DAAAnOTQL5r07NlTu3bt0vjx41VQUKBmzZpp2bJlSk5OliQVFBQoPz/ft37lypWVk5Ojv/zlL2rZsqVq1qypHj166JFHHnGk/qcDQSEAAHCMk79yN3ToUA0dOjToa7Nnzw4oa9y4cUCX89mE7mMAAACQKQQAAA5y6BdNEIigEAAAOIeY0DXoPgYAAACZQgAA4JyKzC+I04ugEAAAOIeY0DXoPgYAAACZQgAA4BwPTx+7BkEhAABwDjGhaxAUAgAA5/CgiWswphAAAABkCgEAgHNIFLoHQSEAAHAOD5q4Bt3HAAAAIFMIAACcQ/exexAUAgAA5xAVugbdxwAAACBTCAAAnEOi0D0ICgEAgHN4+tg16D4GAAAAmUIAAOAg+o9dg6AQAAA4hpjQPQgKAQCAc4gKXYMxhQAAACBTCAAAnOMhPeUaBIUAAMA5dB+7BvE5AAAAyBQCAAAHkSh0DY+ZmdOVAAAA56biJ3uHbFvhI+eFbFvnIjKFZ7nCwkIVFhb6lXm9Xnm9XodqBAAA3IgxhWe5rKwsxcXF+S1ZWVlOVwsAgKPCPKFbcEroPj7LkSkEALhZcfafQrat8OEvhGxb5yK6j89yBIAAAKA8CArPcaEc4IvyCzYYmrZwBm3hHsHaYixz2Dli7JnsRKTb1zUICgEAgHP4SRPXICgEAADOIRvsGoTnAAAAIFMIAAAcxJhC1yAoBAAAzmFMoWvQEgAAACBTCAAAHET3sWsQFAIAAOfw9LFr0H0MAAAAMoUAAMBBYeSn3IKgEAAAOIfuY9cgPAcAAACZQgAA4CC6j12DoBAAADiH7mPXICgEAADOISh0DXK2AAAAIFMIAAAcxJhC1yAoBAAAzqH72DUIzwEAAECmEAAAOMcTRqbQLQgKAQCAczx0WroFLQEAAAAyhQAAwEF0H7sGQSEAAHAOTx+7Bt3HAAAAIFMIAAAcxOTVrkFQCAAAnEP3sWsQFAIAAOcQFLoGOVsAAAAQFAIAAAeFhYVuqaApU6YoJSVFUVFRSk1N1XvvvVeu933wwQeKiIjQZZddVuF9uhlBIQAAcI7HE7qlAhYsWKDhw4dr9OjRWrdundq2basuXbooPz+/zPft2bNHffv2VYcOHU7lqF2JoBAAAJxzJk2apIEDB2rQoEFq0qSJsrOzVa9ePU2dOrXM991xxx3q3bu30tLSzlBNzxyCQgAA4JwwT8iWwsJC7d27128pLCwM2OWhQ4e0du1aderUya+8U6dOWr16dalVff755/Xtt99qzJgxIT8NbkBQCAAAnOMJC9mSlZWluLg4vyUrKytglzt37lRxcbESExP9yhMTE7Vt27ag1fz666913333ae7cuYqIODsnbzk7jwoAAJxzRo0apczMTL8yr9db6vqe48YhmllAmSQVFxerd+/eGjdunC666KLQVNaFCAoBAIBzwkI3T6HX6y0zCCwRHx+v8PDwgKzgjh07ArKHkrRv3z598sknWrdune666y5J0pEjR2RmioiI0IoVK9S+ffvQHISDCAoBAIBzHJi8OjIyUqmpqcrJydFNN93kK8/JydHvf//7gPWrVq2q//3f//UrmzJlit5++20tWrRIKSkpp73OZwJBIQAAOOdkZmaqT58+atmypdLS0jR9+nTl5+dr8ODBko52Rf/www+aM2eOwsLC1KxZM7/316pVS1FRUQHl/80ICgEAgHNOYtLpUOjZs6d27dql8ePHq6CgQM2aNdOyZcuUnJwsSSooKDjhnIVnG4JCAADgHAd/+3jo0KEaOnRo0Ndmz55d5nvHjh2rsWPHhr5SDiIoBAAAznEwKIQ/5ikEAAAAmUIAAOAgD/kptyAoBAAAzqH32DUIzwEAAECmEAAAOIgHTVyDoBAAADiHoNA16D4GAAAAmUIAAOAgMoWuQVAIAAAcRFDoFnQfAwAAgEwhAABwEIlC1yAoBAAAzmFMoWsQFAIAAOcQFLoGYwoBAABAphAAADiITKFrEBQCAAAHERS6Bd3HAAAAIFMIAAAcRKLQNQgKAQCAcxhT6Bp0HwMAAIBMIQAAcBCZQtcgKAQAAA4iKHQLuo8BAABAphAAADiI7mPXICgEAADOISh0DYJCAADgHGJC12BMIQAAAMgUAgAAB9F97BoEhQAAwEEEhW5B9zEAAADIFAIAAAfRfewaBIUAAMA5BIWuQfcxAAAAyBQCAAAHkSh0DYJCAADgHLqPXYPuYwAAAJApBAAATiJT6BYEhQAAwDl0H7sGQSEAAHAOQaFrMKYQAAAAZAoBAICDyBS6BplCAAAAEBQCAACA7mMAAOAkuo9dg6AQAAA4h6DQNeg+BgAAAJlCAADgIDKFrkFQCAAAHERQ6BZ0HwMAAIBMIQAAcBDdx65BUAgAAJzjodPSLQgKAQCAg8gUugXhOQAAAMgUAgAABzGm0DUICgEAgHMYU+gatAQAAADIFAIAACfRfewWBIUAAMA5jCl0DbqPAQAAQKYQAAA4ifyUWxAUAgAA59B97BqE5wAAACAoBAAADvJ4QrdU0JQpU5SSkqKoqCilpqbqvffeK3Xdl19+WR07dlRCQoKqVq2qtLQ0LV++/FSO3HUICgEAgIM8IVzKb8GCBRo+fLhGjx6tdevWqW3bturSpYvy8/ODrv/uu++qY8eOWrZsmdauXauMjAx169ZN69atq/ghuxRjCgEAgHMc+kWTSZMmaeDAgRo0aJAkKTs7W8uXL9fUqVOVlZUVsH52drbf3xMmTNBrr72mJUuWqEWLFmeiyqcdmUIAAHBWKCws1N69e/2WwsLCgPUOHTqktWvXqlOnTn7lnTp10urVq8u1ryNHjmjfvn2qUaNGSOruBgSFAADAOSEcU5iVlaW4uDi/JVjWb+fOnSouLlZiYqJfeWJiorZt21auaj/55JPav3+/evToEZLT4AZ0HwMAAAeFbkqaUaNGKTMz06/M6/WWvufjHk4xs4CyYObPn6+xY8fqtddeU61atU6usi5EUAgAAM4KXq+3zCCwRHx8vMLDwwOygjt27AjIHh5vwYIFGjhwoBYuXKhrrrnmlOrrNnQfAwAA53jCQreUU2RkpFJTU5WTk+NXnpOTo9atW5f6vvnz56t///6aN2+err/++pM+ZLciUwgAABxTnu7a0yEzM1N9+vRRy5YtlZaWpunTpys/P1+DBw+WdLQr+ocfftCcOXMkHQ0I+/btq6eeekpXXnmlL8sYHR2tuLg4R44h1AgKAQDAOadnz57atWuXxo8fr4KCAjVr1kzLli1TcnKyJKmgoMBvzsLnnntORUVFuvPOO3XnnXf6yvv166fZs2ef6eqfFgSFAADAQc799vHQoUM1dOjQoK8dH+i98847p79CDiMoBAAAznFo8moEoiUAAABAphAAADjJue5j+CMoBAAAznHo6WMEIigEAADOYUyha9ASAAAAIFMIAACcRPexWxAUAgAA5zCm0DXoPgYAAACZQgAA4CAeNHENgkIAAOAguo/dgvAcAAAAZAoBAICDeNDENQgKAQCAg+i0dAtaAgAAAGQKAQCAg+g+dg2CQgAA4ByCQtcgKAQAAA5iJJtb0BIAAAAgUwgAABxE97FrEBQCAAAHERS6Bd3HAAAAIFMIAAAcRPexaxAUAgAABxEUugXdxwAAACBTCAAAHET3sWsQFAIAAAfRaekWtAQAAADIFAIAAAfRfewaBIUAAMBBBIVuQVAIAACcQ6bQNRhTCAAAADKFAADASWQK3YKgEAAAOIfuY9eg+xgAAABkCgEAgJPIFLoFQSEAAHAO3ceuQfcxAAAAyBQCAAAnkZ9yC4JCAADgHLqPXYPwHAAAAGQKAQCAk8gUugVBIQAAcBBBoVsQFAIAAMd4GFPoGowpBAAAAJlCAADgJDKFbkFQCAAAnEP3sWvQfQwAAAAyhQAAwElkCt2CoBAAADjHQ6elW9ASAAAAIFMIAACcRPexWxAUAgAA5/D0sWvQfQwAAAAyhQAAwElkCt2CoBAAADiH7mPXICgEAAAOIih0C8YUAgAAgEwhAABwEN3HrkFQCAAAHERQ6BZ0HwMAAIBMIQAAcBC/fewatAQAAHCQJ4RLxUyZMkUpKSmKiopSamqq3nvvvTLXX7VqlVJTUxUVFaXzzz9f06ZNq/A+3YygEAAAnHMWLFig4cOHa/To0Vq3bp3atm2rLl26KD8/P+j6W7Zs0XXXXae2bdtq3bp1uv/++zVs2DC99NJLZ7jmpw9BIQAAcI7HE7qlAiZNmqSBAwdq0KBBatKkibKzs1WvXj1NnTo16PrTpk1T/fr1lZ2drSZNmmjQoEG67bbb9MQTT4TiLLiCx8zM6UoAAIBz1MFdodtWVM1yrXbo0CHFxMRo4cKFuummm3zlf/3rX7V+/XqtWrUq4D1XX321WrRooaeeespX9sorr6hHjx767bffVKlSpVOvv8N40AQAAJwVCgsLVVhY6Ffm9Xrl9Xr9ynbu3Kni4mIlJib6lScmJmrbtm1Bt71t27ag6xcVFWnnzp2qU6dOCI7AWXQfn2MKCws1duzYgA8Nzjzawj1oC/egLc5BUTVDtmRlZSkuLs5vycrKKnXXnuO6nM0soOxE6wcr/29FUHiOKSws1Lhx47jhugBt4R60hXvQFjgVo0aN0p49e/yWUaNGBawXHx+v8PDwgKzgjh07ArKBJWrXrh10/YiICNWsWb5ua7cjKAQAAGcFr9erqlWr+i3Hdx1LUmRkpFJTU5WTk+NXnpOTo9atWwfddlpaWsD6K1asUMuWLc+K8YQSQSEAADgHZWZmasaMGZo1a5Y2bdqkESNGKD8/X4MHD5Z0NOvYt29f3/qDBw/W999/r8zMTG3atEmzZs3SzJkzdffddzt1CCHHgyYAAOCc07NnT+3atUvjx49XQUGBmjVrpmXLlik5OVmSVFBQ4DdnYUpKipYtW6YRI0bo2WefVVJSkp5++mndfPPNTh1CyBEUnmO8Xq/GjBkTNJ2OM4u2cA/awj1oC5xJQ4cO1dChQ4O+Nnv27ICy9PR0ffrpp6e5Vs5hnkIAAAAwphAAAAAEhQAAABBBIQAAAERQCAAAABEUAgAAQASFAAAAEEEhAAAARFAIAAAAERQCAABABIUAAAAQQSEAAAAk/R+tPpHK+dQBsQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -735,7 +735,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGxCAYAAACwbLZkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAvhElEQVR4nO3de1TVdb7/8dcWNpuLgomKgoroKaUxLXFSdMzUwKBMp1xankKzOoNWHiWd0ZxKnM5wKsfpJlqpOY7moYvZjVEobbTEMsPOVJ7pZqEJMeAkpokb/Pz+8Lf3tN3ctmEfxedjLZZrf/h8P9/397b3y+9l4zDGGAEAAFjSynYBAADg3EYYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGDlDrVy5Ug6Ho86fWbNm6csvv5TD4dDKlStPax2TJ09W9+7dT+s8TtX+/fs1f/587dq167SM79kGX3755WkZ/4fmz58vh8OhioqKZh/zhy6//HJdfvnlpzTesWPHlJmZqc6dOysoKEgXX3zxjy+yCS6//HL16dPnJ5nXybZt26b58+fr22+/tTL/M8FPeRw0p+7du2vy5Mne12+++aYcDofefPNNb1t+fr7mz5/fpOlxegXbLgANe/rpp9W7d2+fttjYWMXExKioqEg9e/a0VJl9+/fvV3Z2trp3735aPhivuuoqFRUVqXPnzs0+ti25ubmnPO2SJUv0xBNP6LHHHlNSUpJat27djJWdmbZt26bs7GxNnjxZbdu2tV0OfoT+/furqKhIF154obctPz9fixcvrjOQvPjii4qMjPwJKzy3EUbOcH369NGAAQPq/N2gQYN+4mrODd9//71CQ0PVoUMHdejQodnGPXLkiMLDw5ttvFPxwzfiQH344YcKCwvTHXfc0YwVtXxnwnZviDFGR48eVVhYmO1STqvIyMiA3jMvueSS01gNTsZlmrNUXZdpPKflP/roI91www2KiopSTEyMpkyZooMHD/pMv3jxYl122WXq2LGjIiIidNFFF+nBBx+U2+0+pXo8p9K3bt2qQYMGKSwsTHFxcbrnnntUW1vr0/fAgQOaNm2a4uLiFBISoh49emjevHmqrq726ffcc89p4MCBioqKUnh4uHr06KEpU6ZIOnHK9ec//7kk6eabb/Zewvrh/3Dee+89XXPNNWrXrp1CQ0N1ySWX6Nlnn/WZh+cUdEFBgaZMmaIOHTooPDxc1dXV9Z6eXrFihfr166fQ0FC1a9dOv/zlL7V7926fPpMnT1br1q31t7/9TampqWrTpo1GjhzZ6Hrcu3evrr32WkVGRioqKko33nij/vGPf/j1y8vLU3JysiIiItS6dWuNGjVKxcXFjY5f12WaY8eO6f7771fv3r3lcrnUoUMH3XzzzT7zdTgcWrZsmb7//nvvuvbsew1tp4YEug82177V0CXOH+5D8+fP1+zZsyVJCQkJ3uX+4Wn+kzW03ZuynmfPnq2oqCif5brzzjvlcDj00EMPedsqKyvVqlUrPfbYY5Kko0eP6q677tLFF1+sqKgotWvXTsnJyXrppZfqXMY77rhDS5cuVWJiolwul/70pz9JkrZv364hQ4YoNDRUsbGxmjt3bkDvCe+8845Gjx6t6OhohYaGqmfPnpoxY4ZPn7feeksjR45UmzZtFB4ersGDB+u1117z6eM59jZv3qypU6eqffv2io6O1rXXXqv9+/f79HW73fr1r3+tTp06KTw8XL/4xS/07rvv+tV28mWayZMna/Hixd514vnxHO91XaYpKSnRjTfeqI4dO8rlcikxMVF/+MMfdPz4cW8fz/61cOFCLVq0SAkJCWrdurWSk5O1ffv2Jq/Lc47BGenpp582ksz27duN2+32+THGmD179hhJ5umnn/ZOc9999xlJplevXubee+81hYWFZtGiRcblcpmbb77ZZ/yZM2eaJUuWmA0bNphNmzaZP/7xj6Z9+/Z+/SZNmmTi4+MbrXfYsGEmOjraxMbGmkcffdRs3LjRTJ8+3Ugyt99+u7ff999/b/r27WsiIiLMwoULTUFBgbnnnntMcHCwSU9P9/bbtm2bcTgc5vrrrzf5+flm06ZN5umnnzY33XSTMcaYgwcPetfRb3/7W1NUVGSKiorM3r17jTHGbNq0yYSEhJihQ4eavLw8s2HDBjN58mS/deYZIy4uzvzHf/yH+ctf/mKef/55U1NT4/3dnj17vP1///vfG0nmhhtuMK+99ppZtWqV6dGjh4mKijKffPKJz3pzOp2me/fuJicnx7zxxhtm48aN9a4/z7aLj483s2fPNhs3bjSLFi0yERER5pJLLjHHjh3z9v2v//ov43A4zJQpU8yrr75q1q1bZ5KTk01ERIT56KOP/MY8eTsNGzbM+7q2ttZceeWVJiIiwmRnZ5vCwkKzbNkyExcXZy688EJz5MgRY4wxRUVFJj093YSFhXnXdXl5eaPbqSFN3Qebe9+q69jxkGTuu+8+Y4wxe/fuNXfeeaeRZNatW+dd7oMHD9a7TPVt96au5w0bNhhJZtu2bd4xe/fubcLCwkxKSoq3LS8vz0gyH3/8sTHGmG+//dZMnjzZ/PnPfzabNm0yGzZsMLNmzTKtWrUyf/rTn/yWMS4uzvTt29c888wzZtOmTebDDz80H330kQkPDzcXXnihWbt2rXnppZfMqFGjTLdu3fyOg7ps2LDBOJ1O07dvX7Ny5UqzadMms2LFCnP99dd7+7z55pvG6XSapKQkk5eXZ9avX29SU1ONw+Ew//M//+Pt5zn2evToYe68806zceNGs2zZMnPeeeeZ4cOH+61zh8NhZs+ebQoKCsyiRYtMXFyciYyMNJMmTfL227x5s5FkNm/ebIwx5rPPPjPjxo0zkrzbtqioyBw9etQYY0x8fLzP9OXl5SYuLs506NDBLF261GzYsMHccccdRpKZOnWqt59n/+revbu58sorzfr168369evNRRddZM477zzz7bffNrgez1WEkTOU52Cs68ftdjcYRh588EGfsaZNm2ZCQ0PN8ePH65xXbW2tcbvdZtWqVSYoKMgcOHDA+7tAwogk89JLL/m033bbbaZVq1bmq6++MsYYs3TpUiPJPPvssz79HnjgASPJFBQUGGOMWbhwoZHU4IG7Y8eOej9UevfubS655BJvePO4+uqrTefOnU1tba0x5l/rOSMjw2+Mk8PIP//5TxMWFubzwWaMMSUlJcblcpmJEyd62yZNmmQkmRUrVtRb/w95tt3MmTN92tesWWMkmdWrV3vnFRwcbO68806ffocOHTKdOnUy48eP9xvzh04OI2vXrjWSzAsvvODTz7Nuc3NzfZYpIiLCp19TtlNTNLQPNve+1dQwYowxDz30UJM+iD3q2+5NXc+HDx82ISEhZsGCBcYYY/bt22ckmd/85jcmLCzM+0F52223mdjY2HrrqKmpMW6329xyyy3mkksu8VvGqKgon3VsjDETJkwwYWFhpqyszGec3r17N2kd9OzZ0/Ts2dN8//339fYZNGiQ6dixozl06JDPPPr06WO6dOnifY/yHHvTpk3zmf7BBx80kkxpaakxxpjdu3c3eNw0FEaMMeb222/3O0Y8Tg4jc+bMMZLMO++849Nv6tSpxuFwmL///e/GmH/tXxdddJGpqanx9nv33XeNJLN27dp618+5jMs0Z7hVq1Zpx44dPj/BwQ3f6nPNNdf4vO7bt6+OHj2q8vJyb1txcbGuueYaRUdHKygoSE6nUxkZGaqtrdUnn3xySrW2adPGb94TJ07U8ePHtWXLFknSpk2bFBERoXHjxvn085wOfeONNyTJewlm/PjxevbZZ/X11183uY7PPvtM//d//6d///d/lyTV1NR4f9LT01VaWqq///3vPtNcd911jY5bVFSk77//3u/UbdeuXTVixAhv7YGO+0Oemj3Gjx+v4OBgbd68WZK0ceNG1dTUKCMjw2e5QkNDNWzYsAYvIdTl1VdfVdu2bTV69Gif8S6++GJ16tSp0fF+zHYKZB9szn3rp3Dydm/qeg4PD1dycrJef/11SVJhYaHatm2r2bNn69ixY3rrrbckSa+//rquuOIKn3k899xzGjJkiFq3bq3g4GA5nU4tX77c7xKiJI0YMULnnXeeT9vmzZs1cuRIxcTEeNuCgoI0YcKERpf3k08+0eeff65bbrlFoaGhdfY5fPiw3nnnHY0bN87n5uegoCDddNNN2rdvn99xWdd7mSR99dVX3pql+o+b5rRp0yZdeOGFuvTSS33aJ0+eLGOMNm3a5NN+1VVXKSgoqN7a4YswcoZLTEzUgAEDfH4aEx0d7fPa5XJJOnFjpnTiuufQoUP19ddf65FHHtHWrVu1Y8cO7/VTT79A/fBNzKNTp06STlzj9vzbqVMnv0dOO3bsqODgYG+/yy67TOvXr/d+8Hbp0kV9+vTR2rVrG63jm2++kSTNmjVLTqfT52fatGmS5PcIbVOemPHUVlff2NhY7+89wsPDA74b37O+PIKDgxUdHe0d27NsP//5z/2WLS8vL+BHg7/55ht9++23CgkJ8RuvrKys0fFOdTsFug825751utW13QNZz1dccYW2b9+uw4cP6/XXX9eIESMUHR2tpKQkvf7669qzZ4/27NnjE0bWrVun8ePHKy4uTqtXr1ZRUZF27NihKVOm6OjRo3411rUPe9bfyepqO5nnvpcuXbrU2+ef//ynjDH1Hj+eGn6osfcyT//6jpvmVFlZ2ay1wxdP05yD1q9fr8OHD2vdunWKj4/3tv/Y7+vwfFD+UFlZmaR/HZjR0dF65513ZIzx+dAoLy9XTU2N2rdv720bM2aMxowZo+rqam3fvl05OTmaOHGiunfvruTk5Hrr8Iwxd+5cXXvttXX26dWrl8/rkz/A6uJZhtLSUr/f7d+/36f2po55srKyMsXFxXlf19TUqLKy0jtvzzyef/55n213qjw3Bm7YsKHO37dp06bRMU5lOwW6DzbnvuX5n/vJN0w3V1ipa7sHsp5Hjhype+65R1u2bNEbb7yh++67z9teUFCghIQE72uP1atXKyEhQXl5eT7zP3kZG6oxOjrau05/qK62k3meOtu3b1+9fc477zy1atWq3uNHkt8x1BjPtq/vuGlO0dHRzVo7fHFm5BzkeSPyJHXpxON9Tz311I8a99ChQ3r55Zd92p555hm1atVKl112maQTb6Dfffed1q9f79Nv1apV3t+fzOVyadiwYXrggQckyfvUSH3/0+jVq5fOP/98ffDBB35nlTw/TfmQPVlycrLCwsK0evVqn/Z9+/Zp06ZNTXpapjFr1qzxef3ss8+qpqbG+wTMqFGjFBwcrM8//7zeZQvE1VdfrcrKStXW1tY51smhrSH1bae6BLoPNue+FRMTo9DQUP3v//6vT7+6njxprv/NBrKeL730UkVGRurhhx9WWVmZUlJSJJ04Y1JcXKxnn31WF154ofd/5NKJ9RkSEuITMsrKyupcpvoMHz5cb7zxhk/wq62tVV5eXqPTXnDBBerZs6dWrFhRbwCKiIjQwIEDtW7dOp/1efz4ca1evVpdunTRBRdc0OR6JXmPi/qOm8YEsn1Hjhypjz/+WO+//75P+6pVq+RwODR8+PAmVo26cGbkHJSSkqKQkBDdcMMN+vWvf62jR49qyZIl+uc///mjxo2OjtbUqVNVUlKiCy64QPn5+Xrqqac0depUdevWTZKUkZGhxYsXa9KkSfryyy910UUX6a233tLvf/97paene08933vvvdq3b59GjhypLl266Ntvv9Ujjzwip9OpYcOGSZJ69uypsLAwrVmzRomJiWrdurViY2MVGxurJ554QmlpaRo1apQmT56suLg4HThwQLt379b777+v5557LuDla9u2re655x7dfffdysjI0A033KDKykplZ2crNDTU+z/YH2PdunUKDg5WSkqKPvroI91zzz3q16+fxo8fL+nE44YLFizQvHnz9MUXX+jKK6/Ueeedp2+++UbvvvuuIiIilJ2d3eT5XX/99VqzZo3S09P1n//5n7r00kvldDq1b98+bd68WWPGjNEvf/nLeqdvynaqS6D7YHPuWw6HQzfeeKNWrFihnj17ql+/fnr33Xf1zDPP+M33oosukiQ98sgjmjRpkpxOp3r16hVwmA1kPQcFBWnYsGF65ZVXlJCQ4P1iwyFDhsjlcumNN97Q9OnTfca/+uqrtW7dOk2bNk3jxo3T3r179bvf/U6dO3fWp59+2qQaf/vb3+rll1/WiBEjdO+99yo8PFyLFy/W4cOHmzT94sWLNXr0aA0aNEgzZ85Ut27dVFJSoo0bN3rDQk5OjlJSUjR8+HDNmjVLISEhys3N1Ycffqi1a9cGfDYxMTFRN954ox5++GE5nU5dccUV+vDDD7Vw4cImXSL1bN8HHnhAaWlpCgoKUt++fRUSEuLXd+bMmVq1apWuuuoqLViwQPHx8XrttdeUm5urqVOnBhykcBKbd8+ifp67yXfs2FHn7xt6muYf//hHnWP98G74V155xfTr18+EhoaauLg4M3v2bPOXv/zF727zQJ6m+dnPfmbefPNNM2DAAONyuUznzp3N3Xff7fdES2VlpcnMzDSdO3c2wcHBJj4+3sydO9f7pIAxxrz66qsmLS3NxMXFmZCQENOxY0eTnp5utm7d6jPW2rVrTe/evY3T6fR7EuKDDz4w48ePNx07djROp9N06tTJjBgxwixdutRv3dS1nutab8YYs2zZMtO3b18TEhJioqKizJgxY3weqfWst5OfPGmIZ9vt3LnTjB492rRu3dq0adPG3HDDDeabb77x679+/XozfPhwExkZaVwul4mPjzfjxo0zr7/+ut+YP3Ty0zTGGON2u83ChQu9+0Pr1q1N7969za9+9Svz6aefNrhMTd1OdWnqPtjc+5YxJx4Nv/XWW01MTIyJiIgwo0ePNl9++aXfPmSMMXPnzjWxsbGmVatWfrWdrKHt3tT1bIwxjzzyiJFkbrvtNp/2lJQUI8m8/PLLfuP/93//t+nevbtxuVwmMTHRPPXUU3XuAzrpkegfevvtt82gQYOMy+UynTp1MrNnzzZPPvlkk58oKioqMmlpaSYqKsq4XC7Ts2dPvyddtm7dakaMGGEiIiJMWFiYGTRokHnllVd8+tR3XNb1REx1dbW56667TMeOHU1oaKgZNGiQKSoq8nsapr5pb731VtOhQwfjcDh8lvPk6Y0x5quvvjITJ0400dHRxul0ml69epmHHnrI+3SeMf96b37ooYf81k9d+xdOcBhjzE8XfdBSXX755aqoqNCHH35ouxQAwFmGe0YAAIBVhBEAAGAVl2kAAIBVnBkBAABWEUYAAIBVhBEAAGDVWfGlZ8ePH9f+/fvVpk2bU/qKbQAA8NMzxujQoUOKjY1Vq1b1n/84K8LI/v371bVrV9tlAACAU7B3794G/5DiWRFGPF+9vHfv3oD/CirOLm63WwUFBUpNTZXT6bRdDoDTgOP83FFVVaWuXbs2+icUzoow4rk0ExkZSRhp4dxut/dPsPMmBbRMHOfnnsZuseAGVgAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFgVcBjZsmWLRo8erdjYWDkcDq1fv77Raf76178qKSlJoaGh6tGjh5YuXXoqtQIAgBYo4DBy+PBh9evXT48//niT+u/Zs0fp6ekaOnSoiouLdffdd2v69Ol64YUXAi4WAAC0PAH/oby0tDSlpaU1uf/SpUvVrVs3Pfzww5KkxMREvffee1q4cKGuu+66QGcPAABamNP+V3uLioqUmprq0zZq1CgtX75cbre7zr/YWF1drerqau/rqqoqSSf+0qPb7T69BcMqz/ZlOwMtF8f5uaOp2/i0h5GysjLFxMT4tMXExKimpkYVFRXq3Lmz3zQ5OTnKzs72ay8oKFB4eHiz1jdm7NhmHQ8/jlPSGNtFwMdLTbgvDDgVhYWFtkvAaXbkyJEm9TvtYUSSHA6Hz2tjTJ3tHnPnzlVWVpb3dVVVlbp27arU1FRFRkaevkIB+ElPT7ddAloYt9utwsJCpaSk1Hl2HC2H58pGY057GOnUqZPKysp82srLyxUcHKzo6Og6p3G5XHK5XH7tTqeTHRf4iXHM4XThPb3la+r2Pe3fM5KcnOx3Kq6goEADBgxgJwQAAIGHke+++067du3Srl27JJ14dHfXrl0qKSmRdOISS0ZGhrd/ZmamvvrqK2VlZWn37t1asWKFli9frlmzZjXPEgAAgLNawJdp3nvvPQ0fPtz72nNvx6RJk7Ry5UqVlpZ6g4kkJSQkKD8/XzNnztTixYsVGxurRx99lMd6AQCApFMII5dffrn3BtS6rFy50q9t2LBhev/99wOdFQAAOAfwt2kAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWnVIYyc3NVUJCgkJDQ5WUlKStW7c22H/NmjXq16+fwsPD1blzZ918882qrKw8pYIBAEDLEnAYycvL04wZMzRv3jwVFxdr6NChSktLU0lJSZ3933rrLWVkZOiWW27RRx99pOeee047duzQrbfe+qOLBwAAZ7+Aw8iiRYt0yy236NZbb1ViYqIefvhhde3aVUuWLKmz//bt29W9e3dNnz5dCQkJ+sUvfqFf/epXeu+993508QAA4OwXHEjnY8eOaefOnZozZ45Pe2pqqrZt21bnNIMHD9a8efOUn5+vtLQ0lZeX6/nnn9dVV11V73yqq6tVXV3tfV1VVSVJcrvdcrvdgZTcKGezjga0PM19zAGefYp9q+Vr6jYOKIxUVFSotrZWMTExPu0xMTEqKyurc5rBgwdrzZo1mjBhgo4ePaqamhpdc801euyxx+qdT05OjrKzs/3aCwoKFB4eHkjJjRrTrKMBLU9+fr7tEtBCFRYW2i4Bp9mRI0ea1C+gMOLhcDh8Xhtj/No8Pv74Y02fPl333nuvRo0apdLSUs2ePVuZmZlavnx5ndPMnTtXWVlZ3tdVVVXq2rWrUlNTFRkZeSolAzhF6enptktAC+N2u1VYWKiUlBQ5nZyfbsk8VzYaE1AYad++vYKCgvzOgpSXl/udLfHIycnRkCFDNHv2bElS3759FRERoaFDh+r+++9X586d/aZxuVxyuVx+7U6nkx0X+IlxzOF04T295Wvq9g3oBtaQkBAlJSX5nVorLCzU4MGD65zmyJEjatXKdzZBQUGSTpxRAQAA57aAn6bJysrSsmXLtGLFCu3evVszZ85USUmJMjMzJZ24xJKRkeHtP3r0aK1bt05LlizRF198obffflvTp0/XpZdeqtjY2OZbEgAAcFYK+J6RCRMmqLKyUgsWLFBpaan69Omj/Px8xcfHS5JKS0t9vnNk8uTJOnTokB5//HHdddddatu2rUaMGKEHHnig+ZYCAACctRzmLLhWUlVVpaioKB08eLD5b2Ct58ZbAP/fmf8WgbOM2+1Wfn6+0tPTuWekhWvq5zd/mwYAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVpxRGcnNzlZCQoNDQUCUlJWnr1q0N9q+urta8efMUHx8vl8ulnj17asWKFadUMAAAaFmCA50gLy9PM2bMUG5uroYMGaInnnhCaWlp+vjjj9WtW7c6pxk/fry++eYbLV++XP/2b/+m8vJy1dTU/OjiAQDA2c9hjDGBTDBw4ED1799fS5Ys8bYlJiZq7NixysnJ8eu/YcMGXX/99friiy/Url27UyqyqqpKUVFROnjwoCIjI09pjHo5HM07HtDSBPYWATTK7XYrPz9f6enpcjqdtsvBadTUz++AzowcO3ZMO3fu1Jw5c3zaU1NTtW3btjqnefnllzVgwAA9+OCD+vOf/6yIiAhdc801+t3vfqewsLA6p6murlZ1dbXPwkgndmC32x1IyY3iMAAa1tzHHODZp9i3Wr6mbuOAwkhFRYVqa2sVExPj0x4TE6OysrI6p/niiy/01ltvKTQ0VC+++KIqKio0bdo0HThwoN77RnJycpSdne3XXlBQoPDw8EBKbtSYZh0NaHny8/Ntl4AWqrCw0HYJOM2OHDnSpH4B3zMiSY6TLm0YY/zaPI4fPy6Hw6E1a9YoKipKkrRo0SKNGzdOixcvrvPsyNy5c5WVleV9XVVVpa5duyo1NbX5L9MAaFB6errtEtDCuN1uFRYWKiUlhcs0LZznykZjAgoj7du3V1BQkN9ZkPLycr+zJR6dO3dWXFycN4hIJ+4xMcZo3759Ov/88/2mcblccrlcfu1Op5MdF/iJcczhdOE9veVr6vYN6NHekJAQJSUl+Z1aKyws1ODBg+ucZsiQIdq/f7++++47b9snn3yiVq1aqUuXLoHMHgAAtEABf89IVlaWli1bphUrVmj37t2aOXOmSkpKlJmZKenEJZaMjAxv/4kTJyo6Olo333yzPv74Y23ZskWzZ8/WlClT6r2BFQAAnDsCvmdkwoQJqqys1IIFC1RaWqo+ffooPz9f8fHxkqTS0lKVlJR4+7du3VqFhYW68847NWDAAEVHR2v8+PG6//77m28pAADAWSvg7xmxge8ZASw6898icJbhe0bOHU39/OZv0wAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKw6pTCSm5urhIQEhYaGKikpSVu3bm3SdG+//baCg4N18cUXn8psAQBACxRwGMnLy9OMGTM0b948FRcXa+jQoUpLS1NJSUmD0x08eFAZGRkaOXLkKRcLAABaHocxxgQywcCBA9W/f38tWbLE25aYmKixY8cqJyen3umuv/56nX/++QoKCtL69eu1a9euevtWV1erurra+7qqqkpdu3ZVRUWFIiMjAym3Uc6QkGYdD2hp3MeO2S4BLYzb7VZhYaFSUlLkdDptl4PTqKqqSu3bt9fBgwcb/PwODmTQY8eOaefOnZozZ45Pe2pqqrZt21bvdE8//bQ+//xzrV69Wvfff3+j88nJyVF2drZfe0FBgcLDwwMpuVFjmnU0oOXJz8+3XQJaqMLCQtsl4DQ7cuRIk/oFFEYqKipUW1urmJgYn/aYmBiVlZXVOc2nn36qOXPmaOvWrQoObtrs5s6dq6ysLO9rz5mR1NTUZj8zAqBh6enptktAC8OZkXNHVVVVk/oFFEY8HA6Hz2tjjF+bJNXW1mrixInKzs7WBRdc0OTxXS6XXC6XX7vT6WTHBX5iHHM4XXhPb/maun0DCiPt27dXUFCQ31mQ8vJyv7MlknTo0CG99957Ki4u1h133CFJOn78uIwxCg4OVkFBgUaMGBFICQAAoIUJ6GmakJAQJSUl+V3nKyws1ODBg/36R0ZG6m9/+5t27drl/cnMzFSvXr20a9cuDRw48MdVDwAAznoBX6bJysrSTTfdpAEDBig5OVlPPvmkSkpKlJmZKenE/R5ff/21Vq1apVatWqlPnz4+03fs2FGhoaF+7QAA4NwUcBiZMGGCKisrtWDBApWWlqpPnz7Kz89XfHy8JKm0tLTR7xwBAADwCPh7RmyoqqpSVFRUo88pn5I6brwF8ANn/lsEzjJut1v5+flKT0/nBtYWrqmf3/xtGgAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFadUhjJzc1VQkKCQkNDlZSUpK1bt9bbd926dUpJSVGHDh0UGRmp5ORkbdy48ZQLBgAALUvAYSQvL08zZszQvHnzVFxcrKFDhyotLU0lJSV19t+yZYtSUlKUn5+vnTt3avjw4Ro9erSKi4t/dPEAAODs5zDGmEAmGDhwoPr3768lS5Z42xITEzV27Fjl5OQ0aYyf/exnmjBhgu69994m9a+qqlJUVJQOHjyoyMjIQMptnMPRvOMBLU1gbxFAo9xut/Lz85Weni6n02m7HJxGTf38Dg5k0GPHjmnnzp2aM2eOT3tqaqq2bdvWpDGOHz+uQ4cOqV27dvX2qa6uVnV1tfd1VVWVpBM7sNvtDqTkRnEYAA1r7mMO8OxT7FstX1O3cUBhpKKiQrW1tYqJifFpj4mJUVlZWZPG+MMf/qDDhw9r/Pjx9fbJyclRdna2X3tBQYHCw8MDKblRY5p1NKDlyc/Pt10CWqjCwkLbJeA0O3LkSJP6BRRGPBwnXdowxvi11WXt2rWaP3++XnrpJXXs2LHefnPnzlVWVpb3dVVVlbp27arU1NTmv0wDoEHp6em2S0AL43a7VVhYqJSUFC7TtHCeKxuNCSiMtG/fXkFBQX5nQcrLy/3OlpwsLy9Pt9xyi5577jldccUVDfZ1uVxyuVx+7U6nkx0X+IlxzOF04T295Wvq9g3oaZqQkBAlJSX5nVorLCzU4MGD651u7dq1mjx5sp555hldddVVgcwSAAC0cAFfpsnKytJNN92kAQMGKDk5WU8++aRKSkqUmZkp6cQllq+//lqrVq2SdCKIZGRk6JFHHtGgQYO8Z1XCwsIUFRXVjIsCAADORgGHkQkTJqiyslILFixQaWmp+vTpo/z8fMXHx0uSSktLfb5z5IknnlBNTY1uv/123X777d72SZMmaeXKlT9+CQAAwFkt4O8ZsYHvGQEsOvPfInCW4XtGzh1N/fzmb9MAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACw6pTCSG5urhISEhQaGqqkpCRt3bq1wf5//etflZSUpNDQUPXo0UNLly49pWIBAEDLE3AYycvL04wZMzRv3jwVFxdr6NChSktLU0lJSZ399+zZo/T0dA0dOlTFxcW6++67NX36dL3wwgs/ungAAHD2cxhjTCATDBw4UP3799eSJUu8bYmJiRo7dqxycnL8+v/mN7/Ryy+/rN27d3vbMjMz9cEHH6ioqKhJ86yqqlJUVJQOHjyoyMjIQMptnMPRvOMBLU1gbxFAo9xut/Lz85Weni6n02m7HJxGTf38Dg5k0GPHjmnnzp2aM2eOT3tqaqq2bdtW5zRFRUVKTU31aRs1apSWL18ut9td545YXV2t6upq7+uDBw9Kkg4cOCC32x1IyY2KbtbRgJansrLSdgloYdxut44cOaLKykrCSAt36NAhSVJj5z0CCiMVFRWqra1VTEyMT3tMTIzKysrqnKasrKzO/jU1NaqoqFDnzp39psnJyVF2drZfe0JCQiDlAmgO7dvbrgDAWe7QoUOKioqq9/cBhREPx0mXNowxfm2N9a+r3WPu3LnKysryvj5+/LgOHDig6OjoBueDs19VVZW6du2qvXv3Nv8lOQBnBI7zc4cxRocOHVJsbGyD/QIKI+3bt1dQUJDfWZDy8nK/sx8enTp1qrN/cHCwoqPrvkjicrnkcrl82tq2bRtIqTjLRUZG8iYFtHAc5+eGhs6IeAT0NE1ISIiSkpJUWFjo015YWKjBgwfXOU1ycrJf/4KCAg0YMIBrhQAAIPBHe7OysrRs2TKtWLFCu3fv1syZM1VSUqLMzExJJy6xZGRkePtnZmbqq6++UlZWlnbv3q0VK1Zo+fLlmjVrVvMtBQAAOGsFfM/IhAkTVFlZqQULFqi0tFR9+vRRfn6+4uPjJUmlpaU+3zmSkJCg/Px8zZw5U4sXL1ZsbKweffRRXXfddc23FGgxXC6X7rvvPr/LdABaDo5znCzg7xkBAABoTvxtGgAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEZ4zc3FwlJCQoNDRUSUlJ2rp1q+2SADSjLVu2aPTo0YqNjZXD4dD69ettl4QzBGEEZ4S8vDzNmDFD8+bNU3FxsYYOHaq0tDSf76wBcHY7fPiw+vXrp8cff9x2KTjD8D0jOCMMHDhQ/fv315IlS7xtiYmJGjt2rHJycixWBuB0cDgcevHFFzV27FjbpeAMwJkRWHfs2DHt3LlTqampPu2pqanatm2bpaoAAD8Vwgisq6ioUG1trd9ffo6JifH7i88AgJaHMIIzhsPh8HltjPFrAwC0PIQRWNe+fXsFBQX5nQUpLy/3O1sCAGh5CCOwLiQkRElJSSosLPRpLyws1ODBgy1VBQD4qQTbLgCQpKysLN10000aMGCAkpOT9eSTT6qkpESZmZm2SwPQTL777jt99tln3td79uzRrl271K5dO3Xr1s1iZbCNR3txxsjNzdWDDz6o0tJS9enTR3/84x912WWX2S4LQDN58803NXz4cL/2SZMmaeXKlT99QThjEEYAAIBV3DMCAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAqv8HfuXt7v/nkGAAAAAASUVORK5CYII=\n", + "image/png": "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", "text/plain": [ "
" ] @@ -815,16 +815,16 @@ "data": { "text/plain": [ "{'actions': DeviceArray([[3, 0],\n", - " [1, 0],\n", - " [1, 0],\n", - " [1, 0],\n", - " [1, 0]], dtype=int32),\n", - " 'outcomes': DeviceArray([[0, 0, 1],\n", - " [3, 0, 0],\n", - " [1, 1, 1],\n", - " [1, 1, 0],\n", - " [1, 1, 1],\n", - " [1, 1, 1]], dtype=int32)}" + " [2, 0],\n", + " [2, 0],\n", + " [2, 0],\n", + " [2, 0]], dtype=int32),\n", + " 'outcomes': DeviceArray([[0, 0, 0],\n", + " [3, 0, 1],\n", + " [2, 1, 0],\n", + " [2, 1, 1],\n", + " [2, 1, 0],\n", + " [2, 1, 1]], dtype=int32)}" ] }, "execution_count": 30, @@ -878,8 +878,9 @@ { "data": { "text/plain": [ - "[DeviceArray([1., 0., 0., 0.], dtype=float32),\n", - " DeviceArray([0.5, 0.5], dtype=float32)]" + "[DeviceArray([0., 0., 0., 0.], dtype=float32),\n", + " DeviceArray([ 0., 3., -3.], dtype=float32),\n", + " DeviceArray([0., 0.], dtype=float32)]" ] }, "execution_count": 32, @@ -888,7 +889,7 @@ } ], "source": [ - "params['D']" + "params['C']" ] }, { @@ -919,93 +920,93 @@ { "data": { "text/plain": [ - "{'A': [DeviceArray([[[ 4.8202928e-08, -5.9604645e-08],\n", - " [-1.1346479e-13, 7.1054274e-15],\n", - " [ 0.0000000e+00, 0.0000000e+00],\n", - " [-5.6843419e-14, 0.0000000e+00]],\n", - " \n", - " [[ 0.0000000e+00, 0.0000000e+00],\n", - " [ 5.1783339e-08, -2.9082368e-09],\n", - " [ 0.0000000e+00, 0.0000000e+00],\n", - " [-5.6843419e-14, 0.0000000e+00]],\n", + "{'A': [DeviceArray([[[-5.9604645e-08, 4.8202928e-08],\n", + " [ 0.0000000e+00, 1.7053026e-13],\n", + " [ 0.0000000e+00, -1.1346479e-13],\n", + " [-3.5527137e-15, 0.0000000e+00]],\n", " \n", - " [[ 0.0000000e+00, 0.0000000e+00],\n", - " [-1.1346479e-13, 7.1054274e-15],\n", + " [[ 0.0000000e+00, 7.1054274e-15],\n", " [ 0.0000000e+00, 0.0000000e+00],\n", - " [-5.6843419e-14, 0.0000000e+00]],\n", + " [ 0.0000000e+00, -1.1346479e-13],\n", + " [-3.5527137e-15, 0.0000000e+00]],\n", " \n", - " [[ 0.0000000e+00, 0.0000000e+00],\n", - " [-1.1346479e-13, 7.1054274e-15],\n", - " [ 0.0000000e+00, 0.0000000e+00],\n", - " [ 0.0000000e+00, -2.9082159e-09]]], dtype=float32),\n", - " DeviceArray([[[ 4.8202928e-08, -6.2512861e-08],\n", - " [-1.1346479e-13, 7.1054274e-15],\n", - " [ 0.0000000e+00, 0.0000000e+00],\n", - " [ 4.8202928e-08, -6.2512861e-08]],\n", + " [[ 0.0000000e+00, 7.1054274e-15],\n", + " [ 0.0000000e+00, 1.7053026e-13],\n", + " [-2.9082365e-09, 5.1783339e-08],\n", + " [-3.5527137e-15, 0.0000000e+00]],\n", " \n", - " [[-3.0195665e-01, -4.5293498e-01],\n", - " [ 6.2086362e-01, 5.9745731e+00],\n", - " [-1.6947640e-02, -8.0687037e+00],\n", - " [-3.0195662e-01, 2.5470653e+00]],\n", + " [[ 0.0000000e+00, 7.1054274e-15],\n", + " [ 0.0000000e+00, 1.7053026e-13],\n", + " [ 0.0000000e+00, -1.1346479e-13],\n", + " [-2.9082154e-09, 0.0000000e+00]]], dtype=float32),\n", + " DeviceArray([[[-6.2512861e-08, 4.8202928e-08],\n", + " [ 0.0000000e+00, 1.7053026e-13],\n", + " [ 0.0000000e+00, -1.1346479e-13],\n", + " [-6.2512861e-08, 4.8202928e-08]],\n", " \n", - " [[ 3.0195665e-01, 4.5293498e-01],\n", - " [-6.2086368e-01, -5.9745741e+00],\n", - " [ 1.6950233e-02, 8.0687046e+00],\n", - " [ 3.0195662e-01, -2.5470653e+00]]], dtype=float32),\n", - " DeviceArray([[[ 1.3877788e-17, -1.1632905e-08],\n", - " [ 8.6736174e-19, -1.1632905e-08],\n", - " [-6.6613381e-16, -1.1632905e-08],\n", - " [ 1.5639502e-07, -4.7767704e+01]],\n", + " [[-4.5293498e-01, -3.0195665e-01],\n", + " [-8.0687075e+00, -1.6947633e-02],\n", + " [ 5.9745731e+00, 6.2086433e-01],\n", + " [ 2.5470653e+00, -3.0195662e-01]],\n", " \n", - " [[ 1.9997253e-07, -1.1920929e-07],\n", - " [ 1.9997253e-07, -1.1920929e-07],\n", - " [ 1.9997253e-07, -1.1920929e-07],\n", - " [ 5.6628981e+00, -7.8145462e-08]]], dtype=float32)],\n", - " 'B': [DeviceArray([[[ 3.01956534e-01, 1.47320042e+01, -1.31633423e+02,\n", - " 7.21276321e+01],\n", - " [ 4.52934682e-01, 3.07049377e+02, -2.62853363e+02,\n", - " -1.21084452e+01],\n", - " [ 4.52937736e-33, 3.07051425e-30, -2.62855113e-30,\n", - " -1.21085252e-31],\n", - " [ 3.01955963e-17, 3.02909273e-15, -8.26975670e-17,\n", - " -8.07228275e-16]],\n", + " [[ 4.5293498e-01, 3.0195665e-01],\n", + " [ 8.0687084e+00, 1.6950229e-02],\n", + " [-5.9745741e+00, -6.2086433e-01],\n", + " [-2.5470653e+00, 3.0195662e-01]]], dtype=float32),\n", + " DeviceArray([[[-1.1920929e-07, 1.9997253e-07],\n", + " [-1.1920929e-07, 1.9997253e-07],\n", + " [-1.1920929e-07, 1.9997253e-07],\n", + " [-7.8145455e-08, 5.6628966e+00]],\n", " \n", - " [[-1.47221327e+01, 4.19397838e-03, -6.52539444e+01,\n", - " 1.36325211e+02],\n", - " [-2.19382572e+01, -1.17391949e+01, -1.30286682e+02,\n", - " -2.32241726e+01],\n", - " [-2.19384039e-31, -1.17392718e-31, -1.30287534e-30,\n", - " -2.32243289e-31],\n", - " [-1.50119840e-15, -2.48344952e-18, -4.42394456e-17,\n", - " -1.58692597e-15]],\n", + " [[-1.1632904e-08, 0.0000000e+00],\n", + " [-1.1632904e-08, -2.2204460e-16],\n", + " [-1.1632904e-08, -8.6736174e-19],\n", + " [-4.7767696e+01, 1.5639498e-07]]], dtype=float32)],\n", + " 'B': [DeviceArray([[[ 3.01956534e-01, -1.31633453e+02, 1.47320213e+01,\n", + " 7.21276245e+01],\n", + " [ 4.52937847e-33, -2.62855245e-30, 3.07051444e-30,\n", + " -1.21085287e-31],\n", + " [ 4.52934861e-01, -2.62853485e+02, 3.07049408e+02,\n", + " -1.21084480e+01],\n", + " [ 3.01955864e-17, -8.26975538e-17, 3.02909612e-15,\n", + " -8.07228063e-16]],\n", " \n", - " [[-1.47221327e+01, 7.28492451e+00, 1.24194115e-01,\n", + " [[-1.47221327e+01, 1.24194175e-01, 7.28493309e+00,\n", " 1.42085220e+02],\n", - " [-2.22281361e+01, 1.63661453e+02, 2.31776506e-01,\n", - " -2.35140514e+01],\n", - " [-2.22282831e-31, 1.63662555e-30, 2.31778062e-33,\n", - " -2.35142081e-31],\n", - " [-1.44322280e-15, 1.50122159e-15, 3.32224416e-18,\n", - " -1.52895037e-15]],\n", + " [-2.22282902e-31, 2.31778172e-33, 1.63662555e-30,\n", + " -2.35142128e-31],\n", + " [-2.22281418e+01, 2.31776625e-01, 1.63661469e+02,\n", + " -2.35140572e+01],\n", + " [-1.44322238e-15, 3.32224334e-18, 1.50122328e-15,\n", + " -1.52894995e-15]],\n", + " \n", + " [[-1.47221327e+01, -6.52539597e+01, 4.19397652e-03,\n", + " 1.36325211e+02],\n", + " [-2.19384109e-31, -1.30287600e-30, -1.17392718e-31,\n", + " -2.32243359e-31],\n", + " [-2.19382629e+01, -1.30286743e+02, -1.17391949e+01,\n", + " -2.32241802e+01],\n", + " [-1.50119787e-15, -4.42394356e-17, -2.48345118e-18,\n", + " -1.58692554e-15]],\n", " \n", - " [[-7.28478909e+00, 1.48017712e+01, -1.32256821e+02,\n", - " -2.69804382e+00],\n", - " [-1.09271812e+01, 3.08503510e+02, -2.64098145e+02,\n", - " 4.52934802e-01],\n", - " [-1.09272544e-31, 3.08505540e-30, -2.64099914e-30,\n", - " 4.52937810e-33],\n", - " [-7.28477557e-16, 3.04343787e-15, -8.30892073e-17,\n", - " 3.01956029e-17]]], dtype=float32),\n", - " DeviceArray([[[ 0.6123013],\n", - " [ 26.513119 ]],\n", + " [[-7.28478909e+00, -1.32256851e+02, 1.48017883e+01,\n", + " -2.69804335e+00],\n", + " [-1.09272580e-31, -2.64100027e-30, 3.08505577e-30,\n", + " 4.52937920e-33],\n", + " [-1.09271851e+01, -2.64098267e+02, 3.08503540e+02,\n", + " 4.52934921e-01],\n", + " [-7.28477346e-16, -8.30891808e-17, 3.04344126e-15,\n", + " 3.01955930e-17]]], dtype=float32),\n", + " DeviceArray([[[-13.481548 ],\n", + " [ -1.7142806]],\n", " \n", - " [[ -1.7142805],\n", - " [-13.481548 ]]], dtype=float32)],\n", - " 'C': [DeviceArray([-0.25163043, 2.1984794 , -2.6952178 , 0.7483697 ], dtype=float32),\n", - " DeviceArray([ 0.49673927, -2.3932436 , 1.8965049 ], dtype=float32),\n", - " DeviceArray([-0.47483674, 0.47483736], dtype=float32)],\n", + " [[ 26.513119 ],\n", + " [ 0.6123011]]], dtype=float32)],\n", + " 'C': [DeviceArray([-0.25163046, -2.695219 , 2.1984794 , 0.7483696 ], dtype=float32),\n", + " DeviceArray([ 0.4967391, -2.3932445, 1.8965049], dtype=float32),\n", + " DeviceArray([ 0.47483668, -0.4748372 ], dtype=float32)],\n", " 'D': [DeviceArray([0., 0., 0., 0.], dtype=float32),\n", - " DeviceArray([ 7.9989013e-07, -5.2336878e-07], dtype=float32)]}" + " DeviceArray([-5.2336878e-07, 7.9989013e-07], dtype=float32)]}" ] }, "execution_count": 34, @@ -1020,15 +1021,15 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[-7.6029861e-01 -4.9739015e-01 1.3287575e-07]\n", - "-6.935675\n" + "[-7.6029861e-01 -4.9739018e-01 -2.8424586e-07]\n", + "-6.9356756\n" ] } ], @@ -1053,7 +1054,7 @@ " A[1] = jnp.stack([side_vector, middle_matrix1, middle_matrix2, side_vector], -2)\n", " \n", " C = lax.stop_gradient([jnp.array(x) for x in list(agent.C)])\n", - " C[1] = lam * jnp.array([0., -1., 1.])\n", + " C[1] = lam * jnp.array([0., 1., -1.])\n", "\n", " D = [lax.stop_gradient(nn.one_hot(0, 4)), jnp.array([d, 1-d])]\n", "\n", @@ -1083,14 +1084,14 @@ }, { "cell_type": "code", - "execution_count": 85, + "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "sample: 100%|███████████████████████████████████████████████████████████████| 1250/1250 [00:20<00:00, 60.32it/s]\n" + "sample: 100%|██████████| 1250/1250 [00:21<00:00, 58.95it/s]\n" ] } ], @@ -1113,12 +1114,12 @@ }, { "cell_type": "code", - "execution_count": 98, + "execution_count": 37, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1148,14 +1149,14 @@ }, { "cell_type": "code", - "execution_count": 122, + "execution_count": 38, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "100%|████████████████████| 1000/1000 [00:04<00:00, 248.11it/s, init loss: 14.4783, avg. loss [951-1000]: 7.1074]\n" + "100%|██████████| 1000/1000 [00:04<00:00, 215.53it/s, init loss: 16.6805, avg. loss [951-1000]: 7.1011]\n" ] } ], @@ -1175,12 +1176,12 @@ }, { "cell_type": "code", - "execution_count": 123, + "execution_count": 39, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1192,13 +1193,13 @@ "source": [ "plt.figure(figsize=(16,5))\n", "plt.plot(svi_res.losses)\n", - "plt.ylabel('ELBO');\n", + "plt.ylabel('Variational free energy');\n", "plt.xlabel('iter step');" ] }, { "cell_type": "code", - "execution_count": 124, + "execution_count": 40, "metadata": {}, "outputs": [], "source": [ @@ -1220,12 +1221,12 @@ }, { "cell_type": "code", - "execution_count": 125, + "execution_count": 41, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1235,13 +1236,69 @@ } ], "source": [ - "axes = az.plot_forest([data_mcmc, data_svi],\n", - " model_names = [\"nuts\", \"svi\"],\n", - " kind='forestplot',\n", - " var_names=[\"~z\"],\n", - " combined=True,\n", - " figsize=(20, 6))" + "axes = az.plot_forest(\n", + " [data_mcmc, data_svi],\n", + " model_names = [\"nuts\", \"svi\"],\n", + " kind='forestplot',\n", + " var_names=[\"~z\"],\n", + " combined=True,\n", + " figsize=(20, 6)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "from numpyro import distributions as dist\n", + "class AgentDist(dist.Distribution):\n", + "\n", + " def __init__(self, agent, env):\n", + " self.agent = agent\n", + " self.env = env\n", + "\n", + " # def sample(self):\n", + " # for b in range(blocks):\n", + " # for t in range(steps):\n", + " # responses = agent.get_responses()\n", + " # outcomes = env.get_outcomes(responses)\n", + " # agent.set_outcomes(outcomes)\n", + " \n", + " # return responses\n", + " \n", + " def log_prob(self, value):\n", + " outcomes = self.outcomes \n", + " responses = values\n", + " log_prob = 0.\n", + " for b in range(blocks):\n", + " for t in range(steps):\n", + " log_prob += agent.get_log_prob(outcomes[b, t], responses[b, t])\n", + "\n", + "\n", + "def model(data, env, T, n_pars=3):\n", + " z = npyro.sample('z', dist.Normal(0., 1.).expand([n_pars]).to_event(1))\n", + " x = trans_params(z)\n", + "\n", + " agent = Agent(x)\n", + " \n", + " if 'responses' in data:\n", + " env = data['outcomes']\n", + " obs= data['choices']\n", + " else:\n", + " env = env\n", + " obs = None\n", + " \n", + " choices = npyro.sample('choices', AgentDist(agent, env), obs=obs)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 4e26bfe4e0a556ac1cc71d074c27d98cbd2fb016 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Fri, 21 Oct 2022 13:03:24 +0200 Subject: [PATCH 019/232] a likelihood function for the aif agent --- examples/model_inversion.ipynb | 334 +++++++++++++++------------------ pymdp/jax/likelihoods.py | 55 ++++++ 2 files changed, 211 insertions(+), 178 deletions(-) create mode 100644 pymdp/jax/likelihoods.py diff --git a/examples/model_inversion.ipynb b/examples/model_inversion.ipynb index f83ccd89..2fad3e7a 100644 --- a/examples/model_inversion.ipynb +++ b/examples/model_inversion.ipynb @@ -609,17 +609,17 @@ "output_type": "stream", "text": [ " === Starting experiment === \n", - " Reward condition: Left, Observation: [CENTER, No reward, Cue Right]\n", + " Reward condition: Right, Observation: [CENTER, No reward, Cue Left]\n", "[Step 0] Action: [Move to CUE LOCATION]\n", - "[Step 0] Observation: [CUE LOCATION, No reward, Cue Left]\n", - "[Step 1] Action: [Move to LEFT ARM]\n", - "[Step 1] Observation: [LEFT ARM, Reward!, Cue Right]\n", - "[Step 2] Action: [Move to LEFT ARM]\n", - "[Step 2] Observation: [LEFT ARM, Reward!, Cue Left]\n", - "[Step 3] Action: [Move to LEFT ARM]\n", - "[Step 3] Observation: [LEFT ARM, Reward!, Cue Right]\n", - "[Step 4] Action: [Move to LEFT ARM]\n", - "[Step 4] Observation: [LEFT ARM, Reward!, Cue Left]\n" + "[Step 0] Observation: [CUE LOCATION, No reward, Cue Right]\n", + "[Step 1] Action: [Move to RIGHT ARM]\n", + "[Step 1] Observation: [RIGHT ARM, Reward!, Cue Left]\n", + "[Step 2] Action: [Move to RIGHT ARM]\n", + "[Step 2] Observation: [RIGHT ARM, Reward!, Cue Right]\n", + "[Step 3] Action: [Move to RIGHT ARM]\n", + "[Step 3] Observation: [RIGHT ARM, Reward!, Cue Right]\n", + "[Step 4] Action: [Move to RIGHT ARM]\n", + "[Step 4] Observation: [RIGHT ARM, Reward!, Cue Right]\n" ] } ], @@ -735,7 +735,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -809,22 +809,14 @@ { "cell_type": "code", "execution_count": 30, - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [ { "data": { "text/plain": [ - "{'actions': DeviceArray([[3, 0],\n", - " [2, 0],\n", - " [2, 0],\n", - " [2, 0],\n", - " [2, 0]], dtype=int32),\n", - " 'outcomes': DeviceArray([[0, 0, 0],\n", - " [3, 0, 1],\n", - " [2, 1, 0],\n", - " [2, 1, 1],\n", - " [2, 1, 0],\n", - " [2, 1, 1]], dtype=int32)}" + "DeviceArray(-9.186159, dtype=float32)" ] }, "execution_count": 30, @@ -833,46 +825,79 @@ } ], "source": [ - "measurments" + "# the following grad computation has to work for the Agent class to be differentiable and hence invertible\n", + "from functools import partial\n", + "\n", + "# parameters have to be jax arrays, lists or dictionaries of jax arrays\n", + "params = {\n", + " 'A': [jnp.array(x) for x in list(A_gp)],\n", + " 'B': [jnp.array(x) for x in list(B_gp)],\n", + " 'C': [jnp.array(x) for x in list(agent.C)],\n", + " 'D': [jnp.array(x) for x in list(agent.D)]\n", + "}\n", + "\n", + "partial(model_log_likelihood, T, measurments)(params)" ] }, { "cell_type": "code", - "execution_count": 31, - "metadata": { - "scrolled": true - }, + "execution_count": 36, + "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "DeviceArray(-14.946159, dtype=float32)" + "([DeviceArray([[0.05032608, 0.00282504, 0.8965227 , 0.05032609],\n", + " [0.05032609, 0.8965228 , 0.00282504, 0.0503261 ],\n", + " [0.05032608, 0.00282504, 0.8965227 , 0.05032609],\n", + " [0.05032609, 0.8965228 , 0.00282504, 0.0503261 ],\n", + " [0.05032609, 0.8965228 , 0.00282504, 0.0503261 ]], dtype=float32),\n", + " DeviceArray([[0.99999994],\n", + " [1. ],\n", + " [0.99999994],\n", + " [1. ],\n", + " [1. ]], dtype=float32)],\n", + " [DeviceArray([0, 3, 1, 1, 1], dtype=int32),\n", + " DeviceArray([0, 0, 1, 1, 1], dtype=int32),\n", + " DeviceArray([1, 0, 1, 0, 0], dtype=int32)],\n", + " DeviceArray([[3, 0],\n", + " [1, 0],\n", + " [1, 0],\n", + " [1, 0],\n", + " [1, 0]], dtype=int32))" ] }, - "execution_count": 31, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# the following grad computation has to work for the Agent class to be differentiable and hence invertible\n", - "from functools import partial\n", + "import numpyro as npyro\n", + "from pymdp.jax.likelihoods import aif_likelihood, evolve_trials\n", "\n", - "# parameters have to be jax arrays, lists or dictionaries of jax arrays\n", - "e = 1e-15\n", - "params = {\n", - " 'A': [jnp.array(x) for x in list(A_gp)],\n", - " 'B': [jnp.array(x) for x in list(B_gp)],\n", - " 'C': [jnp.array(x) for x in list(agent.C)],\n", - " 'D': [jnp.array(x) for x in list(agent.D)]\n", + "Na = 1\n", + "Nb = 1\n", + "Nt = T\n", + "\n", + "shape1 = measurments['outcomes'].shape[1:]\n", + "shape2 = measurments['actions'].shape[1:]\n", + "data = {\n", + " 'outcomes': jnp.broadcast_to(jnp.expand_dims(measurments['outcomes'][:-1], -2), (Nb, Nt, Na,) + shape1),\n", + " 'actions': jnp.broadcast_to(jnp.expand_dims(measurments['actions'], -2), (Nb, Nt, Na,) + shape2)\n", "}\n", + "agent = Agent(params['A'], params['B'], C=params['C'], D=params['D'], policies=policies, gamma=1.)\n", "\n", - "partial(model_log_likelihood, T, measurments)(params)" + "xs = {'outcomes': data['outcomes'][0].squeeze(), 'actions': data['actions'][0].squeeze()}\n", + "evolve_trials(agent, xs)\n", + "\n", + "# with npyro.handlers.seed(rng_seed=0):\n", + "# aif_likelihood(Na, Nb, Nt, data, agent)" ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -894,13 +919,13 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "DeviceArray(-14.946159, dtype=float32)" + "DeviceArray(-9.186157, dtype=float32)" ] }, "execution_count": 33, @@ -914,99 +939,99 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'A': [DeviceArray([[[-5.9604645e-08, 4.8202928e-08],\n", - " [ 0.0000000e+00, 1.7053026e-13],\n", - " [ 0.0000000e+00, -1.1346479e-13],\n", - " [-3.5527137e-15, 0.0000000e+00]],\n", + "{'A': [DeviceArray([[[ 4.8202928e-08, -5.9604645e-08],\n", + " [-5.6621374e-14, 1.4210855e-14],\n", + " [ 0.0000000e+00, 0.0000000e+00],\n", + " [-5.6843419e-14, 3.5527137e-15]],\n", " \n", - " [[ 0.0000000e+00, 7.1054274e-15],\n", + " [[ 0.0000000e+00, 3.5527137e-15],\n", + " [ 2.5891669e-08, -5.8164735e-09],\n", " [ 0.0000000e+00, 0.0000000e+00],\n", - " [ 0.0000000e+00, -1.1346479e-13],\n", - " [-3.5527137e-15, 0.0000000e+00]],\n", + " [-5.6843419e-14, 3.5527137e-15]],\n", " \n", - " [[ 0.0000000e+00, 7.1054274e-15],\n", - " [ 0.0000000e+00, 1.7053026e-13],\n", - " [-2.9082365e-09, 5.1783339e-08],\n", - " [-3.5527137e-15, 0.0000000e+00]],\n", + " [[ 0.0000000e+00, 3.5527137e-15],\n", + " [-5.6621374e-14, 1.4210855e-14],\n", + " [ 0.0000000e+00, 0.0000000e+00],\n", + " [-5.6843419e-14, 3.5527137e-15]],\n", " \n", - " [[ 0.0000000e+00, 7.1054274e-15],\n", - " [ 0.0000000e+00, 1.7053026e-13],\n", - " [ 0.0000000e+00, -1.1346479e-13],\n", - " [-2.9082154e-09, 0.0000000e+00]]], dtype=float32),\n", - " DeviceArray([[[-6.2512861e-08, 4.8202928e-08],\n", - " [ 0.0000000e+00, 1.7053026e-13],\n", - " [ 0.0000000e+00, -1.1346479e-13],\n", - " [-6.2512861e-08, 4.8202928e-08]],\n", + " [[ 0.0000000e+00, 3.5527137e-15],\n", + " [-5.6621374e-14, 1.4210855e-14],\n", + " [ 0.0000000e+00, 0.0000000e+00],\n", + " [ 0.0000000e+00, -2.9082159e-09]]], dtype=float32),\n", + " DeviceArray([[[ 4.8202928e-08, -6.2512861e-08],\n", + " [-5.6621374e-14, 1.4210855e-14],\n", + " [ 0.0000000e+00, 0.0000000e+00],\n", + " [ 4.8202928e-08, -6.2512861e-08]],\n", " \n", " [[-4.5293498e-01, -3.0195665e-01],\n", - " [-8.0687075e+00, -1.6947633e-02],\n", - " [ 5.9745731e+00, 6.2086433e-01],\n", - " [ 2.5470653e+00, -3.0195662e-01]],\n", + " [ 9.3129528e-01, 2.9830487e+00],\n", + " [-2.5424069e-02, -5.3791361e+00],\n", + " [-4.5293495e-01, 2.6980436e+00]],\n", " \n", " [[ 4.5293498e-01, 3.0195665e-01],\n", - " [ 8.0687084e+00, 1.6950229e-02],\n", - " [-5.9745741e+00, -6.2086433e-01],\n", - " [-2.5470653e+00, 3.0195662e-01]]], dtype=float32),\n", - " DeviceArray([[[-1.1920929e-07, 1.9997253e-07],\n", - " [-1.1920929e-07, 1.9997253e-07],\n", - " [-1.1920929e-07, 1.9997253e-07],\n", - " [-7.8145455e-08, 5.6628966e+00]],\n", - " \n", - " [[-1.1632904e-08, 0.0000000e+00],\n", - " [-1.1632904e-08, -2.2204460e-16],\n", - " [-1.1632904e-08, -8.6736174e-19],\n", - " [-4.7767696e+01, 1.5639498e-07]]], dtype=float32)],\n", - " 'B': [DeviceArray([[[ 3.01956534e-01, -1.31633453e+02, 1.47320213e+01,\n", - " 7.21276245e+01],\n", - " [ 4.52937847e-33, -2.62855245e-30, 3.07051444e-30,\n", - " -1.21085287e-31],\n", - " [ 4.52934861e-01, -2.62853485e+02, 3.07049408e+02,\n", - " -1.21084480e+01],\n", - " [ 3.01955864e-17, -8.26975538e-17, 3.02909612e-15,\n", - " -8.07228063e-16]],\n", + " [-9.3129539e-01, -2.9830496e+00],\n", + " [ 2.5425371e-02, 5.3791361e+00],\n", + " [ 4.5293495e-01, -2.6980436e+00]]], dtype=float32),\n", + " DeviceArray([[[ 0.0000000e+00, -1.7449379e-08],\n", + " [ 8.6736174e-19, -1.7449379e-08],\n", + " [-2.2204460e-16, -1.7449379e-08],\n", + " [ 1.6566540e-07, -5.0599152e+01]],\n", " \n", - " [[-1.47221327e+01, 1.24194175e-01, 7.28493309e+00,\n", - " 1.42085220e+02],\n", - " [-2.22282902e-31, 2.31778172e-33, 1.63662555e-30,\n", - " -2.35142128e-31],\n", - " [-2.22281418e+01, 2.31776625e-01, 1.63661469e+02,\n", - " -2.35140572e+01],\n", - " [-1.44322238e-15, 3.32224334e-18, 1.50122328e-15,\n", - " -1.52894995e-15]],\n", + " [[ 1.4818920e-07, -1.1920929e-07],\n", + " [ 1.4818920e-07, -1.1920929e-07],\n", + " [ 1.4818920e-07, -1.1920929e-07],\n", + " [ 8.4943476e+00, -8.7415906e-08]]], dtype=float32)],\n", + " 'B': [DeviceArray([[[ 3.01956534e-01, 1.47320042e+01, -1.31633423e+02,\n", + " 7.21276321e+01],\n", + " [ 4.52934742e-01, 1.76242935e+02, -1.32046906e+02,\n", + " -1.21084461e+01],\n", + " [ 4.52937773e-33, 1.76244106e-30, -1.32047794e-30,\n", + " -1.21085263e-31],\n", + " [ 3.01955963e-17, 3.02909273e-15, -8.26975670e-17,\n", + " -8.07228275e-16]],\n", " \n", - " [[-1.47221327e+01, -6.52539597e+01, 4.19397652e-03,\n", + " [[-1.47221327e+01, 4.19397838e-03, -6.52539444e+01,\n", " 1.36325211e+02],\n", - " [-2.19384109e-31, -1.30287600e-30, -1.17392718e-31,\n", - " -2.32243359e-31],\n", - " [-2.19382629e+01, -1.30286743e+02, -1.17391949e+01,\n", - " -2.32241802e+01],\n", - " [-1.50119787e-15, -4.42394356e-17, -2.48345118e-18,\n", - " -1.58692554e-15]],\n", + " [-2.22281380e+01, -5.88822317e+00, -6.54751358e+01,\n", + " -2.35140533e+01],\n", + " [-2.22282855e-31, -5.88826220e-32, -6.54755667e-31,\n", + " -2.35142105e-31],\n", + " [-1.50119840e-15, -2.48344952e-18, -4.42394456e-17,\n", + " -1.58692597e-15]],\n", " \n", - " [[-7.28478909e+00, -1.32256851e+02, 1.48017883e+01,\n", - " -2.69804335e+00],\n", - " [-1.09272580e-31, -2.64100027e-30, 3.08505577e-30,\n", - " 4.52937920e-33],\n", - " [-1.09271851e+01, -2.64098267e+02, 3.08503540e+02,\n", - " 4.52934921e-01],\n", - " [-7.28477346e-16, -8.30891808e-17, 3.04344126e-15,\n", - " 3.01955930e-17]]], dtype=float32),\n", - " DeviceArray([[[-13.481548 ],\n", - " [ -1.7142806]],\n", + " [[-1.47221327e+01, 7.28492451e+00, 1.24194115e-01,\n", + " 1.42085220e+02],\n", + " [-2.19382591e+01, 9.30899048e+01, 1.40805125e-01,\n", + " -2.32241745e+01],\n", + " [-2.19384062e-31, 9.30905292e-31, 1.40806067e-33,\n", + " -2.32243312e-31],\n", + " [-1.44322280e-15, 1.50122159e-15, 3.32224416e-18,\n", + " -1.52895037e-15]],\n", " \n", - " [[ 26.513119 ],\n", - " [ 0.6123011]]], dtype=float32)],\n", - " 'C': [DeviceArray([-0.25163046, -2.695219 , 2.1984794 , 0.7483696 ], dtype=float32),\n", - " DeviceArray([ 0.4967391, -2.3932445, 1.8965049], dtype=float32),\n", - " DeviceArray([ 0.47483668, -0.4748372 ], dtype=float32)],\n", + " [[-7.28478909e+00, 1.48017712e+01, -1.32256821e+02,\n", + " -2.69804382e+00],\n", + " [-1.09271832e+01, 1.77077591e+02, -1.32672256e+02,\n", + " 4.52934831e-01],\n", + " [-1.09272556e-31, 1.77078764e-30, -1.32673129e-30,\n", + " 4.52937883e-33],\n", + " [-7.28477557e-16, 3.04343787e-15, -8.30892073e-17,\n", + " 3.01956029e-17]]], dtype=float32),\n", + " DeviceArray([[[ 0.9184518],\n", + " [21.61026 ]],\n", + " \n", + " [[-2.5714204],\n", + " [-8.027699 ]]], dtype=float32)],\n", + " 'C': [DeviceArray([-0.25163043, 1.3047817 , -1.8015203 , 0.7483697 ], dtype=float32),\n", + " DeviceArray([ 0.49673924, -1.4332438 , 0.936505 ], dtype=float32),\n", + " DeviceArray([-0.52516294, 0.52516335], dtype=float32)],\n", " 'D': [DeviceArray([0., 0., 0., 0.], dtype=float32),\n", - " DeviceArray([-5.2336878e-07, 7.9989013e-07], dtype=float32)]}" + " DeviceArray([ 5.927568e-07, -5.466347e-07], dtype=float32)]}" ] }, "execution_count": 34, @@ -1021,15 +1046,15 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[-7.6029861e-01 -4.9739018e-01 -2.8424586e-07]\n", - "-6.9356756\n" + "[2.7251303e-01 1.7827910e-01 3.6590501e-07]\n", + "-7.051658\n" ] } ], @@ -1084,14 +1109,14 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "sample: 100%|██████████| 1250/1250 [00:21<00:00, 58.95it/s]\n" + " 0%| | 0/1250 [00:00" ] @@ -1149,14 +1174,14 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1000/1000 [00:04<00:00, 215.53it/s, init loss: 16.6805, avg. loss [951-1000]: 7.1011]\n" + "100%|██████████| 1000/1000 [00:04<00:00, 221.73it/s, init loss: 16.8077, avg. loss [951-1000]: 6.9221]\n" ] } ], @@ -1176,12 +1201,12 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1199,7 +1224,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1221,12 +1246,12 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAB9sAAAJjCAYAAACsvnHyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAABIW0lEQVR4nO3deZyWdb0//tcMw4AIDiOKymhiIZiJGBBKkrhRaZpL5lJpmpa5lJrV13M85dbxHHNNy7Q8WVqaGVqpaViKhqkouOSuiAuIqGxKLAMz9+8Pf0yDMwoXzHAP4/P5ePhw5nNt7xvmfnPN9bo/11VRKpVKAQAAAAAAAABWWmW5CwAAAAAAAACAtY2wHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAQDt5/fXXc/bZZ+eTn/xkBg8enO233z5HHnlk/v73vxfaz/XXX59BgwZl0KBBOfXUU1e5nilTpuTkk0/OqFGjMnjw4Oy+++4555xz8uabb7a6fkNDQ370ox9l9OjR2WabbbL33ntn3Lhx77r/p556KltvvXXOOeecVarv/vvvb3qd72XatGlN602bNm25ZaecckrTsmX/DRkyJKNGjcqBBx6YM888M/fee29KpdK77v+SSy7JoEGDcuihh67S6wAAAOD9QdgOAAAA7eDpp5/Ovvvum1/96leZMWNGttxyy9TU1GTChAk56qij8rOf/Wyl9jN79uycd955q13Pfffdl/333z8333xzGhoasuWWW+aNN97IL37xi+y///554403WmxzwQUX5NJLL81bb72VLbbYIs8//3y++c1v5m9/+1urxzjzzDOz/vrr57jjjlvteldXnz59MnTo0AwdOjSDBg1Kz54988QTT+Q3v/lNDj/88Oy77755+umny10mAAAAazFhOwAAALSxpUuX5pvf/GbeeOONjBgxInfddVduuOGGjBs3Lr/85S+z7rrr5oILLsgDDzywwn2dffbZefPNN7Pzzjuvcj3z58/PSSedlEWLFuXQQw/N3XffnRtuuCF33nlnhg4dmpdffrnFjPnZs2fn6quvTl1dXcaNG5ebbropv/zlL1NRUZGLL764xTH+8Ic/ZNKkSfnOd76Tnj17rnKtbWWnnXbKtddem2uvvTa/+93vctttt+XBBx/MJZdckoEDB+app57KQQcdlCeeeKLcpQIAALCWErYDAABAGxs/fnxeeOGFVFdX53//93+z/vrrNy0bOXJkvv71r6dUKuXHP/7xe+7nH//4R2666aYcdNBB2WabbVa5nt/+9reZPXt2PvShD+U//uM/0rVr1yRJbW1tzj///FRVVWX8+PF5/PHHm7Z55plnsnjx4uy///7ZYIMNkiQf+9jHMmzYsDz11FOZP39+07rz58/Peeedl2HDhmWfffZZ5TrbW/fu3fPJT34y119/fUaOHJmFCxfmxBNPTENDQ7lLAwAAYC0kbAcAAIA2Nnny5CTJ4MGDU1dX12L5pz71qSTJxIkTM2vWrFb3sXjx4px++unp06dPvvWtb61WPbfffnuSZL/99kuXLl2WW9avX7+MHDkySfKXv/ylaXz27NlJ3r4de3MbbrhhkuRf//pX09iPf/zjzJ49O9/73vdWq841pXv37jn33HNTXV2dF198Mbfddlu5SwIAAGAtJGwHAACANvbmm28mSTbaaKNWly8bb2xszD//+c9W17n00kvz4osv5rvf/W7WW2+9Va5l6dKlTTPWhw4d2uo6y8YfeeSRprFNNtkkSfLCCy8st+7UqVNTVVWV3r17J0mmTJmSX//61znooIPy4Q9/eJXrXNM23HDD7L777knevhMBAAAAFCVsBwAAgDbWq1evJMnMmTNbXd58fOrUqS2WT5kyJf/3f/+X4cOHZ999912tWqZPn54lS5YkSTbbbLNW11k2/uKLLzaNbbXVVunTp09+//vf5x//+Efmz5+fX/3qV3nyySczfPjwdOvWLUly1llnpWfPnjnxxBNXq85yGDZsWJK86wceAAAA4L1UlbsAAAAA6GwGDx6cJHnssccyY8aMplniy4wbN67p63nz5i23rFQq5fvf/35KpVJOO+201a6l+f5rampaXWfZzPnm666zzjr51re+lVNPPTVHHHFE03iPHj1yyimnJEluvfXW3HvvvTnrrLOa9r1kyZLMmTMnvXv3TnV19SrXPWjQoFXedmVtvPHGSf59y3wAAAAoQtgOAAAAbWy33XZL375989prr+Xkk0/ORRddlL59+yZ5+5bll112WdO6ixcvXm7b3//+93nwwQfzla98JQMHDlztWurr65u+7tq1a6vrLAvF31nLAQcckL59++aGG27I7Nmz079//xx++OH54Ac/mIULF+aHP/xhttlmmxxwwAEplUq56KKLctVVV2XBggXp0aNHDj300Jx00kmpqKgoXPe73fJ+2Wt67LHHCu/znXr06JFk+efPAwAAwMoStgMAAEAb69atWy688MJ87Wtfy6RJk7LLLrtkiy22yLx58/Laa6+lX79++fCHP5wHHnigKfBN3p5hfd5552XjjTfO8ccf3ya1NJ9dvmTJkqbbvze3LJBvbdlOO+2UnXbaqcX4ZZddlhkzZuSiiy5KZWVlLr300lx22WXZZZdd8qlPfSrjxo3L5ZdfnnXWWSfHHHNM4bqvvfbad102bdq07LbbboX3+U4LFixIkvTs2XO19wUAAMD7j2e2AwAAQDsYPnx4brzxxnzuc5/LBhtskBdeeCFJcvDBB2fs2LFpaGhIkmywwQZN25x77rmZO3du/uM//iPrrrtum9TR/Nbx77xl/TJvvvlmi3Xfy0svvZRf/OIX2W+//TJkyJAsWbIkV155ZTbffPNceuml2W+//fKTn/wkm2++ea688sosXbp09V9IO3jllVeSJOuvv36ZKwEAAGBtZGY7AAAAtJPNN988Z599dovxpUuX5qmnnkqSfOQjH2kaf+KJJ5IkZ511Vs4666zltlk2C/vmm2/O+PHjkyT33HPPCmuoq6tL165ds2TJkrz88stNt7Nv7uWXX26qd2X893//d7p165Zvf/vbSZLnn38+b775Zvbaa69UVr79uf7KysrsuOOOueaaazJ16tRsueWWK7XvNWnSpElJkm233bbMlQAAALA2ErYDAADAGjZhwoQsWLAgffv2XS5sX+aNN954120XLVqURYsWrfSxqqqqsvXWW+eRRx7J5MmTM2zYsBbrTJ48OUkyZMiQFe7vzjvvzPjx43PqqaemT58+Sf79QYB3zsZf9v2ymfMdyWuvvZY77rgjSTJ69OgyVwMAAMDayG3kAQAAYA2qr6/PxRdfnCQ55JBD0qVLl6Zlf/zjH/P000+3+t+yZ7gfcMABTWMra8yYMUmSG2+8sen29cu88soruffee5Mkn/zkJ1dY+9lnn52BAwfmC1/4QtP4JptskuTt28s3t+z72trala51TVi0aFG++93vpr6+Pv3798+nPvWpcpcEAADAWkjYDgAAAO3grrvuyiOPPLLc2IwZM3Lcccfl8ccfz4ABA3LUUUe12fFuu+227LrrrjnkkENaLDvkkENSW1ubKVOm5H/+53+yZMmSJMmcOXNy8sknZ+nSpdlpp52yzTbbvOcxfv7zn+ell17K9773vVRV/ftmeRtttFE22WST3HnnnU23x3/66adz5513ZsMNN0z//v3b7HWujkWLFuX222/P5z//+dx7773p0aNHfvSjHy33gQcAAABYWW4jDwAAAO1gwoQJueqqq1JTU5O6urosXrw4zz//fEqlUgYMGJBf/OIXqa6ubrPjLViwINOnT291Wc+ePXPhhRfm6KOPztVXX51bbrklm2yySZ5//vksXLgwdXV1rT5bvrlXXnklP//5z/OZz3wmI0aMWG5ZRUVFjj/++Jx66qk54IADssUWW+SFF15IfX19jjvuuKbnuK9Jd999d9MHDxobGzNv3rxMmzat6YMGH/7wh/PDH/4wAwcOXOO1AQAA0DkI2wEAAKAd7L777nn99dfz6KOPZsqUKamurs7gwYOz55575otf/GKbBu0rY+TIkRk7dmx++tOf5r777sszzzyTjTbaKGPGjMkxxxyTmpqa99z+f//3f1NRUZH/9//+X6vLDzjggCxevDi/+tWvMnXq1PTr1y9HHHFEqzPt14RZs2Zl1qxZSZJu3bqlV69e2XrrrbPNNttkzJgxGTlyZFnqAgAAoPOoKJVKpXIXAQAAAAAAAABrE89sBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgoKpyF9DZzZkzp9wlAGVUU1OTefPmlbsMoIPQE4B30heA5vQEoDk9AWhOTwCa0xPWjNra2hWuY2Y7QDuqrNRmgX/TE4B30heA5vQEoDk9AWhOTwCa0xM6Dn8TAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAlMXPf/7z7LDDDpk0aVK5SylM2A4AAAAAAAAABVWVuwAAAAAAAAAA3p8+//nPZ8yYMdl4443LXUphwnYAAAAAAAAAyqJ3797p3bt3uctYJW4jDwAAAAAAAMBKueOOO3LMMcdkjz32yE477ZTPfvazOfHEE3PXXXdlxowZGTlyZI4//vhWt128eHF22223HHDAAU1ja/Mz281sBwAAAAAAAFhdpVKydGH7H6a+OlmyoPiGVeskFRWrdeyxY8fm3HPPzQYbbJDRo0enpqYmb7zxRp544oncddddGT16dLbbbrtMnjw5r732Wvr27bvc9nfffXf+9a9/5eCDD16tOjoKYTsAAAAAAADA6iiVss51X0yXVx5q90MtTdJzFbZr6Dc0Cw/69WoF7n/605/StWvXXH311amtrV1u2bx585Ikn/70p/PQQw9l3Lhx+dKXvrTcOrfddlvTOp2B28gDAAAAAAAArLbVmzW+tqiqqkpVVcs53TU1NUmS3XbbLdXV1U3B+jJz587N/fffn2222SabbbbZGqm1vZnZDgAAAAAAALA6KirenjW+Bm4j37t378ydO7f4hm1wG/nddtstl156ab7whS9kzJgxGTp0aIYMGZJevXo1rdOzZ8+MGjUqd9xxR5577rkMGDAgSXL77bdn6dKlnWZWeyJsBwAAAAAAAFh9FRVJ1x7tf5jqdZOu9e1+nNYceuihqampyY033phrr70211xzTbp06ZKPf/zjOemkk9KvX78kb98m/o477shf/vKXprD9tttuS1VVVcaMGVOW2tuDsB0AAAAAAACAFaqoqMg+++yTffbZJ/PmzcvDDz+ccePG5W9/+1tefvnl/OY3v2kK33v37p1x48bl2GOPzbRp0/L4449np512arrdfGcgbAcAAAAAAACgkJqamowePTqjR4/OvHnz8uCDD2batGnZfPPNU1VVld122y1jx47N5MmTM3ny5CTpVLeQT5LKchcAAAAAAAAAQMd33333ZenSpcuNLV26NG+++WaSpFu3bk3je+yxR5K3bx//l7/8Jb169cqoUaPWXLFrgJntAAAAAAAAAKzQf/3Xf6V79+4ZMmRINt544yxdujQTJ07M1KlTs/vuu2fjjTduWnebbbbJZpttlltvvTVLly7NPvvsk+rq6jJW3/aE7QAAAAAAAACs0DHHHJP77rsvjz/+eCZMmJDu3btn0003zSmnnJK99tqrxfqf/vSn8/Of/7zp686molQqlcpdRGc2Z86ccpcAlFFtba0+ADTRE4B30heA5vQEoDk9AWhOTwCa0xPWjNra2hWu45ntAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAOgQjjnmmOywww7lLmOlCNsBAAAAAAAAoCBhOwAAAAAAAAAUVFXuAgAAAAAAAABYO0yaNCnHHXdcjjzyyHziE5/IT3/60/zzn/9MRUVFhg8fnhNOOCH9+vVLkrzyyivZf//9s+eee+b73/9+i33tsMMO+ehHP5qf/vSnTd83X7ZM8+0nTZqUq6++Os8991zmzZuXmpqabLbZZvn0pz+dffbZpz1fegvCdgAAAAAAAAAKeeqpp/Kb3/wmQ4cOzb777ptnnnkmd911V6ZMmZLf/OY36datW+F9Hnnkkbnlllvy6quv5sgjj2waHzhwYJLknnvuybe//e306tUrn/jEJ7LBBhtkzpw5efbZZ/OXv/xF2A4AAAAAAACwtimVSlm0qP2P061bKQsXlgpv1717UlFR0WZ13HPPPTnrrLMyZsyYprEzzjgjt956a+6+++7lxlfWV7/61UyePDmvvvpqvvrVr7ZYftNNN6VUKuUnP/lJttxyy+WWzZs3r/iLWE3CdgAAAAAAAIDVUCqVcuw3SvnnY2viaLNXaavB2ySXXtJ2gftHP/rRFoH6XnvtlVtvvTVPPPHEKoXtK6u1WfM1NTXtdrx3U7nGjwgAAAAAAADAWm3QoEEtxvr27ZskmT9/frscc7fddkuSHHXUUTn33HNzxx13ZPbsVfvwQVswsx0AAAAAAABgNVRUVOTSS7JGbiPfu3dt5s6dU3i7tr6N/LrrrttirEuXLkmShoaGNjtOc2PGjElVVVWuu+66/OEPf8jYsWNTUVGRoUOH5oQTTmh6tvuaImwHAAAAAAAAWE0VFRVZZ532P06PHhVZvLjtQvP2VFn59o3WWwvfV3X2+y677JJddtkl//rXv/Loo49m/Pjxuemmm3LCCSfkd7/7XXr16rVaNRchbAcAAAAAAACgzS0Lvl9//fUWy55++ulWt2k+O37Z161Zd911M3LkyIwcOTKNjY256aab8vjjj2eHHXZog8pXjme2AwAAAAAAANDm1l133XzgAx/II488kpdffrlp/F//+ld++tOftrrNeuutlyR57bXXWix74IEHsnjx4hbjy57b3q1bt7Yoe6WZ2Q4AAAAAAABAuzjkkENyzjnn5Ktf/Wp23XXXlEql3Hvvvdlqq61aXX/YsGG54447cuqpp2bkyJHp1q1bPvShD2XHHXfMxRdfnJkzZ+ajH/1oNtlkk1RUVOSRRx7JE088kcGDB2fbbbddo69N2A4AAAAAAABAu9hvv/2ydOnSXHfddfnTn/6UDTbYIJ/5zGdyxBFHZNSoUS3W32effTJjxoz89a9/zS9/+cs0NDRkzz33zI477pjDDjss48ePz9NPP537778/VVVV6devX44//vh87nOfe8/bzreHilKpVFqjR3yfmTNnTrlLAMqotrZWHwCa6AnAO+kLQHN6AtCcngA0pycAzekJa0Ztbe0K1/HMdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABRUVe4CAIDlTX2hlOnTk7q6ZIv+FeUuBwAAAAAAaIWwHaCDmTO3VO4SKJN5b5Zy3vnJw4/8e2y7IaV8++SkZj2he2dQKjVm7rw1+x6v7e1nBwAAAACgPQjbWWstXCiQpOPr1q1U+Gd17339bL9fVVYm666bnHl6RYYMTh75Z3Lu+aUcdnjS2OjnonOYs8aPePuta/yQsNZaZx0fTgEAAABg5QnbWWuN2UPwxNpgdrkLYC3S2Jh85+SK7Lrz22HPrjsnpVJy2hn6HavOv5ew8iaMF7YDAAAAsPIqy10AAPBvQwYv//1225anDgAAAAAA4L2Z2c5a6/ZbzTyi4+vduzZz5xa7bbRZqO9vj/zz7Rntyzz8aNlKoZPw7yUAAAAAQPsQtrPW8kxN1gY9elRk8eJiP6s3/aF9aqHj+95ppVxwUSml0tsz2h9+NLnwR6VsNyQ56ww9rzPoXdM7c+fNXaPH9O8lAAAAAED7ELYDdDC1vQVj71c/OCM54wel5Z7R/rHhyWn/VZHefi46hdraylRU+LsEAAAAAOgMhO0A0EH07l2RC8+ryNQXSpk+PamrS7boL5gFAAAAAICOSNgOAB3MFv0rskX/clcBAAAAAAC8l8pyFwAAAAAAAAAAaxthOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICCqspdQEdXX1+f6667LuPHj89zzz2XWbNmpVevXhk2bFiOPfbYbL311uUuEQAAAAAAAIA1zMz2FZg3b17OPvvs1NfXZ/To0Tn88MMzYsSI3HXXXTn44IPz6KOPlrtEAAAAAAAAANYwM9tXoKamJuPHj89GG2203Pizzz6bAw88MBdeeGGuvPLKMlUHAAAAAAAAQDmY2b4C1dXVLYL2JNlyyy2z/fbb54EHHsiSJUvKUBkAAAAAAAAA5WJm+0p48sknc8UVV2TSpEl54403WoTrc+bMSd++fctUHQAAAAAAAABrmrB9BSZPnpwvf/nLSZIdd9wx/fv3T48ePVJRUZG//vWveeqpp1JfX1/mKgEAAAAAAABYk4TtK3DZZZelvr4+11xzTYYNG7bcsocffrg8RQEAAAAAAABQVp7ZvgIvvfRSevfu3SJoX7hwYZ544okyVQUAAAAAAABAOQnbV6Curi7z5s3Ls88+2zTW0NCQc845J7Nnzy5jZQAAAAAAAACUi9vIr8CXvvSlTJgwIV/4wheyxx57pLq6OhMnTszMmTMzYsSITJw4sdwlAgAAAAAAALCGmdm+ArvssksuvvjibLbZZvnTn/6Um2++OR/84Afz+9//PnV1deUuDwAAAAAAAIAyqCiVSqVyF9GZzZkzp9wlAGVUW1urDwBN9ATgnfQFoDk9AWhOTwCa0xOA5vSENaO2tnaF65jZDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAqqKncBAAAAba1i1nOpnPtSGnt/IKU+A8pdDgAAAACdkLAdAADo+BbMXrn1Fs5N97+elqrpDzYNLa0bnkW7n5Gs03vF2/dYf9XqAwAAAOB9R9gOAACsmiUL1tihel6240qtV6qoTKp7ZeFeF6axblgqp09K99tPy7pX7Z2KUuMKt5//jUmrW+p769qjffcPAAAAwBojbAcAAFZJz0uGlbuEFipKjVk45vQ0DPx0kqRh4KezuFRK91u+tVLbt/drmv+tJ9t1/wAAAACsOZXlLgAAAKAtNdYtH5g3bDq8TJUAAAAA0JmZ2Q4AAKySdr/lejNFZpxXTp/UNLM9SbpMe/A91l7emnxNAAAAAKzdhO0AAMCqWYPPH5//9XtWar3uN52Qbn87K/WlUho2HZ4u0x5M9R0/yNJNP5ZFe1204h14pjoAAAAAK0nYDgAAdHw91l+p1RZ99uJ0//O3l3tG+9LNP55Fe56XrFPbXtUBAAAA8D4kbAcAADqPdWqz6HP/l4pZz6Vy7ktp7P2BlPoMKHdVAAAAAHRCwnYAAKDTKfUZkAYhOwAAAADtqLLcBQAAAAAAAADA2kbYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEFV5S6gs2toaEhjY2O5ywDKZMmSJVmyZEm5ywA6CD0BeCd9AWhOTwCa0xOA5vQEoDk9oeMQtrez6dOnp76+vtxlAGUyd+7czJs3r9xlAB2EngC8k74ANKcnAM3pCUBzegLQnJ6wZvTt23eF6wjb21l9fX26dOmSLl26lLsUoAy6deuW6urqcpcBdBB6AvBO+gLQnJ4ANKcnAM3pCUBzekL7a2hoWKn1hO1rQJcuXdK1a9dylwGUQdeuXb3/gSZ6AvBO+gLQnJ4ANKcnAM3pCUBzekLHUVnuAgAAAAAAAABgbSNsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFVZW7AACAzuzlaV3y6qtV2Xjjpendu9zVAAAAAADQVoTtAKzV5r1ZUe4SoFVvza/Iz6+oyRNPVjeNbTu4MUccXplePUtlrAzeVrOen0MAAAAAWB3CduiAFi0qdwW0lYWL/H22t6OO7lvuEqBVlZXJuusmZ55ekSGDk0f+mZx7fmVO/s6GaWwsd3WQXH3lzHKXQJwrdHbdu5e7AgAAAKA9CduhAzr0iI3KXQJtyt8nvB81NibfObkiu+789t0Xdt05KZWS084wm5iOwflGR+LvorO6/lofagEAAIDOrLLcBQAAdFZDBi///XbblqcOAAAAAADanpnt0AG5rWvnUdO7d+bNnVvuMjo1MzPpyB7559sz2pd5+NGylQItON/oGJwrAAAAAKy9hO3QAXm2Y+exTvdksb/PdnXF5a+VuwRo1QUX9c4FF3ZNqVSZ7bZ9O2i/8EelbP3h+nzrxLnlLg+cb3QQzhUAAAAA1l7CdgDWajXref41HdPJJ87Nj37cO6edUd00NvSjjTnu63Oznp9bAAAAAIC1nrAdAKAdrLdeKd/7zzl5eVqXvPpqVTbeeGkGb9Mrc+cK2gEAAAAAOgNhOwBAO9ps04ZstmlDucsAAAAAAKCNVZa7AAAAAAAAAABY2wjbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHC9tUwbdq0DBo0KKecckq5SwEAAAAAAABgDRK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdtXQkNDQ372s59lzJgxGTx4cMaMGZPLL788pVKp3KUBAAAAAAAAUAZV5S5gbfC9730vY8eOzaabbpovfvGLWbx4ca688so89NBD5S4NAAAAAAAAgDIQtq/A/fffn7Fjx2arrbbKtddemx49eiRJvv71r2efffYpc3UAAAAAAAAAlIPbyK/AH/7whyTJcccd1xS0J8lGG22Uww47rExVAQAAAAAAAFBOwvYVePrpp5Mkw4cPb7GstTEAAAAAAAAAOj9h+wq89dZbqaysTG1tbYtlffr0KUNFAAAAAAAAAJSbsH0FevXqlcbGxsyZM6fFslmzZpWhIgAAAAAAAADKTdi+AoMGDUqSPPjggy2WtTYGAAAAAAAAQOcnbF+BfffdN0nyk5/8JAsWLGganzlzZq666qoyVQUAAAAAAABAOVWVu4CObvvtt8/++++fG264IXvvvXfGjBmT+vr6/PnPf852222XO++8s9wlAgAAAAAAALCGCdtXwg9+8INsscUW+d3vfpdf//rX2XjjjXPEEUdkjz32ELYDAAAAAAAAvA8J21dCly5d8rWvfS1f+9rXWix7+umny1ARAAAAAAAAAOXkme0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABRUVe4CAAAAgLdVz3shXd+aniW96lJf07/c5QAAAADvQdgOAAAAa1CXRXNbjFUufjMbPXhh1nntkaaxhX2HZObwk9LYbb2msYbuvddAhQAAAMDKELYDAADAKqhYunCVtvvgjfu3GCtVVCbVvbJwrwvTWDcsldMnpfvtp2XzW7+SilJj03rPff6WQscqVa2zSjUCAAAAKyZsBwAAgFUw4PrPtNm+KkqNWTjm9DQM/HSSpGHgp7O4VEr3W761Wsd89pA72qxGAAAAYHmV5S4AAAAASBrrhi33fcOmw8tUCQAAALAyzGwHAACAVVD0lu7LvNvs9Mrpk5pmtidJl2kPttkxAQAAgLYnbAcAAIBVsKrPQ39+vxtajG1yzxnp9rczU18qpWHT4eky7cFU33FWFvYdkhk7nrbaxwQAAADanrAdAAAA1qCG7r1bjL0y6vRs8o//To9mz2hfsPHwzPj4qWnsVrMGqwMAAABWlrAdAAAAyqyxW02m7/LDVM97IV3fmp4lvepSX9O/3GUBAAAA70HYDgAAAB1EfU1/ITsAAACsJSrLXQAAAAAAAAAArG2E7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgoKpyF/B+0NDQUO4SgDJZsmRJlixZUu4ygA5CTwDeSV8AmtMTgOb0BKA5PQFoTk9ofyub7wrb21l1dXXq6+sF7vA+tXjx4tTX15e7DKCD0BOAd9IXgOb0BKA5PQFoTk8AmtMTOg5hezurq6tLY2NjucsAyqS2tjZz5swpdxlAB6EnAO+kLwDN6QlAc3oC0JyeADSnJ3QcwvZ21qVLl3Tp0qXcZQBl0rVr13Tt2rXcZQAdhJ4AvJO+ADSnJwDN6QlAc3oC0Jye0HFUlrsAAAAAAAAAAFjbCNsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoqKrcBQAAADQ39YVSpk9P6uqSLfpXlLscAAAAAGiVsB0AKGTO3FK5S1hrlUqNmTvPnx+8m3lvlnLe+cnDj/x7bLshpXz75KRmvc4ZuusLQHN6QsdT27tz/vsDAAC0DWE7vMPChS5s0Ha6dSv5maLT2XtfP9Orbk65C4AOrbIyWXfd5MzTKzJkcPLIP5Nzzy/lsMOTxsbO2nv0BaA5PaGjuf3WclfA+5lrCkBzegLQXPOesM46PiBaThWlUkl3bkdz5vhFeW0zaufGcpcAAPC+debpFdl153//kvi3O0s57Qy/sgAAAAC0ZsL4ynKX0GnV1taucB1/+gAAQIcxZPDy32+3bXnqAAAAAIAVcRt5eIfbb3W7DdpO7961mTvXHS7oXMbsYYYp0H4e+Wey687//v7hR8tWCgC4RkBZuaYANKcnAM3pCR2HsB3ewbMtaEs9elRk8WI/U3QuN/2h3BWsvXrX9M7ceXPLXQZ0WN87rZQLLiqlVHp7RvvDjyYX/qiU7YYkZ53ROf891ReA5vSEjsc1AsrJNQWgOT0BaE5P6DiE7QBAIbW9ncStqtraylRU+PODd/ODM5IzfrD8M9o/Njw57b8q0ruT9h59AWhOTwAAAFi7CNsBAIAOoXfvilx4XkWmvlDK9OlJXV2yRX+hEwAAAAAdk7AdAADoULboX5Et+pe7CgAAAAB4b5XlLgAAAAAAAAAA1jbCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFBQ4bB92rRpGTRoUE455ZT2qKewQYMG5dBDD22TfV1yySUZNGhQ7r///jbZHwAAAAAAAACdk5ntAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBVW2xk8ceeyw33HBDJk6cmBkzZmTJkiXZfPPNs/fee+eII45I165dl1t/1113TZL88Y9/zHnnnZe//e1vmT9/fj7ykY/kP//zP/ORj3wkr7/+es4777zcfffdWbBgQYYPH57vf//72XzzzVutYcaMGTnnnHNy7733ZvHixRk8eHBOOumkDB06tNV1zz333EyYMCFLlizJRz7ykZxwwgmt7re+vj7XXXddxo8fn+eeey6zZs1Kr169MmzYsBx77LHZeuutV/NPDwAAAAAAAIC1TZvMbP/d736X22+/PQMHDsxBBx2UAw44IKVSKeeff36+9a1vtbpNfX19jjjiiEyePDl77LFHdt1110yePDlHHHFEpkyZkoMOOihTp07NZz/72YwcOTITJkzI0UcfnYaGhhb7mjdvXg455JBMnz49Bx54YD75yU/moYceymGHHZb7779/uXVfe+21HHTQQbnlllsyePDgHHrooampqckRRxyRhx9+uNV9n3322amvr8/o0aNz+OGHZ8SIEbnrrrty8MEH59FHH22LP0IAAAAAAAAA1iJtMrP96KOPzmmnnZYuXbo0jZVKpZx66qkZO3ZsJk2alGHDhi23zeuvv55hw4bl/PPPT1XV22VstdVWOf/883PwwQdn//33zymnnJKKiookyemnn55rr702d9xxR8aMGbPcvp5++unss88+Oeecc5rWP+CAA3LYYYfle9/7Xm677bZUVr79uYILLrggM2fOzIknnphjjjmmaR/XXXddvv/977d4bTU1NRk/fnw22mij5cafffbZHHjggbnwwgtz5ZVXruofHQAAAAAAAABroTaZ2V5XV7dc0J4kFRUV+eIXv5gkuffee1vd7rvf/W5T0J4ke++9d5Jk6dKlOeGEE5qC8yTZa6+9kiRPPfVUi/106dIlJ5100nLrjxgxIqNHj86LL76YyZMnJ3l7Nv2f//zn9OnTJ1/5yleW28fnP//59O/fv8W+q6urWwTtSbLllltm++23zwMPPJAlS5a0+voAAAAAAAAA6JzaZGZ7fX19fvOb3+SWW27J888/nwULFqRUKjUtf+2111pss95666Wurm65sQ033DBJ0r9///To0aPVZTNnzmyxr379+mWTTTZpMT5s2LCMHz8+Tz31VIYPH56pU6dm8eLF2WGHHdKtW7fl1q2srMzQoUPzwgsvtNjPk08+mSuuuCKTJk3KG2+80SJcnzNnTvr27dtiOwAAAAAAAAA6pzYJ27/5zW/mzjvvTP/+/bPnnnumT58+qaqqyptvvpmrrroq9fX1Lbbp1atXy2L+/1nuPXv2bLFs2cz5pUuXtljWp0+fVuvaYIMNkiRvvfXWcv9/t/VbG588eXK+/OUvJ0l23HHHpg8CVFRU5K9//WueeuqpVl8fAAAAAAAAAJ3Xaoftjz76aO68886MGjUqP/vZz5a7nfzDDz+cq666anUPsUKzZs1qdfyNN95I8u9gf9n/32391sYvu+yy1NfX55prrmnx3PmHH354VUsGAAAAAAAAYC222s9sf/nll5MkO++8c4vntj/44IOru/uV8sorr2TGjBktxidNmpQk2WqrrZIkW2yxRbp165bHHnssixcvXm7dxsbGpme7N/fSSy+ld+/eLYL2hQsX5oknnmirlwAAAAAAAADAWmS1w/Z+/fol+Xewvcyzzz6bn/3sZ6u7+5XS0NCQCy+8cLnnxE+cODF33XVXNt988wwdOjRJUl1dnT322COzZs3KL37xi+X2cf3117f6vPa6urrMmzcvzz777HLHO+ecczJ79uz2eUEAAAAAAAAAdGirfRv5bbfdNttuu21uvfXWvP766xkyZEhmzJiRO+64I6NHj85f/vKXtqjzPQ0aNCgTJ07MgQcemB122CGvvfZabrnlllRVVeWss85KZeW/P1Nw8skn5957781FF12USZMmZeutt86UKVNy1113ZdSoUZkwYcJy+/7Sl76UCRMm5Atf+EL22GOPVFdXZ+LEiZk5c2ZGjBiRiRMntvvrAwAAAAAAAKBjWe2Z7V26dMnll1+ez33uc3nppZfy61//Os8991y++93v5jvf+U5b1LhCNTU1ueaaa9KvX79cd911ue2227LddtvlV7/6Vbbffvvl1u3bt29++9vfZs8998wjjzySq666KnPnzs2VV16Z7bbbrsW+d9lll1x88cXZbLPN8qc//Sk333xzPvjBD+b3v/996urq1sjrAwAAAAAAAKBjqSg1v/c6bW7OnDnlLgEoo9raWn0AaKInAO+kLwDN6QlAc3oC0JyeADSnJ6wZtbW1K1xntWe2AwAAAAAAAMD7jbAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKCgqnIXALSuYtZzqZz7Uhp7fyClPgPKXQ4AAAAAAADQjLAdymXB7NbHF85N97+elqrpDzYNLa0bnkW7n5Gs07vl+j3Wb5/6AAAAAAAAgHclbIdVtWTBam3e87IdWx0vVVQm1b2ycK8L01g3LJXTJ6X77adl3av2TkWpscX6878xabXqSJJ07bH6+wAAAAAAAID3EWE7rKKelwxrl/1WlBqzcMzpaRj46SRJw8BPZ3GplO63fKvd6pj/rSdXex8AAAAAAADwflJZ7gKAlhrrlg/QGzYdXqZKAAAAAAAAgNaY2Q6raHVv3/5eM9Irp09qmtmeJF2mPfiu67bJbeQBAAAAAACAQoTtsKpW8znn879+T6vj3W86Id3+dlbqS6U0bDo8XaY9mOo7fpClm34si/a6qM3rAAAAAAAAAIoTtkO59Fi/1eFFn7043f/87eWe0b50849n0Z7nJevUrqnqAAAAAAAAgPcgbIeOZp3aLPrc/6Vi1nOpnPtSGnt/IKU+A8pdFQAAAAAAANCMsB06qFKfAWkQsgMAAAAAAECHVFnuAgAAAAAAAABgbSNsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUVFEqlUrlLgIAAAAAAAAA1iZmtgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICCqspdAEBH9Oijj+aSSy7Jww8/nCVLlmTAgAH58pe/nL333nultn/wwQfz17/+NRMnTsz06dOzYMGC1NXVZbfddsvRRx+d9dZbr8U2u+66a6ZPn97q/g466KCceeaZq/WagFW3uj3h/vvvz2GHHfauy6+77rpst912bX5coH2s7nvz0EMPzcSJE99znXPOOSf77rtv0/fOE6Bj+uMf/5hJkyblscceyzPPPJMlS5bkf/7nf7L//vsX2k9jY2OuueaaXHfddXnxxRfTo0ePbL/99jnppJPSv3//VrdxngAdT1v0BNcToPNoi57gegJ0Hm3RE1xP6JiE7QDvcP/99+fII49M165d85nPfCa9evXKuHHj8u1vfzvTp0/P17/+9RXu44QTTsicOXMybNiw7LPPPqmoqMjEiRNzxRVXZNy4cfntb3+bPn36tNiuV69e+fKXv9xifJtttmmT1wYU1xY9YZkRI0ZkxIgRLcY33njjdj0u0Hba4r253377tdoLli5dmssvvzyVlZUZOXJki+XOE6Dj+dGPfpTp06entrY2ffv2fdeLWCty2mmn5Xe/+10GDBiQL33pS5k1a1b+/Oc/55577slvf/vbDBgwYLn1nSdAx9QWPcH1BOg82uo8IXE9ATqDtugJrid0UCUAmixZsqS0++67l7bZZpvS448/3jT+1ltvlT7zmc+Utt5669LUqVNXuJ/LL7+8NHPmzOXGGhsbS6eddlpp4MCBpdNPP73FNrvssktpl112We3XALSdtuoJ9913X2ngwIGliy++eI0eF2hb7f3evO2220oDBw4sHX300S2WOU+Ajumee+4pTZs2rVQqvf07wMCBA0tjx44ttI977723NHDgwNIXvvCF0uLFi5vG//GPf5QGDRpU+uIXv7jc+s4ToONqi57gegJ0Hm3RE1xPgM6jLXrCu3E9obw8sx2gmfvuuy8vvfRS9tprr2y99dZN4z179syxxx6bpUuX5oYbbljhfr72ta+lb9++y41VVFTk2GOPTZI88MADbVs40C7aqiesLccF3lt7vzevv/76JMkBBxyw2rUCa8bHP/7x1NXVrdY+lr33TzzxxFRXVzeNjxw5MqNGjcoDDzyQqVOnNo07T4COqy16gusJ0Hm0RU8oynkCdFzt2RNcTygvt5EHaGbZ805GjRrVYtmOO+643Dqroqrq7bbbpUuXVpfX19fnxhtvzMyZM7Peeutl6NCh2WqrrVb5eMDqaeue8MILL+Sqq67KokWL0q9fv3z84x/P+uuv3+7HBdpGe743X3311dxzzz3ZcMMNs/POO7e6jvME6Jzuv//+9OjRI0OHDm2xbNSoUfn73/+eBx54IFtssUUS5wnwfuV6Ary/uZ4AvBvXE8pP2A7QzAsvvJAk2XzzzVssq6mpSW1tbV588cVV3v/YsWOT/Pvk9p1ef/31nHLKKcuNfeITn8gPf/jDVk+ggfbV1j3h5ptvzs0339z0fffu3fONb3wjRx11VLseF2gb7fneHDt2bBobG7Pffvs1XUx/J+cJ0PksWLAgr7/+egYOHNhqgNa/f/8k/+4/zb92ngDvL64nwPub6wnAu3E9ofyE7QDNzJ8/P0nSq1evVpf37Nkzr7766irt+8knn8xPfvKT9OnTp8WJcJLsv//+GTFiRAYMGJDq6upMmTIlP/7xj3P33Xfn2GOPzbXXXpuKiopVOjawatqqJ6y//vr57ne/m5133jn9+vXLm2++mfvvvz/nnXdezj333PTs2TMHH3xwmx8XaFvt9d4slUpNt3J8t1u+OU+Azumtt95K8nb/aM2y8WX9p/nXzhPg/cP1BHj/cj0BeC+uJ3QMntkOsAa8/PLLOfroo9PQ0JALLrig1U+LHX/88RkxYkTWX3/99OzZM0OGDMnll1+eYcOG5aGHHspdd91VhsqBtrDlllvmyCOPzIc+9KGss8462WijjfLZz342V1xxRbp27ZpLLrkkjY2N5S4TKJP77rsv06ZNy4gRI1qdgZI4TwCA9yvXE+D9zfUE4L24ntAxCNsBmlk2c2TZDJN3mj9//rt+MvTdTJ8+PV/+8pcze/bsXHzxxdlhhx1WetvKysrsv//+SZLJkycXOi6w+tqjJzQ3cODADBkyJG+88cZyt3Fr7+MCq6a93pvXX399knf/FPq7cZ4Aa79lPaP5zPXmlo03n/nuPAHeP1xPAN6N6wlA4npCRyFsB2hm2TMRW3t20bx58zJnzpx3/YRYa6ZNm5ZDDz00r732Wi666KLssssuhWuqra1NkixcuLDwtsDqaeue0Jpl7/FFixat0eMCxbXHe3PevHm5/fbbs9566+VTn/pU4ZqcJ8DarUePHtlwww0zbdq0NDQ0tFi+7Lmry/pP86+dJ0Dn5noCsCKuJ8D7m+sJHYewHaCZj33sY0mSCRMmtFh2zz33JElGjBixUvuaNm1aDjvssLz22mu58MILs/vuu69STY8++miSpK6ubpW2B1ZdW/aE1ixdujRPPPFEKioqsskmm6yx4wKrpj3em3/6059SX1+fvffeO927dy9ck/MEWPuNGDEiCxYsaHVGybJ+s6z/NP/aeQJ0Xq4nACviegLgekLHIWwHaGbkyJHZbLPNcvPNN+fJJ59sGp8/f34uvfTSVFVVZb/99msanz17dqZMmZLZs2cvt59lvxjPnDkzF1xwQcaMGfOex33uuefy5ptvthh/8MEHc+WVV6a6ujqf/OQnV/PVAUW1VU946KGHUiqVlhtbunRpfvjDH2b69OkZNWpUevfuvcrHBdaMtuoJzf3+979P8t63fHOeAJ3Du/WEAw88MEly0UUXpb6+vmn83nvvzYQJE/Kxj30sW2yxRdO48wToHFxPAJpzPQFozvWEtUtF6Z2dGuB97r777stRRx2Vrl27Zq+99krPnj0zbty4TJs2LSeeeGKOOeaYpnUvueSS/PjHP87xxx+fb3zjG03ju+66a6ZPn57tttsuo0aNavU4zde/5JJLcsUVV2TkyJGpq6tLdXV1nnnmmdxzzz2prKzMGWeckc9//vPt96KBd9VWPSFJPvrRj2ajjTbKW2+9lQceeCBTp05Nv3798utf/7rFp0iLHBdYc9qiJyzz2GOP5XOf+1w+8pGP5IYbbnjXYzpPgI7r+uuvz6RJk5IkzzzzTB5//PEMHTq06fasu+++e9OM1PfqCf/1X/+V66+/PgMGDMjo0aMza9as/PnPf063bt3y29/+NgMGDFhufecJ0DG1RU9wPQE6j7bqCYnrCdAZtNXvDonrCR1NVbkLAOhodthhh1xzzTW5+OKLc+utt2bJkiUZMGBATjjhhHz2s59dqX1Mnz49SfLwww/n4YcfbnWd5v9Ibr/99pkyZUqeeOKJTJw4MfX19enTp0/23HPPHH744dl2221X+3UBq6YtesLBBx+cv//975k4cWLmzJmTqqqqfOADH8jXv/71fOUrX0lNTU27HBdoe2353lyZT6EnzhOgI5s0aVJuvPHG5cYmT57cdEv4urq6lbr985lnnplBgwbluuuuy9VXX50ePXpkl112yUknnbTcrPZlnCdAx9QWPcH1BOg82qInuJ4AnUdb/e6QuJ7Q0ZjZDgAAAAAAAAAFeWY7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAr6/wAiBiUBhE85tQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -1246,53 +1271,6 @@ ")" ] }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [], - "source": [ - "from numpyro import distributions as dist\n", - "class AgentDist(dist.Distribution):\n", - "\n", - " def __init__(self, agent, env):\n", - " self.agent = agent\n", - " self.env = env\n", - "\n", - " # def sample(self):\n", - " # for b in range(blocks):\n", - " # for t in range(steps):\n", - " # responses = agent.get_responses()\n", - " # outcomes = env.get_outcomes(responses)\n", - " # agent.set_outcomes(outcomes)\n", - " \n", - " # return responses\n", - " \n", - " def log_prob(self, value):\n", - " outcomes = self.outcomes \n", - " responses = values\n", - " log_prob = 0.\n", - " for b in range(blocks):\n", - " for t in range(steps):\n", - " log_prob += agent.get_log_prob(outcomes[b, t], responses[b, t])\n", - "\n", - "\n", - "def model(data, env, T, n_pars=3):\n", - " z = npyro.sample('z', dist.Normal(0., 1.).expand([n_pars]).to_event(1))\n", - " x = trans_params(z)\n", - "\n", - " agent = Agent(x)\n", - " \n", - " if 'responses' in data:\n", - " env = data['outcomes']\n", - " obs= data['choices']\n", - " else:\n", - " env = env\n", - " obs = None\n", - " \n", - " choices = npyro.sample('choices', AgentDist(agent, env), obs=obs)" - ] - }, { "cell_type": "code", "execution_count": null, diff --git a/pymdp/jax/likelihoods.py b/pymdp/jax/likelihoods.py new file mode 100644 index 00000000..6a084779 --- /dev/null +++ b/pymdp/jax/likelihoods.py @@ -0,0 +1,55 @@ +import jax.numpy as jnp +import numpyro.distributions as dist +from jax import lax +from numpyro import plate, sample, deterministic +from numpyro.contrib.control_flow import scan + +def evolve_trials(agent, data): + + def step_fn(carry, xs): + outcome = xs['outcomes'] + qx = agent.infer_states(outcome) + q_pi, _ = agent.infer_policies() + + nc = agent.num_controls + num_factors = len(agent.num_controls) + + marginal = [] + for factor_i in range(num_factors): + m = [] + actions = agent.policies[:, 0, factor_i] + for a in range(nc[factor_i]): + m.append( jnp.where(actions==a, q_pi, 0).sum() ) + marginal.append(jnp.stack(m)) + + action = xs['actions'] + agent.update_empirical_prior(action) + #TODO: if outcomes and actions are None, generate samples + return None, (marginal, outcome, action) + + _, res = lax.scan(step_fn, None, data) + + return res[0], res[1], res[2] + +def aif_likelihood(Na, Nb, Nt, data, agent): + # Na -> batch dimension - number of different subjects/agents + # Nb -> number of experimental blocks + # Nt -> number of trials within each block + + def step_fn(carry, xs): + probs, outcomes, actions = evolve_trials(agent, xs) + + probs = 0.5*jnp.ones((2, 2)) + print(probs.shape) + + # deterministic('outcomes', outcomes) + + with plate('num_agents', Na): + with plate('num_trials', Nt): + sample('actions', dist.Categorical(probs=probs).to_event(1)) + + return None, None + + # TODO: See if some information has to be passed from one block to the next and change init and carry accordingly + init = None + scan(step_fn, init, data, length=Nb) \ No newline at end of file From b26418b278cb9931f3472a629f05e274c52a644c Mon Sep 17 00:00:00 2001 From: conorheins Date: Tue, 1 Nov 2022 19:31:09 +0100 Subject: [PATCH 020/232] unit test that validates that agent methods can be vmapped (tagging @dimarkov) --- test/test_agent_jax.py | 73 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 73 insertions(+) create mode 100644 test/test_agent_jax.py diff --git a/test/test_agent_jax.py b/test/test_agent_jax.py new file mode 100644 index 00000000..355bfdac --- /dev/null +++ b/test/test_agent_jax.py @@ -0,0 +1,73 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +""" Unit Tests +__author__: Conor Heins +""" + +import os +import unittest + +import numpy as np +import jax.numpy as jnp +from jax import vmap, nn, random +from jax.tree_util import register_pytree_node_class + +from pymdp.jax.maths import compute_log_likelihood_single_modality +from pymdp.jax.utils import norm_dist + +class TestAgentJax(unittest.TestCase): + + def test_vmappable_agent_methods(self): + + dim, N = 5, 10 + sampling_key = random.PRNGKey(1) + + @register_pytree_node_class + class BasicAgent(object): + def __init__(self, A, B): + self.A = A + self.B = B + self.qs = norm_dist(jnp.ones(dim)) + + def tree_flatten(self): + children = (self.A, self.B) + aux_data = None + return (children, aux_data) + + @vmap + def infer_states(self, obs): + qs = nn.softmax(compute_log_likelihood_single_modality(obs, self.A)) + self.qs = qs # @NOTE: weirdly, adding this line doesn't actually change self.qs. When you query self.qs afterwards it's just the same as it was initialized in `self.__init__()` + return qs + + @classmethod + def tree_unflatten(cls, aux_data, children): + return cls(*children) + + A_key, B_key, obs_key, test_key = random.split(sampling_key, 4) + + all_A = vmap(norm_dist)(random.uniform(A_key, shape = (N, dim, dim))) + all_B = vmap(norm_dist)(random.uniform(B_key, shape = (N, dim, dim))) + all_obs = vmap(nn.one_hot, (0, None))(random.choice(obs_key, dim, shape = (N,)), dim) + + my_agent = BasicAgent(all_A, all_B) + + all_qs = my_agent.infer_states(all_obs) + + # validate that the method broadcasted properly + for id_to_check in range(N): + validation_qs = nn.softmax(compute_log_likelihood_single_modality(all_obs[id_to_check], all_A[id_to_check])) + self.assertTrue(jnp.allclose(validation_qs, all_qs[id_to_check])) + +if __name__ == "__main__": + unittest.main() + + + + + + + + + From 3b6b639ba24f1506ddfaa6478e8bb7f641a04094 Mon Sep 17 00:00:00 2001 From: conorheins Date: Wed, 2 Nov 2022 19:32:34 +0100 Subject: [PATCH 021/232] beginning of attempt to vmap the methods of agent class, first by registering the class as a pytree node. @dimarkov see my comments under the @classmethod `tree_unflatten(cls, aux_data, children)` --- pymdp/jax/agent.py | 33 ++++++++++++++++++++++++++------- 1 file changed, 26 insertions(+), 7 deletions(-) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 7c2ea277..830913b8 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -1,16 +1,18 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- -""" Agent Class iplementation in Jax +""" Agent Class implementation in Jax __author__: Conor Heins, Dimitrije Markovic, Alexander Tschantz, Daphne Demekas, Brennan Klein """ import jax.numpy as jnp -from jax import nn +from jax import nn, vmap +from jax.tree_util import register_pytree_node_class from . import inference, control, learning, utils, maths +@register_pytree_node_class class Agent(object): """ The Agent class, the highest-level API that wraps together processes for action, perception, and learning under active inference. @@ -34,10 +36,10 @@ def __init__( B, C=None, D=None, - E = None, + E=None, pA=None, - pB = None, - pD = None, + pB=None, + pD=None, num_controls=None, policy_len=1, inference_horizon=1, @@ -125,6 +127,23 @@ def __init__( self.action = None self.prev_actions = None + + def tree_flatten(self): + children = (self.A, self.B, self.C, self.D, self.E, self.pA, self.pB, self.num_controls, self.policy_len, self.control_fac_idx, + self.policies, self.gamma, self.use_utility, self.use_states_info_gain, self.use_param_info_gain, self.action_selection, + self.modalities_to_learn, self.lr_pA, self.factors_to_learn, self.lr_pB, self.lr_pD) + aux_data = None + return (children, aux_data) + + @classmethod + def tree_unflatten(cls, aux_data, children): + # @NOTE: @dimarkov, see here: I'm unclear on how to handle this, since when this function gets vmapped across the leaf-nodes stored in `children`, some of + # these leaves (e.g. leaves like `self.use_states_info_gain`) won't be `jnp.arrays` with a batch dimension. + # + # We either need to not have them get vmapped across or turn them into NDarray representations with a proper batch dimension. Another example are lists like `self.modalities_to_learn` + # which can be a list of arbitrary length (e.g. something like `[0, 2, 3]`). For instance, we might have to turn this into a boolean array per agent with equal length, and then stacked them + # along a batch-dimension for each agent. + return cls(*children) def reset(self, init_qs=None): """ @@ -229,7 +248,7 @@ def get_future_qs(self): return future_qs_seq - + @vmap def infer_states(self, observations): """ Update approximate posterior over hidden states by solving variational inference problem, given an observation. @@ -257,7 +276,7 @@ def infer_states(self, observations): prior=self.empirical_prior ) - self.qs = qs + self.qs = qs # this doesn't work, apparently? return qs From 3783750d48baa047fab07c7abc59ed71c6097ab8 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Fri, 4 Nov 2022 11:52:44 +0100 Subject: [PATCH 022/232] created dependency on equinox to turn agent into PyTree we use equinox.Module --- test/test_agent_jax.py | 32 +++++++++++++++----------------- 1 file changed, 15 insertions(+), 17 deletions(-) diff --git a/test/test_agent_jax.py b/test/test_agent_jax.py index 355bfdac..9f46b1fc 100644 --- a/test/test_agent_jax.py +++ b/test/test_agent_jax.py @@ -11,10 +11,12 @@ import numpy as np import jax.numpy as jnp from jax import vmap, nn, random -from jax.tree_util import register_pytree_node_class +import jax.tree_util as jtu from pymdp.jax.maths import compute_log_likelihood_single_modality from pymdp.jax.utils import norm_dist +from equinox import Module +from typing import Any, List class TestAgentJax(unittest.TestCase): @@ -23,27 +25,20 @@ def test_vmappable_agent_methods(self): dim, N = 5, 10 sampling_key = random.PRNGKey(1) - @register_pytree_node_class - class BasicAgent(object): - def __init__(self, A, B): + class BasicAgent(Module): + A: jnp.ndarray + B: jnp.ndarray + qs: jnp.ndarray + + def __init__(self, A, B, qs=None): self.A = A self.B = B - self.qs = norm_dist(jnp.ones(dim)) + self.qs = jnp.ones((N, dim))/dim if qs is None else qs - def tree_flatten(self): - children = (self.A, self.B) - aux_data = None - return (children, aux_data) - @vmap def infer_states(self, obs): qs = nn.softmax(compute_log_likelihood_single_modality(obs, self.A)) - self.qs = qs # @NOTE: weirdly, adding this line doesn't actually change self.qs. When you query self.qs afterwards it's just the same as it was initialized in `self.__init__()` - return qs - - @classmethod - def tree_unflatten(cls, aux_data, children): - return cls(*children) + return qs, BasicAgent(self.A, self.B, qs=qs) A_key, B_key, obs_key, test_key = random.split(sampling_key, 4) @@ -53,7 +48,10 @@ def tree_unflatten(cls, aux_data, children): my_agent = BasicAgent(all_A, all_B) - all_qs = my_agent.infer_states(all_obs) + all_qs, my_agent = my_agent.infer_states(all_obs) + + assert all_qs.shape == my_agent.qs.shape + self.assertTrue(jnp.allclose(all_qs, my_agent.qs)) # validate that the method broadcasted properly for id_to_check in range(N): From f30e44b1e40904b764ad867745b64c61f1aa3884 Mon Sep 17 00:00:00 2001 From: Dimitrije Markovic <5038100+dimarkov@users.noreply.github.com> Date: Tue, 8 Nov 2022 18:27:07 +0100 Subject: [PATCH 023/232] changed agent into pytree and tested paralel inference and action sampling --- examples/model_inversion.ipynb | 321 +++++++--------------------- pymdp/jax/agent.py | 379 ++++++--------------------------- pymdp/jax/control.py | 103 +++++++++ 3 files changed, 248 insertions(+), 555 deletions(-) diff --git a/examples/model_inversion.ipynb b/examples/model_inversion.ipynb index 2fad3e7a..3648f43a 100644 --- a/examples/model_inversion.ipynb +++ b/examples/model_inversion.ipynb @@ -16,13 +16,11 @@ "import jax\n", "import jax.numpy as jnp\n", "\n", - "import numpy as np\n", "import seaborn as sns\n", "import matplotlib.pyplot as plt\n", "import copy\n", "\n", - "from pymdp.agent import Agent\n", - "from pymdp import utils\n", + "from pymdp.jax.agent import Agent\n", "from pymdp.envs import TMazeEnv" ] }, @@ -150,7 +148,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -172,7 +170,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -194,7 +192,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -241,7 +239,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -281,7 +279,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -301,7 +299,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -321,7 +319,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -341,7 +339,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAesAAAGiCAYAAADHpO4FAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAtg0lEQVR4nO3de3hU1bnH8d8kIZMLEkgg4WqItiI1iBqKBpqjgES5tVgoVJSLgI8R1AciHowcCSDtHC+lWEpAj1zERoxXUEk9BBFBwRsgVi56UDRVE5CggqADJOv8wZMpw0zCTJzA3t3fz/PsP7KyZtbas2fmnffda8+4jDFGAADAsqLO9gQAAED9CNYAAFgcwRoAAIsjWAMAYHEEawAALI5gDQCAxRGsAQCwOII1AAAWR7AGAMDiwgrWLpcrpG3dunWNNN3wrVu3LmBOpaWlmjFjRtD+HTt21JgxY87I3E4WbJ4zZsyQy+Xy69exY0cNHDgwImMuXbpULpdLn332ma9tzJgx6tixo18/l8ul2267LSJjRkKwx6ouJSUluuiiixQfHy+Xy6X333+/0ef12Wef6bPPPqvzeEZFRenTTz8NuP3hw4fVrFkzuVyus/IcDNWTTz6puXPnNtr9v/TSSxo0aJDS0tIUGxur5ORk9enTR8XFxTp27FijjVsXqz3/a53t97EZM2b43itq30vQeMIK1ps2bfLb+vfvr/j4+ID2yy67rLHmG7bLLrssYE6lpaWaOXNm0P4vvPCC7r333jM1vXqNHz9emzZtOqNj3nvvvXrhhRfO6JiN5euvv9bIkSN1/vnn65VXXtGmTZt0wQUXnO1pqWnTplqyZElA+zPPPKNjx46pSZMmZ2FWoWusYG2M0U033aRf//rXqqmp0Zw5c7RmzRo9/vjj6tq1qyZMmKCioqKIj2tXdnkfQ2TEhNP5iiuu8Pu7VatWioqKCmg/1ZEjR5SQkBD+7CKgWbNmp53fyS699NJGnE142rdvr/bt25/RMc8///wzOl5j+vjjj3Xs2DHdeOONuvLKKyNyn5F4Lg8fPlyPP/64Zs6cqaiof31eXrRoka677jq9+OKLP3WatvTggw9q6dKlmjlzpqZPn+73v0GDBuk///M/tXv37rM0O3ux0vsYIiPi56yvuuoqZWZmav369erRo4cSEhI0duxYSSdKkrm5uWrTpo3i4+PVuXNn3X333Tp8+LDffYwZM0ZNmzbV7t271b9/fzVt2lQdOnTQnXfeKa/X69d3wYIF6tq1q5o2bapzzjlHF154oe655x7f/08tmY4ZM0bz58+X5F/Wry0FBysflZeX68Ybb1Rqaqrcbrc6d+6sP/3pT6qpqfH1qS17PvTQQ5ozZ44yMjLUtGlTZWdn66233mrQYxmsDB5MUVGRYmJiVFhY6Gtbs2aN+vTpo2bNmikhIUE9e/bUq6++etr7ClYGr/XEE0+oc+fOSkhIUNeuXfXyyy8H9HnjjTfUp08fnXPOOUpISFCPHj20atWqgH4ffvihfvOb36hFixaKi4vTJZdcoscffzyg365du3TttdcqISFBLVu2VF5eng4dOhTSfvzqV7+SdCI4ulwuXXXVVb7/v/jii8rOzlZCQoLOOecc9e3bN6CKUfv4b9myRUOHDlWLFi0i8mFm7Nix+uc//6mysjJf28cff6w33njD91o51emeg8eOHVNqaqpGjhwZcNtvv/1W8fHxys/P97UdPHhQU6ZMUUZGhmJjY9WuXTtNmjQp4LV4qquuukqrVq3S559/7vf6qXXgwAFNmDBB7dq1U2xsrM477zxNmzYt4HV7qmPHjun+++/XhRdeWGdG2Lp1a98xretUSO3rcOnSpX7t7733nn79618rOTlZcXFxuvTSS/X000/XO6dwhLrfNTU1mjdvni655BLFx8erefPmuuKKK/w+oIXyPmmn9zFEiPkJRo8ebRITE/3arrzySpOcnGw6dOhg5s2bZ1577TXz+uuvG2OMue+++8yf//xns2rVKrNu3TqzcOFCk5GRYXr16hVwv7GxsaZz587moYceMmvWrDHTp083LpfLzJw509dv+fLlRpK5/fbbzerVq82aNWvMwoULzR133OHr89prrxlJ5rXXXjPGGLN7924zdOhQI8ls2rTJt/3444/GGGPS09PN6NGjfbfft2+fadeunWnVqpVZuHCheeWVV8xtt91mJJlbb73V12/Pnj1GkunYsaO59tprzYoVK8yKFStMly5dTIsWLcy3335b72N56jyNMaawsNCceojS09PNgAEDjDHG1NTUmDvvvNM0adLELFmyxNfniSeeMC6XywwePNg8//zz5qWXXjIDBw400dHRZs2aNb5+S5YsMZLMnj17/B779PR0vzFr96t79+7m6aefNqWlpeaqq64yMTEx5pNPPvH1W7dunWnSpInJysoyJSUlZsWKFSY3N9e4XC7z1FNP+frt2rXLnHPOOeb88883y5YtM6tWrTLXX3+9kWTuv/9+X7/KykqTmppq2rVrZ5YsWWJKS0vNDTfcYM4999yAx+pUu3fvNvPnzzeSzB//+EezadMms337dmOMMcXFxUaSyc3NNStWrDAlJSUmKyvLxMbGmg0bNgQ8/unp6Wbq1KmmrKzMrFixos4xT6f2/r7++muTk5Njhg0b5vvf1KlTTceOHU1NTY1JTExs0HNw8uTJJj4+3nz33Xd+4xYVFRlJ5oMPPjDGGHP48GFzySWXmJYtW5o5c+aYNWvWmIcfftgkJSWZ3r17m5qamjr3Yfv27aZnz56mdevWfq8fY4z54YcfzMUXX2wSExPNQw89ZFavXm3uvfdeExMTY/r371/vY7Nx40YjyUydOjWkxzLY68WYf70OT349rF271sTGxpqcnBxTUlJiXnnlFTNmzJiAfnWRZCZOnFjn/8PZ75EjRxqXy2XGjx9vVq5caf7+97+bP/zhD+bhhx/29QnlfdKq72NoPI0SrCWZV199td7b1tTUmGPHjpnXX3/dSDLbtm3zu19J5umnn/a7Tf/+/U2nTp18f992222mefPm9Y4T7EU9ceLEgCBY69Qn+d13320kmbffftuv36233mpcLpf56KOPjDH/epJ36dLFHD9+3NfvnXfeMZLM8uXLw55nfcH6yJEjZsiQISYpKckvAB8+fNgkJyebQYMG+d2uurradO3a1XTv3t3XFk6wTktLMwcPHvS1VVZWmqioKOPxeHxtV1xxhUlNTTWHDh3ytR0/ftxkZmaa9u3b+4LA73//e+N2u015ebnfOP369TMJCQm+N4SpU6cal8tl3n//fb9+ffv2PW2wNuZfj+kzzzzj9zi0bdvWdOnSxVRXV/vaDx06ZFJTU02PHj18bbWP//Tp0+sdJ1QnB+slS5YYt9ttqqqqzPHjx02bNm3MjBkzjDEmIFiH+hz84IMPjCTz6KOP+vXr3r27ycrK8v3t8XhMVFSUeffdd/36Pfvss0aSKS0trXc/BgwYEPAcMcaYhQsXBn3d3n///UaSWb16dZ33+dRTTxlJZuHChfWOXSucYH3hhReaSy+91Bw7dsyv78CBA02bNm38ngfBnC5Yh7rf69evN5LMtGnTQtjDE+p7n7Ti+xgaT6NcutWiRQv17t07oP3TTz/ViBEj1Lp1a0VHR6tJkya+c4k7d+706+tyuTRo0CC/tosvvliff/657+/u3bvr22+/1fXXX6+VK1dq//79Ed+XtWvX6he/+IW6d+/u1z5mzBgZY7R27Vq/9gEDBig6OtpvzpL85v1TVVVVqXfv3nrnnXd8ZedaGzdu1IEDBzR69GgdP37ct9XU1Ojaa6/Vu+++e9pSZzC9evXSOeec4/s7LS1Nqampvv06fPiw3n77bQ0dOlRNmzb19YuOjtbIkSP1xRdf6KOPPpJ04jHt06ePOnTo4DfGmDFjdOTIEV85+rXXXtNFF12krl27+vUbMWJE2POv9dFHH+mrr77SyJEj/c4XN23aVEOGDNFbb72lI0eO+N1myJAhDR6vLr/73e8UGxur4uJilZaWqrKyss7Vu6E+B7t06aKsrCy/xWs7d+7UO++841def/nll5WZmalLLrnE7zlyzTXX/KSrOdauXavExEQNHTo0YJ6SQjoNE2m7d+/Wrl27dMMNN0iS3/72799fFRUVvudlQ4W633//+98lSRMnTqz3/sJ5nwxnjlZ7H0N4wlpgFqo2bdoEtH3//ffKyclRXFycZs+erQsuuEAJCQn65z//qd/+9rf64Ycf/PonJCQoLi7Or83tduvHH3/0/T1y5EgdP35c//M//6MhQ4aopqZGv/zlLzV79mz17ds3IvtSVVUV9Bxu27Ztff8/WUpKSsCcJQXs30/x8ccf65tvvtHNN9+szMxMv//t3btXkgLeOE524MABJSYmhjXmqfslndi32v365ptvZIwJeuxPfayqqqpC7peRkRHQr3Xr1mHN/WS1913X+DU1Nfrmm2/8FpEF6/tTJSYmavjw4Vq8eLHS09N19dVXKz09vc45h/ocHDt2rCZOnKhdu3bpwgsv1JIlS+R2u3X99df7+uzdu1e7d++uc9V5Qz/0VlVVqXXr1gHrLFJTUxUTExPwWjnZueeeK0nas2dPg8auS+3rYcqUKZoyZUrQPj/1Q36o+/31118rOjq63udvuO+T4czRau9jCE+jBOtgi6LWrl2rr776SuvWrfNbmfvtt9/+pLFuuukm3XTTTTp8+LDWr1+vwsJCDRw4UB9//HGdb37hSElJUUVFRUD7V199JUlq2bLlTx4jXNnZ2frd736ncePGSTqxyK42S6ydz7x58+pcBZ+WlhbxObVo0UJRUVEhPVahPqYpKSmqrKwM6BesLVS1b0J1jR8VFaUWLVr4tTfW9aNjx47VY489pg8++EDFxcV19gvnOXj99dcrPz9fS5cu1R/+8Ac98cQTGjx4sN8+tWzZUvHx8Vq8eHHQ8Rr6nE5JSdHbb78tY4zfY7Zv3z4dP3683vvt1q2bkpOTtXLlSnk8ntM+5rUf5E9dwHVq4K0ds6CgQL/97W+D3lenTp3qHet0Qt3vVq1aqbq6WpWVlXV+AGys90krvo8hPGfsG8xqn8S1n9BqPfLIIxG5/8TERPXr10/Tpk3T0aNHtX379jr7hvMpsU+fPtqxY4e2bNni175s2TK5XC716tXrp028gUaPHq2nnnpKS5Ys0ahRo1RdXS1J6tmzp5o3b64dO3aoW7duQbfY2NiIzycxMVGXX365nn/+eb/HtaamRn/729/Uvn173zXOffr08b0pnWzZsmVKSEjwfcjo1auXtm/frm3btvn1e/LJJxs8z06dOqldu3Z68sknZYzxtR8+fFjPPfecb4X4mZCdna2xY8fquuuu03XXXVdnv3Cegy1atNDgwYO1bNkyvfzyy6qsrAxYYT5w4EB98sknSklJCfr8qOtqgFonV1ROnef333+vFStWBMyz9v91adKkiaZOnapdu3bpvvvuC9pn3759evPNNyXJN8cPPvjAr8+pl7116tRJP//5z7Vt27Y6Xw8nn95piFD3u1+/fpJOfLiuSzjvk/8O72MIXaNk1sH06NFDLVq0UF5engoLC9WkSRMVFxcHvBGH4+abb1Z8fLx69uypNm3aqLKyUh6PR0lJSfrlL39Z5+26dOkiSbr//vvVr18/RUdH6+KLLw4axCZPnqxly5ZpwIABmjVrltLT07Vq1SoVFRXp1ltvPatfsjF06FAlJCRo6NCh+uGHH7R8+XI1bdpU8+bN0+jRo3XgwAENHTpUqamp+vrrr7Vt2zZ9/fXX9b5Z/BQej0d9+/ZVr169NGXKFMXGxqqoqEgffvihli9f7nsjKiws1Msvv6xevXpp+vTpSk5OVnFxsVatWqUHHnhASUlJkqRJkyZp8eLFGjBggGbPnq20tDQVFxdr165dDZ5jVFSUHnjgAd1www0aOHCgbrnlFnm9Xj344IP69ttv9d///d8ReSxCtWjRotP2Cfc5OHbsWJWUlOi2225T+/btdfXVV/v9f9KkSXruuef0H//xH5o8ebIuvvhi1dTUqLy8XKtXr9add96pyy+/vM75dOnSRc8//7wWLFigrKwsRUVFqVu3bho1apTmz5+v0aNH67PPPlOXLl30xhtv6I9//KP69+8fMI9T3XXXXdq5c6cKCwv1zjvvaMSIEerQoYO+++47rV+/Xo8++qhmzpypnj17qnXr1rr66qvl8XjUokULpaen69VXX9Xzzz8fcL+PPPKI+vXrp2uuuUZjxoxRu3btdODAAe3cuVNbtmzRM888c9pj8Mknn+jZZ58NaP/FL34R8n7n5ORo5MiRmj17tvbu3auBAwfK7XZr69atSkhI0O233x7W++S/y/sYQvRTVqfVtRr8oosuCtp/48aNJjs72yQkJJhWrVqZ8ePHmy1btgSs3gx2v8YEro5+/PHHTa9evUxaWpqJjY01bdu2NcOGDfNdomJM8FWjXq/XjB8/3rRq1cq4XC6/FdGnrqI0xpjPP//cjBgxwqSkpJgmTZqYTp06mQcffNBvFWntKsoHH3wwYN6STGFhYdDHpL55nu7SrZNv27RpU3PttdeaI0eOGGOMef31182AAQNMcnKyadKkiWnXrp0ZMGCA38rocFaDB1sNG+yx2rBhg+ndu7dJTEw08fHx5oorrjAvvfRSwG3/8Y9/mEGDBpmkpCQTGxtrunbtGvQymh07dpi+ffuauLg4k5ycbMaNG2dWrlzZ4NXgtVasWGEuv/xyExcXZxITE02fPn3Mm2++6dfn5NXbkRDq/Z26GtyY0J6Dtaqrq02HDh3qXXn8/fffm//6r/8ynTp1MrGxsSYpKcl06dLFTJ482VRWVtY7vwMHDpihQ4ea5s2b+14/taqqqkxeXp5p06aNiYmJMenp6aagoMB3SVEoVq5caQYMGGBatWplYmJiTIsWLUyvXr3MwoULjdfr9fWrqKgwQ4cONcnJySYpKcnceOON5r333gt6Sda2bdvMsGHDTGpqqmnSpIlp3bq16d27d0irzyXVudW+rkPd7+rqavPnP//ZZGZm+h737Oxsv9dIqO+TVnwfQ+NxGXNSLRAAAFgOv7oFAIDFEawBALA4gjUAABZHsAYAIETr16/XoEGD1LZtW7lcroBL9oJ5/fXXlZWVpbi4OJ133nlauHBh2OMSrAEACNHhw4fVtWtX/fWvfw2p/549e9S/f3/l5ORo69atuueee3THHXfoueeeC2tcVoMDANAALpdLL7zwggYPHlxnn6lTp+rFF1/0+173vLw8bdu2LeBneesT9EtRvF5vwNf4ud3ugG/VAQDA7hoz5m3atEm5ubl+bddcc40WLVqkY8eO1fkd/acKGqw9Ho9mzpzp11ZYWKgZM2Y0bLYAAETYjEh9b39hYaPFvMrKyoDfY0hLS9Px48e1f//+kH8oKGiwLigoUH5+vl8bWTUAwEoitehqaiPHvFN/mKb27HM4PxIUNFhT8gYAOEVjxrzWrVsH/FLgvn37FBMTE/Snh+vSsB/y+LHu36VFI4oLcmA5FmcHx8JaOB7WEexYNJLG+fHayMrOztZLL73k17Z69Wp169Yt5PPVEpduAQBsKipCWzi+//57vf/++3r//fclnbg06/3331d5ebmkE6eRR40a5eufl5enzz//XPn5+dq5c6cWL16sRYsWacqUKWGNe8Z+IhMAALt77733/H7/u/Zc9+jRo7V06VJVVFT4ArckZWRkqLS0VJMnT9b8+fPVtm1b/eUvf9GQIUPCGrdh11lTXjo7KPVZB8fCWjge1nEGy+CeCK0GL7DB142QWQMAbMkO56wjhXPWAABYHJk1AMCWnJRtEqwBALbkpDI4wRoAYEtOyqydtK8AANgSmTUAwJaclG0SrAEAtuSkc9ZO+mACAIAtkVkDAGzJSdkmwRoAYEtOCtZO2lcAAGyJzBoAYEtOWmBGsAYA2JKTSsNO2lcAAGyJzBoAYEuUwQEAsDgnlYYJ1gAAW3JSsHbSvgIAYEtk1gAAW+KcNQAAFuek0rCT9hUAAFsiswYA2JKTsk2CNQDAlpx0ztpJH0wAALAlMmsAgC05KdskWAMAbMlJwdpJ+woAgC2RWQMAbMlJC8wI1gAAW3JSaZhgDQCwJSdl1k76YAIAgC2RWQMAbMlJ2SbBGgBgS04K1k7aVwAAbInMGgBgS05aYEawBgDYkpNKw07aVwAAbInMGgBgS07KNgnWAABbctI5ayd9MAEAwJbIrAEAtuSKck5uTbAGANiSy0WwBgDA0qIclFlzzhoAAIsjswYA2BJlcAAALM5JC8wogwMAYHFk1gAAW6IMDgCAxVEGBwAAlkFmDQCwJcrgAABYHGVwAABgGWTWAABbogwOAIDFOem7wQnWAABbclJmzTlrAAAsjswaAGBLTloNTrAGANgSZXAAAGAZZNYAAFuiDA4AgMVRBgcAAHUqKipSRkaG4uLilJWVpQ0bNtTbv7i4WF27dlVCQoLatGmjm266SVVVVSGPR7AGANiSK8oVkS1cJSUlmjRpkqZNm6atW7cqJydH/fr1U3l5edD+b7zxhkaNGqVx48Zp+/bteuaZZ/Tuu+9q/PjxIY9JsAYA2JLL5YrIFq45c+Zo3LhxGj9+vDp37qy5c+eqQ4cOWrBgQdD+b731ljp27Kg77rhDGRkZ+tWvfqVbbrlF7733XshjEqwBAI7m9Xp18OBBv83r9Qbte/ToUW3evFm5ubl+7bm5udq4cWPQ2/To0UNffPGFSktLZYzR3r179eyzz2rAgAEhz5FgDQCwpagoV0Q2j8ejpKQkv83j8QQdc//+/aqurlZaWppfe1pamiorK4PepkePHiouLtbw4cMVGxur1q1bq3nz5po3b17o+xr6wwIAgHVEqgxeUFCg7777zm8rKCg47dgnM8bUWVLfsWOH7rjjDk2fPl2bN2/WK6+8oj179igvLy/kfeXSLQCALUXqOmu32y232x1S35YtWyo6Ojogi963b19Atl3L4/GoZ8+euuuuuyRJF198sRITE5WTk6PZs2erTZs2px2XzBoAgBDFxsYqKytLZWVlfu1lZWXq0aNH0NscOXJEUVH+4TY6OlrSiYw8FGTWAABbOltfipKfn6+RI0eqW7duys7O1qOPPqry8nJfWbugoEBffvmlli1bJkkaNGiQbr75Zi1YsEDXXHONKioqNGnSJHXv3l1t27YNaUyCNQDAllxnqTY8fPhwVVVVadasWaqoqFBmZqZKS0uVnp4uSaqoqPC75nrMmDE6dOiQ/vrXv+rOO+9U8+bN1bt3b91///0hj+kyoebgJ/sx9G9dQQTFpQS2cSzODo6FtXA8rCPYsWgkW34W/BxxuC7bvTci99OYyKwBALbkpO8GJ1gDAGzJSb+6xWpwAAAsjswaAGBLUZTBAQCwNsrgAADAMsisAQC2xGpwAAAszkllcII1AMCWyKxP5wx+Qw1Og2NhHRwLa+F44N9I0GDt9Xrl9Xr92sL5CTEAABqbk8rgQVeDezweJSUl+W0ej+dMzw0AgDq5XK6IbHYQ9Ic8yKwBAFa369KOEbmfC7d+FpH7aUxBy+AEZgCA1bminPNVIQ1bYMZPz50d/AygdXAsrIXjYR1ncGGf489ZAwAA6+A6awCAPdlkcVgkEKwBALZEGRwAAFgGmTUAwJZYDQ4AgMXZ5QtNIoFgDQCwJ85ZAwAAqyCzBgDYEuesAQCwOCeds3bOxxIAAGyKzBoAYEtO+lIUgjUAwJ4cFKwpgwMAYHFk1gAAW3K5nJNvEqwBALbkpHPWzvlYAgCATZFZAwBsyUmZNcEaAGBPnLMGAMDanJRZO+djCQAANkVmDQCwJSdl1gRrAIAt8UMeAADAMsisAQD2xO9ZAwBgbU46Z+2cjyUAANgUmTUAwJactMCMYA0AsCWXg85ZO2dPAQCwKTJrAIAtOWmBGcEaAGBPnLMGAMDanJRZc84aAACLI7MGANiSk1aDE6wBALbkpOusnfOxBAAAmyKzBgDYk4MWmBGsAQC25KRz1s7ZUwAAbIrMGgBgS05aYEawBgDYEl+KAgAALIPMGgBgT5TBAQCwNieVwQnWAAB7ck6s5pw1AABWR2YNALAnB52zJrMGANiSyxWZrSGKioqUkZGhuLg4ZWVlacOGDfX293q9mjZtmtLT0+V2u3X++edr8eLFIY9HZg0AQBhKSko0adIkFRUVqWfPnnrkkUfUr18/7dixQ+eee27Q2wwbNkx79+7VokWL9LOf/Uz79u3T8ePHQx7TZYwxYc/0x6qwb4IIiEsJbONYnB0cC2vheFhHsGPRSA7ePjAi99Ns3sth9b/88st12WWXacGCBb62zp07a/DgwfJ4PAH9X3nlFf3+97/Xp59+quTk5AbNkTI4AMCWIlUG93q9OnjwoN/m9XqDjnn06FFt3rxZubm5fu25ubnauHFj0Nu8+OKL6tatmx544AG1a9dOF1xwgaZMmaIffvgh5H0lWAMAHM3j8SgpKclvC5YhS9L+/ftVXV2ttLQ0v/a0tDRVVlYGvc2nn36qN954Qx9++KFeeOEFzZ07V88++6wmTpwY8hw5Zw0AsKcIrQYvKChQfn6+X5vb7T7N0P5jG2Pq/GGRmpoauVwuFRcXKykpSZI0Z84cDR06VPPnz1d8fPxp50iwBgDYU4Rqw263+7TBuVbLli0VHR0dkEXv27cvINuu1aZNG7Vr184XqKUT57iNMfriiy/085///LTjUgYHANiSy+WKyBaO2NhYZWVlqayszK+9rKxMPXr0CHqbnj176quvvtL333/va/v4448VFRWl9u3bhzQuwRoAgDDk5+frscce0+LFi7Vz505NnjxZ5eXlysvLk3SirD5q1Chf/xEjRiglJUU33XSTduzYofXr1+uuu+7S2LFjQyqBS5TBAQB2dZa+wWz48OGqqqrSrFmzVFFRoczMTJWWlio9PV2SVFFRofLycl//pk2bqqysTLfffru6deumlJQUDRs2TLNnzw55TK6zthOuJbUOjoW1cDys4wxeZ314ym8icj+JD62MyP00JsrgAABYHGVwAIA98XvWAABYnHNiNWVwAACsjswaAGBL4V4jbWcEawCAPTknVlMGBwDA6sisAQC25GI1OAAAFuecWE2wBgDYlIMWmHHOGgAAiyOzBgDYkoMSa4I1AMCmHLTAjDI4AAAWR2YNALAlyuAAAFidg6I1ZXAAACyOzBoAYEsOSqwJ1gAAm2I1OAAAsAoyawCAPTmoDk6wBgDYkoNiNcEaAGBTDorWnLMGAMDiyKwBALbkclC6SbAGANgTZXAAAGAVZNYAAHtyTmLdwGAdlxLhaaDBOBbWwbGwFo7Hvz2Xg8rgQYO11+uV1+v1a3O73XK73WdkUgAA4F+CnrP2eDxKSkry2zwez5meGwAAdYtyRWazAZcxxpzaSGYNALC66rk3RuR+oif9LSL305iClsEJzAAAWEfDFpj9WBXhaSAkwRbMcCzODo6FtXA8rONMLuyzSQk7Erh0CwBgTw76CjOCNQDAnhx06ZZzPpYAAGBTZNYAAHvinDUAABbnoHPWztlTAABsiswaAGBPlMEBALA4VoMDAACrILMGANhTlHPyTYI1AMCeKIMDAACrILMGANgTZXAAACzOQWVwgjUAwJ4cFKydU0MAAMCmyKwBAPbEOWsAACyOMjgAALAKMmsAgC25+CEPAAAsjt+zBgAAVkFmDQCwJ8rgAABYHKvBAQCAVZBZAwDsiS9FAQDA4hxUBidYAwDsyUHB2jk1BAAAbIpgDQCwp6ioyGwNUFRUpIyMDMXFxSkrK0sbNmwI6XZvvvmmYmJidMkll4Q1HsEaAGBPLldktjCVlJRo0qRJmjZtmrZu3aqcnBz169dP5eXl9d7uu+++06hRo9SnT5+wxyRYAwAQhjlz5mjcuHEaP368OnfurLlz56pDhw5asGBBvbe75ZZbNGLECGVnZ4c9JsEaAGBPUa6IbF6vVwcPHvTbvF5v0CGPHj2qzZs3Kzc31689NzdXGzdurHOqS5Ys0SeffKLCwsKG7WqDbgUAwNnmiorI5vF4lJSU5Ld5PJ6gQ+7fv1/V1dVKS0vza09LS1NlZWXQ2/zf//2f7r77bhUXFysmpmEXYXHpFgDA0QoKCpSfn+/X5na7672N65Rz3caYgDZJqq6u1ogRIzRz5kxdcMEFDZ4jwRoAYE8R+iEPt9t92uBcq2XLloqOjg7Iovft2xeQbUvSoUOH9N5772nr1q267bbbJEk1NTUyxigmJkarV69W7969TzsuwRoAYE9n4UtRYmNjlZWVpbKyMl133XW+9rKyMv3mN78J6N+sWTP94x//8GsrKirS2rVr9eyzzyojIyOkcQnWAACEIT8/XyNHjlS3bt2UnZ2tRx99VOXl5crLy5N0oqz+5ZdfatmyZYqKilJmZqbf7VNTUxUXFxfQXh+CNQDAns7SD3kMHz5cVVVVmjVrlioqKpSZmanS0lKlp6dLkioqKk57zXW4XMYYE/atfqyK6CQQoriUwDaOxdnBsbAWjod1BDsWjaRm9X0RuZ+o3Hsjcj+NicwaAGBP/JAHAACwCjJrAIA9uZyTbxKsAQD25JwqOGVwAACsjswaAGBPDlpgRrAGANiTg4I1ZXAAACyOzBoAYE8OyqwJ1gAAm3JOsKYMDgCAxZFZAwDsyTmJNcEaAGBTnLMGAMDiHBSsOWcNAIDFkVkDAOzJQZk1wRoAYFPOCdaUwQEAsDgyawCAPTknsSZYAwBsykHnrCmDAwBgcWTWAAB7clBmTbAGANiUc4I1ZXAAACyOzBoAYE+UwQEAsDiCNQAAFuecWM05awAArI7MGgBgT5TBAQCwOucEa8rgAABYHJk1AMCeKIMDAGBxDgrWlMEBALA4MmsAgD05J7EmWAMAbIoyOAAAsAoyawCATTknsyZYAwDsyUFlcII1AMCeHBSsOWcNAIDFkVkDAOyJzBoAAFgFwRoAAIujDA4AsCcHlcEJ1gAAeyJYn0ZcSoSngQbjWFgHx8JaOB74NxI0WHu9Xnm9Xr82t9stt9t9RiYFAMBpOSizDrrAzOPxKCkpyW/zeDxnem4AANTDFaHN+lzGGHNqI5k1AMDqarYvjcj9RF00JiL305iClsEJzAAAy3NQGbxBC8xmOOgBspIZgUUQjsVZwrGwFo6HdQQ7Fo3G5ZyvCuHSLQCATTnnA5lzPpYAAGBTZNYAAHty0KkOgjUAwJ4cdM7aOXsKAIBNkVkDAGyKMjgAANbmoHPWlMEBALA4MmsAgE05J98kWAMA7IkyOAAAsAqCNQDAnlyuyGwNUFRUpIyMDMXFxSkrK0sbNmyos+/zzz+vvn37qlWrVmrWrJmys7P1v//7v2GNR7AGANjU2fk965KSEk2aNEnTpk3T1q1blZOTo379+qm8vDxo//Xr16tv374qLS3V5s2b1atXLw0aNEhbt24NfU+D/Z716fBrNmcHvyxkHRwLa+F4WMeZ/NWtmk9WROR+os4fHFb/yy+/XJdddpkWLFjga+vcubMGDx4sj8cT0n1cdNFFGj58uKZPnx7aHMOaIQAA/2a8Xq8OHjzot3m93qB9jx49qs2bNys3N9evPTc3Vxs3bgxpvJqaGh06dEjJyckhz5FgDQCwpwids/Z4PEpKSvLb6sqQ9+/fr+rqaqWlpfm1p6WlqbKyMqRp/+lPf9Lhw4c1bNiwkHeVS7cAADYVmVMdBQUFys/P92tzu931j3zKaRZjTEBbMMuXL9eMGTO0cuVKpaamhjxHgjUAwNHcbvdpg3Otli1bKjo6OiCL3rdvX0C2faqSkhKNGzdOzzzzjK6++uqw5kgZHABgT66oyGxhiI2NVVZWlsrKyvzay8rK1KNHjzpvt3z5co0ZM0ZPPvmkBgwYEPauklkDAGwplLJzY8jPz9fIkSPVrVs3ZWdn69FHH1V5ebny8vIknSirf/nll1q2bJmkE4F61KhRevjhh3XFFVf4svL4+HglJSWFNCbBGgCAMAwfPlxVVVWaNWuWKioqlJmZqdLSUqWnp0uSKioq/K65fuSRR3T8+HFNnDhREydO9LWPHj1aS5cuDWlMgjUAwKbO3rX0EyZM0IQJE4L+79QAvG7dup88HsEaAGBPYZ5vtjPn7CkAADZFZg0AsCnnfKUswRoAYE8O+v53gjUAwJ44Zw0AAKyCzBoAYFOUwQEAsDYHnbOmDA4AgMWRWQMA7MlBC8wI1gAAm6IMDgAALILMGgBgTw5aYEawBgDYlHOKw87ZUwAAbIrMGgBgT5TBAQCwOII1AABW55wzuc7ZUwAAbIrMGgBgT5TBAQCwOucEa8rgAABYHJk1AMCeKIMDAGB1zgnWlMEBALA4MmsAgD1RBgcAwOqcUxx2zp4CAGBTZNYAAHuiDA4AgNURrAEAsDYHZdacswYAwOLIrAEANuWczJpgDQCwJ8rgAADAKsisAQA25ZzMmmANALAnyuAAAMAqyKwBADblnHyTYA0AsCfK4AAAwCrIrAEANuWczJpgDQCwKYI1AACW5uKcNQAAsAoyawCATTknsyZYAwDsiTI4AACwCjJrAIBNOSezJlgDAOzJ5ZzisHP2FAAAmyKzBgDYFGVwAACsjdXgAADAKsisAQA25ZzMmmANALAnB5XBCdYAAJtyTrDmnDUAABZHZg0AsCfK4AAAWJ1zgjVlcAAALI7MGgBgT3w3OAAAVueK0Ba+oqIiZWRkKC4uTllZWdqwYUO9/V9//XVlZWUpLi5O5513nhYuXBjWeARrAADCUFJSokmTJmnatGnaunWrcnJy1K9fP5WXlwftv2fPHvXv3185OTnaunWr7rnnHt1xxx167rnnQh6TYA0AsCeXKzJbmObMmaNx48Zp/Pjx6ty5s+bOnasOHTpowYIFQfsvXLhQ5557rubOnavOnTtr/PjxGjt2rB566KGQx2zQOesZxjTkZmgEHAvr4FhYC8fDCc78avCjR49q8+bNuvvuu/3ac3NztXHjxqC32bRpk3Jzc/3arrnmGi1atEjHjh1TkyZNTjsuC8wAAI7m9Xrl9Xr92txut9xud0Df/fv3q7q6WmlpaX7taWlpqqysDHr/lZWVQfsfP35c+/fvV5s2bU47x5DK4F6vVzNmzAjYGZx5HAvr4FhYC8fDgeJSIrJ5PB4lJSX5bR6Pp96hXaeUz40xAW2n6x+svS4hB+uZM2fyIrAAjoV1cCysheOBhiooKNB3333ntxUUFATt27JlS0VHRwdk0fv27QvInmu1bt06aP+YmBilpKSENEcWmAEAHM3tdqtZs2Z+W7ASuCTFxsYqKytLZWVlfu1lZWXq0aNH0NtkZ2cH9F+9erW6desW0vlqiWANAEBY8vPz9dhjj2nx4sXauXOnJk+erPLycuXl5Uk6kamPGjXK1z8vL0+ff/658vPztXPnTi1evFiLFi3SlClTQh6TBWYAAIRh+PDhqqqq0qxZs1RRUaHMzEyVlpYqPT1dklRRUeF3zXVGRoZKS0s1efJkzZ8/X23bttVf/vIXDRkyJOQxQwrWbrdbhYWFdZYFcOZwLKyDY2EtHA+cSRMmTNCECROC/m/p0qUBbVdeeaW2bNnS4PFcxnAxIgAAVsY5awAALI5gDQCAxRGsAQCwOII1AAAWR7AGAMDiCNYAAFgcwRoAAIsjWAMAYHEEawAALI5gDQCAxRGsAQCwuP8HBq50QPVfY/8AAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -370,10 +368,22 @@ "cell_type": "code", "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:jax._src.lib.xla_bridge:No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n" + ] + } + ], "source": [ - "A_gm = copy.deepcopy(A_gp) # make a copy of the true observation likelihood to initialize the observation model\n", - "B_gm = copy.deepcopy(B_gp) # make a copy of the true transition likelihood to initialize the transition model" + "num_agents = 50 # number of different agents \n", + "A_gm = [jnp.broadcast_to(jnp.array(a), (num_agents,) + a.shape) for a in A_gp] # map the true observation likelihood to jax arrays\n", + "B_gm = [jnp.broadcast_to(jnp.array(b), (num_agents,) + b.shape) for b in B_gp] # map the true transition likelihood to jax arrays\n", + "D_gm = [jnp.broadcast_to(jnp.array([1., 0., 0., 0.]), (num_agents, 4)), jnp.broadcast_to(jnp.array([.5, .5]), (num_agents, 2))]\n", + "C_gm = [jnp.zeros((num_agents, 4)), jnp.broadcast_to(jnp.array([0., -3., 3.]), (num_agents, 3)),jnp.zeros((num_agents, 2))]\n", + "E_gm = jnp.ones((num_agents, 4))" ] }, { @@ -430,7 +440,7 @@ "metadata": {}, "outputs": [], "source": [ - "agent = Agent(A=A_gm, B=B_gm, control_fac_idx=controllable_indices)" + "agent = Agent(A_gm, B_gm, C_gm, D_gm, E_gm, control_fac_idx=controllable_indices)" ] }, { @@ -439,154 +449,45 @@ "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "(4, 1, 2)" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "(4, 1, 2)\n", + "int32\n" + ] } ], "source": [ "policies = jnp.stack(agent.policies)\n", - "policies.shape" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we can inspect properties (and change) of the agent as we see fit. Let's look at the initial beliefs the agent has about its starting location and reward condition, encoded in the prior over hidden states $P(s)$, known in SPM-lingo as the `D` array." + "print(policies.shape)\n", + "print(policies.dtype)" ] }, { "cell_type": "code", "execution_count": 19, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_beliefs(agent.D[0],\"Beliefs about initial location\")" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_beliefs(agent.D[1],\"Beliefs about reward condition\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's make it so that agent starts with precise and accurate prior beliefs about its starting location." - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "agent.D[0] = utils.onehot(0, agent.num_states[0])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "And now confirm that our agent knows (i.e. has accurate beliefs about) its initial state by visualizing its priors again." - ] - }, - { - "cell_type": "code", - "execution_count": 22, "metadata": {}, "outputs": [ { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "PyTreeDef(CustomNode(Agent[(('A', 'B', 'C', 'D', 'E', 'empirical_prior', 'gamma', 'qs', 'q_pi'), ('num_obs', 'num_modalities', 'num_states', 'num_factors', 'num_controls', 'inference_algo', 'control_fac_idx', 'policy_len', 'policies', 'use_utility', 'use_states_info_gain', 'use_param_info_gain', 'action_selection'), ([4, 3, 2], 3, [4, 2], 2, [4, 1], 'VANILLA', [0], 1, DeviceArray([[[0, 0]],\n", + "\n", + " [[1, 0]],\n", + "\n", + " [[2, 0]],\n", + "\n", + " [[3, 0]]], dtype=int32), True, True, False, 'deterministic'))], [[*, *, *], [*, *], [*, *, *], [*, *], *, [*, *], *, None, None]))\n" + ] } ], "source": [ - "plot_beliefs(agent.D[0],\"Beliefs about initial location\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Another thing we want to do in this case is make sure the agent has a 'sense' of reward / loss and thus a motivation to be in the 'correct' arm (the arm that maximizes the probability of getting the reward outcome).\n", + "import jax.tree_util as jtu\n", "\n", - "We can do this by changing the prior beliefs about observations, the `C` array (also known as the _prior preferences_ ). This is represented as a collection of distributions over observations for each modality. It is initialized by default to be all 0s. This means agent has no preference for particular outcomes. Since the second modality (index `1` of the `C` array) is the `Reward` modality, with the index of the `Reward` outcome being `1`, and that of the `Loss` outcome being `2`, we populate the corresponding entries with values whose relative magnitudes encode the preference for one outcome over another (technically, this is encoded directly in terms of relative log-probabilities). \n", + "vals, tree = jtu.tree_flatten(agent)\n", "\n", - "Our ability to make the agent's prior beliefs that it tends to observe the outcome with index `1` in the `Reward` modality, more often than the outcome with index `2`, is what makes this modality a Reward modality in the first place -- otherwise, it would just be an arbitrary observation with no extrinsic value _per se_. " - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "agent.C[1][1] = 3.0\n", - "agent.C[1][2] = -3.0" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAGxCAYAAABfrt1aAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAoU0lEQVR4nO3de3TU9Z3/8dcEJpMEkmAYLgECZLFclIJcRINVAxyQIDdXrOguAqKl3FpEtyoWQhBPWkq71vVAxa3BHmTFHq6LiETunkIbrC7iKi2uXDSEcpEECSQDfH5/9JepwwRIWr55g/N8nJNzmM985vt58/l+Z+Y138uMzznnBAAAYCDOugAAABC7CCIAAMAMQQQAAJghiAAAADMEEQAAYIYgAgAAzBBEAACAGYIIAAAwQxABAABmCCKoc4sWLZLP5wv/1a9fX61atdLYsWP1xRdf1GgZY8aMUdu2bb0t9P/Lzs5W586dr/gys7OzI9p8Pp9mzZr1dy1v3759uvvuu5WWliafz6epU6f+wzXWhM/n0+TJk+tkrAstWbJEzz///BVfrhfr+2pSXl6uWbNmafPmzVH3VT039+3bV+d1IXbVty4AsaugoEAdO3bU6dOntXXrVuXn52vLli368MMP1aBBg0s+dsaMGfrhD39YR5XWje3bt6tVq1Z/12Mfe+wx/f73v9crr7yi5s2bKz09/QpXd/VZsmSJdu/eXWeh65uivLxceXl5khQVhu+++25t3749JrYfXD0IIjDTuXNn9ezZU5LUp08fnTt3Ts8++6xWrlypf/mXf6n2MeXl5UpKSlK7du2uaC2nT59WYmLiFV1mbd16661/92N3796tXr16afjw4VeuIJg6d+6czp49q0AgUGdjNmnSRE2aNKmz8QCJQzO4ilS9Ee/fv1/SXw+/NGzYUB9++KEGDBig5ORk9evXL3zfhYdmzpw5o6efflqZmZmKj49Xy5YtNWnSJJ04cSKiX9u2bTV48GAtX75c3bp1U0JCQvgT4qVs27ZNt956qxITE9WyZUvNmDFD586di+hTWVmpOXPmqGPHjgoEAmrSpInGjh2rI0eOXHb51R2aKSkp0fjx49WqVSvFx8crMzNTeXl5Onv2rCRp8+bN8vl82rt3r956663w4a59+/bp/PnzmjNnjjp06KDExEQ1atRIXbp00S9/+ctL1nHmzBk9/vjjuummm5Samqq0tDRlZWVp1apVF33MSy+9pPbt2ysQCOiGG27Q66+/HtVn9+7dGjZsmK677jolJCTopptu0quvvhrR52KHBqr+n1WHE7Kzs/Xmm29q//79EYf5LuX8+fOaO3dueN00bdpUDz30kD7//PNq+9dkfS9YsEBdu3ZVw4YNlZycrI4dO2r69OkRfS63DqW/Hlrz+XyaO3eu5syZo8zMTAUCAb3xxhuKj4/XjBkzour75JNP5PP59MILL0iSjhw5ookTJ+qGG25Qw4YN1bRpU/Xt21fbtm2LGKcqaOTl5YXnbcyYMZec/1deeUVdu3ZVQkKC0tLSdM899+jjjz+O6FP1fN27d68GDRqkhg0bKiMjQ48//rgqKipqPW+IHewRwVVj7969khTxiayyslJDhw7V+PHj9dRTT0W8eH+dc07Dhw/Xhg0b9PTTT+v222/Xrl27lJubq+3bt2v79u0Rnyz/+Mc/6uOPP9aPf/xjZWZmXvZQUElJiUaOHKmnnnpKs2fP1ptvvqk5c+boyy+/1Isvvijpr290w4YN07Zt2/SjH/1IvXv31v79+5Wbm6vs7Gzt3LmzVntdSkpK1KtXL8XFxWnmzJlq166dtm/frjlz5mjfvn0qKChQ9+7dtX37dt1zzz1q166d5s2bJ0lKT0/X3LlzNWvWLP34xz/WHXfcoVAopE8++SQqmF2ooqJCx48f1xNPPKGWLVuqsrJS77zzjv75n/9ZBQUFeuihhyL6r169Wps2bdLs2bPVoEEDzZ8/Xw888IDq16+vESNGSJL27Nmj3r17q2nTpnrhhRfUuHFjLV68WGPGjNHhw4f1ox/9qMbzIknz58/X9773PX366adasWJFjR4zYcIELVy4UJMnT9bgwYO1b98+zZgxQ5s3b9Yf//hHBYPBcN+arO/XX39dEydO1JQpUzRv3jzFxcVp7969+t///d+I5VxuHX7dCy+8oPbt22vevHlKSUnRt771LQ0ePFivvvqq8vLyFBf3t8+OBQUFio+PD+89PH78uCQpNzdXzZs311dffaUVK1YoOztbGzZsUHZ2ttLT07Vu3ToNHDhQ48aN0yOPPCJJl9wLkp+fr+nTp+uBBx5Qfn6+jh07plmzZikrK0tFRUX61re+Fe4bCoU0dOhQjRs3To8//ri2bt2qZ599VqmpqZo5c2aN5w0xxgF1rKCgwElyO3bscKFQyJ08edKtWbPGNWnSxCUnJ7uSkhLnnHOjR492ktwrr7wStYzRo0e7Nm3ahG+vW7fOSXJz586N6Ld06VInyS1cuDDc1qZNG1evXj23Z8+eGtV75513Oklu1apVEe2PPvqoi4uLc/v373fOOfdf//VfTpJbtmxZRL+ioiInyc2fPz9imXfeeWdEP0kuNzc3fHv8+PGuYcOG4eVXmTdvnpPkPvroo4j/09133x3Rb/Dgwe6mm26q0f/xUs6ePetCoZAbN26c69atW1TNiYmJ4XVW1b9jx47u+uuvD7eNHDnSBQIBd+DAgYjH5+TkuKSkJHfixAnn3N+2jc8++yyi36ZNm5wkt2nTpnDb3XffHbENXMrHH3/sJLmJEydGtP/+9793ktz06dPDbTVd35MnT3aNGjW65Lg1XYefffaZk+TatWvnKisrI/quXr3aSXLr168Pt509e9a1aNHC3XvvvRcdu2q99evXz91zzz3h9iNHjkRta1UunP8vv/zSJSYmukGDBkX0O3DggAsEAu7BBx8Mt1U9X994442IvoMGDXIdOnQI367JvCG2cGgGZm699Vb5/X4lJydr8ODBat68ud566y01a9Ysot+999572WVt3LhRksK7mKvcd999atCggTZs2BDR3qVLF7Vv377GtSYnJ2vo0KERbQ8++KDOnz+vrVu3SpLWrFmjRo0aaciQITp79mz476abblLz5s2rvUrhUtasWaM+ffqoRYsWEcvLycmRJG3ZsuWSj+/Vq5f+53/+RxMnTtTbb7+tsrKyGo/929/+VrfddpsaNmyo+vXry+/369e//nXU7nhJ6tevX8Q6q1evnu6//37t3bs3fNhj48aN6tevnzIyMiIeO2bMGJWXl2v79u01ru3vsWnTpvB4X9erVy916tQpavuoyfru1auXTpw4oQceeECrVq3S0aNHo8at7TocOnSo/H5/RFtOTo6aN28esffk7bffVnFxsR5++OGIvr/61a/UvXt3JSQkhNfbhg0bql1vNbF9+3adPn06at4yMjLUt2/fqHnz+XwaMmRIRFuXLl3Ch1ulms0bYgtBBGZ+85vfqKioSO+//76Ki4u1a9cu3XbbbRF9kpKSlJKSctllHTt2TPXr14/axezz+dS8eXMdO3Ysor22VwVcGI4kqXnz5uGxJenw4cM6ceKE4uPj5ff7I/5KSkpq/YJ7+PBh/fd//3fUsm688UZJuuzynn76ac2bN087duxQTk6OGjdurH79+mnnzp2XfNzy5cv13e9+Vy1bttTixYu1fft2FRUV6eGHH9aZM2cuOg/VtVXNzbFjx6qd8xYtWkT080rV8i9Ww4Xj12R9jxo1Sq+88or279+ve++9V02bNtUtt9yiwsLC8GNquw6rq69+/foaNWqUVqxYET6stmjRIqWnp+uuu+4K9/vFL36hCRMm6JZbbtGyZcu0Y8cOFRUVaeDAgTp9+vRl56g6tZ23pKQkJSQkRLQFAoGI7aYm84bYwjkiMNOpU6fwVTMXc7kTEKs0btxYZ8+e1ZEjRyLCiHNOJSUluvnmm/+u5VY5fPhwVFtJSUl4bEkKBoNq3Lix1q1bV+0ykpOTazVmMBhUly5d9Nxzz1V7f9Wb+MXUr19f06ZN07Rp03TixAm98847mj59uu666y4dPHhQSUlJ1T5u8eLFyszM1NKlSyPm6cITDqtUzUN1bVVz07hxYx06dCiqX3FxsSSFz8+oehO7cKx/9FNzVR2HDh2KukS6uLg44vwQqWbrW5LGjh2rsWPH6tSpU9q6datyc3M1ePBg/elPf1KbNm1qvQ4vtl2OHTtWP/vZz/T666/r/vvv1+rVqzV16lTVq1cv3Gfx4sXKzs7WggULIh578uTJapdZE1+ftwtVN281dbl5Q2xhjwi+Eaquplm8eHFE+7Jly3Tq1Knw/X+vkydPavXq1RFtS5YsUVxcnO644w5J0uDBg3Xs2DGdO3dOPXv2jPrr0KFDrcYcPHiwdu/erXbt2lW7vMsFka9r1KiRRowYoUmTJun48eOX/MIqn8+n+Pj4iDfFkpKSi141s2HDhog37nPnzmnp0qVq165d+E2/X79+2rhxYzh4VPnNb36jpKSk8BVTVVdC7dq1K6LfhXMv/fWTdk0/6fft21dS9PZRVFSkjz/+OGr7qMn6/roGDRooJydHzzzzjCorK/XRRx9JunLrsFOnTrrllltUUFCgJUuWqKKiQmPHjo3o4/P5oi713bVrV9Rhr6o+NZm7rKwsJSYmRs3b559/Hj7c9o+42LwhtrBHBN8I/fv311133aUnn3xSZWVluu2228JXzXTr1k2jRo36h5bfuHFjTZgwQQcOHFD79u21du1avfzyy5owYYJat24tSRo5cqRee+01DRo0SD/84Q/Vq1cv+f1+ff7559q0aZOGDRume+65p8Zjzp49W4WFherdu7d+8IMfqEOHDjpz5oz27duntWvX6le/+tUlvwBtyJAh4e9qadKkifbv36/nn39ebdq0ibjS4UJVlzZPnDhRI0aM0MGDB/Xss88qPT1df/7zn6P6B4NB9e3bVzNmzAhfNfPJJ59EXMKbm5sbPl9i5syZSktL02uvvaY333xTc+fOVWpqqiTp5ptvVocOHfTEE0/o7Nmzuu6667RixQq9++67UeN++9vf1vLly7VgwQL16NFDcXFxF93D1qFDB33ve9/Tf/zHfyguLk45OTnhq2YyMjL02GOPRfSvyfp+9NFHlZiYqNtuu03p6ekqKSlRfn6+UlNTw3vg/tF1+HUPP/ywxo8fr+LiYvXu3Tsq2A4ePFjPPvuscnNzdeedd2rPnj2aPXu2MjMzI642S05OVps2bbRq1Sr169dPaWlpCgaD1X5TcaNGjTRjxgxNnz5dDz30kB544AEdO3ZMeXl5SkhIUG5ubo1q/7qazBtijPXZsog9VWfmFxUVXbLf6NGjXYMGDS5634VXTJw+fdo9+eSTrk2bNs7v97v09HQ3YcIE9+WXX0b0q+4Kk0u588473Y033ug2b97sevbs6QKBgEtPT3fTp093oVAoom8oFHLz5s1zXbt2dQkJCa5hw4auY8eObvz48e7Pf/5zxDIvd9WMc3+9wuEHP/iBy8zMdH6/36WlpbkePXq4Z555xn311VeX/D/9/Oc/d71793bBYNDFx8e71q1bu3Hjxrl9+/Zd9v/8k5/8xLVt29YFAgHXqVMn9/LLL7vc3Fx34UuGJDdp0iQ3f/58165dO+f3+13Hjh3da6+9FrXMDz/80A0ZMsSlpqa6+Ph417VrV1dQUBDV709/+pMbMGCAS0lJcU2aNHFTpkxxb775ZtRVM8ePH3cjRoxwjRo1cj6fL6q2C507d8799Kc/de3bt3d+v98Fg0H3r//6r+7gwYMR/Wq6vl999VXXp08f16xZMxcfH+9atGjhvvvd77pdu3ZFLK8m67Dqqpmf/exnF62/tLTUJSYmOknu5Zdfjrq/oqLCPfHEE65ly5YuISHBde/e3a1cubLa58o777zjunXr5gKBgJPkRo8e7Zy7+FVL//mf/+m6dOni4uPjXWpqqhs2bFjEVVvOXfz5euF2U9N5Q+zwOeecUQYCAAAxjnNEAACAGYIIAAAwQxABAABmCCIAAMAMQQQAAJghiAAAADNX9ReanT9/XsXFxUpOTq71V3IDAAAbzjmdPHlSLVq0UFzcpfd5XNVBpLi4OOrXOgEAwLXh4MGDl/324Ks6iFT9SNjBgwdr9AusqLlQKKT169drwIABUT87DtQFtkFYYxv0TllZmTIyMmr0Y59XdRCpOhyTkpJCELnCQqGQkpKSlJKSwhMQJtgGYY1t0Hs1Oa2Ck1UBAIAZgggAADBDEAEAAGYIIgAAwAxBBAAAmCGIAAAAMwQRAABghiACAADMEEQAAIAZgggAADDjaRBZsGCBunTpEv6K9qysLL311lteDgkAAK4hngaRVq1a6Sc/+Yl27typnTt3qm/fvho2bJg++ugjL4cFAADXCE9/9G7IkCERt5977jktWLBAO3bs0I033hjVv6KiQhUVFeHbZWVlkv76w0ShUMjLUmNO1Xwyr7DCNghrbIPeqc2c1tmv7547d06//e1vderUKWVlZVXbJz8/X3l5eVHt69evV1JSktclxqTCwkLrEmLasOHDrUsw45c0zLqIq8CqlSutS4h5vA5eeeXl5TXu63POOQ9r0YcffqisrCydOXNGDRs21JIlSzRo0KBq+1a3RyQjI0NHjx5VSkqKl2XGnFAopMLCQvXv35+fvzbkj4+3LgHGQpWV1iXELF4HvVNWVqZgMKjS0tLLvn97vkekQ4cO+uCDD3TixAktW7ZMo0eP1pYtW3TDDTdE9Q0EAgoEAlHtfr+fjcQjzC1gi+efPV4Hr7zazKfnQSQ+Pl7XX3+9JKlnz54qKirSL3/5S7300kteDw0AAK5ydf49Is65iMMvAAAgdnm6R2T69OnKyclRRkaGTp48qddff12bN2/WunXrvBwWAABcIzwNIocPH9aoUaN06NAhpaamqkuXLlq3bp369+/v5bAAAOAa4WkQ+fWvf+3l4gEAwDWO35oBAABmCCIAAMAMQQQAAJghiAAAADMEEQAAYIYgAgAAzBBEAACAGYIIAAAwQxABAABmCCIAAMAMQQQAAJghiAAAADMEEQAAYIYgAgAAzBBEAACAGYIIAAAwQxABAABmCCIAAMAMQQQAAJghiAAAADMEEQAAYIYgAgAAzBBEAACAGYIIAAAwQxABAABmCCIAAMAMQQQAAJghiAAAADMEEQAAYIYgAgAAzBBEAACAGYIIAAAwQxABAABmCCIAAMAMQQQAAJghiAAAADMEEQAAYIYgAgAAzBBEAACAGYIIAAAwQxABAABmCCIAAMAMQQQAAJghiAAAADMEEQAAYMbTIJKfn6+bb75ZycnJatq0qYYPH649e/Z4OSQAALiGeBpEtmzZokmTJmnHjh0qLCzU2bNnNWDAAJ06dcrLYQEAwDWivpcLX7duXcTtgoICNW3aVO+9957uuOOOqP4VFRWqqKgI3y4rK5MkhUIhhUIhL0uNOVXzybza8lsXAHM8B+3wOuid2sypp0HkQqWlpZKktLS0au/Pz89XXl5eVPv69euVlJTkaW2xqrCw0LqEmDbMugCYW7t2rXUJMY/XwSuvvLy8xn19zjnnYS1hzjkNGzZMX375pbZt21Ztn+r2iGRkZOjo0aNKSUmpizJjRigUUmFhofr37y+/n8/lVvzx8dYlwFiostK6hJjF66B3ysrKFAwGVVpaetn37zrbIzJ58mTt2rVL77777kX7BAIBBQKBqHa/389G4hHmFrDF888er4NXXm3ms06CyJQpU7R69Wpt3bpVrVq1qoshAQDANcDTIOKc05QpU7RixQpt3rxZmZmZXg4HAACuMZ4GkUmTJmnJkiVatWqVkpOTVVJSIklKTU1VYmKil0MDAIBrgKffI7JgwQKVlpYqOztb6enp4b+lS5d6OSwAALhGeH5oBgAA4GL4rRkAAGCGIAIAAMwQRAAAgBmCCAAAMEMQAQAAZggiAADADEEEAACYIYgAAAAzBBEAAGCGIAIAAMwQRAAAgBmCCAAAMEMQAQAAZggiAADADEEEAACYIYgAAAAzBBEAAGCGIAIAAMwQRAAAgBmCCAAAMEMQAQAAZggiAADADEEEAACYIYgAAAAzBBEAAGCGIAIAAMwQRAAAgBmCCAAAMEMQAQAAZggiAADADEEEAACYIYgAAAAzBBEAAGCGIAIAAMwQRAAAgBmCCAAAMEMQAQAAZggiAADADEEEAACYIYgAAAAzBBEAAGCGIAIAAMwQRAAAgBmCCAAAMEMQAQAAZjwNIlu3btWQIUPUokUL+Xw+rVy50svhAADANcbTIHLq1Cl17dpVL774opfDAACAa1R9Lxeek5OjnJycGvevqKhQRUVF+HZZWZkkKRQKKRQKXfH6YlnVfDKvtvzWBcAcz0E7vA56pzZz6mkQqa38/Hzl5eVFta9fv15JSUkGFX3zFRYWWpcQ04ZZFwBza9eutS4h5vE6eOWVl5fXuK/POec8rOVvA/l8WrFihYYPH37RPtXtEcnIyNDRo0eVkpJSB1XGjlAopMLCQvXv319+P5/Lrfjj461LgLFQZaV1CTGL10HvlJWVKRgMqrS09LLv31fVHpFAIKBAIBDV7vf72Ug8wtwCtnj+2eN18MqrzXxy+S4AADBDEAEAAGY8PTTz1Vdfae/eveHbn332mT744AOlpaWpdevWXg4NAACuAZ4GkZ07d6pPnz7h29OmTZMkjR49WosWLfJyaAAAcA3wNIhkZ2erji7KAQAA1yDOEQEAAGYIIgAAwAxBBAAAmCGIAAAAMwQRAABghiACAADMEEQAAIAZgggAADBDEAEAAGYIIgAAwAxBBAAAmCGIAAAAMwQRAABghiACAADMEEQAAIAZgggAADBDEAEAAGYIIgAAwAxBBAAAmCGIAAAAMwQRAABghiACAADMEEQAAIAZgggAADBDEAEAAGYIIgAAwAxBBAAAmCGIAAAAMwQRAABghiACAADMEEQAAIAZgggAADBDEAEAAGYIIgAAwAxBBAAAmCGIAAAAMwQRAABghiACAADMEEQAAIAZgggAADBDEAEAAGYIIgAAwAxBBAAAmCGIAAAAMwQRAABgpk6CyPz585WZmamEhAT16NFD27Ztq4thAQDAVc7zILJ06VJNnTpVzzzzjN5//33dfvvtysnJ0YEDB7weGgAAXOXqez3AL37xC40bN06PPPKIJOn555/X22+/rQULFig/Pz+ib0VFhSoqKsK3y8rKJEmhUEihUMjrUmNK1Xwyr7b81gXAHM9BO7wOeqc2c+ppEKmsrNR7772np556KqJ9wIAB+t3vfhfVPz8/X3l5eVHt69evV1JSkmd1xrLCwkLrEmLbypXWFcDa2rWmww8bPtx0fEt+ScOsi7gKrPLgdai8vLzGfT0NIkePHtW5c+fUrFmziPZmzZqppKQkqv/TTz+tadOmhW+XlZUpIyNDAwYMUEpKipelxpxQKKTCwkL1799ffj+fy1H32AaBq8OgQYOu+DKrjmjUhOeHZiTJ5/NF3HbORbVJUiAQUCAQiGr3+/28UHmEuYU1tkHAlhfPv9os09OTVYPBoOrVqxe19+Mvf/lL1F4SAAAQezwNIvHx8erRo0fUeQiFhYXq3bu3l0MDAIBrgOeHZqZNm6ZRo0apZ8+eysrK0sKFC3XgwAF9//vf93poAABwlfM8iNx///06duyYZs+erUOHDqlz585au3at2rRp4/XQAADgKlcnJ6tOnDhREydOrIuhAADANYTfmgEAAGYIIgAAwAxBBAAAmCGIAAAAMwQRAABghiACAADMEEQAAIAZgggAADBDEAEAAGYIIgAAwAxBBAAAmCGIAAAAMwQRAABghiACAADMEEQAAIAZgggAADBDEAEAAGYIIgAAwAxBBAAAmCGIAAAAMwQRAABghiACAADMEEQAAIAZgggAADBDEAEAAGYIIgAAwAxBBAAAmCGIAAAAMwQRAABghiACAADMEEQAAIAZgggAADBDEAEAAGYIIgAAwAxBBAAAmCGIAAAAMwQRAABghiACAADMEEQAAIAZgggAADBDEAEAAGYIIgAAwAxBBAAAmCGIAAAAMwQRAABgxtMg8txzz6l3795KSkpSo0aNvBwKAABcgzwNIpWVlbrvvvs0YcIEL4cBAADXqPpeLjwvL0+StGjRohr1r6ioUEVFRfh2WVmZJCkUCikUCl3x+mJZ1Xwyr7DCNnh18FsXAHNePAdrs0xPg0ht5efnh8PL161fv15JSUkGFX3zFRYWWpeAGMc2aGuYdQEwt3bt2iu+zPLy8hr39Tnn3BWv4AKLFi3S1KlTdeLEiUv2q26PSEZGho4ePaqUlBSPq4wtoVBIhYWF6t+/v/x+PhOh7rENXh388fHWJcBYqLLyii+zrKxMwWBQpaWll33/rvUekVmzZlW71+LrioqK1LNnz9ouWoFAQIFAIKrd7/fzQuUR5hbW2AYBW148/2qzzFoHkcmTJ2vkyJGX7NO2bdvaLhYAAMSgWgeRYDCoYDDoRS0AACDGeHqy6oEDB3T8+HEdOHBA586d0wcffCBJuv7669WwYUMvhwYAANcAT4PIzJkz9eqrr4Zvd+vWTZK0adMmZWdnezk0AAC4Bnj6hWaLFi2Scy7qjxACAAAkfmsGAAAYIogAAAAzBBEAAGCGIAIAAMwQRAAAgBmCCAAAMEMQAQAAZggiAADADEEEAACYIYgAAAAzBBEAAGCGIAIAAMwQRAAAgBmCCAAAMEMQAQAAZggiAADADEEEAACYIYgAAAAzBBEAAGCGIAIAAMwQRAAAgBmCCAAAMEMQAQAAZggiAADADEEEAACYIYgAAAAzBBEAAGCGIAIAAMwQRAAAgBmCCAAAMEMQAQAAZggiAADADEEEAACYIYgAAAAzBBEAAGCGIAIAAMwQRAAAgBmCCAAAMEMQAQAAZggiAADADEEEAACYIYgAAAAzBBEAAGCGIAIAAMwQRAAAgBnPgsi+ffs0btw4ZWZmKjExUe3atVNubq4qKyu9GhIAAFxj6nu14E8++UTnz5/XSy+9pOuvv167d+/Wo48+qlOnTmnevHleDQsAAK4hngWRgQMHauDAgeHb//RP/6Q9e/ZowYIFFw0iFRUVqqioCN8uKyuTJIVCIYVCIa9KjUlV88m8wgrb4NXBb10AzHnxHKzNMj0LItUpLS1VWlraRe/Pz89XXl5eVPv69euVlJTkZWkxq7Cw0LoExDi2QVvDrAuAubVr117xZZaXl9e4r8855654BdX49NNP1b17d/385z/XI488Um2f6vaIZGRk6OjRo0pJSamLMmNGKBRSYWGh+vfvL7+fz0Soe2yDVwd/fLx1CTAW8uDczbKyMgWDQZWWll72/bvWe0RmzZpV7V6LrysqKlLPnj3Dt4uLizVw4EDdd999Fw0hkhQIBBQIBKLa/X4/L1QeYW5hjW0QsOXF8682y6x1EJk8ebJGjhx5yT5t27YN/7u4uFh9+vRRVlaWFi5cWNvhAADAN1itg0gwGFQwGKxR3y+++EJ9+vRRjx49VFBQoLg4vrYEAAD8jWcnqxYXFys7O1utW7fWvHnzdOTIkfB9zZs392pYAABwDfEsiKxfv1579+7V3r171apVq4j76uj8WAAAcJXz7FjJmDFj5Jyr9g8AAEDit2YAAIAhgggAADBDEAEAAGYIIgAAwAxBBAAAmCGIAAAAMwQRAABghiACAADMEEQAAIAZgggAADBDEAEAAGYIIgAAwAxBBAAAmCGIAAAAMwQRAABghiACAADMEEQAAIAZgggAADBDEAEAAGYIIgAAwAxBBAAAmCGIAAAAMwQRAABghiACAADMEEQAAIAZgggAADBDEAEAAGYIIgAAwAxBBAAAmCGIAAAAMwQRAABghiACAADMEEQAAIAZgggAADBDEAEAAGYIIgAAwAxBBAAAmCGIAAAAMwQRAABghiACAADMEEQAAIAZgggAADBDEAEAAGYIIgAAwAxBBAAAmPE0iAwdOlStW7dWQkKC0tPTNWrUKBUXF3s5JAAAuIZ4GkT69OmjN954Q3v27NGyZcv06aefasSIEV4OCQAAriH1vVz4Y489Fv53mzZt9NRTT2n48OEKhULy+/1R/SsqKlRRURG+XVZWJkkKhUIKhUJelhpzquaTeYUVtsGrQ/QrMWKNF8/B2izT55xzV7yCahw/flwTJkzQF198oXfffbfaPrNmzVJeXl5U+5IlS5SUlOR1iQAA4AooLy/Xgw8+qNLSUqWkpFyyr+dB5Mknn9SLL76o8vJy3XrrrVqzZo0aN25cbd/q9ohkZGTo6NGjl/2PoHZCoZAKCwvVv3//avdOAV5jG4Q1tkHvlJWVKRgM1iiI1PrQzMX2WnxdUVGRevbsKUn6t3/7N40bN0779+9XXl6eHnroIa1Zs0Y+ny/qcYFAQIFAIKrd7/ezkXiEuYU1tkFYYxu88mozn7UOIpMnT9bIkSMv2adt27bhfweDQQWDQbVv316dOnVSRkaGduzYoaysrNoODQAAvmFqHUSqgsXfo+oo0NcPvwAAgNjl2VUzf/jDH/SHP/xB3/nOd3Tdddfp//7v/zRz5ky1a9eOvSEAAECSh98jkpiYqOXLl6tfv37q0KGDHn74YXXu3Flbtmyp9jwQAAAQezzbI/Ltb39bGzdu9GrxAADgG4DfmgEAAGYIIgAAwAxBBAAAmCGIAAAAMwQRAABghiACAADMEEQAAIAZgggAADDj2ReaXQlVv01TVlZmXMk3TygUUnl5ucrKyvjVSZhgG4Q1tkHvVL1vV72PX8pVHUROnjwpScrIyDCuBAAA1NbJkyeVmpp6yT4+V5O4YuT8+fMqLi5WcnKyfD6fdTnfKGVlZcrIyNDBgweVkpJiXQ5iENsgrLENesc5p5MnT6pFixaKi7v0WSBX9R6RuLg4tWrVyrqMb7SUlBSegDDFNghrbIPeuNyekCqcrAoAAMwQRAAAgBmCSIwKBALKzc1VIBCwLgUxim0Q1tgGrw5X9cmqAADgm409IgAAwAxBBAAAmCGIAAAAMwQRAABghiACAADMEERi1Pz585WZmamEhAT16NFD27Ztsy4JMWLr1q0aMmSIWrRoIZ/Pp5UrV1qXhBiTn5+vm2++WcnJyWratKmGDx+uPXv2WJcVswgiMWjp0qWaOnWqnnnmGb3//vu6/fbblZOTowMHDliXhhhw6tQpde3aVS+++KJ1KYhRW7Zs0aRJk7Rjxw4VFhbq7NmzGjBggE6dOmVdWkzie0Ri0C233KLu3btrwYIF4bZOnTpp+PDhys/PN6wMscbn82nFihUaPny4dSmIYUeOHFHTpk21ZcsW3XHHHdblxBz2iMSYyspKvffeexowYEBE+4ABA/S73/3OqCoAsFNaWipJSktLM64kNhFEYszRo0d17tw5NWvWLKK9WbNmKikpMaoKAGw45zRt2jR95zvfUefOna3LiUn1rQuADZ/PF3HbORfVBgDfdJMnT9auXbv07rvvWpcSswgiMSYYDKpevXpRez/+8pe/RO0lAYBvsilTpmj16tXaunWrWrVqZV1OzOLQTIyJj49Xjx49VFhYGNFeWFio3r17G1UFAHXHOafJkydr+fLl2rhxozIzM61LimnsEYlB06ZN06hRo9SzZ09lZWVp4cKFOnDggL7//e9bl4YY8NVXX2nv3r3h25999pk++OADpaWlqXXr1oaVIVZMmjRJS5Ys0apVq5ScnBzeQ5yamqrExETj6mIPl+/GqPnz52vu3Lk6dOiQOnfurH//93/nsjXUic2bN6tPnz5R7aNHj9aiRYvqviDEnIudD1dQUKAxY8bUbTEgiAAAADucIwIAAMwQRAAAgBmCCAAAMEMQAQAAZggiAADADEEEAACYIYgAAAAzBBEAAGCGIAIAAMwQRAAAgBmCCAAAMPP/AHC35dBIzdcJAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_beliefs(agent.C[1],\"Prior beliefs about observations\")" + "print(tree)" ] }, { @@ -599,7 +500,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 28, "metadata": { "scrolled": false }, @@ -609,24 +510,25 @@ "output_type": "stream", "text": [ " === Starting experiment === \n", - " Reward condition: Right, Observation: [CENTER, No reward, Cue Left]\n", - "[Step 0] Action: [Move to CUE LOCATION]\n", - "[Step 0] Observation: [CUE LOCATION, No reward, Cue Right]\n", - "[Step 1] Action: [Move to RIGHT ARM]\n", - "[Step 1] Observation: [RIGHT ARM, Reward!, Cue Left]\n", + " Reward condition: Right, Observation: [CENTER, No reward, Cue Right]\n", + "[Step 0] Action: [Move to LEFT ARM]\n", + "[Step 0] Observation: [LEFT ARM, Loss!, Cue Right]\n", + "[Step 1] Action: [Move to LEFT ARM]\n", + "[Step 1] Observation: [LEFT ARM, Loss!, Cue Left]\n", "[Step 2] Action: [Move to RIGHT ARM]\n", "[Step 2] Observation: [RIGHT ARM, Reward!, Cue Right]\n", - "[Step 3] Action: [Move to RIGHT ARM]\n", - "[Step 3] Observation: [RIGHT ARM, Reward!, Cue Right]\n", + "[Step 3] Action: [Move to LEFT ARM]\n", + "[Step 3] Observation: [LEFT ARM, Loss!, Cue Left]\n", "[Step 4] Action: [Move to RIGHT ARM]\n", - "[Step 4] Observation: [RIGHT ARM, Reward!, Cue Right]\n" + "[Step 4] Observation: [RIGHT ARM, Reward!, Cue Left]\n" ] } ], "source": [ "T = 5 # number of timesteps\n", "\n", - "obs = env.reset() # reset the environment and get an initial observation\n", + "_obs = env.reset() # reset the environment and get an initial observation\n", + "obs = jnp.broadcast_to(jnp.array(_obs), (num_agents, len(_obs)))\n", "\n", "# these are useful for displaying read-outs during the loop over time\n", "reward_conditions = [\"Right\", \"Left\"]\n", @@ -634,108 +536,41 @@ "reward_observations = ['No reward','Reward!','Loss!']\n", "cue_observations = ['Cue Right','Cue Left']\n", "msg = \"\"\" === Starting experiment === \\n Reward condition: {}, Observation: [{}, {}, {}]\"\"\"\n", - "print(msg.format(reward_conditions[env.reward_condition], location_observations[obs[0]], reward_observations[obs[1]], cue_observations[obs[2]]))\n", + "print(msg.format(reward_conditions[env.reward_condition], location_observations[_obs[0]], reward_observations[_obs[1]], cue_observations[_obs[2]]))\n", "\n", - "measurments = {'actions': [], 'outcomes': [jnp.array(obs)]}\n", + "measurments = {'actions': [], 'outcomes': [obs]}\n", "for t in range(T):\n", " qx = agent.infer_states(obs)\n", "\n", - " q_pi, efe = agent.infer_policies()\n", + " q_pi, efe = agent.infer_policies(qx)\n", "\n", - " action = agent.sample_action()\n", - " measurments[\"actions\"].append( jnp.array(action) )\n", + " actions = agent.sample_action(q_pi)\n", + " measurments[\"actions\"].append( actions )\n", "\n", " msg = \"\"\"[Step {}] Action: [Move to {}]\"\"\"\n", - " print(msg.format(t, location_observations[int(action[0])]))\n", + " print(msg.format(t, location_observations[int(actions[0, 0])]))\n", "\n", - " obs = env.step(action)\n", - " measurments[\"outcomes\"].append(jnp.array(obs))\n", + " obs = []\n", + " for a in actions:\n", + " obs.append( jnp.array(env.step(list(a))) )\n", + " obs = jnp.stack(obs)\n", + " measurments[\"outcomes\"].append(obs)\n", "\n", " msg = \"\"\"[Step {}] Observation: [{}, {}, {}]\"\"\"\n", - " print(msg.format(t, location_observations[obs[0]], reward_observations[obs[1]], cue_observations[obs[2]]))\n", + " print(msg.format(t, location_observations[obs[0, 0]], reward_observations[obs[0, 1]], cue_observations[obs[0, 2]]))\n", " \n", "measurments['actions'] = jnp.stack(measurments['actions']).astype(jnp.int32)\n", "measurments['outcomes'] = jnp.stack(measurments['outcomes'])" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The agent begins by moving to the `CUE LOCATION` to resolve its uncertainty about the reward condition - this is because it knows it will get an informative cue in this location, which will signal the true reward condition unambiguously. At the beginning of the next timestep, the agent then uses this observaiton to update its posterior beliefs about states `qx[1]` to reflect the true reward condition. Having resolved its uncertainty about the reward condition, the agent then moves to `RIGHT ARM` to maximize utility and continues to do so, given its (correct) beliefs about the reward condition and the mapping between hidden states and reward observations. \n", - "\n", - "Notice, perhaps confusingly, that the agent continues to receive observations in the 3rd modality (i.e. samples from `A_gp[2]`). These are observations of the form `Cue Right` or `Cue Left`. However, these 'cue' observations are random and totally umambiguous unless the agent is in the `CUE LOCATION` - this is reflected by totally entropic distributions in the corresponding columns of `A_gp[2]` (and the agents beliefs about this ambiguity, reflected in `A_gm[2]`. See below." - ] - }, { "cell_type": "code", "execution_count": 26, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_likelihood(A_gp[2][:,:,0],'Cue Observations when condition is Reward on Right, for Different Locations')" - ] - }, - { - "cell_type": "code", - "execution_count": 27, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_likelihood(A_gp[2][:,:,1],'Cue Observations when condition is Reward on Left, for Different Locations')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The final column on the right side of these matrices represents the distribution over cue observations, conditioned on the agent being in `CUE LOCATION` and the appropriate Reward Condition. This demonstrates that cue observations are uninformative / lacking epistemic value for the agent, _unless_ they are in `CUE LOCATION.`" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we can inspect the agent's final beliefs about the reward condition characterizing the 'trial,' having undergone 10 timesteps of active inference." - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -745,7 +580,7 @@ } ], "source": [ - "plot_beliefs(qx[1],\"Final posterior beliefs about reward condition\")" + "plot_beliefs(qx[1][0],\"Final posterior beliefs about reward condition\")" ] }, { @@ -758,7 +593,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -808,7 +643,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "metadata": { "scrolled": true }, @@ -841,7 +676,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -1281,7 +1116,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3.10.6 ('pymdp')", "language": "python", "name": "python3" }, @@ -1295,11 +1130,11 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.13" + "version": "3.10.6" }, "vscode": { "interpreter": { - "hash": "4e1a08fe767a14203a671ee5de76a8a25ed3badbbf81ba1baf234489164a8ba4" + "hash": "a13d58c3049389772d4ec8f21129068e8476033462907987a5df16214d2dfc1f" } } }, diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 830913b8..4ec5b93f 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -9,11 +9,12 @@ import jax.numpy as jnp from jax import nn, vmap -from jax.tree_util import register_pytree_node_class from . import inference, control, learning, utils, maths +from equinox import Module, static_field -@register_pytree_node_class -class Agent(object): +from typing import Any, List, AnyStr, Optional + +class Agent(Module): """ The Agent class, the highest-level API that wraps together processes for action, perception, and learning under active inference. @@ -30,19 +31,41 @@ class Agent(object): observations and takes actions as inputs, would entail a dynamic agent-environment interaction. """ + A: List + B: List + C: List + D: List + E: jnp.ndarray + empirical_prior: List + gamma: jnp.ndarray + qs: Optional[List] + q_pi: Optional[List] + + # static parameters not leaves of the PyTree + num_obs: List = static_field() + num_modalities: int = static_field() + num_states: List = static_field() + num_factors: int = static_field() + num_controls: List = static_field() + inference_algo: AnyStr = static_field() + control_fac_idx: Any = static_field() + policy_len: int = static_field() + policies: Any = static_field() + use_utility: bool = static_field() + use_states_info_gain: bool = static_field() + use_param_info_gain: bool = static_field() + action_selection: AnyStr = static_field() + def __init__( self, A, B, - C=None, - D=None, - E=None, - pA=None, - pB=None, - pD=None, - num_controls=None, + C, + D, + E, + qs=None, + q_pi=None, policy_len=1, - inference_horizon=1, control_fac_idx=None, policies=None, gamma=16.0, @@ -51,203 +74,57 @@ def __init__( use_param_info_gain=False, action_selection="deterministic", inference_algo="VANILLA", - inference_params=None, - modalities_to_learn="all", - lr_pA=1.0, - factors_to_learn="all", - lr_pB=1.0, - lr_pD=1.0, - use_BMA = True, - policy_sep_prior = False, - save_belief_hist = False ): + ### PyTree leaves + + self.A = A + self.B = B + self.C = C + self.D = D + self.empirical_prior = D + self.E = E + self.qs = qs + self.q_pi = q_pi + + self.gamma = jnp.broadcast_to(gamma, self.A[0].shape[:1]) + + ### Static parameters ### - ### Constant parameters ### + self.inference_algo = inference_algo # policy parameters self.policy_len = policy_len - self.gamma = gamma self.action_selection = action_selection self.use_utility = use_utility self.use_states_info_gain = use_states_info_gain self.use_param_info_gain = use_param_info_gain - # learning parameters - self.modalities_to_learn = modalities_to_learn - self.lr_pA = lr_pA - self.factors_to_learn = factors_to_learn - self.lr_pB = lr_pB - self.lr_pD = lr_pD - - self.A = A - - # self.A = pytree.map(utils.normalized, A) - """ Determine number of observation modalities and their respective dimensions """ - self.num_obs = [self.A[m].shape[0] for m in range(len(self.A))] + self.num_obs = [self.A[m].shape[1] for m in range(len(self.A))] self.num_modalities = len(self.num_obs) - """ Assigning prior parameters on observation model (pA matrices) """ - self.pA = pA - - # self.B = map( utils.normalized, B) - self.B = B - # Determine number of hidden state factors and their dimensionalities - self.num_states = [self.B[f].shape[0] for f in range(len(self.B))] + self.num_states = [self.B[f].shape[1] for f in range(len(self.B))] self.num_factors = len(self.num_states) - """ Assigning prior parameters on transition model (pB matrices) """ - self.pB = pB - # If no `num_controls` are given, then this is inferred from the shapes of the input B matrices - self.num_controls = [self.B[f].shape[2] for f in range(self.num_factors)] + self.num_controls = [self.B[f].shape[-1] for f in range(self.num_factors)] # Users have the option to make only certain factors controllable. # default behaviour is to make all hidden state factors controllable # (i.e. self.num_states == self.num_controls) self.control_fac_idx = control_fac_idx - self.policies = policies - - self.C = C - - """ Construct prior over hidden states (uniform if not specified) """ - self.D = D - self.empirical_prior = D - - """ Assigning prior parameters on initial hidden states (pD vectors) """ - self.pD = pD - - """ Construct prior over policies (uniform if not specified) """ - - self.E = E - - self.prev_obs = [] - self.reset() - - self.action = None - self.prev_actions = None - - def tree_flatten(self): - children = (self.A, self.B, self.C, self.D, self.E, self.pA, self.pB, self.num_controls, self.policy_len, self.control_fac_idx, - self.policies, self.gamma, self.use_utility, self.use_states_info_gain, self.use_param_info_gain, self.action_selection, - self.modalities_to_learn, self.lr_pA, self.factors_to_learn, self.lr_pB, self.lr_pD) - aux_data = None - return (children, aux_data) - - @classmethod - def tree_unflatten(cls, aux_data, children): - # @NOTE: @dimarkov, see here: I'm unclear on how to handle this, since when this function gets vmapped across the leaf-nodes stored in `children`, some of - # these leaves (e.g. leaves like `self.use_states_info_gain`) won't be `jnp.arrays` with a batch dimension. - # - # We either need to not have them get vmapped across or turn them into NDarray representations with a proper batch dimension. Another example are lists like `self.modalities_to_learn` - # which can be a list of arbitrary length (e.g. something like `[0, 2, 3]`). For instance, we might have to turn this into a boolean array per agent with equal length, and then stacked them - # along a batch-dimension for each agent. - return cls(*children) - - def reset(self, init_qs=None): - """ - Resets the posterior beliefs about hidden states of the agent to a uniform distribution, and resets time to first timestep of the simulation's temporal horizon. - Returns the posterior beliefs about hidden states. - - Returns - --------- - qs: ``numpy.ndarray`` of dtype object - Initialized posterior over hidden states. Depending on the inference algorithm chosen and other parameters (such as the parameters stored within ``edge_handling_paramss), - the resulting ``qs`` variable will have additional sub-structure to reflect whether beliefs are additionally conditioned on timepoint and policy. - For example, in case the ``self.inference_algo == 'MMP' `, the indexing structure of ``qs`` is policy->timepoint-->factor, so that - ``qs[p_idx][t_idx][f_idx]`` refers to beliefs about marginal factor ``f_idx`` expected under policy ``p_idx`` - at timepoint ``t_idx``. In this case, the returned ``qs`` will only have entries filled out for the first timestep, i.e. for ``q[p_idx][0]``, for all - policy-indices ``p_idx``. Subsequent entries ``q[:][1, 2, ...]`` will be initialized to empty ``numpy.ndarray`` objects. - """ - - self.curr_timestep = 0 - - self.qs = utils.list_array_uniform(self.num_states) - - return self.qs - - def step_time(self): - """ - Advances time by one step. This involves updating the ``self.prev_actions``, and in the case of a moving - inference horizon, this also shifts the history of post-dictive beliefs forward in time (using ``self.set_latest_beliefs()``), - so that the penultimate belief before the beginning of the horizon is correctly indexed. - - Returns - --------- - curr_timestep: ``int`` - The index in absolute simulation time of the current timestep. - """ - - if self.prev_actions is None: - self.prev_actions = [self.action] + if policies is not None: + self.policies = policies else: - self.prev_actions.append(self.action) - - self.curr_timestep += 1 + self._construct_policies() - if self.inference_algo == "MMP" and (self.curr_timestep - self.inference_horizon) >= 0: - self.set_latest_beliefs() + def _construct_policies(self): - return self.curr_timestep - - def set_latest_beliefs(self,last_belief=None): - """ - Both sets and returns the penultimate belief before the first timestep of the backwards inference horizon. - In the case that the inference horizon includes the first timestep of the simulation, then the ``latest_belief`` is - simply the first belief of the whole simulation, or the prior (``self.D``). The particular structure of the ``latest_belief`` - depends on the value of ``self.edge_handling_params['use_BMA']``. - - Returns - --------- - latest_belief: ``numpy.ndarray`` of dtype object - Penultimate posterior beliefs over hidden states at the timestep just before the first timestep of the inference horizon. - Depending on the value of ``self.edge_handling_params['use_BMA']``, the shape of this output array will differ. - If ``self.edge_handling_params['use_BMA'] == True``, then ``latest_belief`` will be a Bayesian model average - of beliefs about hidden states, where the average is taken with respect to posterior beliefs about policies. - Otherwise, `latest_belief`` will be the full, policy-conditioned belief about hidden states, and will have indexing structure - policies->factors, such that ``latest_belief[p_idx][f_idx]`` refers to the penultimate belief about marginal factor ``f_idx`` - under policy ``p_idx``. - """ - - if last_belief is None: - last_belief = utils.obj_array(len(self.policies)) - for p_i, _ in enumerate(self.policies): - last_belief[p_i] = copy.deepcopy(self.qs[p_i][0]) - - begin_horizon_step = self.curr_timestep - self.inference_horizon - if self.edge_handling_params['use_BMA'] and (begin_horizon_step >= 0): - if hasattr(self, "q_pi_hist"): - self.latest_belief = inference.average_states_over_policies(last_belief, self.q_pi_hist[begin_horizon_step]) # average the earliest marginals together using contemporaneous posterior over policies (`self.q_pi_hist[0]`) - else: - self.latest_belief = inference.average_states_over_policies(last_belief, self.q_pi) # average the earliest marginals together using posterior over policies (`self.q_pi`) - else: - self.latest_belief = last_belief - - return self.latest_belief + self.policies = control.construct_policies( + self.num_states, self.num_controls, self.policy_len, self.control_fac_idx + ) - def get_future_qs(self): - """ - Returns the last ``self.policy_len`` timesteps of each policy-conditioned belief - over hidden states. This is a step of pre-processing that needs to be done before computing - the expected free energy of policies. We do this to avoid computing the expected free energy of - policies using beliefs about hidden states in the past (so-called "post-dictive" beliefs). - - Returns - --------- - future_qs_seq: ``numpy.ndarray`` of dtype object - Posterior beliefs over hidden states under a policy, in the future. This is a nested ``numpy.ndarray`` object array, with one - sub-array ``future_qs_seq[p_idx]`` for each policy. The indexing structure is policy->timepoint-->factor, so that - ``future_qs_seq[p_idx][t_idx][f_idx]`` refers to beliefs about marginal factor ``f_idx`` expected under policy ``p_idx`` - at future timepoint ``t_idx``, relative to the current timestep. - """ - - future_qs_seq = utils.obj_array(len(self.qs)) - for p_idx in range(len(self.qs)): - future_qs_seq[p_idx] = self.qs[p_idx][-(self.policy_len+1):] # this grabs only the last `policy_len`+1 beliefs about hidden states, under each policy - - return future_qs_seq - @vmap def infer_states(self, observations): """ @@ -276,8 +153,6 @@ def infer_states(self, observations): prior=self.empirical_prior ) - self.qs = qs # this doesn't work, apparently? - return qs def update_empirical_prior(self, action): @@ -286,7 +161,8 @@ def update_empirical_prior(self, action): self.qs, self.B, action ) - def infer_policies(self): + @vmap + def infer_policies(self, qs: List): """ Perform policy inference by optimizing a posterior (categorical) distribution over policies. This distribution is computed as the softmax of ``G * gamma + lnE`` where ``G`` is the negative expected @@ -303,159 +179,38 @@ def infer_policies(self): q_pi, G = control.update_posterior_policies( self.policies, - self.qs, + qs, self.A, self.B, self.C, gamma = self.gamma ) - self.q_pi = q_pi - self.G = G return q_pi, G - def sample_action(self): + def sample_action(self, q_pi: jnp.ndarray): """ Sample or select a discrete action from the posterior over control states. - This function both sets or cachés the action as an internal variable with the agent and returns it. - This function also updates time variable (and thus manages consequences of updating the moving reference frame of beliefs) - using ``self.step_time()``. Returns ---------- - action: 1D ``numpy.ndarray`` + action: 1D ``jax.numpy.ndarray`` Vector containing the indices of the actions for each control factor """ - action = control.sample_action( - self.q_pi, self.policies, self.num_controls, self.action_selection - ) - - self.action = action + sample_action = lambda x: control.sample_action(x, self.policies, self.num_controls, self.action_selection) - self.step_time() + action = vmap(sample_action)(q_pi) return action - def update_A(self, obs): - """ - Update approximate posterior beliefs about Dirichlet parameters that parameterise the observation likelihood or ``A`` array. - - Parameters - ---------- - observation: ``list`` or ``tuple`` of ints - The observation input. Each entry ``observation[m]`` stores the index of the discrete - observation for modality ``m``. - - Returns - ----------- - qA: ``numpy.ndarray`` of dtype object - Posterior Dirichlet parameters over observation model (same shape as ``A``), after having updated it with observations. - """ - - qA = learning.update_obs_likelihood_dirichlet( - self.pA, - self.A, - obs, - self.qs, - self.lr_pA, - self.modalities_to_learn - ) - - self.pA = qA # set new prior to posterior - self.A = utils.norm_dist_obj_arr(qA) # take expected value of posterior Dirichlet parameters to calculate posterior over A array - - return qA - - def update_B(self, qs_prev): - """ - Update posterior beliefs about Dirichlet parameters that parameterise the transition likelihood - - Parameters - ----------- - qs_prev: 1D ``numpy.ndarray`` or ``numpy.ndarray`` of dtype object - Marginal posterior beliefs over hidden states at previous timepoint. - - Returns - ----------- - qB: ``numpy.ndarray`` of dtype object - Posterior Dirichlet parameters over transition model (same shape as ``B``), after having updated it with state beliefs and actions. - """ - - qB = learning.update_state_likelihood_dirichlet( - self.pB, - self.B, - self.action, - self.qs, - qs_prev, - self.lr_pB, - self.factors_to_learn - ) - - self.pB = qB # set new prior to posterior - self.B = utils.norm_dist_obj_arr(qB) # take expected value of posterior Dirichlet parameters to calculate posterior over B array - - return qB - - def update_D(self, qs_t0 = None): - """ - Update Dirichlet parameters of the initial hidden state distribution - (prior beliefs about hidden states at the beginning of the inference window). - - Parameters - ----------- - qs_t0: 1D ``numpy.ndarray``, ``numpy.ndarray`` of dtype object, or ``None`` - Marginal posterior beliefs over hidden states at current timepoint. If ``None``, the - value of ``qs_t0`` is set to ``self.qs_hist[0]`` (i.e. the initial hidden state beliefs at the first timepoint). - If ``self.inference_algo == "MMP"``, then ``qs_t0`` is set to be the Bayesian model average of beliefs about hidden states - at the first timestep of the backwards inference horizon, where the average is taken with respect to posterior beliefs about policies. - - Returns - ----------- - qD: ``numpy.ndarray`` of dtype object - Posterior Dirichlet parameters over initial hidden state prior (same shape as ``qs_t0``), after having updated it with state beliefs. - """ - - if self.inference_algo == "VANILLA": - - if qs_t0 is None: - - try: - qs_t0 = self.qs_hist[0] - except ValueError: - print("qs_t0 must either be passed as argument to `update_D` or `save_belief_hist` must be set to True!") - - elif self.inference_algo == "MMP": - - if self.edge_handling_params['use_BMA']: - qs_t0 = self.latest_belief - elif self.edge_handling_params['policy_sep_prior']: - - qs_pi_t0 = self.latest_belief - - # get beliefs about policies at the time at the beginning of the inference horizon - if hasattr(self, "q_pi_hist"): - begin_horizon_step = max(0, self.curr_timestep - self.inference_horizon) - q_pi_t0 = self.q_pi_hist[begin_horizon_step].copy() - else: - q_pi_t0 = self.q_pi.copy() - - qs_t0 = inference.average_states_over_policies(qs_pi_t0,q_pi_t0) # beliefs about hidden states at the first timestep of the inference horizon - - qD = learning.update_state_prior_dirichlet(self.pD, qs_t0, self.lr_pD, factors = self.factors_to_learn) - - self.pD = qD # set new prior to posterior - self.D = utils.norm_dist_obj_arr(qD) # take expected value of posterior Dirichlet parameters to calculate posterior over D array - - return qD - def _get_default_params(self): method = self.inference_algo default_params = None if method == "VANILLA": default_params = {"num_iter": 10, "dF": 1.0, "dF_tol": 0.001} elif method == "MMP": - default_params = {"num_iter": 10, "grad_descent": True, "tau": 0.25} + raise NotImplementedError("MMP is not implemented") elif method == "VMP": raise NotImplementedError("VMP is not implemented") elif method == "BP": diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index cb0f8f9c..c65a14c6 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -3,7 +3,9 @@ # pylint: disable=no-member # pylint: disable=not-an-iterable +import itertools import jax.numpy as jnp +import jax.tree_util as jtu from functools import partial from jax import lax, jit, vmap, nn from itertools import chain @@ -12,6 +14,107 @@ # import pymdp.jax.utils as utils +def sample_action(q_pi, policies, num_controls, action_selection="deterministic", alpha=16.0, rng_key=None): + """ + Computes the marginal posterior over actions and then samples an action from it, one action per control factor. + + Parameters + ---------- + q_pi: 1D ``numpy.ndarray`` + Posterior beliefs over policies, i.e. a vector containing one posterior probability per policy. + policies: ``list`` of 2D ``numpy.ndarray`` + ``list`` that stores each policy as a 2D array in ``policies[p_idx]``. Shape of ``policies[p_idx]`` + is ``(num_timesteps, num_factors)`` where ``num_timesteps`` is the temporal + depth of the policy and ``num_factors`` is the number of control factors. + num_controls: ``list`` of ``int`` + ``list`` of the dimensionalities of each control state factor. + action_selection: string, default "deterministic" + String indicating whether whether the selected action is chosen as the maximum of the posterior over actions, + or whether it's sampled from the posterior marginal over actions + alpha: float, default 16.0 + Action selection precision -- the inverse temperature of the softmax that is used to scale the + action marginals before sampling. This is only used if ``action_selection`` argument is "stochastic" + + Returns + ---------- + selected_policy: 1D ``numpy.ndarray`` + Vector containing the indices of the actions for each control factor + """ + + num_factors = len(num_controls) + + # weight each action according to its integrated posterior probability over policies and timesteps + # for pol_idx, policy in enumerate(policies): + # for t in range(policy.shape[0]): + # for factor_i, action_i in enumerate(policy[t, :]): + # marginal[factor_i][action_i] += q_pi[pol_idx] + + # weight each action according to its integrated posterior probability under all policies at the current timestep + + #NOTE: Why is the original version selecting policy[0, :] and not policy[t, :] + # for pol_idx, policy in enumerate(policies): + # for factor_i, action_i in enumerate(policy[0, :]): + # action_marginals[factor_i][action_i] += q_pi[pol_idx] + + marginal = [] + for factor_i in range(num_factors): + actions = jnp.arange(num_controls[factor_i])[:, None] + marginal.append(jnp.where(actions==policies[:, 0, factor_i], q_pi, 0).sum(-1)) + + if action_selection == 'deterministic': + selected_policy = jtu.tree_map(lambda x: jnp.argmax(x, -1), marginal) + elif action_selection == 'stochastic': + selected_policy = jtu.tree_map( lambda x: random.categorical(rng_key, alpha * log_stable(x)), marginal) + else: + raise NotImplementedError + + return jnp.array(selected_policy) + + +def construct_policies(num_states, num_controls = None, policy_len=1, control_fac_idx=None): + """ + Generate a ``list`` of policies. The returned array ``policies`` is a ``list`` that stores one policy per entry. + A particular policy (``policies[i]``) has shape ``(num_timesteps, num_factors)`` + where ``num_timesteps`` is the temporal depth of the policy and ``num_factors`` is the number of control factors. + + Parameters + ---------- + num_states: ``list`` of ``int`` + ``list`` of the dimensionalities of each hidden state factor + num_controls: ``list`` of ``int``, default ``None`` + ``list`` of the dimensionalities of each control state factor. If ``None``, then is automatically computed as the dimensionality of each hidden state factor that is controllable + policy_len: ``int``, default 1 + temporal depth ("planning horizon") of policies + control_fac_idx: ``list`` of ``int`` + ``list`` of indices of the hidden state factors that are controllable (i.e. those state factors ``i`` where ``num_controls[i] > 1``) + + Returns + ---------- + policies: ``list`` of 2D ``numpy.ndarray`` + ``list`` that stores each policy as a 2D array in ``policies[p_idx]``. Shape of ``policies[p_idx]`` + is ``(num_timesteps, num_factors)`` where ``num_timesteps`` is the temporal + depth of the policy and ``num_factors`` is the number of control factors. + """ + + num_factors = len(num_states) + if control_fac_idx is None: + if num_controls is not None: + control_fac_idx = [f for f, n_c in enumerate(num_controls) if n_c > 1] + else: + control_fac_idx = list(range(num_factors)) + + if num_controls is None: + num_controls = [num_states[c_idx] if c_idx in control_fac_idx else 1 for c_idx in range(num_factors)] + + x = num_controls * policy_len + policies = list(itertools.product(*[list(range(i)) for i in x])) + + for pol_i in range(len(policies)): + policies[pol_i] = jnp.array(policies[pol_i]).reshape(policy_len, num_factors) + + return jnp.stack(policies) + + def update_posterior_policies(policy_matrix, qs_init, A, B, C, gamma=16.0): # policy --> n_levels_factor_f x 1 # factor --> n_levels_factor_f x n_policies From 097fcc4c1789e790cfcaf1bfc39050a2ae19f934 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Thu, 10 Nov 2022 19:16:04 +0100 Subject: [PATCH 024/232] added likelihood function for an AIF agent --- examples/model_inversion.ipynb | 385 ++++++--------------------------- pymdp/jax/agent.py | 44 +++- pymdp/jax/control.py | 50 +++-- pymdp/jax/likelihoods.py | 42 ++-- 4 files changed, 153 insertions(+), 368 deletions(-) diff --git a/examples/model_inversion.ipynb b/examples/model_inversion.ipynb index 3648f43a..b8e0bc0b 100644 --- a/examples/model_inversion.ipynb +++ b/examples/model_inversion.ipynb @@ -18,7 +18,6 @@ "\n", "import seaborn as sns\n", "import matplotlib.pyplot as plt\n", - "import copy\n", "\n", "from pymdp.jax.agent import Agent\n", "from pymdp.envs import TMazeEnv" @@ -148,7 +147,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -170,7 +169,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -192,7 +191,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -239,7 +238,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -279,7 +278,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -299,7 +298,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -319,7 +318,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -339,7 +338,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -368,15 +367,7 @@ "cell_type": "code", "execution_count": 15, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:jax._src.lib.xla_bridge:No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n" - ] - } - ], + "outputs": [], "source": [ "num_agents = 50 # number of different agents \n", "A_gm = [jnp.broadcast_to(jnp.array(a), (num_agents,) + a.shape) for a in A_gp] # map the true observation likelihood to jax arrays\n", @@ -472,13 +463,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "PyTreeDef(CustomNode(Agent[(('A', 'B', 'C', 'D', 'E', 'empirical_prior', 'gamma', 'qs', 'q_pi'), ('num_obs', 'num_modalities', 'num_states', 'num_factors', 'num_controls', 'inference_algo', 'control_fac_idx', 'policy_len', 'policies', 'use_utility', 'use_states_info_gain', 'use_param_info_gain', 'action_selection'), ([4, 3, 2], 3, [4, 2], 2, [4, 1], 'VANILLA', [0], 1, DeviceArray([[[0, 0]],\n", + "PyTreeDef(CustomNode(Agent[(('A', 'B', 'C', 'D', 'E', 'gamma', 'qs', 'q_pi'), ('num_obs', 'num_modalities', 'num_states', 'num_factors', 'num_controls', 'inference_algo', 'control_fac_idx', 'policy_len', 'policies', 'use_utility', 'use_states_info_gain', 'use_param_info_gain', 'action_selection'), ([4, 3, 2], 3, [4, 2], 2, [4, 1], 'VANILLA', [0], 1, DeviceArray([[[0, 0]],\n", "\n", " [[1, 0]],\n", "\n", " [[2, 0]],\n", "\n", - " [[3, 0]]], dtype=int32), True, True, False, 'deterministic'))], [[*, *, *], [*, *], [*, *, *], [*, *], *, [*, *], *, None, None]))\n" + " [[3, 0]]], dtype=int32), True, True, False, 'deterministic'))], [[*, *, *], [*, *], [*, *, *], [*, *], *, *, None, None]))\n" ] } ], @@ -500,7 +491,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 20, "metadata": { "scrolled": false }, @@ -510,23 +501,24 @@ "output_type": "stream", "text": [ " === Starting experiment === \n", - " Reward condition: Right, Observation: [CENTER, No reward, Cue Right]\n", - "[Step 0] Action: [Move to LEFT ARM]\n", - "[Step 0] Observation: [LEFT ARM, Loss!, Cue Right]\n", - "[Step 1] Action: [Move to LEFT ARM]\n", - "[Step 1] Observation: [LEFT ARM, Loss!, Cue Left]\n", + " Reward condition: Left, Observation: [CENTER, No reward, Cue Left]\n", + "[Step 0] Action: [Move to RIGHT ARM]\n", + "[Step 0] Observation: [RIGHT ARM, Loss!, Cue Right]\n", + "[Step 1] Action: [Move to CUE LOCATION]\n", + "[Step 1] Observation: [CUE LOCATION, No reward, Cue Left]\n", "[Step 2] Action: [Move to RIGHT ARM]\n", - "[Step 2] Observation: [RIGHT ARM, Reward!, Cue Right]\n", - "[Step 3] Action: [Move to LEFT ARM]\n", - "[Step 3] Observation: [LEFT ARM, Loss!, Cue Left]\n", + "[Step 2] Observation: [RIGHT ARM, Loss!, Cue Left]\n", + "[Step 3] Action: [Move to RIGHT ARM]\n", + "[Step 3] Observation: [RIGHT ARM, Loss!, Cue Left]\n", "[Step 4] Action: [Move to RIGHT ARM]\n", - "[Step 4] Observation: [RIGHT ARM, Reward!, Cue Left]\n" + "[Step 4] Observation: [RIGHT ARM, Loss!, Cue Right]\n" ] } ], "source": [ "T = 5 # number of timesteps\n", "\n", + "emp_prior = D_gm\n", "_obs = env.reset() # reset the environment and get an initial observation\n", "obs = jnp.broadcast_to(jnp.array(_obs), (num_agents, len(_obs)))\n", "\n", @@ -538,15 +530,16 @@ "msg = \"\"\" === Starting experiment === \\n Reward condition: {}, Observation: [{}, {}, {}]\"\"\"\n", "print(msg.format(reward_conditions[env.reward_condition], location_observations[_obs[0]], reward_observations[_obs[1]], cue_observations[_obs[2]]))\n", "\n", - "measurments = {'actions': [], 'outcomes': [obs]}\n", + "measurements = {'actions': [], 'outcomes': [obs]}\n", "for t in range(T):\n", - " qx = agent.infer_states(obs)\n", + " qs = agent.infer_states(obs, emp_prior)\n", "\n", - " q_pi, efe = agent.infer_policies(qx)\n", + " q_pi, efe = agent.infer_policies(qs)\n", "\n", " actions = agent.sample_action(q_pi)\n", - " measurments[\"actions\"].append( actions )\n", + " emp_prior = agent.update_empirical_prior(actions, qs)\n", "\n", + " measurements[\"actions\"].append( actions )\n", " msg = \"\"\"[Step {}] Action: [Move to {}]\"\"\"\n", " print(msg.format(t, location_observations[int(actions[0, 0])]))\n", "\n", @@ -554,23 +547,26 @@ " for a in actions:\n", " obs.append( jnp.array(env.step(list(a))) )\n", " obs = jnp.stack(obs)\n", - " measurments[\"outcomes\"].append(obs)\n", + " measurements[\"outcomes\"].append(obs)\n", "\n", " msg = \"\"\"[Step {}] Observation: [{}, {}, {}]\"\"\"\n", " print(msg.format(t, location_observations[obs[0, 0]], reward_observations[obs[0, 1]], cue_observations[obs[0, 2]]))\n", " \n", - "measurments['actions'] = jnp.stack(measurments['actions']).astype(jnp.int32)\n", - "measurments['outcomes'] = jnp.stack(measurments['outcomes'])" + "measurements['actions'] = jnp.stack(measurements['actions']).astype(jnp.int32)\n", + "measurements['outcomes'] = jnp.stack(measurements['outcomes'])\n", + "\n", + "measurements['outcomes'] = measurements['outcomes'][None, :T]\n", + "measurements['actions'] = measurements['actions'][None]" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -580,7 +576,7 @@ } ], "source": [ - "plot_beliefs(qx[1][0],\"Final posterior beliefs about reward condition\")" + "plot_beliefs(qs[1][0],\"Final posterior beliefs about reward condition\")" ] }, { @@ -593,303 +589,52 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import pymdp.jax.utils as jutil\n", - "import pymdp.jax.maths as jmaths\n", - "from pymdp.jax.agent import Agent\n", - "\n", - "def scan(step_fn, init, iterator):\n", - " carry = init\n", - " for itr in iterator:\n", - " carry = step_fn(carry, itr)\n", - " \n", - " return carry[-1]\n", - " \n", - "def model_log_likelihood(T, data, params):\n", - " agent = Agent(params['A'], params['B'], C=params['C'], D=params['D'], policies=policies, gamma=1.)\n", - " def step_fn(carry, t):\n", - " log_prob = carry\n", - " outcome = list(data['outcomes'][t])\n", - " qx = agent.infer_states(outcome)\n", - " q_pi, _ = agent.infer_policies()\n", - " \n", - " nc = agent.num_controls\n", - " num_factors = len(agent.num_controls)\n", - " \n", - " marginal = []\n", - " for factor_i in range(num_factors):\n", - " m = []\n", - " actions = agent.policies[:, 0, factor_i]\n", - " for a in range(nc[factor_i]):\n", - " m.append( jnp.where(actions==a, q_pi, 0).sum() )\n", - " marginal.append(jnp.stack(m))\n", - " \n", - " action = data['actions'][t]\n", - " for factor_idx, m in enumerate(marginal):\n", - " log_prob += jmaths.log_stable(m[action[factor_idx]])\n", - " \n", - " # action = npyro.sample('action', dist.CategoricalProbs(marginal), obs=action)\n", - " agent.update_empirical_prior(action)\n", - " return log_prob, None\n", - " \n", - " log_prob = 0.\n", - " init = (log_prob)\n", - " log_prob, _ = jax.lax.scan(step_fn, init, np.arange(T))\n", - " return log_prob" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "DeviceArray(-9.186159, dtype=float32)" - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# the following grad computation has to work for the Agent class to be differentiable and hence invertible\n", - "from functools import partial\n", - "\n", - "# parameters have to be jax arrays, lists or dictionaries of jax arrays\n", - "params = {\n", - " 'A': [jnp.array(x) for x in list(A_gp)],\n", - " 'B': [jnp.array(x) for x in list(B_gp)],\n", - " 'C': [jnp.array(x) for x in list(agent.C)],\n", - " 'D': [jnp.array(x) for x in list(agent.D)]\n", - "}\n", - "\n", - "partial(model_log_likelihood, T, measurments)(params)" - ] - }, - { - "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "([DeviceArray([[0.05032608, 0.00282504, 0.8965227 , 0.05032609],\n", - " [0.05032609, 0.8965228 , 0.00282504, 0.0503261 ],\n", - " [0.05032608, 0.00282504, 0.8965227 , 0.05032609],\n", - " [0.05032609, 0.8965228 , 0.00282504, 0.0503261 ],\n", - " [0.05032609, 0.8965228 , 0.00282504, 0.0503261 ]], dtype=float32),\n", - " DeviceArray([[0.99999994],\n", - " [1. ],\n", - " [0.99999994],\n", - " [1. ],\n", - " [1. ]], dtype=float32)],\n", - " [DeviceArray([0, 3, 1, 1, 1], dtype=int32),\n", - " DeviceArray([0, 0, 1, 1, 1], dtype=int32),\n", - " DeviceArray([1, 0, 1, 0, 0], dtype=int32)],\n", - " DeviceArray([[3, 0],\n", - " [1, 0],\n", - " [1, 0],\n", - " [1, 0],\n", - " [1, 0]], dtype=int32))" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 5, 50, 3)\n", + "(1, 5, 50, 2)\n", + "444 ms ± 6.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] } ], "source": [ "import numpyro as npyro\n", "from pymdp.jax.likelihoods import aif_likelihood, evolve_trials\n", "\n", - "Na = 1\n", - "Nb = 1\n", - "Nt = T\n", + "print(measurements['outcomes'].shape)\n", + "print(measurements['actions'].shape)\n", "\n", - "shape1 = measurments['outcomes'].shape[1:]\n", - "shape2 = measurments['actions'].shape[1:]\n", - "data = {\n", - " 'outcomes': jnp.broadcast_to(jnp.expand_dims(measurments['outcomes'][:-1], -2), (Nb, Nt, Na,) + shape1),\n", - " 'actions': jnp.broadcast_to(jnp.expand_dims(measurments['actions'], -2), (Nb, Nt, Na,) + shape2)\n", - "}\n", - "agent = Agent(params['A'], params['B'], C=params['C'], D=params['D'], policies=policies, gamma=1.)\n", + "Nb, Nt, Na, _ = measurements['actions'].shape\n", "\n", - "xs = {'outcomes': data['outcomes'][0].squeeze(), 'actions': data['actions'][0].squeeze()}\n", + "xs = {'outcomes': measurements['outcomes'][0], 'actions': measurements['actions'][0]}\n", "evolve_trials(agent, xs)\n", + "%timeit evolve_trials(agent, xs)\n", "\n", - "# with npyro.handlers.seed(rng_seed=0):\n", - "# aif_likelihood(Na, Nb, Nt, data, agent)" + "with npyro.handlers.seed(rng_seed=0):\n", + " aif_likelihood(Nb, Nt, Na, measurements, agent)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "[DeviceArray([0., 0., 0., 0.], dtype=float32),\n", - " DeviceArray([ 0., 3., -3.], dtype=float32),\n", - " DeviceArray([0., 0.], dtype=float32)]" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "params['C']" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "DeviceArray(-9.186157, dtype=float32)" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "jax.jit(partial(model_log_likelihood, T, measurments))(params)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'A': [DeviceArray([[[ 4.8202928e-08, -5.9604645e-08],\n", - " [-5.6621374e-14, 1.4210855e-14],\n", - " [ 0.0000000e+00, 0.0000000e+00],\n", - " [-5.6843419e-14, 3.5527137e-15]],\n", - " \n", - " [[ 0.0000000e+00, 3.5527137e-15],\n", - " [ 2.5891669e-08, -5.8164735e-09],\n", - " [ 0.0000000e+00, 0.0000000e+00],\n", - " [-5.6843419e-14, 3.5527137e-15]],\n", - " \n", - " [[ 0.0000000e+00, 3.5527137e-15],\n", - " [-5.6621374e-14, 1.4210855e-14],\n", - " [ 0.0000000e+00, 0.0000000e+00],\n", - " [-5.6843419e-14, 3.5527137e-15]],\n", - " \n", - " [[ 0.0000000e+00, 3.5527137e-15],\n", - " [-5.6621374e-14, 1.4210855e-14],\n", - " [ 0.0000000e+00, 0.0000000e+00],\n", - " [ 0.0000000e+00, -2.9082159e-09]]], dtype=float32),\n", - " DeviceArray([[[ 4.8202928e-08, -6.2512861e-08],\n", - " [-5.6621374e-14, 1.4210855e-14],\n", - " [ 0.0000000e+00, 0.0000000e+00],\n", - " [ 4.8202928e-08, -6.2512861e-08]],\n", - " \n", - " [[-4.5293498e-01, -3.0195665e-01],\n", - " [ 9.3129528e-01, 2.9830487e+00],\n", - " [-2.5424069e-02, -5.3791361e+00],\n", - " [-4.5293495e-01, 2.6980436e+00]],\n", - " \n", - " [[ 4.5293498e-01, 3.0195665e-01],\n", - " [-9.3129539e-01, -2.9830496e+00],\n", - " [ 2.5425371e-02, 5.3791361e+00],\n", - " [ 4.5293495e-01, -2.6980436e+00]]], dtype=float32),\n", - " DeviceArray([[[ 0.0000000e+00, -1.7449379e-08],\n", - " [ 8.6736174e-19, -1.7449379e-08],\n", - " [-2.2204460e-16, -1.7449379e-08],\n", - " [ 1.6566540e-07, -5.0599152e+01]],\n", - " \n", - " [[ 1.4818920e-07, -1.1920929e-07],\n", - " [ 1.4818920e-07, -1.1920929e-07],\n", - " [ 1.4818920e-07, -1.1920929e-07],\n", - " [ 8.4943476e+00, -8.7415906e-08]]], dtype=float32)],\n", - " 'B': [DeviceArray([[[ 3.01956534e-01, 1.47320042e+01, -1.31633423e+02,\n", - " 7.21276321e+01],\n", - " [ 4.52934742e-01, 1.76242935e+02, -1.32046906e+02,\n", - " -1.21084461e+01],\n", - " [ 4.52937773e-33, 1.76244106e-30, -1.32047794e-30,\n", - " -1.21085263e-31],\n", - " [ 3.01955963e-17, 3.02909273e-15, -8.26975670e-17,\n", - " -8.07228275e-16]],\n", - " \n", - " [[-1.47221327e+01, 4.19397838e-03, -6.52539444e+01,\n", - " 1.36325211e+02],\n", - " [-2.22281380e+01, -5.88822317e+00, -6.54751358e+01,\n", - " -2.35140533e+01],\n", - " [-2.22282855e-31, -5.88826220e-32, -6.54755667e-31,\n", - " -2.35142105e-31],\n", - " [-1.50119840e-15, -2.48344952e-18, -4.42394456e-17,\n", - " -1.58692597e-15]],\n", - " \n", - " [[-1.47221327e+01, 7.28492451e+00, 1.24194115e-01,\n", - " 1.42085220e+02],\n", - " [-2.19382591e+01, 9.30899048e+01, 1.40805125e-01,\n", - " -2.32241745e+01],\n", - " [-2.19384062e-31, 9.30905292e-31, 1.40806067e-33,\n", - " -2.32243312e-31],\n", - " [-1.44322280e-15, 1.50122159e-15, 3.32224416e-18,\n", - " -1.52895037e-15]],\n", - " \n", - " [[-7.28478909e+00, 1.48017712e+01, -1.32256821e+02,\n", - " -2.69804382e+00],\n", - " [-1.09271832e+01, 1.77077591e+02, -1.32672256e+02,\n", - " 4.52934831e-01],\n", - " [-1.09272556e-31, 1.77078764e-30, -1.32673129e-30,\n", - " 4.52937883e-33],\n", - " [-7.28477557e-16, 3.04343787e-15, -8.30892073e-17,\n", - " 3.01956029e-17]]], dtype=float32),\n", - " DeviceArray([[[ 0.9184518],\n", - " [21.61026 ]],\n", - " \n", - " [[-2.5714204],\n", - " [-8.027699 ]]], dtype=float32)],\n", - " 'C': [DeviceArray([-0.25163043, 1.3047817 , -1.8015203 , 0.7483697 ], dtype=float32),\n", - " DeviceArray([ 0.49673924, -1.4332438 , 0.936505 ], dtype=float32),\n", - " DeviceArray([-0.52516294, 0.52516335], dtype=float32)],\n", - " 'D': [DeviceArray([0., 0., 0., 0.], dtype=float32),\n", - " DeviceArray([ 5.927568e-07, -5.466347e-07], dtype=float32)]}" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# grad computation cannot work until everything is jaxified\n", - "jax.grad(jax.jit(partial(model_log_likelihood, T, measurments)))(params)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[2.7251303e-01 1.7827910e-01 3.6590501e-07]\n", - "-7.051658\n" + "ename": "NameError", + "evalue": "name 'model_log_likelihood' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn [23], line 42\u001b[0m\n\u001b[1;32m 38\u001b[0m npyro\u001b[39m.\u001b[39mfactor(\u001b[39m'\u001b[39m\u001b[39mlog_prob\u001b[39m\u001b[39m'\u001b[39m, log_prob)\n\u001b[1;32m 40\u001b[0m \u001b[39mreturn\u001b[39;00m log_prob\n\u001b[0;32m---> 42\u001b[0m \u001b[39mprint\u001b[39m(jax\u001b[39m.\u001b[39;49mgrad(\u001b[39mlambda\u001b[39;49;00m x: model_log_likelihood(T, measurments, trans_params(x)))(jnp\u001b[39m.\u001b[39;49mones(\u001b[39m3\u001b[39;49m)))\n\u001b[1;32m 44\u001b[0m \u001b[39mwith\u001b[39;00m npyro\u001b[39m.\u001b[39mhandlers\u001b[39m.\u001b[39mseed(rng_seed\u001b[39m=\u001b[39m\u001b[39m101111\u001b[39m):\n\u001b[1;32m 45\u001b[0m lp \u001b[39m=\u001b[39m model(measurments, T)\n", + " \u001b[0;31m[... skipping hidden 10 frame]\u001b[0m\n", + "Cell \u001b[0;32mIn [23], line 42\u001b[0m, in \u001b[0;36m\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 38\u001b[0m npyro\u001b[39m.\u001b[39mfactor(\u001b[39m'\u001b[39m\u001b[39mlog_prob\u001b[39m\u001b[39m'\u001b[39m, log_prob)\n\u001b[1;32m 40\u001b[0m \u001b[39mreturn\u001b[39;00m log_prob\n\u001b[0;32m---> 42\u001b[0m \u001b[39mprint\u001b[39m(jax\u001b[39m.\u001b[39mgrad(\u001b[39mlambda\u001b[39;00m x: model_log_likelihood(T, measurments, trans_params(x)))(jnp\u001b[39m.\u001b[39mones(\u001b[39m3\u001b[39m)))\n\u001b[1;32m 44\u001b[0m \u001b[39mwith\u001b[39;00m npyro\u001b[39m.\u001b[39mhandlers\u001b[39m.\u001b[39mseed(rng_seed\u001b[39m=\u001b[39m\u001b[39m101111\u001b[39m):\n\u001b[1;32m 45\u001b[0m lp \u001b[39m=\u001b[39m model(measurments, T)\n", + "\u001b[0;31mNameError\u001b[0m: name 'model_log_likelihood' is not defined" ] } ], @@ -1116,7 +861,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.10.6 ('pymdp')", + "display_name": "Python 3.9.13 ('pymdp')", "language": "python", "name": "python3" }, @@ -1130,11 +875,11 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.6" + "version": "3.9.13" }, "vscode": { "interpreter": { - "hash": "a13d58c3049389772d4ec8f21129068e8476033462907987a5df16214d2dfc1f" + "hash": "4e1a08fe767a14203a671ee5de76a8a25ed3badbbf81ba1baf234489164a8ba4" } } }, diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 4ec5b93f..32e978a3 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -8,6 +8,7 @@ """ import jax.numpy as jnp +import jax.tree_util as jtu from jax import nn, vmap from . import inference, control, learning, utils, maths from equinox import Module, static_field @@ -36,7 +37,7 @@ class Agent(Module): C: List D: List E: jnp.ndarray - empirical_prior: List + # empirical_prior: List gamma: jnp.ndarray qs: Optional[List] q_pi: Optional[List] @@ -81,7 +82,7 @@ def __init__( self.B = B self.C = C self.D = D - self.empirical_prior = D + # self.empirical_prior = D self.E = E self.qs = qs self.q_pi = q_pi @@ -126,7 +127,7 @@ def _construct_policies(self): ) @vmap - def infer_states(self, observations): + def infer_states(self, observations, empirical_prior): """ Update approximate posterior over hidden states by solving variational inference problem, given an observation. @@ -150,16 +151,15 @@ def infer_states(self, observations): qs = inference.update_posterior_states( self.A, o_vec, - prior=self.empirical_prior + prior=empirical_prior ) return qs - def update_empirical_prior(self, action): - # update self.empirical_prior - self.empirical_prior = control.compute_expected_state( - self.qs, self.B, action - ) + @vmap + def update_empirical_prior(self, action, qs): + # return empirical_prior + return control.compute_expected_state(qs, self.B, action) @vmap def infer_policies(self, qs: List): @@ -187,6 +187,32 @@ def infer_policies(self, qs: List): ) return q_pi, G + + @vmap + def action_probabilities(self, q_pi: jnp.ndarray): + """ + Compute probabilities of discrete actions from the posterior over policies. + + Parameters + ---------- + q_pi: 1D ``numpy.ndarray`` + Posterior beliefs over policies, i.e. a vector containing one posterior probability per policy. + + Returns + ---------- + action: 2D ``jax.numpy.ndarray`` + Vector containing probabilities of possible actions for different factors + """ + + marginals = control.get_marginals(q_pi, self.policies, self.num_controls) + + # make all arrays same length (add 0 probability) + lengths = jtu.tree_map(lambda x: len(x), marginals) + max_length = max(lengths) + marginals = jtu.tree_map(lambda x: jnp.pad(x, (0, max_length - len(x))), marginals) + + return jnp.stack(marginals, -2) + def sample_action(self, q_pi: jnp.ndarray): """ diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index c65a14c6..5c546ae1 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -13,10 +13,9 @@ from pymdp.jax.maths import * # import pymdp.jax.utils as utils - -def sample_action(q_pi, policies, num_controls, action_selection="deterministic", alpha=16.0, rng_key=None): +def get_marginals(q_pi, policies, num_controls): """ - Computes the marginal posterior over actions and then samples an action from it, one action per control factor. + Computes the marginal posterior over actions. Parameters ---------- @@ -28,19 +27,12 @@ def sample_action(q_pi, policies, num_controls, action_selection="deterministic" depth of the policy and ``num_factors`` is the number of control factors. num_controls: ``list`` of ``int`` ``list`` of the dimensionalities of each control state factor. - action_selection: string, default "deterministic" - String indicating whether whether the selected action is chosen as the maximum of the posterior over actions, - or whether it's sampled from the posterior marginal over actions - alpha: float, default 16.0 - Action selection precision -- the inverse temperature of the softmax that is used to scale the - action marginals before sampling. This is only used if ``action_selection`` argument is "stochastic" - + Returns ---------- - selected_policy: 1D ``numpy.ndarray`` - Vector containing the indices of the actions for each control factor + selected_policy: ``list`` of ``jax.numpy.ndarrays`` + List of arrays corresponding to marginal probability of each action possible action """ - num_factors = len(num_controls) # weight each action according to its integrated posterior probability over policies and timesteps @@ -61,6 +53,38 @@ def sample_action(q_pi, policies, num_controls, action_selection="deterministic" actions = jnp.arange(num_controls[factor_i])[:, None] marginal.append(jnp.where(actions==policies[:, 0, factor_i], q_pi, 0).sum(-1)) + return marginal + + +def sample_action(q_pi, policies, num_controls, action_selection="deterministic", alpha=16.0, rng_key=None): + """ + Samples an action from posterior marginals, one action per control factor. + + Parameters + ---------- + q_pi: 1D ``numpy.ndarray`` + Posterior beliefs over policies, i.e. a vector containing one posterior probability per policy. + policies: ``list`` of 2D ``numpy.ndarray`` + ``list`` that stores each policy as a 2D array in ``policies[p_idx]``. Shape of ``policies[p_idx]`` + is ``(num_timesteps, num_factors)`` where ``num_timesteps`` is the temporal + depth of the policy and ``num_factors`` is the number of control factors. + num_controls: ``list`` of ``int`` + ``list`` of the dimensionalities of each control state factor. + action_selection: string, default "deterministic" + String indicating whether whether the selected action is chosen as the maximum of the posterior over actions, + or whether it's sampled from the posterior marginal over actions + alpha: float, default 16.0 + Action selection precision -- the inverse temperature of the softmax that is used to scale the + action marginals before sampling. This is only used if ``action_selection`` argument is "stochastic" + + Returns + ---------- + selected_policy: 1D ``numpy.ndarray`` + Vector containing the indices of the actions for each control factor + """ + + marginal = get_marginals(q_pi, policies, num_controls) + if action_selection == 'deterministic': selected_policy = jtu.tree_map(lambda x: jnp.argmax(x, -1), marginal) elif action_selection == 'stochastic': diff --git a/pymdp/jax/likelihoods.py b/pymdp/jax/likelihoods.py index 6a084779..3f44a152 100644 --- a/pymdp/jax/likelihoods.py +++ b/pymdp/jax/likelihoods.py @@ -7,31 +7,24 @@ def evolve_trials(agent, data): def step_fn(carry, xs): - outcome = xs['outcomes'] - qx = agent.infer_states(outcome) - q_pi, _ = agent.infer_policies() - - nc = agent.num_controls - num_factors = len(agent.num_controls) - - marginal = [] - for factor_i in range(num_factors): - m = [] - actions = agent.policies[:, 0, factor_i] - for a in range(nc[factor_i]): - m.append( jnp.where(actions==a, q_pi, 0).sum() ) - marginal.append(jnp.stack(m)) - - action = xs['actions'] - agent.update_empirical_prior(action) + empirical_prior = carry + outcomes = xs['outcomes'] + qs = agent.infer_states(outcomes, empirical_prior) + q_pi, _ = agent.infer_policies(qs) + + probs = agent.action_probabilities(q_pi) + + actions = xs['actions'] + empirical_prior = agent.update_empirical_prior(actions, qs) #TODO: if outcomes and actions are None, generate samples - return None, (marginal, outcome, action) + return empirical_prior, (probs, outcomes, actions) - _, res = lax.scan(step_fn, None, data) + prior = agent.D + _, res = lax.scan(step_fn, prior, data) - return res[0], res[1], res[2] + return res -def aif_likelihood(Na, Nb, Nt, data, agent): +def aif_likelihood(Nb, Nt, Na, data, agent): # Na -> batch dimension - number of different subjects/agents # Nb -> number of experimental blocks # Nt -> number of trials within each block @@ -39,14 +32,11 @@ def aif_likelihood(Na, Nb, Nt, data, agent): def step_fn(carry, xs): probs, outcomes, actions = evolve_trials(agent, xs) - probs = 0.5*jnp.ones((2, 2)) - print(probs.shape) - - # deterministic('outcomes', outcomes) + deterministic('outcomes', outcomes) with plate('num_agents', Na): with plate('num_trials', Nt): - sample('actions', dist.Categorical(probs=probs).to_event(1)) + sample('actions', dist.Categorical(logits=probs).to_event(1), obs=actions) return None, None From 5ce6f37d12e2e6f5eba88a177fd0c402ff025931 Mon Sep 17 00:00:00 2001 From: Dimitrije Markovic <5038100+dimarkov@users.noreply.github.com> Date: Tue, 15 Nov 2022 13:45:00 +0100 Subject: [PATCH 025/232] a working model inversion example --- examples/model_inversion.ipynb | 215 +++++++++++++++++---------------- 1 file changed, 110 insertions(+), 105 deletions(-) diff --git a/examples/model_inversion.ipynb b/examples/model_inversion.ipynb index b8e0bc0b..1d19efbb 100644 --- a/examples/model_inversion.ipynb +++ b/examples/model_inversion.ipynb @@ -147,7 +147,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -169,7 +169,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -191,7 +191,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -238,7 +238,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -278,7 +278,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -298,7 +298,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAesAAAGkCAYAAAAR/Q0YAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAwFElEQVR4nO3deXgUZbr38V8nkE5CICzZADlEwZmArBMgBmTTjDkQQVQwkEEgB3cQNK/D4kIQlXYDM8NiAA8uDNGwKTOCKCLxHBUHBXFEBUW2I5qQgCwG6GBS7x9e6aFJBzqxA1XW93NddSlPanmqn07uvu+nqtphGIYhAABgWkEXuwMAAODcCNYAAJgcwRoAAJMjWAMAYHIEawAATI5gDQCAyRGsAQAwOYI1AAAmR7AGAMDkCNY+vPjii3I4HNq7d+951y0oKJDD4VBBQUGd9+ts/fr1U79+/Tz/3rt3rxwOh1588UVP25gxYxQRERGQ4/na//Tp0+VwOLzWczgcGj9+fECOGQg1GaOPP/5YPXv2VIMGDeRwOLRt27Y67x/qnq/3bk23feaZZwLfMcBPdR6sHQ6HX8vFCHY1MX/+/Fr9osM6Tp8+rWHDhunw4cN69tlntWTJErVu3brOjlf5IWLv3r2egHDm70HlB6GgoCD93//9X5Xtjx07prCwMNN9ODpbXl6ecnJyAr7ffv36ef0NCQsLU6dOnZSTk6OKioqAH88fa9eu1fTp02u1bY8ePeRwOPTcc88FtlN+mD59uuLj4yX9O1mBudSr6wMsWbLE698vv/yy1q9fX6W9Xbt2dd0Vv91yyy0aPny4nE6np23+/PmKiorSmDFjvNbt06ePTp48qZCQkAvcy6pat26tkydPqn79+hfsmA899JCmTJlywY5Xl7799lvt27dPixYt0q233nqxu+PhdDr1yiuvaNKkSV7tq1atukg9qpm8vDxt375d9957b8D3fckll8jlckmSSkpKlJeXp/vuu0/FxcV6/PHHPetdqN+NtWvXat68eTUO2N98840+/vhjxcfHa+nSpbrrrrvqpoOwrDoP1iNHjvT690cffaT169dXaT/biRMnFB4eXpddq1ZwcLCCg4P9WjcoKEihoaF13CP/OByOC96XevXqqV69On8bXRAHDx6UJDVu3Dhg+ywtLVWDBg1+1T4GDhzoM1jn5eUpLS1NK1eu/FX7t7LIyEivvyV33nmnEhISNGfOHM2YMcPze3wxfjdq4m9/+5tiYmI0a9YsDR06VHv37vVkuucSiPcXrMEUc9b9+vVThw4dtGXLFvXp00fh4eF64IEHJEmrV69WWlqaWrRoIafTqTZt2ujRRx9VeXm5z318+eWX6t+/v8LDw9WyZUs99dRTVY43Z84cXXHFFQoPD1eTJk3UrVs35eXleX5+9px1fHy8vvjiC7333nueklvlXHF186HLly9XYmKiwsLCFBUVpZEjR+rAgQNe61TOJx84cEBDhgxRRESEoqOjdf/991c5P3/4Oy+3bds2RUdHq1+/fvrpp58kSQcOHNB//dd/KTY2Vk6nU1dccYUWL1583mP6mrOu9Prrr6tDhw6e/a1bt67KOp9++qkGDBigRo0aKSIiQtdcc40++uijKuvt3r1bw4YNU9OmTRUeHq4rr7xSa9asqbLed999pyFDhqhBgwaKiYnRfffdJ7fbfd7zGDNmjPr27StJGjZsmNcYS9K7776r3r17q0GDBmrcuLGuv/56ffXVVz5fiy+//FIZGRlq0qSJrrrqqvMe+3wyMjK0bds27dixw9NWWFiod999VxkZGT63OXjwoMaOHavY2FiFhoaqc+fOeumllzw/P336tJo2barMzMwq2x47dkyhoaG6//77PW1ut1vZ2dlq27atnE6nWrVqpUmTJp33te3Xr5/WrFmjffv2eX53zgxC5+tnTYWGhqp79+46fvy458OXVP3vxvLly9W+fXuFhoaqQ4cOeu211zRmzJhqA+XChQvVpk0bOZ1Ode/eXR9//LHnZ2PGjNG8efMkeU//+SMvL09Dhw7Vddddp8jISK+/R5XO9f6Kj4/Xddddp4KCAnXr1k1hYWHq2LGj5+/SqlWr1LFjR4WGhioxMVGffvqpX/2CeZgmJTp06JAGDBig4cOHa+TIkYqNjZX0S+CMiIhQVlaWIiIi9O6772ratGk6duyYnn76aa99/Pjjj/rP//xP3Xjjjbr55pu1YsUKTZ48WR07dtSAAQMkSYsWLdKECRM0dOhQTZw4UadOndK//vUv/fOf/6z2D19OTo7uueceRURE6MEHH5QkT/98efHFF5WZmanu3bvL5XKpqKhIf/nLX/TBBx/o008/9crcysvLlZqaqqSkJD3zzDN65513NGvWLLVp06ZOSmEff/yxUlNT1a1bN61evVphYWEqKirSlVde6Zn7jI6O1ptvvqmxY8fq2LFjtSpfvv/++1q1apXuvvtuNWzYUH/961910003af/+/WrWrJkk6YsvvlDv3r3VqFEjTZo0SfXr19eCBQvUr18/vffee0pKSpIkFRUVqWfPnjpx4oQmTJigZs2a6aWXXtLgwYO1YsUK3XDDDZKkkydP6pprrtH+/fs1YcIEtWjRQkuWLNG777573v7ecccdatmypWbOnKkJEyaoe/funjF+5513NGDAAF122WWaPn26Tp48qTlz5qhXr17aunVrlT/sw4YN0+WXX66ZM2cqEN9A26dPH11yySXKy8vTjBkzJEn5+fmKiIhQWlpalfVPnjypfv36adeuXRo/frwuvfRSLV++XGPGjNGRI0c0ceJE1a9fXzfccINWrVqlBQsWeE3jvP7663K73Ro+fLgkqaKiQoMHD9b777+v22+/Xe3atdPnn3+uZ599Vl9//bVef/31avv+4IMP6ujRo/ruu+/07LPPSpLngkd/+lkblYH5fBWSNWvWKD09XR07dpTL5dKPP/6osWPHqmXLlj7Xz8vL0/Hjx3XHHXfI4XDoqaee0o033qjdu3erfv36uuOOO/T999/7nOY7l3/+85/atWuXXnjhBYWEhOjGG2/U0qVLPQnL2ap7f+3atUsZGRm64447NHLkSD3zzDMaNGiQcnNz9cADD+juu++WJLlcLt18883auXOngoJMka/BH8YFNm7cOOPsw/bt29eQZOTm5lZZ/8SJE1Xa7rjjDiM8PNw4depUlX28/PLLnja3223ExcUZN910k6ft+uuvN6644opz9vGFF14wJBl79uzxtF1xxRVG3759q6y7ceNGQ5KxceNGwzAMo6yszIiJiTE6dOhgnDx50rPeG2+8YUgypk2b5mkbPXq0IcmYMWOG1z67du1qJCYmnrOPled8Zp/27NljSDJeeOEFr2M0aNDAMAzDeP/9941GjRoZaWlpXq/d2LFjjebNmxslJSVe+x8+fLgRGRnpGQNf+8/Ozq4ynpKMkJAQY9euXZ62zz77zJBkzJkzx9M2ZMgQIyQkxPj22289bd9//73RsGFDo0+fPp62e++915Bk/O///q+n7fjx48all15qxMfHG+Xl5YZhGEZOTo4hyVi2bJlnvdLSUqNt27ZeY1SdyrFcvny5V3uXLl2MmJgY49ChQ17nExQUZIwaNarKazFixIhzHsdflfsrLi427r//fqNt27aen3Xv3t3IzMw0DOOX13vcuHGen1W+Dn/72988bWVlZUZycrIRERFhHDt2zDAMw3jrrbcMScY//vEPr+MOHDjQuOyyyzz/XrJkiREUFOT1+huGYeTm5hqSjA8++OCc55GWlma0bt26Sru//axO3759jYSEBKO4uNgoLi42duzYYfz5z382JBlpaWle6/p673bs2NG45JJLjOPHj3vaCgoKDEle/a3ctlmzZsbhw4c97atXr67y+vn6+3Y+48ePN1q1amVUVFQYhmEYb7/9tiHJ+PTTT73WO9f7q3Xr1oYk48MPP/S0VY5vWFiYsW/fPk/7ggUL/Pp9gLmY5mOV0+n0WZILCwvz/P/x48dVUlKi3r1768SJE15lQemXT+xnzl+FhISoR48e2r17t6etcePG+u6777zKV4H0ySef6ODBg7r77ru95sjS0tKUkJDgs3R75513ev27d+/eXn0OhI0bNyo1NVXXXHONVq1a5bl4zjAMrVy5UoMGDZJhGCopKfEsqampOnr0qLZu3Vrj46WkpKhNmzaef3fq1EmNGjXynFd5ebnefvttDRkyRJdddplnvebNmysjI0Pvv/++jh07JumXi3Z69OjhVVKOiIjQ7bffrr179+rLL7/0rNe8eXMNHTrUs154eLhuv/32Gve/0g8//KBt27ZpzJgxatq0qdf5/PGPf9TatWurbHP2eAZCRkaGdu3apY8//tjz3+oqQWvXrlVcXJxGjBjhaatfv74mTJign376Se+9954k6eqrr1ZUVJTy8/M96/34449av3690tPTPW3Lly9Xu3btlJCQ4PX+uPrqqyX98t6qDX/7eS47duxQdHS0oqOjlZCQoKefflqDBw8+71TQ999/r88//1yjRo3yurWxb9++6tixo89t0tPT1aRJE8+/e/fuLUm/6nf1559/Vn5+vtLT0z0l86uvvloxMTFaunSpz22qe3+1b99eycnJnn9XVqauvvpq/cd//EeV9kD/jUHdMk2wbtmypc8rqr/44gvdcMMNioyMVKNGjRQdHe0JyEePHvVa95JLLqkyR9SkSRP9+OOPnn9PnjxZERER6tGjhy6//HKNGzdOH3zwQcDOY9++fZKk3//+91V+lpCQ4Pl5pdDQUEVHR5+zz7/WqVOnlJaWpq5du2rZsmVer3NxcbGOHDmihQsXev7oVS6VH57OnPvz15l/HCqdeV7FxcU6ceKEz9epXbt2qqio8NyutG/fvmrXq/x55X/btm1b5T3ga1t/nWs827Vrp5KSEpWWlnq1X3rppbU+XnW6du2qhIQE5eXlaenSpYqLi/MES199vvzyy6uUOM9+verVq6ebbrpJq1ev9sw9r1q1SqdPn/YK1t98842++OKLKu+P3/3ud5Jq9/6oST/PJT4+XuvXr9dbb72l+fPnq2XLliouLj7vxWSV+27btm2Vn/lqk6q+pysD96/5XX377bdVXFysHj16aNeuXdq1a5f27Nmj/v3765VXXvF5C1p176+z+xcZGSlJatWqlc/2QP6NQd0zzZz1mRl0pSNHjqhv375q1KiRZsyYoTZt2ig0NFRbt27V5MmTq7yRq7uC2zhjXqddu3bauXOn3njjDa1bt04rV67U/PnzNW3aND3yyCOBPSk/+HvV+a/hdDo1cOBArV69WuvWrdN1113n+Vnlazhy5EiNHj3a5/adOnWq8TH9GYvfKl/v5UDIyMjQc889p4YNGyo9PT0g843Dhw/XggUL9Oabb2rIkCFatmyZEhIS1LlzZ886FRUV6tixo2bPnu1zH2cHgwupQYMGSklJ8fy7V69e+sMf/qAHHnhAf/3rXwN6rLp4T1dmzzfffLPPn7/33nvq37+/V1t176/q+mfn38XfEtMEa18KCgp06NAhrVq1Sn369PG079mz51ftt0GDBkpPT1d6errKysp044036vHHH9fUqVOr/UTu71WdlQ/R2LlzZ5XMZ+fOnXX6kI3qOBwOLV26VNdff72GDRumN99803Olc3R0tBo2bKjy8nKvP3p1LTo6WuHh4dq5c2eVn+3YsUNBQUGeINC6detq16v8eeV/t2/fLsMwvMbL17b+OnM8fR0/Kirqgt06k5GRoWnTpumHH3445wVMrVu31r/+9S9VVFR4BfSzXy/pl4vXmjdvrvz8fF111VV69913PRdRVmrTpo0+++wzXXPNNbV6WEZ129Skn/7q1KmTRo4cqQULFuj+++/3WeE5c9+7du2q8jNfbf6qyetTWlqq1atXKz093WvqptKECRO0dOnSKsEa9mSaMrgvlZ8Iz/wEWFZWpvnz59d6n4cOHfL6d0hIiNq3by/DMHT69Olqt2vQoIGOHDly3v1369ZNMTExys3N9bqt5c0339RXX33l8+rdCyEkJESrVq1S9+7dNWjQIG3evFnSL6/xTTfdpJUrV2r79u1VtisuLq6T/gQHB+vaa6/V6tWrvR7rWlRUpLy8PF111VVq1KiRpF/uM968ebM2bdrkWa+0tFQLFy5UfHy82rdv71nv+++/14oVKzzrnThxQgsXLqx1P5s3b64uXbropZde8hr/7du36+2339bAgQNrve+aatOmjXJycuRyudSjR49q1xs4cKAKCwu95qJ//vlnzZkzRxEREZ5b1KRfnhMwdOhQ/eMf/9CSJUv0888/e5XApV+yvgMHDmjRokVVjnXy5Mkq0wBna9CgQZUpq5r2syYmTZqk06dPV1sJkKQWLVqoQ4cOevnllz23L0q/ZLKff/55rY4ryfPBzZ+/Fa+99ppKS0s1btw4DR06tMpy3XXXaeXKlX7deojfPlNn1j179lSTJk00evRoTZgwQQ6HQ0uWLPlV5Ztrr71WcXFx6tWrl2JjY/XVV19p7ty5SktLU8OGDavdLjExUc8995wee+wxtW3bVjExMT7nDOvXr68nn3xSmZmZ6tu3r0aMGOG5dSs+Pl733Xdfrfv+a4WFhemNN97Q1VdfrQEDBui9995Thw4d9MQTT2jjxo1KSkrSbbfdpvbt2+vw4cPaunWr3nnnHR0+fLhO+vPYY49p/fr1uuqqq3T33XerXr16WrBggdxut9f98VOmTNErr7yiAQMGaMKECWratKleeukl7dmzRytXrvRkZbfddpvmzp2rUaNGacuWLWrevLmWLFnyqx+u8/TTT2vAgAFKTk7W2LFjPbduRUZG1vrRkrXlz+1Mt99+uxYsWKAxY8Zoy5Ytio+P14oVK/TBBx8oJyenyvs8PT1dc+bMUXZ2tjp27FjlaYK33HKLli1bpjvvvFMbN25Ur169VF5erh07dmjZsmV666231K1bt2r7k5iYqPz8fGVlZal79+6KiIjQoEGDatxPf7Vv314DBw7U888/r4cffthzq+DZZs6cqeuvv169evVSZmamfvzxR82dO1cdOnTwCuA1kZiYKOmXrDg1NVXBwcGeW+DOtnTpUjVr1kw9e/b0+fPBgwdr0aJFWrNmjW688cZa9Qe/IRf68vPqbt2q7naqDz74wLjyyiuNsLAwo0WLFsakSZM8tySceetBdfsYPXq0120YCxYsMPr06WM0a9bMcDqdRps2bYw///nPxtGjRz3r+Lp1q7Cw0EhLSzMaNmxoSPLcMnX2rVuV8vPzja5duxpOp9No2rSp8ac//cn47rvvqvSt8raqM/m6HcqXmt66VamkpMRo3769ERcXZ3zzzTeGYRhGUVGRMW7cOKNVq1ZG/fr1jbi4OOOaa64xFi5ceM79V3fr1pm3ElVq3bq1MXr0aK+2rVu3GqmpqUZERIQRHh5u9O/f3+v2k0rffvutMXToUKNx48ZGaGio0aNHD+ONN96ost6+ffuMwYMHG+Hh4UZUVJQxceJEY926db/q1i3DMIx33nnH6NWrlxEWFmY0atTIGDRokPHll196rXPmrVaB4O/+fL3eRUVFRmZmphEVFWWEhIQYHTt29Bq3M1VUVBitWrUyJBmPPfaYz3XKysqMJ5980rjiiisMp9NpNGnSxEhMTDQeeeQRr98dX3766ScjIyPDaNy4cZXbomrSz7Od6+9G5S1Y2dnZhmH4fu8ahmG8+uqrRkJCguF0Oo0OHToYf//7342bbrrJSEhI8KxTue3TTz9d5ThnHsMwDOPnn3827rnnHiM6OtpwOBzV/h4XFRUZ9erVM2655ZZqz+/EiRNGeHi4ccMNNxiGce73Q+vWravcrlbZv7PfG+c6H5iXwzC4ygAAKnXp0kXR0dFav379xe4K4GHqOWsAqCunT5/Wzz//7NVWUFCgzz77zOtRs4AZkFkDsKW9e/cqJSVFI0eOVIsWLbRjxw7l5uYqMjJS27dvr3auG7gYTH2BGQDUlSZNmigxMVHPP/+8iouL1aBBA6WlpemJJ54gUMN0KIMDsKXIyEjl5+fru+++k9vt1uHDh7V8+XKvx+QCZ/uf//kfDRo0SC1atJDD4TjnF9lUKigo0B/+8Ac5nU61bdv2vI/D9YVgDQCAn0pLS9W5c2fP16Gez549e5SWlqb+/ftr27Ztuvfee3XrrbfqrbfeqtFxmbMGAKAWHA6HXnvtNQ0ZMqTadSZPnqw1a9Z4PXRq+PDhOnLkiNatW+f3sXzOWbvd7ipPzXE6nZ5vagIA4LeiLmPepk2bqjzKOTU1Vffee2+N9uMzWLtcripfapGdnX3Bn9YEAEB1ptfiWfU+ZWfXWcwrLCxUbGysV1tsbKyOHTumkydP+v3FPz6D9dSpU5WVleXVRlYNADCTQF10NdkCMc9nsKbkDQCwi7qMeXFxcSoqKvJqKyoqUqNGjWr0dbq1u8/61KHzr4PAC/Vx7ydjcXEwFubCeJiHr7GoIwEqgtep5ORkrV271qtt/fr1Sk5OrtF+uHULAGBJQQFaauKnn37Stm3btG3bNkm/3Jq1bds27d+/X9Iv08ijRo3yrH/nnXdq9+7dmjRpknbs2KH58+dr2bJlNf4GRoI1AAB++uSTT9S1a1d17dpVkpSVlaWuXbtq2rRpkqQffvjBE7gl6dJLL9WaNWu0fv16de7cWbNmzdLzzz+v1NTUGh23dvdZU166OCj1mQdjYS6Mh3lcwDK4K0BXg0+1wONGeDY4AMCSrDBnHSiUwQEAMDkyawCAJdkp2yRYAwAsyU5lcII1AMCS7JRZ2+lcAQCwJDJrAIAl2SnbJFgDACzJTnPWdvpgAgCAJZFZAwAsyU7ZJsEaAGBJdgrWdjpXAAAsicwaAGBJdrrAjGANALAkO5WG7XSuAABYEpk1AMCSKIMDAGBydioNE6wBAJZkp2Btp3MFAMCSyKwBAJbEnDUAACZnp9Kwnc4VAABLIrMGAFiSnbJNgjUAwJLsNGdtpw8mAABYEpk1AMCS7JRtEqwBAJZkp2Btp3MFAMCSyKwBAJZkpwvMCNYAAEuyU2mYYA0AsCQ7ZdZ2+mACAIAlkVkDACzJTtkmwRoAYEl2CtZ2OlcAACyJzBoAYEl2usCMYA0AsCQ7lYbtdK4AAFgSmTUAwJLslG0SrAEAlmSnOWs7fTABAMCSyKwBAJbkCLJPbk2wBgBYksNBsAYAwNSCbJRZM2cNAIDJkVkDACyJMjgAACZnpwvMKIMDAGByZNYAAEuiDA4AgMlRBgcAAKZBZg0AsCTK4AAAmBxlcAAAYBpk1gAAS6IMDgCAydnp2eAEawCAJdkps2bOGgAAkyOzBgBYkp2uBidYAwAsiTI4AAAwDTJrAIAlUQYHAMDkKIMDAIBqzZs3T/Hx8QoNDVVSUpI2b958zvVzcnL0+9//XmFhYWrVqpXuu+8+nTp1yu/jkVkDACzpYpXB8/PzlZWVpdzcXCUlJSknJ0epqanauXOnYmJiqqyfl5enKVOmaPHixerZs6e+/vprjRkzRg6HQ7Nnz/brmGTWAABLcjgcAVlqavbs2brtttuUmZmp9u3bKzc3V+Hh4Vq8eLHP9T/88EP16tVLGRkZio+P17XXXqsRI0acNxs/E8EaAGBrbrdbx44d81rcbrfPdcvKyrRlyxalpKR42oKCgpSSkqJNmzb53KZnz57asmWLJzjv3r1ba9eu1cCBA/3uI8EaAGBJQUGOgCwul0uRkZFei8vl8nnMkpISlZeXKzY21qs9NjZWhYWFPrfJyMjQjBkzdNVVV6l+/fpq06aN+vXrpwceeMD/c/X/ZQEAwDwCVQafOnWqjh496rVMnTo1YP0sKCjQzJkzNX/+fG3dulWrVq3SmjVr9Oijj/q9Dy4wAwBYUqAuMHM6nXI6nX6tGxUVpeDgYBUVFXm1FxUVKS4uzuc2Dz/8sG655RbdeuutkqSOHTuqtLRUt99+ux588EEFBZ0/byazBgDATyEhIUpMTNSGDRs8bRUVFdqwYYOSk5N9bnPixIkqATk4OFiSZBiGX8clswYAWNLFeihKVlaWRo8erW7duqlHjx7KyclRaWmpMjMzJUmjRo1Sy5YtPfPegwYN0uzZs9W1a1clJSVp165devjhhzVo0CBP0D4fgjUAwJIcF6k2nJ6eruLiYk2bNk2FhYXq0qWL1q1b57nobP/+/V6Z9EMPPSSHw6GHHnpIBw4cUHR0tAYNGqTHH3/c72M6DH9z8DOdOlTjTRAAoc2qtjEWFwdjYS6Mh3n4Gos6srVt7PlX8sMfdhWdf6WLjMwaAGBJdno2OMEaAGBJdvrWLa4GBwDA5MisAQCWFEQZHAAAc6MMDgAATIPMGgBgSVwNDgCAydmpDE6wBgBYEpn1+VzAJ9TgPBgL82AszIXxwG+Iz2Dtdrvldru92mryFWIAANQ1O5XBfV4N7nK5FBkZ6bVUfnsIAABm4HA4ArJYgc8v8iCzBgCY3Y6u8QHZT8KnewOyn7rkswxOYAYAmJ0jyD6PCqnVBWbTLVI2+K2Z7uPbTBmLi4OxMBfGwzx8jUVdsf2cNQAAMA/uswYAWJONqicEawCAJVEGBwAApkFmDQCwJK4GBwDA5KzyQJNAIFgDAKyJOWsAAGAWZNYAAEtizhoAAJOz05y1fT6WAABgUWTWAABLstNDUQjWAABrslGwpgwOAIDJkVkDACzJ4bBPvkmwBgBYkp3mrO3zsQQAAIsiswYAWJKdMmuCNQDAmpizBgDA3OyUWdvnYwkAABZFZg0AsCQ7ZdYEawCAJfFFHgAAwDTIrAEA1sT3WQMAYG52mrO2z8cSAAAsiswaAGBJdrrAjGANALAkh43mrO1zpgAAWBSZNQDAkux0gRnBGgBgTcxZAwBgbnbKrJmzBgDA5MisAQCWZKerwQnWAABLstN91vb5WAIAgEWRWQMArMlGF5gRrAEAlmSnOWv7nCkAABZFZg0AsCQ7XWBGsAYAWBIPRQEAAKZBZg0AsCbK4AAAmJudyuAEawCANdknVjNnDQCA2ZFZAwCsyUZz1mTWAABLcjgCs9TGvHnzFB8fr9DQUCUlJWnz5s3nXP/IkSMaN26cmjdvLqfTqd/97ndau3at38cjswYAoAby8/OVlZWl3NxcJSUlKScnR6mpqdq5c6diYmKqrF9WVqY//vGPiomJ0YoVK9SyZUvt27dPjRs39vuYBGsAgDVdpKvBZ8+erdtuu02ZmZmSpNzcXK1Zs0aLFy/WlClTqqy/ePFiHT58WB9++KHq168vSYqPj6/RMSmDAwAsKVBlcLfbrWPHjnktbrfb5zHLysq0ZcsWpaSkeNqCgoKUkpKiTZs2+dzm73//u5KTkzVu3DjFxsaqQ4cOmjlzpsrLy/0+V4I1AMDWXC6XIiMjvRaXy+Vz3ZKSEpWXlys2NtarPTY2VoWFhT632b17t1asWKHy8nKtXbtWDz/8sGbNmqXHHnvM7z5SBgcAWFOArgafOnWqsrKyvNqcTmdA9i1JFRUViomJ0cKFCxUcHKzExEQdOHBATz/9tLKzs/3aB8EaAGBNAaoNO51Ov4NzVFSUgoODVVRU5NVeVFSkuLg4n9s0b95c9evXV3BwsKetXbt2KiwsVFlZmUJCQs57XMrgAABLcjgcAVlqIiQkRImJidqwYYOnraKiQhs2bFBycrLPbXr16qVdu3apoqLC0/b111+refPmfgVqiWANAECNZGVladGiRXrppZf01Vdf6a677lJpaann6vBRo0Zp6tSpnvXvuusuHT58WBMnTtTXX3+tNWvWaObMmRo3bpzfx6QMDgCwpov0BLP09HQVFxdr2rRpKiwsVJcuXbRu3TrPRWf79+9XUNC/c+FWrVrprbfe0n333adOnTqpZcuWmjhxoiZPnuz3MQnWAABLuphPGx0/frzGjx/v82cFBQVV2pKTk/XRRx/V+niUwQEAMDkyawCANfF91gAAmJx9YjVlcAAAzI7MGgBgSTW9R9rKCNYAAGuyT6ymDA4AgNmRWQMALMnB1eAAAJicfWI1wRoAYFE2usCMOWsAAEyOzBoAYEk2SqwJ1gAAi7LRBWaUwQEAMDkyawCAJVEGBwDA7GwUrSmDAwBgcmTWAABLslFiTbAGAFgUV4MDAACzILMGAFiTjergBGsAgCXZKFYTrAEAFmWjaM2cNQAAJkdmDQCwJIeN0k2CNQDAmiiDAwAAsyCzBgBYk30SazkMwzAudicAAKip8lkZAdlP8P/LC8h+6pLPzNrtdsvtdnu1OZ1OOZ3OC9IpAADwbz7nrF0ulyIjI70Wl8t1ofsGAED1ghyBWSzAZxmczBoAYHblOSMDsp/ge/8WkP3UJZ9lcAIzAADmUburwU8dCnA34JfQZlXbGIuLg7EwF8bDPHyNRV2xSAk7ELh1CwBgTTZ6hBnBGgBgTTzBDAAAmAWZNQDAmpizBgDA5Gw0Z22fMwUAwKLIrAEA1kQZHAAAk+NqcAAAYBZk1gAAawqyT75JsAYAWBNlcAAAYBZk1gAAa6IMDgCAydmoDE6wBgBYk42CtX1qCAAAWBSZNQDAmpizBgDA5CiDAwAAsyCzBgBYkoMv8gAAwOT4PmsAAGAWZNYAAGuiDA4AgMlxNTgAADALMmsAgDXxUBQAAEzORmVwgjUAwJpsFKztU0MAAMCiCNYAAGsKCgrMUgvz5s1TfHy8QkNDlZSUpM2bN/u13auvviqHw6EhQ4bU6HgEawCANTkcgVlqKD8/X1lZWcrOztbWrVvVuXNnpaam6uDBg+fcbu/evbr//vvVu3fvGh+TYA0AQA3Mnj1bt912mzIzM9W+fXvl5uYqPDxcixcvrnab8vJy/elPf9Ijjzyiyy67rMbHJFgDAKwpyBGQxe1269ixY16L2+32eciysjJt2bJFKSkp/+5GUJBSUlK0adOmars6Y8YMxcTEaOzYsbU71VptBQDAxeYICsjicrkUGRnptbhcLp+HLCkpUXl5uWJjY73aY2NjVVhY6HOb999/X//93/+tRYsW1fpUuXULAGBrU6dOVVZWlleb0+kMyL6PHz+uW265RYsWLVJUVFSt90OwBgBYU4C+yMPpdPodnKOiohQcHKyioiKv9qKiIsXFxVVZ/9tvv9XevXs1aNAgT1tFRYUkqV69etq5c6fatGlz3uNSBgcAWNNFuBo8JCREiYmJ2rBhg6etoqJCGzZsUHJycpX1ExIS9Pnnn2vbtm2eZfDgwerfv7+2bdumVq1a+XVcMmsAAGogKytLo0ePVrdu3dSjRw/l5OSotLRUmZmZkqRRo0apZcuWcrlcCg0NVYcOHby2b9y4sSRVaT8XgjUAwJou0hd5pKenq7i4WNOmTVNhYaG6dOmidevWeS46279/v4IC3DeHYRhGjbc6dSignYCfQptVbWMsLg7GwlwYD/PwNRZ1pOLtRwOyn6BrHw7IfuoSmTUAwJr4Ig8AAGAWZNYAAGty2CffJFgDAKzJPlVwyuAAAJgdmTUAwJpsdIEZwRoAYE02CtaUwQEAMDkyawCANdkosyZYAwAsyj7BmjI4AAAmR2YNALAm+yTWBGsAgEUxZw0AgMnZKFgzZw0AgMmRWQMArMlGmTXBGgBgUfYJ1pTBAQAwOTJrAIA12SexJlgDACzKRnPWlMEBADA5MmsAgDXZKLMmWAMALMo+wZoyOAAAJkdmDQCwJsrgAACYHMEaAACTs0+sZs4aAACzI7MGAFgTZXAAAMzOPsGaMjgAACZHZg0AsCbK4AAAmJyNgjVlcAAATI7MGgBgTfZJrAnWAACLogwOAADMgswaAGBR9smsCdYAAGuyURmcYA0AsCYbBWvmrAEAMDkyawCANZFZAwAAsyBYAwBgcpTBAQDWZKMyOMEaAGBNBOvzCG0W4G6g1hgL82AszIXxwG+Iz2Dtdrvldru92pxOp5xO5wXpFAAA52WjzNrnBWYul0uRkZFei8vlutB9AwDgHBwBWszPYRiGcXYjmTUAwOwqvngxIPsJumJMQPZTl3yWwQnMAADTs1EZvHYXmJ06FOBuwC++LphhLC4OxsJcGA/zuJAX9jns86gQbt0CAFiUfTJr+3wsAQDAosisAQDWxJw1AAAmZ6M5a/ucKQAAFkVmDQCwKMrgAACYm43mrCmDAwBgcmTWAACLsk++SbAGAFgTZXAAAGAWBGsAgDU5HIFZamHevHmKj49XaGiokpKStHnz5mrXXbRokXr37q0mTZqoSZMmSklJOef6vhCsAQAWdXG+zzo/P19ZWVnKzs7W1q1b1blzZ6WmpurgwYM+1y8oKNCIESO0ceNGbdq0Sa1atdK1116rAwcO+H+mvr7P+rz4NpuLg28WMg/GwlwYD/O4gN+6VfHt6wHZT1CbITVaPykpSd27d9fcuXN/6UdFhVq1aqV77rlHU6ZMOe/25eXlatKkiebOnatRo0b518ca9RAAgN8Yt9utY8eOeS1ut9vnumVlZdqyZYtSUlI8bUFBQUpJSdGmTZv8Ot6JEyd0+vRpNW3a1O8+EqwBANYUoDlrl8ulyMhIr8Xlcvk8ZElJicrLyxUbG+vVHhsbq8LCQr+6PXnyZLVo0cIr4J8Pt24BACwqMLduTZ06VVlZWV5tTqczIPs+2xNPPKFXX31VBQUFCg0N9Xs7gjUAwNacTqffwTkqKkrBwcEqKiryai8qKlJcXNw5t33mmWf0xBNP6J133lGnTp1q1EfK4AAAa3IEBWapgZCQECUmJmrDhg2etoqKCm3YsEHJycnVbvfUU0/p0Ucf1bp169StW7canyqZNQDAkhwX6QlmWVlZGj16tLp166YePXooJydHpaWlyszMlCSNGjVKLVu29Mx7P/nkk5o2bZry8vIUHx/vmduOiIhQRESEX8ckWAMAUAPp6ekqLi7WtGnTVFhYqC5dumjdunWei87279+voKB/Z+zPPfecysrKNHToUK/9ZGdna/r06X4dk/usrYR7Sc2DsTAXxsM8LuB91sbetQHZjyN+YED2U5fIrAEA1lTD+WYrs8+ZAgBgUWTWAACLss9XZBKsAQDWZKPvsyZYAwCsiTlrAABgFmTWAACLogwOAIC52WjOmjI4AAAmR2YNALAmG11gRrAGAFgUZXAAAGASZNYAAGuy0QVmBGsAgEXZpzhsnzMFAMCiyKwBANZEGRwAAJMjWAMAYHb2mcm1z5kCAGBRZNYAAGuiDA4AgNnZJ1hTBgcAwOTIrAEA1kQZHAAAs7NPsKYMDgCAyZFZAwCsiTI4AABmZ5/isH3OFAAAiyKzBgBYE2VwAADMjmANAIC52SizZs4aAACTI7MGAFiUfTJrgjUAwJoogwMAALMgswYAWJR9MmuCNQDAmiiDAwAAsyCzBgBYlH3yTYI1AMCaKIMDAACzILMGAFiUfTJrgjUAwKII1gAAmJqDOWsAAGAWZNYAAIuyT2ZNsAYAWBNlcAAAYBZk1gAAi7JPZk2wBgBYk8M+xWH7nCkAABZFZg0AsCjK4AAAmBtXgwMAALMgswYAWJR9MmuCNQDAmmxUBidYAwAsyj7BmjlrAABMjswaAGBNlMEBADA7+wRryuAAAJgcmTUAwJp4NjgAAGbnCNBSc/PmzVN8fLxCQ0OVlJSkzZs3n3P95cuXKyEhQaGhoerYsaPWrl1bo+MRrAEAqIH8/HxlZWUpOztbW7duVefOnZWamqqDBw/6XP/DDz/UiBEjNHbsWH366acaMmSIhgwZou3bt/t9TIdhGEaNe3rqUI03QQCENqvaxlhcHIyFuTAe5uFrLOrKqZLA7Cc0qkarJyUlqXv37po7d64kqaKiQq1atdI999yjKVOmVFk/PT1dpaWleuONNzxtV155pbp06aLc3Fy/jlm7OesLORg4N8bCPBgLc2E8bODCXw1eVlamLVu2aOrUqZ62oKAgpaSkaNOmTT632bRpk7KysrzaUlNT9frrr/t9XC4wAwDYmtvtltvt9mpzOp1yOp1V1i0pKVF5ebliY2O92mNjY7Vjxw6f+y8sLPS5fmFhod999GvO2u12a/r06VVOBhceY2EejIW5MB42FNosIIvL5VJkZKTX4nK5LvbZefE7WD/yyCP8EpgAY2EejIW5MB6oralTp+ro0aNey5ll7jNFRUUpODhYRUVFXu1FRUWKi4vzuU1cXFyN1veFq8EBALbmdDrVqFEjr8VXCVySQkJClJiYqA0bNnjaKioqtGHDBiUnJ/vcJjk52Wt9SVq/fn216/vCnDUAADWQlZWl0aNHq1u3burRo4dycnJUWlqqzMxMSdKoUaPUsmVLTyl94sSJ6tu3r2bNmqW0tDS9+uqr+uSTT7Rw4UK/j0mwBgCgBtLT01VcXKxp06apsLBQXbp00bp16zwXke3fv19BQf8uXPfs2VN5eXl66KGH9MADD+jyyy/X66+/rg4dOvh9TL+CtdPpVHZ2drVlAVw4jIV5MBbmwnjgQho/frzGjx/v82cFBQVV2oYNG6Zhw4bV+ni1eygKAAC4YLjADAAAkyNYAwBgcgRrAABMjmANAIDJEawBADA5gjUAACZHsAYAwOQI1gAAmBzBGgAAkyNYAwBgcgRrAABM7v8DN+ThsHPUKaIAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -318,7 +318,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAesAAAGiCAYAAADHpO4FAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAs6UlEQVR4nO3deXRUZZrH8V8lkMoCBAgQ1g7RHm2GADahwQQZBSTKdsQBoaWbHY9RbE+IeDAyyqJtjUszdCsBHQmIHeioLCLk0MSFrcENEJVFhlZMK4lIVMCgBSTv/MFJNUVVQiVWyL19v59z7h95c+ve99ZbyVPP8763ymWMMQIAAJYV0dAdAAAANSNYAwBgcQRrAAAsjmANAIDFEawBALA4gjUAABZHsAYAwOII1gAAWBzBGgAAi2uwYO1yuULaNm/e3FBdDLB58+aAPhUWFmrOnDlB9+/cubMmTpx4Wfp2oWD9nDNnjlwul99+nTt31rBhw8JyzmXLlsnlcunIkSO+tokTJ6pz585++7lcLt1zzz1hOWc4BHuuqlNQUKCuXbsqJiZGLpdLH3zwQb3368iRIzpy5Ei14xkREaFPP/004PHl5eVq1qyZXC5Xg7wGQ7VixQotWLAg7MedOHGimjRpErbjBRv73NxcLVu2rNbHOnv2rNq2bSuXy6VXXnklbH0M1cSJE3XDDTdIOv86uvhvFNbUYMF6586dftuQIUMUExMT0N6zZ8+G6mKAnj17BvSpsLBQc+fODbr/mjVr9NBDD12u7tVo6tSp2rlz52U950MPPaQ1a9Zc1nPWl6+//lrjxo3TlVdeqY0bN2rnzp266qqrGrpbatKkiZYuXRrQ/vLLL+vs2bNq3LhxA/QqdPUVrMOpurGva7Bev369vvrqK0nSkiVLwtxb/Ktq1FAnvvbaa/1+bt26tSIiIgLaL3b69GnFxsbWZ9eq1axZs0v270K//OUv67E3tdOxY0d17Njxsp7zyiuvvKznq0+HDh3S2bNn9dvf/lbXX399WI4ZjtfymDFj9MILL2ju3LmKiPjne+8lS5bo1ltv1bp1635qNx0v3GO/ZMkSRUVF6frrr9emTZv0xRdfhPS32ZD/+9DwLD1nfcMNNyglJUVbt25Venq6YmNjNXnyZEnny1IZGRlq166dYmJi1KVLFz3wwAMqLy/3O0ZVOezw4cMaMmSImjRpok6dOum+++6T1+v123fRokXq0aOHmjRpoqZNm+oXv/iFHnzwQd/vLy6ZTpw4UQsXLpTkX9avKgUHK4MXFxfrt7/9rdq0aSO3260uXbroD3/4gyorK337VJU9n3rqKc2fP1/Jyclq0qSJ0tLS9Pbbb9fpuQxWBg8mNzdXjRo10uzZs31tr7/+ugYOHKhmzZopNjZWffv21RtvvHHJYwUrg1d58cUX1aVLF8XGxqpHjx5av359wD7bt2/XwIED1bRpU8XGxio9PV0bNmwI2O/jjz/WLbfcohYtWig6OlrXXHONXnjhhYD9Dh48qJtvvlmxsbFq1aqVMjMzderUqZCu47rrrpN0Pji6XC5fGVGS1q1bp7S0NMXGxqpp06YaNGhQQBWj6vnfvXu3Ro0apRYtWoTlzczkyZP1j3/8Q0VFRb62Q4cOafv27b6/lYtd6jV49uxZtWnTRuPGjQt47HfffaeYmBhlZ2f72k6ePKkZM2YoOTlZUVFR6tChg7KysgL+Fi92ww03aMOGDfr888/9/n6qfPPNN7r77rvVoUMHRUVF6YorrtCsWbMC/m5/iku9tqsb+86dO2vfvn3asmWLr9+hlJOPHj2qjRs3avjw4br//vtVWVkZNDuv+r/10UcfKSMjQ02bNtXAgQMl/XMqaenSpbr66qsVExOjXr166e2335YxRk8++aTvf8aAAQN0+PDhsDxXaGDGIiZMmGDi4uL82q6//nrTsmVL06lTJ/P000+bt956y2zZssUYY8wjjzxi/ud//sds2LDBbN682SxevNgkJyeb/v37Bxw3KirKdOnSxTz11FPm9ddfNw8//LBxuVxm7ty5vv1WrlxpJJnf/e53ZtOmTeb11183ixcvNvfee69vn7feestIMm+99ZYxxpjDhw+bUaNGGUlm586dvu3HH380xhiTlJRkJkyY4Hv8sWPHTIcOHUzr1q3N4sWLzcaNG80999xjJJm77rrLt99nn31mJJnOnTubm2++2axdu9asXbvWdOvWzbRo0cJ89913NT6XF/fTGGNmz55tLh7upKQkM3ToUGOMMZWVlea+++4zjRs3NkuXLvXt8+KLLxqXy2VGjBhhVq9ebV577TUzbNgwExkZaV5//XXffkuXLjWSzGeffeb33CclJfmds+q6evfubV566SVTWFhobrjhBtOoUSPz97//3bff5s2bTePGjU1qaqopKCgwa9euNRkZGcblcpm//OUvvv0OHjxomjZtaq688kqzfPlys2HDBnP77bcbSebxxx/37VdaWmratGljOnToYJYuXWoKCwvNb37zG/Ozn/0s4Lm62OHDh83ChQuNJPPYY4+ZnTt3mn379hljjMnPzzeSTEZGhlm7dq0pKCgwqampJioqymzbti3g+U9KSjIzZ840RUVFZu3atdWe81Kqjvf111+bfv36mdGjR/t+N3PmTNO5c2dTWVlp4uLi6vQanD59uomJiTEnTpzwO29ubq6RZD788ENjjDHl5eXmmmuuMa1atTLz5883r7/+uvnjH/9o4uPjzYABA0xlZWW117Bv3z7Tt29f07ZtW7+/H2OM+eGHH0z37t1NXFyceeqpp8ymTZvMQw89ZBo1amSGDBlyyecn2P+Ti4Xy2q5u7Hfv3m2uuOIK88tf/tLX7927d1+yX7///e+NJLNhwwZTWVlpkpKSTHJycsDzNGHCBNO4cWPTuXNn4/F4zBtvvGH++te/GmOM73WUnp5uVq9ebdasWWOuuuoq07JlSzN9+nRzyy23mPXr15v8/HyTmJhounfvXuM4wB4sH6wlmTfeeKPGx1ZWVpqzZ8+aLVu2GElm7969fseVZF566SW/xwwZMsRcffXVvp/vuece07x58xrPEywITps2LSAIVrk4WD/wwANGknnnnXf89rvrrruMy+Uyn3zyiTHmn8G6W7du5ty5c7793n33XSPJrFy5stb9rClYnz592owcOdLEx8f7BeDy8nLTsmVLM3z4cL/HVVRUmB49epjevXv72moTrBMTE83Jkyd9baWlpSYiIsJ4PB5f27XXXmvatGljTp065Ws7d+6cSUlJMR07dvT98/n1r39t3G63KS4u9jvP4MGDTWxsrO+NzcyZM43L5TIffPCB336DBg26ZLA25p/P6csvv+z3PLRv395069bNVFRU+NpPnTpl2rRpY9LT031tVc//ww8/XON5QnVhsF66dKlxu92mrKzMnDt3zrRr187MmTPHGGMCgnWor8EPP/zQSDLPPfec3369e/c2qampvp89Ho+JiIgw7733nt9+r7zyipFkCgsLa7yOoUOHBrxGjDFm8eLFQf9uH3/8cSPJbNq0qcbjXipY1+a1HWzsjTGma9eu5vrrr6+xHxeqrKw0P//5z02HDh18f9dV43jx/7iq/1t5eXkBx5Fk2rZta77//ntf29q1a40kc8011/gF5gULFvi9uYJ9WboMLkktWrTQgAEDAto//fRTjR07Vm3btlVkZKQaN27sm086cOCA374ul0vDhw/3a+vevbs+//xz38+9e/fWd999p9tvv12vvvqqjh8/HvZrefPNN/Xv//7v6t27t1/7xIkTZYzRm2++6dc+dOhQRUZG+vVZkl+/f6qysjINGDBA7777rq/sXGXHjh365ptvNGHCBJ07d863VVZW6uabb9Z77713yVJnMP3791fTpk19PycmJqpNmza+6yovL9c777yjUaNG+a3ojYyM1Lhx4/TFF1/ok08+kXT+OR04cKA6derkd46JEyfq9OnTvnL0W2+9pa5du6pHjx5++40dO7bW/a/yySef6OjRoxo3bpzffHGTJk00cuRIvf322zp9+rTfY0aOHFnn81XntttuU1RUlPLz81VYWKjS0tJqV4CH+hrs1q2bUlNT/RavHThwQO+++65feX39+vVKSUnRNddc4/cauemmm37S3Rxvvvmm4uLiNGrUqIB+SgppGqYm9fXarsmWLVt0+PBhTZgwwfd3PWnSJLlcLuXl5QV9THWvl/79+ysuLs73c5cuXSRJgwcP9ptKqGoP5/8MNIwGW2AWqnbt2gW0ff/99+rXr5+io6P16KOP6qqrrlJsbKz+8Y9/6D//8z/1ww8/+O0fGxur6Ohovza3260ff/zR9/O4ceN07tw5/e///q9GjhypyspK/epXv9Kjjz6qQYMGheVaysrKgs5rtW/f3vf7CyUkJAT0WVLA9f0Uhw4d0rfffqs77rhDKSkpfr+rWrF68T/MC33zzTd+/zRCcfF1Seevreq6vv32Wxljgo79xc9VWVlZyPslJycH7Ne2bdta9f1CVceu7vyVlZX69ttv/RYFBdv3p4qLi9OYMWOUl5enpKQk3XjjjUpKSqq2z6G+BidPnqxp06bp4MGD+sUvfqGlS5fK7Xbr9ttv9+3z1Vdf6fDhw9WuOq/rm96ysjLf7U0XatOmjRo1ahTwt1Jb9fXarknVyu9bb71V3333nSQpPj5e1113nVatWqVnnnlGzZs39+0fGxurZs2aBT1Wy5Yt/X6Oioqqsf3C/3WwJ8sH62CLot58800dPXpUmzdv9ludWfUHUFeTJk3SpEmTVF5erq1bt2r27NkaNmyYDh06VO0/v9pISEhQSUlJQPvRo0clSa1atfrJ56ittLQ03XbbbZoyZYqk84vsqrLEqv48/fTT1a6CT0xMDHufWrRooYiIiJCeq1Cf04SEBJWWlgbsF6wtVFVvOqo7f0REhFq0aOHXHsoiv7qYPHmynn/+eX344YfKz8+vdr/avAZvv/12ZWdna9myZfr973+vF198USNGjPC7platWikmJqbazLCur+mEhAS98847Msb4PWfHjh3TuXPnfvLfyuV+bZ84cUKrVq2SJP3qV78Kus+KFSt09913+36ur9cK7MnywTqYqhdxVaZZ5dlnnw3L8ePi4jR48GCdOXNGI0aM0L59+6oN1hdmuzExMTUed+DAgfJ4PNq9e7ffvdrLly+Xy+VS//79w9L/2powYYLi4uI0duxYlZeX64UXXlBkZKT69u2r5s2ba//+/Zf1g0zi4uLUp08frV69Wk899ZTvea2srNSf//xndezY0XeP88CBA7VmzRodPXrUlx1K55/T2NhY3z/i/v3764knntDevXv9SuErVqyocz+vvvpqdejQQStWrNCMGTN8r8vy8nKtWrXKt0L8ckhLS9PkyZN14sQJ3XrrrdXuV5vXYIsWLTRixAgtX75caWlpKi0tDVhhPmzYMD322GNKSEgIWrm4lAsrKhf386WXXtLatWv9rmf58uW+3/8U4XhtV9f3YFasWKEffvhBjzzyiG91+YVuu+025eXl+QVr4EK2DNbp6elq0aKFMjMzNXv2bDVu3Fj5+fnau3dvnY95xx13KCYmRn379lW7du1UWloqj8ej+Pj4at8JS+fn9iTp8ccf1+DBgxUZGanu3bv7yk8Xmj59upYvX66hQ4dq3rx5SkpK0oYNG5Sbm6u77rqrQT9kY9SoUYqNjdWoUaP0ww8/aOXKlWrSpImefvppTZgwQd98841GjRqlNm3a6Ouvv9bevXv19ddfa9GiRfXSH4/Ho0GDBql///6aMWOGoqKilJubq48//lgrV670BcbZs2dr/fr16t+/vx5++GG1bNlS+fn52rBhg5544gnFx8dLkrKyspSXl6ehQ4fq0UcfVWJiovLz83Xw4ME69zEiIkJPPPGEfvOb32jYsGG688475fV69eSTT+q7777Tf//3f4fluQhVKB+wUdvX4OTJk1VQUKB77rlHHTt21I033uj3+6ysLK1atUr/8R//oenTp6t79+6qrKxUcXGxNm3apPvuu099+vSptj/dunXT6tWrtWjRIqWmpioiIkK9evXS+PHjtXDhQk2YMEFHjhxRt27dtH37dj322GMaMmRIQD+CqaioCPoJYVVvxn/qa7tbt276y1/+ooKCAl1xxRWKjo72/T+42JIlS9SiRQvNmDEjYEpOksaPH6/58+cHvJkEfBp2fds/VbcavGvXrkH337Fjh0lLSzOxsbGmdevWZurUqWb37t1Gkt+tR9WtCr14dfQLL7xg+vfvbxITE01UVJRp3769GT16tN8qymCrrL1er5k6dapp3bq1cblcfiuiL14Nbowxn3/+uRk7dqxJSEgwjRs3NldffbV58skn/VYTV60Gf/LJJwP6LcnMnj076HNSUz8vdevWhY9t0qSJufnmm83p06eNMcZs2bLFDB061LRs2dI0btzYdOjQwQwdOtRvdWxtVoNPmzYtoM/Bnqtt27aZAQMGmLi4OBMTE2OuvfZa89prrwU89qOPPjLDhw838fHxJioqyvTo0cPvNVBl//79ZtCgQSY6Otq0bNnSTJkyxbz66qt1Xg1eZe3ataZPnz4mOjraxMXFmYEDB5q//e1vfvtcuHo7HEI93sWrwY0J7TVYpaKiwnTq1MlIMrNmzQp6ju+//97813/9l7n66qtNVFSUiY+PN926dTPTp083paWlNfbvm2++MaNGjTLNmzf3/f1UKSsrM5mZmaZdu3amUaNGJikpyeTk5PhujaxJ1WrqYNuFr8lQXtvVjf2RI0dMRkaGadq0acBxL7R3714jyWRlZVXb34MHD/puHa3qf3Wr2YP9DVX3P6Om1y3sxWWMMZflXQEAAKgTy9+6BQCA0xGsAQCwOII1AAAWR7AGACBEW7du1fDhw9W+fXu5XC6tXbv2ko/ZsmWLUlNTFR0drSuuuEKLFy+u9XkJ1gAAhKi8vFw9evTQM888E9L+n332mYYMGaJ+/fppz549evDBB3Xvvff6PiQnVKwGBwCgDlwul9asWaMRI0ZUu8/MmTO1bt06v++syMzM1N69ewO+SrcmQT8Uxev1BnxnrNvtDvjEMAAA7K4+Y97OnTuVkZHh13bTTTdpyZIlOnv2bLWfq3+xoMHa4/Fo7ty5fm2zZ8/WnDlz6tZbAADCbE64Pj999ux6i3mlpaUBnzOfmJioc+fO6fjx4yF/uU/QYJ2Tk6Ps7Gy/NrJqAICVhGvR1cx6jnkXfylL1exzbb6sJWiwpuQNAHCK+ox5bdu2Dfh2v2PHjqlRo0ZBvy64OnX7Io8ff9p3yaKOooMMLGPRMBgLa2E8rCPYWNQTO3yJaFpaml577TW/tk2bNqlXr14hz1dL3LoFALCpiDBttfH999/rgw8+0AcffCDp/K1ZH3zwgYqLiyWdn0YeP368b//MzEx9/vnnys7O1oEDB5SXl6clS5ZoxowZtTqvLb8iEwCAhvD+++/7fe971Vz3hAkTtGzZMpWUlPgCtyQlJyersLBQ06dP18KFC9W+fXv96U9/0siRI2t13rrdZ015qWFQ6rMOxsJaGA/ruIxlcE+YVoPn2ODjRsisAQC2ZIc563BhzhoAAIsjswYA2JKTsk2CNQDAlpxUBidYAwBsyUmZtZOuFQAAWyKzBgDYkpOyTYI1AMCWnDRn7aQ3JgAA2BKZNQDAlpyUbRKsAQC25KRg7aRrBQDAlsisAQC25KQFZgRrAIAtOak07KRrBQDAlsisAQC2RBkcAACLc1JpmGANALAlJwVrJ10rAAC2RGYNALAl5qwBALA4J5WGnXStAADYEpk1AMCWnJRtEqwBALbkpDlrJ70xAQDAlsisAQC25KRsk2ANALAlJwVrJ10rAAC2RGYNALAlJy0wI1gDAGzJSaVhgjUAwJaclFk76Y0JAAC2RGYNALAlJ2WbBGsAgC05KVg76VoBALAlMmsAgC05aYEZwRoAYEtOKg076VoBALAlMmsAgC05KdskWAMAbMlJc9ZOemMCAIAtkVkDAGzJFeGc3JpgDQCwJZeLYA0AgKVFOCizZs4aAACLI7MGANgSZXAAACzOSQvMKIMDAGBxZNYAAFuiDA4AgMVRBgcAAJZBZg0AsCXK4AAAWBxlcAAAYBlk1gAAW6IMDgCAxTnps8EJ1gAAW3JSZs2cNQAAFkdmDQCwJSetBidYAwBsiTI4AACwDDJrAIAtUQYHAMDiKIMDAIBq5ebmKjk5WdHR0UpNTdW2bdtq3D8/P189evRQbGys2rVrp0mTJqmsrCzk8xGsAQC25IpwhWWrrYKCAmVlZWnWrFnas2eP+vXrp8GDB6u4uDjo/tu3b9f48eM1ZcoU7du3Ty+//LLee+89TZ06NeRzEqwBALbkcrnCstXW/PnzNWXKFE2dOlVdunTRggUL1KlTJy1atCjo/m+//bY6d+6se++9V8nJybruuut055136v333w/5nARrAICjeb1enTx50m/zer1B9z1z5ox27dqljIwMv/aMjAzt2LEj6GPS09P1xRdfqLCwUMYYffXVV3rllVc0dOjQkPtIsAYA2FJEhCssm8fjUXx8vN/m8XiCnvP48eOqqKhQYmKiX3tiYqJKS0uDPiY9PV35+fkaM2aMoqKi1LZtWzVv3lxPP/106Nca+tMCAIB1hKsMnpOToxMnTvhtOTk5lzz3hYwx1ZbU9+/fr3vvvVcPP/ywdu3apY0bN+qzzz5TZmZmyNfKrVsAAFsK133Wbrdbbrc7pH1btWqlyMjIgCz62LFjAdl2FY/Ho759++r++++XJHXv3l1xcXHq16+fHn30UbVr1+6S5yWzBgAgRFFRUUpNTVVRUZFfe1FRkdLT04M+5vTp04qI8A+3kZGRks5n5KEgswYA2FJDfShKdna2xo0bp169eiktLU3PPfeciouLfWXtnJwcffnll1q+fLkkafjw4brjjju0aNEi3XTTTSopKVFWVpZ69+6t9u3bh3ROgjUAwJZcDVQbHjNmjMrKyjRv3jyVlJQoJSVFhYWFSkpKkiSVlJT43XM9ceJEnTp1Ss8884zuu+8+NW/eXAMGDNDjjz8e8jldJtQc/EI/hv6pKwij6ITANsaiYTAW1sJ4WEewsagnu38efI64tnoe/iosx6lPZNYAAFty0meDE6wBALbkpG/dYjU4AAAWR2YNALClCMrgAABYG2VwAABgGWTWAABbYjU4AAAW56QyOMEaAGBLZNaXchk/oQaXwFhYB2NhLYwH/oUEDdZer1der9evrTZfIQYAQH1zUhk86Gpwj8ej+Ph4v83j8VzuvgEAUC2XyxWWzQ6CfpEHmTUAwOoO/rJzWI7ziz1HwnKc+hS0DE5gBgBYnSvCOR8VUrcFZnz1XMPgawCtg7GwFsbDOi7jwj7Hz1kDAADr4D5rAIA92WRxWDgQrAEAtkQZHAAAWAaZNQDAllgNDgCAxdnlA03CgWANALAn5qwBAIBVkFkDAGyJOWsAACzOSXPWznlbAgCATZFZAwBsyUkfikKwBgDYk4OCNWVwAAAsjswaAGBLLpdz8k2CNQDAlpw0Z+2ctyUAANgUmTUAwJaclFkTrAEA9sScNQAA1uakzNo5b0sAALApMmsAgC05KbMmWAMAbIkv8gAAAJZBZg0AsCe+zxoAAGtz0py1c96WAABgU2TWAABbctICM4I1AMCWXA6as3bOlQIAYFNk1gAAW3LSAjOCNQDAnpizBgDA2pyUWTNnDQCAxZFZAwBsyUmrwQnWAABbctJ91s55WwIAgE2RWQMA7MlBC8wI1gAAW3LSnLVzrhQAAJsiswYA2JKTFpgRrAEAtsSHogAAAMsgswYA2BNlcAAArM1JZXCCNQDAnpwTq5mzBgDA6sisAQD25KA5azJrAIAtuVzh2eoiNzdXycnJio6OVmpqqrZt21bj/l6vV7NmzVJSUpLcbreuvPJK5eXlhXw+MmsAAGqhoKBAWVlZys3NVd++ffXss89q8ODB2r9/v372s58Ffczo0aP11VdfacmSJfr5z3+uY8eO6dy5cyGf02WMMbXu6Y9ltX4IwiA6IbCNsWgYjIW1MB7WEWws6snJ3w0Ly3GaPb2+Vvv36dNHPXv21KJFi3xtXbp00YgRI+TxeAL237hxo37961/r008/VcuWLevUR8rgAABbClcZ3Ov16uTJk36b1+sNes4zZ85o165dysjI8GvPyMjQjh07gj5m3bp16tWrl5544gl16NBBV111lWbMmKEffvgh5GslWAMAHM3j8Sg+Pt5vC5YhS9Lx48dVUVGhxMREv/bExESVlpYGfcynn36q7du36+OPP9aaNWu0YMECvfLKK5o2bVrIfWTOGgBgT2FaDZ6Tk6Ps7Gy/NrfbfYlT+5/bGFPtF4tUVlbK5XIpPz9f8fHxkqT58+dr1KhRWrhwoWJiYi7ZR4I1AMCewlQbdrvdlwzOVVq1aqXIyMiALPrYsWMB2XaVdu3aqUOHDr5ALZ2f4zbG6IsvvtC//du/XfK8lMEBALbkcrnCstVGVFSUUlNTVVRU5NdeVFSk9PT0oI/p27evjh49qu+//97XdujQIUVERKhjx44hnZdgDQBALWRnZ+v5559XXl6eDhw4oOnTp6u4uFiZmZmSzpfVx48f79t/7NixSkhI0KRJk7R//35t3bpV999/vyZPnhxSCVyiDA4AsKsG+gSzMWPGqKysTPPmzVNJSYlSUlJUWFiopKQkSVJJSYmKi4t9+zdp0kRFRUX63e9+p169eikhIUGjR4/Wo48+GvI5uc/aTriX1DoYC2thPKzjMt5nXT7jlrAcJ+6pV8NynPpEGRwAAIujDA4AsCe+zxoAAItzTqymDA4AgNWRWQMAbKm290jbGcEaAGBPzonVlMEBALA6MmsAgC25WA0OAIDFOSdWE6wBADbloAVmzFkDAGBxZNYAAFtyUGJNsAYA2JSDFphRBgcAwOLIrAEAtkQZHAAAq3NQtKYMDgCAxZFZAwBsyUGJNcEaAGBTrAYHAABWQWYNALAnB9XBCdYAAFtyUKwmWAMAbMpB0Zo5awAALI7MGgBgSy4HpZsEawCAPVEGBwAAVkFmDQCwJ+ck1nUM1tEJYe4G6oyxsA7GwloYj395LgeVwYMGa6/XK6/X69fmdrvldrsvS6cAAMA/BZ2z9ng8io+P99s8Hs/l7hsAANWLcIVnswGXMcZc3EhmDQCwuooFvw3LcSKz/hyW49SnoGVwAjMAANZRpwVmcxw0qW8lcwKLIIxFA2EsrIXxsI5gY1FvbFLCDgdu3QIA2JODPsKMYA0AsCcHVU+c87YEAACbIrMGANgTc9YAAFicg+asnXOlAADYFJk1AMCeKIMDAGBxrAYHAABWQWYNALCnCOfkmwRrAIA9UQYHAABWQWYNALAnyuAAAFicg8rgBGsAgD05KFg7p4YAAIBNkVkDAOyJOWsAACyOMjgAALAKMmsAgC25+CIPAAAsju+zBgAAVkFmDQCwJ8rgAABYHKvBAQCAVZBZAwDsiQ9FAQDA4hxUBidYAwDsyUHB2jk1BAAAbIpgDQCwp4iI8Gx1kJubq+TkZEVHRys1NVXbtm0L6XF/+9vf1KhRI11zzTW1Oh/BGgBgTy5XeLZaKigoUFZWlmbNmqU9e/aoX79+Gjx4sIqLi2t83IkTJzR+/HgNHDiw1uckWAMAUAvz58/XlClTNHXqVHXp0kULFixQp06dtGjRohofd+edd2rs2LFKS0ur9TkJ1gAAe4pwhWXzer06efKk3+b1eoOe8syZM9q1a5cyMjL82jMyMrRjx45qu7p06VL9/e9/1+zZs+t2qXV6FAAADc0VEZbN4/EoPj7eb/N4PEFPefz4cVVUVCgxMdGvPTExUaWlpUEf83//93964IEHlJ+fr0aN6nYTFrduAQAcLScnR9nZ2X5tbre7xse4LprrNsYEtElSRUWFxo4dq7lz5+qqq66qcx8J1gAAewrTF3m43e5LBucqrVq1UmRkZEAWfezYsYBsW5JOnTql999/X3v27NE999wjSaqsrJQxRo0aNdKmTZs0YMCAS56XYA0AsKcG+FCUqKgopaamqqioSLfeequvvaioSLfcckvA/s2aNdNHH33k15abm6s333xTr7zyipKTk0M6L8EaAIBayM7O1rhx49SrVy+lpaXpueeeU3FxsTIzMyWdL6t/+eWXWr58uSIiIpSSkuL3+DZt2ig6OjqgvSYEawCAPTXQF3mMGTNGZWVlmjdvnkpKSpSSkqLCwkIlJSVJkkpKSi55z3VtuYwxprYPmuOgz2O1kjlBhoqxaBiMhbUwHtYRbCzqS+WmR8JynIiMh8JynPpEZg0AsCcHvSHjPmsAACyOzBoAYE8u5+SbBGsAgD05pwpOGRwAAKsjswYA2JODFpgRrAEA9uSgYE0ZHAAAiyOzBgDYk4Mya4I1AMCmnBOsKYMDAGBxZNYAAHtyTmJNsAYA2BRz1gAAWJyDgjVz1gAAWByZNQDAnhyUWROsAQA25ZxgTRkcAACLI7MGANiTcxJrgjUAwKYcNGdNGRwAAIsjswYA2JODMmuCNQDAppwTrCmDAwBgcWTWAAB7ogwOAIDFEawBALA458Rq5qwBALA6MmsAgD1RBgcAwOqcE6wpgwMAYHFk1gAAe6IMDgCAxTkoWFMGBwDA4sisAQD25JzEmmANALApyuAAAMAqyKwBADblnMyaYA0AsCcHlcEJ1gAAe3JQsGbOGgAAiyOzBgDYE5k1AACwCoI1AAAWRxkcAGBPDiqDE6wBAPbkoGDtMsaYhu4EAAC1VflxXliOE5EyOSzHqU9BM2uv1yuv1+vX5na75Xa7L0unAAC4JAdl1kEXmHk8HsXHx/ttHo/ncvcNAIAauMK0WV/QMjiZNQDA6ir3LQvLcSK6TgzLcepT0DI4gRkAYHkOKoPXbTX4j2Vh7gZCEp0Q2MZYNAzGwloYD+sINhb1xeWcjwrh1i0AgE05J7N2ztsSAABsiswaAGBPzFkDAGBxDpqzds6VAgBgU2TWAACbogwOAIC1OWjOmjI4AAAWR2YNALAp5+SbBGsAgD1RBgcAAFZBsAYA2JPLFZ6tDnJzc5WcnKzo6GilpqZq27Zt1e67evVqDRo0SK1bt1azZs2Ulpamv/71r7U6H8EaAGBTDfN91gUFBcrKytKsWbO0Z88e9evXT4MHD1ZxcXHQ/bdu3apBgwapsLBQu3btUv/+/TV8+HDt2bMn9CsN9n3Wl8S32TQMvlnIOhgLa2E8rOMyfutW5d/XhuU4EVeOqNX+ffr0Uc+ePbVo0SJfW5cuXTRixAh5PJ6QjtG1a1eNGTNGDz/8cGh9rFUPAQD4F+P1enXy5Em/zev1Bt33zJkz2rVrlzIyMvzaMzIytGPHjpDOV1lZqVOnTqlly5Yh95FgDQCwpzDNWXs8HsXHx/tt1WXIx48fV0VFhRITE/3aExMTVVpaGlK3//CHP6i8vFyjR48O+VK5dQsAYFPhuXUrJydH2dnZfm1ut7vmM1+0MM0YE9AWzMqVKzVnzhy9+uqratOmTch9JFgDABzN7XZfMjhXadWqlSIjIwOy6GPHjgVk2xcrKCjQlClT9PLLL+vGG2+sVR8pgwMA7MkVEZ6tFqKiopSamqqioiK/9qKiIqWnp1f7uJUrV2rixIlasWKFhg4dWutLJbMGANhSKGXn+pCdna1x48apV69eSktL03PPPafi4mJlZmZKOl9W//LLL7V8+XJJ5wP1+PHj9cc//lHXXnutLyuPiYlRfHx8SOckWAMAUAtjxoxRWVmZ5s2bp5KSEqWkpKiwsFBJSUmSpJKSEr97rp999lmdO3dO06ZN07Rp03ztEyZM0LJly0I6J/dZ2wn3kloHY2EtjId1XMb7rM2RwrAcx9V5SFiOU5/IrAEA9lTL+WY7c86VAgBgU2TWAACbcs5XZBKsAQD25KDvsyZYAwDsiTlrAABgFWTWAACbogwOAIC1OWjOmjI4AAAWR2YNALAnBy0wI1gDAGyKMjgAALAIMmsAgD05aIEZwRoAYFPOKQ4750oBALApMmsAgD1RBgcAwOII1gAAWJ1zZnKdc6UAANgUmTUAwJ4ogwMAYHXOCdaUwQEAsDgyawCAPVEGBwDA6pwTrCmDAwBgcWTWAAB7ogwOAIDVOac47JwrBQDApsisAQD2RBkcAACrI1gDAGBtDsqsmbMGAMDiyKwBADblnMyaYA0AsCfK4AAAwCrIrAEANuWczJpgDQCwJ8rgAADAKsisAQA25Zx8k2ANALAnyuAAAMAqyKwBADblnMyaYA0AsCmCNQAAluZizhoAAFgFmTUAwKack1kTrAEA9kQZHAAAWAWZNQDAppyTWROsAQD25HJOcdg5VwoAgE2RWQMAbIoyOAAA1sZqcAAAYBVk1gAAm3JOZk2wBgDYk4PK4ARrAIBNOSdYM2cNAIDFkVkDAOyJMjgAAFbnnGBNGRwAAIsjswYA2BOfDQ4AgNW5wrTVXm5urpKTkxUdHa3U1FRt27atxv23bNmi1NRURUdH64orrtDixYtrdT6CNQAAtVBQUKCsrCzNmjVLe/bsUb9+/TR48GAVFxcH3f+zzz7TkCFD1K9fP+3Zs0cPPvig7r33Xq1atSrkc7qMMabWPf2xrNYPQRhEJwS2MRYNg7GwFsbDOoKNRX358Xh4jhPdqla79+nTRz179tSiRYt8bV26dNGIESPk8XgC9p85c6bWrVunAwcO+NoyMzO1d+9e7dy5M6Rz1m3O+nIOBmrGWFgHY2EtjIcDXP7V4GfOnNGuXbv0wAMP+LVnZGRox44dQR+zc+dOZWRk+LXddNNNWrJkic6ePavGjRtf8rwsMAMAOJrX65XX6/Vrc7vdcrvdAfseP35cFRUVSkxM9GtPTExUaWlp0OOXlpYG3f/cuXM6fvy42rVrd8k+hjRn7fV6NWfOnICLweXHWFgHY2EtjIcDRSeEZfN4PIqPj/fbgpWzL+S66ANZjDEBbZfaP1h7dUIO1nPnzuWPwAIYC+tgLKyF8UBd5eTk6MSJE35bTk5O0H1btWqlyMjIgCz62LFjAdlzlbZt2wbdv1GjRkpICG26htXgAABHc7vdatasmd8WrAQuSVFRUUpNTVVRUZFfe1FRkdLT04M+Ji0tLWD/TZs2qVevXiHNV0sEawAAaiU7O1vPP/+88vLydODAAU2fPl3FxcXKzMyUdD5THz9+vG//zMxMff7558rOztaBAweUl5enJUuWaMaMGSGfkwVmAADUwpgxY1RWVqZ58+appKREKSkpKiwsVFJSkiSppKTE757r5ORkFRYWavr06Vq4cKHat2+vP/3pTxo5cmTI5wwpWLvdbs2ePbvasgAuH8bCOhgLa2E8cDndfffduvvuu4P+btmyZQFt119/vXbv3l3n89XtQ1EAAMBlw5w1AAAWR7AGAMDiCNYAAFgcwRoAAIsjWAMAYHEEawAALI5gDQCAxRGsAQCwOII1AAAWR7AGAMDiCNYAAFjc/wP34zr2WeOb4AAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -338,7 +338,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -501,17 +501,17 @@ "output_type": "stream", "text": [ " === Starting experiment === \n", - " Reward condition: Left, Observation: [CENTER, No reward, Cue Left]\n", + " Reward condition: Right, Observation: [CENTER, No reward, Cue Left]\n", "[Step 0] Action: [Move to RIGHT ARM]\n", - "[Step 0] Observation: [RIGHT ARM, Loss!, Cue Right]\n", + "[Step 0] Observation: [RIGHT ARM, Reward!, Cue Right]\n", "[Step 1] Action: [Move to CUE LOCATION]\n", - "[Step 1] Observation: [CUE LOCATION, No reward, Cue Left]\n", - "[Step 2] Action: [Move to RIGHT ARM]\n", - "[Step 2] Observation: [RIGHT ARM, Loss!, Cue Left]\n", - "[Step 3] Action: [Move to RIGHT ARM]\n", - "[Step 3] Observation: [RIGHT ARM, Loss!, Cue Left]\n", - "[Step 4] Action: [Move to RIGHT ARM]\n", - "[Step 4] Observation: [RIGHT ARM, Loss!, Cue Right]\n" + "[Step 1] Observation: [CUE LOCATION, No reward, Cue Right]\n", + "[Step 2] Action: [Move to LEFT ARM]\n", + "[Step 2] Observation: [LEFT ARM, Loss!, Cue Left]\n", + "[Step 3] Action: [Move to CUE LOCATION]\n", + "[Step 3] Observation: [CUE LOCATION, No reward, Cue Right]\n", + "[Step 4] Action: [Move to LEFT ARM]\n", + "[Step 4] Observation: [LEFT ARM, Reward!, Cue Right]\n" ] } ], @@ -566,7 +566,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -589,7 +589,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -598,12 +598,16 @@ "text": [ "(1, 5, 50, 3)\n", "(1, 5, 50, 2)\n", - "444 ms ± 6.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + "494 ms ± 6.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "172 ms ± 412 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "dict_keys(['actions', 'outcomes'])\n" ] } ], "source": [ "import numpyro as npyro\n", + "from jax import random\n", + "from numpyro.infer import Predictive\n", "from pymdp.jax.likelihoods import aif_likelihood, evolve_trials\n", "\n", "print(measurements['outcomes'].shape)\n", @@ -615,39 +619,31 @@ "evolve_trials(agent, xs)\n", "%timeit evolve_trials(agent, xs)\n", "\n", + "rng_key = random.PRNGKey(0)\n", + "\n", "with npyro.handlers.seed(rng_seed=0):\n", - " aif_likelihood(Nb, Nt, Na, measurements, agent)" + " aif_likelihood(Nb, Nt, Na, measurements, agent)\n", + "\n", + "%timeit pred_samples = Predictive(aif_likelihood, num_samples=11)(rng_key, Nb, Nt, Na, measurements, agent)\n", + "print(pred_samples.keys())" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 59, "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'model_log_likelihood' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn [23], line 42\u001b[0m\n\u001b[1;32m 38\u001b[0m npyro\u001b[39m.\u001b[39mfactor(\u001b[39m'\u001b[39m\u001b[39mlog_prob\u001b[39m\u001b[39m'\u001b[39m, log_prob)\n\u001b[1;32m 40\u001b[0m \u001b[39mreturn\u001b[39;00m log_prob\n\u001b[0;32m---> 42\u001b[0m \u001b[39mprint\u001b[39m(jax\u001b[39m.\u001b[39;49mgrad(\u001b[39mlambda\u001b[39;49;00m x: model_log_likelihood(T, measurments, trans_params(x)))(jnp\u001b[39m.\u001b[39;49mones(\u001b[39m3\u001b[39;49m)))\n\u001b[1;32m 44\u001b[0m \u001b[39mwith\u001b[39;00m npyro\u001b[39m.\u001b[39mhandlers\u001b[39m.\u001b[39mseed(rng_seed\u001b[39m=\u001b[39m\u001b[39m101111\u001b[39m):\n\u001b[1;32m 45\u001b[0m lp \u001b[39m=\u001b[39m model(measurments, T)\n", - " \u001b[0;31m[... skipping hidden 10 frame]\u001b[0m\n", - "Cell \u001b[0;32mIn [23], line 42\u001b[0m, in \u001b[0;36m\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 38\u001b[0m npyro\u001b[39m.\u001b[39mfactor(\u001b[39m'\u001b[39m\u001b[39mlog_prob\u001b[39m\u001b[39m'\u001b[39m, log_prob)\n\u001b[1;32m 40\u001b[0m \u001b[39mreturn\u001b[39;00m log_prob\n\u001b[0;32m---> 42\u001b[0m \u001b[39mprint\u001b[39m(jax\u001b[39m.\u001b[39mgrad(\u001b[39mlambda\u001b[39;00m x: model_log_likelihood(T, measurments, trans_params(x)))(jnp\u001b[39m.\u001b[39mones(\u001b[39m3\u001b[39m)))\n\u001b[1;32m 44\u001b[0m \u001b[39mwith\u001b[39;00m npyro\u001b[39m.\u001b[39mhandlers\u001b[39m.\u001b[39mseed(rng_seed\u001b[39m=\u001b[39m\u001b[39m101111\u001b[39m):\n\u001b[1;32m 45\u001b[0m lp \u001b[39m=\u001b[39m model(measurments, T)\n", - "\u001b[0;31mNameError\u001b[0m: name 'model_log_likelihood' is not defined" - ] - } - ], + "outputs": [], "source": [ "import numpyro as npyro\n", "import numpyro.distributions as dist\n", - "from jax import nn, lax\n", + "from jax import nn, lax, vmap\n", "\n", + "@vmap\n", "def trans_params(z):\n", "\n", - " a = npyro.deterministic('a', nn.sigmoid(z[0]))\n", - " lam = npyro.deterministic('lambda', nn.softplus(z[1]))\n", - " d = npyro.deterministic('d', nn.sigmoid(z[2]))\n", + " a = nn.sigmoid(z[0])\n", + " lam = nn.softplus(z[1])\n", + " d = nn.sigmoid(z[2])\n", "\n", " A = lax.stop_gradient([jnp.array(x) for x in list(A_gp)])\n", "\n", @@ -658,73 +654,96 @@ "\n", " A[1] = jnp.stack([side_vector, middle_matrix1, middle_matrix2, side_vector], -2)\n", " \n", - " C = lax.stop_gradient([jnp.array(x) for x in list(agent.C)])\n", - " C[1] = lam * jnp.array([0., 1., -1.])\n", + " C = [\n", + " jnp.zeros(4),\n", + " lam * jnp.array([0., 1., -1.]),\n", + " jnp.zeros(2)\n", + " ]\n", + "\n", + " D = [nn.one_hot(0, 4), jnp.array([d, 1-d])]\n", "\n", - " D = [lax.stop_gradient(nn.one_hot(0, 4)), jnp.array([d, 1-d])]\n", + " E = jnp.ones(4)/4\n", "\n", " params = {\n", " 'A': A,\n", " 'B': lax.stop_gradient([jnp.array(x) for x in list(B_gp)]),\n", " 'C': C,\n", - " 'D': D\n", + " 'D': D,\n", + " 'E': E\n", " }\n", "\n", - " return params\n", - "\n", - "def model(data, T, n_pars=3):\n", - " z = npyro.sample('z', dist.Normal(0., 1.).expand([n_pars]).to_event(1))\n", - " x = trans_params(z)\n", - " log_prob = model_log_likelihood(T, data, x)\n", - " npyro.factor('log_prob', log_prob)\n", - "\n", - " return log_prob\n", - "\n", - "print(jax.grad(lambda x: model_log_likelihood(T, measurments, trans_params(x)))(jnp.ones(3)))\n", - "\n", - "with npyro.handlers.seed(rng_seed=101111):\n", - " lp = model(measurments, T)\n", - " print(lp)" + " return params, a, lam, d" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 61, "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - " 0%| | 0/1250 [00:00" ] @@ -738,33 +757,25 @@ "az.style.use('arviz-darkgrid')\n", "\n", "coords = {\n", + " 'idx': jnp.arange(num_agents),\n", " 'vars': jnp.arange(3), \n", "}\n", - "dims = {'z': [\"vars\"], 'd': [], 'lambda': [], 'a': []}\n", + "dims = {'z': [\"idx\", \"vars\"], 'd': [\"idx\"], 'lambda': [\"idx\"], 'a': [\"idx\"]}\n", "data_kwargs = {\n", " \"dims\": dims,\n", " \"coords\": coords,\n", - " \"num_chains\": num_chains\n", "}\n", - "data_mcmc = az.from_numpyro(posterior=mcmc, posterior_predictive=samples)\n", - "az.plot_trace(data_mcmc, kind=\"rank_bars\", var_names=['~z']);\n", + "data_mcmc = az.from_numpyro(posterior=mcmc, **data_kwargs)\n", + "az.plot_trace(data_mcmc, kind=\"rank_bars\", var_names=['d', 'lambda', 'a']);\n", "\n", "#TODO: maybe plot real values on top of samples from the posterior" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 69, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 1000/1000 [00:04<00:00, 221.73it/s, init loss: 16.8077, avg. loss [951-1000]: 6.9221]\n" - ] - } - ], + "outputs": [], "source": [ "# inferenace with SVI and autoguides\n", "import optax\n", @@ -776,17 +787,17 @@ "optimizer = npyro.optim.optax_to_numpyro(optax.chain(optax.adabelief(1e-3)))\n", "svi = SVI(model, guide, optimizer, Trace_ELBO(num_particles=10))\n", "rng_key, _rng_key = random.split(rng_key)\n", - "svi_res = svi.run(_rng_key, num_iters, measurments, T)" + "svi_res = svi.run(_rng_key, num_iters, measurements, Nb, Nt, Na, progress_bar=False)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 70, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -804,7 +815,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 81, "metadata": {}, "outputs": [], "source": [ @@ -812,26 +823,26 @@ "pred = Predictive(\n", " model, \n", " guide=guide, \n", - " parallel=svi_res.params, \n", + " params=svi_res.params, \n", " num_samples=1000, \n", - " return_sites=[\"z\", \"d\", \"a\", \"lambda\"]\n", + " return_sites=[\"d\", \"a\", \"lambda\"]\n", ")\n", - "post_sample = pred(_rng_key, measurments, T)\n", + "post_sample = pred(_rng_key, measurements, Nb, Nt, Na)\n", "\n", "for key in post_sample:\n", - " post_sample[key] = np.expand_dims(post_sample[key], 0)\n", + " post_sample[key] = jnp.expand_dims(post_sample[key], 0)\n", "\n", "data_svi = az.convert_to_inference_data(post_sample, group=\"posterior\", **data_kwargs)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 85, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -845,23 +856,17 @@ " [data_mcmc, data_svi],\n", " model_names = [\"nuts\", \"svi\"],\n", " kind='forestplot',\n", - " var_names=[\"~z\"],\n", + " var_names=['d', 'lambda', 'a'],\n", + " coords={\"idx\": 0},\n", " combined=True,\n", " figsize=(20, 6)\n", ")" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3.9.13 ('pymdp')", + "display_name": "pymdp", "language": "python", "name": "python3" }, @@ -875,11 +880,11 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.13" + "version": "3.10.6" }, "vscode": { "interpreter": { - "hash": "4e1a08fe767a14203a671ee5de76a8a25ed3badbbf81ba1baf234489164a8ba4" + "hash": "ee9ec9b0986c80b528a0decd8a099ef790c4bc969bd74a31889dfc8308eb58a2" } } }, From 00700b910446f9e6c6d1e360b70a2c9885dc67fa Mon Sep 17 00:00:00 2001 From: conorheins Date: Tue, 15 Nov 2022 19:19:55 +0100 Subject: [PATCH 026/232] added batch_dim variable to `agent` class's `__init__()` to make the broadcasting of `gamma` variable more intuitive/readable --- pymdp/jax/agent.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 32e978a3..87cd3e7d 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -87,7 +87,9 @@ def __init__( self.qs = qs self.q_pi = q_pi - self.gamma = jnp.broadcast_to(gamma, self.A[0].shape[:1]) + batch_dim = (self.A[0].shape[0],) + + self.gamma = jnp.broadcast_to(gamma, batch_dim) ### Static parameters ### From 80300ac390f14b4d4d2c0e02226e8b33d4a5cd0a Mon Sep 17 00:00:00 2001 From: conorheins Date: Tue, 15 Nov 2022 19:20:15 +0100 Subject: [PATCH 027/232] added jax-related requirements to `requirements.txt` to allow running of jupyter notebook `model_inversion.ipynb` --- requirements.txt | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 7443de46..dbeae96f 100644 --- a/requirements.txt +++ b/requirements.txt @@ -25,4 +25,8 @@ sphinx-rtd-theme>=0.4 myst-nb>=0.13.1 autograd>=1.3 jax>=0.3 -jaxlib>=0.3 \ No newline at end of file +jaxlib>=0.3 +equinox>=0.9 +numpyro>=0.1 +arviz>=0.13 +optax>=0.1 \ No newline at end of file From 65a006ec502a9463eaf9201fbbff0fcdaf4f149e Mon Sep 17 00:00:00 2001 From: conorheins Date: Tue, 15 Nov 2022 19:20:47 +0100 Subject: [PATCH 028/232] increased readability of `jax.control.get_marginals.py`, also renamed output and revised docstring a bit --- pymdp/jax/control.py | 23 +++++------------------ 1 file changed, 5 insertions(+), 18 deletions(-) diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index 5c546ae1..5e95ba52 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -15,7 +15,7 @@ def get_marginals(q_pi, policies, num_controls): """ - Computes the marginal posterior over actions. + Computes the marginal posterior(s) over actions by integrating their posterior probability under the policies that they appear within. Parameters ---------- @@ -30,30 +30,17 @@ def get_marginals(q_pi, policies, num_controls): Returns ---------- - selected_policy: ``list`` of ``jax.numpy.ndarrays`` + action_marginals: ``list`` of ``jax.numpy.ndarrays`` List of arrays corresponding to marginal probability of each action possible action """ num_factors = len(num_controls) - # weight each action according to its integrated posterior probability over policies and timesteps - # for pol_idx, policy in enumerate(policies): - # for t in range(policy.shape[0]): - # for factor_i, action_i in enumerate(policy[t, :]): - # marginal[factor_i][action_i] += q_pi[pol_idx] - - # weight each action according to its integrated posterior probability under all policies at the current timestep - - #NOTE: Why is the original version selecting policy[0, :] and not policy[t, :] - # for pol_idx, policy in enumerate(policies): - # for factor_i, action_i in enumerate(policy[0, :]): - # action_marginals[factor_i][action_i] += q_pi[pol_idx] - - marginal = [] + action_marginals = [] for factor_i in range(num_factors): actions = jnp.arange(num_controls[factor_i])[:, None] - marginal.append(jnp.where(actions==policies[:, 0, factor_i], q_pi, 0).sum(-1)) + action_marginals.append(jnp.where(actions==policies[:, 0, factor_i], q_pi, 0).sum(-1)) - return marginal + return action_marginals def sample_action(q_pi, policies, num_controls, action_selection="deterministic", alpha=16.0, rng_key=None): From eed2455154d0e427d0f0b144d3521ce3074b9258 Mon Sep 17 00:00:00 2001 From: conorheins Date: Tue, 15 Nov 2022 19:21:30 +0100 Subject: [PATCH 029/232] cleaned up `model_inversion.ipynb` notebook, made generative model parameterization more readable --- examples/model_inversion.ipynb | 553 +++++---------------------------- 1 file changed, 85 insertions(+), 468 deletions(-) diff --git a/examples/model_inversion.ipynb b/examples/model_inversion.ipynb index 1d19efbb..8b1ef878 100644 --- a/examples/model_inversion.ipynb +++ b/examples/model_inversion.ipynb @@ -9,48 +9,21 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import jax\n", "import jax.numpy as jnp\n", + "from copy import deepcopy\n", "\n", "import seaborn as sns\n", "import matplotlib.pyplot as plt\n", "\n", "from pymdp.jax.agent import Agent\n", - "from pymdp.envs import TMazeEnv" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Auxiliary Functions\n", - "\n", - "Define some utility functions that will be helpful for plotting." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "def plot_beliefs(belief_dist, title=\"\"):\n", - " plt.grid(zorder=0)\n", - " plt.bar(range(belief_dist.shape[0]), belief_dist, color='r', zorder=3)\n", - " plt.xticks(range(belief_dist.shape[0]))\n", - " plt.title(title)\n", - " plt.show()\n", - " \n", - "def plot_likelihood(A, title=\"\"):\n", - " ax = sns.heatmap(A, cmap=\"OrRd\", linewidth=2.5)\n", - " plt.xticks(range(A.shape[1]))\n", - " plt.yticks(range(A.shape[0]))\n", - " plt.title(title)\n", - " plt.show()" + "from pymdp.envs import TMazeEnv\n", + "from pymdp import utils \n", + "import numpy as np" ] }, { @@ -61,164 +34,51 @@ "\n", "Here we consider an agent navigating a three-armed 'T-maze,' with the agent starting in a central location of the maze. The bottom arm of the maze contains an informative cue, which signals in which of the two top arms ('Left' or 'Right', the ends of the 'T') a reward is likely to be found. \n", "\n", - "At each timestep, the environment is described by the joint occurrence of two qualitatively-different 'kinds' of states (hereafter referred to as _hidden state factors_). These hidden state factors are independent of one another.\n", - "\n", - "We represent the first hidden state factor (`Location`) as a $ 1 \\ x \\ 4 $ vector that encodes the current position of the agent, and can take the following values: {`CENTER`, `RIGHT ARM`, `LEFT ARM`, or `CUE LOCATION`}. For example, if the agent is in the `CUE LOCATION`, the current state of this factor would be $s_1 = [0 \\ 0 \\ 0 \\ 1]$.\n", + "### Hidden states\n", "\n", - "We represent the second hidden state factor (`Reward Condition`) as a $ 1 \\ x \\ 2 $ vector that encodes the reward condition of the trial: {`Reward on Right`, or `Reward on Left`}. A trial where the condition is reward is `Reward on Left` is thus encoded as the state $s_2 = [0 \\ 1]$.\n", + "The T-Maze environment is comprised of two hidden state factors:\n", "\n", - "The environment is designed such that when the agent is located in the `RIGHT ARM` and the reward condition is `Reward on Right`, the agent has a specified probability $a$ (where $a > 0.5$) of receiving a reward, and a low probability $b = 1 - a$ of receiving a 'loss' (we can think of this as an aversive or unpreferred stimulus). If the agent is in the `LEFT ARM` for the same reward condition, the reward probabilities are swapped, and the agent experiences loss with probability $a$, and reward with lower probability $b = 1 - a$. These reward contingencies are intuitively swapped for the `Reward on Left` condition. \n", + "- `Location`: a $4$-dimensional vector that encodes the current position of the agent, and can take the following values: {`CENTER`, `RIGHT ARM`, `LEFT ARM`, or `CUE LOCATION`}. For example, if the agent is in the `CUE LOCATION`, the current state of this factor would be $s_1 = [0 \\ 0 \\ 0 \\ 1]$.\n", "\n", - "For instance, we can encode the state of the environment at the first time step in a `Reward on Right` trial with the following pair of hidden state vectors: $s_1 = [1 \\ 0 \\ 0 \\ 0]$, $s_2 = [1 \\ 0]$, where we assume the agent starts sitting in the central location. If the agent moved to the right arm, then the corresponding hidden state vectors would now be $s_1 = [0 \\ 1 \\ 0 \\ 0]$, $s_2 = [1 \\ 0]$. This highlights the _independence_ of the two hidden state factors -- the location of the agent ($s_1$) can change without affecting the identity of the reward condition ($s_2$).\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 1. Initialize environment\n", - "Now we can initialize the T-maze environment using the built-in `TMazeEnv` class from the `pymdp.envs` module." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Choose reward probabilities $a$ and $b$, where $a$ and $b$ are the probabilities of reward / loss in the 'correct' arm, and the probabilities of loss / reward in the 'incorrect' arm. Which arm counts as 'correct' vs. 'incorrect' depends on the reward condition (state of the 2nd hidden state factor)." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "reward_probabilities = [0.98, 0.02] # probabilities used in the original SPM T-maze demo" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Initialize an instance of the T-maze environment" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "env = TMazeEnv(reward_probs = reward_probabilities)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Structure of the state --> outcome mapping\n", - "We can 'peer into' the rules encoded by the environment (also known as the _generative process_ ) by looking at the probability distributions that map from hidden states to observations. Following the SPM version of active inference, we refer to this collection of probabilistic relationships as the `A` array. In the case of the true rules of the environment, we refer to this array as `A_gp` (where the suffix `_gp` denotes the generative process). \n", + "-`Reward Condition`: a $ 1 \\ x \\ 2 $ vector that encodes the reward condition of the trial: {`Reward on Right`, or `Reward on Left`}. A trial where the condition is reward is `Reward on Left` is thus encoded as the state $s_2 = [0 \\ 1]$.\n", "\n", - "It is worth outlining what constitute the agent's observations in this task. In this T-maze demo, we have three sensory channels or observation modalities: `Location`, `Reward`, and `Cue`. \n", + "The environment is designed such that when the agent is located in the `RIGHT ARM` and the reward condition is `Reward on Right`, the agent has a specified probability $a$ (where $a > 0.5$) of receiving a reward, and a low probability $b = 1 - a$ of receiving a 'loss' (we can think of this as an aversive or unpreferred stimulus). If the agent is in the `LEFT ARM` for the same reward condition, the reward probabilities are swapped, and the agent experiences loss with probability $a$, and reward with lower probability $b = 1 - a$. These reward contingencies are intuitively swapped for the `Reward on Left` condition. \n", "\n", - ">The `Location` observation values are identical to the `Location` hidden state values. In this case, the agent always unambiguously observes its own state - if the agent is in `RIGHT ARM`, it receives a `RIGHT ARM` observation in the corresponding modality. This might be analogized to a 'proprioceptive' sense of one's own place.\n", + "### Observations\n", "\n", - ">The `Reward` observation modality assumes the values `No Reward`, `Reward` or `Loss`. The `No Reward` (index 0) observation is observed whenever the agent isn't occupying one of the two T-maze arms (the right or left arms). The `Reward` (index 1) and `Loss` (index 2) observations are observed in the right and left arms of the T-maze, with associated probabilities that depend on the reward condition (i.e. on the value of the second hidden state factor).\n", + "The agent is equipped with three sensory channels or observation modalities: `Location`, `Reward`, and `Cue`. \n", "\n", - "> The `Cue` observation modality assumes the values `Cue Right`, `Cue Left`. This observation unambiguously signals the reward condition of the trial, and therefore in which arm the `Reward` observation is more probable. When the agent occupies the other arms, the `Cue` observation will be `Cue Right` or `Cue Left` with equal probability. However (as we'll see below when we intialise the agent), the agent's beliefs about the likelihood mapping render these observations uninformative and irrelevant to state inference.\n", + "- `Location`: a $4$-dimensional observation that encodes the sensed position of the agent, and can take the same values as the `Location` hidden state factor.\n", + " \n", + "- `Reward` : a $3$-dimensional observation that can take the values `No Reward`, `Reward` or `Loss`. The `No Reward` (index 0) observation is observed whenever the agent isn't occupying one of the two T-maze arms (the right or left arms). The `Reward` (index 1) and `Loss` (index 2) observations are observed in the right and left arms of the T-maze, with associated probabilities that depend on the reward condition (i.e. on the value of the second hidden state factor).\n", "\n", - "In `pymdp`, we store the set of probability distributions encoding the conditional probabilities of observations, under different configurations of hidden states, as a set of matrices referred to as the likelihood mapping or `A` array (this is a convention borrowed from SPM). The likelihood mapping _for a single modality_ is stored as a single matrix `A[i]` with the larger likelihood array, where `i` is the index of the corresponding modality. Each modality-specific A matrix has `n_observations[i]` rows, and as many lagging dimensions (e.g. columns, 'slices' and higher-order dimensions) as there are hidden state factors. `n_observations[i]` tells you the number of observation values for observation modality `i`, and is usually stored as a property of the `Env` class (e.g. `env.n_observations`).\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "A_gp = env.get_likelihood_dist()" + "- `Cue`: a $2$-dimensional observation that can take the values `Cue Right` or `Cue Left`. This observation signals the reward condition of the trial, and therefore in which arm the `Reward` observation is more probable. When the agent occupies the other two arms (the `RIGHT` or `LEFT` arms), the `Cue` observation will be `Cue Right` or `Cue Left` with equal probability. However (as we'll see below when we intialise the agent), the agent's beliefs about the likelihood mapping render these observations uninformative and irrelevant to state inference" ] }, { - "cell_type": "code", - "execution_count": 6, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ - "plot_likelihood(A_gp[1][:, :, 0],'Reward Right')" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_likelihood(A_gp[1][:, :, 1],'Reward Left')" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_likelihood(A_gp[2][:, 3, :],'Cue Mapping')" + "## Initialize environment\n", + "Now we can initialize the T-maze environment using the built-in `TMazeEnv` class from the `pymdp.envs` module." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Transition Dynamics\n", - "\n", - "We represent the dynamics of the environment (e.g. changes in the location of the agent and changes to the reward condition) as conditional probability distributions that encode the likelihood of transitions between the states of a given hidden state factor. These distributions are collected into the so-called `B` array, also known as _transition likelihoods_ or _transition distribution_ . As with the `A` array, we denote the true probabilities describing the environmental dynamics as `B_gp`. Each sub-matrix `B_gp[f]` of the larger array encodes the transition probabilities between state-values of a given hidden state factor with index `f`. These matrices encode dynamics as Markovian transition probabilities, such that the entry $i,j$ of a given matrix encodes the probability of transition to state $i$ at time $t+1$, given state $j$ at $t$. " + "Choose reward probabilities $a$ and $b$, where $a$ and $b$ are the probabilities of reward / loss in the 'correct' arm, and the probabilities of loss / reward in the 'incorrect' arm. Which arm counts as 'correct' vs. 'incorrect' depends on the reward condition (state of the 2nd hidden state factor)." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ + "reward_probabilities = [0.98, 0.02] # probabilities used in the original SPM T-maze demo\n", + "env = TMazeEnv(reward_probs = reward_probabilities)\n", + "A_gp = env.get_likelihood_dist()\n", "B_gp = env.get_transition_dist()" ] }, @@ -226,131 +86,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "For example, we can inspect the 'dynamics' of the `Reward Condition` factor by indexing into the appropriate sub-matrix of `B_gp`" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_likelihood(B_gp[1][:, :, 0],'Reward Condition Transitions')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The above transition array is the 'trivial' identity matrix, meaning that the reward condition doesn't change over time (it's mapped from whatever it's current value is to the same value at the next timestep)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### (Controllable-) Transition Dynamics\n", + "### Note on Controllable (and Uncontrollable-) Transition Dynamics\n", "\n", - "Importantly, some hidden state factors are _controllable_ by the agent, meaning that the probability of being in state $i$ at $t+1$ isn't merely a function of the state at $t$, but also of actions (or from the agent's perspective, _control states_ ). So now each transition likelihood encodes conditional probability distributions over states at $t+1$, where the conditioning variables are both the states at $t-1$ _and_ the actions at $t-1$. This extra conditioning on actions is encoded via an optional third dimension to each factor-specific `B` matrix.\n", + "Importantly, some hidden state factors are _controllable_ by the agent, meaning that the probability of being in state $i$ at $t+1$ doesn't only depend on the state at $t$, but also on actions or _control states_. So now each transition likelihood encodes conditional probability distributions over states at $t+1$, where the conditioning variables are both the states at $t-1$ _and_ the actions at $t-1$. This extra conditioning on actions is encoded via an optional third dimension to each factor-specific `B` matrix.\n", "\n", "For example, in our case the first hidden state factor (`Location`) is under the control of the agent, which means the corresponding transition likelihoods `B[0]` are index-able by both previous state and action." ] }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_likelihood(B_gp[0][:,:,0],'Transition likelihood for \"Move to Center\"')" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_likelihood(B_gp[0][:,:,1],'Transition likelihood for \"Move to Right Arm\"')" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_likelihood(B_gp[0][:,:,2],'Transition likelihood for \"Move to Left Arm\"')" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_likelihood(B_gp[0][:,:,3],'Transition likelihood for \"Move to Cue Location\"')" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -365,28 +107,41 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "num_agents = 50 # number of different agents \n", - "A_gm = [jnp.broadcast_to(jnp.array(a), (num_agents,) + a.shape) for a in A_gp] # map the true observation likelihood to jax arrays\n", - "B_gm = [jnp.broadcast_to(jnp.array(b), (num_agents,) + b.shape) for b in B_gp] # map the true transition likelihood to jax arrays\n", - "D_gm = [jnp.broadcast_to(jnp.array([1., 0., 0., 0.]), (num_agents, 4)), jnp.broadcast_to(jnp.array([.5, .5]), (num_agents, 2))]\n", - "C_gm = [jnp.zeros((num_agents, 4)), jnp.broadcast_to(jnp.array([0., -3., 3.]), (num_agents, 3)),jnp.zeros((num_agents, 2))]\n", - "E_gm = jnp.ones((num_agents, 4))" + "# make the generative model of each agent a copy of the true generative process likelihood array\n", + "\n", + "base_A_gm = deepcopy(A_gp) \n", + "base_B_gm = deepcopy(B_gp) \n", + "\n", + "num_obs, num_states, num_modalities, num_factors = utils.get_model_dimensions(A=base_A_gm, B=base_B_gm)\n", + "\n", + "base_D_gm = utils.obj_array_uniform(num_states)\n", + "base_D_gm[0] = utils.onehot(0, num_states[0])\n", + "\n", + "base_C_gm = utils.obj_array_zeros(num_obs)\n", + "base_C_gm[1] = np.array([0., 3., -3.])\n", + "\n", + "num_actions = 4\n" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "### Note !\n", - "It is not necessary, or even in many cases _important_ , that the generative model is a veridical representation of the generative process. This distinction between generative model (essentially, beliefs entertained by the agent and its interaction with the world) and the generative process (the actual dynamical system 'out there' generating sensations) is of crucial importance to the active inference formalism and (in our experience) often overlooked in code.\n", - "\n", - "It is for notational and computational convenience that we encode the generative process using `A` and `B` matrices. By doing so, it simply puts the rules of the environment in a data structure that can easily be converted into the Markovian-style conditional distributions useful for encoding the agent's generative model.\n", + "num_agents = 50 # number of different agents \n", "\n", - "Strictly speaking, however, all the generative process needs to do is generate observations and be 'perturbable' by actions. The way in which it does so can be arbitrarily complex, non-linear, and unaccessible by the agent." + "# construct all the generative models of all agents by copying the \"base\" generative model\n", + "# we're putting the batch-dimension (here: `num_agents`) in the leading dimension of each modality- or factor-specific sub-array\n", + "A_gm_all = [jnp.broadcast_to(jnp.array(a), (num_agents,) + a.shape) for a in base_A_gm] # map the true observation likelihood to jax arrays\n", + "B_gm_all = [jnp.broadcast_to(jnp.array(b), (num_agents,) + b.shape) for b in base_B_gm] # map the true transition likelihood to jax arrays\n", + "D_gm_all = [jnp.broadcast_to(jnp.array(d), (num_agents,) + d.shape) for d in base_D_gm]\n", + "C_gm_all = [jnp.broadcast_to(jnp.array(c), (num_agents,) + c.shape) for c in base_C_gm]\n", + "E_gm_all = jnp.ones((num_agents, num_actions))" ] }, { @@ -411,68 +166,19 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "controllable_indices = [0] # this is a list of the indices of the hidden state factors that are controllable" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we can construct our agent..." + "controllable_indices = [0] # this is a list of the indices of the hidden state factors that are controllable\n", + "agent = Agent(A_gm_all, B_gm_all, C_gm_all, D_gm_all, E_gm_all, control_fac_idx=controllable_indices)" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, "outputs": [], - "source": [ - "agent = Agent(A_gm, B_gm, C_gm, D_gm, E_gm, control_fac_idx=controllable_indices)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(4, 1, 2)\n", - "int32\n" - ] - } - ], - "source": [ - "policies = jnp.stack(agent.policies)\n", - "print(policies.shape)\n", - "print(policies.dtype)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "PyTreeDef(CustomNode(Agent[(('A', 'B', 'C', 'D', 'E', 'gamma', 'qs', 'q_pi'), ('num_obs', 'num_modalities', 'num_states', 'num_factors', 'num_controls', 'inference_algo', 'control_fac_idx', 'policy_len', 'policies', 'use_utility', 'use_states_info_gain', 'use_param_info_gain', 'action_selection'), ([4, 3, 2], 3, [4, 2], 2, [4, 1], 'VANILLA', [0], 1, DeviceArray([[[0, 0]],\n", - "\n", - " [[1, 0]],\n", - "\n", - " [[2, 0]],\n", - "\n", - " [[3, 0]]], dtype=int32), True, True, False, 'deterministic'))], [[*, *, *], [*, *], [*, *, *], [*, *], *, *, None, None]))\n" - ] - } - ], "source": [ "import jax.tree_util as jtu\n", "\n", @@ -491,36 +197,19 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": { "scrolled": false }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " === Starting experiment === \n", - " Reward condition: Right, Observation: [CENTER, No reward, Cue Left]\n", - "[Step 0] Action: [Move to RIGHT ARM]\n", - "[Step 0] Observation: [RIGHT ARM, Reward!, Cue Right]\n", - "[Step 1] Action: [Move to CUE LOCATION]\n", - "[Step 1] Observation: [CUE LOCATION, No reward, Cue Right]\n", - "[Step 2] Action: [Move to LEFT ARM]\n", - "[Step 2] Observation: [LEFT ARM, Loss!, Cue Left]\n", - "[Step 3] Action: [Move to CUE LOCATION]\n", - "[Step 3] Observation: [CUE LOCATION, No reward, Cue Right]\n", - "[Step 4] Action: [Move to LEFT ARM]\n", - "[Step 4] Observation: [LEFT ARM, Reward!, Cue Right]\n" - ] - } - ], + "outputs": [], "source": [ "T = 5 # number of timesteps\n", "\n", - "emp_prior = D_gm\n", + "emp_prior = D_gm_all\n", "_obs = env.reset() # reset the environment and get an initial observation\n", - "obs = jnp.broadcast_to(jnp.array(_obs), (num_agents, len(_obs)))\n", + "obs = jnp.broadcast_to(jnp.array(_obs), (num_agents, num_modalities)) # everyone gets the same initial observation\n", + "\n", + "agent_to_show = 1 # which agent to print the messages of over time\n", "\n", "# these are useful for displaying read-outs during the loop over time\n", "reward_conditions = [\"Right\", \"Left\"]\n", @@ -541,7 +230,7 @@ "\n", " measurements[\"actions\"].append( actions )\n", " msg = \"\"\"[Step {}] Action: [Move to {}]\"\"\"\n", - " print(msg.format(t, location_observations[int(actions[0, 0])]))\n", + " print(msg.format(t, location_observations[int(actions[agent_to_show, 0])]))\n", "\n", " obs = []\n", " for a in actions:\n", @@ -550,7 +239,7 @@ " measurements[\"outcomes\"].append(obs)\n", "\n", " msg = \"\"\"[Step {}] Observation: [{}, {}, {}]\"\"\"\n", - " print(msg.format(t, location_observations[obs[0, 0]], reward_observations[obs[0, 1]], cue_observations[obs[0, 2]]))\n", + " print(msg.format(t, location_observations[obs[agent_to_show, 0]], reward_observations[obs[agent_to_show, 1]], cue_observations[obs[agent_to_show, 2]]))\n", " \n", "measurements['actions'] = jnp.stack(measurements['actions']).astype(jnp.int32)\n", "measurements['outcomes'] = jnp.stack(measurements['outcomes'])\n", @@ -559,26 +248,6 @@ "measurements['actions'] = measurements['actions'][None]" ] }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_beliefs(qs[1][0],\"Final posterior beliefs about reward condition\")" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -589,21 +258,9 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(1, 5, 50, 3)\n", - "(1, 5, 50, 2)\n", - "494 ms ± 6.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "172 ms ± 412 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", - "dict_keys(['actions', 'outcomes'])\n" - ] - } - ], + "outputs": [], "source": [ "import numpyro as npyro\n", "from jax import random\n", @@ -624,13 +281,14 @@ "with npyro.handlers.seed(rng_seed=0):\n", " aif_likelihood(Nb, Nt, Na, measurements, agent)\n", "\n", + "pred_samples = Predictive(aif_likelihood, num_samples=11)(rng_key, Nb, Nt, Na, measurements, agent)\n", "%timeit pred_samples = Predictive(aif_likelihood, num_samples=11)(rng_key, Nb, Nt, Na, measurements, agent)\n", "print(pred_samples.keys())" ] }, { "cell_type": "code", - "execution_count": 59, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -645,7 +303,7 @@ " lam = nn.softplus(z[1])\n", " d = nn.sigmoid(z[2])\n", "\n", - " A = lax.stop_gradient([jnp.array(x) for x in list(A_gp)])\n", + " A = lax.stop_gradient([jnp.array(x) for x in list(base_A_gm)])\n", "\n", " middle_matrix1 = jnp.array([[0., 0.], [a, 1-a], [1-a, a]])\n", " middle_matrix2 = jnp.array([[0., 0.], [1-a, a], [a, 1-a]])\n", @@ -666,7 +324,7 @@ "\n", " params = {\n", " 'A': A,\n", - " 'B': lax.stop_gradient([jnp.array(x) for x in list(B_gp)]),\n", + " 'B': lax.stop_gradient([jnp.array(x) for x in list(base_B_gm)]),\n", " 'C': C,\n", " 'D': D,\n", " 'E': E\n", @@ -677,18 +335,9 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "357 ms ± 3.31 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "dict_keys(['a', 'actions', 'd', 'lambda', 'outcomes', 'z'])\n" - ] - } - ], + "outputs": [], "source": [ "def model(data, num_blocks, num_steps, num_agents, num_params=3):\n", " with npyro.plate('agents', num_agents):\n", @@ -714,12 +363,13 @@ " model(measurements, Nb, Nt, Na)\n", "\n", "%timeit pred_samples = Predictive(model, num_samples=11)(rng_key, measurements, Nb, Nt, Na)\n", + "pred_samples = Predictive(model, num_samples=11)(rng_key, measurements, Nb, Nt, Na)\n", "print(pred_samples.keys())" ] }, { "cell_type": "code", - "execution_count": 62, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -738,20 +388,9 @@ }, { "cell_type": "code", - "execution_count": 83, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import arviz as az\n", "az.style.use('arviz-darkgrid')\n", @@ -773,11 +412,11 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# inferenace with SVI and autoguides\n", + "# inference with SVI and autoguides\n", "import optax\n", "from numpyro.infer import SVI, Trace_ELBO, Predictive\n", "from numpyro.infer.autoguide import AutoMultivariateNormal\n", @@ -792,20 +431,9 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.figure(figsize=(16,5))\n", "plt.plot(svi_res.losses)\n", @@ -815,7 +443,7 @@ }, { "cell_type": "code", - "execution_count": 81, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -837,20 +465,9 @@ }, { "cell_type": "code", - "execution_count": 85, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAB9sAAAJjCAYAAACsvnHyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABRxUlEQVR4nO3dd5xV9Z0//tcMvQkj9tGI7gprwQaCBWNEMYIaW7Ka2I3RqFk1muImq0ZN3diiSYxGY4Iag3XtJpZAFhsKdtQIayWoqDCKlIGZ+/vDL/NzMiAcmJnLlefz8eDxmPmc9j4D73u487qfc6pKpVIpAAAAAAAAAMAyqy53AQAAAAAAAABQaYTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAANBGpk+fnnPOOSe77757tthiiwwdOjRf/epXM3bs2EL7ufbaazNgwIAMGDAg3//+95e7nmeffTYnnXRSdtxxxwwcODDDhw/Pueeem3fffXeJ2/zhD3/IiBEjssUWW2SPPfbItddeu8R133rrrQwaNChHH330cte46DwfffTRT1xv+PDhGTBgQG6++eZm4zfffHPTPhb9WfSzHzVqVE477bSMGTMms2fPXuK+H3300aZtAQAAYEmE7QAAANAGnn766ey333659tprM2/evHz2s5/Nv/zLv+TRRx/Ncccdl4svvniZ9vP666/nvPPOS1VV1QrVc8899+Sggw7Kn//856y33nrZbbfdUl1dnWuuuSZf+MIX8uqrr7bY5pprrsmPf/zjzJ07N5/73OcyZ86cnHPOOfnd73632GOcc845aWhoyNlnn71CtbaG7t27Z//998/++++fUaNGZdttt02HDh1y11135cwzz8zOO++c0aNHp1QqlbtUAAAAKlTHchcAAAAAnzbz58/PSSedlFmzZmXUqFH5yU9+kq5duyb5KIT/2te+ll/96lcZNGhQdtpppyXup7GxMaeffnqSZL/99sstt9yyXPW89dZbOf3007Nw4cKcc845Oeigg5IkDQ0NOf3003PbbbfltNNOyw033NAU6jc0NOSXv/xlampqctttt2X11VfPu+++m1GjRuXSSy/NYYcdlk6dOjUd49577819992Xb3/729lggw2Wq87WVFNTk5/+9Kctxt9+++1cccUVGT16dH70ox/lzTffzHe+850yVAgAAEClM7MdAAAAWtm9996b6dOnZ7XVVsvZZ5/dFLQnyZZbbpkTTzwxSfKrX/3qE/czevToPP744/nWt76V2tra5a7nD3/4Q+bOnZsdd9yxKWhPkg4dOuQHP/hBevXqlWeeeSbjx49vWjZt2rTMnDkzI0aMyOqrr54k6du3b0aMGJH3338/U6dObVp39uzZOffcc7PpppvmyCOPXO4628Naa62V733veznjjDOSJFdeeWUef/zxMlcFAABAJRK2AwAAQCt75plnkiSbb755VltttRbLd9xxxyTJpEmTMmPGjMXu4//+7/9y4YUXZsiQIfnKV76yQvXcd999SZK99967xbIePXpk+PDhST76kMAis2bNSpL07t272fp9+vRJksyZM6dp7IILLsg777yTc889Nx07VsZN9A455JAMHDgwSXLFFVeUuRoAAAAqkbAdAAAAWtmiIHpRMP3PampqkiSlUimTJ09usXzR7d2rqqryox/9aIWe1z579uym57FvscUWi11n0fjHa1k0k/7jM9g//v3aa6+dJHnyySdz3XXX5bDDDmsKryvFF77whSTJo48+moULF5a5GgAAACqNsB0AAABa2aLbrr/++uuLXf7x8TfeeKPF8iuvvDJPPfVUTjnllHzmM59ZoVqmTZvW9PV666232HXWXXfdFrX07ds322yzTcaNG5c777wzs2fPzh133JFx48ZlwIABqa2tzYIFC3LGGWdk3XXXzcknn7xCdZbD5ptvnuSjD0f84x//KHM1AAAAVJrKuLcbAAAAVJDtt98+v/nNb/Lcc89l8uTJ2WyzzZot/9Of/tT09ezZs5st+/vf/56LL74422yzTQ4//PAVruXDDz9s+rpbt26LXad79+6LreX73/9+Dj/88Jx66qlNYz179swPf/jDJMnvfve7/P3vf8/ll1/etI8kmTdvXrp06bJCM/Jb49yXZtEdBpKPbpu/oh9sAAAAYNUibAcAAIBWtsMOO2S77bbLY489luOPPz5nnXVWtttuu8yaNSt//OMf8z//8z/p1KlTFixY0CyQXrhwYU4//fRUV1fnxz/+caqry3tDuoEDB+aOO+7ILbfckrfeeivrrrtu9t9//6y77rp57bXX8utf/zp77713dtlllyTJ1VdfnSuuuCJvvvlmunbtmt133z3/9V//1SzUXlbDhg3LmmuuucTlf/7zn5s9N355lEqlFdoeAACAVZuwHQAAANrAL37xi3zjG9/IpEmTcvzxxzdbdsQRR2TixIl59tlnmz3XfdFs+G9961vZeOONW6WOHj16NH09d+7c9OrVq8U6i0Lrnj17tlhWW1ubb3zjGy3GzzzzzHTt2jXf+973kiSjR4/Oj370o+y2224544wzMnXq1FxyySV59dVXc/311xf+4MCxxx6boUOHLnH5hAkTVjhsnzlzZtPXH/97AAAAgGUhbAcAAIA20Ldv3/zxj3/MQw89lEceeSSzZs1K3759s9tuu2XgwIEZNmxYkqR///5N29x7771Jkr/+9a/529/+1mx/i569Pm7cuBx22GFJPppJvjS1tbVNX//jH//IgAEDWqwzffr0Fut+kltuuSUPP/xwfvzjH6dv375Jkssvvzy1tbW5+OKL07Fjx+y+++754IMP8tvf/jYPPfRQ0/muTJ577rkkH30gYVnPHQAAABYRtgMAAEAbqaqqyk477ZSddtqp2fhrr72WGTNmpE+fPi2e554kEydOXOI+Z8yYkRkzZixzDT179syGG26YV199Nc8+++xiw/Znn302SbL55psvdX/vvfdefvrTn2bo0KE58MADkyTvvPNOZsyYkc9//vPp2PH//1XDoEGD8tvf/jbPP//8Shm233777UmS7bffPh06dChzNQAAAFSa8j78DQAAAFZBV155ZZLkoIMOSufOnZvGb7311rz44ouL/bPoVu5f/OIXm8aW1e67754kueOOO1os+/DDD/PXv/41STJixIil7uunP/1p5s6dm3POOadpbNFz5+fOndts3UXff/y59CuLa6+9Ns8880yS5JhjjilzNQAAAFQiYTsAAAC0gSlTpmT27NnNxhYuXJjf/OY3GTNmTDbccMN8/etfb7Xj3Xvvvdlzzz1zxBFHtFh2xBFHpFu3bnnooYdy/fXXN403NDTk7LPPzvvvv9/s1vZL8tBDD+XWW2/NCSeckH79+jWN9+3bN+uss04effTRvPbaa037vummm5Is24z59jJjxoz85Cc/ybnnnpskOe6447LtttuWuSoAAAAqkdvIAwAAQBsYM2ZMxowZk8033zxrr7126uvr89RTT+Wdd97JhhtumN/97nfp3r17qx3vgw8+yMsvv5z6+voWy9Zee+385Cc/yWmnnZYzzjgjN954Y2pra/PMM8/k9ddfzxprrJHzzz//E2egz5s3L2eddVb69++fr371qy2Wn3DCCTnzzDNz4IEHZujQoXnllVfy0ksvZdttt83222/faue5rGbOnJnTTz89SdLY2JgPP/wwr732WqZMmZLGxsZ07949p512Wg455JB2rw0AAIBPB2E7AAAAtIFddtkl06ZNy+TJk/Pss8+mc+fO2WijjXLUUUfl0EMPTdeuXdu1npEjR2aDDTbIZZddlscffzyTJ0/OWmutlUMOOSQnnHBC1lhjjU/c/le/+lXeeOON/OlPf0qnTp1aLD/ooIPSqVOn/O53v8vYsWPTq1evHHTQQfn2t79dltvIz5kzJ7fcckuSpFOnTunRo0f69u2bkSNHZujQodlrr73Ss2fPdq8LAACAT4+qUqlUKncRAAAAAAAAAFBJPLMdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICCOpa7gE+7mTNnttuxevfunbq6unY7HtB69C9UNj0MlU0PQ+XSv1DZ9DBUNj0MlUv/wrKpqalZ6jpmtn+KVFf764RKpX+hsulhqGx6GCqX/oXKpoehsulhqFz6F1qPbgIAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAKAsfvvb32b77bfPxIkTy11KYcJ2AAAAAAAAACioY7kLAAAAAAAAAGDV9KUvfSkjRozIOuusU+5SChO2AwAAAAAAAFAWffr0SZ8+fcpdxnJxG3kAAAAAAAAAlskDDzyQ448/PiNHjsxnP/vZ7L333vnGN76RBx54INOnT88OO+yQE088cbHbLly4MJ///OfzhS98IY2NjUkq+5ntZrYDAAAAAAAArKhSKVk4t9xVLFnHbklV1Qrt4qabbsrPf/7zrLHGGtlll13Su3fvvPvuu5k8eXLGjRuX4cOHZ+utt84TTzyRt99+O2uttVaz7R966KHU1dXlsMMOS3V15c8LF7YDAAAAAAAArIhSKd3GHJIO/3ii3JUsUcN622buQdesUOB+2223pVOnThk9enRWX331Zsvq6uqSJCNHjswTTzyRP//5zznssMOarXP33Xc3rfNpUPkfFwAAAAAAAAAouxWbNV4pOnbsmI4dW87p7t27d5Jk+PDh6dKlS+65555myz/44IM8+OCD6d+/fzbeeON2qbWtmdkOAAAAAAAAsCKqqj6aNf4pv438iBEj8stf/jKHHHJI9thjjwwaNChbbbVVevTo0bROz549M2zYsNx///156aWXsskmmyRJ7r///tTX12fPPfdcoRpWJsJ2AAAAAAAAgBVVVZV06l7uKtrUIYcckt69e+fmm2/OH//4x1x77bXp0KFDdtppp5xyyilZb731knx0m/j7778/99xzT1PYfs8996RDhw75/Oc/X85TaFXCdgAAAAAAAACWqqqqKvvss0/22Wef1NXV5cknn8xf/vKX3H///Xn99ddzzTXXpEOHDtl+++1TU1OTv/zlLznxxBPz5ptv5qmnnsrQoUPTt2/fcp9GqxG2AwAAAAAAAFBI7969s8suu2SXXXZJXV1dHn/88bzxxhvZcMMN07Fjx+y+++654YYbMnHixDz77LMplUqfqlntSVJd7gIAAAAAAAAAWPlNnDgxpVKp2djChQvz/vvvJ0k6d+7cND5y5Mgkyd1335177rkn3bp1y+c+97l2q7U9mNkOAAAAAAAAwFJ997vfTY8ePbLFFltknXXWycKFCzNhwoS8/PLLGT58eNZdd92mdTfbbLNsuOGG+ctf/pKFCxdm5MiR6datWxmrb33CdgAAAAAAAACW6vjjj88jjzyS5557LuPHj0/Xrl1TW1ub73znO/nCF77QYv0999wzl112WdPXnzZVpX+e50+rmjlzZrsdq6ampl2PB7Qe/QuVTQ9DZdPDULn0L1Q2PQyVTQ9D5dK/sGxqamqWuo5ntgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAKwUjj/++Gy//fblLmOZCNsBAAAAAAAAoCBhOwAAAAAAAAAU1LHcBQAAAAAAAABQGSZOnJgTTzwxX/3qVzNs2LD8+te/znPPPZeqqqoMHjw4J598ctZbb70kyT/+8Y8ccMABGTVqVM4888wW+9p+++2zzTbb5NJLL236/uPLFvn49hMnTszVV1+dKVOmpK6uLj179sxnPvOZjBw5Mvvtt18bnnlLwnYAAAAAAACAFVQqlTJvXrmrWLKuXZOqqqpW29/zzz+fa665JoMGDcp+++2Xv//97xk3blymTp2aa6+9Nl26dCm8z69+9au588478+abb+arX/1q03j//v2TJA8++GC+9a1vpVevXtl5552zxhprZObMmZkyZUruvvtuYTsAAAAAAABAJSmVSjnhP0p55tlyV7JkA7dIfn1J6wXuDz30UM4999yMGDGiaezss8/O3Xffnb/97W/NxpfV1772tUyaNClvvvlmvva1r7VYfvvtt6dUKuVXv/pVNtlkk2bL6urqip/ECvLMdgAAAAAAAAAK2WabbVoE6nvvvXeSZPLkyW167MXNmu/du3ebHnNxzGwHAAAAAAAAWAFVVVX59SVZpW4jP2DAgBZja621VpJk9uzZrXacjxsxYkTGjh2bY445JnvssUcGDx6crbfeOn369GmT4y2NsB0AAAAAAABgBVVVVaVbt3JX0X569OjRYqxDhw5JkoaGhjY55m677ZZOnTrluuuuyy233JIbb7wxVVVVGTRoUE466aSmZ7u3F2E7AAAAAAAAAK2uuvqjp5ovLnxf3tnvn/3sZ/PZz342H374YZ5++umMHTs2t99+e0455ZSMGTMmvXr1WqGaixC2AwAAAAAAANDqFgXfM2bMaLHsxRdfXOw2H58dv+jrxenRo0d22GGH7LDDDmlsbMztt9+e5557Lttvv30rVL5sqtvtSAAAAAAAAACsMnr06JENN9wwTz31VF5//fWm8Q8//DCXXnrpYrdZbbXVkiRvvfVWi2VPPPHEYmfJv/fee0mSzp07t0bZy8zMdgAAAAAAAADaxJe//OX89Kc/zde+9rUMHz48pVIpDz/8cDbddNPFrj9o0KA88MAD+c///M/ssMMO6dy5czbZZJPsvPPOueCCC/LOO+9kyy23zLrrrpuqqqo89dRTmTx5crbYYotstdVW7XpuwnYAAAAAAAAA2sR+++2XhQsXZsyYMbntttuyxhprZK+99spRRx2VYcOGtVh/3333zfTp03Pffffl6quvTkNDQ0aNGpWdd945hx9+eMaOHZsXX3wxjz76aDp27Jh11103J554Yg488MBPvO18W6gqlUqldj3iKmbmzJntdqyampp2PR7QevQvVDY9DJVND0Pl0r9Q2fQwVDY9DJVL/8KyqampWeo6ntkOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABTUsdwFAABUopdfKWXatKS2NqmpKXc1AAAAAAC0N2E7ACSZOatU7hKoEHXvl3Le+cmTT/3/Y4MH1eWUkxvTe7Wq8hVGxarp498NAAAAAFQiYTusIubOFSSuzLp0Kfk7KrN99vPzZ9lUVyc9eiTn/KAqWw1Mnnom+fn5C3P4kUljo39HFHfv3eWuANfhFdOtmw+MAAAAAKsmYTusIkaM9Avkldt75S4AWEaNjcm3T6vK8M99FC4N/1xSKiVnne11luXjGr0ycB1eEePHCtsBAACAVVN1uQsAAKg0Ww1s/v3WW5anDgAAAAAAysfMdlhF3Hu3GUcrsz59ajJr1sxyl7FKM7OUIp565qMZ7Ys8+XTZSuFTwDW6/FyHAQAAAFgewnZYRXiW5sqte/eqzJ/v76icbv+fcldApTjjrFIuuKiUUumjGe1PPp1c+ItStt4qOfdsfUxxrtHl5zoMAAAAwPIQtgNAkpo+QhaWzQ/PTs7+YanZM9p32L5jvn96Q/r4dwQAAAAAsMoQtgMAFNCnT1UuPK8qL79SyrRpSW1tsu02vTNzpltQAwAAAACsSoTtAADLYaN+VdmoX7mrAAAAAACgXKrLXQAAAAAAAAAAVBphOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2L4C3njjjQwYMCCnn356uUsBAAAAAAAAoB0J2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTty6ChoSGXX355RowYkYEDB2bEiBG57LLLUiqVyl0aAAAAAAAAAGXQsdwFVIIzzjgjN910U9Zff/0ccsghmT9/fq666qo88cQT5S4NAAAAAAAAgDIQti/Fo48+mptuuin/9m//luuuuy7du3dPknz961/PvvvuW+bqAAAAAAAAACgHt5Ffiv/5n/9Jkpx44olNQXuSrL322jn88MPLVBUAAAAAAAAA5SRsX4oXX3wxSTJ48OAWyxY3BgAAAAAAAMCnn7B9KT744INUV1enpqamxbK+ffuWoSIAAAAAAAAAyk3YvhS9evVKY2NjZs6c2WLZu+++W4aKAAAAAAAAACg3YftSDBgwIEny+OOPt1i2uDEAAAAAAAAAPv2E7Uux7777Jkl+9atfZc6cOU3jb731VkaPHl2usgAAAAAAAAAoo47lLmBlt/322+eAAw7IzTffnH322ScjRoxIfX197rrrrmy99db561//Wu4SAQAAAAAAAGhnwvZl8MMf/jAbbbRRrr/++lxzzTVZZ511ctRRR2XkyJHCdgAAAAAAAIBVkLB9GXTo0CHHHntsjj322BbLXnzxxTJUBAAAAAAAAEA5eWY7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFdSx3AQAAq6Kqd6eketZraezzmZT6/mu5ywEAAAAAoCBhOwC0tTnvlbsC2lipc0Myp27ZVp47K13vOysdpz3eNLSwdnDm7X520q1P2xRIZem+erkrAAAAAACWgbAdaH8L5pS7gpVOqb6zn8unWM/f7FTuEmhjC5P0XMZ1S1XVSedembv3hWmsHZTqaRPT9d6z0mP0PqkqNbZlmVSI2f8xsdwlrHJch1cynbqXuwIAAACAZSJsB9pdz0sGlbuElU6RoA6obFWlxswd8YM09N8zSdLQf8/ML5XS9c5Ty1wZKwvXyfbnOrxymX3q8+UuAQAAAGCZVJe7AACAVU1jbfMwtWH9wWWqBAAAAACA5WVmO9Du3B63pT59+mTWrFnlLoM2YpYq/6x62sSmme1J0uGNxz9hbVY1rpPtz3UYAAAAgOUhbAfan+dwtlDVuUfSqb7cZdBGZn/9wXKXQBvr06d3Zs2qW6Z1u95+crrcf27qS6U0rD84Hd54PJ0f+GEWrr9d5u19UdsWSmVwnWx3rsMAAAAALA9hOwC0te6rl7sC2lhVj5qkvsMyrTvvCxen613favaM9oUb7ph5o85LutW0VYkAAAAAALQyYTsAQHvqVpN5B16ZqnenpHrWa2ns85mU+v5ruasCAAAAAKAgYTsAQBmU+v5rGoTsAAAAAAAVq7rcBQAAAAAAAABApRG2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICCOpa7gE+7hoaGNDY2tsuxFixYkAULFrTLsYDWpX+hsulhqGx6GCqX/oXKpoehsulhqFz6F1qPsL2NTZs2LfX19e1yrFmzZqWurq5djgW0Lv0LlU0PQ2XTw1C59C9UNj0MlU0PQ+XSv7Bs1lprraWuI2xvY/X19enQoUM6dOjQ5sfq0qVLOnfu3ObHAVqf/oXKpoehsulhqFz6FyqbHobKpoehculfWLqGhoZlWk/Y3g46dOiQTp06tflxOnXq1C7HAVqf/oXKpoehsulhqFz6FyqbHobKpoehculfaD3V5S4AAAAAAAAAACqNsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICCOpa7AAAAgHJ5/Y0OmfxCdXr17JAN1m8odzkAAAAAVBBhOwDA/1P3flVZtgXa3wezq/LbK3pn8vOd/9/IGtls0/p87Zi69OpZKmttQDGuwayo3qt53QcAAJaPsB1W0Lx55a6AT4O58/xbgpXBMcettQJbr8i2QHurrk569EjO+UFVthqYPPVM8vPzO+e0b6+ZxsZyVwcU4xrMirn6qrfKXcIqy3thqGx6GCqX/v106dq13BWs2oTtsIIOO2rtcpfAp4Z/SwDQXhobk2+fVpXhn/toRuzwzyWlUnLW2WY3AqxqvK8vNz9/qGx6GCqX/v20uOE6Hx4tp+pyFwAAAFAOWw1s/v3WW5anDgAAAAAqk5ntsILcbo7W0LtPn9TNmlXuMmCVZ1YTrFqeeuajGe2LPPl02UoBoIy8ry8f74WhsulhqFz6F1qPsB1WkGdh0Bq6dU3m+7cEZXfFZW8v13a9V+uduvfrWrkaoC1dcFGfXHBhp5RK1dl6y4+C9gsvasxmmy7IqafMKnd5wDJyDaY1eF9fPt4LQ2XTw1C59C+0HmE7AMD/03u15XtWc58+SeI5z1BJTjtlVn7xyz456+zOTWNbDlyQk78xK6st52sB0P5cgwEAACgnYTsAALDKWW21Us743sy8/kaHfDC7d3r1rMsG6zeUuywAAAAAKoiwHQAAWGVtsH5D+vRpzKxZgnYAAAAAiqkudwEAAAAAAAAAUGmE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKCgwmH7G2+8kQEDBuT0009vi3oKGzBgQA477LBW2dcll1ySAQMG5NFHH22V/QEAAAAAAADw6WRmOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQUMfW2Mmzzz6bm2++ORMmTMj06dOzYMGCbLjhhtlnn31y1FFHpVOnTs3WHz58eJLk1ltvzXnnnZf7778/s2fPzuabb57vfe972XzzzfPWW2/l5z//eR588MF8+OGHGTx4cM4888z069dvsTW8+eab+e///u88+OCDmTdvXjbddNOcdNJJ2XHHHVusO3369Pz85z/P+PHjs2DBgmy++eY5+eSTF7vf+vr6jBkzJmPHjs2UKVPy7rvvplevXhk0aFBOOOGEbLbZZiv2wwMAAAAAAACg4rTKzPbrr78+9957b/r375+DDjooX/ziF1MqlXL++efn1FNPXew29fX1OeqoozJp0qSMHDkyw4cPz6RJk3LUUUdl6tSpOfjgg/Paa6/lC1/4Qnbcccc8+OCDOe6449LQ0NBiX3V1dfnyl7+cV155JV/60pey11575cUXX8wxxxyT++67r9m6b7/9dg466KDceeedGThwYA477LD07t07Rx11VJ588snF7vvHP/5x6uvrs8suu+TII4/MkCFDMm7cuBx88MF5+umnW+NHCAAAAAAAAEAFaZWZ7V//+tdz1llnpUOHDk1jpVIp3//+93PTTTdl4sSJGTRoULNtZsyYkUGDBuX8889Px44flbHpppvmvPPOy8EHH5wDDjggp59+eqqqqpIkP/jBD3Ldddfl/vvvzx577NFsXy+++GL23nvvnHfeeU3rH3744fniF7+YM844I8OGDUvXrl2TJBdccEHeeuutnHLKKTn++OOb9jFmzJiceeaZLc6td+/eGTt2bNZee+1m4y+99FL+/d//PRdeeGGuuuqq5f3RAQAAAAAAAFCBWmVm+3rrrdcsaE+SqqqqHHLIIUmShx9+eLHbffe7320K2pNk7733TpIsXLgwp5xySlNw/vFlL7zwQov9dOjQIaeeemqz9f/t3/4t++67b957772MGzcuyUez6e+666707ds3Rx99dLN9fOlLX1rsLeo7d+7cImhPkk022SRDhw7NY489lgULFiz2/AAAAAAAAAD4dGqVme319fW59tprc+edd+b//u//MmfOnJRKpablb7/9dottevfunfXWW6/Z2Jprrpkk6devX7p167bYZYvb17rrrpva2toW44MHD86NN96YyZMn5/Of/3xefvnlzJ8/P9tvv326dOnSbN3q6upsu+22eeWVV1rs5/nnn88VV1yRiRMn5p133mkRrs+cOTNrrbVWi+0AAAAAAAAA+HRqlbD9pJNOyl//+tf069cvo0aNSt++fdOxY8e8//77GT16dOrr61ts07Nnz5bF/L9Z7otbtmjm/MKFC1ssW2ONNRZbV9++fZMks2fPTpJ88MEHzcaXtP7HTZo0KUcccUSSZKeddkq/fv3SvXv3VFVV5b777ssLL7yw2PMDAAAAAAAA4NNrhcP2p59+On/9618zbNiwXH755c1uJ//kk09m9OjRK3qIpXrnnXcWO/7uu+8m+f/D+169ejUbX9L6H/eb3/ymaeb+4MGDmy178sknl7dkAAAAAAAAACrYCj+z/fXXX0+SfO5zn2vx3PbHH398RXe/TKZPn55p06a1GF90/M022yxJstFGG6VLly559tlnM3/+/GbrNjY2ZtKkSS328dprr6VPnz4tgva5c+dm8uTJrXUKAAAAAAAAAFSQFQ7bFz13feLEic3GX3rppVx++eUruvtl0tDQkAsuuKDZc+JfeOGF3HrrrVl99dWzyy67JEk6d+6ckSNH5t13383vfve7Zvu44YYbFvu89tra2tTV1eWll15qdryf/exnee+999rmhAAAAAAAAABYqa3wbeS33HLLbLnllrn77rszY8aMbLXVVpk+fXoeeOCB7LLLLvnzn//cGnV+ogEDBmTSpEk58MADs+OOO+a9997L3XffnYaGhpx77rnp2rVr07qnnXZaHn744Vx00UWZOHFiNttss0ydOjXjxo3LsGHDMn78+Gb7PvTQQzN+/Ph85StfyciRI9O5c+dMmDAhb731VoYMGZIJEya0+fkBAAAAAAAAsHJZ4ZntHTp0yGWXXZYDDzwwr732Wq655ppMmTIl3/nOd/Ltb3+7NWpcqt69e+e6667LhhtumBtuuCF33HFHBgwYkCuuuCK77757s3XXWmut/OlPf8qoUaPy1FNPZfTo0Zk1a1auuuqqbL311i32veuuu+biiy/OBhtskNtuuy133HFHNt5449x4442pra1tl/MDAAAAAAAAYOVSVfr4vddpdY899lg6d+6cTp06tfmx+vTpk1mzZrX5cYDWp3+hsulhqGx6GCqX/oXKpoehsulhqFz6F5ZuwYIF2WqrrZa63grPbAcAAAAAAACAVY2wHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABTUsdwFAAAArIw6172STh9My4Jetanv3a/c5QAAAACwkhG2AwAsRYd5sz5xedXcUjrMq2ufYoBW9889XD3//az9+IXp9vZTTWNz19oqbw3+Zhq7rFaOEoElcA2uHA1d+5S7BAAAgFYnbIeVQNXCueUugXJb0MW/A1iJbXzLAUtdZ412qANoOx/v4VJVddK5V+bufWEaaweletrEdL33rGx499GpKjWWrUZg8VyDK8OUL91Z7hJYGXkvDJVND1NAqWO3cpcA0CaE7bAS+Ncb9ip3CawE1ix3AQBAkqSq1Ji5I36Qhv57Jkka+u+Z+aVSut55apkrA6hc3veyJN4LQ2XTwyyrl778QLlLAGgT1eUuAAAAYGXTWDuo2fcN6w8uUyUAAAAArKzMbIeVgNvp0bt3n9TVzSp3GcASmIkFq57qaRObZrYnSYc3Hi9jNQCVz/teFsd7YahsehgAhO2wUvC8GtKpW0od55e7CmAJ/m//mz9x+Wq9e+f9urp2qgZobf/cw+s+eHa63H9O6kulNKw/OB3eeDydHzg3c9faKtN3OquMlQL/zDW4cnjfy2J5LwyVTQ8DgLAdAGBpGrr2+cTlpW590jC/qn2KAVrdP/fwP4b9IOs+9KN0/9gz2uesMzjTd/x+Grv0LkeJwBK4BgMAAFBOwnYAAICPaezSO9N2/e90rnslnT6YlgW9alPfu1+5ywIAAABgJSNsBwAAWIz63v2E7AAAAAAsUXW5CwAAAAAAAACASiNsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoKCO5S5gVdDQ0NAux1mwYEEWLFjQLscCWpf+hcqmh6Gy6WGoXPoXKpsehsqmh6Fy6V9YumXNd4Xtbaxz586pr69vl8B9/vz5qa+vb/PjAK1P/0Jl08NQ2fQwVC79C5VND0Nl08NQufQvtB5hexurra1NY2NjuxyrpqYmM2fObJdjAa1L/0Jl08NQ2fQwVC79C5VND0Nl08NQufQvtB5hexvr0KFDOnTo0C7H6tSpUzp16tQuxwJal/6FyqaHobLpYahc+hcqmx6GyqaHoXLpX2g91eUuAAAAAAAAAAAqjbAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABTUsdwFAMA/e/mVUqZNS2prk436VZW7HAAAAAAAgBaE7QDtaOas0mLHS6XGzKpb/LJVSd37pZx3fvLkU///2NZblfKt05Leqwnd/1lNHz8TAAAAAAAoF2E7FWvuXMEklWef/Zb073Zmu9axsqquTnr0SM75QVW2Gpg89Uzy8/NLOfzIpLFRz/+ze+8udwUs0qVLqdWvS926+TAFAAAAAMDKTNhOxRoxUvAGnzaNjcm3T6vK8M99FDIO/1xSKiVnna3fF8fr4MrkvVbf4/ixwnYAAAAAgJVZdbkLAICP22pg8++33rI8dQAAAAAAAHwSM9upWPfebcYflcdM5KV76pmPZrQv8uTTZStlped1cOXRp09NZs3yOAgAAAAAgFWJsJ2K5Vm2VKLb/2fx431698msulntWcpK6YyzSrngolJKpY9mtD/5dHLhL0rZeqvk3LP1/D/zOrjy6N69KvPn+/sAAAAAAFiVCNsB2lFNn8WHcTU11amqEtT98Ozk7B+Wmj2jfbvByVn/VZU+S/jZAQAAAAAAlIOwHYCVRp8+VbnwvKq8/Eop06YltbXJRv2E7AAAAAAAwMpH2A7ASmejflXZqF+5qwAAAAAAAFiy6nIXAAAAAAAAAACVRtgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoKCO5S5gZVdfX58xY8Zk7NixmTJlSt5999306tUrgwYNygknnJDNNtus3CUCAAAAAAAA0M7MbF+Kurq6/PjHP059fX122WWXHHnkkRkyZEjGjRuXgw8+OE8//XS5SwQAAAAAAACgnZnZvhS9e/fO2LFjs/baazcbf+mll/Lv//7vufDCC3PVVVeVqToAAAAAAAAAysHM9qXo3Llzi6A9STbZZJMMHTo0jz32WBYsWFCGygAAAAAAAAAoFzPbl8Hzzz+fK664IhMnTsw777zTIlyfOXNm1lprrTJVBwAAAAAAAEB7E7YvxaRJk3LEEUckSXbaaaf069cv3bt3T1VVVe6777688MILqa+vL3OVAAAAAAAAALQnYftS/OY3v0l9fX2uvfbaDB48uNmyJ598sjxFAQAAAAAAAFBWntm+FK+99lr69OnTImifO3duJk+eXKaqAAAAAAAAACgnYftS1NbWpq6uLi+99FLTWENDQ372s5/lvffeK2NlAAAAAAAAAJSL28gvxaGHHprx48fnK1/5SkaOHJnOnTtnwoQJeeuttzJkyJBMmDCh3CUCAAAAAAAA0M7MbF+KXXfdNRdffHE22GCD3Hbbbbnjjjuy8cYb58Ybb0xtbW25ywMAAAAAAACgDKpKpVKp3EV8ms2cObPdjlVTU9OuxwNaj/6FyqaHobLpYahc+hcqmx6GyqaHoXLpX1g2NTU1S13HzHYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAArqWO4CAKh8Ve9OSfWs19LY5zMp9f3XcpcDAAAAAADQ5oTtAMtiznttuvtS54ZkTl2bHqNNzJ2VrvedlY7THm8aWlg7OPN2Pzvp1qd8dVWy7quXuwIAAAAAAGAZCNuhnBbMKXcFLKOev9mpTfe/MEnPNj1C2yhVVSede2Xu3hemsXZQqqdNTNd7z0qP0fukqtRY7vIq0uz/mFjuElgOpfrOK89reqfu5a4AAAAAAGCVIGyHMup5yaBylwArpKrUmLkjfpCG/nsmSRr675n5pVK63nlqmSurXF4XKtPK9IGZ2ac+X+4SAAAAAABWCdXlLgCAytZY2zwcblh/cJkqAQAAAAAAaD9mtkMZuV105TDbeMmqp01smtmeJB3eePwT1mZpvC5Upj59+mTWrFnlLgMAAAAAgHYkbIdy8lzdijH76w+26f779OmdWbPq2vQYbaHr7Seny/3npr5USsP6g9PhjcfT+YEfZuH622Xe3heVu7zK5HWhIlV17pF0qi93GQAAAAAAtCNhO8Cy6L56m+6+qkdNUt+hTY/RFuZ94eJ0vetbzZ7RvnDDHTNv1HlJt5oyVgYAAAAAANC2hO0ALL9uNZl34JWpendKqme9lsY+n0mp77+WuyoAAAAAAIA2J2wHYIWV+v5rGoTsAAAAAADAKqS63AUAAAAAAAAAQKURtgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAACqoqlUqlchcBAAAAAAAAAJXEzHYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQUMdyF7Cqe/rpp3PJJZfkiSeeyMKFC9O/f/8ceeSRGTVq1DLvo76+Ppdffnluu+22TJ8+Pb17986uu+6aU045JX379l3sNrfddltGjx6dKVOmpFOnTtl2221z0kknZfPNN2+tU4NVwor0cKlUyt/+9rc88MADmTRpUv7xj39k4cKF2XDDDTNq1KgcddRR6dKlS4vtBgwYsMR97r///vnpT3+6QucEq5IVvQ7ffPPN+c///M8lLh89enSGDh3a6scFVryPhg8fnmnTpn3iOtdee20GDx7c9L1rMLSOW2+9NRMnTsyzzz6bv//971mwYEF+8pOf5IADDii0n8bGxlx77bW5/vrr8+qrr6Z79+7Zcccd881vfjMbbLDBYrf53//931x22WV57rnnUlVVlc033zwnnHBCdthhh9Y4NfjUa43+ffzxx3PfffdlwoQJmTZtWubMmZPa2trstttuOe6447Laaqu12OaTrttDhgzJ1VdfvdznBKuS1ujhRx99NIcffvgSly9pfy+//HIuuuiiPPLII5k7d2769euXgw8+OF/+8pdTVVW1XOcDq5rW6OHDDjssEyZM+MR1fvazn2W//fZr+t51GD6ZsL2MHnnkkRxzzDHp3Llz9tprr/To0SN/+ctf8s1vfjNvvvlmjj766KXuo7GxMccff3zGjx+frbfeOnvssUdeffXV3HDDDXn44Ydz/fXXZ/XVV2+2zaWXXpqLLrootbW1Ofjgg/Phhx/mzjvvzMEHH5zf//73GTRoUFudMnyqrGgP19fX59hjj03nzp0zZMiQDBs2LPX19Rk/fnwuvPDC3Hfffbn66qvTrVu3FtvW1tZm//33bzG+6aabttr5wadda1yHF9ltt90W23+1tbVtelxYVbVGHx1++OH54IMPWozPnDkz1157bXr37p2BAwe2WO4aDCvuF7/4RaZNm5aampqstdZaS/3gy5KceeaZueGGG7LJJpvksMMOy9tvv5277747Dz74YMaMGZN+/fo1W//WW2/Nd77znay++upNv5C86667ctRRR+Wiiy7KnnvuuaKnBp96rdG/J598cmbOnJlBgwZl3333TVVVVSZMmJArrrgif/7zn/OnP/0pa6yxRovtevXqlSOOOKLF+OL+zw0sXmtdg5OPArYhQ4a0GF/c/4unTJmSgw8+OPPmzcvIkSOz1lprZdy4cTn77LMzderUnHHGGctdB6xKWqOH999//8X27sKFC3PZZZelurp6sR9EdR2GT1CiLBYsWFDafffdS1tssUVp8uTJTePvv/9+aY899ihtvvnmpTfeeGOp+7nxxhtL/fv3L5166qmlxsbGpvE//vGPpf79+5fOOOOMZuu//PLLpc0226y0xx57lN5///2m8cmTJ5e22GKL0siRI0sNDQ2tcIbw6dYaPVxfX1/69a9/XZo1a1aL8eOOO67Uv3//0m9/+9sW2/Xv37906KGHts6JwCqqta7DN910U6l///6lm266qV2PC6uytu6jK6+8stS/f//Sueee22KZazC0jgcffLCpTy+77LJC19JFHn744VL//v1LhxxySGn+/PlN42PHji3179+/dPTRRzdbf9asWaXBgweXhg4dWpo+fXrT+PTp00tDhw4tDR06tPTBBx+swFnBqqE1+veyyy4rvfnmm83GGhsbS2eddVapf//+pR/84Actttl1111Lu+666/IXDpRKpdbp4UceeaTUv3//0sUXX7zM2xxyyCGl/v37l8aOHds0Nn/+/NJXvvKVUv/+/UuTJk0qVAOsqlqjh5fknnvuKfXv37903HHHtVjmOgyfzDPby+SRRx7Ja6+9lr333rvZp/169eqVr3/961mwYEFuueWWpe7nhhtuSJKceuqpzW63c/DBB2eDDTbI7bffnnnz5jWN33zzzVm4cGGOP/749OrVq2l80003zd57752pU6dm4sSJrXGK8KnWGj3cqVOnHH/88endu3eL8eOOOy5J8thjj7V+8UCrXYcr5bjwadLWfXTjjTcmSb74xS+ucK3A4u24444rPANm0Xvhk08+OZ07d24a32WXXTJkyJCMHz8+//jHP5rG77nnnrz//vs59NBDs8466zSNr7POOjn00EMzc+bM3HfffStUE6wKWqN/jz322Ky99trNxqqqqnLCCSck8T4Y2lJr9HBRL7/8ch577LEMHTo0u+yyS9N4586dc/LJJydJrr/++natCSpVW/aw98Kw/NxGvkwWPRNj2LBhLZYtGlvam4v58+fnqaeeykYbbdTiBbaqqio77rhjxowZk2effbbpWZOLjrvTTjst9rg333xzJkyYkO222674ScEqpDV6+JN07PjRy3OHDh0Wu/z999/PmDFjMnPmzPTu3TvbbrvtJz5HFmiutXt48uTJmTVrVhYuXJj1118/O+ywQ2pqatr8uLAqass+mjRpUqZOnZotttgi//Zv/7bYdVyDYeXw6KOPpnv37tl2221bLNt5550zYcKETJgwoelZk0t77bjkkkuarQ+0v6W9D66vr8/NN9+ct99+Oz179szAgQOz1VZbtWeJwMe88sor+f3vf5/58+dn7bXXzg477NDigzTJJ1+DBw0alO7du3sfDGX25ptvZvz48VlzzTXzuc99brHruA7Dkgnby+SVV15Jkmy44YYtlq255prp3r17Xn311U/cx2uvvZbGxsYWz6FbZNH4K6+80hS2v/LKK+nevXvWXHPNFusvqmVpxwVap4c/yU033ZRk8R+MSZIXXnghZ555ZrOxnXfeOT/72c/St2/f5T4urCpau4evvvrqZt937do1J554Yo499tg2PS6sitqyjxZ9kv9LX/rSEtdxDYbymzNnTmbMmJH+/fsvNpRb3HvbT3rt8F4YVg5Lex88Y8aM/Od//mezsYEDB+aCCy7IZz7zmTavD2jujjvuyB133NH0fceOHXPooYfmO9/5TrPr8yddgzt06JD1118/U6ZMycKFC5s+dAO0r5tuuimNjY3Zf//9l9iHrsOwZK5eZTJ79uwkaXYr94/r2bNnPvjgg0/cx6LlPXv2XOI+Pn6sRV+vvvrqn7j+0o4LtE4PL8m4ceMyZsyY/Mu//Mtif9l/9NFHZ4899ki/fv3SqVOnvPTSS/n1r3+dv/3tbznuuOMyZsyYJc4EAD7SWj28/vrr54wzzsiwYcOyzjrrpK6uLg8//HAuuOCCnH/++enWrVsOO+ywVj8urMraqo8+/PDD3H333enWrVv23nvvxa7jGgwrh2V9L/zx14JPeu3wXhjK7/nnn8+vfvWr9O3bN8ccc0yL5QcccEAGDRqU/v37p3v37nnllVdy1VVX5dZbb82RRx6Z2267bYmvCUDrWn311XPaaadl1113TW1tbebOnZsnnngi559/fn7/+9+nqqoqp59+etP6S/v/e48ePdLY2JgPP/ywxaMWgbZXKpVy8803J1nyLeRdh+GTeWY7wErk6aefzje/+c306tUrv/jFL5o9f3KR7373u9lmm21SU1OTnj17Zptttslll12WIUOG5Jlnnsn9999fhsph1TRkyJAceuih6devX7p27Zq11147++23X6688sp06dIlv/zlL7Nw4cJylwksg7vuuitz5szJnnvuucRfErgGA0Dre/3113PsscemoaEhF1xwwWIniXzjG9/IDjvskL59+6Zbt27ZdNNN89///d/Zd999M23atNxwww1lqBxWTZtsskmOPfbYbLLJJunevXv69u2b3XffPaNHj87qq6+eq6++Ou+++265ywSW0SOPPJI33ngjQ4YMWewdKBLXYVgaYXuZLO2T87Nnz17ip/0WWbT84zPX/3kfHz/Woq8/6Zgf3y+wZK3Rw//smWeeyVe/+tVUV1fniiuuyCabbLLM21ZXVzfNgp80aVKh48KqqC16+OM22WSTDBo0KLNmzcrUqVPb7biwKmirPlp069olfZJ/SVyDof0t63vhj78WfNJrh/fCUD6vv/56Dj/88MycOTMXX3xxtt9++0LbH3TQQUlcg2FlsOaaa2a33XbLwoUL89RTTzWNL+3/7x9++GGqqqrSo0ePdqkTaG7R49SKvhdOXIdhEWF7mSx6nvringk3Y8aMzJkzZ4mfIlpkgw02SHV1ddNzb/7ZovGPP9O9X79+Tc+3+2eLalnacYHW6eGPe+aZZ3L00UensbExV155ZbbccsvCNdXU1CT56BmWwCdr7R5enEU9OXfu3HY9LnzatUUfTZkyJU888UQ23njjDB48uHBNrsHQvrp3754111wzb7zxRhoaGlosX9x720967fBeGMpjUdA+Y8aMXHTRRdl1110L78M1GFYuRd8HNzQ05I033sj666/vee1QBnV1dbn33nuz2mqrZc899yy8veswfETYXibbbbddkmT8+PEtli0aW7TOknTt2jVbbrllXn755UybNq3ZslKplIceeijdu3fPFlts0eK4Dz744BKPO2TIkAJnAqum1ujhRRYF7Q0NDbniiiuy1VZbLVdNiz41vP766y/X9rAqac0eXpyGhoY8++yzSZL11luv3Y4Lq4K26KMV+SR/4hoM5TBkyJDMmTNnsbNo/vd//zdJ89eCZXnt8F4Y2s/Hg/YLL7wwu++++3Lt5+mnn06S1NbWtmZ5wHJa9P/ij/fkJ12DJ06cmDlz5ngfDGVy2223Zf78+dlnn33SpUuXwtu7DsNHhO1lssMOO2SDDTbIHXfckeeff75p/IMPPshvfvObdOrUKfvtt1/T+Ntvv52pU6e2uN3Ov//7vydJLrjggpRKpabxP/3pT3n99dezzz77pGvXrk3jBxxwQDp27JhLL7202b6ef/753HHHHfmXf/mXDBo0qLVPFz51WquHn3322Rx99NFZuHBhfvvb32abbbb5xOO++OKLWbBgQYvxSZMm5YorrkinTp2W61OIsKppzR7+Zw0NDTnvvPPy6quvZujQoVlrrbWW+7hAS63Vv4ssWLAgt95661L7zzUYyuO9997L1KlT89577zUbX/Re+Be/+EXq6+ubxseNG5cJEyZk2LBhzX7pN3LkyPTq1SvXXHNN3nzzzabxN998M9dcc01qamqWO+wDFm9J/bsoaH/77bdzwQUXZMSIEZ+4n6lTpzabJfvx8fPOOy9Jss8++7Re4UCSJffw4t4HJ8kf/vCHPProo+nXr18GDhzYNL7xxhtnu+22y6OPPppx48Y1jdfX1+cXv/hFkjQ9lgloPUvq4Y9blg+euw7D0lWVPp7Q0q4eeeSRHHPMMencuXP22muv9OjRI3/5y18ybdq0fPe7383RRx/dtO7pp5+eW265JT/5yU9ywAEHNI03Njbma1/7WsaPH5+tt9462223XV577bX85S9/SW1tbW644YasvvrqzY576aWX5qKLLkptbW322GOPfPjhh7nzzjuzYMGC/P73vxe2wzJa0R6eNWtW9thjj9TV1WXnnXde7Iz2Xr165cgjj2y2n7Fjx2bQoEFZd91107Fjx7z00kt58MEHU1VVlTPPPDNf/vKX2/zc4dOgNa7DAwYMaPqz9tprp66uLhMmTMgrr7ySddZZJ9dcc0022GCD5T4usHit0b+L/PnPf85JJ52UPfbYI5dccskSj+kaDK3nhhtuyMSJE5Mkf//73/Pcc89l2223bbqN+6BBg5p+6X7JJZfkl7/8Zb7xjW/kP/7jP5rt57/+679yww03ZJNNNskuu+ySGTNm5K677kqPHj3ypz/9KRtttFGz9W+99dZ85zvfyeqrr55Ro0YlSe66667MnDkzF154YUaOHNnWpw4VrzX6d/jw4Zk2bVq23nrrDBs2bLHH+fj6l1xySa666qpst912WW+99dKtW7e88sor+dvf/pYFCxbkuOOOy6mnntpWpwyfKq3Vwx07dswWW2yRtddeO3Pnzs1TTz2VyZMnZ7XVVlvs4xFfeumlfPnLX868efMyatSorLnmmhk3blxeeumlHHrooTnjjDPa6ScAla21/h+dfPTBmQMPPDCbb755br755iUe03UYls6DUMpo++23zx//+MdcfPHFueuuu7Jw4cL0798/3/rWt5re+C9NdXV1Lr300lx++eW59dZb8/vf/z59+vTJF7/4xZxyyiktgvYkOf7441NbW5s//OEPue6669KpU6cMHjw4J598cjbffPPWPk341FrRHp49e3bq6uqSfHSry0W3u/y42traZmH7brvtlvfffz8vvPBCHnrooSxYsCBrrLFG9tprrxxxxBHL9ax3WFW1xnX46KOPzpNPPpmHHnoodXV16dSpUz7zmc/k+OOPz1FHHZXevXu3yXFhVdeafbSst5B3DYbWM3HixNxyyy3NxiZNmtTslvDLMsPtnHPOSf/+/XP99ddn9OjR6d69e0aMGJFvfvOb+cxnPtNi/X333Tc1NTW57LLLmn6huMUWW+T444/PjjvuuIJnBauG1ujfRY9CfPLJJ/Pkk08udp2PhwJDhw7N1KlT8/zzz+fxxx/PvHnzUlNTk89+9rP5yle+ssTAHmipNXr44IMPzvjx4/PYY49l1qxZqa6uznrrrZcjjjgiRx99dNZZZ50W22yyySa5/vrrc9FFF2XcuHGZM2dO+vXrlzPPPDNf+cpXWufkYBXQWv+PTpb9vbDrMCydme0AAAAAAAAAUJBntgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgoP8PHD+WTrZ5KmQAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "axes = az.plot_forest(\n", " [data_mcmc, data_svi],\n", @@ -866,7 +483,7 @@ ], "metadata": { "kernelspec": { - "display_name": "pymdp", + "display_name": "Python 3.10.6 ('pymdp_env3')", "language": "python", "name": "python3" }, @@ -884,7 +501,7 @@ }, "vscode": { "interpreter": { - "hash": "ee9ec9b0986c80b528a0decd8a099ef790c4bc969bd74a31889dfc8308eb58a2" + "hash": "32c08a4ac355ebac62cad37715f1d18a3925a14af2b6a4a96942ab426da83c5e" } } }, From f160848a81614c04f383f3ec471ac93b7cf49589 Mon Sep 17 00:00:00 2001 From: conorheins Date: Sun, 11 Dec 2022 15:54:30 +0100 Subject: [PATCH 030/232] some extra cells to debug weird T-Maze inference (leftover from session with @dimarkov) --- examples/model_inversion.ipynb | 149 +++++++++++++++++++++++++++++++-- 1 file changed, 140 insertions(+), 9 deletions(-) diff --git a/examples/model_inversion.ipynb b/examples/model_inversion.ipynb index 8b1ef878..e3ef1c1c 100644 --- a/examples/model_inversion.ipynb +++ b/examples/model_inversion.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -72,7 +72,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -107,7 +107,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -129,7 +129,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -166,7 +166,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -176,9 +176,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PyTreeDef(CustomNode(Agent[(('A', 'B', 'C', 'D', 'E', 'gamma', 'qs', 'q_pi'), ('num_obs', 'num_modalities', 'num_states', 'num_factors', 'num_controls', 'inference_algo', 'control_fac_idx', 'policy_len', 'policies', 'use_utility', 'use_states_info_gain', 'use_param_info_gain', 'action_selection'), ([4, 3, 2], 3, [4, 2], 2, [4, 1], 'VANILLA', [0], 1, DeviceArray([[[0, 0]],\n", + "\n", + " [[1, 0]],\n", + "\n", + " [[2, 0]],\n", + "\n", + " [[3, 0]]], dtype=int32), True, True, False, 'deterministic'))], [[*, *, *], [*, *], [*, *, *], [*, *], *, *, None, None]))\n" + ] + } + ], "source": [ "import jax.tree_util as jtu\n", "\n", @@ -187,6 +201,112 @@ "print(tree)" ] }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "_obs = env.reset()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "from pymdp.jax.inference import update_posterior_states as jax_update_posterior\n", + "from jax.nn import one_hot\n", + "\n", + "o_vec = [one_hot(o, base_A_gm[i].shape[0]) for i, o in enumerate(_obs)]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "agent_i = 0\n", + "agent_i_A = [a[agent_i] for a in A_gm_all]\n", + "agent_i_D = [d[agent_i] for d in D_gm_all]\n", + "# agent_i_D = [jnp.ones(4)/4., jnp.ones(2)/2.]\n", + "# o_vec[2] = jnp.array([1.0, 0.0])\n", + "test_out = jax_update_posterior(\n", + " agent_i_A,\n", + " o_vec,\n", + " prior=agent_i_D\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from pymdp.jax.maths import compute_log_likelihood,compute_log_likelihood_single_modality, log_stable\n", + "ll = compute_log_likelihood(o_vec, agent_i_A)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "compute_log_likelihood_single_modality(o_vec[2], agent_i_A[2])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "log_likelihood = jnp.zeros((4, 2))\n", + "\n", + "for i in range(3):\n", + "\n", + " o_m, A_m = o_vec[i], agent_i_A[i]\n", + "\n", + " expanded_obs = jnp.expand_dims(o_m, tuple(range(1, A_m.ndim)))\n", + " likelihood = (expanded_obs * A_m).sum(axis=0, keepdims=True).squeeze()\n", + "\n", + " log_likelihood += log_stable(likelihood)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from jax.nn import softmax\n", + "\n", + "softmax((log_likelihood * jnp.ones((1,2))/2.0).sum(1) + log_stable(agent_i_D[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "softmax((log_likelihood * jnp.ones((4,1))/4.0).sum(0) + log_stable(agent_i_D[1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "from pymdp.inference import update_posterior_states as numpy_update_posterior\n", + "test_out_np = numpy_update_posterior(base_A_gm, _obs, prior=base_D_gm)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -219,9 +339,11 @@ "msg = \"\"\" === Starting experiment === \\n Reward condition: {}, Observation: [{}, {}, {}]\"\"\"\n", "print(msg.format(reward_conditions[env.reward_condition], location_observations[_obs[0]], reward_observations[_obs[1]], cue_observations[_obs[2]]))\n", "\n", + "qs_list = []\n", "measurements = {'actions': [], 'outcomes': [obs]}\n", "for t in range(T):\n", " qs = agent.infer_states(obs, emp_prior)\n", + " qs_list.append(qs.copy())\n", "\n", " q_pi, efe = agent.infer_policies(qs)\n", "\n", @@ -243,9 +365,18 @@ " \n", "measurements['actions'] = jnp.stack(measurements['actions']).astype(jnp.int32)\n", "measurements['outcomes'] = jnp.stack(measurements['outcomes'])\n", - "\n", "measurements['outcomes'] = measurements['outcomes'][None, :T]\n", - "measurements['actions'] = measurements['actions'][None]" + "measurements['actions'] = measurements['actions'][None]\n", + "reward_condition_beliefs = jnp.stack([qs_i[1] for qs_i in qs_list])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.imshow(reward_condition_beliefs[0], aspect='auto')" ] }, { From 6d6cf9462a2bfc65bef9dfc47dcfc3e50320941a Mon Sep 17 00:00:00 2001 From: conorheins Date: Sun, 11 Dec 2022 15:54:57 +0100 Subject: [PATCH 031/232] tried increasing epsilon value in MIN_VAL from 1e-32 to 1e-16 -- didn't work in fixing JAX fixed-point iteration :( --- pymdp/jax/maths.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/pymdp/jax/maths.py b/pymdp/jax/maths.py index 1d0c3ecb..0e021936 100644 --- a/pymdp/jax/maths.py +++ b/pymdp/jax/maths.py @@ -1,7 +1,8 @@ from jax import tree_util, nn, jit import jax.numpy as jnp -MIN_VAL = 1e-32 +MIN_VAL = 1e-16 # to debug weird inference with FPI, which we encountered with the T-Maze, try uncommenting this / commenting out the 1e-32 below +# MIN_VAL = 1e-32 def log_stable(x): From 445fe9cce89abc1df9c81e2ec11953bb6d99e34a Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Tue, 13 Dec 2022 18:08:56 +0100 Subject: [PATCH 032/232] fixed fpi error but now gradients true state inference do not work for num_iter > 2 --- examples/model_inversion.ipynb | 340 ++++++++++++++++++++------------- pymdp/jax/agent.py | 7 +- pymdp/jax/algos.py | 3 +- pymdp/jax/inference.py | 4 +- pymdp/jax/maths.py | 3 +- 5 files changed, 221 insertions(+), 136 deletions(-) diff --git a/examples/model_inversion.ipynb b/examples/model_inversion.ipynb index e3ef1c1c..890f0571 100644 --- a/examples/model_inversion.ipynb +++ b/examples/model_inversion.ipynb @@ -72,7 +72,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -107,7 +107,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -129,7 +129,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -166,7 +166,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -176,14 +176,14 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "PyTreeDef(CustomNode(Agent[(('A', 'B', 'C', 'D', 'E', 'gamma', 'qs', 'q_pi'), ('num_obs', 'num_modalities', 'num_states', 'num_factors', 'num_controls', 'inference_algo', 'control_fac_idx', 'policy_len', 'policies', 'use_utility', 'use_states_info_gain', 'use_param_info_gain', 'action_selection'), ([4, 3, 2], 3, [4, 2], 2, [4, 1], 'VANILLA', [0], 1, DeviceArray([[[0, 0]],\n", + "PyTreeDef(CustomNode(Agent[(('A', 'B', 'C', 'D', 'E', 'gamma', 'qs', 'q_pi'), ('num_iter', 'num_obs', 'num_modalities', 'num_states', 'num_factors', 'num_controls', 'inference_algo', 'control_fac_idx', 'policy_len', 'policies', 'use_utility', 'use_states_info_gain', 'use_param_info_gain', 'action_selection'), (16, [4, 3, 2], 3, [4, 2], 2, [4, 1], 'VANILLA', [0], 1, DeviceArray([[[0, 0]],\n", "\n", " [[1, 0]],\n", "\n", @@ -201,112 +201,6 @@ "print(tree)" ] }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "_obs = env.reset()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "from pymdp.jax.inference import update_posterior_states as jax_update_posterior\n", - "from jax.nn import one_hot\n", - "\n", - "o_vec = [one_hot(o, base_A_gm[i].shape[0]) for i, o in enumerate(_obs)]\n" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "agent_i = 0\n", - "agent_i_A = [a[agent_i] for a in A_gm_all]\n", - "agent_i_D = [d[agent_i] for d in D_gm_all]\n", - "# agent_i_D = [jnp.ones(4)/4., jnp.ones(2)/2.]\n", - "# o_vec[2] = jnp.array([1.0, 0.0])\n", - "test_out = jax_update_posterior(\n", - " agent_i_A,\n", - " o_vec,\n", - " prior=agent_i_D\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from pymdp.jax.maths import compute_log_likelihood,compute_log_likelihood_single_modality, log_stable\n", - "ll = compute_log_likelihood(o_vec, agent_i_A)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "compute_log_likelihood_single_modality(o_vec[2], agent_i_A[2])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "log_likelihood = jnp.zeros((4, 2))\n", - "\n", - "for i in range(3):\n", - "\n", - " o_m, A_m = o_vec[i], agent_i_A[i]\n", - "\n", - " expanded_obs = jnp.expand_dims(o_m, tuple(range(1, A_m.ndim)))\n", - " likelihood = (expanded_obs * A_m).sum(axis=0, keepdims=True).squeeze()\n", - "\n", - " log_likelihood += log_stable(likelihood)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from jax.nn import softmax\n", - "\n", - "softmax((log_likelihood * jnp.ones((1,2))/2.0).sum(1) + log_stable(agent_i_D[0]))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "softmax((log_likelihood * jnp.ones((4,1))/4.0).sum(0) + log_stable(agent_i_D[1]))" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [], - "source": [ - "from pymdp.inference import update_posterior_states as numpy_update_posterior\n", - "test_out_np = numpy_update_posterior(base_A_gm, _obs, prior=base_D_gm)" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -317,7 +211,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": { "scrolled": false }, @@ -335,7 +229,112 @@ "reward_conditions = [\"Right\", \"Left\"]\n", "location_observations = ['CENTER','RIGHT ARM','LEFT ARM','CUE LOCATION']\n", "reward_observations = ['No reward','Reward!','Loss!']\n", - "cue_observations = ['Cue Right','Cue Left']\n", + "cue_observations = ['Cue Right','Cue Left']" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DeviceArray([[nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan],\n", + " [nan, nan]], dtype=float32)" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#TODO: understand why gradient returns nans for num_iter > 2\n", + "\n", + "agent = Agent(A_gm_all, B_gm_all, C_gm_all, D_gm_all, E_gm_all, control_fac_idx=controllable_indices, num_iter=3)\n", + "def test(prior):\n", + " loc_prior = [emp_prior[0], prior]\n", + " qs = agent.infer_states(obs, loc_prior)\n", + "\n", + " return jnp.log(qs[1]).sum()\n", + "\n", + "jax.grad(test)(emp_prior[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " === Starting experiment === \n", + " Reward condition: Right, Observation: [CENTER, No reward, Cue Left]\n", + "[Step 0] Action: [Move to CUE LOCATION]\n", + "[Step 0] Observation: [CUE LOCATION, No reward, Cue Right]\n", + "[Step 1] Action: [Move to RIGHT ARM]\n", + "[Step 1] Observation: [RIGHT ARM, Reward!, Cue Right]\n", + "[Step 2] Action: [Move to RIGHT ARM]\n", + "[Step 2] Observation: [RIGHT ARM, Reward!, Cue Left]\n", + "[Step 3] Action: [Move to RIGHT ARM]\n", + "[Step 3] Observation: [RIGHT ARM, Reward!, Cue Left]\n", + "[Step 4] Action: [Move to RIGHT ARM]\n", + "[Step 4] Observation: [RIGHT ARM, Reward!, Cue Left]\n" + ] + } + ], + "source": [ "msg = \"\"\" === Starting experiment === \\n Reward condition: {}, Observation: [{}, {}, {}]\"\"\"\n", "print(msg.format(reward_conditions[env.reward_condition], location_observations[_obs[0]], reward_observations[_obs[1]], cue_observations[_obs[2]]))\n", "\n", @@ -372,11 +371,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "plt.imshow(reward_condition_beliefs[0], aspect='auto')" + "plt.imshow(reward_condition_beliefs[4], aspect='auto')" ] }, { @@ -389,9 +409,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 5, 50, 3)\n", + "(1, 5, 50, 2)\n", + "475 ms ± 7.64 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "497 ms ± 12.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "dict_keys(['actions', 'outcomes'])\n" + ] + } + ], "source": [ "import numpyro as npyro\n", "from jax import random\n", @@ -419,7 +451,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -466,9 +498,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "603 ms ± 8.16 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "dict_keys(['a', 'actions', 'd', 'lambda', 'outcomes', 'z'])\n" + ] + } + ], "source": [ "def model(data, num_blocks, num_steps, num_agents, num_params=3):\n", " with npyro.plate('agents', num_agents):\n", @@ -485,7 +526,8 @@ " params['C'], \n", " params['D'], \n", " params['E'], \n", - " control_fac_idx=controllable_indices\n", + " control_fac_idx=controllable_indices,\n", + " num_iter=2\n", " )\n", "\n", " aif_likelihood(num_blocks, num_steps, num_agents, data, agents)\n", @@ -500,18 +542,35 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "RuntimeError", + "evalue": "Cannot find valid initial parameters. Please check your model again.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn [22], line 11\u001b[0m\n\u001b[1;32m 8\u001b[0m mcmc \u001b[39m=\u001b[39m MCMC(kernel, num_warmup\u001b[39m=\u001b[39m\u001b[39m1000\u001b[39m, num_samples\u001b[39m=\u001b[39m\u001b[39m1000\u001b[39m, progress_bar\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n\u001b[1;32m 10\u001b[0m rng_key, _rng_key \u001b[39m=\u001b[39m random\u001b[39m.\u001b[39msplit(rng_key)\n\u001b[0;32m---> 11\u001b[0m mcmc\u001b[39m.\u001b[39;49mrun(_rng_key, measurements, Nb, Nt, Na)\n", + "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/mcmc.py:593\u001b[0m, in \u001b[0;36mMCMC.run\u001b[0;34m(self, rng_key, extra_fields, init_params, *args, **kwargs)\u001b[0m\n\u001b[1;32m 591\u001b[0m map_args \u001b[39m=\u001b[39m (rng_key, init_state, init_params)\n\u001b[1;32m 592\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mnum_chains \u001b[39m==\u001b[39m \u001b[39m1\u001b[39m:\n\u001b[0;32m--> 593\u001b[0m states_flat, last_state \u001b[39m=\u001b[39m partial_map_fn(map_args)\n\u001b[1;32m 594\u001b[0m states \u001b[39m=\u001b[39m tree_map(\u001b[39mlambda\u001b[39;00m x: x[jnp\u001b[39m.\u001b[39mnewaxis, \u001b[39m.\u001b[39m\u001b[39m.\u001b[39m\u001b[39m.\u001b[39m], states_flat)\n\u001b[1;32m 595\u001b[0m \u001b[39melse\u001b[39;00m:\n", + "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/mcmc.py:381\u001b[0m, in \u001b[0;36mMCMC._single_chain_mcmc\u001b[0;34m(self, init, args, kwargs, collect_fields)\u001b[0m\n\u001b[1;32m 379\u001b[0m rng_key, init_state, init_params \u001b[39m=\u001b[39m init\n\u001b[1;32m 380\u001b[0m \u001b[39mif\u001b[39;00m init_state \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 381\u001b[0m init_state \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msampler\u001b[39m.\u001b[39;49minit(\n\u001b[1;32m 382\u001b[0m rng_key,\n\u001b[1;32m 383\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mnum_warmup,\n\u001b[1;32m 384\u001b[0m init_params,\n\u001b[1;32m 385\u001b[0m model_args\u001b[39m=\u001b[39;49margs,\n\u001b[1;32m 386\u001b[0m model_kwargs\u001b[39m=\u001b[39;49mkwargs,\n\u001b[1;32m 387\u001b[0m )\n\u001b[1;32m 388\u001b[0m sample_fn, postprocess_fn \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_get_cached_fns()\n\u001b[1;32m 389\u001b[0m diagnostics \u001b[39m=\u001b[39m (\n\u001b[1;32m 390\u001b[0m \u001b[39mlambda\u001b[39;00m x: \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msampler\u001b[39m.\u001b[39mget_diagnostics_str(x[\u001b[39m0\u001b[39m])\n\u001b[1;32m 391\u001b[0m \u001b[39mif\u001b[39;00m rng_key\u001b[39m.\u001b[39mndim \u001b[39m==\u001b[39m \u001b[39m1\u001b[39m\n\u001b[1;32m 392\u001b[0m \u001b[39melse\u001b[39;00m \u001b[39m\"\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 393\u001b[0m ) \u001b[39m# noqa: E731\u001b[39;00m\n", + "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/hmc.py:706\u001b[0m, in \u001b[0;36mHMC.init\u001b[0;34m(self, rng_key, num_warmup, init_params, model_args, model_kwargs)\u001b[0m\n\u001b[1;32m 701\u001b[0m \u001b[39m# vectorized\u001b[39;00m\n\u001b[1;32m 702\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 703\u001b[0m rng_key, rng_key_init_model \u001b[39m=\u001b[39m jnp\u001b[39m.\u001b[39mswapaxes(\n\u001b[1;32m 704\u001b[0m vmap(random\u001b[39m.\u001b[39msplit)(rng_key), \u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m\n\u001b[1;32m 705\u001b[0m )\n\u001b[0;32m--> 706\u001b[0m init_params \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_init_state(\n\u001b[1;32m 707\u001b[0m rng_key_init_model, model_args, model_kwargs, init_params\n\u001b[1;32m 708\u001b[0m )\n\u001b[1;32m 709\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_potential_fn \u001b[39mand\u001b[39;00m init_params \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 710\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[1;32m 711\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mValid value of `init_params` must be provided with\u001b[39m\u001b[39m\"\u001b[39m \u001b[39m\"\u001b[39m\u001b[39m `potential_fn`.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 712\u001b[0m )\n", + "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/hmc.py:652\u001b[0m, in \u001b[0;36mHMC._init_state\u001b[0;34m(self, rng_key, model_args, model_kwargs, init_params)\u001b[0m\n\u001b[1;32m 650\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_init_state\u001b[39m(\u001b[39mself\u001b[39m, rng_key, model_args, model_kwargs, init_params):\n\u001b[1;32m 651\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_model \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 652\u001b[0m init_params, potential_fn, postprocess_fn, model_trace \u001b[39m=\u001b[39m initialize_model(\n\u001b[1;32m 653\u001b[0m rng_key,\n\u001b[1;32m 654\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_model,\n\u001b[1;32m 655\u001b[0m dynamic_args\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m,\n\u001b[1;32m 656\u001b[0m init_strategy\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_init_strategy,\n\u001b[1;32m 657\u001b[0m model_args\u001b[39m=\u001b[39;49mmodel_args,\n\u001b[1;32m 658\u001b[0m model_kwargs\u001b[39m=\u001b[39;49mmodel_kwargs,\n\u001b[1;32m 659\u001b[0m forward_mode_differentiation\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_forward_mode_differentiation,\n\u001b[1;32m 660\u001b[0m )\n\u001b[1;32m 661\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_init_fn \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 662\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_init_fn, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_sample_fn \u001b[39m=\u001b[39m hmc(\n\u001b[1;32m 663\u001b[0m potential_fn_gen\u001b[39m=\u001b[39mpotential_fn,\n\u001b[1;32m 664\u001b[0m kinetic_fn\u001b[39m=\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_kinetic_fn,\n\u001b[1;32m 665\u001b[0m algo\u001b[39m=\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_algo,\n\u001b[1;32m 666\u001b[0m )\n", + "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/util.py:698\u001b[0m, in \u001b[0;36minitialize_model\u001b[0;34m(rng_key, model, init_strategy, dynamic_args, model_args, model_kwargs, forward_mode_differentiation, validate_grad)\u001b[0m\n\u001b[1;32m 685\u001b[0m w\u001b[39m.\u001b[39mmessage\u001b[39m.\u001b[39margs \u001b[39m=\u001b[39m (\n\u001b[1;32m 686\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mSite \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m: \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m\"\u001b[39m\u001b[39m.\u001b[39mformat(\n\u001b[1;32m 687\u001b[0m site[\u001b[39m\"\u001b[39m\u001b[39mname\u001b[39m\u001b[39m\"\u001b[39m], w\u001b[39m.\u001b[39mmessage\u001b[39m.\u001b[39margs[\u001b[39m0\u001b[39m]\n\u001b[1;32m 688\u001b[0m ),\n\u001b[1;32m 689\u001b[0m ) \u001b[39m+\u001b[39m w\u001b[39m.\u001b[39mmessage\u001b[39m.\u001b[39margs[\u001b[39m1\u001b[39m:]\n\u001b[1;32m 690\u001b[0m warnings\u001b[39m.\u001b[39mshowwarning(\n\u001b[1;32m 691\u001b[0m w\u001b[39m.\u001b[39mmessage,\n\u001b[1;32m 692\u001b[0m w\u001b[39m.\u001b[39mcategory,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 696\u001b[0m line\u001b[39m=\u001b[39mw\u001b[39m.\u001b[39mline,\n\u001b[1;32m 697\u001b[0m )\n\u001b[0;32m--> 698\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mRuntimeError\u001b[39;00m(\n\u001b[1;32m 699\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mCannot find valid initial parameters. Please check your model again.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 700\u001b[0m )\n\u001b[1;32m 701\u001b[0m \u001b[39mreturn\u001b[39;00m ModelInfo(\n\u001b[1;32m 702\u001b[0m ParamInfo(init_params, pe, grad), potential_fn, postprocess_fn, model_trace\n\u001b[1;32m 703\u001b[0m )\n", + "\u001b[0;31mRuntimeError\u001b[0m: Cannot find valid initial parameters. Please check your model again." + ] + } + ], "source": [ "# inference with NUTS and MCMC\n", "from numpyro.infer import NUTS, MCMC\n", - "from numpyro.infer import init_to_feasible, init_to_sample\n", + "from numpyro.infer import init_to_feasible, init_to_sample, init_to_median\n", "\n", "rng_key = random.PRNGKey(0)\n", - "kernel = NUTS(model, init_strategy=init_to_feasible)\n", + "kernel = NUTS(model, init_strategy=init_to_median)\n", "\n", - "mcmc = MCMC(kernel, num_warmup=1000, num_samples=1000, progress_bar=False)\n", + "mcmc = MCMC(kernel, num_warmup=1000, num_samples=1000, progress_bar=True)\n", "\n", "rng_key, _rng_key = random.split(rng_key)\n", "mcmc.run(_rng_key, measurements, Nb, Nt, Na)" @@ -545,7 +604,28 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "RuntimeError", + "evalue": "Cannot find valid initial parameters. Please check your model again.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn [36], line 11\u001b[0m\n\u001b[1;32m 9\u001b[0m svi \u001b[39m=\u001b[39m SVI(model, guide, optimizer, Trace_ELBO(num_particles\u001b[39m=\u001b[39m\u001b[39m10\u001b[39m))\n\u001b[1;32m 10\u001b[0m rng_key, _rng_key \u001b[39m=\u001b[39m random\u001b[39m.\u001b[39msplit(rng_key)\n\u001b[0;32m---> 11\u001b[0m svi_res \u001b[39m=\u001b[39m svi\u001b[39m.\u001b[39;49mrun(_rng_key, num_iters, measurements, Nb, Nt, Na, progress_bar\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m)\n", + "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/svi.py:342\u001b[0m, in \u001b[0;36mSVI.run\u001b[0;34m(self, rng_key, num_steps, progress_bar, stable_update, init_state, *args, **kwargs)\u001b[0m\n\u001b[1;32m 339\u001b[0m \u001b[39mreturn\u001b[39;00m svi_state, loss\n\u001b[1;32m 341\u001b[0m \u001b[39mif\u001b[39;00m init_state \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 342\u001b[0m svi_state \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49minit(rng_key, \u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 343\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 344\u001b[0m svi_state \u001b[39m=\u001b[39m init_state\n", + "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/svi.py:180\u001b[0m, in \u001b[0;36mSVI.init\u001b[0;34m(self, rng_key, *args, **kwargs)\u001b[0m\n\u001b[1;32m 178\u001b[0m model_init \u001b[39m=\u001b[39m seed(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mmodel, model_seed)\n\u001b[1;32m 179\u001b[0m guide_init \u001b[39m=\u001b[39m seed(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mguide, guide_seed)\n\u001b[0;32m--> 180\u001b[0m guide_trace \u001b[39m=\u001b[39m trace(guide_init)\u001b[39m.\u001b[39;49mget_trace(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mstatic_kwargs)\n\u001b[1;32m 181\u001b[0m model_trace \u001b[39m=\u001b[39m trace(replay(model_init, guide_trace))\u001b[39m.\u001b[39mget_trace(\n\u001b[1;32m 182\u001b[0m \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mstatic_kwargs\n\u001b[1;32m 183\u001b[0m )\n\u001b[1;32m 184\u001b[0m params \u001b[39m=\u001b[39m {}\n", + "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/handlers.py:171\u001b[0m, in \u001b[0;36mtrace.get_trace\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 163\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mget_trace\u001b[39m(\u001b[39mself\u001b[39m, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[1;32m 164\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 165\u001b[0m \u001b[39m Run the wrapped callable and return the recorded trace.\u001b[39;00m\n\u001b[1;32m 166\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[39m :return: `OrderedDict` containing the execution trace.\u001b[39;00m\n\u001b[1;32m 170\u001b[0m \u001b[39m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 171\u001b[0m \u001b[39mself\u001b[39;49m(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 172\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mtrace\n", + "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/primitives.py:105\u001b[0m, in \u001b[0;36mMessenger.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 103\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\n\u001b[1;32m 104\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mself\u001b[39m:\n\u001b[0;32m--> 105\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfn(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n", + "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/primitives.py:105\u001b[0m, in \u001b[0;36mMessenger.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 103\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\n\u001b[1;32m 104\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mself\u001b[39m:\n\u001b[0;32m--> 105\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfn(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n", + "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/autoguide.py:559\u001b[0m, in \u001b[0;36mAutoContinuous.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 556\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m__call__\u001b[39m(\u001b[39mself\u001b[39m, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[1;32m 557\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mprototype_trace \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 558\u001b[0m \u001b[39m# run model to inspect the model structure\u001b[39;00m\n\u001b[0;32m--> 559\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_setup_prototype(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 561\u001b[0m latent \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_sample_latent(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[1;32m 563\u001b[0m \u001b[39m# unpack continuous latent samples\u001b[39;00m\n", + "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/autoguide.py:521\u001b[0m, in \u001b[0;36mAutoContinuous._setup_prototype\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 520\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_setup_prototype\u001b[39m(\u001b[39mself\u001b[39m, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[0;32m--> 521\u001b[0m \u001b[39msuper\u001b[39;49m()\u001b[39m.\u001b[39;49m_setup_prototype(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 522\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_init_latent, shape_dict \u001b[39m=\u001b[39m _ravel_dict(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_init_locs)\n\u001b[1;32m 523\u001b[0m unpack_latent \u001b[39m=\u001b[39m partial(_unravel_dict, shape_dict\u001b[39m=\u001b[39mshape_dict)\n", + "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/autoguide.py:156\u001b[0m, in \u001b[0;36mAutoGuide._setup_prototype\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 149\u001b[0m rng_key \u001b[39m=\u001b[39m numpyro\u001b[39m.\u001b[39mprng_key()\n\u001b[1;32m 150\u001b[0m \u001b[39mwith\u001b[39;00m handlers\u001b[39m.\u001b[39mblock():\n\u001b[1;32m 151\u001b[0m (\n\u001b[1;32m 152\u001b[0m init_params,\n\u001b[1;32m 153\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_potential_fn_gen,\n\u001b[1;32m 154\u001b[0m postprocess_fn_gen,\n\u001b[1;32m 155\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mprototype_trace,\n\u001b[0;32m--> 156\u001b[0m ) \u001b[39m=\u001b[39m initialize_model(\n\u001b[1;32m 157\u001b[0m rng_key,\n\u001b[1;32m 158\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mmodel,\n\u001b[1;32m 159\u001b[0m init_strategy\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49minit_loc_fn,\n\u001b[1;32m 160\u001b[0m dynamic_args\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m,\n\u001b[1;32m 161\u001b[0m model_args\u001b[39m=\u001b[39;49margs,\n\u001b[1;32m 162\u001b[0m model_kwargs\u001b[39m=\u001b[39;49mkwargs,\n\u001b[1;32m 163\u001b[0m )\n\u001b[1;32m 164\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_potential_fn \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_potential_fn_gen(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[1;32m 165\u001b[0m postprocess_fn \u001b[39m=\u001b[39m postprocess_fn_gen(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n", + "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/util.py:698\u001b[0m, in \u001b[0;36minitialize_model\u001b[0;34m(rng_key, model, init_strategy, dynamic_args, model_args, model_kwargs, forward_mode_differentiation, validate_grad)\u001b[0m\n\u001b[1;32m 685\u001b[0m w\u001b[39m.\u001b[39mmessage\u001b[39m.\u001b[39margs \u001b[39m=\u001b[39m (\n\u001b[1;32m 686\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mSite \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m: \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m\"\u001b[39m\u001b[39m.\u001b[39mformat(\n\u001b[1;32m 687\u001b[0m site[\u001b[39m\"\u001b[39m\u001b[39mname\u001b[39m\u001b[39m\"\u001b[39m], w\u001b[39m.\u001b[39mmessage\u001b[39m.\u001b[39margs[\u001b[39m0\u001b[39m]\n\u001b[1;32m 688\u001b[0m ),\n\u001b[1;32m 689\u001b[0m ) \u001b[39m+\u001b[39m w\u001b[39m.\u001b[39mmessage\u001b[39m.\u001b[39margs[\u001b[39m1\u001b[39m:]\n\u001b[1;32m 690\u001b[0m warnings\u001b[39m.\u001b[39mshowwarning(\n\u001b[1;32m 691\u001b[0m w\u001b[39m.\u001b[39mmessage,\n\u001b[1;32m 692\u001b[0m w\u001b[39m.\u001b[39mcategory,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 696\u001b[0m line\u001b[39m=\u001b[39mw\u001b[39m.\u001b[39mline,\n\u001b[1;32m 697\u001b[0m )\n\u001b[0;32m--> 698\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mRuntimeError\u001b[39;00m(\n\u001b[1;32m 699\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mCannot find valid initial parameters. Please check your model again.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 700\u001b[0m )\n\u001b[1;32m 701\u001b[0m \u001b[39mreturn\u001b[39;00m ModelInfo(\n\u001b[1;32m 702\u001b[0m ParamInfo(init_params, pe, grad), potential_fn, postprocess_fn, model_trace\n\u001b[1;32m 703\u001b[0m )\n", + "\u001b[0;31mRuntimeError\u001b[0m: Cannot find valid initial parameters. Please check your model again." + ] + } + ], "source": [ "# inference with SVI and autoguides\n", "import optax\n", @@ -557,7 +637,7 @@ "optimizer = npyro.optim.optax_to_numpyro(optax.chain(optax.adabelief(1e-3)))\n", "svi = SVI(model, guide, optimizer, Trace_ELBO(num_particles=10))\n", "rng_key, _rng_key = random.split(rng_key)\n", - "svi_res = svi.run(_rng_key, num_iters, measurements, Nb, Nt, Na, progress_bar=False)" + "svi_res = svi.run(_rng_key, num_iters, measurements, Nb, Nt, Na, progress_bar=True)" ] }, { diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 87cd3e7d..446fd4ff 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -43,6 +43,7 @@ class Agent(Module): q_pi: Optional[List] # static parameters not leaves of the PyTree + num_iter: int = static_field() num_obs: List = static_field() num_modalities: int = static_field() num_states: List = static_field() @@ -75,6 +76,7 @@ def __init__( use_param_info_gain=False, action_selection="deterministic", inference_algo="VANILLA", + num_iter=16, ): ### PyTree leaves @@ -93,6 +95,8 @@ def __init__( ### Static parameters ### + self.num_iter = num_iter + self.inference_algo = inference_algo # policy parameters @@ -153,7 +157,8 @@ def infer_states(self, observations, empirical_prior): qs = inference.update_posterior_states( self.A, o_vec, - prior=empirical_prior + prior=empirical_prior, + num_iter=self.num_iter ) return qs diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index 7927b3d2..23453f76 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -13,7 +13,8 @@ def marginal_log_likelihood(qs, log_likelihood, i): joint = log_likelihood * x dims = (f for f in range(len(qs)) if f != i) - return joint.sum(dims)/qs[i] + marg = joint.sum(dims) + return jnp.where(marg < 0., marg/qs[i], marg) def run_vanilla_fpi(A, obs, prior, num_iter=1): """ Vanilla fixed point iteration (jaxified) """ diff --git a/pymdp/jax/inference.py b/pymdp/jax/inference.py index 9865b34d..92edf30a 100644 --- a/pymdp/jax/inference.py +++ b/pymdp/jax/inference.py @@ -4,7 +4,7 @@ from .algos import run_vanilla_fpi -def update_posterior_states(A, obs, prior=None): +def update_posterior_states(A, obs, prior=None, num_iter=16): - return run_vanilla_fpi(A, obs, prior) + return run_vanilla_fpi(A, obs, prior, num_iter=num_iter) diff --git a/pymdp/jax/maths.py b/pymdp/jax/maths.py index 0e021936..d00df2c6 100644 --- a/pymdp/jax/maths.py +++ b/pymdp/jax/maths.py @@ -1,8 +1,7 @@ from jax import tree_util, nn, jit import jax.numpy as jnp -MIN_VAL = 1e-16 # to debug weird inference with FPI, which we encountered with the T-Maze, try uncommenting this / commenting out the 1e-32 below -# MIN_VAL = 1e-32 +MIN_VAL = jnp.finfo(float).eps def log_stable(x): From 84b1a0218232d048abc2bf208409a917a1deee6d Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Thu, 15 Dec 2022 10:47:39 +0100 Subject: [PATCH 033/232] replaced where with clip in log_stable --- pymdp/jax/maths.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/pymdp/jax/maths.py b/pymdp/jax/maths.py index d00df2c6..bceb3723 100644 --- a/pymdp/jax/maths.py +++ b/pymdp/jax/maths.py @@ -1,11 +1,10 @@ from jax import tree_util, nn, jit import jax.numpy as jnp -MIN_VAL = jnp.finfo(float).eps +MINVAL = jnp.finfo(float).eps def log_stable(x): - - return jnp.log(jnp.where(x >= MIN_VAL, x, MIN_VAL)) + return jnp.log(jnp.clip(x, a_min=MINVAL)) def compute_log_likelihood_single_modality(o_m, A_m): """ Compute observation likelihood for a single modality (observation and likelihood)""" @@ -21,7 +20,7 @@ def compute_log_likelihood(obs, A): ll = jnp.sum(jnp.stack(result), 0) return ll - +MINVAL def compute_accuracy(qs, obs, A): """ Compute the accuracy portion of the variational free energy (expected log likelihood under the variational posterior) """ From a22f598ffb0055751e1ca8112ecaa62f136fe036 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Thu, 15 Dec 2022 10:59:34 +0100 Subject: [PATCH 034/232] fixed numerical issues with gradient computation so that model inversion works --- examples/model_inversion.ipynb | 205 +++++++++++---------------------- pymdp/jax/algos.py | 4 +- 2 files changed, 71 insertions(+), 138 deletions(-) diff --git a/examples/model_inversion.ipynb b/examples/model_inversion.ipynb index 890f0571..b62628c1 100644 --- a/examples/model_inversion.ipynb +++ b/examples/model_inversion.ipynb @@ -211,7 +211,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 7, "metadata": { "scrolled": false }, @@ -234,85 +234,7 @@ }, { "cell_type": "code", - "execution_count": 56, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "DeviceArray([[nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan],\n", - " [nan, nan]], dtype=float32)" - ] - }, - "execution_count": 56, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "#TODO: understand why gradient returns nans for num_iter > 2\n", - "\n", - "agent = Agent(A_gm_all, B_gm_all, C_gm_all, D_gm_all, E_gm_all, control_fac_idx=controllable_indices, num_iter=3)\n", - "def test(prior):\n", - " loc_prior = [emp_prior[0], prior]\n", - " qs = agent.infer_states(obs, loc_prior)\n", - "\n", - " return jnp.log(qs[1]).sum()\n", - "\n", - "jax.grad(test)(emp_prior[1])" - ] - }, - { - "cell_type": "code", - "execution_count": 24, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -324,13 +246,13 @@ "[Step 0] Action: [Move to CUE LOCATION]\n", "[Step 0] Observation: [CUE LOCATION, No reward, Cue Right]\n", "[Step 1] Action: [Move to RIGHT ARM]\n", - "[Step 1] Observation: [RIGHT ARM, Reward!, Cue Right]\n", + "[Step 1] Observation: [RIGHT ARM, Reward!, Cue Left]\n", "[Step 2] Action: [Move to RIGHT ARM]\n", - "[Step 2] Observation: [RIGHT ARM, Reward!, Cue Left]\n", + "[Step 2] Observation: [RIGHT ARM, Reward!, Cue Right]\n", "[Step 3] Action: [Move to RIGHT ARM]\n", - "[Step 3] Observation: [RIGHT ARM, Reward!, Cue Left]\n", + "[Step 3] Observation: [RIGHT ARM, Reward!, Cue Right]\n", "[Step 4] Action: [Move to RIGHT ARM]\n", - "[Step 4] Observation: [RIGHT ARM, Reward!, Cue Left]\n" + "[Step 4] Observation: [RIGHT ARM, Reward!, Cue Right]\n" ] } ], @@ -371,22 +293,22 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 12, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -409,7 +331,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -418,8 +340,8 @@ "text": [ "(1, 5, 50, 3)\n", "(1, 5, 50, 2)\n", - "475 ms ± 7.64 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "497 ms ± 12.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "454 ms ± 4.72 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "476 ms ± 6.32 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", "dict_keys(['actions', 'outcomes'])\n" ] } @@ -451,7 +373,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -498,14 +420,14 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "603 ms ± 8.16 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "589 ms ± 6.35 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", "dict_keys(['a', 'actions', 'd', 'lambda', 'outcomes', 'z'])\n" ] } @@ -542,23 +464,14 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 13, "metadata": {}, "outputs": [ { - "ename": "RuntimeError", - "evalue": "Cannot find valid initial parameters. Please check your model again.", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn [22], line 11\u001b[0m\n\u001b[1;32m 8\u001b[0m mcmc \u001b[39m=\u001b[39m MCMC(kernel, num_warmup\u001b[39m=\u001b[39m\u001b[39m1000\u001b[39m, num_samples\u001b[39m=\u001b[39m\u001b[39m1000\u001b[39m, progress_bar\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n\u001b[1;32m 10\u001b[0m rng_key, _rng_key \u001b[39m=\u001b[39m random\u001b[39m.\u001b[39msplit(rng_key)\n\u001b[0;32m---> 11\u001b[0m mcmc\u001b[39m.\u001b[39;49mrun(_rng_key, measurements, Nb, Nt, Na)\n", - "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/mcmc.py:593\u001b[0m, in \u001b[0;36mMCMC.run\u001b[0;34m(self, rng_key, extra_fields, init_params, *args, **kwargs)\u001b[0m\n\u001b[1;32m 591\u001b[0m map_args \u001b[39m=\u001b[39m (rng_key, init_state, init_params)\n\u001b[1;32m 592\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mnum_chains \u001b[39m==\u001b[39m \u001b[39m1\u001b[39m:\n\u001b[0;32m--> 593\u001b[0m states_flat, last_state \u001b[39m=\u001b[39m partial_map_fn(map_args)\n\u001b[1;32m 594\u001b[0m states \u001b[39m=\u001b[39m tree_map(\u001b[39mlambda\u001b[39;00m x: x[jnp\u001b[39m.\u001b[39mnewaxis, \u001b[39m.\u001b[39m\u001b[39m.\u001b[39m\u001b[39m.\u001b[39m], states_flat)\n\u001b[1;32m 595\u001b[0m \u001b[39melse\u001b[39;00m:\n", - "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/mcmc.py:381\u001b[0m, in \u001b[0;36mMCMC._single_chain_mcmc\u001b[0;34m(self, init, args, kwargs, collect_fields)\u001b[0m\n\u001b[1;32m 379\u001b[0m rng_key, init_state, init_params \u001b[39m=\u001b[39m init\n\u001b[1;32m 380\u001b[0m \u001b[39mif\u001b[39;00m init_state \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 381\u001b[0m init_state \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msampler\u001b[39m.\u001b[39;49minit(\n\u001b[1;32m 382\u001b[0m rng_key,\n\u001b[1;32m 383\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mnum_warmup,\n\u001b[1;32m 384\u001b[0m init_params,\n\u001b[1;32m 385\u001b[0m model_args\u001b[39m=\u001b[39;49margs,\n\u001b[1;32m 386\u001b[0m model_kwargs\u001b[39m=\u001b[39;49mkwargs,\n\u001b[1;32m 387\u001b[0m )\n\u001b[1;32m 388\u001b[0m sample_fn, postprocess_fn \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_get_cached_fns()\n\u001b[1;32m 389\u001b[0m diagnostics \u001b[39m=\u001b[39m (\n\u001b[1;32m 390\u001b[0m \u001b[39mlambda\u001b[39;00m x: \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msampler\u001b[39m.\u001b[39mget_diagnostics_str(x[\u001b[39m0\u001b[39m])\n\u001b[1;32m 391\u001b[0m \u001b[39mif\u001b[39;00m rng_key\u001b[39m.\u001b[39mndim \u001b[39m==\u001b[39m \u001b[39m1\u001b[39m\n\u001b[1;32m 392\u001b[0m \u001b[39melse\u001b[39;00m \u001b[39m\"\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 393\u001b[0m ) \u001b[39m# noqa: E731\u001b[39;00m\n", - "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/hmc.py:706\u001b[0m, in \u001b[0;36mHMC.init\u001b[0;34m(self, rng_key, num_warmup, init_params, model_args, model_kwargs)\u001b[0m\n\u001b[1;32m 701\u001b[0m \u001b[39m# vectorized\u001b[39;00m\n\u001b[1;32m 702\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 703\u001b[0m rng_key, rng_key_init_model \u001b[39m=\u001b[39m jnp\u001b[39m.\u001b[39mswapaxes(\n\u001b[1;32m 704\u001b[0m vmap(random\u001b[39m.\u001b[39msplit)(rng_key), \u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m\n\u001b[1;32m 705\u001b[0m )\n\u001b[0;32m--> 706\u001b[0m init_params \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_init_state(\n\u001b[1;32m 707\u001b[0m rng_key_init_model, model_args, model_kwargs, init_params\n\u001b[1;32m 708\u001b[0m )\n\u001b[1;32m 709\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_potential_fn \u001b[39mand\u001b[39;00m init_params \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 710\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[1;32m 711\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mValid value of `init_params` must be provided with\u001b[39m\u001b[39m\"\u001b[39m \u001b[39m\"\u001b[39m\u001b[39m `potential_fn`.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 712\u001b[0m )\n", - "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/hmc.py:652\u001b[0m, in \u001b[0;36mHMC._init_state\u001b[0;34m(self, rng_key, model_args, model_kwargs, init_params)\u001b[0m\n\u001b[1;32m 650\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_init_state\u001b[39m(\u001b[39mself\u001b[39m, rng_key, model_args, model_kwargs, init_params):\n\u001b[1;32m 651\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_model \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 652\u001b[0m init_params, potential_fn, postprocess_fn, model_trace \u001b[39m=\u001b[39m initialize_model(\n\u001b[1;32m 653\u001b[0m rng_key,\n\u001b[1;32m 654\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_model,\n\u001b[1;32m 655\u001b[0m dynamic_args\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m,\n\u001b[1;32m 656\u001b[0m init_strategy\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_init_strategy,\n\u001b[1;32m 657\u001b[0m model_args\u001b[39m=\u001b[39;49mmodel_args,\n\u001b[1;32m 658\u001b[0m model_kwargs\u001b[39m=\u001b[39;49mmodel_kwargs,\n\u001b[1;32m 659\u001b[0m forward_mode_differentiation\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_forward_mode_differentiation,\n\u001b[1;32m 660\u001b[0m )\n\u001b[1;32m 661\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_init_fn \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 662\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_init_fn, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_sample_fn \u001b[39m=\u001b[39m hmc(\n\u001b[1;32m 663\u001b[0m potential_fn_gen\u001b[39m=\u001b[39mpotential_fn,\n\u001b[1;32m 664\u001b[0m kinetic_fn\u001b[39m=\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_kinetic_fn,\n\u001b[1;32m 665\u001b[0m algo\u001b[39m=\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_algo,\n\u001b[1;32m 666\u001b[0m )\n", - "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/util.py:698\u001b[0m, in \u001b[0;36minitialize_model\u001b[0;34m(rng_key, model, init_strategy, dynamic_args, model_args, model_kwargs, forward_mode_differentiation, validate_grad)\u001b[0m\n\u001b[1;32m 685\u001b[0m w\u001b[39m.\u001b[39mmessage\u001b[39m.\u001b[39margs \u001b[39m=\u001b[39m (\n\u001b[1;32m 686\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mSite \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m: \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m\"\u001b[39m\u001b[39m.\u001b[39mformat(\n\u001b[1;32m 687\u001b[0m site[\u001b[39m\"\u001b[39m\u001b[39mname\u001b[39m\u001b[39m\"\u001b[39m], w\u001b[39m.\u001b[39mmessage\u001b[39m.\u001b[39margs[\u001b[39m0\u001b[39m]\n\u001b[1;32m 688\u001b[0m ),\n\u001b[1;32m 689\u001b[0m ) \u001b[39m+\u001b[39m w\u001b[39m.\u001b[39mmessage\u001b[39m.\u001b[39margs[\u001b[39m1\u001b[39m:]\n\u001b[1;32m 690\u001b[0m warnings\u001b[39m.\u001b[39mshowwarning(\n\u001b[1;32m 691\u001b[0m w\u001b[39m.\u001b[39mmessage,\n\u001b[1;32m 692\u001b[0m w\u001b[39m.\u001b[39mcategory,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 696\u001b[0m line\u001b[39m=\u001b[39mw\u001b[39m.\u001b[39mline,\n\u001b[1;32m 697\u001b[0m )\n\u001b[0;32m--> 698\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mRuntimeError\u001b[39;00m(\n\u001b[1;32m 699\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mCannot find valid initial parameters. Please check your model again.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 700\u001b[0m )\n\u001b[1;32m 701\u001b[0m \u001b[39mreturn\u001b[39;00m ModelInfo(\n\u001b[1;32m 702\u001b[0m ParamInfo(init_params, pe, grad), potential_fn, postprocess_fn, model_trace\n\u001b[1;32m 703\u001b[0m )\n", - "\u001b[0;31mRuntimeError\u001b[0m: Cannot find valid initial parameters. Please check your model again." + "name": "stderr", + "output_type": "stream", + "text": [ + "sample: 100%|██████████| 2000/2000 [03:27<00:00, 9.65it/s, 31 steps of size 1.48e-01. acc. prob=0.88]\n" ] } ], @@ -578,9 +491,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import arviz as az\n", "az.style.use('arviz-darkgrid')\n", @@ -602,27 +526,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, "outputs": [ { - "ename": "RuntimeError", - "evalue": "Cannot find valid initial parameters. Please check your model again.", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn [36], line 11\u001b[0m\n\u001b[1;32m 9\u001b[0m svi \u001b[39m=\u001b[39m SVI(model, guide, optimizer, Trace_ELBO(num_particles\u001b[39m=\u001b[39m\u001b[39m10\u001b[39m))\n\u001b[1;32m 10\u001b[0m rng_key, _rng_key \u001b[39m=\u001b[39m random\u001b[39m.\u001b[39msplit(rng_key)\n\u001b[0;32m---> 11\u001b[0m svi_res \u001b[39m=\u001b[39m svi\u001b[39m.\u001b[39;49mrun(_rng_key, num_iters, measurements, Nb, Nt, Na, progress_bar\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m)\n", - "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/svi.py:342\u001b[0m, in \u001b[0;36mSVI.run\u001b[0;34m(self, rng_key, num_steps, progress_bar, stable_update, init_state, *args, **kwargs)\u001b[0m\n\u001b[1;32m 339\u001b[0m \u001b[39mreturn\u001b[39;00m svi_state, loss\n\u001b[1;32m 341\u001b[0m \u001b[39mif\u001b[39;00m init_state \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 342\u001b[0m svi_state \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49minit(rng_key, \u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 343\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 344\u001b[0m svi_state \u001b[39m=\u001b[39m init_state\n", - "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/svi.py:180\u001b[0m, in \u001b[0;36mSVI.init\u001b[0;34m(self, rng_key, *args, **kwargs)\u001b[0m\n\u001b[1;32m 178\u001b[0m model_init \u001b[39m=\u001b[39m seed(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mmodel, model_seed)\n\u001b[1;32m 179\u001b[0m guide_init \u001b[39m=\u001b[39m seed(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mguide, guide_seed)\n\u001b[0;32m--> 180\u001b[0m guide_trace \u001b[39m=\u001b[39m trace(guide_init)\u001b[39m.\u001b[39;49mget_trace(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mstatic_kwargs)\n\u001b[1;32m 181\u001b[0m model_trace \u001b[39m=\u001b[39m trace(replay(model_init, guide_trace))\u001b[39m.\u001b[39mget_trace(\n\u001b[1;32m 182\u001b[0m \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mstatic_kwargs\n\u001b[1;32m 183\u001b[0m )\n\u001b[1;32m 184\u001b[0m params \u001b[39m=\u001b[39m {}\n", - "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/handlers.py:171\u001b[0m, in \u001b[0;36mtrace.get_trace\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 163\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mget_trace\u001b[39m(\u001b[39mself\u001b[39m, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[1;32m 164\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 165\u001b[0m \u001b[39m Run the wrapped callable and return the recorded trace.\u001b[39;00m\n\u001b[1;32m 166\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[39m :return: `OrderedDict` containing the execution trace.\u001b[39;00m\n\u001b[1;32m 170\u001b[0m \u001b[39m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 171\u001b[0m \u001b[39mself\u001b[39;49m(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 172\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mtrace\n", - "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/primitives.py:105\u001b[0m, in \u001b[0;36mMessenger.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 103\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\n\u001b[1;32m 104\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mself\u001b[39m:\n\u001b[0;32m--> 105\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfn(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n", - "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/primitives.py:105\u001b[0m, in \u001b[0;36mMessenger.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 103\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\n\u001b[1;32m 104\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mself\u001b[39m:\n\u001b[0;32m--> 105\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfn(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n", - "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/autoguide.py:559\u001b[0m, in \u001b[0;36mAutoContinuous.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 556\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m__call__\u001b[39m(\u001b[39mself\u001b[39m, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[1;32m 557\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mprototype_trace \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 558\u001b[0m \u001b[39m# run model to inspect the model structure\u001b[39;00m\n\u001b[0;32m--> 559\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_setup_prototype(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 561\u001b[0m latent \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_sample_latent(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[1;32m 563\u001b[0m \u001b[39m# unpack continuous latent samples\u001b[39;00m\n", - "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/autoguide.py:521\u001b[0m, in \u001b[0;36mAutoContinuous._setup_prototype\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 520\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_setup_prototype\u001b[39m(\u001b[39mself\u001b[39m, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[0;32m--> 521\u001b[0m \u001b[39msuper\u001b[39;49m()\u001b[39m.\u001b[39;49m_setup_prototype(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 522\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_init_latent, shape_dict \u001b[39m=\u001b[39m _ravel_dict(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_init_locs)\n\u001b[1;32m 523\u001b[0m unpack_latent \u001b[39m=\u001b[39m partial(_unravel_dict, shape_dict\u001b[39m=\u001b[39mshape_dict)\n", - "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/autoguide.py:156\u001b[0m, in \u001b[0;36mAutoGuide._setup_prototype\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 149\u001b[0m rng_key \u001b[39m=\u001b[39m numpyro\u001b[39m.\u001b[39mprng_key()\n\u001b[1;32m 150\u001b[0m \u001b[39mwith\u001b[39;00m handlers\u001b[39m.\u001b[39mblock():\n\u001b[1;32m 151\u001b[0m (\n\u001b[1;32m 152\u001b[0m init_params,\n\u001b[1;32m 153\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_potential_fn_gen,\n\u001b[1;32m 154\u001b[0m postprocess_fn_gen,\n\u001b[1;32m 155\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mprototype_trace,\n\u001b[0;32m--> 156\u001b[0m ) \u001b[39m=\u001b[39m initialize_model(\n\u001b[1;32m 157\u001b[0m rng_key,\n\u001b[1;32m 158\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mmodel,\n\u001b[1;32m 159\u001b[0m init_strategy\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49minit_loc_fn,\n\u001b[1;32m 160\u001b[0m dynamic_args\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m,\n\u001b[1;32m 161\u001b[0m model_args\u001b[39m=\u001b[39;49margs,\n\u001b[1;32m 162\u001b[0m model_kwargs\u001b[39m=\u001b[39;49mkwargs,\n\u001b[1;32m 163\u001b[0m )\n\u001b[1;32m 164\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_potential_fn \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_potential_fn_gen(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[1;32m 165\u001b[0m postprocess_fn \u001b[39m=\u001b[39m postprocess_fn_gen(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n", - "File \u001b[0;32m~/.conda/envs/pymdp/lib/python3.9/site-packages/numpyro/infer/util.py:698\u001b[0m, in \u001b[0;36minitialize_model\u001b[0;34m(rng_key, model, init_strategy, dynamic_args, model_args, model_kwargs, forward_mode_differentiation, validate_grad)\u001b[0m\n\u001b[1;32m 685\u001b[0m w\u001b[39m.\u001b[39mmessage\u001b[39m.\u001b[39margs \u001b[39m=\u001b[39m (\n\u001b[1;32m 686\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mSite \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m: \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m\"\u001b[39m\u001b[39m.\u001b[39mformat(\n\u001b[1;32m 687\u001b[0m site[\u001b[39m\"\u001b[39m\u001b[39mname\u001b[39m\u001b[39m\"\u001b[39m], w\u001b[39m.\u001b[39mmessage\u001b[39m.\u001b[39margs[\u001b[39m0\u001b[39m]\n\u001b[1;32m 688\u001b[0m ),\n\u001b[1;32m 689\u001b[0m ) \u001b[39m+\u001b[39m w\u001b[39m.\u001b[39mmessage\u001b[39m.\u001b[39margs[\u001b[39m1\u001b[39m:]\n\u001b[1;32m 690\u001b[0m warnings\u001b[39m.\u001b[39mshowwarning(\n\u001b[1;32m 691\u001b[0m w\u001b[39m.\u001b[39mmessage,\n\u001b[1;32m 692\u001b[0m w\u001b[39m.\u001b[39mcategory,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 696\u001b[0m line\u001b[39m=\u001b[39mw\u001b[39m.\u001b[39mline,\n\u001b[1;32m 697\u001b[0m )\n\u001b[0;32m--> 698\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mRuntimeError\u001b[39;00m(\n\u001b[1;32m 699\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mCannot find valid initial parameters. Please check your model again.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 700\u001b[0m )\n\u001b[1;32m 701\u001b[0m \u001b[39mreturn\u001b[39;00m ModelInfo(\n\u001b[1;32m 702\u001b[0m ParamInfo(init_params, pe, grad), potential_fn, postprocess_fn, model_trace\n\u001b[1;32m 703\u001b[0m )\n", - "\u001b[0;31mRuntimeError\u001b[0m: Cannot find valid initial parameters. Please check your model again." + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 1000/1000 [00:08<00:00, 116.43it/s, init loss: 855.6790, avg. loss [951-1000]: 435.0552]\n" ] } ], @@ -642,9 +553,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure(figsize=(16,5))\n", "plt.plot(svi_res.losses)\n", @@ -654,7 +576,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -676,9 +598,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAB9sAAAJjCAYAAACsvnHyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAABJcUlEQVR4nO3de5xVZb0/8M8Mw4AIziCKymhiIZiJGBBKknij0jQvmdpF07RMs9Ssfp5jpWbHc8xrWqblybLSzLCLmoalaJiKQmrelfACmhcug8RlBmb//uAwSYPCYmbYzOb9fr18yTxr7Wd998B3FovPftaqKpVKpQAAAAAAAAAAq6263AUAAAAAAAAAQFcjbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAANBJXn311Zxzzjl5//vfn6FDh2bnnXfOMccckz//+c+F5rn++uszZMiQDBkyJKeffvoa1zNt2rSceuqpGTNmTIYOHZq999475557bubNm7fS/ZcuXZrvfOc7GTt2bHbYYYfsv//+mTBhwpvO/8QTT2T77bfPueeeu0b13Xfffa3v863MmDGjdb8ZM2assO20005r3bb8v2HDhmXMmDE59NBD881vfjP33HNPSqXSm85/6aWXZsiQITniiCPW6H0AAACwfhC2AwAAQCd48sknc+CBB+YnP/lJXnrppWy77bapq6vLpEmTcuyxx+YHP/jBas0ze/bsnH/++e2u5957783BBx+cm266KUuXLs22226b1157LT/60Y9y8MEH57XXXmvzmgsvvDCXXXZZXn/99WyzzTb5+9//ni9+8Yv505/+tNJjfPOb38zGG2+cz3/+8+2ut7369euX4cOHZ/jw4RkyZEh69+6dxx57LD//+c9z1FFH5cADD8yTTz5Z7jIBAADowoTtAAAA0MGWLFmSL37xi3nttdcyatSo3HnnnbnhhhsyYcKE/PjHP86GG26YCy+8MPfff/8q5zrnnHMyb9687L777mtcz/z583PKKadk0aJFOeKII3LXXXflhhtuyB133JHhw4fnhRdeaLNifvbs2fnpT3+ahoaGTJgwITfeeGN+/OMfp6qqKpdcckmbY/zmN7/JlClT8pWvfCW9e/de41o7ym677ZZrr7021157bX75y1/m1ltvzQMPPJBLL700gwcPzhNPPJHDDjssjz32WLlLBQAAoIsStgMAAEAHmzhxYp599tnU1tbmf/7nf7Lxxhu3bhs9enQ+97nPpVQq5bvf/e5bzvOXv/wlN954Yw477LDssMMOa1zPL37xi8yePTvveMc78h//8R/p3r17kqRv37654IILUlNTk4kTJ+bRRx9tfc1TTz2VxYsX5+CDD84mm2ySJHnPe96TESNG5Iknnsj8+fNb950/f37OP//8jBgxIgcccMAa19nZevbsmfe///25/vrrM3r06CxcuDAnn3xyli5dWu7SAAAA6IKE7QAAANDBpk6dmiQZOnRoGhoa2mz/wAc+kCSZPHlyZs2atdI5Fi9enDPPPDP9+vXLl770pXbVc9tttyVJDjrooHTr1m2FbQMGDMjo0aOTJH/4wx9ax2fPnp1k2e3Y32jTTTdNkvzzn/9sHfvud7+b2bNn5+tf/3q76lxbevbsmfPOOy+1tbV57rnncuutt5a7JAAAALogYTsAAAB0sHnz5iVJNttss5VuXz7e0tKSv/3tbyvd57LLLstzzz2Xr371q9loo43WuJYlS5a0rlgfPnz4SvdZPv7QQw+1jm2xxRZJkmeffXaFfadPn56amprU19cnSaZNm5af/exnOeyww/LOd75zjetc2zbddNPsvffeSZbdiQAAAACKErYDAABAB+vTp0+S5OWXX17p9jeOT58+vc32adOm5X//938zcuTIHHjgge2qZebMmWlubk6SbLXVVivdZ/n4c8891zq23XbbpV+/fvnVr36Vv/zlL5k/f35+8pOf5PHHH8/IkSPTo0ePJMnZZ5+d3r175+STT25XneUwYsSIJHnTDzwAAADAW6kpdwEAAABQaYYOHZokeeSRR/LSSy+1rhJfbsKECa2/bmxsXGFbqVTKN77xjZRKpZxxxhntruWN89fV1a10n+Ur59+47wYbbJAvfelLOf3003P00Ue3jvfq1SunnXZakuSWW27JPffck7PPPrt17ubm5syZMyf19fWpra1d47qHDBmyxq9dXZtvvnmSf90yHwAAAIoQtgMAAEAH22uvvdK/f/+88sorOfXUU3PxxRenf//+SZbdsvzyyy9v3Xfx4sUrvPZXv/pVHnjggXz605/O4MGD211LU1NT66+7d+++0n2Wh+L/XsshhxyS/v3754Ybbsjs2bMzcODAHHXUUXn729+ehQsX5tvf/nZ22GGHHHLIISmVSrn44otz9dVXZ8GCBenVq1eOOOKInHLKKamqqipc95vd8n75e3rkkUcKz/nvevXqlWTF588DAADA6hK2AwAAQAfr0aNHLrroonz2s5/NlClTsscee2SbbbZJY2NjXnnllQwYMCDvfOc7c//997cGvsmyFdbnn39+Nt9885x44okdUssbV5c3Nze33v79jZYH8ivbtttuu2W33XZrM3755ZfnpZdeysUXX5zq6upcdtllufzyy7PHHnvkAx/4QCZMmJArrrgiG2ywQY4//vjCdV977bVvum3GjBnZa6+9Cs/57xYsWJAk6d27d7vnAgAAYP3jme0AAADQCUaOHJlf//rX+chHPpJNNtkkzz77bJLk8MMPz/jx47N06dIkySabbNL6mvPOOy9z587Nf/zHf2TDDTfskDreeOv4f79l/XLz5s1rs+9bef755/OjH/0oBx10UIYNG5bm5uZcddVV2XrrrXPZZZfloIMOyve+971svfXWueqqq7JkyZL2v5FO8OKLLyZJNt544zJXAgAAQFdkZTsAAAB0kq233jrnnHNOm/ElS5bkiSeeSJK8613vah1/7LHHkiRnn312zj777BVes3wV9k033ZSJEycmSe6+++5V1tDQ0JDu3bunubk5L7zwQuvt7N/ohRdeaK13dfzXf/1XevTokS9/+ctJkr///e+ZN29e9ttvv1RXL/tcf3V1dXbddddcc801mT59erbddtvVmnttmjJlSpJkxx13LHMlAAAAdEXCdgAAAFjLJk2alAULFqR///4rhO3Lvfbaa2/62kWLFmXRokWrfayamppsv/32eeihhzJ16tSMGDGizT5Tp05NkgwbNmyV891xxx2ZOHFiTj/99PTr1y/Jvz4I8O+r8Zd/vXzl/LrklVdeye23354kGTt2bJmrAQAAoCtyG3kAAABYi5qamnLJJZckST72sY+lW7durdt++9vf5sknn1zpf8uf4X7IIYe0jq2ucePGJUl+/etft96+frkXX3wx99xzT5Lk/e9//yprP+ecczJ48OB8/OMfbx3fYostkiy7vfwbLf+6b9++q13r2rBo0aJ89atfTVNTUwYOHJgPfOAD5S4JAACALkjYDgAAAJ3gzjvvzEMPPbTC2EsvvZTPf/7zefTRRzNo0KAce+yxHXa8W2+9NXvuuWc+9rGPtdn2sY99LH379s20adPy3//932lubk6SzJkzJ6eeemqWLFmS3XbbLTvssMNbHuOHP/xhnn/++Xz9619PTc2/bpa32WabZYsttsgdd9zRenv8J598MnfccUc23XTTDBw4sMPeZ3ssWrQot912Wz760Y/mnnvuSa9evfKd73xnhQ88AAAAwOpyG3kAAADoBJMmTcrVV1+durq6NDQ0ZPHixfn73/+eUqmUQYMG5Uc/+lFqa2s77HgLFizIzJkzV7qtd+/eueiii3Lcccflpz/9aW6++eZsscUW+fvf/56FCxemoaFhpc+Wf6MXX3wxP/zhD/OhD30oo0aNWmFbVVVVTjzxxJx++uk55JBDss022+TZZ59NU1NTPv/5z7c+x31tuuuuu1o/eNDS0pLGxsbMmDGj9YMG73znO/Ptb387gwcPXuu1AQAAUBmE7QAAANAJ9t5777z66qt5+OGHM23atNTW1mbo0KHZd99984lPfKJDg/bVMXr06IwfPz7f//73c++99+app57KZpttlnHjxuX4449PXV3dW77+f/7nf1JVVZX/9//+30q3H3LIIVm8eHF+8pOfZPr06RkwYECOPvrola60XxtmzZqVWbNmJUl69OiRPn36ZPvtt88OO+yQcePGZfTo0WWpCwAAgMpRVSqVSuUuAgAAAAAAAAC6Es9sBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgoJpyF1Dp5syZU+4SgHaqq6tLY2NjucsAOpC+hsqjr6Ey6W2oPPoaKo++hsqjr2GZvn37rnIfK9sBVqG62o9KqDT6GiqPvobKpLeh8uhrqDz6GiqPvobVp1sAAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAAAoix/+8IfZZZddMmXKlHKXUpiwHQAAAAAAAAAKqil3AQAAAAAAAACsnz760Y9m3Lhx2XzzzctdSmHCdgAAAAAAAADKor6+PvX19eUuY424jTwAAAAAAAAAq+X222/P8ccfn3322Se77bZbPvzhD+fkk0/OnXfemZdeeimjR4/OiSeeuNLXLl68OHvttVcOOeSQ1rGu/Mx2K9sBAAAAAAAA2qtUSpYsLHcVb65mg6Sqql1TjB8/Puedd1422WSTjB07NnV1dXnttdfy2GOP5c4778zYsWOz0047ZerUqXnllVfSv3//FV5/11135Z///GcOP/zwdtWxrhC2AwAAAAAAALRHqZQNrvtEur3413JX8qaWDhiehYf9rF2B++9+97t07949P/3pT9O3b98VtjU2NiZJPvjBD+avf/1rJkyYkE9+8pMr7HPrrbe27lMJ3EYeAAAAAAAAoN3at2q8q6ipqUlNTds13XV1dUmSvfbaK7W1ta3B+nJz587Nfffdlx122CFbbbXVWqm1s1nZDgAAAAAAANAeVVXLVo1X+G3k99prr1x22WX5+Mc/nnHjxmX48OEZNmxY+vTp07pP7969M2bMmNx+++155plnMmjQoCTJbbfdliVLllTMqvZE2A4AAAAAAADQflVVSfde5a6iUx1xxBGpq6vLr3/961x77bW55ppr0q1bt7z3ve/NKaeckgEDBiRZdpv422+/PX/4wx9aw/Zbb701NTU1GTduXDnfQocStgMAAAAAAACwSlVVVTnggANywAEHpLGxMQ8++GAmTJiQP/3pT3nhhRfy85//vDV8r6+vz4QJE3LCCSdkxowZefTRR7Pbbru13m6+EgjbAQAAAAAAACikrq4uY8eOzdixY9PY2JgHHnggM2bMyNZbb52amprstddeGT9+fKZOnZqpU6cmSUXdQj5JqstdAAAAAAAAAADrvnvvvTdLlixZYWzJkiWZN29ekqRHjx6t4/vss0+SZbeP/8Mf/pA+ffpkzJgxa6/YtcDKdgAAAAAAAABW6Wtf+1p69uyZYcOGZfPNN8+SJUsyefLkTJ8+PXvvvXc233zz1n132GGHbLXVVrnllluyZMmSHHDAAamtrS1j9R1P2A4AAAAAAADAKh1//PG599578+ijj2bSpEnp2bNnttxyy5x22mnZb7/92uz/wQ9+MD/84Q9bf11pqkqlUqncRVSyOXPmlLsEoJ369u2rl6HC6GuoPPoaKpPehsqjr6Hy6GuoPPoalunbt+8q9/HMdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAACsE44//vjssssu5S5jtQjbAQAAAAAAAKAgYTsAAAAAAAAAFFRT7gIAAAAAAAAA6BqmTJmSz3/+8znmmGPyvve9L9///vfzt7/9LVVVVRk5cmROOumkDBgwIEny4osv5uCDD86+++6bb3zjG23m2mWXXfLud7873//+91u/fuO25d74+ilTpuSnP/1pnnnmmTQ2Nqauri5bbbVVPvjBD+aAAw7ozLfehrAdAAAAAAAAgEKeeOKJ/PznP8/w4cNz4IEH5qmnnsqdd96ZadOm5ec//3l69OhReM5jjjkmN998c/7xj3/kmGOOaR0fPHhwkuTuu+/Ol7/85fTp0yfve9/7sskmm2TOnDl5+umn84c//EHYDgAAAAAAANDVlEqlLFpU7ireXM+eSVVVVYfNd/fdd+fss8/OuHHjWsfOOuus3HLLLbnrrrtWGF9dn/nMZzJ16tT84x//yGc+85k222+88caUSqV873vfy7bbbrvCtsbGxuJvop2E7QAAAAAAAADtUCqVcsIXSvnbI+Wu5M0N3SG57NKOC9zf/e53twnU99tvv9xyyy157LHH1ihsX10rWzVfV1fXacd7M9Vr/YgAAAAAAAAAdGlDhgxpM9a/f/8kyfz58zvlmHvttVeS5Nhjj815552X22+/PbNnz+6UY60OK9sBAAAAAAAA2qGqqiqXXZr16jbyG264YZuxbt26JUmWLl3aYcd5o3HjxqWmpibXXXddfvOb32T8+PGpqqrK8OHDc9JJJ7U+231tEbYDAAAAAAAAtFNVVVU22KDcVaxbqquX3Wh9ZeH7mq5+32OPPbLHHnvkn//8Zx5++OFMnDgxN954Y0466aT88pe/TJ8+fdpVcxHCdgAAAAAAAAA63PLg+9VXX22z7cknn1zpa964On75r1dmww03zOjRozN69Oi0tLTkxhtvzKOPPppddtmlAypfPZ7ZDgAAAAAAAECH23DDDfO2t70tDz30UF544YXW8X/+85/5/ve/v9LXbLTRRkmSV155pc22+++/P4sXL24zvvy57T169OiIsleble0AAAAAAAAAdIqPfexjOffcc/OZz3wme+65Z0qlUu65555st912K91/xIgRuf3223P66adn9OjR6dGjR97xjndk1113zSWXXJKXX3457373u7PFFlukqqoqDz30UB577LEMHTo0O+6441p9b8J2AAAAAAAAADrFQQcdlCVLluS6667L7373u2yyySb50Ic+lKOPPjpjxoxps/8BBxyQl156KX/84x/z4x//OEuXLs2+++6bXXfdNUceeWQmTpyYJ598Mvfdd19qamoyYMCAnHjiifnIRz7ylred7wxVpVKptFaPuJ6ZM2dOuUsA2qlv3756GSqMvobKo6+hMultqDz6GiqPvobKo69hmb59+65yH89sBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEE15S4AAKCzTH+2lJkzk4aGZJuBVeUuBwAAAACACiJsB6DLmDO3VO4S6CIa55Vy/gXJgw/9a2ynYaV8+dSkbqOqlEotmdvozxNt9a33oQwAAAAAYPUI26GdFi4U1lS6Hj1Kfp/XEfsf6PeB1VNdnWy4YfLNM6sybGjy0N+S8y4o5cijkpaWUpI55S6RddRtt5S7AtaU8/Xq22ADHyoBAAAA6AjCdmincfv4R93KN7vcBQAFtbQkXzm1KnvuvixQ2nP3pFRKzjjLz2zemvN6V+Z8vbomTRS2AwAAAHSE6nIXAADQGYYNXfHrnXYsTx0AAAAAAFQmK9uhnW67xcqgSldf3zdz57rl9LrAilOKeOhvy1a0L/fgw2UrhS7Eeb3rcr4GAAAAYG0TtkM7eeZl5evVqyqLF/t9Xhfc+JtyV0BX8fUzSrnw4lJKpWUr2h98OLnoO6XsNCw5+6yq1NfVZ27j3HKXyTrIeb3rcr4GAAAAYG0TtgPQZfStF6Kwer51VnLWt0orPKP9PSOTM75Wlfr6qvTtW52qKn+eAAAAAABYc8J2AKDi1NdX5aLzqzL92VJmzkwaGpJtBgrXAQAAAADoOMJ2AKBibTOwKtsMLHcVAAAAAABUoupyFwAAAAAAAAAAXY2wHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbG+HGTNmZMiQITnttNPKXQoAAAAAAAAAa5GwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNi+GpYuXZof/OAHGTduXIYOHZpx48bliiuuSKlUKndpAAAAAAAAAJRBTbkL6Aq+/vWvZ/z48dlyyy3ziU98IosXL85VV12Vv/71r+UuDQAAAAAAAIAyELavwn333Zfx48dnu+22y7XXXptevXolST73uc/lgAMOKHN1AAAAAAAAAJSD28ivwm9+85skyec///nWoD1JNttssxx55JFlqgoAAAAAAACAchK2r8KTTz6ZJBk5cmSbbSsbAwAAAAAAAKDyCdtX4fXXX091dXX69u3bZlu/fv3KUBEAAAAAAAAA5SZsX4U+ffqkpaUlc+bMabNt1qxZZagIAAAAAAAAgHITtq/CkCFDkiQPPPBAm20rGwMAAAAAAACg8gnbV+HAAw9Mknzve9/LggULWsdffvnlXH311WWqCgAAAAAAAIByqil3Aeu6nXfeOQcffHBuuOGG7L///hk3blyampry+9//PjvttFPuuOOOcpcIAAAAAAAAwFombF8N3/rWt7LNNtvkl7/8ZX72s59l8803z9FHH5199tlH2A4AAAAAAACwHhK2r4Zu3brls5/9bD772c+22fbkk0+WoSIAAAAAAAAAyskz2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBNeUuAACgHKpmPZPquc+npf5tKfUbVO5yAAAAAADoYoTtAHRtC2aXuwK6moVz0zz+7Gz43L2tQ0saRmbR3mclG9SXry66rl4bl7sCAAAAAKAMhO2wvmleUO4KupxSU63v2zqs9+W7lrsEuphSVXVKtX2yaL+L0tIwItUzp6TnbWdkw6v3T1Wppdzl0QXN/8KUcpdAnK/LpnuvclcAAAAAUDbCdljP9L50RLlL6HKWJOld7iKADlNVasnCcWdm6eAPJkmWDv5gFpdK6Xnzl8pcGV2Vc+u6wfm6POZ/6fFylwAAAABQNtXlLgAAYG1raVgxHF265cgyVQIAAAAAQFdlZTusZ9zqtrj6+vrMnTu33GXwJqwoZU1Uz5zSurI9SbrNeKCM1dDVObeuG5yvAQAAAFjbhO2wvvFczcKqajdMujeVuwzexPzP3V3uEuhiet54Unr+6ewsLpWydMuR6TbjgdTe/q0s2fI9WbTfxeUuj67IuXWd4HwNAAAAwNombAega+u1cbkroItZ9OFL0mfCaSs8o33J1u/Non3PTzboW8bKAAAAAADoSoTtAMD6ZYO+qTnql5n7zP2pnvt8WurfllK/QeWuCgAAAACALkbYDgCsl0r9BmWpkB0AAAAAgDVUXe4CAAAAAAAAAKCrEbYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQUE25C6h0S5cuTUtLS7nLANqhubk5zc3N5S4D6ED6GiqPvobKpLeh8uhrqDz6GiqPvobVJ2zvZDNnzkxTU1O5ywDaYe7cuWlsbCx3GUAH0tdQefQ1VCa9DZVHX0Pl0ddQefQ1LNO/f/9V7iNs72RNTU3p1q1bunXrVu5SgDXUo0eP1NbWlrsMoAPpa6g8+hoqk96GyqOvofLoa6g8+hqW3b18dQjb14Ju3bqle/fu5S4DWEPdu3fXw1Bh9DVUHn0NlUlvQ+XR11B59DVUHn0Nq6+63AUAAAAAAAAAQFcjbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABdWUuwAAAABW3wszuuUf/6jJ5psvyVZbLi13OQAAAADrLWE7AEA7NM6rKncJwP+p9H58fX5VfnhlXR57vLZ1bPt3NuUzxzamT+9SGSuDzlXpvc36oW4jP6cBAKASCdvpshYtKncFrC8WLvLnDSpNR/b1scf175iJgA5Q2f1YXZ1suGHyzTOrMmxo8tDfkvMuqM2pX9k0LS3lrg46U2X3NuuHn171crlLWGe4xobKo6+h8ujrdUvPnuWugLcibKfLOuLozcpdAusVf96g8uhroGtpaUm+cmpV9tx92SrfPXdPSqXkjLOslgRY1/k3jH/n+wGVR19D5dHX64rrr/XBzXVZdbkLAAAAYPUMG7ri1zvtWJ46AAAAALCynS7MLdhYW+rq69M4d265ywA6UEf2tVVKwNr00N+WrWhf7sGHy1YKAAX4N4x/cY0NlUdfQ+XR17D6hO10WZ5RwdqyQc9ksT9vUFE6sq+vvOKVjpkIaJe6jerSOK+x3GV0qgsvrs+FF3VPqVSdnXZcFrRfdHFLtn9nc7508txylwedYn3obdYP/g3jX1xjQ+XR11B59DWsPmE7AEA71G3kWcmwLqivT5LK7sdTT56b73y3PmecVds6tuPQ5px04txs5GcRFWp96G0AAAC6LmE7AABAF7DRRqV8/T/n5IUZ3fKPf9Rk882XZKstl5a7LAAAAID1lrAdAACgC9lqy6VCdgAAAIB1QHW5CwAAAAAAAACArkbYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoqHLbPmDEjQ4YMyWmnndYZ9RQ2ZMiQHHHEER0y16WXXpohQ4bkvvvu65D5AAAAAAAAAKhMVrYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAXVdMQkjzzySG644YZMnjw5L730Upqbm7P11ltn//33z9FHH53u3buvsP+ee+6ZJPntb3+b888/P3/6058yf/78vOtd78p//ud/5l3veldeffXVnH/++bnrrruyYMGCjBw5Mt/4xjey9dZbr7SGl156Keeee27uueeeLF68OEOHDs0pp5yS4cOHr3Tf8847L5MmTUpzc3Pe9a535aSTTlrpvE1NTbnuuusyceLEPPPMM5k1a1b69OmTESNG5IQTTsj222/fzu8eAAAAAAAAAF1Nh6xs/+Uvf5nbbrstgwcPzmGHHZZDDjkkpVIpF1xwQb70pS+t9DVNTU05+uijM3Xq1Oyzzz7Zc889M3Xq1Bx99NGZNm1aDjvssEyfPj0f/vCHM3r06EyaNCnHHXdcli5d2mauxsbGfOxjH8vMmTNz6KGH5v3vf3/++te/5sgjj8x99923wr6vvPJKDjvssNx8880ZOnRojjjiiNTV1eXoo4/Ogw8+uNK5zznnnDQ1NWXs2LE56qijMmrUqNx55505/PDD8/DDD3fEtxAAAAAAAACALqRDVrYfd9xxOeOMM9KtW7fWsVKplNNPPz3jx4/PlClTMmLEiBVe8+qrr2bEiBG54IILUlOzrIztttsuF1xwQQ4//PAcfPDBOe2001JVVZUkOfPMM3Pttdfm9ttvz7hx41aY68knn8wBBxyQc889t3X/Qw45JEceeWS+/vWv59Zbb0119bLPFVx44YV5+eWXc/LJJ+f4449vneO6667LN77xjTbvra6uLhMnTsxmm222wvjTTz+dQw89NBdddFGuuuqqNf3WAQAAAAAAANAFdcjK9oaGhhWC9iSpqqrKJz7xiSTJPffcs9LXffWrX20N2pNk//33T5IsWbIkJ510UmtwniT77bdfkuSJJ55oM0+3bt1yyimnrLD/qFGjMnbs2Dz33HOZOnVqkmWr6X//+9+nX79++fSnP73CHB/96EczcODANnPX1ta2CdqTZNttt83OO++c+++/P83NzSt9fwAAAAAAAABUpg5Z2d7U1JSf//znufnmm/P3v/89CxYsSKlUat3+yiuvtHnNRhttlIaGhhXGNt100yTJwIED06tXr5Vue/nll9vMNWDAgGyxxRZtxkeMGJGJEyfmiSeeyMiRIzN9+vQsXrw4u+yyS3r06LHCvtXV1Rk+fHieffbZNvM8/vjjufLKKzNlypS89tprbcL1OXPmpH///m1eBwAAAAAAAEBl6pCw/Ytf/GLuuOOODBw4MPvuu2/69euXmpqazJs3L1dffXWampravKZPnz5ti/m/Ve69e/dus235yvklS5a02davX7+V1rXJJpskSV5//fUV/v9m+69sfOrUqfnUpz6VJNl1111bPwhQVVWVP/7xj3niiSdW+v4AAAAAAAAAqFztDtsffvjh3HHHHRkzZkx+8IMfrHA7+QcffDBXX311ew+xSrNmzVrp+GuvvZbkX8H+8v+/2f4rG7/88svT1NSUa665ps1z5x988ME1LRkAAAAAAACALqzdz2x/4YUXkiS77757m+e2P/DAA+2dfrW8+OKLeemll9qMT5kyJUmy3XbbJUm22Wab9OjRI4888kgWL168wr4tLS2tz3Z/o+effz719fVtgvaFCxfmscce66i3AAAAAAAAAEAX0u6wfcCAAUn+FWwv9/TTT+cHP/hBe6dfLUuXLs1FF120wnPiJ0+enDvvvDNbb711hg8fniSpra3NPvvsk1mzZuVHP/rRCnNcf/31K31ee0NDQxobG/P000+vcLxzzz03s2fP7pw3BAAAAAAAAMA6rd23kd9xxx2z44475pZbbsmrr76aYcOG5aWXXsrtt9+esWPH5g9/+ENH1PmWhgwZksmTJ+fQQw/NLrvskldeeSU333xzampqcvbZZ6e6+l+fKTj11FNzzz335OKLL86UKVOy/fbbZ9q0abnzzjszZsyYTJo0aYW5P/nJT2bSpEn5+Mc/nn322Se1tbWZPHlyXn755YwaNSqTJ0/u9PcHAAAAAAAAwLql3Svbu3XrliuuuCIf+chH8vzzz+dnP/tZnnnmmXz1q1/NV77ylY6ocZXq6upyzTXXZMCAAbnuuuty6623ZqeddspPfvKT7Lzzzivs279///ziF7/Ivvvum4ceeihXX3115s6dm6uuuio77bRTm7n32GOPXHLJJdlqq63yu9/9LjfddFPe/va351e/+lUaGhrWyvsDAAAAAAAAYN1SVXrjvdfpcPfff39qa2vTvXv3cpcCrKH6+vrMnTu33GUAHUhfQ+XR11CZ9DZUHn0NlUdfQ+XR15A0Nzdn2LBhq9yv3SvbAQAAAAAAAGB9I2wHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABdWUuwAAAADWPbWNz6b76zPT3KchTXUDy10OAAAAwDpH2A4A0IV1WzS33CXAOqFqYSndFjWWu4yKUL14XjZ74KJs8MpDrWML+w/LyyNPSUuPjcpYGesjvQ2VZWnP+nKXAAAAHUrYDl1Y1ZKF5S5h/dDcw/caKk0F9fXbf31wuUuAdcYm5S6gQpSqqpPaPlm430VpaRiR6plT0vO2M7L1LZ9OVaml3OWxHtLbUDme+ejNFfV3ceD/6GuoPPq6SynVbFDuEtZrwnbowgZd/6Fyl7De2LTcBQAdTl8DrFxVqSULx52ZpYM/mCRZOviDWVwqpefNXypzZQB0dcv/HcPfxaHy6GuoPPq663j6Y7eXu4T1WnW5CwAAAGDd0tIwYoWvl245skyVAAAAAKy7rGyHLuyZj95c7hLWC3V19WlsnFvuMoAOVEl97S4nQGeonjmldWV7knSb8UAZqwGgUjzz0Zsr6u/iwDL6GiqPvobVJ2yHLsxzONaS7hukVLO43FUAHamC+vrvB91Q7hJgnbBRXV3mNTaWu4yKsMXdZ6XHn76ZplIpS7ccmW4zHkjt7WdnYf9heWnXM8pdHusZvQ2VpVSzQUX9XRz4P/oaKo++htUmbAcA6MKW9qwvdwmwTihtUJ+li6vKXUZFeHHMmdniL/+VXm94RvuCzUfmpfeenpYedWWsjPWR3gYAAGBdJmwHAACgVUuPuszc49upbXw23V+fmeY+DWmqG1jusgAAAADWOcJ2AAAA2miqGyhkBwAAAHgL1eUuAAAAAAAAAAC6GmE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAACioptwFrA+WLl1a7hKAdmhubk5zc3O5ywA6kL6GyqOvoTLpbag8+hoqj76GyqOvYfXzXWF7J6utrU1TU5PAHbqwxYsXp6mpqdxlAB1IX0Pl0ddQmfQ2VB59DZVHX0Pl0dew+oTtnayhoSEtLS3lLgNoh759+2bOnDnlLgPoQPoaKo++hsqkt6Hy6GuoPPoaKo++htUnbO9k3bp1S7du3cpdBtAO3bt3T/fu3ctdBtCB9DVUHn0NlUlvQ+XR11B59DVUHn0Nq6+63AUAAAAAAAAAQFcjbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKCgmnIXAAAAlMf0Z0uZOTNpaEi2GVhV7nIAAAAAoEsRtgMA0KXNmVsqdwldTuO8Us6/IHnwoX+N7TSslC+fmtRt1DVD91KpJXMb196fhb71XfP7BAAAAEDHEbYDAF3KwoXtD9N69Ch1yDysG/Y/0O9lUdXVyYYbJt88syrDhiYP/S0574JSjjwqaWnpqt/POWv1aLfdslYPxzpsgw188AIAAADWV8J2AKBLGbdPRwSBsztgDui6WlqSr5xalT13XxYS7rl7UiolZ5zVVYP2ta9jfhZRCSZNFLYDAADA+qq63AUAAABr37ChK369047lqQMAAAAAuior2wGALuW2W9q/grC+vm/mzl27t5ym81hhvGYe+tuyFe3LPfhw2UrpkjriZxEAAAAAXZuwHQDoUjri2bi9elVl8WJBWaW48TflrqDr+foZpVx4cSml0rIV7Q8+nFz0nVJ2GpacfVbX7I36uvrMbZy71o7nOd0AAAAACNsBAOjS+tYLPYv61lnJWd8qrfCM9veMTM74WlXqu+j3s2/f6lRVdc3aAQAAAOiahO0AALCeqa+vykXnV2X6s6XMnJk0NCTbDBRUAwAAAEARwnYAAFhPbTOwKtsMLHcVAAAAANA1VZe7AAAAAAAAAADoaoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAqqKXcB67qmpqZcd911mThxYp555pnMmjUrffr0yYgRI3LCCSdk++23L3eJAAAAAAAAAKxlVravQmNjY84555w0NTVl7NixOeqoozJq1KjceeedOfzww/Pwww+Xu0QAAAAAAAAA1jIr21ehrq4uEydOzGabbbbC+NNPP51DDz00F110Ua666qoyVQcAAAAAAABAOVjZvgq1tbVtgvYk2XbbbbPzzjvn/vvvT3NzcxkqAwAAAAAAAKBcrGxfDY8//niuvPLKTJkyJa+99lqbcH3OnDnp379/maoDAAAAAAAAYG0Ttq/C1KlT86lPfSpJsuuuu2bgwIHp1atXqqqq8sc//jFPPPFEmpqaylwlAAAAAAAAAGuTsH0VLr/88jQ1NeWaa67JiBEjVtj24IMPlqcoAAAAAAAAAMrKM9tX4fnnn099fX2boH3hwoV57LHHylQVAAAAAAAAAOUkbF+FhoaGNDY25umnn24dW7p0ac4999zMnj27jJUBAAAAAAAAUC5uI78Kn/zkJzNp0qR8/OMfzz777JPa2tpMnjw5L7/8ckaNGpXJkyeXu0QAAAAAAAAA1jIr21dhjz32yCWXXJKtttoqv/vd73LTTTfl7W9/e371q1+loaGh3OUBAAAAAAAAUAZVpVKpVO4iKtmcOXPKXQLQTn379tXLUGH0NVQefQ2VSW9D5dHXUHn0NVQefQ3L9O3bd5X7WNkOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAACqopdwEAAEB5VM16JtVzn09L/dtS6jeo3OUAAAAAQJcibAcAoOtZMLvcFXRtC+em5x/PSM3MB1qHljSMzKK9z0o2qC9fXe1Qql2aLGjsuAl7bdxxcwEAAABQkYTtAMC6q3lBp0xbaqrttLlZO3pfvmu5S+jSSlXVSW2fLNzvorQ0jEj1zCnpedsZ2fDq/VNVail3eWtkSZLeHTjf/C9M6cDZKLvuvcpdAQAAAFCBhO0AwDqr96UjOmXejg7loKupKrVk4bgzs3TwB5MkSwd/MItLpfS8+Utlrmzd0Vk/fyiP+V96vNwlAAAAABWoutwFAAAAa19Lw4ph8tItR5apEgAAAADomqxsBwDWWZ11G+f6+vrMnTu3U+Zm7bDquP2qZ05pXdmeJN1mPPAWe69/3EYeAAAAgFURtgMA665OesZuVe2GSfemTpmbtWP+5+4udwldWs8bT0qPP52dplIpS7ccmW4zHkjt7d/Kki3fk0X7XVzu8tZIfX1d5s5t7LgJPeMbAAAAgFUQtgMA0PX02rjcFXRpiz58SXr+/ssrPKN9ydbvzaJ9z0826FvGytZc1YZ9k6Zu5S4DAAAAgPWIsB0AANY3G/TNoo/8b6pmPZPquc+npf5tKfUbVO6qAAAAAKBLEbYDAMB6qtRvUJYK2QEAAABgjVSXuwAAAAAAAAAA6GqE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgoTtAAAAAAAAAFCQsB0AAAAAAAAAChK2AwAAAAAAAEBBwnYAAAAAAAAAKEjYDgAAAAAAAAAFCdsBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoSNgOAAAAAAAAAAUJ2wEAAAAAAACgIGE7AAAAAAAAABQkbAcAAAAAAACAgqpKpVKp3EUAAAAAAAAAQFdiZTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUJCwHQAAAAAAAAAKErYDAAAAAAAAQEHCdgAAAAAAAAAoqKbcBQB0locffjiXXnppHnzwwTQ3N2fQoEH51Kc+lf3333+1Xv/AAw/kj3/8YyZPnpyZM2dmwYIFaWhoyF577ZXjjjsuG220UZvX7Lnnnpk5c+ZK5zvssMPyzW9+s13vCdZ37e3r++67L0ceeeSbbr/uuuuy0047dfhxgTfX3v464ogjMnny5Lfc59xzz82BBx7Y+rXzNXSe3/72t5kyZUoeeeSRPPXUU2lubs5///d/5+CDDy40T0tLS6655ppcd911ee6559KrV6/svPPOOeWUUzJw4MCVvsb5GjpHR/S162tYt3REX7u+hnVLR/S162tYM8J2oCLdd999OeaYY9K9e/d86EMfSp8+fTJhwoR8+ctfzsyZM/O5z31ulXOcdNJJmTNnTkaMGJEDDjggVVVVmTx5cq688spMmDAhv/jFL9KvX782r+vTp08+9alPtRnfYYcdOuS9wfqqI/p6uVGjRmXUqFFtxjfffPNOPS6woo7or4MOOmil/bxkyZJcccUVqa6uzujRo9tsd76GzvGd73wnM2fOTN++fdO/f/83/Ye3VTnjjDPyy1/+MoMGDconP/nJzJo1K7///e9z99135xe/+EUGDRq0wv7O19B5OqKvXV/DuqWjzteJ62tYV3REX7u+hjVUAqgwzc3Npb333ru0ww47lB599NHW8ddff730oQ99qLT99tuXpk+fvsp5rrjiitLLL7+8wlhLS0vpjDPOKA0ePLh05plntnnNHnvsUdpjjz3a/R6AFXVUX997772lwYMHly655JK1elygrc7ur1tvvbU0ePDg0nHHHddmm/M1dJ677767NGPGjFKptOzv04MHDy6NHz++0Bz33HNPafDgwaWPf/zjpcWLF7eO/+UvfykNGTKk9IlPfGKF/Z2voXN1RF+7voZ1S0f0tetrWLd0RF+/GdfX8NY8sx2oOPfee2+ef/757Lffftl+++1bx3v37p0TTjghS5YsyQ033LDKeT772c+mf//+K4xVVVXlhBNOSJLcf//9HVs48KY6qq+7ynFhfdDZ/XX99dcnSQ455JB21wqsvve+971paGho1xzL+/fkk09ObW1t6/jo0aMzZsyY3H///Zk+fXrruPM1dK6O6GvX17Bu6Yi+Lsr5GjpXZ/a162t4a24jD1Sc5c+VGTNmTJttu+666wr7rImammU/Ort167bS7U1NTfn1r3+dl19+ORtttFGGDx+e7bbbbo2PB3R8Xz/77LO5+uqrs2jRogwYMCDvfe97s/HGG3f6cYF/6cz++sc//pG77747m266aXbfffeV7uN8Deuu++67L7169crw4cPbbBszZkz+/Oc/5/77788222yTxPkaujLX19D1ub6Gyub6GlZN2A5UnGeffTZJsvXWW7fZVldXl759++a5555b4/nHjx+f5F8XAv/u1VdfzWmnnbbC2Pve9758+9vfXunFBrBqHd3XN910U2666abWr3v27JkvfOELOfbYYzv1uMC/dGZ/jR8/Pi0tLTnooINa/xH/3zlfw7ppwYIFefXVVzN48OCVhm8DBw5M8q+fIW/8tfM1dD2ur6Hrc30Nlc31NayasB2oOPPnz0+S9OnTZ6Xbe/funX/84x9rNPfjjz+e733ve+nXr1+bi4YkOfjggzNq1KgMGjQotbW1mTZtWr773e/mrrvuygknnJBrr702VVVVa3RsWJ91VF9vvPHG+epXv5rdd989AwYMyLx583Lffffl/PPPz3nnnZfevXvn8MMP7/DjAm11Vn+VSqXW20++2S3unK9h3fX6668nWfYzYGWWjy//GfLGXztfQ9fi+hq6NtfXUPlcX8Pq8cx2gNX0wgsv5LjjjsvSpUtz4YUXrvRTeSeeeGJGjRqVjTfeOL17986wYcNyxRVXZMSIEfnrX/+aO++8swyVA8ttu+22OeaYY/KOd7wjG2ywQTbbbLN8+MMfzpVXXpnu3bvn0ksvTUtLS7nLBNrh3nvvzYwZMzJq1KiVrppJnK8BoNxcX0PX5/oaKp/ra1g9wnag4ixf7bJ8Vcy/mz9//pt+ivbNzJw5M5/61Kcye/bsXHLJJdlll11W+7XV1dU5+OCDkyRTp04tdFxgmc7o6zcaPHhwhg0bltdee22F29Z19nFhfdZZ/XX99dcnefNP3b8Z52tYNyzv+zeuXH+j5eNvXPnufA1di+trqGyur6FyuL6G1SNsByrO8uc4ruw5T42NjZkzZ86bfhJvZWbMmJEjjjgir7zySi6++OLssccehWvq27dvkmThwoWFXwt0fF+vzPI+XbRo0Vo9LqyvOqO/Ghsbc9ttt2WjjTbKBz7wgcI1OV9D+fXq1SubbrppZsyYkaVLl7bZvvx5r8t/hrzx187XsO5zfQ3rB9fX0PW5vobVJ2wHKs573vOeJMmkSZPabLv77ruTJKNGjVqtuWbMmJEjjzwyr7zySi666KLsvffea1TTww8/nCRpaGhYo9fD+q4j+3pllixZksceeyxVVVXZYost1tpxYX3WGf31u9/9Lk1NTdl///3Ts2fPwjU5X8O6YdSoUVmwYMFKV8Es/5mx/GfIG3/tfA3rNtfXsH5wfQ2VwfU1rD5hO1BxRo8ena222io33XRTHn/88dbx+fPn57LLLktNTU0OOuig1vHZs2dn2rRpmT179grzLP+HgJdffjkXXnhhxo0b95bHfeaZZzJv3rw24w888ECuuuqq1NbW5v3vf3873x2snzqqr//617+mVCqtMLZkyZJ8+9vfzsyZMzNmzJjU19ev8XGB1ddRff1Gv/rVr5K89S3unK9h3fFmfX3ooYcmSS6++OI0NTW1jt9zzz2ZNGlS3vOe92SbbbZpHXe+hnWH62uoPK6vofK4voaOVVX69zMiQAW49957c+yxx6Z79+7Zb7/90rt370yYMCEzZszIySefnOOPP75130svvTTf/e53c+KJJ+YLX/hC6/iee+6ZmTNnZqeddsqYMWNWepw37n/ppZfmyiuvzOjRo9PQ0JDa2to89dRTufvuu1NdXZ2zzjorH/3oRzvvTUOF66i+TpJ3v/vd2WyzzfL666/n/vvvz/Tp0zNgwID87Gc/a/OJ2yLHBYrpiL5e7pFHHslHPvKRvOtd78oNN9zwpsd0vobOdf3112fKlClJkqeeeiqPPvpohg8f3npb2L333rt1Netb9fXXvva1XH/99Rk0aFDGjh2bWbNm5fe//3169OiRX/ziFxk0aNAK+ztfQ+fpiL52fQ3rlo7q68T1NawrOurv4YnrayiqptwFAHSGXXbZJddcc00uueSS3HLLLWlubs6gQYNy0kkn5cMf/vBqzTFz5swkyYMPPpgHH3xwpfu88S8jO++8c6ZNm5bHHnsskydPTlNTU/r165d99903Rx11VHbcccd2vy9Yn3VEXx9++OH585//nMmTJ2fOnDmpqanJ2972tnzuc5/Lpz/96dTV1XXKcYGV68j+Wp1P3SfO19DZpkyZkl//+tcrjE2dOrX1lvANDQ2rdevob37zmxkyZEiuu+66/PSnP02vXr2yxx575JRTTllhVftyztfQeTqir11fw7qlI/ra9TWsWzrq7+GJ62soysp2AAAAAAAAACjIM9sBAAAAAAAAoCBhOwAAAAAAAAAUJGwHAAAAAAAAgIKE7QAAAAAAAABQkLAdAAAAAAAAAAoStgMAAAAAAABAQcJ2AAAAAAAAAChI2A4AAAAAAAAABQnbAQAAAAAAAKAgYTsAAAAAAAAAFCRsBwAAAAAAAICChO0AAAAAAAAAUND/B8kAdEfrRuVNAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "axes = az.plot_forest(\n", " [data_mcmc, data_svi],\n", @@ -694,7 +627,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.10.6 ('pymdp_env3')", + "display_name": "pymdp", "language": "python", "name": "python3" }, @@ -708,11 +641,11 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.6" + "version": "3.9.13" }, "vscode": { "interpreter": { - "hash": "32c08a4ac355ebac62cad37715f1d18a3925a14af2b6a4a96942ab426da83c5e" + "hash": "4e1a08fe767a14203a671ee5de76a8a25ed3badbbf81ba1baf234489164a8ba4" } } }, diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index 23453f76..ea3adaf2 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -1,7 +1,7 @@ import jax.numpy as jnp from jax import tree_util, jit, grad, lax, nn -from pymdp.jax.maths import compute_log_likelihood, log_stable +from pymdp.jax.maths import compute_log_likelihood, log_stable, MINVAL def add(x, y): return x + y @@ -14,7 +14,7 @@ def marginal_log_likelihood(qs, log_likelihood, i): joint = log_likelihood * x dims = (f for f in range(len(qs)) if f != i) marg = joint.sum(dims) - return jnp.where(marg < 0., marg/qs[i], marg) + return marg/jnp.clip(qs[i], a_min=MINVAL) def run_vanilla_fpi(A, obs, prior, num_iter=1): """ Vanilla fixed point iteration (jaxified) """ From 78e4d727280d03345d5368236fce24361ee6d5a0 Mon Sep 17 00:00:00 2001 From: Dimitrije Markovic <5038100+dimarkov@users.noreply.github.com> Date: Tue, 10 Jan 2023 16:37:17 +0100 Subject: [PATCH 035/232] illustrative example with pybefit --- examples/model_inversion.ipynb | 50 ++++++++++++++++++++++++++++++++-- 1 file changed, 48 insertions(+), 2 deletions(-) diff --git a/examples/model_inversion.ipynb b/examples/model_inversion.ipynb index 1d19efbb..563f3501 100644 --- a/examples/model_inversion.ipynb +++ b/examples/model_inversion.ipynb @@ -19,10 +19,56 @@ "import seaborn as sns\n", "import matplotlib.pyplot as plt\n", "\n", - "from pymdp.jax.agent import Agent\n", + "from pymdp.jax.agent import Agent as AIFAgent\n", "from pymdp.envs import TMazeEnv" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from pybefit import ModelInference\n", + "\n", + "def param_transform(z):\n", + " init = {} # define some initial values of random variables that should be infered\n", + " params = {} # define parameters that should be infered\n", + " return init, params\n", + "\n", + "\n", + "# we could simplify the interface so that AIFAgent class is constructed as \n", + "# aif_agent = AIFAgent(init_variables, params, options)\n", + "\n", + "# define some static options for the AIFAgent class\n", + "agent_options = {\n", + "\n", + "}\n", + "\n", + "# define properties of inference\n", + "inference_options = {\n", + " # e.g. method can be svi or nuts\n", + " 'method': 'SVI',\n", + " # different forms of the parameteric prior, such as, NormalGamma, NormalHorseshoe, NormalRegularizedHorseshoe\n", + " 'prior': 'NormalGamma',\n", + " # hierachical inference with group level \n", + " 'type': 'Hierarchical',\n", + "\n", + "}\n", + "\n", + "inference = ModelInference(AIFAgent, agent_options, inference_options)\n", + "\n", + "num_samples = 1000\n", + "max_iterations = 1000\n", + "tolerance = 1e-3\n", + "# optimizer options\n", + "opts = {\n", + " 'learning_rate': 1e-3\n", + "}\n", + "\n", + "inference.fit(behavioural_data, num_samples, max_iterations, tolerance, opts)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -880,7 +926,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.6" + "version": "3.11.0 | packaged by conda-forge | (main, Oct 25 2022, 06:18:27) [GCC 10.4.0]" }, "vscode": { "interpreter": { From 9ff3db7df2e27e6a40e8b0fc8b3cec06209f73c3 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 9 Mar 2023 17:49:01 +0100 Subject: [PATCH 036/232] - added `A_factor_list` and `B_factor_list` optional input arguments. If `None`, they will default to being `all` factors - infer `num_controls` from the last dimension of each `B[f]`, if not given. This needs to be changed from dimension `2` of each B sub-array, because now we allow inter-factor dependencies in `B` --- pymdp/agent.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/pymdp/agent.py b/pymdp/agent.py index 94d093e2..6b31cde2 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -61,7 +61,9 @@ def __init__( lr_pD=1.0, use_BMA = True, policy_sep_prior = False, - save_belief_hist = False + save_belief_hist = False, + A_factor_list = None, + B_factor_list = None ): ### Constant parameters ### @@ -119,7 +121,7 @@ def __init__( # If no `num_controls` are given, then this is inferred from the shapes of the input B matrices if num_controls == None: - self.num_controls = [self.B[f].shape[2] for f in range(self.num_factors)] + self.num_controls = [self.B[f].shape[-1] for f in range(self.num_factors)] else: self.num_controls = num_controls From cb17c6edbd2c2b2a355c7fbad39a6acff49d7c63 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 9 Mar 2023 17:59:55 +0100 Subject: [PATCH 037/232] added in checks to ensure consistency of factor lists with user-given `A` and `B` arrays --- pymdp/agent.py | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/pymdp/agent.py b/pymdp/agent.py index 6b31cde2..7d9683ad 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -124,6 +124,25 @@ def __init__( self.num_controls = [self.B[f].shape[-1] for f in range(self.num_factors)] else: self.num_controls = num_controls + + # checking that `A_factor_list` and `B_factor_list` are consistent with `num_factors`, `num_states`, and lagging dimensions of `A` and `B` tensors + if A_factor_list == None: + self.A_factor_list = list(range(self.num_factors)) + else: + for m in range(self.num_modalities): + assert max(A_factor_list[m]) <= (self.num_factors - 1), f"Check modality {m} of A_factor_list - must be consistent with `num_states` and `num_factors`..." + factor_dims = tuple([self.num_states[f] for f in A_factor_list[m]]) + assert self.A[m].shape[1:] == factor_dims, f"Check modality {m} of A_factor_list. It must coincide with lagging dimensions of A{m}..." + assert self.pA[m].shape[1:] == factor_dims, f"Check modality {m} of A_factor_list. It must coincide with lagging dimensions of pA{m}..." + + if B_factor_list == None: + B_factor_list = list(range(self.num_factors)) + else: + for f in range(self.num_factors): + assert max(B_factor_list[f]) <= (self.num_factors - 1), f"Check factor {f} of B_factor_list - must be consistent with `num_states` and `num_factors`..." + factor_dims = tuple([self.num_states[f] for f in B_factor_list[f]]) + assert self.B[f].shape[1:-1] == factor_dims, f"Check factor {f} of B_factor_list. It must coincide with all-but-final lagging dimensions of B{f}..." + assert self.pB[f].shape[1:-1] == factor_dims, f"Check factor {f} of B_factor_list. It must coincide with all-but-final lagging dimensions of pB{f}..." # Users have the option to make only certain factors controllable. # default behaviour is to make all hidden state factors controllable From da39163e9879bfeb6d5aa628bdd840e6dec13262 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 9 Mar 2023 20:03:21 +0100 Subject: [PATCH 038/232] fixed default values of `A_factor_list` and `B_factor_list` in case they are not provided (`None`) --- pymdp/agent.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/pymdp/agent.py b/pymdp/agent.py index 7d9683ad..92d09b63 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -127,7 +127,7 @@ def __init__( # checking that `A_factor_list` and `B_factor_list` are consistent with `num_factors`, `num_states`, and lagging dimensions of `A` and `B` tensors if A_factor_list == None: - self.A_factor_list = list(range(self.num_factors)) + self.A_factor_list = self.num_modalities * [list(range(self.num_factors))] # defaults to having all modalities depend on all factors else: for m in range(self.num_modalities): assert max(A_factor_list[m]) <= (self.num_factors - 1), f"Check modality {m} of A_factor_list - must be consistent with `num_states` and `num_factors`..." @@ -136,7 +136,7 @@ def __init__( assert self.pA[m].shape[1:] == factor_dims, f"Check modality {m} of A_factor_list. It must coincide with lagging dimensions of pA{m}..." if B_factor_list == None: - B_factor_list = list(range(self.num_factors)) + B_factor_list = [[f] for f in range(self.num_factors)] # defaults to having all factors depend only on themselves else: for f in range(self.num_factors): assert max(B_factor_list[f]) <= (self.num_factors - 1), f"Check factor {f} of B_factor_list - must be consistent with `num_states` and `num_factors`..." @@ -145,8 +145,7 @@ def __init__( assert self.pB[f].shape[1:-1] == factor_dims, f"Check factor {f} of B_factor_list. It must coincide with all-but-final lagging dimensions of pB{f}..." # Users have the option to make only certain factors controllable. - # default behaviour is to make all hidden state factors controllable - # (i.e. self.num_states == self.num_controls) + # default behaviour is to make all hidden state factors controllable, i.e. `self.num_factors == len(self.num_controls)` if control_fac_idx == None: self.control_fac_idx = [f for f in range(self.num_factors) if self.num_controls[f] > 1] else: From 4700c2b6f4482eb8aa44e6a019483d391bb1b0f9 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 9 Mar 2023 20:08:26 +0100 Subject: [PATCH 039/232] - check consistency `num_controls` in case provided by user - fixed D vector normalization error message --- pymdp/agent.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/pymdp/agent.py b/pymdp/agent.py index 92d09b63..72e6efc5 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -123,6 +123,8 @@ def __init__( if num_controls == None: self.num_controls = [self.B[f].shape[-1] for f in range(self.num_factors)] else: + inferred_num_controls = [self.B[f].shape[-1] for f in range(self.num_factors)] + assert num_controls == inferred_num_controls, "num_controls must be consistent with the shapes of the input B matrices" self.num_controls = num_controls # checking that `A_factor_list` and `B_factor_list` are consistent with `num_factors`, `num_states`, and lagging dimensions of `A` and `B` tensors @@ -203,7 +205,7 @@ def __init__( else: self.D = self._construct_D_prior() - assert utils.is_normalized(self.D), "A matrix is not normalized (i.e. A.sum(axis = 0) must all equal 1.0" + assert utils.is_normalized(self.D), "D vector is not normalized (i.e. D[f].sum() must all equal 1.0 for all factors)" # Assigning prior parameters on initial hidden states (pD vectors) self.pD = pD From 37aea404ef3ee12f70994ba825864fb1ee2758ff Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 9 Mar 2023 20:09:13 +0100 Subject: [PATCH 040/232] made B matrix error normalization message more specific --- pymdp/agent.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pymdp/agent.py b/pymdp/agent.py index 72e6efc5..5d0005f2 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -110,7 +110,7 @@ def __init__( self.B = utils.to_obj_array(B) - assert utils.is_normalized(self.B), "B matrix is not normalized (i.e. B.sum(axis = 0) must all equal 1.0)" + assert utils.is_normalized(self.B), "B matrix is not normalized (i.e. B[f].sum(axis = 0) must all equal 1.0 for all factors)" # Determine number of hidden state factors and their dimensionalities self.num_states = [self.B[f].shape[0] for f in range(len(self.B))] From 18052c9e58611253dba214836ab181aa96b26adf Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 9 Mar 2023 20:09:43 +0100 Subject: [PATCH 041/232] made `A` matrix normalization error message for specific --- pymdp/agent.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pymdp/agent.py b/pymdp/agent.py index 5d0005f2..b4220daa 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -93,7 +93,7 @@ def __init__( self.A = utils.to_obj_array(A) - assert utils.is_normalized(self.A), "A matrix is not normalized (i.e. A.sum(axis = 0) must all equal 1.0)" + assert utils.is_normalized(self.A), "A matrix is not normalized (i.e. A[m].sum(axis = 0) must all equal 1.0 for all modalities)" # Determine number of observation modalities and their respective dimensions self.num_obs = [self.A[m].shape[0] for m in range(len(self.A))] From 5c1d64666ae5f2aecf842e7dd5f6fc663434e8f7 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 9 Mar 2023 20:12:54 +0100 Subject: [PATCH 042/232] reset A and B parameters to expectations of Dirichlet prior distributions, in case those priors exist --- pymdp/agent.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/pymdp/agent.py b/pymdp/agent.py index b4220daa..cbbd2b36 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -331,6 +331,12 @@ def reset(self, init_qs=None): else: self.qs = init_qs + + if self.pA != None: + self.A = utils.norm_dist_obj_arr(self.pA) + + if self.pB != None: + self.B = utils.norm_dist_obj_arr(self.pB) return self.qs From 24e40e56998b29c2ec473d165a482c2c3aae7721 Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 10 Mar 2023 12:23:10 +0100 Subject: [PATCH 043/232] add `mb_dict` property to `Agent` class in its __init__ --- pymdp/agent.py | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/pymdp/agent.py b/pymdp/agent.py index cbbd2b36..28ba8f31 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -137,6 +137,17 @@ def __init__( assert self.A[m].shape[1:] == factor_dims, f"Check modality {m} of A_factor_list. It must coincide with lagging dimensions of A{m}..." assert self.pA[m].shape[1:] == factor_dims, f"Check modality {m} of A_factor_list. It must coincide with lagging dimensions of pA{m}..." + # generate a list of the modalities that depend on each factor + A_modality_list = [] + for f in range(self.num_factors): + A_modality_list.append( [m for m in range(self.num_modalities) if f in A_factor_list[m]] ) + + # Store thee `A_factor_list` and the `A_modality_list` in a Markov blanket dictionary + self.mb_dict = { + 'A_factor_list': A_factor_list, + 'A_modality_list': A_modality_list + } + if B_factor_list == None: B_factor_list = [[f] for f in range(self.num_factors)] # defaults to having all factors depend only on themselves else: From c43c1b1ff303c136b397719e7b929213c2e295e0 Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 10 Mar 2023 12:50:55 +0100 Subject: [PATCH 044/232] added in factorized version of fixed-point iteration algorithm into `fpi.py` module, where local markov blanket of each factors is used to compute the factor-wise expected energies. The variational free energy is also computed differently, whereby the temporary expected energies are accumulated online in order to compute the accuracy term of the VFE, and the complexity term is calculated at the end. untested --- pymdp/algos/fpi.py | 143 +++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 138 insertions(+), 5 deletions(-) diff --git a/pymdp/algos/fpi.py b/pymdp/algos/fpi.py index 37532130..e687f81d 100644 --- a/pymdp/algos/fpi.py +++ b/pymdp/algos/fpi.py @@ -3,8 +3,8 @@ # pylint: disable=no-member import numpy as np -from pymdp.maths import spm_dot, get_joint_likelihood, softmax, calc_free_energy, spm_log_single, spm_log_obj_array -from pymdp.utils import to_obj_array, obj_array_uniform +from pymdp.maths import spm_dot, dot_likelihood, get_joint_likelihood, softmax, calc_free_energy, spm_log_single, spm_log_obj_array +from pymdp.utils import to_obj_array, obj_array, obj_array_uniform from itertools import chain def run_vanilla_fpi(A, obs, num_obs, num_states, prior=None, num_iter=10, dF=1.0, dF_tol=0.001): @@ -63,9 +63,7 @@ def run_vanilla_fpi(A, obs, num_obs, num_states, prior=None, num_iter=10, dF=1.0 Create a flat posterior (and prior if necessary) """ - qs = np.empty(n_factors, dtype=object) - for factor in range(n_factors): - qs[factor] = np.ones(num_states[factor]) / num_states[factor] + qs = obj_array_uniform(num_states) """ If prior is not provided, initialise prior to be identical to posterior @@ -143,6 +141,141 @@ def run_vanilla_fpi(A, obs, num_obs, num_states, prior=None, num_iter=10, dF=1.0 return qs +def run_vanilla_fpi_factorized(A, obs, num_obs, num_states, mb_dict, prior=None, num_iter=10, dF=1.0, dF_tol=0.001): + """ + Update marginal posterior beliefs over hidden states using mean-field variational inference, via + fixed point iteration. + + Parameters + ---------- + A: ``numpy.ndarray`` of dtype object + Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of + stores an ``np.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store + the probability of observation level ``i`` given hidden state levels ``j, k, ...`` + obs: numpy 1D array or numpy ndarray of dtype object + The observation (generated by the environment). If single modality, this should be a 1D ``np.ndarray`` + (one-hot vector representation). If multi-modality, this should be ``np.ndarray`` of dtype object whose entries are 1D one-hot vectors. + num_obs: ``list`` of ints + List of dimensionalities of each observation modality + num_states: ``list`` of ints + List of dimensionalities of each hidden state factor + mb_dict: ``Dict`` + Dictionary with two keys (``A_factor_list`` and ``A_modality_list``), that stores the factor indices that influence each modality (``A_factor_list``) + and the modality indices influenced by each factor (``A_modality_list``). + prior: numpy ndarray of dtype object, default None + Prior over hidden states. If absent, prior is set to be the log uniform distribution over hidden states (identical to the + initialisation of the posterior) + num_iter: int, default 10 + Number of variational fixed-point iterations to run until convergence. + dF: float, default 1.0 + Initial free energy gradient (dF/dt) before updating in the course of gradient descent. + dF_tol: float, default 0.001 + Threshold value of the time derivative of the variational free energy (dF/dt), to be checked at + each iteration. If dF <= dF_tol, the iterations are halted pre-emptively and the final + marginal posterior belief(s) is(are) returned + + Returns + ---------- + qs: numpy 1D array, numpy ndarray of dtype object, optional + Marginal posterior beliefs over hidden states at current timepoint + """ + + # get model dimensions + n_modalities = len(num_obs) + n_factors = len(num_states) + + """ + =========== Step 1 =========== + Generate modality-specific log-likelihood tensors (will be tensors of different-shapes, + where `likelihood[m].ndim` will be equal to `len(mb_dict['A_factor_list'][m])` + """ + + likelihood = obj_array(num_modalities) + obs = to_obj_array(obs) + for (m, A_m) in enumerate(A): + likelihood[m] = dot_likelihood(A_m, obs[m]) + + log_likelihood = spm_log_obj_array(likelihood) + + """ + =========== Step 2 =========== + Create a flat posterior (and prior if necessary) + """ + + qs = obj_array_uniform(num_states) + + """ + If prior is not provided, initialise prior to be identical to posterior + (namely, a flat categorical distribution). Take the logarithm of it (required for + FPI algorithm below). + """ + if prior is None: + prior = obj_array_uniform(num_states) + + prior = spm_log_obj_array(prior) # log the prior + + + """ + =========== Step 3 =========== + Initialize initial free energy + """ + prev_vfe = calc_free_energy(qs, prior, n_factors) + + """ + =========== Step 4 =========== + If we have a single factor, we can just add prior and likelihood because there is a unique FE minimum that can reached instantaneously, + otherwise we run fixed point iteration + """ + + if n_factors == 1: + + joint_loglikelihood = np.zeros(tuple(num_states)) + for m in range(n_modalities): + joint_loglikelihood += log_likelihood[m] # add up all the log-likelihoods, since we know they will all have the same dimension in the case of a single hidden state factor + qL = spm_dot(joint_loglikelihood, qs, [0]) + + qs = to_obj_array(softmax(qL + prior[0])) + + else: + """ + =========== Step 5 =========== + Run the factorized FPI scheme + """ + + A_factor_list, A_modality_list = mb_dict['A_factor_list'], mb_dict['A_modality_list'] + curr_iter = 0 + while curr_iter < num_iter and dF >= dF_tol: + + vfe = 0 + for f in range(n_factors): + + ''' + Sum the expected log likelihoods E_q(s_i/f)[ln P(o=obs[m]|s)] for independent modalities together, + since they may have differing dimension. This obtains a marginal log-likelihood for the current factor index `factor`, + which includes the evidence for that particular factor afforded by the different modalities. + ''' + + qL = np.zeros(num_states[f]) + + for ii, m in enumerate(A_modality_list[f]): + + qL += spm_dot(log_likelihood[m], qs[A_factor_list[m]], [A_factor_list[m].index(f)]) + + qs[f] = softmax(qL + prior[f]) + + vfe -= qL.sum() # likelihood part of vfe, sum of factor-level expected energies E_q(s_i/f)[ln P(o=obs|s)] + + # calculate new free energy, leaving out the accuracy term + vfe += calc_free_energy(qs, prior, n_factors) + + # stopping condition - time derivative of free energy + dF = np.abs(prev_vfe - vfe) + prev_vfe = vfe + + curr_iter += 1 + + return qs + def _run_vanilla_fpi_faster(A, obs, n_observations, n_states, prior=None, num_iter=10, dF=1.0, dF_tol=0.001): """ From d183cb0cda65b0430685a7b360c56f94cc225de8 Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 10 Mar 2023 12:51:47 +0100 Subject: [PATCH 045/232] factorized version of `update_posterior_states` (that calls `run_vanilla_fpi_factorized` from `fpi` module in `algos`) now provided in `inference` module --- pymdp/inference.py | 46 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 45 insertions(+), 1 deletion(-) diff --git a/pymdp/inference.py b/pymdp/inference.py index 8a77e74c..7b28dadb 100644 --- a/pymdp/inference.py +++ b/pymdp/inference.py @@ -240,4 +240,48 @@ def update_posterior_states(A, obs, prior=None, **kwargs): prior = utils.to_obj_array(prior) return run_vanilla_fpi(A, obs, num_obs, num_states, prior, **kwargs) - + +def update_posterior_states_factorized(A, obs, mb_dict, prior=None, **kwargs): + """ + Update marginal posterior over hidden states using mean-field fixed point iteration + FPI or Fixed point iteration. This version identifies the Markov blanket of each factor using `A_factor_list` + + See the following links for details: + http://www.cs.cmu.edu/~guestrin/Class/10708/recitations/r9/VI-view.pdf, slides 13- 18, and http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.137.221&rep=rep1&type=pdf, slides 24 - 38. + + Parameters + ---------- + A: ``numpy.ndarray`` of dtype object + Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of + stores an ``np.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store + the probability of observation level ``i`` given hidden state levels ``j, k, ...`` + obs: 1D ``numpy.ndarray``, ``numpy.ndarray`` of dtype object, int or tuple + The observation (generated by the environment). If single modality, this can be a 1D ``np.ndarray`` + (one-hot vector representation) or an ``int`` (observation index) + If multi-modality, this can be ``np.ndarray`` of dtype object whose entries are 1D one-hot vectors, + or a tuple (of ``int``) + mb_dict: ``Dict`` + Dictionary with two keys (``A_factor_list`` and ``A_modality_list``), that stores the factor indices that influence each modality (``A_factor_list``) + and the modality indices influenced by each factor (``A_modality_list``). + prior: 1D ``numpy.ndarray`` or ``numpy.ndarray`` of dtype object, default None + Prior beliefs about hidden states, to be integrated with the marginal likelihood to obtain + a posterior distribution. If not provided, prior is set to be equal to a flat categorical distribution (at the level of + the individual inference functions). + **kwargs: keyword arguments + List of keyword/parameter arguments corresponding to parameter values for the fixed-point iteration + algorithm ``algos.fpi.run_vanilla_fpi.py`` + + Returns + ---------- + qs: 1D ``numpy.ndarray`` or ``numpy.ndarray`` of dtype object + Marginal posterior beliefs over hidden states at current timepoint + """ + + num_obs, num_states, num_modalities, num_factors = utils.get_model_dimensions(A = A) + + obs = utils.process_observation(obs, num_modalities, num_obs) + + if prior is not None: + prior = utils.to_obj_array(prior) + + return run_vanilla_fpi_factorized(A, obs, num_obs, num_states, mb_dict, prior, **kwargs) From bd4463d62f5cff95d91f7be6d57810f3836c2674 Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 10 Mar 2023 13:57:28 +0100 Subject: [PATCH 046/232] added print messages to track posterior evolution during fixed point updates --- pymdp/algos/fpi.py | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/pymdp/algos/fpi.py b/pymdp/algos/fpi.py index e687f81d..90727505 100644 --- a/pymdp/algos/fpi.py +++ b/pymdp/algos/fpi.py @@ -119,6 +119,9 @@ def run_vanilla_fpi(A, obs, num_obs, num_states, prior=None, num_iter=10, dF=1.0 qL = np.einsum(LL_tensor, list(range(n_factors)), [factor])/qs_i qs[factor] = softmax(qL + prior[factor]) + print(f'Posteriors at iteration {curr_iter}:\n') + print(qs[0]) + print(qs[1]) # List of orders in which marginal posteriors are sequentially multiplied into the joint likelihood: # First order loops over factors starting at index = 0, second order goes in reverse # factor_orders = [range(n_factors), range((n_factors - 1), -1, -1)] @@ -133,6 +136,7 @@ def run_vanilla_fpi(A, obs, num_obs, num_states, prior=None, num_iter=10, dF=1.0 # calculate new free energy vfe = calc_free_energy(qs, prior, n_factors, likelihood) + # print(f'VFE at iteration {curr_iter}: {vfe}\n') # stopping condition - time derivative of free energy dF = np.abs(prev_vfe - vfe) prev_vfe = vfe @@ -190,7 +194,7 @@ def run_vanilla_fpi_factorized(A, obs, num_obs, num_states, mb_dict, prior=None, where `likelihood[m].ndim` will be equal to `len(mb_dict['A_factor_list'][m])` """ - likelihood = obj_array(num_modalities) + likelihood = obj_array(n_modalities) obs = to_obj_array(obs) for (m, A_m) in enumerate(A): likelihood[m] = dot_likelihood(A_m, obs[m]) @@ -264,10 +268,13 @@ def run_vanilla_fpi_factorized(A, obs, num_obs, num_states, mb_dict, prior=None, qs[f] = softmax(qL + prior[f]) vfe -= qL.sum() # likelihood part of vfe, sum of factor-level expected energies E_q(s_i/f)[ln P(o=obs|s)] - + print(f'Posteriors at iteration {curr_iter}:\n') + print(qs[0]) + print(qs[1]) # calculate new free energy, leaving out the accuracy term vfe += calc_free_energy(qs, prior, n_factors) + # print(f'VFE at iteration {curr_iter}: {vfe}\n') # stopping condition - time derivative of free energy dF = np.abs(prev_vfe - vfe) prev_vfe = vfe From 413c42489a070a17fd3dc1a3922c58f2c0206c2e Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 10 Mar 2023 13:57:49 +0100 Subject: [PATCH 047/232] import `run_vanilla_fpi_factorized` in the algos module __init__.py file --- pymdp/algos/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pymdp/algos/__init__.py b/pymdp/algos/__init__.py index 09e9272f..0cf505f9 100644 --- a/pymdp/algos/__init__.py +++ b/pymdp/algos/__init__.py @@ -1,2 +1,2 @@ -from .fpi import run_vanilla_fpi +from .fpi import run_vanilla_fpi, run_vanilla_fpi_factorized from .mmp import run_mmp, _run_mmp_testing From f645b0c24e52684c26eb4545c6dd0d98a3b4b4bb Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 10 Mar 2023 13:58:20 +0100 Subject: [PATCH 048/232] unit tests for fixed point iteration functions, currently failing unless `num_iters` set very high and `dF_tol` set very low --- test/test_fpi.py | 96 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 96 insertions(+) create mode 100644 test/test_fpi.py diff --git a/test/test_fpi.py b/test/test_fpi.py new file mode 100644 index 00000000..0eb2ec78 --- /dev/null +++ b/test/test_fpi.py @@ -0,0 +1,96 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +""" Unit Tests for factorized version of variational fixed point iteration (FPI or "Vanilla FPI") +__author__: Conor Heins +""" + +import os +import unittest + +import numpy as np + +from pymdp import utils, maths +from pymdp.algos import run_vanilla_fpi, run_vanilla_fpi_factorized + +class TestFPI(unittest.TestCase): + + def test_factorized_fpi_one_factor_one_modality(self): + """ + Test the sparsified version of `run_vanilla_fpi`, named `run_vanilla_fpi_factorized` + with single hidden state factor and single observation modality. + """ + + num_states = [3] + num_obs = [3] + + prior = utils.random_single_categorical(num_states) + + A = utils.to_obj_array(maths.softmax(np.eye(num_states[0]) * 0.1)) + + obs_idx = np.random.choice(num_obs[0]) + obs = utils.onehot(obs_idx, num_obs[0]) + + mb_dict = {'A_factor_list': [[0]], + 'A_modality_list': [[0]]} + + qs_out = run_vanilla_fpi_factorized(A, obs, num_obs, num_states, mb_dict, prior=prior)[0] + qs_validation_1 = run_vanilla_fpi(A, obs, num_obs, num_states, prior=prior)[0] + qs_validation_2 = maths.softmax(maths.spm_log_single(A[0][obs_idx,:]) + maths.spm_log_single(prior[0])) + + self.assertTrue(np.isclose(qs_validation_1, qs_out).all()) + self.assertTrue(np.isclose(qs_validation_2, qs_out).all()) + + def test_factorized_fpi_one_factor_multi_modality(self): + """ + Test the sparsified version of `run_vanilla_fpi`, named `run_vanilla_fpi_factorized` + with single hidden state factor and multiple observation modalities. + """ + + num_states = [3] + num_obs = [3, 2] + + prior = utils.random_single_categorical(num_states) + + A = utils.random_A_matrix(num_obs, num_states) + + obs = utils.obj_array(len(num_obs)) + for m, obs_dim in enumerate(num_obs): + obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) + + mb_dict = {'A_factor_list': [[0], [0]], + 'A_modality_list': [[0, 1]]} + + qs_out = run_vanilla_fpi_factorized(A, obs, num_obs, num_states, mb_dict, prior=prior)[0] + qs_validation = run_vanilla_fpi(A, obs, num_obs, num_states, prior=prior)[0] + + self.assertTrue(np.isclose(qs_validation, qs_out).all()) + + def test_factorized_fpi_multi_factor_one_modality(self): + """ + Test the sparsified version of `run_vanilla_fpi`, named `run_vanilla_fpi_factorized` + with multiple hidden state factors and one observation modality. + """ + + num_states = [4, 5] + num_obs = [3] + + prior = utils.random_single_categorical(num_states) + + A = utils.random_A_matrix(num_obs, num_states) + + obs_idx = np.random.choice(num_obs[0]) + obs = utils.onehot(obs_idx, num_obs[0]) + + mb_dict = {'A_factor_list': [[0, 1]], + 'A_modality_list': [[0], [0]]} + + qs_out = run_vanilla_fpi_factorized(A, obs, num_obs, num_states, mb_dict, prior=prior, num_iter=5, dF_tol=1e-10) + qs_validation = run_vanilla_fpi(A, obs, num_obs, num_states, prior=prior, num_iter=5, dF_tol=1e-10) + + for qs_f_val, qs_f_out in zip(qs_validation, qs_out): + self.assertTrue(np.isclose(qs_f_val, qs_f_out).all()) + + +if __name__ == "__main__": + unittest.main() \ No newline at end of file From 77858faddfcea9627e7140ab365207314bdc8712 Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 10 Mar 2023 15:00:39 +0100 Subject: [PATCH 049/232] removed factor-order dependence in `run_vanilla_fpi_factorized` by initializing a new set of empty posteriors per variational iteration. order of factor updates doesn't matter per iteration, since they are all conditionally independent given the previous iteration --- pymdp/algos/fpi.py | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/pymdp/algos/fpi.py b/pymdp/algos/fpi.py index 90727505..ecf3e0d6 100644 --- a/pymdp/algos/fpi.py +++ b/pymdp/algos/fpi.py @@ -6,6 +6,7 @@ from pymdp.maths import spm_dot, dot_likelihood, get_joint_likelihood, softmax, calc_free_energy, spm_log_single, spm_log_obj_array from pymdp.utils import to_obj_array, obj_array, obj_array_uniform from itertools import chain +from copy import deepcopy def run_vanilla_fpi(A, obs, num_obs, num_states, prior=None, num_iter=10, dF=1.0, dF_tol=0.001): """ @@ -119,9 +120,9 @@ def run_vanilla_fpi(A, obs, num_obs, num_states, prior=None, num_iter=10, dF=1.0 qL = np.einsum(LL_tensor, list(range(n_factors)), [factor])/qs_i qs[factor] = softmax(qL + prior[factor]) - print(f'Posteriors at iteration {curr_iter}:\n') - print(qs[0]) - print(qs[1]) + # print(f'Posteriors at iteration {curr_iter}:\n') + # print(qs[0]) + # print(qs[1]) # List of orders in which marginal posteriors are sequentially multiplied into the joint likelihood: # First order loops over factors starting at index = 0, second order goes in reverse # factor_orders = [range(n_factors), range((n_factors - 1), -1, -1)] @@ -251,6 +252,8 @@ def run_vanilla_fpi_factorized(A, obs, num_obs, num_states, mb_dict, prior=None, while curr_iter < num_iter and dF >= dF_tol: vfe = 0 + + qs_new = obj_array(n_factors) for f in range(n_factors): ''' @@ -265,12 +268,14 @@ def run_vanilla_fpi_factorized(A, obs, num_obs, num_states, mb_dict, prior=None, qL += spm_dot(log_likelihood[m], qs[A_factor_list[m]], [A_factor_list[m].index(f)]) - qs[f] = softmax(qL + prior[f]) + qs_new[f] = softmax(qL + prior[f]) vfe -= qL.sum() # likelihood part of vfe, sum of factor-level expected energies E_q(s_i/f)[ln P(o=obs|s)] - print(f'Posteriors at iteration {curr_iter}:\n') - print(qs[0]) - print(qs[1]) + + qs = deepcopy(qs_new) + # print(f'Posteriors at iteration {curr_iter}:\n') + # print(qs[0]) + # print(qs[1]) # calculate new free energy, leaving out the accuracy term vfe += calc_free_energy(qs, prior, n_factors) From 9789549387f2c3ef08b067d32a10df31fdc1b166 Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 10 Mar 2023 15:44:30 +0100 Subject: [PATCH 050/232] temporary fix: to compute variational free energy accurately in factorized FPI algorithm, create the full joint log-likelihood by adding together all the modality-specific factorized likelihoods (dimensionality expansion) --- pymdp/algos/fpi.py | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/pymdp/algos/fpi.py b/pymdp/algos/fpi.py index ecf3e0d6..716cbcb3 100644 --- a/pymdp/algos/fpi.py +++ b/pymdp/algos/fpi.py @@ -248,10 +248,18 @@ def run_vanilla_fpi_factorized(A, obs, num_obs, num_states, mb_dict, prior=None, """ A_factor_list, A_modality_list = mb_dict['A_factor_list'], mb_dict['A_modality_list'] + joint_loglikelihood = np.zeros(tuple(num_states)) + for m in range(n_modalities): + reshape_dims = n_factors*[1] + for _f_id in A_factor_list[m]: + reshape_dims[_f_id] = num_states[_f_id] + + joint_loglikelihood += log_likelihood[m].reshape(reshape_dims) # add up all the log-likelihoods after reshaping them to the global common dimensions of all hidden state factors + curr_iter = 0 while curr_iter < num_iter and dF >= dF_tol: - vfe = 0 + # vfe = 0 qs_new = obj_array(n_factors) for f in range(n_factors): @@ -270,14 +278,16 @@ def run_vanilla_fpi_factorized(A, obs, num_obs, num_states, mb_dict, prior=None, qs_new[f] = softmax(qL + prior[f]) - vfe -= qL.sum() # likelihood part of vfe, sum of factor-level expected energies E_q(s_i/f)[ln P(o=obs|s)] + # vfe -= qL.sum() # accuracy part of vfe, sum of factor-level expected energies E_q(s_i/f)[ln P(o=obs|s)] qs = deepcopy(qs_new) # print(f'Posteriors at iteration {curr_iter}:\n') # print(qs[0]) # print(qs[1]) # calculate new free energy, leaving out the accuracy term - vfe += calc_free_energy(qs, prior, n_factors) + # vfe += calc_free_energy(qs, prior, n_factors) + + vfe = calc_free_energy(qs, prior, n_factors, likelihood=joint_loglikelihood) # print(f'VFE at iteration {curr_iter}: {vfe}\n') # stopping condition - time derivative of free energy From abd346d637862ef1cae29069e470c85a52ae212e Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 10 Mar 2023 15:45:14 +0100 Subject: [PATCH 051/232] third unit test (multi-factor, single modality) of run_vanilla_fpi_factorized now passing --- test/test_fpi.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/test_fpi.py b/test/test_fpi.py index 0eb2ec78..a853f81f 100644 --- a/test/test_fpi.py +++ b/test/test_fpi.py @@ -85,8 +85,8 @@ def test_factorized_fpi_multi_factor_one_modality(self): mb_dict = {'A_factor_list': [[0, 1]], 'A_modality_list': [[0], [0]]} - qs_out = run_vanilla_fpi_factorized(A, obs, num_obs, num_states, mb_dict, prior=prior, num_iter=5, dF_tol=1e-10) - qs_validation = run_vanilla_fpi(A, obs, num_obs, num_states, prior=prior, num_iter=5, dF_tol=1e-10) + qs_out = run_vanilla_fpi_factorized(A, obs, num_obs, num_states, mb_dict, prior=prior) + qs_validation = run_vanilla_fpi(A, obs, num_obs, num_states, prior=prior) for qs_f_val, qs_f_out in zip(qs_validation, qs_out): self.assertTrue(np.isclose(qs_f_val, qs_f_out).all()) From 26e8f4375e6794620de01e1bd0cda9e77328a75d Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 10 Mar 2023 18:13:00 +0100 Subject: [PATCH 052/232] added optional ability to supply `A_factor_list` of conditionally-dependent state factors to `random_A_matrix` constructor in `utils` module --- pymdp/utils.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/pymdp/utils.py b/pymdp/utils.py index 3934f09b..c938d6a3 100644 --- a/pymdp/utils.py +++ b/pymdp/utils.py @@ -87,16 +87,21 @@ def onehot(value, num_values): arr[value] = 1.0 return arr -def random_A_matrix(num_obs, num_states): +def random_A_matrix(num_obs, num_states, A_factor_list=None): if type(num_obs) is int: num_obs = [num_obs] if type(num_states) is int: num_states = [num_states] num_modalities = len(num_obs) + if A_factor_list is None: + num_factors = len(num_states) + A_factor_list = [list(range(num_factors))] * num_modalities + A = obj_array(num_modalities) for modality, modality_obs in enumerate(num_obs): - modality_shape = [modality_obs] + num_states + lagging_dimensions = [ns for i, ns in enumerate(num_states) if i in A_factor_list[modality]] + modality_shape = [modality_obs] + lagging_dimensions modality_dist = np.random.rand(*modality_shape) A[modality] = norm_dist(modality_dist) return A From 182e6a50362689c74e0d237cac216c56b3b63d1a Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 10 Mar 2023 18:13:41 +0100 Subject: [PATCH 053/232] added and passed two more unit tests for new factorized FPI functions: - multi-factor / multi-modality, validated with fully-connected dependencies - multi-factor/multi-modality, but with sparse conditional dependence graph --- test/test_fpi.py | 62 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 62 insertions(+) diff --git a/test/test_fpi.py b/test/test_fpi.py index a853f81f..70a55635 100644 --- a/test/test_fpi.py +++ b/test/test_fpi.py @@ -90,6 +90,68 @@ def test_factorized_fpi_multi_factor_one_modality(self): for qs_f_val, qs_f_out in zip(qs_validation, qs_out): self.assertTrue(np.isclose(qs_f_val, qs_f_out).all()) + + def test_factorized_fpi_multi_factor_multi_modality(self): + """ + Test the sparsified version of `run_vanilla_fpi`, named `run_vanilla_fpi_factorized` + with multiple hidden state factors and multiple observation modalities. + """ + + num_states = [3, 4] + num_obs = [3, 3, 5] + + prior = utils.random_single_categorical(num_states) + + A = utils.random_A_matrix(num_obs, num_states) + + obs = utils.obj_array(len(num_obs)) + for m, obs_dim in enumerate(num_obs): + obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) + + mb_dict = {'A_factor_list': [[0, 1], [0, 1], [0, 1]], + 'A_modality_list': [[0, 1, 2], [0, 1, 2]]} + + qs_out = run_vanilla_fpi_factorized(A, obs, num_obs, num_states, mb_dict, prior=prior) + qs_validation = run_vanilla_fpi(A, obs, num_obs, num_states, prior=prior) + + for qs_f_val, qs_f_out in zip(qs_validation, qs_out): + self.assertTrue(np.isclose(qs_f_val, qs_f_out).all()) + + def test_factorized_fpi_multi_factor_multi_modality_with_condind(self): + """ + Test the sparsified version of `run_vanilla_fpi`, named `run_vanilla_fpi_factorized` + with multiple hidden state factors and multiple observation modalities, where some modalities only depend on some factors. + """ + + num_states = [3, 4] + num_obs = [3, 3, 5] + + prior = utils.random_single_categorical(num_states) + + obs = utils.obj_array(len(num_obs)) + for m, obs_dim in enumerate(num_obs): + obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) + + mb_dict = {'A_factor_list': [[0], [1], [0, 1]], + 'A_modality_list': [[0, 2], [1, 2]]} + + A_reduced = utils.random_A_matrix(num_obs, num_states, A_factor_list=mb_dict['A_factor_list']) + + qs_out = run_vanilla_fpi_factorized(A_reduced, obs, num_obs, num_states, mb_dict, prior=prior) + + A_full = utils.initialize_empty_A(num_obs, num_states) + for m, A_m in enumerate(A_full): + other_factors = list(set(range(len(num_states))) - set(mb_dict['A_factor_list'][m])) # list of the factors that modality `m` does not depend on + + # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` + expanded_dims = [num_obs[m]] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] + tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] + A_full[m] = np.tile(A_reduced[m].reshape(expanded_dims), tile_dims) + + qs_validation = run_vanilla_fpi(A_full, obs, num_obs, num_states, prior=prior) + + for qs_f_val, qs_f_out in zip(qs_validation, qs_out): + self.assertTrue(np.isclose(qs_f_val, qs_f_out).all()) if __name__ == "__main__": From 1652b8385308602191bbb264da478065b91c3132 Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 10 Mar 2023 22:06:02 +0100 Subject: [PATCH 054/232] tested one modality, two hidden state factor model where only one hidden state factor influences observations --- test/test_fpi.py | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/test/test_fpi.py b/test/test_fpi.py index 70a55635..33b167b2 100644 --- a/test/test_fpi.py +++ b/test/test_fpi.py @@ -152,6 +152,44 @@ def test_factorized_fpi_multi_factor_multi_modality_with_condind(self): for qs_f_val, qs_f_out in zip(qs_validation, qs_out): self.assertTrue(np.isclose(qs_f_val, qs_f_out).all()) + + def test_factorized_fpi_multi_factor_single_modality_with_condind(self): + """ + Test the sparsified version of `run_vanilla_fpi`, named `run_vanilla_fpi_factorized` + with multiple hidden state factors and one observation modality, where the modality only depend on some factors. + """ + + num_states = [3, 4] + num_obs = [3] + + prior = utils.random_single_categorical(num_states) + + obs = utils.obj_array(len(num_obs)) + for m, obs_dim in enumerate(num_obs): + obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) + + mb_dict = {'A_factor_list': [[0]], + 'A_modality_list': [[0], []]} + + A_reduced = utils.random_A_matrix(num_obs, num_states, A_factor_list=mb_dict['A_factor_list']) + + qs_out = run_vanilla_fpi_factorized(A_reduced, obs, num_obs, num_states, mb_dict, prior=prior) + + A_full = utils.initialize_empty_A(num_obs, num_states) + for m, A_m in enumerate(A_full): + other_factors = list(set(range(len(num_states))) - set(mb_dict['A_factor_list'][m])) # list of the factors that modality `m` does not depend on + + # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` + expanded_dims = [num_obs[m]] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] + tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] + A_full[m] = np.tile(A_reduced[m].reshape(expanded_dims), tile_dims) + + qs_validation = run_vanilla_fpi(A_full, obs, num_obs, num_states, prior=prior) + + for qs_f_val, qs_f_out in zip(qs_validation, qs_out): + self.assertTrue(np.isclose(qs_f_val, qs_f_out).all()) + + self.assertTrue(np.isclose(qs_out[1], prior[1]).all()) if __name__ == "__main__": From e19a160e7e922cc25cb45bd20dcdee8060b32d6b Mon Sep 17 00:00:00 2001 From: conorheins Date: Mon, 13 Mar 2023 12:39:09 +0100 Subject: [PATCH 055/232] added unit-tests of new inference function `update_posterior_states_factorized` which does some observation / prior pre-processing before passing inputs to `run_vanilla_fpi_factorized` --- test/test_inference.py | 64 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+) diff --git a/test/test_inference.py b/test/test_inference.py index c84a958a..10be48de 100644 --- a/test/test_inference.py +++ b/test/test_inference.py @@ -108,6 +108,70 @@ def test_update_posterior_states(self): for factor in range(len(num_states)): self.assertTrue(np.isclose(qs_out1[factor], qs_out2[factor]).all()) + def test_update_posterior_states_factorized_single_factor(self): + """ + Tests the version of `update_posterior_states` where an `mb_dict` is provided as an argument to factorize + the fixed-point iteration (FPI) algorithm. Single factor version. + """ + num_states = [3] + num_obs = [3] + + prior = utils.random_single_categorical(num_states) + + A = utils.to_obj_array(maths.softmax(np.eye(num_states[0]) * 0.1)) + + obs_idx = 1 + obs = utils.onehot(obs_idx, num_obs[0]) + + mb_dict = {'A_factor_list': [[0]], + 'A_modality_list': [[0]]} + + qs_out = inference.update_posterior_states_factorized(A, obs, num_obs, num_states, mb_dict, prior=prior) + qs_validation = maths.softmax(maths.spm_log_single(A[0][obs_idx,:]) + maths.spm_log_single(prior[0])) + + self.assertTrue(np.isclose(qs_validation, qs_out[0]).all()) + + '''Try single modality inference where the observation is passed in as an int''' + qs_out_2 = inference.update_posterior_states_factorized(A, obs_idx, num_obs, num_states, mb_dict, prior=prior) + self.assertTrue(np.isclose(qs_out_2[0], qs_out[0]).all()) + + '''Try single modality inference where the observation is a one-hot stored in an object array''' + qs_out_3 = inference.update_posterior_states_factorized(A, utils.to_obj_array(obs),num_obs, num_states, mb_dict, prior=prior) + self.assertTrue(np.isclose(qs_out_3[0], qs_out[0]).all()) + + def test_update_posterior_states_factorized(self): + """ + Tests the version of `update_posterior_states` where an `mb_dict` is provided as an argument to factorize + the fixed-point iteration (FPI) algorithm. + """ + + num_states = [3, 4] + num_obs = [3, 3, 5] + + prior = utils.random_single_categorical(num_states) + + obs_index_tuple = tuple([np.random.randint(obs_dim) for obs_dim in num_obs]) + + mb_dict = {'A_factor_list': [[0], [1], [0, 1]], + 'A_modality_list': [[0, 2], [1, 2]]} + + A_reduced = utils.random_A_matrix(num_obs, num_states, A_factor_list=mb_dict['A_factor_list']) + + qs_out = inference.update_posterior_states_factorized(A_reduced, obs_index_tuple, num_obs, num_states, mb_dict, prior=prior) + + A_full = utils.initialize_empty_A(num_obs, num_states) + for m, A_m in enumerate(A_full): + other_factors = list(set(range(len(num_states))) - set(mb_dict['A_factor_list'][m])) # list of the factors that modality `m` does not depend on + + # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` + expanded_dims = [num_obs[m]] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] + tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] + A_full[m] = np.tile(A_reduced[m].reshape(expanded_dims), tile_dims) + + qs_validation = inference.update_posterior_states(A_full, obs_index_tuple, prior=prior) + + for qs_f_val, qs_f_out in zip(qs_validation, qs_out): + self.assertTrue(np.isclose(qs_f_val, qs_f_out).all()) if __name__ == "__main__": From 22a8ad8881733e1263f490d3ea4a319ac703ae1d Mon Sep 17 00:00:00 2001 From: conorheins Date: Mon, 13 Mar 2023 12:39:59 +0100 Subject: [PATCH 056/232] import `run_vanilla_fpi_factorized` into `inference` module, and pass `num_obs` and `num_states` into `update_posterior_states_factorized`, removing need to call `utils.get_model_dimensions()` within the function --- pymdp/inference.py | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/pymdp/inference.py b/pymdp/inference.py index 7b28dadb..a84f7609 100644 --- a/pymdp/inference.py +++ b/pymdp/inference.py @@ -6,7 +6,7 @@ from pymdp import utils from pymdp.maths import get_joint_likelihood_seq -from pymdp.algos import run_vanilla_fpi, run_mmp, _run_mmp_testing +from pymdp.algos import run_vanilla_fpi, run_vanilla_fpi_factorized, run_mmp, _run_mmp_testing VANILLA = "VANILLA" VMP = "VMP" @@ -232,7 +232,7 @@ def update_posterior_states(A, obs, prior=None, **kwargs): Marginal posterior beliefs over hidden states at current timepoint """ - num_obs, num_states, num_modalities, num_factors = utils.get_model_dimensions(A = A) + num_obs, num_states, num_modalities, _ = utils.get_model_dimensions(A = A) obs = utils.process_observation(obs, num_modalities, num_obs) @@ -241,7 +241,7 @@ def update_posterior_states(A, obs, prior=None, **kwargs): return run_vanilla_fpi(A, obs, num_obs, num_states, prior, **kwargs) -def update_posterior_states_factorized(A, obs, mb_dict, prior=None, **kwargs): +def update_posterior_states_factorized(A, obs, num_obs, num_states, mb_dict, prior=None, **kwargs): """ Update marginal posterior over hidden states using mean-field fixed point iteration FPI or Fixed point iteration. This version identifies the Markov blanket of each factor using `A_factor_list` @@ -260,6 +260,10 @@ def update_posterior_states_factorized(A, obs, mb_dict, prior=None, **kwargs): (one-hot vector representation) or an ``int`` (observation index) If multi-modality, this can be ``np.ndarray`` of dtype object whose entries are 1D one-hot vectors, or a tuple (of ``int``) + num_obs: ``list`` of ``int`` + List of dimensionalities of each observation modality + num_states: ``list`` of ``int`` + List of dimensionalities of each hidden state factor mb_dict: ``Dict`` Dictionary with two keys (``A_factor_list`` and ``A_modality_list``), that stores the factor indices that influence each modality (``A_factor_list``) and the modality indices influenced by each factor (``A_modality_list``). @@ -277,7 +281,7 @@ def update_posterior_states_factorized(A, obs, mb_dict, prior=None, **kwargs): Marginal posterior beliefs over hidden states at current timepoint """ - num_obs, num_states, num_modalities, num_factors = utils.get_model_dimensions(A = A) + num_modalities = len(num_obs) obs = utils.process_observation(obs, num_modalities, num_obs) From 7932986902e199d321e181c1925f00bb8dd19086 Mon Sep 17 00:00:00 2001 From: conorheins Date: Mon, 13 Mar 2023 12:40:38 +0100 Subject: [PATCH 057/232] added optional `factorized` argument into `get_model_dimensions`, which blocks the function from inferring `num_states` from the dimensions of the `A[0]` array in case the `A` matrix is sparse --- pymdp/utils.py | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/pymdp/utils.py b/pymdp/utils.py index c938d6a3..7c18b74d 100644 --- a/pymdp/utils.py +++ b/pymdp/utils.py @@ -173,7 +173,7 @@ def dirichlet_like(template_categorical, scale = 1.0): return dirichlet_out -def get_model_dimensions(A=None, B=None): +def get_model_dimensions(A=None, B=None, factorized=False): if A is None and B is None: raise ValueError( @@ -191,8 +191,13 @@ def get_model_dimensions(A=None, B=None): num_factors = len(num_states) else: if A is not None: - num_states = list(A[0].shape[1:]) if is_obj_array(A) else list(A.shape[1:]) - num_factors = len(num_states) + if not factorized: + num_states = list(A[0].shape[1:]) if is_obj_array(A) else list(A.shape[1:]) + num_factors = len(num_states) + else: + raise ValueError( + "`A` array is factorized and cannot be used to infer `num_states`" + ) else: num_states, num_factors = None, None From 2768609da26cf2e6f1a0056bc536a5b48bf6c606 Mon Sep 17 00:00:00 2001 From: conorheins Date: Mon, 13 Mar 2023 12:41:05 +0100 Subject: [PATCH 058/232] fixed docstring for `num_states` argument in `run_vanilla_fpi` --- pymdp/algos/fpi.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pymdp/algos/fpi.py b/pymdp/algos/fpi.py index 716cbcb3..6e87480f 100644 --- a/pymdp/algos/fpi.py +++ b/pymdp/algos/fpi.py @@ -25,7 +25,7 @@ def run_vanilla_fpi(A, obs, num_obs, num_states, prior=None, num_iter=10, dF=1.0 num_obs: list of ints List of dimensionalities of each observation modality num_states: list of ints - List of dimensionalities of each observation modality + List of dimensionalities of each hidden state factor prior: numpy ndarray of dtype object, default None Prior over hidden states. If absent, prior is set to be the log uniform distribution over hidden states (identical to the initialisation of the posterior) From 0a9d244f89a55b6188cda0243ad7bccb7b0170a1 Mon Sep 17 00:00:00 2001 From: conorheins Date: Mon, 13 Mar 2023 14:17:35 +0100 Subject: [PATCH 059/232] unit test for factorized hidden state inference using the `Agent` API --- test/test_agent.py | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/test/test_agent.py b/test/test_agent.py index ad3768ca..423bb809 100644 --- a/test/test_agent.py +++ b/test/test_agent.py @@ -577,6 +577,42 @@ def test_agent_distributional_obs(self): for f in range(len(num_states)): self.assertTrue(np.isclose(qs_pi_validation[p_idx][t][f], qs_pi_out[p_idx][t][f]).all()) + def test_agent_with_factorized_inference(self): + """ + Test that an instance of the `Agent` class can be initialized with a provided `A_factor_list` and run the factorized inference algorithm. Validate + against an equivalent `Agent` whose `A` matrix represents the full set of (redundant) conditional dependence relationships. + """ + + num_obs = [5, 4] + num_states = [2, 3] + num_controls = [2, 3] + + A_factor_list = [ [0], [1] ] + A_reduced = utils.random_A_matrix(num_obs, num_states, A_factor_list) + B = utils.random_B_matrix(num_states, num_controls) + + agent = Agent(A=A_reduced, B=B, A_factor_list=A_factor_list, inference_algo = "VANILLA") + + obs = [np.random.randint(obs_dim) for obs_dim in num_obs] + + qs_out = agent._infer_states_test(obs) + + A_full = utils.initialize_empty_A(num_obs, num_states) + for m, A_m in enumerate(A_full): + other_factors = list(set(range(len(num_states))) - set(A_factor_list[m])) # list of the factors that modality `m` does not depend on + + # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` + expanded_dims = [num_obs[m]] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] + tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] + A_full[m] = np.tile(A_reduced[m].reshape(expanded_dims), tile_dims) + + agent = Agent(A=A_full, B=B, inference_algo = "VANILLA") + qs_validation = agent.infer_states(obs) + + for qs_out_f, qs_val_f in zip(qs_out, qs_validation): + self.assertTrue(np.isclose(qs_out_f, qs_val_f).all()) + + From fcfc19659d857806039ea99dfa101baf2b977d2b Mon Sep 17 00:00:00 2001 From: conorheins Date: Mon, 13 Mar 2023 14:27:12 +0100 Subject: [PATCH 060/232] changed default behavior of `infer_states` method of `agent` to use the factorized version of fixed point iteration, where an `mb_dict` of factor->modality conditional dependence relationships are specified --- pymdp/agent.py | 42 ++++++++++++++++++++++++++---------------- 1 file changed, 26 insertions(+), 16 deletions(-) diff --git a/pymdp/agent.py b/pymdp/agent.py index 28ba8f31..2cc2623d 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -135,28 +135,32 @@ def __init__( assert max(A_factor_list[m]) <= (self.num_factors - 1), f"Check modality {m} of A_factor_list - must be consistent with `num_states` and `num_factors`..." factor_dims = tuple([self.num_states[f] for f in A_factor_list[m]]) assert self.A[m].shape[1:] == factor_dims, f"Check modality {m} of A_factor_list. It must coincide with lagging dimensions of A{m}..." - assert self.pA[m].shape[1:] == factor_dims, f"Check modality {m} of A_factor_list. It must coincide with lagging dimensions of pA{m}..." + if self.pA != None: + assert self.pA[m].shape[1:] == factor_dims, f"Check modality {m} of A_factor_list. It must coincide with lagging dimensions of pA{m}..." + self.A_factor_list = A_factor_list # generate a list of the modalities that depend on each factor A_modality_list = [] for f in range(self.num_factors): - A_modality_list.append( [m for m in range(self.num_modalities) if f in A_factor_list[m]] ) + A_modality_list.append( [m for m in range(self.num_modalities) if f in self.A_factor_list[m]] ) # Store thee `A_factor_list` and the `A_modality_list` in a Markov blanket dictionary self.mb_dict = { - 'A_factor_list': A_factor_list, + 'A_factor_list': self.A_factor_list, 'A_modality_list': A_modality_list } if B_factor_list == None: - B_factor_list = [[f] for f in range(self.num_factors)] # defaults to having all factors depend only on themselves + self.B_factor_list = [[f] for f in range(self.num_factors)] # defaults to having all factors depend only on themselves else: for f in range(self.num_factors): assert max(B_factor_list[f]) <= (self.num_factors - 1), f"Check factor {f} of B_factor_list - must be consistent with `num_states` and `num_factors`..." factor_dims = tuple([self.num_states[f] for f in B_factor_list[f]]) assert self.B[f].shape[1:-1] == factor_dims, f"Check factor {f} of B_factor_list. It must coincide with all-but-final lagging dimensions of B{f}..." - assert self.pB[f].shape[1:-1] == factor_dims, f"Check factor {f} of B_factor_list. It must coincide with all-but-final lagging dimensions of pB{f}..." - + if self.pB != None: + assert self.pB[f].shape[1:-1] == factor_dims, f"Check factor {f} of B_factor_list. It must coincide with all-but-final lagging dimensions of pB{f}..." + self.B_factor_list = B_factor_list + # Users have the option to make only certain factors controllable. # default behaviour is to make all hidden state factors controllable, i.e. `self.num_factors == len(self.num_controls)` if control_fac_idx == None: @@ -465,11 +469,14 @@ def infer_states(self, observation, distr_obs = False): )[0] else: empirical_prior = self.D - qs = inference.update_posterior_states( - self.A, - observation, - empirical_prior, - **self.inference_params + qs = inference.update_posterior_states_factorized( + self.A, + observation, + self.num_obs, + self.num_states, + self.mb_dict, + empirical_prior, + **self.inference_params ) elif self.inference_algo == "MMP": @@ -518,10 +525,10 @@ def _infer_states_test(self, observation): else: empirical_prior = self.D qs = inference.update_posterior_states( - self.A, - observation, - empirical_prior, - **self.inference_params + self.A, + observation, + empirical_prior, + **self.inference_params ) elif self.inference_algo == "MMP": @@ -551,7 +558,10 @@ def _infer_states_test(self, observation): self.qs = qs - return qs, xn, vn + if self.inference_algo == "MMP": + return qs, xn, vn + else: + return qs def infer_policies(self): """ From ea1064d9567fbaa6fa0de99e823c84ce9a8118a7 Mon Sep 17 00:00:00 2001 From: conorheins Date: Mon, 13 Mar 2023 14:28:00 +0100 Subject: [PATCH 061/232] swapped the behaviour of `agent.infer_states()` and `agent._infer_states_test()`, so that now `_infer_states_test()` uses the old, redundant form of hidden state inference and `infer_states()` uses the new, factorized version --- test/test_agent.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/test_agent.py b/test/test_agent.py index 423bb809..80a5d660 100644 --- a/test/test_agent.py +++ b/test/test_agent.py @@ -595,7 +595,7 @@ def test_agent_with_factorized_inference(self): obs = [np.random.randint(obs_dim) for obs_dim in num_obs] - qs_out = agent._infer_states_test(obs) + qs_out = agent.infer_states(obs) A_full = utils.initialize_empty_A(num_obs, num_states) for m, A_m in enumerate(A_full): @@ -607,7 +607,7 @@ def test_agent_with_factorized_inference(self): A_full[m] = np.tile(A_reduced[m].reshape(expanded_dims), tile_dims) agent = Agent(A=A_full, B=B, inference_algo = "VANILLA") - qs_validation = agent.infer_states(obs) + qs_validation = agent._infer_states_test(obs) for qs_out_f, qs_val_f in zip(qs_out, qs_validation): self.assertTrue(np.isclose(qs_out_f, qs_val_f).all()) From 14b8a47d11b435e26d7331fcbeeaa45322117a10 Mon Sep 17 00:00:00 2001 From: conorheins Date: Tue, 14 Mar 2023 23:07:24 +0100 Subject: [PATCH 062/232] new version of `get_expected_states` called `get_expected_states_interactions` that has new `B_factor_list` argument that allows interactions to occur in the B matrix. Uses `spm_dot` instead of standard dot product to generalize the marginalization of joint distribution over past and current states, given an action --- pymdp/control.py | 39 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 38 insertions(+), 1 deletion(-) diff --git a/pymdp/control.py b/pymdp/control.py index 81933bef..dedfe604 100644 --- a/pymdp/control.py +++ b/pymdp/control.py @@ -247,8 +247,45 @@ def get_expected_states(qs, B, policy): qs_pi[t+1][control_factor] = B[control_factor][:,:,int(action)].dot(qs_pi[t][control_factor]) return qs_pi[1:] - + +def get_expected_states_interactions(qs, B, B_factor_list, policy): + """ + Compute the expected states under a policy, also known as the posterior predictive density over states + + Parameters + ---------- + qs: ``numpy.ndarray`` of dtype object + Marginal posterior beliefs over hidden states at a given timepoint. + B: ``numpy.ndarray`` of dtype object + Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. + Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability + of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. + B_factor_list: ``list`` of ``list`` of ``int`` + List of lists of hidden state factors each hidden state factor depends on. Each element ``B_factor_list[i]`` is a list of the factor indices that factor i's dynamics depend on. + policy: 2D ``numpy.ndarray`` + Array that stores actions entailed by a policy over time. Shape is ``(num_timesteps, num_factors)`` where ``num_timesteps`` is the temporal + depth of the policy and ``num_factors`` is the number of control factors. + + Returns + ------- + qs_pi: ``list`` of ``numpy.ndarray`` of dtype object + Predictive posterior beliefs over hidden states expected under the policy, where ``qs_pi[t]`` stores the beliefs about + hidden states expected under the policy at time ``t`` + """ + n_steps = policy.shape[0] + n_factors = policy.shape[1] + # initialise posterior predictive density as a list of beliefs over time, including current posterior beliefs about hidden states as the first element + qs_pi = [qs] + [utils.obj_array(n_factors) for t in range(n_steps)] + + # get expected states over time + for t in range(n_steps): + for control_factor, action in enumerate(policy[t,:]): + factor_idx = B_factor_list[control_factor] # list of the hidden state factor indices that the dynamics of `qs[control_factor]` depend on + qs_pi[t+1][control_factor] = spm_dot(B[control_factor][...,int(action)], qs_pi[t][factor_idx]) + + return qs_pi[1:] + def get_expected_obs(qs_pi, A): """ Compute the expected observations under a policy, also known as the posterior predictive density over observations From 717b44aacccd4b555a7cb27deb6dd5cc7532adff Mon Sep 17 00:00:00 2001 From: conorheins Date: Tue, 14 Mar 2023 23:07:46 +0100 Subject: [PATCH 063/232] optional `B_factor_list` argument in `utils.random_B_matrix()` --- pymdp/utils.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/pymdp/utils.py b/pymdp/utils.py index 7c18b74d..78799a8f 100644 --- a/pymdp/utils.py +++ b/pymdp/utils.py @@ -106,7 +106,7 @@ def random_A_matrix(num_obs, num_states, A_factor_list=None): A[modality] = norm_dist(modality_dist) return A -def random_B_matrix(num_states, num_controls): +def random_B_matrix(num_states, num_controls, B_factor_list=None): if type(num_states) is int: num_states = [num_states] if type(num_controls) is int: @@ -114,9 +114,14 @@ def random_B_matrix(num_states, num_controls): num_factors = len(num_states) assert len(num_controls) == len(num_states) + if B_factor_list is None: + B_factor_list = [[f] for f in range(num_factors)] + B = obj_array(num_factors) for factor in range(num_factors): - factor_shape = (num_states[factor], num_states[factor], num_controls[factor]) + lagging_shape = [ns for i, ns in enumerate(num_states) if i in B_factor_list[factor]] + factor_shape = [num_states[factor]] + lagging_shape + [num_controls[factor]] + # factor_shape = (num_states[factor], num_states[factor], num_controls[factor]) factor_dist = np.random.rand(*factor_shape) B[factor] = norm_dist(factor_dist) return B From c56deb1a1bcce4df0763328fea295b089dc5c064 Mon Sep 17 00:00:00 2001 From: conorheins Date: Tue, 14 Mar 2023 23:08:41 +0100 Subject: [PATCH 064/232] unit tests for`get_expected_states_interactions()` that tests a single and simple multi-factor case --- test/test_control.py | 42 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/test/test_control.py b/test/test_control.py index 54423496..a7c689d0 100644 --- a/test/test_control.py +++ b/test/test_control.py @@ -99,6 +99,48 @@ def test_get_expected_states(self): else: self.assertTrue((qs_pi[p_idx][t_idx][factor_idx] == B[factor_idx][:,:,policies[p_idx][t_idx,factor_idx]].dot(qs_pi[p_idx][t_idx-1][factor_idx])).all()) + def test_get_expected_states_interactions_single_factor(self): + """ + Test the new version of `get_expected_states` that includes `B` array inter-factor dependencies, in case a of trivial single factor + """ + + num_states = [3] + num_controls = [3] + + B_factor_list = [[0]] + + qs = utils.random_single_categorical(num_states) + B = utils.random_B_matrix(num_states, num_controls, B_factor_list=B_factor_list) + + policies = control.construct_policies(num_states, num_controls, policy_len=1) + + qs_pi_0 = control.get_expected_states_interactions(qs, B, B_factor_list, policies[0]) + + self.assertTrue((qs_pi_0[0][0] == B[0][:,:,policies[0][0,0]].dot(qs[0])).all()) + + def test_get_expected_states_interactions_multi_factor(self): + """ + Test the new version of `get_expected_states` that includes `B` array inter-factor dependencies, + in the case where there are two hidden state factors: one that depends on itself and another that depends on both itself and the other factor. + """ + + num_states = [3, 4] + num_controls = [3, 2] + + B_factor_list = [[0], [0, 1]] + + qs = utils.random_single_categorical(num_states) + B = utils.random_B_matrix(num_states, num_controls, B_factor_list=B_factor_list) + + policies = control.construct_policies(num_states, num_controls, policy_len=1) + + qs_pi_0 = control.get_expected_states_interactions(qs, B, B_factor_list, policies[0]) + + self.assertTrue((qs_pi_0[0][0] == B[0][:,:,policies[0][0,0]].dot(qs[0])).all()) + + qs_next_validation = (B[1][..., policies[0][0,1]] * maths.spm_cross(qs)[None,...]).sum(axis=(1,2)) # how to compute equivalent of `spm_dot(B[...,past_action], qs)` + self.assertTrue(np.allclose(qs_pi_0[0][1], qs_next_validation)) + def test_get_expected_states_and_obs(self): """ Tests the refactored (Categorical-less) versions of `get_expected_states` and `get_expected_obs` together From b2b9f66615c5c9f89bc18fbcecba8898c8e55204 Mon Sep 17 00:00:00 2001 From: conorheins Date: Wed, 15 Mar 2023 15:32:45 +0100 Subject: [PATCH 065/232] - changed default behaviour of `infer_states()` so that it uses `control.get_expected_states_interactions` when carrying forward posteriors from the previous timestep to form empirical priors for the current timestep - added in `distr_obs` flag argument to `agent._infer_states_test()` function for consistency --- pymdp/agent.py | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/pymdp/agent.py b/pymdp/agent.py index 2cc2623d..25c232f3 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -437,7 +437,7 @@ def get_future_qs(self): return future_qs_seq - def infer_states(self, observation, distr_obs = False): + def infer_states(self, observation, distr_obs=False): """ Update approximate posterior over hidden states by solving variational inference problem, given an observation. @@ -446,6 +446,8 @@ def infer_states(self, observation, distr_obs = False): observation: ``list`` or ``tuple`` of ints The observation input. Each entry ``observation[m]`` stores the index of the discrete observation for modality ``m``. + distr_obs: ``bool`` + Whether the observation is a distribution over possible observations, rather than a single observation. Returns --------- @@ -464,8 +466,8 @@ def infer_states(self, observation, distr_obs = False): if self.inference_algo == "VANILLA": if self.action is not None: - empirical_prior = control.get_expected_states( - self.qs, self.B, self.action.reshape(1, -1) #type: ignore + empirical_prior = control.get_expected_states_interactions( + self.qs, self.B, self.B_factor_list, self.action.reshape(1, -1) )[0] else: empirical_prior = self.D @@ -507,12 +509,12 @@ def infer_states(self, observation, distr_obs = False): return qs - def _infer_states_test(self, observation): + def _infer_states_test(self, observation, distr_obs=False): """ Test version of ``infer_states()`` that additionally returns intermediate variables of MMP, such as the prediction errors and intermediate beliefs from the optimization. Used for benchmarking against SPM outputs. """ - observation = tuple(observation) + observation = tuple(observation) if not distr_obs else observation if not hasattr(self, "qs"): self.reset() @@ -520,8 +522,8 @@ def _infer_states_test(self, observation): if self.inference_algo == "VANILLA": if self.action is not None: empirical_prior = control.get_expected_states( - self.qs, self.B, self.action.reshape(1, -1) #type: ignore - ) + self.qs, self.B, self.action.reshape(1, -1) + )[0] else: empirical_prior = self.D qs = inference.update_posterior_states( From b27b47c69e67ffc6fabda87493889229fa695ea5 Mon Sep 17 00:00:00 2001 From: conorheins Date: Wed, 15 Mar 2023 15:33:38 +0100 Subject: [PATCH 066/232] unit test that tests out hidden state inference over time, when empirical priors from the past are computed now using the new `get_expected_states_interactions()` function --- test/test_agent.py | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/test/test_agent.py b/test/test_agent.py index 80a5d660..8bdd0249 100644 --- a/test/test_agent.py +++ b/test/test_agent.py @@ -611,6 +611,41 @@ def test_agent_with_factorized_inference(self): for qs_out_f, qs_val_f in zip(qs_out, qs_validation): self.assertTrue(np.isclose(qs_out_f, qs_val_f).all()) + + def test_agent_with_interactions_in_B(self): + """ + Test that an instance of the `Agent` class can be initialized with a provided `B_factor_list` and run a time loop of active inferece + """ + + num_obs = [5, 4] + num_states = [2, 3] + num_controls = [2, 3] + + A = utils.random_A_matrix(num_obs, num_states) + B = utils.random_B_matrix(num_states, num_controls) + + agent_test = Agent(A=A, B=B) + agent_val = Agent(A=A, B=B) + + obs_seq = [] + for t in range(5): + obs_seq.append([np.random.randint(obs_dim) for obs_dim in num_obs]) + + for t in range(5): + qs_out = agent_test.infer_states(obs_seq[t]) + qs_val = agent_val._infer_states_test(obs_seq[t]) + for qs_out_f, qs_val_f in zip(qs_out, qs_val): + self.assertTrue(np.isclose(qs_out_f, qs_val_f).all()) + + agent_test.infer_policies() + agent_val.infer_policies() + + agent_test.sample_action() + agent_val.sample_action() + + + + From b295d2358012b2a64f931289fe6f7a0c96817a31 Mon Sep 17 00:00:00 2001 From: conorheins Date: Wed, 15 Mar 2023 15:34:04 +0100 Subject: [PATCH 067/232] added unit test of interactions function, with multiple hidden state factors but they're all independent of eachother (independent hidden state dynamics) --- test/test_control.py | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/test/test_control.py b/test/test_control.py index a7c689d0..30953d4e 100644 --- a/test/test_control.py +++ b/test/test_control.py @@ -140,6 +140,29 @@ def test_get_expected_states_interactions_multi_factor(self): qs_next_validation = (B[1][..., policies[0][0,1]] * maths.spm_cross(qs)[None,...]).sum(axis=(1,2)) # how to compute equivalent of `spm_dot(B[...,past_action], qs)` self.assertTrue(np.allclose(qs_pi_0[0][1], qs_next_validation)) + + def test_get_expected_states_interactions_multi_factor_independent(self): + """ + Test the new version of `get_expected_states` that includes `B` array inter-factor dependencies, + in the case where there are multiple hidden state factors, but they all only depend on themselves + """ + + num_states = [3, 4, 5, 6] + num_controls = [1, 2, 5, 3] + + B_factor_list = [[f] for f in range(len(num_states))] # each factor only depends on itself + + qs = utils.random_single_categorical(num_states) + B = utils.random_B_matrix(num_states, num_controls) + + policies = control.construct_policies(num_states, num_controls, policy_len=1) + + qs_pi_0 = control.get_expected_states_interactions(qs, B, B_factor_list, policies[0]) + + qs_pi_0_validation = control.get_expected_states(qs, B, policies[0]) + + for qs_f, qs_val_f in zip(qs_pi_0[0], qs_pi_0_validation[0]): + self.assertTrue(np.allclose(qs_f, qs_val_f)) def test_get_expected_states_and_obs(self): """ From bd7374ac3b62c0aeb45b8e4a089d7a7afffc8ebb Mon Sep 17 00:00:00 2001 From: conorheins Date: Wed, 15 Mar 2023 16:17:18 +0100 Subject: [PATCH 068/232] test `control.get_expected_obs_factorized()` under different conditions --- test/test_control.py | 56 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) diff --git a/test/test_control.py b/test/test_control.py index 30953d4e..5d6db4fe 100644 --- a/test/test_control.py +++ b/test/test_control.py @@ -164,6 +164,53 @@ def test_get_expected_states_interactions_multi_factor_independent(self): for qs_f, qs_val_f in zip(qs_pi_0[0], qs_pi_0_validation[0]): self.assertTrue(np.allclose(qs_f, qs_val_f)) + def test_get_expected_obs_factorized(self): + """ + Test the new version of `get_expected_obs` that includes sparse dependencies of `A` array on hidden state factors (not all observation modalities depend on all hidden state factors) + """ + + """ Case 1, where all modalities depend on all hidden state factors """ + + num_states = [3, 4] + num_obs = [3, 4] + + A_factor_list = [[0, 1], [0, 1]] + + qs = utils.random_single_categorical(num_states) + A = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_factor_list) + + qo_test = control.get_expected_obs_factorized([qs], A, A_factor_list) # need to wrap `qs` in list because `get_expected_obs_factorized` expects a list of `qs` (representing multiple timesteps) + qo_val = control.get_expected_obs([qs], A) # need to wrap `qs` in list because `get_expected_obs` expects a list of `qs` (representing multiple timesteps) + + for qo_m, qo_val_m in zip(qo_test[0], qo_val[0]): # need to extract first index of `qo_test` and `qo_val` because `get_expected_obs_factorized` returns a list of `qo` (representing multiple timesteps) + self.assertTrue(np.allclose(qo_m, qo_val_m)) + + """ Case 2, where some modalities depend on some hidden state factors """ + + num_states = [3, 4] + num_obs = [3, 4] + + A_factor_list = [[0], [0, 1]] + + qs = utils.random_single_categorical(num_states) + A_reduced = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_factor_list) + + qo_test = control.get_expected_obs_factorized([qs], A_reduced, A_factor_list) # need to wrap `qs` in list because `get_expected_obs_factorized` expects a list of `qs` (representing multiple timesteps) + + A_full = utils.initialize_empty_A(num_obs, num_states) + for m, A_m in enumerate(A_full): + other_factors = list(set(range(len(num_states))) - set(A_factor_list[m])) # list of the factors that modality `m` does not depend on + + # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` + expanded_dims = [num_obs[m]] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] + tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] + A_full[m] = np.tile(A_reduced[m].reshape(expanded_dims), tile_dims) + + qo_val = control.get_expected_obs([qs], A_full) # need to wrap `qs` in list because `get_expected_obs` expects a list of `qs` (representing multiple timesteps) + + for qo_m, qo_val_m in zip(qo_test[0], qo_val[0]): # need to extract first index of `qo_test` and `qo_val` because `get_expected_obs_factorized` returns a list of `qo` (representing multiple timesteps) + self.assertTrue(np.allclose(qo_m, qo_val_m)) + def test_get_expected_states_and_obs(self): """ Tests the refactored (Categorical-less) versions of `get_expected_states` and `get_expected_obs` together @@ -417,6 +464,15 @@ def test_state_info_gain(self): state_info_gains[idx] += control.calc_states_info_gain(A, qs_pi) self.assertGreater(state_info_gains[1], state_info_gains[0]) + # def test_state_info_gain_factorized(self): + # """ + # Test that the output of the `control.calc_states_info_gain()` function is + # the same as that out of the factorized version (`control.calc_states_info_gain_factorized()`) + # """ + + # num_states = [3, 2, 4] + # num_controls = [2, 3, 2] + def test_pA_info_gain(self): """ From ed4ffd9dc277f7ce5b9b84443f6668ca35822bbf Mon Sep 17 00:00:00 2001 From: conorheins Date: Wed, 15 Mar 2023 16:18:16 +0100 Subject: [PATCH 069/232] added new factorized versions of old `pymdp.control` functions: - `update_posterior_policies()` - `get_expected_obs_factorized()` - `calc_states_info_gain_factorized` --- pymdp/control.py | 171 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 171 insertions(+) diff --git a/pymdp/control.py b/pymdp/control.py index dedfe604..71e7a634 100644 --- a/pymdp/control.py +++ b/pymdp/control.py @@ -213,6 +213,105 @@ def update_posterior_policies( return q_pi, G +def update_posterior_policies_factorized( + qs, + A, + B, + C, + A_factor_list, + B_factor_list, + policies, + use_utility=True, + use_states_info_gain=True, + use_param_info_gain=False, + pA=None, + pB=None, + E = None, + gamma=16.0 +): + """ + Update posterior beliefs about policies by computing expected free energy of each policy and integrating that + with the prior over policies ``E``. This is intended to be used in conjunction + with the ``update_posterior_states`` method of the ``inference`` module, since only the posterior about the hidden states at the current timestep + ``qs`` is assumed to be provided, unconditional on policies. The predictive posterior over hidden states under all policies Q(s, pi) is computed + using the starting posterior about states at the current timestep ``qs`` and the generative model (e.g. ``A``, ``B``, ``C``) + + Parameters + ---------- + qs: ``numpy.ndarray`` of dtype object + Marginal posterior beliefs over hidden states at current timepoint (unconditioned on policies) + A: ``numpy.ndarray`` of dtype object + Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of + stores an ``numpy.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store + the probability of observation level ``i`` given hidden state levels ``j, k, ...`` + B: ``numpy.ndarray`` of dtype object + Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. + Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability + of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. + C: ``numpy.ndarray`` of dtype object + Prior over observations or 'prior preferences', storing the "value" of each outcome in terms of relative log probabilities. + This is softmaxed to form a proper probability distribution before being used to compute the expected utility term of the expected free energy. + A_factor_list: ``list`` of ``list``s of ``int`` + ``list`` that stores the indices of the hidden state factor indices that each observation modality depends on. For example, if ``A_factor_list[m] = [0, 1]``, then + observation modality ``m`` depends on hidden state factors 0 and 1. + B_factor_list: ``list`` of ``list``s of ``int`` + ``list`` that stores the indices of the hidden state factor indices that each hidden state factor depends on. For example, if ``B_factor_list[f] = [0, 1]``, then + the transitions in hidden state factor ``f`` depend on hidden state factors 0 and 1. + policies: ``list`` of 2D ``numpy.ndarray`` + ``list`` that stores each policy in ``policies[p_idx]``. Shape of ``policies[p_idx]`` is ``(num_timesteps, num_factors)`` where `num_timesteps` is the temporal + depth of the policy and ``num_factors`` is the number of control factors. + use_utility: ``Bool``, default ``True`` + Boolean flag that determines whether expected utility should be incorporated into computation of EFE. + use_states_info_gain: ``Bool``, default ``True`` + Boolean flag that determines whether state epistemic value (info gain about hidden states) should be incorporated into computation of EFE. + use_param_info_gain: ``Bool``, default ``False`` + Boolean flag that determines whether parameter epistemic value (info gain about generative model parameters) should be incorporated into computation of EFE. + pA: ``numpy.ndarray`` of dtype object, optional + Dirichlet parameters over observation model (same shape as ``A``) + pB: ``numpy.ndarray`` of dtype object, optional + Dirichlet parameters over transition model (same shape as ``B``) + E: 1D ``numpy.ndarray``, optional + Vector of prior probabilities of each policy (what's referred to in the active inference literature as "habits") + gamma: float, default 16.0 + Prior precision over policies, scales the contribution of the expected free energy to the posterior over policies + + Returns + ---------- + q_pi: 1D ``numpy.ndarray`` + Posterior beliefs over policies, i.e. a vector containing one posterior probability per policy. + G: 1D ``numpy.ndarray`` + Negative expected free energies of each policy, i.e. a vector containing one negative expected free energy per policy. + """ + + n_policies = len(policies) + G = np.zeros(n_policies) + q_pi = np.zeros((n_policies, 1)) + + if E is None: + lnE = spm_log_single(np.ones(n_policies) / n_policies) + else: + lnE = spm_log_single(E) + + for idx, policy in enumerate(policies): + qs_pi = get_expected_states_interactions(qs, B, B_factor_list, policy) + qo_pi = get_expected_obs_factorized(qs_pi, A, A_factor_list) + + if use_utility: + G[idx] += calc_expected_utility(qo_pi, C) + + if use_states_info_gain: + G[idx] += calc_states_info_gain_factorized(A, qs_pi, A_factor_list) + + if use_param_info_gain: + if pA is not None: + G[idx] += calc_pA_info_gain(pA, qo_pi, qs_pi) + if pB is not None: + G[idx] += calc_pB_info_gain(pB, qs_pi, qs, policy) + + q_pi = softmax(G * gamma + lnE) + + return q_pi, G + def get_expected_states(qs, B, policy): """ Compute the expected states under a policy, also known as the posterior predictive density over states @@ -323,6 +422,45 @@ def get_expected_obs(qs_pi, A): return qo_pi +def get_expected_obs_factorized(qs_pi, A, A_factor_list): + """ + Compute the expected observations under a policy, also known as the posterior predictive density over observations + + Parameters + ---------- + qs_pi: ``list`` of ``numpy.ndarray`` of dtype object + Predictive posterior beliefs over hidden states expected under the policy, where ``qs_pi[t]`` stores the beliefs about + hidden states expected under the policy at time ``t`` + A: ``numpy.ndarray`` of dtype object + Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of + stores an ``numpy.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store + the probability of observation level ``i`` given hidden state levels ``j, k, ...`` + A_factor_list: ``list`` of ``list`` of ``int`` + List of lists of hidden state factor indices that each observation modality depends on. Each element ``A_factor_list[i]`` is a list of the factor indices that modality i's observation model depends on. + Returns + ------- + qo_pi: ``list`` of ``numpy.ndarray`` of dtype object + Predictive posterior beliefs over observations expected under the policy, where ``qo_pi[t]`` stores the beliefs about + observations expected under the policy at time ``t`` + """ + + n_steps = len(qs_pi) # each element of the list is the PPD at a different timestep + + # initialise expected observations + qo_pi = [] + + for t in range(n_steps): + qo_pi_t = utils.obj_array(len(A)) + qo_pi.append(qo_pi_t) + + # compute expected observations over time + for t in range(n_steps): + for modality, A_m in enumerate(A): + factor_idx = A_factor_list[modality] # list of the hidden state factor indices that observation modality with the index `modality` depends on + qo_pi[t][modality] = spm_dot(A_m, qs_pi[t][factor_idx]) + + return qo_pi + def calc_expected_utility(qo_pi, C): """ Computes the expected utility of a policy, using the observation distribution expected under that policy and a prior preference vector. @@ -397,6 +535,39 @@ def calc_states_info_gain(A, qs_pi): return states_surprise +def calc_states_info_gain_factorized(A, qs_pi, A_factor_list): + """ + Computes the Bayesian surprise or information gain about states of a policy, + using the observation model and the hidden state distribution expected under that policy. + + Parameters + ---------- + A: ``numpy.ndarray`` of dtype object + Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of + stores an ``numpy.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store + the probability of observation level ``i`` given hidden state levels ``j, k, ...`` + qs_pi: ``list`` of ``numpy.ndarray`` of dtype object + Predictive posterior beliefs over hidden states expected under the policy, where ``qs_pi[t]`` stores the beliefs about + hidden states expected under the policy at time ``t`` + A_factor_list: ``list`` of ``list`` of ``int`` + List of lists, where ``A_factor_list[m]`` is a list of the hidden state factor indices that observation modality with the index ``m`` depends on + + Returns + ------- + states_surprise: float + Bayesian surprise (about states) or salience expected under the policy in question + """ + + n_steps = len(qs_pi) + + states_surprise = 0 + for t in range(n_steps): + for m, A_m in enumerate(A): + factor_idx = A_factor_list[m] # list of the hidden state factor indices that observation modality with the index `m` depends on + states_surprise += spm_MDP_G(A_m, qs_pi[t][factor_idx]) + + return states_surprise + def calc_pA_info_gain(pA, qo_pi, qs_pi): """ From 1dcbdbc5e4cfec77ea084d494050fa889a1ea0c5 Mon Sep 17 00:00:00 2001 From: conorheins Date: Wed, 15 Mar 2023 16:49:43 +0100 Subject: [PATCH 070/232] started testing factorized information gain calculations (WIP) --- test/test_control.py | 53 ++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 49 insertions(+), 4 deletions(-) diff --git a/test/test_control.py b/test/test_control.py index 5d6db4fe..186438c9 100644 --- a/test/test_control.py +++ b/test/test_control.py @@ -464,14 +464,59 @@ def test_state_info_gain(self): state_info_gains[idx] += control.calc_states_info_gain(A, qs_pi) self.assertGreater(state_info_gains[1], state_info_gains[0]) - # def test_state_info_gain_factorized(self): + def test_state_info_gain_factorized(self): + """ + Test the factorized version of the `calc_states_info_gain` function (`calc_states_info_gain_factorized`). + Make sure that summing across modalities is allowed when the modalities only depend on certain hidden state factors. + """ + + num_states = [3, 2, 4] + num_obs = [2, 3, 2] + + qs = utils.random_single_categorical(num_states) + + A_factor_list = [[0], [1], [2]] # this only works when modalities are all independent of each other (not in eachother's MBs) + A_reduced = utils.random_A_matrix(num_obs, num_states, A_factor_list) + + states_info_gain_across_modality = 0. + for m, A_m in enumerate(A_reduced): + if len(A_factor_list[m]) == 1: + qs_that_matter = utils.to_obj_array(qs[A_factor_list[m]]) + else: + qs_that_matter = qs[A_factor_list[m]] + states_info_gain_across_modality += control.calc_states_info_gain(A_m, [qs_that_matter]) + + A_full = utils.initialize_empty_A(num_obs, num_states) + for m, A_m in enumerate(A_full): + other_factors = list(set(range(len(num_states))) - set(A_factor_list[m])) # list of the factors that modality `m` does not depend on + + # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` + expanded_dims = [num_obs[m]] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] + tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] + A_full[m] = np.tile(A_reduced[m].reshape(expanded_dims), tile_dims) + + states_info_gain_full = control.calc_states_info_gain(A_full, [qs]) # need to wrap `qs` in a list because the function expects a list of policy-conditioned posterior beliefs (corresponding to each timestep) + + self.assertTrue(np.isclose(states_info_gain_across_modality, states_info_gain_full)) + + + # def test_state_info_gain_modality_sum(self): # """ - # Test that the output of the `control.calc_states_info_gain()` function is - # the same as that out of the factorized version (`control.calc_states_info_gain_factorized()`) + # Test that the states_info_gain function is the same when computed using the full (unfactorized) joint distribution over observations and hidden state factors vs. when computed for each modality separately and summed together. # """ # num_states = [3, 2, 4] - # num_controls = [2, 3, 2] + # num_obs = [2, 3, 2] + + # qs = utils.random_single_categorical(num_states) + # A = utils.random_A_matrix(num_obs, num_states) + + # states_info_gain_full = control.calc_states_info_gain(A, [qs]) # need to wrap `qs` in a list because the function expects a list of policy-conditioned posterior beliefs (corresponding to each timestep) + # states_info_gain_by_modality = 0. + # for m, A_m in enumerate(A): + # states_info_gain_by_modality += control.calc_states_info_gain(A_m, [qs]) + + # self.assertEqual(states_info_gain_full, states_info_gain_by_modality) def test_pA_info_gain(self): From 79d6544e229a314fcab469bc80872ba0606d7698 Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 17 Mar 2023 17:11:20 +0100 Subject: [PATCH 071/232] unit test the factorized state information gain calculations by validating the ranking of the state information gains afforded to different policies in the T-Maze / contextual bandit generative model --- test/test_control.py | 107 +++++++++++++++++++++++++++++++------------ 1 file changed, 77 insertions(+), 30 deletions(-) diff --git a/test/test_control.py b/test/test_control.py index 186438c9..49c4f5ab 100644 --- a/test/test_control.py +++ b/test/test_control.py @@ -463,60 +463,107 @@ def test_state_info_gain(self): qs_pi = control.get_expected_states(qs, B, policy) state_info_gains[idx] += control.calc_states_info_gain(A, qs_pi) self.assertGreater(state_info_gains[1], state_info_gains[0]) - + def test_state_info_gain_factorized(self): """ - Test the factorized version of the `calc_states_info_gain` function (`calc_states_info_gain_factorized`). - Make sure that summing across modalities is allowed when the modalities only depend on certain hidden state factors. + Unit test the `calc_states_info_gain_factorized` function by qualitatively checking that in the T-Maze (contextual bandit) + example, the state info gain is higher for the policy that leads to visiting the cue, which is higher than state info gain + for visiting the bandit arm, which in turn is higher than the state info gain for the policy that leads to staying in the start state. """ - num_states = [3, 2, 4] - num_obs = [2, 3, 2] + num_states = [2, 3] + num_obs = [3, 3, 3] + num_controls = [1, 3] - qs = utils.random_single_categorical(num_states) + A_factor_list = [[0, 1], [0, 1], [1]] + + A = utils.obj_array(len(num_obs)) + for m, obs in enumerate(num_obs): + lagging_dimensions = [ns for i, ns in enumerate(num_states) if i in A_factor_list[m]] + modality_shape = [obs] + lagging_dimensions + A[m] = np.zeros(modality_shape) + if m == 0: + A[m][:, :, 0] = np.ones( (num_obs[m], num_states[0]) ) / num_obs[m] + A[m][:, :, 1] = np.ones( (num_obs[m], num_states[0]) ) / num_obs[m] + A[m][:, :, 2] = np.array([[0.9, 0.1], [0.0, 0.0], [0.1, 0.9]]) # cue statistics + if m == 1: + A[m][2, :, 0] = np.ones(num_states[0]) + A[m][0:2, :, 1] = np.array([[0.6, 0.4], [0.6, 0.4]]) # bandit statistics (mapping between reward-state (first hidden state factor) and rewards (Good vs Bad)) + A[m][2, :, 2] = np.ones(num_states[0]) + if m == 2: + A[m] = np.eye(obs) + + qs_start = utils.obj_array_uniform(num_states) + qs_start[1] = np.array([1., 0., 0.]) # agent believes it's in the start state + + state_info_gain_visit_start = 0. + for m, A_m in enumerate(A): + if len(A_factor_list[m]) == 1: + qs_that_matter = utils.to_obj_array(qs_start[A_factor_list[m]]) + else: + qs_that_matter = qs_start[A_factor_list[m]] + state_info_gain_visit_start += control.calc_states_info_gain(A_m, [qs_that_matter]) - A_factor_list = [[0], [1], [2]] # this only works when modalities are all independent of each other (not in eachother's MBs) - A_reduced = utils.random_A_matrix(num_obs, num_states, A_factor_list) + qs_arm = utils.obj_array_uniform(num_states) + qs_arm[1] = np.array([0., 1., 0.]) # agent believes it's in the arm-visiting state - states_info_gain_across_modality = 0. - for m, A_m in enumerate(A_reduced): + state_info_gain_visit_arm = 0. + for m, A_m in enumerate(A): if len(A_factor_list[m]) == 1: - qs_that_matter = utils.to_obj_array(qs[A_factor_list[m]]) + qs_that_matter = utils.to_obj_array(qs_arm[A_factor_list[m]]) else: - qs_that_matter = qs[A_factor_list[m]] - states_info_gain_across_modality += control.calc_states_info_gain(A_m, [qs_that_matter]) + qs_that_matter = qs_arm[A_factor_list[m]] + state_info_gain_visit_arm += control.calc_states_info_gain(A_m, [qs_that_matter]) - A_full = utils.initialize_empty_A(num_obs, num_states) - for m, A_m in enumerate(A_full): - other_factors = list(set(range(len(num_states))) - set(A_factor_list[m])) # list of the factors that modality `m` does not depend on + qs_cue = utils.obj_array_uniform(num_states) + qs_cue[1] = np.array([0., 0., 1.]) # agent believes it's in the cue-visiting state - # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` - expanded_dims = [num_obs[m]] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] - tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] - A_full[m] = np.tile(A_reduced[m].reshape(expanded_dims), tile_dims) + state_info_gain_visit_cue = 0. + for m, A_m in enumerate(A): + if len(A_factor_list[m]) == 1: + qs_that_matter = utils.to_obj_array(qs_cue[A_factor_list[m]]) + else: + qs_that_matter = qs_cue[A_factor_list[m]] + state_info_gain_visit_cue += control.calc_states_info_gain(A_m, [qs_that_matter]) - states_info_gain_full = control.calc_states_info_gain(A_full, [qs]) # need to wrap `qs` in a list because the function expects a list of policy-conditioned posterior beliefs (corresponding to each timestep) + self.assertGreater(state_info_gain_visit_arm, state_info_gain_visit_start) + self.assertGreater(state_info_gain_visit_cue, state_info_gain_visit_arm) - self.assertTrue(np.isclose(states_info_gain_across_modality, states_info_gain_full)) + # def test_neg_ambiguity_modality_sum(self): + # """ + # Test that the negativity ambiguity function is the same when computed using the full (unfactorized) joint distribution over observations and hidden state factors vs. when computed for each modality separately and summed together. + # """ + # num_states = [10, 20, 10, 10] + # num_obs = [2, 25, 10, 8] - # def test_state_info_gain_modality_sum(self): + # qs = utils.random_single_categorical(num_states) + # A = utils.random_A_matrix(num_obs, num_states) + + # neg_ambig_full = maths.spm_calc_neg_ambig(A, qs) # need to wrap `qs` in a list because the function expects a list of policy-conditioned posterior beliefs (corresponding to each timestep) + # neg_ambig_by_modality = 0. + # for m, A_m in enumerate(A): + # neg_ambig_by_modality += maths.spm_calc_neg_ambig(A_m, qs) + + # self.assertEqual(neg_ambig_full, neg_ambig_by_modality) + + # def test_entropy_modality_sum(self): # """ - # Test that the states_info_gain function is the same when computed using the full (unfactorized) joint distribution over observations and hidden state factors vs. when computed for each modality separately and summed together. + # Test that the negativity ambiguity function is the same when computed using the full (unfactorized) joint distribution over observations and hidden state factors vs. when computed for each modality separately and summed together. # """ - # num_states = [3, 2, 4] - # num_obs = [2, 3, 2] + # num_states = [10, 20, 10, 10] + # num_obs = [2, 25, 10, 8] # qs = utils.random_single_categorical(num_states) # A = utils.random_A_matrix(num_obs, num_states) - # states_info_gain_full = control.calc_states_info_gain(A, [qs]) # need to wrap `qs` in a list because the function expects a list of policy-conditioned posterior beliefs (corresponding to each timestep) - # states_info_gain_by_modality = 0. + # H_full = maths.spm_calc_qo_entropy(A, qs) # need to wrap `qs` in a list because the function expects a list of policy-conditioned posterior beliefs (corresponding to each timestep) + # H_by_modality = 0. # for m, A_m in enumerate(A): - # states_info_gain_by_modality += control.calc_states_info_gain(A_m, [qs]) + # H_by_modality += maths.spm_calc_qo_entropy(A_m, qs) - # self.assertEqual(states_info_gain_full, states_info_gain_by_modality) + # self.assertEqual(H_full, H_by_modality) def test_pA_info_gain(self): From 7cb79dbd0427a67162ad0e320ab0043ac4c0d26a Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 17 Mar 2023 17:12:25 +0100 Subject: [PATCH 072/232] added more expansion of the ambiguity term in spm_MDP_G and also added two versions of the state info gain that separately compute the negative ambiguity and marginal entropy, respectively --- pymdp/maths.py | 106 ++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 105 insertions(+), 1 deletion(-) diff --git a/pymdp/maths.py b/pymdp/maths.py index 27b163a8..c5d38fa4 100644 --- a/pymdp/maths.py +++ b/pymdp/maths.py @@ -372,6 +372,110 @@ def calc_free_energy(qs, prior, n_factors, likelihood=None): free_energy -= compute_accuracy(likelihood, qs) return free_energy +def spm_calc_qo_entropy(A, x): + """ + Function that just calculates the entropy part of the state information gain, using the same method used in + spm_MDP_G.m in the original matlab code. + + Parameters + ---------- + A (numpy ndarray or array-object): + array assigning likelihoods of observations/outcomes under the various + hidden state configurations + + x (numpy ndarray or array-object): + Categorical distribution presenting probabilities of hidden states + (this can also be interpreted as the predictive density over hidden + states/causes if you're calculating the expected Bayesian surprise) + + Returns + ------- + H (float): + the entropy of the marginal distribution over observations/outcomes + """ + + num_modalities = len(A) + + # Probability distribution over the hidden causes: i.e., Q(x) + qx = spm_cross(x) + qo = 0 + idx = np.array(np.where(qx > np.exp(-16))).T + + if utils.is_obj_array(A): + # Accumulate expectation of entropy: i.e., E_{Q(o, x)}[lnP(o|x)] = E_{P(o|x)Q(x)}[lnP(o|x)] = E_{Q(x)}[P(o|x)lnP(o|x)] = E_{Q(x)}[H[P(o|x)]] + for i in idx: + # Probability over outcomes for this combination of causes + po = np.ones(1) + for modality_idx, A_m in enumerate(A): + index_vector = [slice(0, A_m.shape[0])] + list(i) + po = spm_cross(po, A_m[tuple(index_vector)]) + po = po.ravel() + qo += qx[tuple(i)] * po + else: + for i in idx: + po = np.ones(1) + index_vector = [slice(0, A.shape[0])] + list(i) + po = spm_cross(po, A[tuple(index_vector)]) + po = po.ravel() + qo += qx[tuple(i)] * po + + # Compute entropy of expectations: i.e., -E_{Q(o)}[lnQ(o)] + H = - qo.dot(spm_log_single(qo)) + + return H + +def spm_calc_neg_ambig(A, x): + """ + Function that just calculates the negativity ambiguity part of the state information gain, using the same method used in + spm_MDP_G.m in the original matlab code. + + Parameters + ---------- + A (numpy ndarray or array-object): + array assigning likelihoods of observations/outcomes under the various + hidden state configurations + + x (numpy ndarray or array-object): + Categorical distribution presenting probabilities of hidden states + (this can also be interpreted as the predictive density over hidden + states/causes if you're calculating the expected Bayesian surprise) + + Returns + ------- + G (float): + the negative ambiguity (negative entropy of the likelihood of observations given hidden states, expected under current posterior over hidden states) + """ + + num_modalities = len(A) + + # Probability distribution over the hidden causes: i.e., Q(x) + qx = spm_cross(x) + G = 0 + qo = 0 + idx = np.array(np.where(qx > np.exp(-16))).T + + if utils.is_obj_array(A): + # Accumulate expectation of entropy: i.e., E_{Q(o, x)}[lnP(o|x)] = E_{P(o|x)Q(x)}[lnP(o|x)] = E_{Q(x)}[P(o|x)lnP(o|x)] = E_{Q(x)}[H[P(o|x)]] + for i in idx: + # Probability over outcomes for this combination of causes + po = np.ones(1) + for modality_idx, A_m in enumerate(A): + index_vector = [slice(0, A_m.shape[0])] + list(i) + po = spm_cross(po, A_m[tuple(index_vector)]) + + po = po.ravel() + qo += qx[tuple(i)] * po + G += qx[tuple(i)] * po.dot(np.log(po + np.exp(-16))) + else: + for i in idx: + po = np.ones(1) + index_vector = [slice(0, A.shape[0])] + list(i) + po = spm_cross(po, A[tuple(index_vector)]) + po = po.ravel() + qo += qx[tuple(i)] * po + G += qx[tuple(i)] * po.dot(np.log(po + np.exp(-16))) + + return G def spm_MDP_G(A, x): """ @@ -406,7 +510,7 @@ def spm_MDP_G(A, x): idx = np.array(np.where(qx > np.exp(-16))).T if utils.is_obj_array(A): - # Accumulate expectation of entropy: i.e., E_{Q(o, s)}[lnP(o|x)] + # Accumulate expectation of entropy: i.e., E_{Q(o, x)}[lnP(o|x)] = E_{P(o|x)Q(x)}[lnP(o|x)] = E_{Q(x)}[P(o|x)lnP(o|x)] = E_{Q(x)}[H[P(o|x)]] for i in idx: # Probability over outcomes for this combination of causes po = np.ones(1) From 6b73f2371ed2a56e4a415cc928642937e5bd689c Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 17 Mar 2023 17:20:43 +0100 Subject: [PATCH 073/232] added new verison of policy inference method of `Agent` called`infer_policies_factorized`, which takes advantage of sparse conditional dependence structure of the graphical model to speed up EFE calculations. Still kept as separate method for now because we haven't added in factorized version of information gain calculations --- pymdp/agent.py | 65 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) diff --git a/pymdp/agent.py b/pymdp/agent.py index 25c232f3..13e4e210 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -624,6 +624,71 @@ def infer_policies(self): self.q_pi = q_pi self.G = G return q_pi, G + + def infer_policies_factorized(self): + """ + Perform policy inference by optimizing a posterior (categorical) distribution over policies. + This distribution is computed as the softmax of ``G * gamma + lnE`` where ``G`` is the negative expected + free energy of policies, ``gamma`` is a policy precision and ``lnE`` is the (log) prior probability of policies. + This function returns the posterior over policies as well as the negative expected free energy of each policy. + In this version of the function, the expected free energy of policies is computed using known factorized structure + in the model, which speeds up computation (particular the state information gain calculations). + + Returns + ---------- + q_pi: 1D ``numpy.ndarray`` + Posterior beliefs over policies, i.e. a vector containing one posterior probability per policy. + G: 1D ``numpy.ndarray`` + Negative expected free energies of each policy, i.e. a vector containing one negative expected free energy per policy. + """ + + if self.inference_algo == "VANILLA": + q_pi, G = control.update_posterior_policies_factorized( + self.qs, + self.A, + self.B, + self.C, + self.A_factor_list, + self.B_factor_list, + self.policies, + self.use_utility, + self.use_states_info_gain, + self.use_param_info_gain, + self.pA, + self.pB, + E = self.E, + gamma = self.gamma + ) + elif self.inference_algo == "MMP": + Raise(NotImplementedError("Factorized inference not implemented for MMP")) + + # future_qs_seq = self.get_future_qs() + + # q_pi, G = control.update_posterior_policies_full( + # future_qs_seq, + # self.A, + # self.B, + # self.C, + # self.policies, + # self.use_utility, + # self.use_states_info_gain, + # self.use_param_info_gain, + # self.latest_belief, + # self.pA, + # self.pB, + # F = self.F, + # E = self.E, + # gamma = self.gamma + # ) + + if hasattr(self, "q_pi_hist"): + self.q_pi_hist.append(q_pi) + if len(self.q_pi_hist) > self.inference_horizon: + self.q_pi_hist = self.q_pi_hist[-(self.inference_horizon-1):] + + self.q_pi = q_pi + self.G = G + return q_pi, G def sample_action(self): """ From aa904dddcafef9480f428b0745b938ec0df32349 Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 17 Mar 2023 17:21:21 +0100 Subject: [PATCH 074/232] raise a `NonImplementedError` if you try to use parameter information gain (novelty) terms in conjunction with `update_posterior_policies_factorized()` --- pymdp/control.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/pymdp/control.py b/pymdp/control.py index 71e7a634..54d8e1e2 100644 --- a/pymdp/control.py +++ b/pymdp/control.py @@ -302,11 +302,14 @@ def update_posterior_policies_factorized( if use_states_info_gain: G[idx] += calc_states_info_gain_factorized(A, qs_pi, A_factor_list) + # @TODO: Make sure parameter information gain terms are compatible with new factorized version of the model if use_param_info_gain: if pA is not None: - G[idx] += calc_pA_info_gain(pA, qo_pi, qs_pi) + Raise(NotImplementedError("Parameter information gain terms are not yet compatible with factorized version of the model")) + # G[idx] += calc_pA_info_gain(pA, qo_pi, qs_pi) if pB is not None: - G[idx] += calc_pB_info_gain(pB, qs_pi, qs, policy) + Raise(NotImplementedError("Parameter information gain terms are not yet compatible with factorized version of the model")) + # G[idx] += calc_pB_info_gain(pB, qs_pi, qs, policy) q_pi = softmax(G * gamma + lnE) From 03f06870ea6e1c0afb140d9845111755ec9ca7a8 Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 17 Mar 2023 17:28:14 +0100 Subject: [PATCH 075/232] added unit test for `update_posterior_policies_factorized()` to just make sure it runs through / outputs correct shapes --- test/test_control.py | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/test/test_control.py b/test/test_control.py index 49c4f5ab..7e75fb21 100644 --- a/test/test_control.py +++ b/test/test_control.py @@ -1359,6 +1359,43 @@ def test_update_posterior_policies_pB_infogain(self): self.assertTrue(np.allclose(efe, efe_valid)) self.assertTrue(np.allclose(q_pi, q_pi_valid)) + + def test_update_posterior_policies_factorized(self): + """ + Test new update_posterior_policies_factorized function, just to make sure it runs through and outputs correct shapes + """ + + num_obs = [3, 3] + num_states = [3, 2] + num_controls = [3, 2] + + A_factor_list = [[0, 1], [1]] + B_factor_list = [[0], [0, 1]] + + qs = utils.random_single_categorical(num_states) + A = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_factor_list) + B = utils.random_B_matrix(num_states, num_controls, B_factor_list=B_factor_list) + C = utils.obj_array_zeros(num_obs) + + policies = control.construct_policies(num_states, num_controls, policy_len=1) + + q_pi, efe = control.update_posterior_policies_factorized( + qs, + A, + B, + C, + A_factor_list, + B_factor_list, + policies, + use_utility = True, + use_states_info_gain = True, + gamma=16.0 + ) + + self.assertEqual(len(q_pi), len(policies)) + self.assertEqual(len(efe), len(policies)) + + chosen_action = control.sample_action(q_pi, policies, num_controls, action_selection="deterministic") def test_sample_action(self): """ From 8e8cbe8d148d8700189743b69c85256b88429be4 Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 17 Mar 2023 17:30:06 +0100 Subject: [PATCH 076/232] added trivial `B_factor_list` to instantiation of `Agent` in unit test for interactions in `B` matrix --- test/test_agent.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/test_agent.py b/test/test_agent.py index 8bdd0249..ba8c5267 100644 --- a/test/test_agent.py +++ b/test/test_agent.py @@ -624,7 +624,7 @@ def test_agent_with_interactions_in_B(self): A = utils.random_A_matrix(num_obs, num_states) B = utils.random_B_matrix(num_states, num_controls) - agent_test = Agent(A=A, B=B) + agent_test = Agent(A=A, B=B, B_factor_list=[[0], [1]]) agent_val = Agent(A=A, B=B) obs_seq = [] From f1fa46482e16b26e907a47ca29b706c779001a31 Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 17 Mar 2023 17:33:47 +0100 Subject: [PATCH 077/232] unit test to make sure the full active infernece loop now works, including with fully factorized state and policy ifnerence that takes advantage of sparse conditional dependencies between hidden state and outcomes, and interactions between hidden states. --- test/test_agent.py | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/test/test_agent.py b/test/test_agent.py index ba8c5267..b5a80acf 100644 --- a/test/test_agent.py +++ b/test/test_agent.py @@ -642,7 +642,32 @@ def test_agent_with_interactions_in_B(self): agent_test.sample_action() agent_val.sample_action() + + def test_actinfloop_factorized(self): + """ + Test that an instance of the `Agent` class can be initialized and run + with the fully-factorized generative model functions (including policy inference) + """ + + num_obs = [5, 4, 4] + num_states = [2, 3, 5] + num_controls = [2, 3, 2] + + A_factor_list = [[0], [0, 1], [0, 1, 2]] + B_factor_list = [[0], [0, 1], [1, 2]] + A = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_factor_list) + B = utils.random_B_matrix(num_states, num_controls, B_factor_list=B_factor_list) + + agent = Agent(A=A, B=B, A_factor_list=A_factor_list, B_factor_list=B_factor_list, inference_algo = "VANILLA") + + obs_seq = [] + for t in range(5): + obs_seq.append([np.random.randint(obs_dim) for obs_dim in num_obs]) + for t in range(5): + qs_out = agent.infer_states(obs_seq[t]) + agent.infer_policies_factorized() + agent.sample_action() From 1582d76385ad96f3c66d5479cde77409cb78554c Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 17 Mar 2023 17:36:23 +0100 Subject: [PATCH 078/232] added in another test case for agent when the sparsity is not taken advantage of, but the factorized version of policy inference is still called --- test/test_agent.py | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/test/test_agent.py b/test/test_agent.py index b5a80acf..a9e69c42 100644 --- a/test/test_agent.py +++ b/test/test_agent.py @@ -658,7 +658,22 @@ def test_actinfloop_factorized(self): A = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_factor_list) B = utils.random_B_matrix(num_states, num_controls, B_factor_list=B_factor_list) - agent = Agent(A=A, B=B, A_factor_list=A_factor_list, B_factor_list=B_factor_list, inference_algo = "VANILLA") + agent = Agent(A=A, B=B, A_factor_list=A_factor_list, B_factor_list=B_factor_list, inference_algo="VANILLA") + + obs_seq = [] + for t in range(5): + obs_seq.append([np.random.randint(obs_dim) for obs_dim in num_obs]) + + for t in range(5): + qs_out = agent.infer_states(obs_seq[t]) + agent.infer_policies_factorized() + agent.sample_action() + + """ Test to make sure it works even when generative model sparsity is not taken advantage of """ + A = utils.random_A_matrix(num_obs, num_states) + B = utils.random_B_matrix(num_states, num_controls) + + agent = Agent(A=A, B=B, inference_algo="VANILLA") obs_seq = [] for t in range(5): From d5ab7464e6c28b08da4cdbf2a70182d0c1017168 Mon Sep 17 00:00:00 2001 From: conorheins Date: Sat, 18 Mar 2023 18:32:13 +0100 Subject: [PATCH 079/232] added factorized version of `update_obs_likelihood_dirichlet` (`update_obs_likelihood_dirichlet_factorized`) and unit tested --- pymdp/learning.py | 53 +++++++++++++++++++++++++++++++++++++++++++ test/test_learning.py | 23 +++++++++++++++++++ 2 files changed, 76 insertions(+) diff --git a/pymdp/learning.py b/pymdp/learning.py index ec334f68..8d0af2cc 100644 --- a/pymdp/learning.py +++ b/pymdp/learning.py @@ -57,6 +57,59 @@ def update_obs_likelihood_dirichlet(pA, A, obs, qs, lr=1.0, modalities="all"): return qA +def update_obs_likelihood_dirichlet_factorized(pA, A, obs, qs, A_factor_list, lr=1.0, modalities="all"): + """ + Update Dirichlet parameters of the observation likelihood distribution, in a case where the observation model is reduced (factorized) and only represents + the conditional dependencies between the observation modalities and particular hidden state factors (whose indices are specified in each modality-specific entry of ``A_factor_list``) + + Parameters + ----------- + pA: ``numpy.ndarray`` of dtype object + Prior Dirichlet parameters over observation model (same shape as ``A``) + A: ``numpy.ndarray`` of dtype object + Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of + stores an ``numpy.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store + the probability of observation level ``i`` given hidden state levels ``j, k, ...`` + obs: 1D ``numpy.ndarray``, ``numpy.ndarray`` of dtype object, ``int`` or ``tuple`` + The observation (generated by the environment). If single modality, this can be a 1D ``numpy.ndarray`` + (one-hot vector representation) or an ``int`` (observation index) + If multi-modality, this can be ``numpy.ndarray`` of dtype object whose entries are 1D one-hot vectors, + or a ``tuple`` (of ``int``) + qs: 1D ``numpy.ndarray`` or ``numpy.ndarray`` of dtype object, default None + Marginal posterior beliefs over hidden states at current timepoint. + A_factor_list: ``list`` of ``list`` of ``int`` + List of lists, where each list with index `m` contains the indices of the hidden states that observation modality `m` depends on. + lr: float, default 1.0 + Learning rate, scale of the Dirichlet pseudo-count update. + modalities: ``list``, default "all" + Indices (ranging from 0 to ``n_modalities - 1``) of the observation modalities to include + in learning. Defaults to "all", meaning that modality-specific sub-arrays of ``pA`` + are all updated using the corresponding observations. + + Returns + ----------- + qA: ``numpy.ndarray`` of dtype object + Posterior Dirichlet parameters over observation model (same shape as ``A``), after having updated it with observations. + """ + + num_modalities = len(pA) + num_observations = [pA[modality].shape[0] for modality in range(num_modalities)] + + obs_processed = utils.process_observation(obs, num_modalities, num_observations) + obs = utils.to_obj_array(obs_processed) + + if modalities == "all": + modalities = list(range(num_modalities)) + + qA = copy.deepcopy(pA) + + for modality in modalities: + dfda = maths.spm_cross(obs[modality], qs[A_factor_list[modality]]) + dfda = dfda * (A[modality] > 0).astype("float") + qA[modality] = qA[modality] + (lr * dfda) + + return qA + def update_state_likelihood_dirichlet( pB, B, actions, qs, qs_prev, lr=1.0, factors="all" ): diff --git a/test/test_learning.py b/test/test_learning.py index a849c982..5e3a7f8b 100644 --- a/test/test_learning.py +++ b/test/test_learning.py @@ -249,6 +249,29 @@ def test_update_pA_diff_observation_formats(self): pA, A, observation_onehot, qs, lr=l_rate, modalities=modalities_to_update) self.assertTrue(np.allclose(pA_updated_1[0], pA_updated_2[0])) + + def test_update_pA_factorized(self): + """ + Test for `learning.update_obs_likelihood_dirichlet_factorized`, which is the learning function updating prior Dirichlet parameters over the sensory likelihood (pA) + in the case that the generative model is sparse and only some modalities depend on some hidden state factors + """ + + num_states = [2, 6, 5] + num_obs = [3, 4, 5] + A_factor_list = [[0], [1, 2], [0, 2]] + + qs = utils.random_single_categorical(num_states) + A = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_factor_list) + pA = utils.dirichlet_like(A, scale=1.0) + observation = [np.random.randint(obs_dim) for obs_dim in num_obs] + pA_updated_test = learning.update_obs_likelihood_dirichlet_factorized( + pA, A, observation, qs, A_factor_list + ) + + for modality, obs_dim in enumerate(num_obs): + update = maths.spm_cross(utils.onehot(observation[modality], obs_dim), qs[A_factor_list[modality]]) + pA_updated_valid_m = pA[modality] + update + self.assertTrue(np.allclose(pA_updated_test[modality], pA_updated_valid_m)) def test_update_pB_single_factor_no_actions(self): From 62eb4f8a56de8ae7552cf709419c3e5f3cfc6833 Mon Sep 17 00:00:00 2001 From: conorheins Date: Sat, 18 Mar 2023 18:42:12 +0100 Subject: [PATCH 080/232] added version of `B` matrix learning (`update_state_likelihood_dirichlet_interactions()`) that allows interactions between hidden state factors in the `B` tensors --- pymdp/learning.py | 51 ++++++++++++++++++++++++++++++++++ test/test_learning.py | 64 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 115 insertions(+) diff --git a/pymdp/learning.py b/pymdp/learning.py index 8d0af2cc..1c21568a 100644 --- a/pymdp/learning.py +++ b/pymdp/learning.py @@ -158,6 +158,57 @@ def update_state_likelihood_dirichlet( return qB +def update_state_likelihood_dirichlet_interactions( + pB, B, actions, qs, qs_prev, B_factor_list, lr=1.0, factors="all" +): + """ + Update Dirichlet parameters of the transition distribution, in the case when 'interacting' hidden state factors are present, i.e. + the dynamics of a given hidden state factor `f` are no longer independent of the dynamics of other hidden state factors. + + Parameters + ----------- + pB: ``numpy.ndarray`` of dtype object + Prior Dirichlet parameters over transition model (same shape as ``B``) + B: ``numpy.ndarray`` of dtype object + Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. + Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability + of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. + actions: 1D ``numpy.ndarray`` + A vector with length equal to the number of control factors, where each element contains the index of the action (for that control factor) performed at + a given timestep. + qs: 1D ``numpy.ndarray`` or ``numpy.ndarray`` of dtype object + Marginal posterior beliefs over hidden states at current timepoint. + qs_prev: 1D ``numpy.ndarray`` or ``numpy.ndarray`` of dtype object + Marginal posterior beliefs over hidden states at previous timepoint. + B_factor_list: ``list`` of ``list`` of ``int`` + A list of lists, where each element ``B_factor_list[f]`` is a list of indices of hidden state factors that that are needed to predict the dynamics of hidden state factor ``f``. + lr: float, default ``1.0`` + Learning rate, scale of the Dirichlet pseudo-count update. + factors: ``list``, default "all" + Indices (ranging from 0 to ``n_factors - 1``) of the hidden state factors to include + in learning. Defaults to "all", meaning that factor-specific sub-arrays of ``pB`` + are all updated using the corresponding hidden state distributions and actions. + + Returns + ----------- + qB: ``numpy.ndarray`` of dtype object + Posterior Dirichlet parameters over transition model (same shape as ``B``), after having updated it with state beliefs and actions. + """ + + num_factors = len(pB) + + qB = copy.deepcopy(pB) + + if factors == "all": + factors = list(range(num_factors)) + + for factor in factors: + dfdb = maths.spm_cross(qs[factor], qs_prev[B_factor_list[factor]]) + dfdb *= (B[factor][...,int(actions[factor])] > 0).astype("float") + qB[factor][...,int(actions[factor])] += (lr*dfdb) + + return qB + def update_state_prior_dirichlet( pD, qs, lr=1.0, factors="all" ): diff --git a/test/test_learning.py b/test/test_learning.py index 5e3a7f8b..269b7cd8 100644 --- a/test/test_learning.py +++ b/test/test_learning.py @@ -575,6 +575,70 @@ def test_update_pB_multi_factor_some_controllable_some_factors(self): ) self.assertTrue(np.all(pB_updated[factor] == validation_pB[factor])) + def test_update_pB_interactions(self): + """ + Test for `learning.update_state_likelihood_dirichlet_factorized`, which is the learning function updating prior Dirichlet parameters over the transition likelihood (pB) + in the case that there are allowable interactions between hidden state factors, i.e. the dynamics of factor `f` may depend on more than just its control factor and its own state. + """ + + """ Test version with interactions """ + num_states = [3, 4, 5] + num_controls = [2, 1, 1] + B_factor_list= [[0, 1], [0,1,2], [1, 2]] + factors_to_update = [0, 1] + + qs_prev = utils.random_single_categorical(num_states) + qs = utils.random_single_categorical(num_states) + + B = utils.random_B_matrix(num_states, num_controls, B_factor_list=B_factor_list) + pB = utils.dirichlet_like(B, scale=1.) + l_rate = np.random.rand() # sample some positive learning rate + + action = np.array([np.random.randint(c_dim) for c_dim in num_controls]) + + pB_updated_test = learning.update_state_likelihood_dirichlet_interactions( + pB, B, action, qs, qs_prev, B_factor_list, lr=l_rate, factors=factors_to_update + ) + + pB_updated_valid = utils.dirichlet_like(B, scale=1.) + + for factor, action_i in enumerate(action): + + if factor in factors_to_update: + pB_updated_valid[factor][...,action_i] += ( + l_rate + * maths.spm_cross(qs[factor], qs_prev[B_factor_list[factor]]) + * (B[factor][...,action_i] > 0) + ) + self.assertTrue(np.all(pB_updated_test[factor] == pB_updated_valid[factor])) + + """ Test version without interactions, but still use the factorized version to test it against the non-interacting version `update_state_likelihood_dirichlet` """ + num_states = [3, 4, 5] + num_controls = [2, 1, 1] + B_factor_list= [[0], [1], [2]] + factors_to_update = [0, 1] + + qs_prev = utils.random_single_categorical(num_states) + qs = utils.random_single_categorical(num_states) + + B = utils.random_B_matrix(num_states, num_controls, B_factor_list=B_factor_list) + pB = utils.dirichlet_like(B, scale=1.) + l_rate = np.random.rand() # sample some positive learning rate + + action = np.array([np.random.randint(c_dim) for c_dim in num_controls]) + + pB_updated_test = learning.update_state_likelihood_dirichlet_interactions( + pB, B, action, qs, qs_prev, B_factor_list, lr=l_rate, factors=factors_to_update + ) + + pB_updated_valid = learning.update_state_likelihood_dirichlet( + pB, B, action, qs, qs_prev, lr=l_rate, factors=factors_to_update + ) + + for factor, action_i in enumerate(action): + self.assertTrue(np.allclose(pB_updated_test[factor], pB_updated_valid[factor])) + + def test_update_pD(self): """ Test updating prior Dirichlet parameters over initial hidden states (pD). From d1b27943c86175df3530655bd2886b6354968231 Mon Sep 17 00:00:00 2001 From: conorheins Date: Sat, 18 Mar 2023 18:46:59 +0100 Subject: [PATCH 081/232] added additional unit test for `update_obs_dirichlet_factorized()` ensuring that even in case of fully-dense conditional dependency graph (all modalities depend on all factors), the updates using the factorized version are identical to the un-factorized version --- test/test_learning.py | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/test/test_learning.py b/test/test_learning.py index 269b7cd8..c839704c 100644 --- a/test/test_learning.py +++ b/test/test_learning.py @@ -256,6 +256,7 @@ def test_update_pA_factorized(self): in the case that the generative model is sparse and only some modalities depend on some hidden state factors """ + """ Test version with sparse conditional dependency graph (taking advantage of `A_factor_list` argument) """ num_states = [2, 6, 5] num_obs = [3, 4, 5] A_factor_list = [[0], [1, 2], [0, 2]] @@ -273,6 +274,28 @@ def test_update_pA_factorized(self): pA_updated_valid_m = pA[modality] + update self.assertTrue(np.allclose(pA_updated_test[modality], pA_updated_valid_m)) + """ Test version with full conditional dependency graph (not taking advantage of `A_factor_list` argument, but including it anyway) """ + num_states = [2, 6, 5] + num_obs = [3, 4, 5] + A_factor_list = len(num_obs) * [[0, 1, 2]] + qs = utils.random_single_categorical(num_states) + A = utils.random_A_matrix(num_obs, num_states) + + modalities_to_update = [0, 2] + learning_rate = np.random.rand() # sample some positive learning rate + + pA = utils.dirichlet_like(A, scale=1.0) + observation = [np.random.randint(obs_dim) for obs_dim in num_obs] + pA_updated_test = learning.update_obs_likelihood_dirichlet_factorized( + pA, A, observation, qs, A_factor_list, lr=learning_rate, modalities=modalities_to_update + ) + + pA_updated_valid = learning.update_obs_likelihood_dirichlet( + pA, A, observation, qs, lr=learning_rate, modalities=modalities_to_update + ) + + for modality, obs_dim in enumerate(num_obs): + self.assertTrue(np.allclose(pA_updated_test[modality], pA_updated_valid[modality])) def test_update_pB_single_factor_no_actions(self): """ From d1e45898e3d8536c97faab8a8882196cc04c8060 Mon Sep 17 00:00:00 2001 From: conorheins Date: Sat, 18 Mar 2023 18:58:30 +0100 Subject: [PATCH 082/232] changed `update_A()` and `update_B()` methods of `Agent`, such that they now use the factorized versions of the respectively functions from the `learning` module --- pymdp/agent.py | 62 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 62 insertions(+) diff --git a/pymdp/agent.py b/pymdp/agent.py index 13e4e210..2f216e32 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -762,6 +762,37 @@ def update_A(self, obs): Posterior Dirichlet parameters over observation model (same shape as ``A``), after having updated it with observations. """ + qA = learning.update_obs_likelihood_dirichlet_factorized( + self.pA, + self.A, + obs, + self.qs, + self.A_factor_list, + self.lr_pA, + self.modalities_to_learn + ) + + self.pA = qA # set new prior to posterior + self.A = utils.norm_dist_obj_arr(qA) # take expected value of posterior Dirichlet parameters to calculate posterior over A array + + return qA + + def _update_A_old(self, obs): + """ + Update approximate posterior beliefs about Dirichlet parameters that parameterise the observation likelihood or ``A`` array. + + Parameters + ---------- + observation: ``list`` or ``tuple`` of ints + The observation input. Each entry ``observation[m]`` stores the index of the discrete + observation for modality ``m``. + + Returns + ----------- + qA: ``numpy.ndarray`` of dtype object + Posterior Dirichlet parameters over observation model (same shape as ``A``), after having updated it with observations. + """ + qA = learning.update_obs_likelihood_dirichlet( self.pA, self.A, @@ -791,6 +822,37 @@ def update_B(self, qs_prev): Posterior Dirichlet parameters over transition model (same shape as ``B``), after having updated it with state beliefs and actions. """ + qB = learning.update_state_likelihood_dirichlet_interactions( + self.pB, + self.B, + self.action, + self.qs, + qs_prev, + self.B_factor_list, + self.lr_pB, + self.factors_to_learn + ) + + self.pB = qB # set new prior to posterior + self.B = utils.norm_dist_obj_arr(qB) # take expected value of posterior Dirichlet parameters to calculate posterior over B array + + return qB + + def _update_B_old(self, qs_prev): + """ + Update posterior beliefs about Dirichlet parameters that parameterise the transition likelihood + + Parameters + ----------- + qs_prev: 1D ``numpy.ndarray`` or ``numpy.ndarray`` of dtype object + Marginal posterior beliefs over hidden states at previous timepoint. + + Returns + ----------- + qB: ``numpy.ndarray`` of dtype object + Posterior Dirichlet parameters over transition model (same shape as ``B``), after having updated it with state beliefs and actions. + """ + qB = learning.update_state_likelihood_dirichlet( self.pB, self.B, From 496816b6161018551b5a3b9a2a7d10d34a831b0e Mon Sep 17 00:00:00 2001 From: conorheins Date: Sat, 18 Mar 2023 18:59:09 +0100 Subject: [PATCH 083/232] added unit test in `test_agent` where we ensure that updating of Dirichlet prior over sensory likelihood parameters works in the context of the `Agent` class --- test/test_agent.py | 47 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) diff --git a/test/test_agent.py b/test/test_agent.py index a9e69c42..8d9cb844 100644 --- a/test/test_agent.py +++ b/test/test_agent.py @@ -201,6 +201,53 @@ def test_mmp_active_inference(self): self.assertEqual(len(agent.prev_obs), T) self.assertEqual(len(agent.prev_actions), T) + def test_agent_with_A_learning_vanilla(self): + """ Unit test for updating prior Dirichlet parameters over likelihood model (pA) with the ``Agent`` class, + in the case that you're using "vanilla" inference mode. + """ + + # 3 x 3, 2-dimensional grid world + num_obs = [9] + num_states = [9] + num_controls = [4] + + A = utils.obj_array_zeros([ [num_obs[0], num_states[0]] ]) + A[0] = np.eye(num_obs[0]) + + pA = utils.dirichlet_like(A, scale=1.) + + action_labels = ["LEFT", "DOWN", "RIGHT", "UP"] + + # get some true transition dynamics + true_transition_matrix = generate_grid_world_transitions(action_labels, num_rows = 3, num_cols = 3) + B = utils.to_obj_array(true_transition_matrix) + + # instantiate the agent + learning_rate_pA = np.random.rand() + agent = Agent(A=A, B=B, pA=pA, inference_algo="VANILLA", action_selection="stochastic", lr_pA=learning_rate_pA) + + # time horizon + T = 10 + next_state = 0 + + for t in range(T): + + prev_state = next_state + o = [prev_state] + qx = agent.infer_states(o) + agent.infer_policies() + agent.sample_action() + + # sample the next state given the true transition dynamics and the sampled action + next_state = utils.sample(true_transition_matrix[:,prev_state,int(agent.action[0])]) + + # compute the predicted update to the action-conditioned slice of qB + predicted_update = agent.pA[0] + learning_rate_pA*maths.spm_cross(utils.onehot(o[0], num_obs[0]), qx[0]) + qA = agent.update_A(o) # update qA using the agent function + + # check if the predicted update and the actual update are the same + self.assertTrue(np.allclose(predicted_update, qA[0])) + def test_agent_with_B_learning_vanilla(self): """ Unit test for updating prior Dirichlet parameters over transition model (pB) with the ``Agent`` class, in the case that you're using "vanilla" inference mode. From b176611f316da08cc1bdd6922017a20b1407ed94 Mon Sep 17 00:00:00 2001 From: conorheins Date: Sat, 18 Mar 2023 19:20:03 +0100 Subject: [PATCH 084/232] added additional checks into the `__init__()` of agent, in case the user has provided reduced `A` tensors or `B` matrices with interactions, but have not passed in a `A_factor_list` or `B_factor_list` --- pymdp/agent.py | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/pymdp/agent.py b/pymdp/agent.py index 2f216e32..07dbb877 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -130,6 +130,11 @@ def __init__( # checking that `A_factor_list` and `B_factor_list` are consistent with `num_factors`, `num_states`, and lagging dimensions of `A` and `B` tensors if A_factor_list == None: self.A_factor_list = self.num_modalities * [list(range(self.num_factors))] # defaults to having all modalities depend on all factors + for m in range(self.num_modalities): + factor_dims = tuple([self.num_states[f] for f in self.A_factor_list[m]]) + assert self.A[m].shape[1:] == factor_dims, f"Please input an `A_factor_list` whose {m}-th indices pick out the hidden state factors that line up with lagging dimensions of A{m}..." + if self.pA != None: + assert self.pA[m].shape[1:] == factor_dims, f"Please input an `A_factor_list` whose {m}-th indices pick out the hidden state factors that line up with lagging dimensions of pA{m}..." else: for m in range(self.num_modalities): assert max(A_factor_list[m]) <= (self.num_factors - 1), f"Check modality {m} of A_factor_list - must be consistent with `num_states` and `num_factors`..." @@ -152,6 +157,11 @@ def __init__( if B_factor_list == None: self.B_factor_list = [[f] for f in range(self.num_factors)] # defaults to having all factors depend only on themselves + for f in range(self.num_factors): + factor_dims = tuple([self.num_states[f] for f in self.B_factor_list[f]]) + assert self.B[f].shape[1:-1] == factor_dims, f"Please input a `B_factor_list` whose {f}-th indices pick out the hidden state factors that line up with the all-but-final lagging dimensions of B{f}..." + if self.pB != None: + assert self.pB[f].shape[1:-1] == factor_dims, f"Please input a `B_factor_list` whose {f}-th indices pick out the hidden state factors that line up with the all-but-final lagging dimensions of pB{f}..." else: for f in range(self.num_factors): assert max(B_factor_list[f]) <= (self.num_factors - 1), f"Check factor {f} of B_factor_list - must be consistent with `num_states` and `num_factors`..." From 286505fd2bb8fb84a1010da6a5edb9a811baf14d Mon Sep 17 00:00:00 2001 From: conorheins Date: Sat, 18 Mar 2023 19:20:46 +0100 Subject: [PATCH 085/232] unit test for running active inference with learning, in case the agent is working with a reduced `A` tensor i.e. a factorized generative model (with a provided `A_factor_list` that is not all-to-all) --- test/test_agent.py | 45 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+) diff --git a/test/test_agent.py b/test/test_agent.py index 8d9cb844..5eadc609 100644 --- a/test/test_agent.py +++ b/test/test_agent.py @@ -247,6 +247,51 @@ def test_agent_with_A_learning_vanilla(self): # check if the predicted update and the actual update are the same self.assertTrue(np.allclose(predicted_update, qA[0])) + + def test_agent_with_A_learning_vanilla_factorized(self): + """ Unit test for updating prior Dirichlet parameters over likelihood model (pA) with the ``Agent`` class, + in the case that you're using "vanilla" inference mode. In this case, we encode sparse conditional dependencies by specifying + a non-all-to-all `A_factor_list`, that specifies the subset of hidden state factors that different modalities depend on. + """ + + num_obs = [5, 4, 3] + num_states = [9, 8, 2, 4] + num_controls = [2, 2, 1, 1] + + A_factor_list = [[0, 1], [0, 2], [3]] + + A = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_factor_list) + pA = utils.dirichlet_like(A, scale=1.) + + B = utils.random_B_matrix(num_states, num_controls) + + # instantiate the agent + learning_rate_pA = np.random.rand() + agent = Agent(A=A, B=B, pA=pA, A_factor_list=A_factor_list, inference_algo="VANILLA", action_selection="stochastic", lr_pA=learning_rate_pA) + + # time horizon + T = 10 + + obs_seq = [] + for t in range(T): + obs_seq.append([np.random.randint(obs_dim) for obs_dim in num_obs]) + + for t in range(T): + print(t) + + qx = agent.infer_states(obs_seq[t]) + agent.infer_policies_factorized() + agent.sample_action() + + # compute the predicted update to the action-conditioned slice of qB + qA_valid = utils.obj_array_zeros([A_m.shape for A_m in A]) + for m, pA_m in enumerate(agent.pA): + qA_valid[m] = pA_m + learning_rate_pA*maths.spm_cross(utils.onehot(obs_seq[t][m], num_obs[m]), qx[A_factor_list[m]]) + qA_test = agent.update_A(obs_seq[t]) # update qA using the agent function + + # check if the predicted update and the actual update are the same + for m, qA_valid_m in enumerate(qA_valid): + self.assertTrue(np.allclose(qA_valid_m, qA_test[m])) def test_agent_with_B_learning_vanilla(self): """ Unit test for updating prior Dirichlet parameters over transition model (pB) with the ``Agent`` class, From 8f8e12b0b7121a8e6703aacdc87220eebe37cbe8 Mon Sep 17 00:00:00 2001 From: conorheins Date: Sun, 19 Mar 2023 12:12:39 +0100 Subject: [PATCH 086/232] added factorized version of calculating pA information gain (novelty) term, that takes in `A_factor_list` as input --- pymdp/control.py | 44 ++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 42 insertions(+), 2 deletions(-) diff --git a/pymdp/control.py b/pymdp/control.py index 54d8e1e2..f49b87df 100644 --- a/pymdp/control.py +++ b/pymdp/control.py @@ -305,8 +305,7 @@ def update_posterior_policies_factorized( # @TODO: Make sure parameter information gain terms are compatible with new factorized version of the model if use_param_info_gain: if pA is not None: - Raise(NotImplementedError("Parameter information gain terms are not yet compatible with factorized version of the model")) - # G[idx] += calc_pA_info_gain(pA, qo_pi, qs_pi) + G[idx] += calc_pA_info_gain_factorized(pA, qo_pi, qs_pi, A_factor_list) if pB is not None: Raise(NotImplementedError("Parameter information gain terms are not yet compatible with factorized version of the model")) # G[idx] += calc_pB_info_gain(pB, qs_pi, qs, policy) @@ -609,6 +608,47 @@ def calc_pA_info_gain(pA, qo_pi, qs_pi): return pA_infogain +def calc_pA_info_gain_factorized(pA, qo_pi, qs_pi, A_factor_list): + """ + Compute expected Dirichlet information gain about parameters ``pA`` under a policy. + In this version of the function, we assume that the observation model is factorized, i.e. that each observation modality depends on a subset of the hidden state factors. + + Parameters + ---------- + pA: ``numpy.ndarray`` of dtype object + Dirichlet parameters over observation model (same shape as ``A``) + qo_pi: ``list`` of ``numpy.ndarray`` of dtype object + Predictive posterior beliefs over observations expected under the policy, where ``qo_pi[t]`` stores the beliefs about + observations expected under the policy at time ``t`` + qs_pi: ``list`` of ``numpy.ndarray`` of dtype object + Predictive posterior beliefs over hidden states expected under the policy, where ``qs_pi[t]`` stores the beliefs about + hidden states expected under the policy at time ``t`` + A_factor_list: ``list`` of ``list`` of ``int`` + List of lists, where ``A_factor_list[m]`` is a list of the hidden state factor indices that observation modality with the index ``m`` depends on + + Returns + ------- + infogain_pA: float + Surprise (about Dirichlet parameters) expected under the policy in question + """ + + n_steps = len(qo_pi) + + num_modalities = len(pA) + wA = utils.obj_array(num_modalities) + for modality, pA_m in enumerate(pA): + wA[modality] = spm_wnorm(pA[modality]) + + pA_infogain = 0 + + for modality in range(num_modalities): + wA_modality = wA[modality] * (pA[modality] > 0).astype("float") + factor_idx = A_factor_list[modality] + for t in range(n_steps): + pA_infogain -= qo_pi[t][modality].dot(spm_dot(wA_modality, qs_pi[t][factor_idx])[:, np.newaxis]) + + return pA_infogain + def calc_pB_info_gain(pB, qs_pi, qs_prev, policy): """ From 210eed8423b3b38d0480ca691844655e757b6b45 Mon Sep 17 00:00:00 2001 From: conorheins Date: Sun, 19 Mar 2023 12:18:17 +0100 Subject: [PATCH 087/232] added version of pB information gain calculations that allow interactions in the `B` tensors --- pymdp/control.py | 59 ++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 55 insertions(+), 4 deletions(-) diff --git a/pymdp/control.py b/pymdp/control.py index f49b87df..9e5629d3 100644 --- a/pymdp/control.py +++ b/pymdp/control.py @@ -302,13 +302,11 @@ def update_posterior_policies_factorized( if use_states_info_gain: G[idx] += calc_states_info_gain_factorized(A, qs_pi, A_factor_list) - # @TODO: Make sure parameter information gain terms are compatible with new factorized version of the model if use_param_info_gain: if pA is not None: G[idx] += calc_pA_info_gain_factorized(pA, qo_pi, qs_pi, A_factor_list) if pB is not None: - Raise(NotImplementedError("Parameter information gain terms are not yet compatible with factorized version of the model")) - # G[idx] += calc_pB_info_gain(pB, qs_pi, qs, policy) + G[idx] += calc_pB_info_gain_interactions(pB, qs_pi, qs, B_factor_list, policy) q_pi = softmax(G * gamma + lnE) @@ -649,7 +647,6 @@ def calc_pA_info_gain_factorized(pA, qo_pi, qs_pi, A_factor_list): return pA_infogain - def calc_pB_info_gain(pB, qs_pi, qs_prev, policy): """ Compute expected Dirichlet information gain about parameters ``pB`` under a given policy @@ -701,6 +698,60 @@ def calc_pB_info_gain(pB, qs_pi, qs_prev, policy): return pB_infogain +def calc_pB_info_gain_interactions(pB, qs_pi, qs_prev, B_factor_list, policy): + """ + Compute expected Dirichlet information gain about parameters ``pB`` under a given policy + + Parameters + ---------- + pB: ``numpy.ndarray`` of dtype object + Dirichlet parameters over transition model (same shape as ``B``) + qs_pi: ``list`` of ``numpy.ndarray`` of dtype object + Predictive posterior beliefs over hidden states expected under the policy, where ``qs_pi[t]`` stores the beliefs about + hidden states expected under the policy at time ``t`` + qs_prev: ``numpy.ndarray`` of dtype object + Posterior over hidden states at beginning of trajectory (before receiving observations) + B_factor_list: ``list`` of ``list`` of ``int`` + List of lists, where ``B_factor_list[f]`` is a list of the hidden state factor indices that hidden state factor with the index ``f`` depends on + policy: 2D ``numpy.ndarray`` + Array that stores actions entailed by a policy over time. Shape is ``(num_timesteps, num_factors)`` where ``num_timesteps`` is the temporal + depth of the policy and ``num_factors`` is the number of control factors. + + Returns + ------- + infogain_pB: float + Surprise (about dirichlet parameters) expected under the policy in question + """ + + n_steps = len(qs_pi) + + num_factors = len(pB) + wB = utils.obj_array(num_factors) + for factor, pB_f in enumerate(pB): + wB[factor] = spm_wnorm(pB_f) + + pB_infogain = 0 + + for t in range(n_steps): + # the 'past posterior' used for the information gain about pB here is the posterior + # over expected states at the timestep previous to the one under consideration + # if we're on the first timestep, we just use the latest posterior in the + # entire action-perception cycle as the previous posterior + if t == 0: + previous_qs = qs_prev + # otherwise, we use the expected states for the timestep previous to the timestep under consideration + else: + previous_qs = qs_pi[t - 1] + + # get the list of action-indices for the current timestep + policy_t = policy[t, :] + for factor, a_i in enumerate(policy_t): + wB_factor_t = wB[factor][...,int(a_i)] * (pB[factor][...,int(a_i)] > 0).astype("float") + f_idx = B_factor_list[factor] + pB_infogain -= qs_pi[t][factor].dot(spm_dot(wB_factor_t, previous_qs[f_idx])) + + return pB_infogain + def construct_policies(num_states, num_controls = None, policy_len=1, control_fac_idx=None): """ Generate a ``list`` of policies. The returned array ``policies`` is a ``list`` that stores one policy per entry. From eccf2cdbf59cc011fdb6a619445006d858492465 Mon Sep 17 00:00:00 2001 From: conorheins Date: Sun, 19 Mar 2023 12:19:13 +0100 Subject: [PATCH 088/232] added unit tests into `test_control` that allow calculation of information gain terms in case of factorized A tensors (with eliminated redundant dependencies) and interacting state factors (> 3-dimensional B tensors) --- test/test_control.py | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/test/test_control.py b/test/test_control.py index 7e75fb21..84fcefe1 100644 --- a/test/test_control.py +++ b/test/test_control.py @@ -566,7 +566,6 @@ def test_state_info_gain_factorized(self): # self.assertEqual(H_full, H_by_modality) def test_pA_info_gain(self): - """ Test the pA_info_gain function. Demonstrates operation by manipulating shape of the Dirichlet priors over likelihood parameters @@ -608,6 +607,15 @@ def test_pA_info_gain(self): pA_info_gains[idx] += control.calc_pA_info_gain(pA, qo_pi, qs_pi) self.assertGreater(pA_info_gains[1], pA_info_gains[0]) + + """ Test the factorized version of the pA_info_gain function. """ + pA_info_gains_fac = np.zeros(len(policies)) + for idx, policy in enumerate(policies): + qs_pi = control.get_expected_states(qs, B, policy) + qo_pi = control.get_expected_obs_factorized(qs_pi, A, A_factor_list=[[0]]) + pA_info_gains_fac[idx] += control.calc_pA_info_gain_factorized(pA, qo_pi, qs_pi, A_factor_list=[[0]]) + + self.assertTrue(np.allclose(pA_info_gains_fac, pA_info_gains)) def test_pB_info_gain(self): """ @@ -645,6 +653,13 @@ def test_pB_info_gain(self): pB_info_gains[idx] += control.calc_pB_info_gain(pB, qs_pi, qs, policy) self.assertGreater(pB_info_gains[1], pB_info_gains[0]) + B_factor_list = [[0]] + pB_info_gains_interactions = np.zeros(len(policies)) + for idx, policy in enumerate(policies): + qs_pi = control.get_expected_states_interactions(qs, B, B_factor_list, policy) + pB_info_gains_interactions[idx] += control.calc_pB_info_gain_interactions(pB, qs_pi, qs, B_factor_list, policy) + self.assertTrue(np.allclose(pB_info_gains_interactions, pB_info_gains)) + def test_update_posterior_policies_utility(self): """ Tests the refactored (Categorical-less) version of `update_posterior_policies`, using only the expected utility component of the expected free energy From fb9ad86e850d8dd7cab9fbc310613e5501040d6e Mon Sep 17 00:00:00 2001 From: conorheins Date: Sun, 19 Mar 2023 12:26:14 +0100 Subject: [PATCH 089/232] tested active inference loop using the full construct with the new interacting hidden state factors and reduced / factorized generative model, where information gain terms and learning is included --- test/test_agent.py | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/test/test_agent.py b/test/test_agent.py index 5eadc609..e9a44b0e 100644 --- a/test/test_agent.py +++ b/test/test_agent.py @@ -775,7 +775,33 @@ def test_actinfloop_factorized(self): qs_out = agent.infer_states(obs_seq[t]) agent.infer_policies_factorized() agent.sample_action() + + """ Test with pA and pB learning & information gain """ + + num_obs = [5, 4, 4] + num_states = [2, 3, 5] + num_controls = [2, 3, 2] + + A_factor_list = [[0], [0, 1], [0, 1, 2]] + B_factor_list = [[0], [0, 1], [1, 2]] + A = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_factor_list) + B = utils.random_B_matrix(num_states, num_controls, B_factor_list=B_factor_list) + pA = utils.dirichlet_like(A) + pB = utils.dirichlet_like(B) + agent = Agent(A=A, pA=pA, B=B, pB=pB, save_belief_hist=True, use_param_info_gain=True, A_factor_list=A_factor_list, B_factor_list=B_factor_list, inference_algo="VANILLA") + + obs_seq = [] + for t in range(5): + obs_seq.append([np.random.randint(obs_dim) for obs_dim in num_obs]) + + for t in range(5): + qs_out = agent.infer_states(obs_seq[t]) + agent.infer_policies_factorized() + agent.sample_action() + agent.update_A(obs_seq[t]) + if t > 0: + agent.update_B(qs_prev = agent.qs_hist[-2]) # need to have `save_belief_hist=True` for this to work From fbdc833b478c3ebfe898d32be3eec0b4e292ab6a Mon Sep 17 00:00:00 2001 From: conorheins Date: Sun, 19 Mar 2023 12:38:18 +0100 Subject: [PATCH 090/232] executed all the documentation demo notebooks to ensure they all work with new features --- .../active_inference_from_scratch.ipynb | 60 ++++++------ docs/notebooks/cue_chaining_demo.ipynb | 8 +- docs/notebooks/free_energy_calculation.ipynb | 40 ++++---- docs/notebooks/pymdp_fundamentals.ipynb | 6 +- docs/notebooks/tmaze_demo.ipynb | 6 +- docs/notebooks/using_the_agent_class.ipynb | 92 +++++++++---------- 6 files changed, 106 insertions(+), 106 deletions(-) diff --git a/docs/notebooks/active_inference_from_scratch.ipynb b/docs/notebooks/active_inference_from_scratch.ipynb index 53ca2f56..da06de66 100644 --- a/docs/notebooks/active_inference_from_scratch.ipynb +++ b/docs/notebooks/active_inference_from_scratch.ipynb @@ -165,9 +165,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "[[0.42309635]\n", - " [0.50568896]\n", - " [0.07121468]]\n", + "[[0.16880278]\n", + " [0.51728256]\n", + " [0.31391466]]\n", "Integral of the distribution: 1.0\n" ] } @@ -232,7 +232,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -281,9 +281,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "[[0.322 0.726 0.772 0.126]\n", - " [0.52 0.812 0.567 0.608]\n", - " [0.452 0.44 0.201 0.441]]\n" + "[[0.089 0.739 0.145 0.399]\n", + " [0.772 0.201 0.026 0.578]\n", + " [0.181 0.253 0.788 0.844]]\n" ] } ], @@ -308,9 +308,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "[[0.249 0.367 0.501 0.107]\n", - " [0.402 0.41 0.368 0.518]\n", - " [0.349 0.223 0.131 0.375]]\n" + "[[0.086 0.619 0.151 0.219]\n", + " [0.741 0.168 0.027 0.318]\n", + " [0.174 0.212 0.821 0.463]]\n" ] } ], @@ -340,10 +340,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "[[0.2488664 ]\n", - " [0.40202984]\n", - " [0.34910376]]\n", - "Integral of P(X|Y=0): 1.0\n" + "[[0.08555937]\n", + " [0.74093812]\n", + " [0.1735025 ]]\n", + "Integral of P(X|Y=0): 0.9999999999999999\n" ] } ], @@ -2028,12 +2028,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Time 2: Agent observes itself in location: (0, 1)\n" + "Time 2: Agent observes itself in location: (0, 0)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2045,12 +2045,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Time 3: Agent observes itself in location: (0, 1)\n" + "Time 3: Agent observes itself in location: (0, 0)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2062,12 +2062,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Time 4: Agent observes itself in location: (0, 2)\n" + "Time 4: Agent observes itself in location: (0, 0)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2353,12 +2353,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Time 3: Agent observes itself in location: (0, 0)\n" + "Time 3: Agent observes itself in location: (0, 1)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2370,12 +2370,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Time 4: Agent observes itself in location: (0, 0)\n" + "Time 4: Agent observes itself in location: (0, 2)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2387,12 +2387,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Time 5: Agent observes itself in location: (0, 1)\n" + "Time 5: Agent observes itself in location: (1, 2)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2404,12 +2404,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Time 6: Agent observes itself in location: (0, 2)\n" + "Time 6: Agent observes itself in location: (2, 2)\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAEUCAYAAADHgubDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAwRklEQVR4nO3de1wU5f4H8A+gpLKIYqhHuUjYYiIoKRp3RUDRMqMUDMVSj9SP8kriejymaSkqB8W8G5qXCNHEG5ihoqbHTAtLLUtBFryFoshiCrjz+8Oze1iXywLLsp35vF8vXi955pmZ7yzrZ2efeXbWRBAEAUREJAqmTV0AEREZDkOfiEhEGPpERCLC0CciEhGGPhGRiDD0iYhEhKHfCGbOnAlnZ2eNnx49eiAgIADz589HcXFxvbY7ZswYBAQEaO2nPvbu3YuAgAC4urpi+vTp9dpGXaxYsQLOzs4oKCho9H09TalU1rrfr776Cs7Ozvjuu+8MVFX18vPz1f8uKCiAs7MzVqxY0YQV1axyvXXp9/TzuSkVFRVh9uzZ8PLywosvvogxY8YgOzu7qctqFM2auoD/ZTKZDG3btgUAPHr0CJcvX0ZKSgp+/vlnJCcnw8zMrEHbDwsLg6enZ53Xu3v3LmQyGWxtbTF79mw4ODg0qA5jplAo8NZbb8Hf3x/vv/9+U5dTq/Hjx8PGxgaLFi0CAFhbW2Px4sX1fnFvbKtWrcKuXbvwzTff1Nhv586dmDdvHn766Sd12zvvvIM///yzsUuslUKhQEREBP744w+89dZbaN26NbZt24axY8ciNTUVUqm0qUvUK4Z+IwoMDIStra1GW5cuXTBv3jwcO3YMAwYMaND23d3d4e7uXuf1cnNzUV5ejoiICISFhTWoBmN37949/Pzzz/D392/qUnTy7bff4rXXXlP/3qpVK7z66qtNWFHN/v3vf+Px48e19vv+++/x6NEjjTZvb+/GKqtO1q9fj9zcXGzZsgUeHh4AgCFDhiAwMBAbNmzA4sWLm7hC/eLwjoH169cPAPD77783WQ3l5eUAAAsLiyargcgYCIKAXbt2oX///urABwAbGxvMmDEDffr0acLqGgdD38Bu3rwJALC3t9dov3z5MqKjo9GnTx/07NkT4eHhOH78eI3bqmpM/+bNm5gxYwZeeukluLq6Yvjw4dizZ4/GOpGRkQCeDD+pxtkFQcCnn36KQYMGwdXVFV5eXvjggw9w48aNWo/pwoULeP/99+Hl5QUXFxd4enpi+vTp6mOtLCcnB5GRkXBzc0P//v2xfPly9YuQyt27dzF37lz4+vqiR48eGDRoENatW6dxRlndNYLK7d999x0GDhwIAPj000/rfE3hzz//RHx8PAICAtTXZJYuXao1JFFWVoYVK1YgODgYbm5uVdabl5eH2NhY+Pn5oUePHujbty/eeecd9Yu/auweAHbt2qW+vlDdmH5qaipeffVVuLq64qWXXsL06dM1jk21XlpaGhISEuDn5wdXV1eMGDECp06dqvXYFQoF4uPjMXjwYLi6usLd3R0jR47EoUOH1H0CAgJw+vRpXLt2rcbrDmPGjMGuXbsAAM7Ozpg5c6a6vfKY/pgxYxAVFYXMzEwMGzYMrq6uGDp0KI4ePQqFQoE5c+bAw8MDnp6emDNnDh4+fKixnx9//BFvv/22+h3wuHHjNIaTqlJQUIBbt27By8sLwJMXgdLSUgBAREQERo4cWetj9VfD4Z1GdP/+fRQVFQF4cnZ95coVLFiwAC4uLhpP9kuXLuHNN9/Es88+i6ioKDRv3hz79u3DxIkTER8fjyFDhui0v1u3bmHEiBEQBAFjxoyBlZUVDh06hA8++AB//PEHJkyYgLCwMHTo0AFr1qxBWFgYevfuDWtra6xZswYrV65ERESEOhw3b96M8+fPY9++fdVef1DV7uDggIkTJ6Jly5b44YcfsHv3buTl5WHHjh0a/SdPnox+/fohNjYWp0+fxqpVq3Djxg31GHZxcTHCw8Nx7do1hIeHw9HRESdOnEB8fDwuXryIZcuW6fz4Ozk5QSaTYeHChQgKCkJQUBCsra11WresrAxvv/02srOzERoaih49euCnn37C+vXrcfbsWWzevBnNmzcHAERHR+PYsWN45ZVX8Pbbb+Onn35CfHw87ty5A5lMhtu3b2PkyJGQSCQYPXo02rZti19++QXbt2/HhQsXcPjwYfXYverscuTIkXByctIKNgCIi4tDUlISPD09MWPGDPzxxx/YunUrTp48idTUVI0hxeXLl6Nly5YYN24cysvLkZSUhKioKGRlZamvNz1NEARERUXh4sWLGD16NOzt7XHz5k18+eWXeO+995CWlgZnZ2fMmjUL8fHx6mtE1V13eOedd6BUKnHmzBksXrxY64SnsgsXLuDHH39EZGQkLC0tsXbtWkyZMgUvvPACWrZsiWnTpuHMmTNISUlB+/bt8d577wEATpw4gaioKHTr1g2TJ09GWVkZvvrqK0RERGDjxo3VnrHn5eUBANq1a4e4uDhs374dCoUC9vb2kMlkRnOhWa8E0rvY2FhBKpVW+ePm5iZkZ2dr9B89erQQGBgolJaWqtvKy8uFN998U/Dy8hIePXqk7jdgwACt/VT+vW/fvsKtW7fUbUqlUpg2bZrQo0cP4fbt24IgCMKpU6cEqVQq7Ny5U90vJCREmDhxokZdycnJwrBhw4S8vLxqj3XOnDlCz549hbt372q0T506VZBKper2xMREQSqVCpMnT9boN3PmTEEqlQq//vqrIAiCsGTJEkEqlQrffPONRr+5c+cKUqlUyMrK0thefn6+Rr+n2/Pz8wWpVCokJiZWewyCIAg7d+4UpFKpcOrUKUEQBOGLL74QpFKpsHHjRo1+69evF6RSqbB161ZBEAQhKytLkEqlwurVqzX6TZ8+XXBxcRGKi4uFtWvXCs7OzsLly5c1+ixdulSQSqXC+fPn1W1SqVSIjY1V//50/b///rvg7OwsREdHC0qlUt0vOztbcHZ2FiZNmqSxnr+/v8bzav/+/YJUKhVSUlKqfSyys7MFqVQqJCcna7QfO3ZMkEqlQlJSkrrt6edkdZ5+rla17ujRowWpVCocPnxY3bZ161ZBKpUKI0eOVLcplUrBz89PCAsLEwRBEB4/fiwMHDhQCA8PFyoqKtT9SktLhaCgIOHVV1+tti7V4xEUFCSEhIQIO3fuFHbt2iW8/PLLQrdu3YQTJ07Uemx/NRzeaURLlizBxo0bsXHjRqxbtw4ffvghbG1tERERgZMnTwJ4MpRx+vRp+Pv74+HDhygqKkJRURHu37+PoKAg3L59Gz///HOt+1IqlcjMzESfPn3QrFkz9Xbu3r2L4OBglJWV4cSJE9Wu37FjR3z33Xf4/PPPcfv2bQBAeHg4du/eXeOZ2dy5c3H48GG0adNG3aZQKPDMM88AAB48eKDRf/z48Rq/jxkzBgBw9OhRAMDhw4fh5OSEwMBAjX7/93//BwAawwuN6fDhw5BIJIiIiNBoj4yMhEQiweHDhwEAWVlZMDU1xejRozX6xcbGYvfu3bCwsMDEiRNx4sQJODk5qZc/fPgQpqZP/vs9/RjV5MiRIxAEARMnToSJiYm6vWfPnvD29sbRo0dRUVGhbvf390erVq3Uv3fr1g0AUFhYWO0+evbsie+//x6hoaHqtsePH0OpVAKAevijMTzzzDPw9fVV/+7o6AgA6mE6ADAxMUHnzp3Vx3Dx4kXk5+cjMDAQxcXF6uf+w4cPMWDAAPzyyy+4detWlfsrKysD8ORdeXJyMkJDQzF8+HBs27YNrVu3Rnx8fGMdapPh8E4jevHFF7Vm74SEhCA4OBjz589HRkaGeu7yli1bsGXLliq3o8u4+t27d1FSUoLMzExkZmbWeTszZszAu+++i08++QQLFy5UD0GNHDkSNjY21a5nYmKCu3fvYu3atbh06RLkcjmuX78O4T937FYFhcpzzz2n8bvqBUU1Hl1QUKDxn17FxsYGrVu3xrVr16qtRZ8KCgpgZ2enHsJRMTc3h52dnbqOa9euoV27dpBIJFr1Vn7cysvLkZCQgAsXLkAul6OgoEA95v/0Y1RbXcB/w7AyJycnfPvtt7h796667enhLHNzc5322axZM3z55Zc4ffo08vLyIJfL1UNNQiPejb1NmzZo1uy/saQaVmzXrp1GPzMzM3UdcrkcALB48eJqZ9pcv34dHTp00GpXvSAGBwfDyspK3d66dWsEBARg165dKC0t/Z+a9MDQN7C2bduiX79++Oabb1BcXKz+jx8REaF1dqvStWvXWrer2s6gQYMQHh5eZR87O7tq1+/WrRu+/vprHD9+HEeOHMHx48eRmJiIjRs3IiUlReMstbL09HTExMSgffv2eOmll9QXKr/99lusXbtWq3/ls1PgvwGi+s9dU6AolUqtEH6aLtMHdaFrHbrs78yZMxg/fjxatWoFLy8vvP766+jevTvkcjk++ugjvdYFAM2bN1dPj1S9m6iLoqIijBgxAn/88Qe8vb0REBCAbt26oXPnzhgxYkSdt1cXlQO/sqefN5Wpjnvy5Mno1atXlX2ePtlQUb0QVHWtx9raGoIg4MGDBwx9ahjVk9TU1BSdO3cG8CT0VDMIVC5fvoyCggK0bNmy1m1aW1ujZcuWqKio0NrO9evXcfHixWq38/jxY/z666+QSCQYOHCg+q10eno6pk6ditTUVPWMi6fFx8fDwcEBO3fu1BhG2Lt3b5X9r127hueff179e25uLoD/nvF37txZ3VZZYWEhFAoF/va3vwH4b5ip3p6rqIamGqpz587Izs5GeXm5xgtNWVkZCgoK1BcGO3XqhJMnT2qdDV64cAFJSUl49913kZiYiBYtWmD//v0a4bJmzZo616V655iTk4OePXtqLMvNzUWrVq1gZWUFhUJR522rfPHFFygoKMCmTZs0Pvz3ww8/1HubjUn1f0j1olrZTz/9hOLiYrRo0aLKdZ9//nmYm5vj8uXLWssKCgrwzDPP6Hzx/6+CY/oGdvv2bZw6dQovvPACLC0t0b59e/To0QO7du3SGHcsLy/HrFmzMGnSJI0x2uo0a9YMfn5+OHr0KH799VeNZYsWLUJ0dLTG2/7KHj9+jMjISHzyySca7apQqels8d69e+jUqZNG4N+4cQMHDx5Ub7uy7du3a/y+ceNGmJiYqGdJDBgwAFeuXNEaolq3bh0AoH///gCgHjqpfKwKhUJ9bUBF9Q6iLkMowJPpiAqFAtu2bdNo/+KLL1BaWqquw9/fH0qlEqmpqRr9kpOTkZGRgWeffRb37t2DtbW1RniUlJSopzFWfoxMTU1rrFX1gb7169drnPVfuHABJ0+ehL+/f41nxbq4d+8eAM13mIIgYOvWrQCg8Xysrd7K/YC6/x100aNHD9jY2GDLli0a1xsUCgWmTJkCmUxW7eyzVq1aISAgAFlZWRqfncnPz8fhw4cxcODABn9y3tjwTL8RZWZmqqfFCYKAmzdvYvv27fjzzz8xdepUdb/Zs2dj7NixeP311zFq1Ci0adMG+/fvx7lz5zB9+vRqp9Y9LSYmBt999x0iIiIQERGBTp06ISsrC0eOHEFYWJjGGXZl5ubmGDNmDFavXo3o6Gj4+vri4cOHSElJQcuWLfH6669Xu08/Pz+kp6djzpw5cHV1RUFBgfoYAe2Lfnv37oVCoYCbmxuOHj2KI0eOYMKECepbQURFReHgwYOYMmUKRo0ahS5duuDUqVM4ePAggoOD1Z+sDQwMxIIFC/DRRx/h2rVrMDc3x/bt2zVefIAnY8SmpqY4dOgQOnXqpDV2W50RI0Zg165dWLRoEX777Tf06NED58+fx1dffYVevXqphzkCAgLg4+ODRYsW4ffff4erqyt+/PFHpKWlITo6Gm3atIGfnx/Wr1+PyZMnw8fHB4WFhdixY4f6XUnlx8ja2hqnT5/G9u3b4ePjo1XX888/jzFjxmDLli14++23ERgYiMLCQmzZsgWtW7fWy32U/Pz8sGXLFkRFReGNN95AeXk5MjIycP78eZiammrV+/333yMpKQm9e/fWevdRuR8AJCYmol+/fvW6fUh1mjdvjtmzZ2Pq1KkIDQ3FG2+8gWeeeQapqam4fv06li5dWu2wEQB88MEHOH36NCIjIxEZGYnmzZtj8+bNaNGiBaZNm6a3Oo0FQ78RLVy4UP1vMzMzWFlZwdXVFR9//LHGk97d3R3JyclYsWIFNm7ciIqKCjg6OmLRokUaH8mvjb29PbZv347ExERs374dDx48gJ2dHWQymXqWTHUmTZqENm3aYOfOnYiLi4OZmRlefPFFLFmypNrxfODJ7J1WrVrh8OHD2L17Nzp27Ijhw4cjKCgIo0aNwqlTp9C9e3d1//Xr12PBggXYt28fOnToAJlMhrfeeku9vE2bNkhJScGyZcuQnp6O+/fvw87ODjNmzNDoZ21tjfXr1yM+Ph6JiYlo27YtRo4cieeee07jBbVly5aYOnUqPvvsMyxYsAD29vbqT0XXxNzcHJs2bcLKlSuRkZGBPXv2oGPHjoiKisK7776rHvIxNTXFqlWrsHLlSuzduxd79uyBvb095syZg1GjRgEA3n//fTx+/Bjp6ek4cuQI2rdvDy8vL4wbNw5Dhw7FqVOnEBQUBODJC3d8fDzmz5+P+fPnVzm//B//+AccHR3x5ZdfYtGiRbCyskJQUBAmTZqkHupoCD8/PyxYsABJSUnq7bu4uCAlJQX//Oc/NW5KN2HCBFy6dAn/+te/EBoaWm3oq54LGzZswM8//6zX0AeAwYMHw8rKCqtXr8aqVatgamqK559/HqtXr671die2trbYvn07lixZgs8++wyCIKBPnz6YMWNGjdfB/qpMhMa8FE9EREaFY/pERCLC0CciEhGGPhGRiDD0iYhEhKFPRCQiDH0iIhH5S8zTv3u3FEql4WaWtmsnwZ079f8Y+/9aHYDx1GIsdQCsxZjrAIynFkPXYWpqgrZtq79X0F8i9JVKwaChr9qnMTCWOgDjqcVY6gBYS1WMpQ7AeGoxljoADu8QEYkKQ5+ISETqHPq//PILXFxcqvzS68pKS0sxb948eHt7w93dHX//+99x9erV+tZJRER6UKfQv3LlCqKionS61e/UqVNx4MABxMTEIC4uDrdu3UJkZCRKSkrqXSwRETWMTqFfUVGBbdu2YcSIEepv5KnJmTNncPToUcTFxeG1115DcHAwNm3ahJKSEiQnJze4aCIiqh+dQv/s2bNYunQpxo0bh5iYmFr7nzhxAhYWFvD29la3WVtbw8PDA8eOHat/tURE1CA6hb6TkxMyMzPx3nvv6fQtMjk5OXBwcNDqa29vX+VX4RERkWHoNE//2WefrdNGFQoFJBKJVruFhUW9vruzXTvtbTU2GxtLg++zKvquQ1lWBlNzc4PV0pD96bOOxsJatBlLHYDx1GIsdQCN9OGsmr6XpabvW63OnTsKg364wcbGEoWFTX/BuTHqsLGxxIlXq//6Q33z3r1Tr8dgLH8bgLUYcx2A8dRi6DpMTU1qPFFulHn6EolE67tRgSfTOKt6B0BERIbRKKHv6OiI/Px8rTP+vLw8ODo6NsYuiYhIB40S+j4+Prh//z5OnjypbisqKsKZM2fg5eXVGLskIiId6CX0i4qKkJ2drb5I6+Hhgb59+2LatGlITU3FN998g7feeguWlpYYNWqUPnZJRET1oJfQz8rKQlhYGC5cuKBu+/TTTxEQEIDFixdj5syZ6NixIzZt2gQrKyt97JKIiOrBRKhpqo2R4Owd/W6Ts3f0g7UYbx2A8dQiitk7RERknBj6REQiwtAnIhIRhj4RkYgw9ImIRIShT0QkIgx9IiIRYegTEYkIQ5+ISEQY+kREIsLQJyISEYY+EZGIMPSJiESEoU9EJCIMfSIiEWHoExGJCEOfiEhEGPpERCLC0CciEhGGPhGRiDD0iYhEhKFPRCQiDH0iIhFh6BMRiQhDn4hIRBj6REQiwtAnIhIRhj4RkYjoHPr79u3D0KFD4ebmhpCQEKSlpdXYv6ioCDKZDD4+Pujbty+ioqJw9erVBpZLREQNoVPop6enIyYmBj4+Pli5ciX69u2L2NhYHDhwoMr+giAgOjoax44dQ0xMDBYvXozCwkJERkaiuLhYrwdARES6a6ZLp4SEBISEhEAmkwEAfH19UVxcjOXLl2Pw4MFa/a9evYoffvgBcXFxGD58OADAyckJgYGBOHz4MF577TX9HQEREems1jP9/Px8yOVyBAcHa7QPGjQIOTk5yM/P11rn0aNHAAALCwt1m5WVFQDg3r17DamXiIgaoNbQz8nJAQA4OjpqtDs4OAAAcnNztdbp1q0b+vXrh5UrV+LKlSsoKirCggUL0KpVKwQGBuqjbiIiqodah3dKSkoAABKJRKNddRavUCiqXG/u3LmYMGEChgwZAgAwNzfHypUrYWdn16CCiYio/moNfUEQalxuaqr9ZuHKlSsIDw+Hvb09Zs2ahRYtWmD79u2YNGkSNmzYgD59+tSpyHbtJLV30jMbG0uD77MqxlJHQ+j7GIzpMWEt2oylDsB4ajGWOgAdQt/S8kmxpaWlGu2qM3zV8so2bdoEAEhKSlKP5Xt7e+PNN9/EJ598gq+++qpORd65o4BSWfOLjz7Z2FiisLDEYPszZB1N8eTT5zEYy98GYC3GXAdgPLUYug5TU5MaT5RrHdNXjeXL5XKN9ry8PI3llV2/fh1OTk7qwAcAExMT9O7dG5cvX9atciIi0rtaQ9/BwQG2trZac/IPHjyILl26oFOnTlrrODo64vfff8f9+/c12s+dO4fOnTs3sGQiIqovnebpR0dHQyaTwcrKCv3798ehQ4eQkZGBhIQEAE8+fSuXy9G1a1dIJBK89dZb2LNnD8aNG4eJEyeiRYsW2L17N06fPq1eh4iIDE+n0A8NDUVZWRmSkpKQmpoKOzs7xMXFqWfmZGVlQSaTYfPmzejXrx9sbW2RnJyMpUuXQiaTwcTEBFKpFBs3boSXl1ejHhAREVVPp9AHgPDwcISHh1e5LDQ0FKGhoRptTk5OWL16dcOqIyIiveJdNomIRIShT0QkIgx9IiIRYegTEYkIQ5+ISEQY+kREIsLQJyISEYY+EZGIMPSJiESEoU9EJCIMfSIiEWHoExGJCEOfiEhEGPpERCLC0CciEhGGPhGRiDD0iYhEhKFPRCQiDH0iIhFh6BMRiQhDn4hIRBj6REQiwtAnIhIRhj4RkYgw9ImIRIShT0QkIgx9IiIRYegTEYmIzqG/b98+DB06FG5ubggJCUFaWlqN/ZVKJVavXo2BAwfCzc0Nr7zyCvbv39/QeomIqAGa6dIpPT0dMTExGDt2LHx8fJCZmYnY2Fi0aNECgwcPrnKdTz75BCkpKZg2bRq6deuG/fv3Y/r06ZBIJPD399frQRARkW50Cv2EhASEhIRAJpMBAHx9fVFcXIzly5dXGfpyuRzbtm3DRx99hBEjRgAAPD09cfXqVRw/fpyhT0TURGoN/fz8fMjlckybNk2jfdCgQcjIyEB+fj7s7Ow0lmVmZqJFixYYPny4RvvWrVsbXjEREdVbrWP6OTk5AABHR0eNdgcHBwBAbm6u1jqXLl2Co6MjTp48iWHDhqF79+4IDg5Genq6PmomIqJ6qjX0S0pKAAASiUSj3cLCAgCgUCi01ikqKsKNGzcwa9YsjB49Ghs2bICLiwumTp2KU6dO6aNuIiKqh1qHdwRBqHG5qan260Z5eTmKioqwZs0aDBgwAADw0ksvIScnB59++ileeumlOhXZrp2k9k56ZmNjafB9VsVY6mgIfR+DMT0mrEWbsdQBGE8txlIHoEPoW1o+Kba0tFSjXXWGr1pemYWFBczMzODt7a1uMzU1hZeXF3bs2FHnIu/cUUCprPnFR59sbCxRWFhisP0Zso6mePLp8xiM5W8DsBZjrgMwnloMXYepqUmNJ8q1Du+oxvLlcrlGe15ensbyyhwcHKBUKlFRUaHRXl5eDhMTk9qrJiKiRlFr6Ds4OMDW1hYHDhzQaD948CC6dOmCTp06aa3j6+sLQRCQkZGhbquoqMDx48fRu3dvPZRNRET1odM8/ejoaMhkMlhZWaF///44dOgQMjIykJCQAODJhVu5XI6uXbtCIpHA09MT/v7+WLBgAR48eIAuXbrgiy++wLVr1xAfH9+oB0RERNXTKfRDQ0NRVlaGpKQkpKamws7ODnFxcRgyZAgAICsrCzKZDJs3b0a/fv0AAImJiVi+fDnWrVuH4uJidO/eHUlJSejRo0fjHQ0REdXIRKhteo4R4IVc/W7zxKuv63WbNfHevZMXcg3AWGoxljoA46nlL3chl4iI/ncw9ImIRIShT0QkIgx9IiIRYegTEYkIQ5+ISEQY+kREIsLQJyISEYY+EZGIMPSJiESEoU9EJCIMfSIiEWHoExGJCEOfiEhEGPpERCLC0CciEhGGPhGRiDD0iYhEhKFPRCQiDH0iIhFh6BMRiQhDn4hIRBj6REQiwtAnIhIRhj4RkYgw9ImIRIShT0QkIgx9IiIRYegTEYmIzqG/b98+DB06FG5ubggJCUFaWprOO7lx4wZ69+6NVatW1adGIiLSE51CPz09HTExMfDx8cHKlSvRt29fxMbG4sCBA7WuKwgCZs2aBYVC0eBiiYioYZrp0ikhIQEhISGQyWQAAF9fXxQXF2P58uUYPHhwjet+8cUXyMnJaXilRETUYLWe6efn50MulyM4OFijfdCgQcjJyUF+fn6N6y5duhTz589veKVERNRgtYa+6izd0dFRo93BwQEAkJubW+V6SqUSM2fOREhICPz8/BpaJxER6UGtwzslJSUAAIlEotFuYWEBANWO1X/++ecoKCjAmjVrGloj2rWT1N5Jz2xsLA2+z6oYSx0Noe9jMKbHhLVoM5Y6AOOpxVjqAHQIfUEQalxuaqr9ZuHKlStYtmwZEhMTYWnZ8IO9c0cBpbLmOvTJxsYShYUlBtufIetoiiefPo/BWP42AGsx5joA46nF0HWYmprUeKJc6/COKrRLS0s12lVn+E+H+uPHjyGTyTB48GB4e3ujoqICFRUVAJ4M+aj+TUREhldr6KvG8uVyuUZ7Xl6exnKVGzdu4Ny5c0hLS4OLi4v6BwBWrFih/jcRERlercM7Dg4OsLW1xYEDBxAUFKRuP3jwILp06YJOnTpp9G/fvj127NihtZ033ngDo0aNwuuvv66HsomIqD50mqcfHR0NmUwGKysr9O/fH4cOHUJGRgYSEhIAAEVFRZDL5ejatSskEglcXV2r3E779u2rXUZERI1Pp0/khoaGYt68efj2228RHR2N77//HnFxcRgyZAgAICsrC2FhYbhw4UKjFktERA2j05k+AISHhyM8PLzKZaGhoQgNDa1x/UuXLtWtMiIi0jveZZOISEQY+kREIsLQJyISEYY+EZGIMPSJiESEoU9EJCIMfSIiEWHoExGJCEOfiEhEGPpERCLC0CciEhGGPhGRiDD0iYhEhKFPRCQiDH0iIhFh6BMRiQhDn4hIRBj6REQiwtAnIhIRhj4RkYgw9ImIRIShT0QkIgx9IiIRYegTEYkIQ5+ISEQY+kREIsLQJyISEYY+EZGI6Bz6+/btw9ChQ+Hm5oaQkBCkpaXV2L+wsBCzZ8/GgAED4O7ujtDQUGRkZDS0XiIiaoBmunRKT09HTEwMxo4dCx8fH2RmZiI2NhYtWrTA4MGDtfqXlZVhwoQJKCkpwaRJk9C+fXt8/fXXmDJlCh4/foyXX35Z7wdCRES10yn0ExISEBISAplMBgDw9fVFcXExli9fXmXoHzt2DL/++itSU1Ph5uYGAPD29sb169exfv16hj4RUROpdXgnPz8fcrkcwcHBGu2DBg1CTk4O8vPztdaxsLBAWFgYXF1dNdqfe+45yOXyBpZMRET1VeuZfk5ODgDA0dFRo93BwQEAkJubCzs7O41lnp6e8PT01GgrLy/H0aNH8fzzzzeoYCIiqr9az/RLSkoAABKJRKPdwsICAKBQKHTa0ZIlS3D16lVMnDixrjUSEZGe1HqmLwhCjctNTWt+3RAEAUuWLMHnn3+O8ePHIzAwsG4VAmjXTlJ7Jz2zsbE0+D6rYix1NIS+j8GYHhPWos1Y6gCMpxZjqQPQIfQtLZ8UW1paqtGuOsNXLa9KWVkZZs6cif3792P8+PGYMWNGvYq8c0cBpbLmFx99srGxRGFhicH2Z8g6muLJp89jMJa/DcBajLkOwHhqMXQdpqYmNZ4o1xr6qrF8uVwOZ2dndXteXp7G8qcpFApERUXhhx9+wKxZszB27Ng6FU5ERPpX65i+g4MDbG1tceDAAY32gwcPokuXLujUqZPWOo8fP8a7776Lc+fOISEhgYFPRGQkdJqnHx0dDZlMBisrK/Tv3x+HDh1CRkYGEhISAABFRUWQy+Xo2rUrJBIJvvzyS5w+fRphYWHo2LEjsrOz1dsyMTFBz549G+VgiIioZjqFfmhoKMrKypCUlITU1FTY2dkhLi4OQ4YMAQBkZWVBJpNh8+bN6NevH77++msAQEpKClJSUjS2ZWZmhosXL+r5MIiISBc6hT4AhIeHIzw8vMploaGhCA0NVf++efPmhldGRER6x7tsEhGJCEOfiEhEGPpERCLC0CciEhGGPhGRiDD0iYhEhKFPRCQiDH0iIhFh6BMRiQhDn4hIRBj6REQiwtAnIhIRhj4RkYgw9ImIRIShT0QkIgx9IiIRYegTEYkIQ5+ISEQY+kREIsLQJyISEYY+EZGIMPSJiESEoU9EJCIMfSIiEWHoExGJCEOfiEhEGPpERCLC0CciEhGGPhGRiOgc+vv27cPQoUPh5uaGkJAQpKWl1di/tLQU8+bNg7e3N9zd3fH3v/8dV69ebWC5RETUEDqFfnp6OmJiYuDj44OVK1eib9++iI2NxYEDB6pdZ+rUqThw4ABiYmIQFxeHW7duITIyEiUlJXornoiI6qaZLp0SEhIQEhICmUwGAPD19UVxcTGWL1+OwYMHa/U/c+YMjh49ivXr18PPzw8A0KdPHwwcOBDJycmYOHGiHg+BiIh0VeuZfn5+PuRyOYKDgzXaBw0ahJycHOTn52utc+LECVhYWMDb21vdZm1tDQ8PDxw7dkwPZRMRUX3Ueqafk5MDAHB0dNRod3BwAADk5ubCzs5Oax0HBweYmZlptNvb2yMjI6PORZqamtR5nYZqin1WxVjqaAh9H4MxPSasRZux1AEYTy2GrKO2fdUa+qoxeIlEotFuYWEBAFAoFFrrKBQKrf6qdarqX5u2bS3qvE5DtWunXX9TaIw6vHfv1Ps2a6LvYzCWvw3AWqpiLHUAxlOLsdQB6DC8IwhCzRsw1d5ETetU1Z+IiAyj1gS2tLQE8GQKZmWqM3bV8sokEolWf9U2qnoHQEREhlFr6KvG8uVyuUZ7Xl6exvKn18nPz9c648/Ly6uyPxERGUatoe/g4ABbW1utOfkHDx5Ely5d0KlTJ611fHx8cP/+fZw8eVLdVlRUhDNnzsDLy0sPZRMRUX3oNE8/OjoaMpkMVlZW6N+/Pw4dOoSMjAwkJCQAeBLocrkcXbt2hUQigYeHB/r27Ytp06YhJiYGbdq0wYoVK2BpaYlRo0Y16gEREVH1TITartT+x5dffomkpCTcuHEDdnZ2mDhxIoYPHw4A+OqrryCTybB582b069cPAFBcXIxFixYhMzMTSqUSvXv3xsyZM/Hcc8812sEQEVHNdA59IiL66+P8SSIiEWHoExGJCEO/krrePrqx/fLLL3BxccHNmzebZP9KpRLJycl45ZVX4O7ujsDAQCxcuLBen6puKEEQsGnTJgwaNAhubm4YNmwY9u7da/A6nvbee+8hKCioSfZdUVEBNzc3ODs7a/y4u7sbvJbvv/8eo0aNQs+ePeHj44P58+dX+VmdxvTdd99pPRaVf3bt2mXQepKTkxESEoJevXrhlVdewZ49ewy6/+roNHtHDFS3jx47dix8fHyQmZmJ2NhYtGjRoso7iTa2K1euICoqChUVFQbft8qGDRuwbNkyjB8/Hp6ensjNzUViYiIuX76Mzz77zKC1rF27FomJiXj//ffRq1cvHDt2DDExMTAzM8OQIUMMWovK7t278c0338De3r5J9p+bm4tHjx4hLi4OXbp0Ubcb+lPv2dnZePvttxEQEIDVq1cjLy8P//rXv1BUVKSe4WcILi4uSElJ0WgTBAH/+Mc/8ODBA/j7+xuslpSUFMydOxfjxo2Dr68vjh49ig8++ADNmzdHSEiIweqokkCCIAhCYGCgMGXKFI22yZMnC4MHDzZoHeXl5cLWrVsFd3d3oW/fvoJUKhVu3Lhh0BoEQRCUSqXg4eEhzJ07V6N9//79glQqFS5evGiwWsrKygQPDw/ho48+0mgfPXq0MGrUKIPVUdnNmzcFDw8Pwc/PTwgMDGySGvbs2SN069ZNePDgQZPsXyUiIkKIiIgQlEqlum3r1q3CwIEDm7y2TZs2Cd26dROys7MNut+wsDBhzJgxGm1vvvmmMHr0aIPWURUO76B+t49uLGfPnsXSpUsxbtw4xMTEGGy/TystLcWwYcPw8ssva7Srptw+/QntxmRmZoYtW7ZofQ9D8+bN8ejRI4PVUdns2bPh7e0NT0/PJtk/8GT4z97eHi1btmyyGlQfuhw1ahRMTP57d8eIiAhkZmY2aW2FhYVYvny5etjJkB49eqS+KaVKmzZtcO/ePYPWURWGPnS7fbShODk5ITMzE++9957WrakNSSKRYPbs2ejdu7dGe2ZmJgCga9euBqvF1NQUzs7O6NChAwRBwO3bt7Fu3TqcPHkSYWFhBqtDJTU1FRcuXMA///lPg++7skuXLsHc3Bzjx4+Hu7s7PDw8MGfOHINec/ntt98gCAKsrKwwZcoU9OrVC71798aHH36Ihw8fGqyOqqxYsQKmpqaYMmWKwfcdGRmJ48ePIyMjAwqFAgcOHEBWVhZeffVVg9fyNI7po363j24szz77rMH2VVfnzp3DunXrEBgYCCcnpyap4eDBg5g0aRIAoH///hg2bJhB93/t2jUsXLgQCxcuhLW1tUH3/bRff/0VCoUCI0aMwDvvvIPz589jxYoVyM3NxebNmzXOvBtLUVERAGDmzJkICgrC6tWrcenSJSxbtgyPHj3CokWLGr2Gqty5cwdpaWkYN24cWrdubfD9Dx06FKdOndJ4wXnttdcwYcIEg9fyNIY+6nf7aLE5e/Ys3nnnHdja2mLBggVNVkf37t2xdetWXLp0CcuXL8fEiRPx+eefGyTgBEHArFmz4O/vj0GDBjX6/mqTkJAAKysrODs7AwA8PDzQrl07fPDBBzh58qTGN9c1lvLycgDAiy++iA8//BAA4OnpCUEQEBcXh+joaK0vWTKE1NRUKJVKREZGGnzfAPDuu+/ixx9/hEwmQ/fu3XHu3DmsWrVK/Q66KTH0Ub/bR4tJeno6Zs6ciS5dumDDhg1o27Ztk9ViZ2cHOzs7eHh4QCKRIDY2Fj/++CNefPHFRt/3tm3bcOnSJezdu1c9q0p1wlBRUQEzMzODvPio9O3bV6utf//+AJ68CzBE6KveDau+C1vFx8cHixYtwqVLl5ok9L/++mv4+vo2ybuxH374Ad9++y0WLlyI0NBQAE/+Vq1bt8acOXMwcuRISKVSg9elwlNY1O/20WKxceNGTJs2Db169cK2bdvQvn17g9dw7949pKWl4datWxrt3bt3BwD88ccfBqnj66+/xt27d+Hj4wMXFxe4uLggLS0NcrkcLi4uBp0HfufOHaSmpmpNMlCNoxvqhVk1VbSsrEyjXfUOwJAvgiq3bt3CxYsXm2xq5PXr1wFA60SkT58+AIDLly8bvKbKGPqo3+2jxSA1NRWLFi1CSEgINmzY0GTveJRKJWbOnKk1B/vEiRMAYLCzpnnz5mHHjh0aPwMGDEDHjh3V/zYUExMTzJkzB1u3btVoT09Ph5mZmdYF+Mbi5OSEzp07Iz09XaP9yJEjaNasWZN8UOzcuXMAYLDH4Gmqk8SzZ89qtGdnZwMAOnfubOiSNHB45z9qu3202Ny5cwcff/wxOnfujIiICFy8eFFjub29vcHeOltbW+PNN9/EunXr0KJFC7i6uuLs2bNYu3YtRowYYbA7t1a1nzZt2sDc3Byurq4GqUHF2toaERER2LJlCyQSCfr06YOzZ89izZo1iIiIUM88a2wmJiaIiYlR30Y9NDQU58+fx+rVqzF69OgmGV757bff0LJlyyYLVxcXFwQGBuLjjz9GSUkJXnjhBZw/fx4rV66En5+fwaePPo2h/x+hoaEoKytDUlISUlNTYWdnh7i4uCb7tGdTO378OP78809cu3YNERERWssXL15s0OlnMpkMf/vb37Bjxw6sWLECHTt2xKRJkzB+/HiD1WBsYmNj0aFDB+zcuRPr1q1Dhw4dMGnSJIPPEBkyZAjMzc2xcuVKREVFoV27doiOjkZUVJRB61C5fft2k8zYqSwhIQGffvopNm3ahDt37qBz584YN26c1mdNmgJvrUxEJCIc0yciEhGGPhGRiDD0iYhEhKFPRCQiDH0iIhFh6BMRiQhDn4hIRBj6REQiwtAnIhKR/wcy3YTma7RZ0QAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -2421,12 +2421,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Time 7: Agent observes itself in location: (1, 2)\n" + "Time 7: Agent observes itself in location: (2, 2)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/docs/notebooks/cue_chaining_demo.ipynb b/docs/notebooks/cue_chaining_demo.ipynb index e01e2d68..b00a28f9 100644 --- a/docs/notebooks/cue_chaining_demo.ipynb +++ b/docs/notebooks/cue_chaining_demo.ipynb @@ -118,7 +118,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -698,7 +698,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -977,7 +977,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1059,7 +1059,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.10" + "version": "3.8.8" }, "orig_nbformat": 4 }, diff --git a/docs/notebooks/free_energy_calculation.ipynb b/docs/notebooks/free_energy_calculation.ipynb index 3f78419b..f80f7826 100644 --- a/docs/notebooks/free_energy_calculation.ipynb +++ b/docs/notebooks/free_energy_calculation.ipynb @@ -26,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -44,7 +44,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -78,7 +78,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -93,7 +93,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -167,7 +167,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -216,7 +216,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -267,7 +267,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -285,7 +285,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -327,7 +327,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -388,7 +388,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -447,7 +447,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -501,7 +501,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -546,7 +546,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -566,7 +566,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -620,7 +620,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -653,7 +653,7 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -662,13 +662,13 @@ "Text(0.5, 1.0, 'Gradient descent on VFE')" ] }, - "execution_count": 54, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -691,7 +691,7 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -751,7 +751,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.8" }, "vscode": { "interpreter": { diff --git a/docs/notebooks/pymdp_fundamentals.ipynb b/docs/notebooks/pymdp_fundamentals.ipynb index fb43573c..329c96bf 100644 --- a/docs/notebooks/pymdp_fundamentals.ipynb +++ b/docs/notebooks/pymdp_fundamentals.ipynb @@ -171,7 +171,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "[0.53712305 0.46287695]\n" + "[0.13370366 0.86629634]\n" ] } ], @@ -533,7 +533,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "[0, 1, 6]\n" + "[2, 2, 0]\n" ] } ], @@ -630,7 +630,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.8" }, "vscode": { "interpreter": { diff --git a/docs/notebooks/tmaze_demo.ipynb b/docs/notebooks/tmaze_demo.ipynb index 5f8c9e3d..2d791396 100644 --- a/docs/notebooks/tmaze_demo.ipynb +++ b/docs/notebooks/tmaze_demo.ipynb @@ -628,7 +628,7 @@ "output_type": "stream", "text": [ " === Starting experiment === \n", - " Reward condition: Right, Observation: [CENTER, No reward, Cue Right]\n", + " Reward condition: Right, Observation: [CENTER, No reward, Cue Left]\n", "[Step 0] Action: [Move to CUE LOCATION]\n", "[Step 0] Observation: [CUE LOCATION, No reward, Cue Right]\n", "[Step 1] Action: [Move to RIGHT ARM]\n", @@ -636,9 +636,9 @@ "[Step 2] Action: [Move to RIGHT ARM]\n", "[Step 2] Observation: [RIGHT ARM, Reward!, Cue Left]\n", "[Step 3] Action: [Move to RIGHT ARM]\n", - "[Step 3] Observation: [RIGHT ARM, Reward!, Cue Left]\n", + "[Step 3] Observation: [RIGHT ARM, Reward!, Cue Right]\n", "[Step 4] Action: [Move to RIGHT ARM]\n", - "[Step 4] Observation: [RIGHT ARM, Reward!, Cue Left]\n" + "[Step 4] Observation: [RIGHT ARM, Reward!, Cue Right]\n" ] } ], diff --git a/docs/notebooks/using_the_agent_class.ipynb b/docs/notebooks/using_the_agent_class.ipynb index 200392da..c1251a43 100644 --- a/docs/notebooks/using_the_agent_class.ipynb +++ b/docs/notebooks/using_the_agent_class.ipynb @@ -290,7 +290,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -359,7 +359,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -411,7 +411,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -532,7 +532,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -754,12 +754,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Context: Left-Better\n" + "Context: Right-Better\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEICAYAAABPgw/pAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAATrklEQVR4nO3df7BcZ33f8fcHGdnB2DjBRMSykV2sgdjFAXothxnaXCgE2SGVmfzAJCWBkKpux1BKaOKkhPGUBJJOOzgkbhSHetwUYodMAlGCiWba5CbtOKSSCqEIoowwEF1scPEPwMapEf72j3MER6vde1fX92qlR+/XzM7dc86z53z37LOfc/a5e+9JVSFJOvk9YdYFSJJWh4EuSY0w0CWpEQa6JDXCQJekRhjoktQIA/0kk2Q+yeJgel+S+Skf+4okB5M8lOR5q1TPhUkqyWmrsb7Ha3T/aPUl+bkk7551HTqagT4DST6T5JE+WB9I8sEkF6xkXVV1aVUtTNn8PwDXVdWTq+ojK9ne8ZTk1iS/sEybSnLx8appNaxmzY93XX1ffMkSy486QFbV26vqJ1e6zWOR5LlJ9ib5av/zucdjuycrA312vr+qngx8B/AF4FePwzY3AfuOw3akxy3JeuAPgPcA3wr8F+AP+vkap6q8Hecb8BngJYPpq4C/GUyfTnc2/bd0Yb8D+JZ+2TywOG5ddAfo64FPAfcB7wO+rV/fQ0ABDwOf6tv/DPA54CvAfuAfT6j3+4CPAF8GDgI3DJZd2K93O3A3cA/wUyPP5cZ+2d39/dP7Za8B/ufItgq4uF/f14BH+9r/cExdfz54Tg8Brzy8f4CfAu7t63ntNPt2wnP/Z8An+330CeD5/fzvBBaAB+kOkv9k8JhbgZuAD/aP+0vgmZNq7ue/HPhov747gcv6+a8E7gLO7qevBD4PPG3SukbqfybwJ31/+CLwXuCcftl/BR4DHukf/9Mjjz2zX/ZYv/wh4DzgBuA9I6//a/u+8QBwLXA58LH++fzayHp/ot+nDwC7gE0T9v330vXPDOb9LbB11u/hE/U28wJOxRtHhvCT6M48fmuw/EZgJ10YnwX8IfCOftk8kwP9jcCHgfPpgus3gNsGbQu4uL//rP4NeF4/feHh0BlT7zzwHLoDxmV0QXj14HEF3NYHwHOA/zuo6d/1NX17H0J3Am/rl72GCYHe378V+IVl9uU32g9qPdRv94l0B8uvAt+63L4ds+4f6gPlciB0B5pN/XoPAD8HrAdeTBfczxrUfT+wBTiNLkRvX6Lm59MdfK4A1gE/3r+uhw987+3X+VS6g+LLJ61rzHO4GHhp3x8OHwRuHNd/lnjtF0fm3cDRgb4DOIMuhP8O+ED/mm/sn9v39O2v7vfdd/b75i3AnRO2/a+BD43M+yMGJwzeRvbZrAs4FW/9m+ghurOXQ/2b9Dn9stCdcT1z0P4FwKf7+0e8wTgy0D/J4Cybbjjna8Bp/fQwLC/u32gvAZ54jPXfCLyzv3/4Df3swfJ/D/zn/v6ngKsGy14GfKa//xrWJtAfOfyc+3n3At+93L4ds+5dwL8aM/8f0p0lP2Ew7zb6Ty593e8eLLsK+Oslav51+oPcYN7+QQieQ3dm+n+A31jq+U/x2l0NfGRc/5nQ/oj+1s+7gaMDfeNg+X0MPi0Avwe8sb//IeB1g2VPoDvgbhqz7Z9ncCDs572XwSdEb0feTohvJpyirq6q/5ZkHbAN+LMkl9B9vH0SsDfJ4bahO3Nbzibg/UkeG8z7OrCB7kzzG6rqQJI30r05L02yC3hTVd09utIkVwC/BPx9ujPS04HfHWl2cHD/s3Rn6tB9RP/syLLzpnguj8d9VXVoMP1V4Ml0Z6jHsm8voDsgjToPOFhVw/38Wbqz0cM+P2b7k2wCfjzJ6wfz1vfboaoeTPK7wJuAH1hiPUdJ8u3Au+gOQmfRBegDx7KOKX1hcP+RMdOHn/8m4FeS/MdhmXT7bthPoDvpOXtk3tl0n4Y0hr8UnbGq+npV/T5d8L6QbpzzEeDSqjqnvz2lul+gLucgcOXgcedU1RlV9blxjavqt6vqhXRvsgJ+ecJ6f5tumOKCqnoK3cfrjLQZfkvnGXSfOuh/bpqw7GG6gAUgydNHS5xQz0od6749SDcGPepu4IIkw/fPMxg5aB6Dg8AvjrxuT6qq26D7pgfduPNtdOF8LN5Btx8vq6qzgX/Kka/dcvt4tV+Dg8A/H3mu31JVd45puw+4LIOjL92Qn7/Yn8BAn7F0ttH9Fv+T/VnfbwLv7M+uSLIxycumWN0O4BeTbOof97R+3eO2+6wkL05yOt2Y5yN0B5VxzgLur6q/S7IF+JExbX4+yZOSXEr3C7Lf6effBrylr+Vc4K1031oA+Cu6TwfPTXIG3aeFoS8Af2+Z5zxNGwBWsG/fDbw5yT/oX6eL+337l3QHo59O8sT+7wC+H7h9mjrG1PybwLVJrui3c2aS70tyVr9f3kM3Xv9aYGOSf7nEukadRT+8l2Qj8G+WqWVcrU9N8pSpntnydgA/2/cTkjwlyQ9NaLtA1yffkOT0JNf18/9klWppz6zHfE7FG9245eFvFnwF+Djwo4PlZwBvp/t2w5fpxsbf0C+bZ+lvubyJbvz1K3TDBW8ftB2OT18G/K++3f10v2w6b0K9P0j3cfgrfbtf4+gx1MPfcvk8g29L9M/lXXTfNrmnv3/GYPm/pTtzPkh39jiscTPf/ObHBybUdm2/3geBHx7dP2P20cR9u8T69/ev1ceB5/XzLwX+DPgS3bdfXjF4zK0Mxv7HvGZH1NzP2wrs7ufdQzekdRbwTuCPB4/9rv712jxpXSP1Xwrs7ev/KN23f4a1bKMbn38QePOEfXAL3bj4g0z+lsvwdxaLwPxg+j3AWwbTr6b7fcDhb03dssT+f15f/yPA/z68/72Nv6XfaZKkk5xDLpLUCANdkhphoEtSIwx0SWrEzP6w6Nxzz60LL7xwVptvysMPP8yZZ5456zKkieyjq2fv3r1frKqnjVs2s0C/8MIL2bNnz6w235SFhQXm5+dnXYY0kX109SQZ/Yvab3DIRZIaYaBLUiMMdElqhIEuSY0w0CWpEQa6JDViqkBPsjXJ/iQHklw/Zvl8ki8l+Wh/e+vqlypJWsqy30Pvr6hzE911CReB3Ul2VtUnRpr+j6p6+RrUKEmawjRn6FuAA1V1V1U9SvdP/MdeNEGSNDvT/KXoRo68XuQi3dXJR70gyV/RXeTgzVV11GWikmynuxACGzZsYGFh4ZgLBph/0YtW9LhWzc+6gBPMwp/+6axLAOynQ/OzLuAEs1Z9dNkLXPSXh3pZVf1kP/1qYEtVvX7Q5mzgsap6KMlVwK9U1eal1js3N1cr/tP/jF7OUho4US7aYj/VJI+jjybZW1Vz45ZNM+SyyJEXAD6fb17kt6+tvlxVD/X37wCe2F8/UpJ0nEwT6LuBzUkuSrIeuIbuCvDfkOTph6/M3V9E+Al01yCUJB0ny46hV9Wh/mrbu4B1dBd03Zfk2n75DrqLCP+LJIfoLuZ6TXmxUkk6rmZ2kWjH0LVmTpRzCfupJpnhGLok6SRgoEtSIwx0SWqEgS5JjTDQJakRBrokNcJAl6RGGOiS1AgDXZIaYaBLUiMMdElqhIEuSY0w0CWpEQa6JDXCQJekRhjoktQIA12SGmGgS1IjDHRJaoSBLkmNMNAlqREGuiQ1wkCXpEYY6JLUCANdkhphoEtSIwx0SWqEgS5JjTDQJakRBrokNcJAl6RGGOiS1IipAj3J1iT7kxxIcv0S7S5P8vUkP7h6JUqSprFsoCdZB9wEXAlcArwqySUT2v0ysGu1i5QkLW+aM/QtwIGququqHgVuB7aNafd64PeAe1exPknSlE6bos1G4OBgehG4YtggyUbgFcCLgcsnrSjJdmA7wIYNG1hYWDjGcjvzK3qUThUr7VerbX7WBeiEtVZ9dJpAz5h5NTJ9I/AzVfX1ZFzz/kFVNwM3A8zNzdX8/Px0VUrHwH6lE91a9dFpAn0RuGAwfT5w90ibOeD2PszPBa5KcqiqPrAaRUqSljdNoO8GNie5CPgccA3wI8MGVXXR4ftJbgX+yDCXpONr2UCvqkNJrqP79so64Jaq2pfk2n75jjWuUZI0hWnO0KmqO4A7RuaNDfKqes3jL0uSdKz8S1FJaoSBLkmNMNAlqREGuiQ1wkCXpEYY6JLUCANdkhphoEtSIwx0SWqEgS5JjTDQJakRBrokNcJAl6RGGOiS1AgDXZIaYaBLUiMMdElqhIEuSY0w0CWpEQa6JDXCQJekRhjoktQIA12SGmGgS1IjDHRJaoSBLkmNMNAlqREGuiQ1wkCXpEYY6JLUCANdkhphoEtSI6YK9CRbk+xPciDJ9WOWb0vysSQfTbInyQtXv1RJ0lJOW65BknXATcBLgUVgd5KdVfWJQbP/DuysqkpyGfA+4NlrUbAkabxpztC3AAeq6q6qehS4Hdg2bFBVD1VV9ZNnAoUk6biaJtA3AgcH04v9vCMkeUWSvwY+CPzE6pQnSZrWskMuQMbMO+oMvKreD7w/yT8C3ga85KgVJduB7QAbNmxgYWHhmIo9bH5Fj9KpYqX9arXNz7oAnbDWqo/mmyMlExokLwBuqKqX9dM/C1BV71jiMZ8GLq+qL05qMzc3V3v27FlR0WTcMUbqLdOnjxv7qSZ5HH00yd6qmhu3bJohl93A5iQXJVkPXAPsHNnAxUnXe5M8H1gP3LfiiiVJx2zZIZeqOpTkOmAXsA64par2Jbm2X74D+AHgx5J8DXgEeGUtd+ovSVpVyw65rBWHXLRmTpRzCfupJpnhkIsk6SRgoEtSIwx0SWqEgS5JjTDQJakRBrokNcJAl6RGGOiS1AgDXZIaYaBLUiMMdElqhIEuSY0w0CWpEQa6JDXCQJekRhjoktQIA12SGmGgS1IjDHRJaoSBLkmNMNAlqREGuiQ1wkCXpEYY6JLUCANdkhphoEtSIwx0SWqEgS5JjTDQJakRBrokNcJAl6RGGOiS1AgDXZIaMVWgJ9maZH+SA0muH7P8R5N8rL/dmeS7Vr9USdJSlg30JOuAm4ArgUuAVyW5ZKTZp4HvqarLgLcBN692oZKkpU1zhr4FOFBVd1XVo8DtwLZhg6q6s6oe6Cc/DJy/umVKkpZz2hRtNgIHB9OLwBVLtH8d8KFxC5JsB7YDbNiwgYWFhemqHDG/okfpVLHSfrXa5mddgE5Ya9VHpwn0jJlXYxsmL6IL9BeOW15VN9MPx8zNzdX8/Px0VUrHwH6lE91a9dFpAn0RuGAwfT5w92ijJJcB7waurKr7Vqc8SdK0phlD3w1sTnJRkvXANcDOYYMkzwB+H3h1Vf3N6pcpSVrOsmfoVXUoyXXALmAdcEtV7Utybb98B/BW4KnAf0oCcKiq5taubEnSqFSNHQ5fc3Nzc7Vnz56VPTjjhvWl3oz69FHsp5rkcfTRJHsnnTD7l6KS1AgDXZIaYaBLUiMMdElqhIEuSY0w0CWpEQa6JDXCQJekRhjoktQIA12SGmGgS1IjDHRJaoSBLkmNMNAlqREGuiQ1wkCXpEYY6JLUCANdkhphoEtSIwx0SWqEgS5JjTDQJakRBrokNcJAl6RGGOiS1AgDXZIaYaBLUiMMdElqhIEuSY0w0CWpEQa6JDXCQJekRkwV6Em2Jtmf5ECS68csf3aSv0jy/5K8efXLlCQt57TlGiRZB9wEvBRYBHYn2VlVnxg0ux94A3D1WhQpSVreNGfoW4ADVXVXVT0K3A5sGzaoqnurajfwtTWoUZI0hWXP0IGNwMHB9CJwxUo2lmQ7sB1gw4YNLCwsrGQ1zK/oUTpVrLRfrbb5WRegE9Za9dFpAj1j5tVKNlZVNwM3A8zNzdX8/PxKViMtyX6lE91a9dFphlwWgQsG0+cDd69JNZKkFZsm0HcDm5NclGQ9cA2wc23LkiQdq2WHXKrqUJLrgF3AOuCWqtqX5Np++Y4kTwf2AGcDjyV5I3BJVX157UqXJA1NM4ZOVd0B3DEyb8fg/ufphmIkSTPiX4pKUiMMdElqhIEuSY0w0CWpEQa6JDXCQJekRhjoktQIA12SGmGgS1IjDHRJaoSBLkmNMNAlqREGuiQ1wkCXpEYY6JLUCANdkhphoEtSIwx0SWqEgS5JjTDQJakRBrokNcJAl6RGGOiS1AgDXZIaYaBLUiMMdElqhIEuSY0w0CWpEQa6JDXCQJekRhjoktQIA12SGmGgS1Ijpgr0JFuT7E9yIMn1Y5Ynybv65R9L8vzVL1WStJRlAz3JOuAm4ErgEuBVSS4ZaXYlsLm/bQd+fZXrlCQtY5oz9C3Agaq6q6oeBW4Hto202Qb8VnU+DJyT5DtWuVZJ0hJOm6LNRuDgYHoRuGKKNhuBe4aNkmynO4MHeCjJ/mOqVpOcC3xx1kWcMJJZV6Cj2UeHHl8f3TRpwTSBPm7LtYI2VNXNwM1TbFPHIMmeqpqbdR3SJPbR42OaIZdF4ILB9PnA3StoI0laQ9ME+m5gc5KLkqwHrgF2jrTZCfxY/22X7wa+VFX3jK5IkrR2lh1yqapDSa4DdgHrgFuqal+Sa/vlO4A7gKuAA8BXgdeuXckaw2Esnejso8dBqo4a6pYknYT8S1FJaoSBLkmNMNBPYsv9SwZp1pLckuTeJB+fdS2nAgP9JDXlv2SQZu1WYOusizhVGOgnr2n+JYM0U1X158D9s67jVGGgn7wm/bsFSacoA/3kNdW/W5B06jDQT17+uwVJRzDQT17T/EsGSacQA/0kVVWHgMP/kuGTwPuqat9sq5KOlOQ24C+AZyVZTPK6WdfUMv/0X5Ia4Rm6JDXCQJekRhjoktQIA12SGmGgS1IjDHRJaoSBLkmN+P+iwTOqX+BAbQAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -779,7 +779,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -799,7 +799,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -813,13 +813,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Action at time 2: Play-left\n", + "Action at time 2: Play-right\n", "Reward at time 2: Reward\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -833,13 +833,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Action at time 3: Play-left\n", + "Action at time 3: Play-right\n", "Reward at time 3: Reward\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -853,13 +853,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Action at time 4: Play-left\n", - "Reward at time 4: Reward\n" + "Action at time 4: Play-right\n", + "Reward at time 4: Loss\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -873,13 +873,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Action at time 5: Play-left\n", - "Reward at time 5: Reward\n" + "Action at time 5: Play-right\n", + "Reward at time 5: Loss\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -893,13 +893,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Action at time 6: Play-left\n", - "Reward at time 6: Loss\n" + "Action at time 6: Play-right\n", + "Reward at time 6: Reward\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -913,13 +913,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Action at time 7: Play-left\n", - "Reward at time 7: Reward\n" + "Action at time 7: Play-right\n", + "Reward at time 7: Loss\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -933,13 +933,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Action at time 8: Play-left\n", + "Action at time 8: Play-right\n", "Reward at time 8: Reward\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEICAYAAABPgw/pAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAATZUlEQVR4nO3dfbBcdX3H8feXREAeBEv0VpKYUEnR8FCxV9DRjlfFGlCJTn2A1lYoNXXatDo+FRWRwYeOFou1UiEqgxVNRNs61xJNZypXxiIUGZQSYpwrgklQo0CQi1iIfPvHObeebHbvbsLeu/f+8n7N3Mmec357znd/e85nz/52zyYyE0nS3LffoAuQJPWHgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDfY6JiJGI2NqY3hgRIz3e9xURsSUiJiLixD7VszQiMiLm92N9j1Zr/6j/IuKdEfHJQdeh3RnoAxARd0TEg3Ww3hsRV0fE4r1ZV2Yem5ljPTa/CFidmYdk5s17s72ZFBFXRMT7urTJiDh6pmrqh37W/GjXVe+Lp0yxfLcXyMz8QGb+2d5uc09ExMsi4tb6WLkuIpbPxHbnKgN9cF6WmYcATwJ+AvzjDGxzCbBxBrYjPWoRsQz4LPAG4HDgy8DobHk3OCtlpn8z/AfcAZzSmD4N+F5j+gCqs+kfUoX9pcBj62UjwNZ266J6gT4X+D5wN3AV8Bv1+iaABB4Avl+3/xtgG3A/sBl4YYd6XwLcDPwc2AJc0Fi2tF7vKuAu4EfAW1sey0fqZXfVtw+ol50FfKNlWwkcXa/vYeChuvYvt6nr2sZjmgBeM9k/wFuA7XU9Z/fStx0e++uBTXUf3QY8o57/NGAM2EH1Inl64z5XAJcAV9f3uwF4Sqea6/kvBb5dr+864IR6/muAHwCPq6dPBX4MPKHTulrqfwrwtXp/+BlVQB5eL/sM8AjwYH3/t7fc9+B62SP18gngSOAC4MqW5//set+4lyqAnwncUj+ej7Ws90/rPr0X2AAs6dD3q4GrG9P71fW03U/9SwN9IJ2+awgfBHwa+OfG8ouBUaowPpTqzORv62UjdA70NwLXA4uogusyYG2jbQJH17ePqQ/AI+vppZOh06beEeD4+oA6gSoIX964XwJr6wA4Hvhpo6YL65qeWIfQdcB762Vn0SHQ69tXAO/r0pf/375R6856u4+herH8BfD4bn3bZt2vonrBeyYQVC80S+r1jgPvBPYHXkAV3Mc06r4bOAmYTxWi66ao+USqF5+TgXnA6+rndfKF77P1Oo+gelF8aad1tXkMRwMvqveHyReBj7Tbf6Z47re2zLuA3QP9UuBA4PeBXwJfqp/zhfVje17dfmXdd0+r++Y84LoO214NrG9Mz6vX/cZBH8Oz9W/gBeyLf/VBNEF19vJwfZAeXy8LqjOupzTaPxv4QX17lwOMXQN9E42zF6rhnIeB+fV0MyyPrg+0U4DH7GH9HwEurm9PHtBPbSz/EPCp+vb3gdMay14M3FHfPovpCfQHJx9zPW878Kxufdtm3RvahQfwe1Rnyfs15q2lfudS1/3JxrLTgO9OUfPHqV/kGvM2N0LwcKp3FP8DXDbV4+/huXs5cHO7/adD+132t3reBewe6Asby++m8W4B+BfgTfXtrwDnNJbtR/WCu6TNtp9aP18jVC+c76Z6t/COfhyHJf45hj44L8/Mw6nOalYDX4+I36Q6izoIuCkidkTEDuCr9fxulgD/1rjfJuBXwFBrw8wcB95EdXBuj4h1EXFku5VGxMkRcU1E/DQi7qN6S72gpdmWxu07qd6aU/97Z4dl0+XuzNzZmP4FcAh73reLqV6QWh0JbMnMRxrz7qQ6G5304zbb72QJ8JbJmuq6FtfbITN3AF8AjgM+PMV6dhMRQ/Vzuy0ifg5cye7PXT/8pHH7wTbTk49/CfAPjcd5D9ULbbPvAMjM71K9W/kY1dDZAqphL7/F1IGBPmCZ+avM/Feq4H0u1Tjng8CxmXl4/XdYVh+gdrMFOLVxv8Mz88DM3NZh25/LzOdSHWQJfLDDej9HNUyxODMPo3p7HS1tmt/SeTLVuw7qf5d0WPYAVcACUL+g7VJih3r21p727RaqMehWdwGLI6J5/DyZanhmb2wB3t/yvB2UmWsBIuLpVOPOa4GP7uG6P0DVj8dn5uOA17Lrc9etj/v9HGwB/rzlsT42M69ru/HML2bmcZl5BPAeqncEN/a5pmIY6AMWlZXA44FN9VnfJ4CLI+KJdZuFEfHiHlZ3KfD+iFhS3+8J9brbbfeYiHhBRBxANS45+eFXO4cC92TmLyPiJOAP27R5d0QcFBHHUn1A9vl6/lrgvLqWBcD5VGeJAN8Bjo2Ip0fEgVTvFpp+AvxWl8fcSxsA9qJvPwm8NSJ+t36ejq779gaqs+63R8Rj6usAXgas66WONjV/AnhD/U4oIuLgiHhJRBxa98uVVOP1ZwMLI+IvplhXq0Ophvfui4iFwNu61NKu1iMi4rCeHll3lwLvqPcTIuKwiHhVp8Z138+LiCcAa4DR+sxd7Qx6zGdf/KMat5z8ZsH9wK3AHzWWH0h1ZnU71TdLNgF/XS8bYepvubyZavz1fqrhgg802jbHp08A/rtudw/w79QfkLap95VUQwr31+0+xu5jqJPfcvkxjW9L1I/lo1RvmX9U3z6wsfxdVGfOW6jOHps1LuPX3/z4Uofa3lCvdwfw6tb+adNHHft2ivVvrp+rW4ET6/nHAl8H7qMaBnhF4z5X0Bj7b/Oc7VJzPW8F1ZnnjnrZF6jC+GLgK437/k79fC3rtK6W+o8Fbqrr/zbVt3+ataykGp/fQePbSS3ruJxqXHwHnb/l0vzMYisw0pi+EjivMf3HVJ8HTH5r6vIp+v8b/HofvQw4eNDH72z+i7rTJElznEMuklQIA12SCtE10CPi8ojYHhG3dlgeEfHRiBiPiFsi4hn9L1OS1E0vZ+hXUH1g08mpVB9eLaP6YOzjj74sSdKe6vojN5l5bUQsnaLJSqrL1hO4PiIOj4gnZeaPplrvggULcunSqVarXj3wwAMcfPDBgy5D6sh9tH9uuummn2Vm24vh+vGrZQvZ9SrBrfW83QI9IlZRncUzNDTERRdd1IfNa2JigkMO6eW6I2kw3Ef75/nPf/6dnZbN6M9QZuYaqosDGB4ezpGRkZncfLHGxsawLzWbuY/OjH58y2Ubu172vYi9vwRakrSX+hHoo8Cf1N92eRZwX7fxc0lS/3UdcomItVSXLi+o/yuq91D9HjSZeSmwnurnQcepft/i7OkqVpLUWS/fcjmzy/IE/rJvFUmS9opXikpSIQx0SSqEgS5JhTDQJakQM3phkbTPiNb/oW/fNjLoAmabafp/KDxDl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqRE+BHhErImJzRIxHxLltlj85Iq6JiJsj4paIOK3/pUqSptI10CNiHnAJcCqwHDgzIpa3NDsPuCozTwTOAP6p34VKkqbWyxn6ScB4Zt6emQ8B64CVLW0SeFx9+zDgrv6VKEnqxfwe2iwEtjSmtwInt7S5APiPiPgr4GDglL5UJ0nqWS+B3oszgSsy88MR8WzgMxFxXGY+0mwUEauAVQBDQ0OMjY31afP7tomJCftylhkZdAGa1abreO0l0LcBixvTi+p5TecAKwAy85sRcSCwANjebJSZa4A1AMPDwzkyMrJ3VWsXY2Nj2JfS3DFdx2svY+g3Assi4qiI2J/qQ8/RljY/BF4IEBFPAw4EftrPQiVJU+sa6Jm5E1gNbAA2UX2bZWNEXBgRp9fN3gK8PiK+A6wFzsrMnK6iJUm762kMPTPXA+tb5p3fuH0b8Jz+liZJ2hNeKSpJhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBWip0CPiBURsTkixiPi3A5tXh0Rt0XExoj4XH/LlCR1M79bg4iYB1wCvAjYCtwYEaOZeVujzTLgHcBzMvPeiHjidBUsSWqvlzP0k4DxzLw9Mx8C1gErW9q8HrgkM+8FyMzt/S1TktRN1zN0YCGwpTG9FTi5pc1vA0TEfwHzgAsy86utK4qIVcAqgKGhIcbGxvaiZLWamJiwL2eZkUEXoFltuo7XXgK91/Uso9qPFwHXRsTxmbmj2Sgz1wBrAIaHh3NkZKRPm9+3jY2NYV9Kc8d0Ha+9DLlsAxY3phfV85q2AqOZ+XBm/gD4HlXAS5JmSC+BfiOwLCKOioj9gTOA0ZY2X6J+lxkRC6iGYG7vX5mSpG66Bnpm7gRWAxuATcBVmbkxIi6MiNPrZhuAuyPiNuAa4G2Zefd0FS1J2l1PY+iZuR5Y3zLv/MbtBN5c/0mSBsArRSWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVoqdAj4gVEbE5IsYj4twp2v1BRGREDPevRElSL7oGekTMAy4BTgWWA2dGxPI27Q4F3gjc0O8iJUnd9XKGfhIwnpm3Z+ZDwDpgZZt27wU+CPyyj/VJkno0v4c2C4EtjemtwMnNBhHxDGBxZl4dEW/rtKKIWAWsAhgaGmJsbGyPC9buJiYm7MtZZmTQBWhWm67jtZdAn1JE7Af8PXBWt7aZuQZYAzA8PJwjIyOPdvOi2jnsS2numK7jtZchl23A4sb0onrepEOB44CxiLgDeBYw6gejkjSzegn0G4FlEXFUROwPnAGMTi7MzPsyc0FmLs3MpcD1wOmZ+a1pqViS1FbXQM/MncBqYAOwCbgqMzdGxIURcfp0FyhJ6k1PY+iZuR5Y3zLv/A5tRx59WZKkPeWVopJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIK0VOgR8SKiNgcEeMRcW6b5W+OiNsi4paI+M+IWNL/UiVJU+ka6BExD7gEOBVYDpwZEctbmt0MDGfmCcAXgQ/1u1BJ0tR6OUM/CRjPzNsz8yFgHbCy2SAzr8nMX9ST1wOL+lumJKmb+T20WQhsaUxvBU6eov05wFfaLYiIVcAqgKGhIcbGxnqrUlOamJiwL2eZkUEXoFltuo7XXgK9ZxHxWmAYeF675Zm5BlgDMDw8nCMjI/3c/D5rbGwM+1KaO6breO0l0LcBixvTi+p5u4iIU4B3Ac/LzP/tT3mSpF71MoZ+I7AsIo6KiP2BM4DRZoOIOBG4DDg9M7f3v0xJUjddAz0zdwKrgQ3AJuCqzNwYERdGxOl1s78DDgG+EBHfjojRDquTJE2TnsbQM3M9sL5l3vmN26f0uS5J0h7ySlFJKoSBLkmFMNAlqRAGuiQVwkCXpEIY6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFcJAl6RCGOiSVAgDXZIKYaBLUiEMdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklQIA12SCmGgS1IhDHRJKoSBLkmFMNAlqRAGuiQVYv6gC9grEYOuYFYZGXQBs03moCuQBsIzdEkqhIEuSYUw0CWpEAa6JBXCQJekQhjoklSIngI9IlZExOaIGI+Ic9ssPyAiPl8vvyEilva9UknSlLoGekTMAy4BTgWWA2dGxPKWZucA92bm0cDFwAf7XagkaWq9nKGfBIxn5u2Z+RCwDljZ0mYl8On69heBF0Z49Y8kzaRerhRdCGxpTG8FTu7UJjN3RsR9wBHAz5qNImIVsKqenIiIzXtTtHazgJa+3qd5LjEbuY82Pbp9dEmnBTN66X9mrgHWzOQ29wUR8a3MHB50HVIn7qMzo5chl23A4sb0onpe2zYRMR84DLi7HwVKknrTS6DfCCyLiKMiYn/gDGC0pc0o8Lr69iuBr2X6C0mSNJO6DrnUY+KrgQ3APODyzNwYERcC38rMUeBTwGciYhy4hyr0NXMcxtJs5z46A8ITaUkqg1eKSlIhDHRJKoSBPod1+0kGadAi4vKI2B4Rtw66ln2BgT5H9fiTDNKgXQGsGHQR+woDfe7q5ScZpIHKzGupvvmmGWCgz13tfpJh4YBqkTQLGOiSVAgDfe7q5ScZJO1DDPS5q5efZJC0DzHQ56jM3AlM/iTDJuCqzNw42KqkXUXEWuCbwDERsTUizhl0TSXz0n9JKoRn6JJUCANdkgphoEtSIQx0SSqEgS5JhTDQJakQBrokFeL/AIuxC9WMTbSdAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -953,8 +953,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Action at time 9: Play-left\n", - "Reward at time 9: Loss\n" + "Action at time 9: Play-right\n", + "Reward at time 9: Reward\n" ] } ], @@ -996,7 +996,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1011,12 +1011,12 @@ "output_type": "stream", "text": [ "Action at time 0: Play-left\n", - "Reward at time 0: Loss\n" + "Reward at time 0: Reward\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1030,13 +1030,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Action at time 1: Play-right\n", - "Reward at time 1: Reward\n" + "Action at time 1: Play-left\n", + "Reward at time 1: Loss\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1050,13 +1050,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Action at time 2: Play-right\n", - "Reward at time 2: Reward\n" + "Action at time 2: Play-left\n", + "Reward at time 2: Loss\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1076,7 +1076,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1091,12 +1091,12 @@ "output_type": "stream", "text": [ "Action at time 4: Play-right\n", - "Reward at time 4: Loss\n" + "Reward at time 4: Reward\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1116,7 +1116,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1136,7 +1136,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1151,12 +1151,12 @@ "output_type": "stream", "text": [ "Action at time 7: Play-right\n", - "Reward at time 7: Loss\n" + "Reward at time 7: Reward\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1176,7 +1176,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1231,7 +1231,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.8" }, "vscode": { "interpreter": { From 1b558758e5b0c55427b1cd8db6d16e74e6f0d6c0 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 27 Apr 2023 17:11:26 +0200 Subject: [PATCH 091/232] function wrapper for the multidimensional outer product (equivalent of `spm.cross` from old `pymdp`) --- pymdp/jax/maths.py | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/pymdp/jax/maths.py b/pymdp/jax/maths.py index bceb3723..65ba6c0f 100644 --- a/pymdp/jax/maths.py +++ b/pymdp/jax/maths.py @@ -20,7 +20,7 @@ def compute_log_likelihood(obs, A): ll = jnp.sum(jnp.stack(result), 0) return ll -MINVAL + def compute_accuracy(qs, obs, A): """ Compute the accuracy portion of the variational free energy (expected log likelihood under the variational posterior) """ @@ -53,6 +53,15 @@ def compute_free_energy(qs, prior, obs, A): return vfe +def multidimensional_outer(arrs): + """ Compute the outer product of a list of arrays by iteratively expanding the first array and multiplying it with the next array """ + + x = arrs[0] + for q in arrs[1:]: + x = jnp.expand_dims(x, -1) * q + + return x + if __name__ == '__main__': obs = [0, 1, 2] obs_vec = [ nn.one_hot(o, 3) for o in obs] From 6b4478e6945bfb2d10fc56f5328057df10a8e83b Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 27 Apr 2023 17:26:51 +0200 Subject: [PATCH 092/232] version of `compute_log_likelihood` that doesn't collapse across observation modalities, keeps log-likelihoods separate --- pymdp/jax/maths.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/pymdp/jax/maths.py b/pymdp/jax/maths.py index 65ba6c0f..6877efc6 100644 --- a/pymdp/jax/maths.py +++ b/pymdp/jax/maths.py @@ -21,6 +21,13 @@ def compute_log_likelihood(obs, A): return ll +def compute_log_likelihood_per_modality(obs, A): + """ Compute likelihood over hidden states across observations from different modalities, and return them per modality """ + ll_all = tree_util.tree_map(compute_log_likelihood_single_modality, obs, A) + ll_all = tree_util.tree_map(lambda x: jnp.sum(x, 0), ll_all) # sum out the observation dimension + + return ll_all + def compute_accuracy(qs, obs, A): """ Compute the accuracy portion of the variational free energy (expected log likelihood under the variational posterior) """ From 4d897d5f0493a9a3e944398d58d2330387722789 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 27 Apr 2023 17:27:07 +0200 Subject: [PATCH 093/232] WIP version of fixed-point iteraiton that leverages sparsity of graphical model --- pymdp/jax/algos.py | 34 +++++++++++++++++++++++++++++++++- 1 file changed, 33 insertions(+), 1 deletion(-) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index ea3adaf2..24b17ab2 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -1,7 +1,7 @@ import jax.numpy as jnp from jax import tree_util, jit, grad, lax, nn -from pymdp.jax.maths import compute_log_likelihood, log_stable, MINVAL +from pymdp.jax.maths import compute_log_likelihood, compute_log_likelihood_per_modality, log_stable, MINVAL def add(x, y): return x + y @@ -46,6 +46,38 @@ def scan_fn(carry, t): qs = tree_util.tree_map(nn.softmax, res) return qs +def run_factorized_fpi(A, obs, prior, blanket_dict, num_iter=1): + """ + @TODO: Run the sparsity-leveraging fixed point iteration algorithm (jaxified) + """ + + nf = len(prior) + factors = list(range(nf)) + # Step 1: Compute log likelihoods for each factor + log_likelihoods = compute_log_likelihood_per_modality(obs, A) + + # Step 2: Map prior to log space and create initial log-posterior + log_prior = tree_util.tree_map(log_stable, prior) + log_q = tree_util.tree_map(jnp.zeros_like, prior) + + # Step 3: Iterate until convergence + def scan_fn(carry, t): + log_q = carry + q = tree_util.tree_map(nn.softmax, log_q) + mll = tree_util.Partial(marginal_log_likelihood, q) + marginal_ll = tree_util.tree_map(mll, log_likelihoods, factors) + + log_q = tree_util.tree_map(add, marginal_ll, log_prior) + + return log_q, None + + res, _ = lax.scan(scan_fn, log_q, jnp.arange(num_iter)) + + # Step 4: Map result to factorised posterior + qs = tree_util.tree_map(nn.softmax, res) + return qs + + if __name__ == "__main__": prior = [jnp.ones(2)/2, jnp.ones(2)/2, nn.softmax(jnp.array([0, -80., -80., -80, -80.]))] obs = [nn.one_hot(0, 5), nn.one_hot(5, 10)] From f838886d5eb68cdfa5eacbf41102d38ed53cbcbd Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Mon, 22 May 2023 13:40:45 +0200 Subject: [PATCH 094/232] learning sceleton --- pymdp/jax/agent.py | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 446fd4ff..c952ec68 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -131,6 +131,16 @@ def _construct_policies(self): self.policies = control.construct_policies( self.num_states, self.num_controls, self.policy_len, self.control_fac_idx ) + + @vmap + def learning(self, *args, **kwargs): + # do stuff + # variables = ... + # parameters = ... + # varibles = {'A': jnp.ones(5)} + + # return Agent(variables, parameters) + raise NotImplementedError @vmap def infer_states(self, observations, empirical_prior): From 8e39cbc2e875d4c884b52c444a3c84755d62d708 Mon Sep 17 00:00:00 2001 From: conorheins Date: Mon, 22 May 2023 16:53:59 +0200 Subject: [PATCH 095/232] - `marginal_log_likelihood` in `algos` now can broadcast across arbitrary leading dimensions - `run_vanilla_fpi` now made sparser so that `log_likelihoods` aren't copied for as many factors as there are - started building blocks in `algos` for marginal and variational message passing Co-authored-by: Dimitrije Markovic --- pymdp/algos/mmp.py | 2 +- pymdp/jax/algos.py | 130 ++++++++++++++++++++++++++++++++++-------- pymdp/jax/learning.py | 28 ++++++++- 3 files changed, 133 insertions(+), 27 deletions(-) diff --git a/pymdp/algos/mmp.py b/pymdp/algos/mmp.py index e38b5b7f..19319fe9 100644 --- a/pymdp/algos/mmp.py +++ b/pymdp/algos/mmp.py @@ -113,7 +113,7 @@ def run_mmp( lnqs = spm_log_single(sx) coeff = 1 if (t >= future_cutoff) else 2 err = (coeff * lnA + lnB_past + lnB_future) - coeff * lnqs - lnqs = lnqs + tau * (err - err.mean()) + lnqs = lnqs + tau * (err - err.mean()) # for numerical stability, before passing into the softmax qs_seq[t][f] = softmax(lnqs) if (t == 0) or (t == (infer_len-1)): F += sx.dot(0.5*err) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index 24b17ab2..896688dd 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -1,5 +1,8 @@ import jax.numpy as jnp -from jax import tree_util, jit, grad, lax, nn +from jax import jit, grad, lax, nn +import jax.tree_util as jtu +# from jax.config import config +# config.update("jax_enable_x64", True) from pymdp.jax.maths import compute_log_likelihood, compute_log_likelihood_per_modality, log_stable, MINVAL @@ -7,14 +10,22 @@ def add(x, y): return x + y def marginal_log_likelihood(qs, log_likelihood, i): - x = qs[0] - for q in qs[1:]: - x = jnp.expand_dims(x, -1) * q - + if i == 0: + x = jnp.ones_like(qs[0]) + else: + x = qs[0] + + parallel_ndim = len(x.shape[:-1]) + + for (f, q) in enumerate(qs[1:]): + if (f + 1) != i: + x = jnp.expand_dims(x, -1) * q + else: + x = jnp.expand_dims(x, -1) * jnp.ones_like(q) + joint = log_likelihood * x - dims = (f for f in range(len(qs)) if f != i) - marg = joint.sum(dims) - return marg/jnp.clip(qs[i], a_min=MINVAL) + dims = (f + parallel_ndim for f in range(len(qs)) if f != i) + return joint.sum(dims) def run_vanilla_fpi(A, obs, prior, num_iter=1): """ Vanilla fixed point iteration (jaxified) """ @@ -23,27 +34,27 @@ def run_vanilla_fpi(A, obs, prior, num_iter=1): factors = list(range(nf)) # Step 1: Compute log likelihoods for each factor ll = compute_log_likelihood(obs, A) - log_likelihoods = [ll] * nf + # log_likelihoods = [ll] * nf # Step 2: Map prior to log space and create initial log-posterior - log_prior = tree_util.tree_map(log_stable, prior) - log_q = tree_util.tree_map(jnp.zeros_like, prior) + log_prior = jtu.tree_map(log_stable, prior) + log_q = jtu.tree_map(jnp.zeros_like, prior) # Step 3: Iterate until convergence def scan_fn(carry, t): log_q = carry - q = tree_util.tree_map(nn.softmax, log_q) - mll = tree_util.Partial(marginal_log_likelihood, q) - marginal_ll = tree_util.tree_map(mll, log_likelihoods, factors) - - log_q = tree_util.tree_map(add, marginal_ll, log_prior) + q = jtu.tree_map(nn.softmax, log_q) + mll = jtu.Partial(marginal_log_likelihood, q, ll) + marginal_ll = jtu.tree_map(mll, factors) + # marginal_ll = jtu.tree_map(mll, log_likelihoods, factors) + log_q = jtu.tree_map(add, marginal_ll, log_prior) return log_q, None res, _ = lax.scan(scan_fn, log_q, jnp.arange(num_iter)) # Step 4: Map result to factorised posterior - qs = tree_util.tree_map(nn.softmax, res) + qs = jtu.tree_map(nn.softmax, res) return qs def run_factorized_fpi(A, obs, prior, blanket_dict, num_iter=1): @@ -57,26 +68,84 @@ def run_factorized_fpi(A, obs, prior, blanket_dict, num_iter=1): log_likelihoods = compute_log_likelihood_per_modality(obs, A) # Step 2: Map prior to log space and create initial log-posterior - log_prior = tree_util.tree_map(log_stable, prior) - log_q = tree_util.tree_map(jnp.zeros_like, prior) + log_prior = jtu.tree_map(log_stable, prior) + log_q = jtu.tree_map(jnp.zeros_like, prior) # Step 3: Iterate until convergence def scan_fn(carry, t): log_q = carry - q = tree_util.tree_map(nn.softmax, log_q) - mll = tree_util.Partial(marginal_log_likelihood, q) - marginal_ll = tree_util.tree_map(mll, log_likelihoods, factors) + q = jtu.tree_map(nn.softmax, log_q) + mll = jtu.Partial(marginal_log_likelihood, q) + marginal_ll = jtu.tree_map(mll, log_likelihoods, factors) - log_q = tree_util.tree_map(add, marginal_ll, log_prior) + log_q = jtu.tree_map(add, marginal_ll, log_prior) return log_q, None res, _ = lax.scan(scan_fn, log_q, jnp.arange(num_iter)) # Step 4: Map result to factorised posterior - qs = tree_util.tree_map(nn.softmax, res) + qs = jtu.tree_map(nn.softmax, res) + return qs + + +def mirror_gradient_descent_step(tau, ln_A, lnB_past, lnB_future, ln_qs): + """ + u_{k+1} = u_{k} - \nabla_p F_k + p_k = softmax(u_k) + """ + + err = ln_A + lnB_past + lnB_future - ln_qs + ln_qs = ln_qs + tau * err + qs = nn.softmax(ln_qs - ln_qs.mean(axis=-1, keepdims=True)) + + return qs + +def update_marginals(get_messages, obs, A, B, prior, num_iter=1, tau=1.): + + nf = len(prior) + T = obs.shape[0] + factors = list(range(nf)) + ln_B = jtu.tree_map(log_stable, B) + # log likelihoods -> $\ln(A)$ for all time steps + # for $k > t$ we have $\ln(A) = 0$ + + log_likelihoods = vmap(compute_log_likelihood, (0, None))(obs, A) # this gives a sequence of log-likelihoods (one for each `t`) + + # log marginals -> $\ln(q(s_t))$ for all time steps and factors + ln_qs = jtu.tree_map( lambda p: jnp.broadcast_to(jnp.zeros_like(p), (T,) + p.shape), prior) + + qs = jtu.tree_map(nn.softmax, ln_qs) + + def scan_fn(carry, iter): + qs = carry + + ln_qs = jtu.tree_map(log_stable, qs) + # messages from future $m_+(s_t)$ and past $m_-(s_t)$ for all time steps and factors. For t = T we have that $m_+(s_T) = 0$ + lnB_past, lnB_future = get_messages(ln_B, B, qs) + + mgds = partial(mirror_gradient_descent_step, tau) + + mll = vmap(jtu.Partial(marginal_log_likelihood, qs, log_likelihoods), ((None, 0, 1, None), 0)) + ln_As = jtu.tree_map(mll, factors) + + qs = jtu.tree_map(mgds, ln_As, lnB_past, lnB_future, ln_qs) + + return qs, None + + qs, _ = lax.scan(scan_fn, qs, jnp.arange(num_iter)) + + # Step 4: Map result to factorised posterior + # qs = jtu.tree_map(nn.softmax, res) return qs +def run_vmp(A, obs, prior, blanket_dict, num_iter=1): + + qs = update_marginals(get_vmp_messages, num_iter=num_iter) + +def run_mmp(A, obs, prior, blanket_dict, num_iter=1): + + qs = update_marginals(get_mmp_messages, num_iter=num_iter) if __name__ == "__main__": prior = [jnp.ones(2)/2, jnp.ones(2)/2, nn.softmax(jnp.array([0, -80., -80., -80, -80.]))] @@ -88,9 +157,22 @@ def scan_fn(carry, t): # test if differentiable from functools import partial + def sum_prod(prior): qs = jnp.concatenate(run_vanilla_fpi(A, obs, prior)) return (qs * log_stable(qs)).sum() print(jit(grad(sum_prod))(prior)) + # def sum_prod(precision): + # # prior = [jnp.ones(2)/2, jnp.ones(2)/2, nn.softmax(log_prior)] + # prior = [jnp.ones(2)/2, jnp.ones(2)/2, nn.softmax(precision*nn.one_hot(0, 5))] + # qs = jnp.concatenate(run_vanilla_fpi(A, obs, prior)) + # return (qs * log_stable(qs)).sum() + + # precis_to_test = 1. + # print(jit(grad(sum_prod))(precis_to_test)) + + # log_prior = jnp.array([0, -80., -80., -80, -80.]) + # print(jit(grad(sum_prod))(log_prior)) + diff --git a/pymdp/jax/learning.py b/pymdp/jax/learning.py index bd694a6d..80e3bea6 100644 --- a/pymdp/jax/learning.py +++ b/pymdp/jax/learning.py @@ -3,8 +3,32 @@ # pylint: disable=no-member import numpy as np -from pymdp import utils, maths -import copy +from .maths import multidimensional_outer +from jax.tree_utils import tree_map +from jax import vmap + +def update_obs_likelihood_dirichlet_m(pA_m, A_m, obs_m, qs, lr=1.0): + """ JAX version of ``pymdp.learning.update_obs_likelihood_dirichlet_m`` """ + + dfda = vmap(multidimensional_outer)([obs_m]+ qs) + # dfda = dfda * (A_m > 0) + dfda = jnp.where(A_m > 0, dfda, 0.0) + qA_m = pA_m + (lr * dfda) + + return qA_m + +def update_obs_likelihood_dirichlet(pA, A, obs, qs, lr=1.0): + """ JAX version of ``pymdp.learning.update_obs_likelihood_dirichlet`` """ + + update_A_fn = lambda pA_m, A_m, obs_m: update_obs_likelihood_dirichlet_m(pA_m, A_m, obs_m, qs, lr=lr) + qA = tree_map(update_A_fn, pA, A, obs) + + # qA=[] + # for (pA_m, A_m, o_m) in zip(pA, A, obs): + # qA_m = update_obs_likelihood_dirichlet_m(pA_m, A_m, o_m, qs, lr=lr) + # qA.append(qA_m) + + return qA def update_obs_likelihood_dirichlet(pA, A, obs, qs, lr=1.0, modalities="all"): """ From a7f1f96402ddb81162e2cc4fee7643c63a1e2bd9 Mon Sep 17 00:00:00 2001 From: conorheins Date: Tue, 23 May 2023 16:34:44 +0200 Subject: [PATCH 096/232] made observation sampling in unit tests for inference algorithms more stable --- test/test_inference_jax.py | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/test/test_inference_jax.py b/test/test_inference_jax.py index 69b0004d..bcf8347f 100644 --- a/test/test_inference_jax.py +++ b/test/test_inference_jax.py @@ -41,8 +41,9 @@ def test_fixed_point_iteration_singlestate_singleobs(self): prior = utils.random_single_categorical(num_states) A = utils.random_A_matrix(num_obs, num_states) - obs_idx = [utils.sample(maths.spm_dot(a_m, prior)) for a_m in A] - obs = utils.process_observation(obs_idx, len(num_obs), num_obs) + obs = utils.obj_array(len(num_obs)) + for m, obs_dim in enumerate(num_obs): + obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) qs_numpy = fpi_numpy(A, obs, num_obs, num_states, prior=prior, num_iter=16, dF=1.0, dF_tol=-1.0) # set dF_tol to negative number so numpy version of FPI never stops early due to convergence @@ -80,8 +81,9 @@ def test_fixed_point_iteration_singlestate_multiobs(self): prior = utils.random_single_categorical(num_states) A = utils.random_A_matrix(num_obs, num_states) - obs_idx = [utils.sample(maths.spm_dot(a_m, prior)) for a_m in A] - obs = utils.process_observation(obs_idx, len(num_obs), num_obs) + obs = utils.obj_array(len(num_obs)) + for m, obs_dim in enumerate(num_obs): + obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) qs_numpy = fpi_numpy(A, obs, num_obs, num_states, prior=prior, num_iter=16, dF=1.0, dF_tol=-1.0) # set dF_tol to negative number so numpy version of FPI never stops early due to convergence @@ -119,8 +121,9 @@ def test_fixed_point_iteration_multistate_singleobs(self): prior = utils.random_single_categorical(num_states) A = utils.random_A_matrix(num_obs, num_states) - obs_idx = [utils.sample(maths.spm_dot(a_m, prior)) for a_m in A] - obs = utils.process_observation(obs_idx, len(num_obs), num_obs) + obs = utils.obj_array(len(num_obs)) + for m, obs_dim in enumerate(num_obs): + obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) qs_numpy = fpi_numpy(A, obs, num_obs, num_states, prior=prior, num_iter=16, dF=1.0, dF_tol=-1.0) # set dF_tol to negative number so numpy version of FPI never stops early due to convergence @@ -162,8 +165,9 @@ def test_fixed_point_iteration_multistate_multiobs(self): prior = utils.random_single_categorical(num_states) A = utils.random_A_matrix(num_obs, num_states) - obs_idx = [utils.sample(maths.spm_dot(a_m, prior)) for a_m in A] - obs = utils.process_observation(obs_idx, len(num_obs), num_obs) + obs = utils.obj_array(len(num_obs)) + for m, obs_dim in enumerate(num_obs): + obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) qs_numpy = fpi_numpy(A, obs, num_obs, num_states, prior=prior, num_iter=16, dF=1.0, dF_tol=-1.0) # set dF_tol to negative number so numpy version of FPI never stops early due to convergence From 25bec09d5d70c402c3c31cfabfa934bd01b8efc7 Mon Sep 17 00:00:00 2001 From: conorheins Date: Tue, 23 May 2023 16:35:00 +0200 Subject: [PATCH 097/232] - allow factorized message passing for vanilla fixed point iteration in `pymdp.jax` - finished off implementations of `run_vmp` and `run_mmp` - added unit tests for factorized version of `run_fpi` in `jax` - started working on unit tests for mmp / vmp -removed unecessary sum in `compute_log_likelihood_single_modality` Co-authored-by: Dimitrije Markovic --- pymdp/jax/algos.py | 76 +++++++++++--- pymdp/jax/maths.py | 4 +- test/test_agent_jax.py | 2 +- test/test_message_passing_jax.py | 169 +++++++++++++++++++++++++++++++ 4 files changed, 233 insertions(+), 18 deletions(-) create mode 100644 test/test_message_passing_jax.py diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index 896688dd..9ec0b0ea 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -1,10 +1,11 @@ import jax.numpy as jnp -from jax import jit, grad, lax, nn +from jax import jit, vmap, grad, lax, nn import jax.tree_util as jtu # from jax.config import config # config.update("jax_enable_x64", True) from pymdp.jax.maths import compute_log_likelihood, compute_log_likelihood_per_modality, log_stable, MINVAL +from typing import Any, List def add(x, y): return x + y @@ -27,6 +28,25 @@ def marginal_log_likelihood(qs, log_likelihood, i): dims = (f + parallel_ndim for f in range(len(qs)) if f != i) return joint.sum(dims) +def all_marginal_log_likelihood(qs, log_likelihoods, all_factor_lists): + qL_marginals = jtu.tree_map(lambda ll_m, factor_list_m: mll_factors(qs, ll_m, factor_list_m), log_likelihoods, all_factor_lists) + + num_factors = len(qs) + + qL_all = [0.] * num_factors + for m, factor_list_m in enumerate(all_factor_lists): + for l, f in enumerate(factor_list_m): + qL_all[f] += qL_marginals[m][l] + + return qL_all + +def mll_factors(qs, ll_m, factor_list_m) -> List: + relevant_factors = [qs[f] for f in factor_list_m] + marginal_ll_f = jtu.Partial(marginal_log_likelihood, relevant_factors, ll_m) + loc_nf = len(factor_list_m) + loc_factors = list(range(loc_nf)) + return jtu.tree_map(marginal_ll_f, loc_factors) + def run_vanilla_fpi(A, obs, prior, num_iter=1): """ Vanilla fixed point iteration (jaxified) """ @@ -46,7 +66,6 @@ def scan_fn(carry, t): q = jtu.tree_map(nn.softmax, log_q) mll = jtu.Partial(marginal_log_likelihood, q, ll) marginal_ll = jtu.tree_map(mll, factors) - # marginal_ll = jtu.tree_map(mll, log_likelihoods, factors) log_q = jtu.tree_map(add, marginal_ll, log_prior) return log_q, None @@ -57,7 +76,7 @@ def scan_fn(carry, t): qs = jtu.tree_map(nn.softmax, res) return qs -def run_factorized_fpi(A, obs, prior, blanket_dict, num_iter=1): +def run_factorized_fpi(A, obs, prior, factor_lists, num_iter=1): """ @TODO: Run the sparsity-leveraging fixed point iteration algorithm (jaxified) """ @@ -75,9 +94,7 @@ def run_factorized_fpi(A, obs, prior, blanket_dict, num_iter=1): def scan_fn(carry, t): log_q = carry q = jtu.tree_map(nn.softmax, log_q) - mll = jtu.Partial(marginal_log_likelihood, q) - marginal_ll = jtu.tree_map(mll, log_likelihoods, factors) - + marginal_ll = all_marginal_log_likelihood(q, log_likelihoods, factor_lists) log_q = jtu.tree_map(add, marginal_ll, log_prior) return log_q, None @@ -88,7 +105,6 @@ def scan_fn(carry, t): qs = jtu.tree_map(nn.softmax, res) return qs - def mirror_gradient_descent_step(tau, ln_A, lnB_past, lnB_future, ln_qs): """ u_{k+1} = u_{k} - \nabla_p F_k @@ -126,7 +142,8 @@ def scan_fn(carry, iter): mgds = partial(mirror_gradient_descent_step, tau) - mll = vmap(jtu.Partial(marginal_log_likelihood, qs, log_likelihoods), ((None, 0, 1, None), 0)) + # @TODO: Change to allow factorized updates + mll = jtu.Partial(marginal_log_likelihood, qs, log_likelihoods) ln_As = jtu.tree_map(mll, factors) qs = jtu.tree_map(mgds, ln_As, lnB_past, lnB_future, ln_qs) @@ -135,17 +152,48 @@ def scan_fn(carry, iter): qs, _ = lax.scan(scan_fn, qs, jnp.arange(num_iter)) - # Step 4: Map result to factorised posterior - # qs = jtu.tree_map(nn.softmax, res) return qs -def run_vmp(A, obs, prior, blanket_dict, num_iter=1): +def get_vmp_messages(ln_B, B, qs, ln_prior): + + @vmap(in_axes=(0, 1), out_axes=1) + def forward(ln_b, q, ln_prior): + msg = q[:-1] @ ln_b.T + return jnp.concatenate([jnp.expand_dims(ln_prior, 0), msg], axis=0) + + @vmap(in_axes=(0, 1), out_axes=1) + def backward(ln_b, q): + msg = q[1:] @ ln_b + return jnp.pad(msg, ((0, 1), (0, 0))) + + lnB_future = jtu.tree_map(forward, ln_B, qs, ln_prior) + lnB_past = jtu.tree_map(backward, ln_B, qs) - qs = update_marginals(get_vmp_messages, num_iter=num_iter) + return lnB_future, lnB_past -def run_mmp(A, obs, prior, blanket_dict, num_iter=1): +def run_vmp(A, obs, prior, blanket_dict, num_iter=1, tau=1.): + qs = update_marginals(get_vmp_messages, obs, A, B, prior, num_iter=num_iter, tau=tau) - qs = update_marginals(get_mmp_messages, num_iter=num_iter) +def get_mmp_messages(ln_B, B, qs, ln_prior): + + @vmap(in_axes=(0, 1), out_axes=1) + def forward(b, q, ln_prior): + msg = log_stable(q[:-1] @ b.T) + return jnp.concatenate([jnp.expand_dims(ln_prior, 0), msg], axis=0) + + @vmap(in_axes=(0, 1), out_axes=1) + def backward(b, q): + msg = log_stable(q[1:] @ b) + return jnp.pad(msg, ((0, 1), (0, 0))) + + lnB_future = jtu.tree_map(forward, B, qs, ln_prior) + lnB_past = jtu.tree_map(backward, B, qs) + + return lnB_future, lnB_past + +def run_mmp(A, obs, prior, blanket_dict, num_iter=1, tau=1.): + qs = update_marginals(get_vmp_messages, obs, A, B, prior, num_iter=num_iter, tau=tau) + return qs if __name__ == "__main__": prior = [jnp.ones(2)/2, jnp.ones(2)/2, nn.softmax(jnp.array([0, -80., -80., -80, -80.]))] diff --git a/pymdp/jax/maths.py b/pymdp/jax/maths.py index 6877efc6..a6b6b8a0 100644 --- a/pymdp/jax/maths.py +++ b/pymdp/jax/maths.py @@ -9,14 +9,13 @@ def log_stable(x): def compute_log_likelihood_single_modality(o_m, A_m): """ Compute observation likelihood for a single modality (observation and likelihood)""" expanded_obs = jnp.expand_dims(o_m, tuple(range(1, A_m.ndim))) - likelihood = (expanded_obs * A_m).sum(axis=0, keepdims=True).squeeze() + likelihood = (expanded_obs * A_m).sum(axis=0) return log_stable(likelihood) def compute_log_likelihood(obs, A): """ Compute likelihood over hidden states across observations from different modalities """ result = tree_util.tree_map(compute_log_likelihood_single_modality, obs, A) - ll = jnp.sum(jnp.stack(result), 0) return ll @@ -24,7 +23,6 @@ def compute_log_likelihood(obs, A): def compute_log_likelihood_per_modality(obs, A): """ Compute likelihood over hidden states across observations from different modalities, and return them per modality """ ll_all = tree_util.tree_map(compute_log_likelihood_single_modality, obs, A) - ll_all = tree_util.tree_map(lambda x: jnp.sum(x, 0), ll_all) # sum out the observation dimension return ll_all diff --git a/test/test_agent_jax.py b/test/test_agent_jax.py index 9f46b1fc..ad3d85d8 100644 --- a/test/test_agent_jax.py +++ b/test/test_agent_jax.py @@ -2,7 +2,7 @@ # -*- coding: utf-8 -*- """ Unit Tests -__author__: Conor Heins +__author__: Dimitrije Markovic, Conor Heins """ import os diff --git a/test/test_message_passing_jax.py b/test/test_message_passing_jax.py new file mode 100644 index 00000000..37068404 --- /dev/null +++ b/test/test_message_passing_jax.py @@ -0,0 +1,169 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +""" Unit Tests +__author__: Dimitrije Markovic, Conor Heins +""" + +import os +import unittest + +import numpy as np +import jax.numpy as jnp + +from pymdp.jax.algos import run_vanilla_fpi as fpi_jax +from pymdp.jax.algos import run_factorized_fpi as fpi_jax_factorized +from pymdp.algos import run_vanilla_fpi as fpi_numpy +from pymdp.algos import run_mmp as mmp_numpy +from pymdp.jax.algos import run_mmp as mmp_jax +from pymdp import utils, maths + +from typing import Any, List + +class TestMessagePassing(unittest.TestCase): + + def test_fixed_point_iteration(self): + num_states_list = [ + [2, 2, 5], + [2, 2, 2], + [4, 4] + ] + + num_obs_list = [ + [5, 10], + [4, 3, 2], + [5, 10, 6] + ] + + for (num_states, num_obs) in zip(num_states_list, num_obs_list): + + # numpy version + prior = utils.random_single_categorical(num_states) + A = utils.random_A_matrix(num_obs, num_states) + + obs = utils.obj_array(len(num_obs)) + for m, obs_dim in enumerate(num_obs): + obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) + + qs_numpy = fpi_numpy(A, obs, num_obs, num_states, prior=prior, num_iter=16, dF=1.0, dF_tol=-1.0) # set dF_tol to negative number so numpy version of FPI never stops early due to convergence + + # jax version + prior = [jnp.array(prior_f) for prior_f in prior] + A = [jnp.array(a_m) for a_m in A] + obs = [jnp.array(o_m) for o_m in obs] + + qs_jax = fpi_jax(A, obs, prior, num_iter=16) + + for f, _ in enumerate(qs_jax): + self.assertTrue(np.allclose(qs_numpy[f], qs_jax[f])) + + + def test_fixed_point_iteration_factorized_fullyconnected(self): + """ + Test the factorized version of `run_vanilla_fpi`, named `run_factorized_fpi` + with multiple hidden state factors and multiple observation modalities. + """ + + num_states_list = [ + [2, 2, 5], + [2, 2, 2], + [4, 4] + ] + + num_obs_list = [ + [5, 10], + [4, 3, 2], + [5, 10, 6] + ] + + for (num_states, num_obs) in zip(num_states_list, num_obs_list): + + # initialize arrays in numpy version + prior = utils.random_single_categorical(num_states) + A = utils.random_A_matrix(num_obs, num_states) + + obs = utils.obj_array(len(num_obs)) + for m, obs_dim in enumerate(num_obs): + obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) + + # jax version + prior = [jnp.array(prior_f) for prior_f in prior] + A = [jnp.array(a_m) for a_m in A] + obs = [jnp.array(o_m) for o_m in obs] + + factor_lists = len(num_obs) * [list(range(len(num_states)))] + + qs_jax = fpi_jax(A, obs, prior, num_iter=16) + qs_jax_factorized = fpi_jax_factorized(A, obs, prior, factor_lists, num_iter=16) + + for f, _ in enumerate(qs_jax): + self.assertTrue(np.allclose(qs_jax[f], qs_jax_factorized[f])) + + def test_fixed_point_iteration_factorized_sparsegraph(self): + """ + Test the factorized version of `run_vanilla_fpi`, named `run_factorized_fpi` + with multiple hidden state factors and multiple observation modalities, and with sparse conditional dependence relationships between hidden states + and observation modalities + """ + + num_states = [3, 4] + num_obs = [3, 3, 5] + + prior = utils.random_single_categorical(num_states) + + obs = utils.obj_array(len(num_obs)) + for m, obs_dim in enumerate(num_obs): + obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) + + A_factor_list = [[0], [1], [0, 1]] # modalities 0 and 1 only depend on factors 0 and 1, respectively + A_reduced = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_factor_list) + + # jax version + prior_jax = [jnp.array(prior_f) for prior_f in prior] + A_reduced_jax = [jnp.array(a_m) for a_m in A_reduced] + obs_jax = [jnp.array(o_m) for o_m in obs] + + qs_out = fpi_jax_factorized(A_reduced_jax, obs_jax, prior_jax, A_factor_list, num_iter=16) + + A_full = utils.initialize_empty_A(num_obs, num_states) + for m, A_m in enumerate(A_full): + other_factors = list(set(range(len(num_states))) - set(A_factor_list[m])) # list of the factors that modality `m` does not depend on + + # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` + expanded_dims = [num_obs[m]] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] + tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] + A_full[m] = np.tile(A_reduced[m].reshape(expanded_dims), tile_dims) + + # jax version + A_full_jax = [jnp.array(a_m) for a_m in A_full] + + qs_validation = fpi_jax(A_full_jax, obs_jax, prior_jax, num_iter=16) + + for qs_f_val, qs_f_out in zip(qs_validation, qs_out): + self.assertTrue(np.allclose(qs_f_val, qs_f_out)) + + def test_marginal_message_passing(self): + pass + + # blanket_dict = {} # @TODO: implement factorized likelihoods for marginal message passing + + # qs_out = mmp_jax(A, obs, prior, blanket_dict, num_iter=1, tau=1.) + + # for qs_f_val, qs_f_out in zip(qs_validation, qs_out): + # self.assertTrue(np.allclose(qs_f_val, qs_f_out).all()) + + def test_vmp(self): + pass + + +if __name__ == "__main__": + unittest.main() + + + + + + + + + From 1ef88a3a1c3b93352a2fe4fc5083857b9b869cf1 Mon Sep 17 00:00:00 2001 From: conorheins Date: Wed, 24 May 2023 11:24:42 +0200 Subject: [PATCH 098/232] unit-testing configuration for MMP in jax Co-authored-by: Dimitrije Markovic --- pymdp/jax/algos.py | 26 ++-- test/test_message_passing_jax.py | 250 +++++++++++++++++++------------ 2 files changed, 168 insertions(+), 108 deletions(-) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index 9ec0b0ea..4f29f060 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -120,7 +120,7 @@ def mirror_gradient_descent_step(tau, ln_A, lnB_past, lnB_future, ln_qs): def update_marginals(get_messages, obs, A, B, prior, num_iter=1, tau=1.): nf = len(prior) - T = obs.shape[0] + T = obs[0].shape[0] factors = list(range(nf)) ln_B = jtu.tree_map(log_stable, B) # log likelihoods -> $\ln(A)$ for all time steps @@ -131,6 +131,9 @@ def update_marginals(get_messages, obs, A, B, prior, num_iter=1, tau=1.): # log marginals -> $\ln(q(s_t))$ for all time steps and factors ln_qs = jtu.tree_map( lambda p: jnp.broadcast_to(jnp.zeros_like(p), (T,) + p.shape), prior) + # log prior -> $\ln(p(s_t))$ for all factors + ln_prior = jtu.tree_map(log_stable, prior) + qs = jtu.tree_map(nn.softmax, ln_qs) def scan_fn(carry, iter): @@ -138,9 +141,9 @@ def scan_fn(carry, iter): ln_qs = jtu.tree_map(log_stable, qs) # messages from future $m_+(s_t)$ and past $m_-(s_t)$ for all time steps and factors. For t = T we have that $m_+(s_T) = 0$ - lnB_past, lnB_future = get_messages(ln_B, B, qs) + lnB_past, lnB_future = get_messages(ln_B, B, qs, ln_prior) - mgds = partial(mirror_gradient_descent_step, tau) + mgds = jtu.Partial(mirror_gradient_descent_step, tau) # @TODO: Change to allow factorized updates mll = jtu.Partial(marginal_log_likelihood, qs, log_likelihoods) @@ -156,18 +159,20 @@ def scan_fn(carry, iter): def get_vmp_messages(ln_B, B, qs, ln_prior): - @vmap(in_axes=(0, 1), out_axes=1) + # @vmap(in_axes=(0, 1, 0), out_axes=1) def forward(ln_b, q, ln_prior): msg = q[:-1] @ ln_b.T return jnp.concatenate([jnp.expand_dims(ln_prior, 0), msg], axis=0) - - @vmap(in_axes=(0, 1), out_axes=1) + fwd = vmap(forward, in_axes=(0, 1, 0), out_axes=1) + + # @vmap(in_axes=(0, 1), out_axes=1) def backward(ln_b, q): msg = q[1:] @ ln_b return jnp.pad(msg, ((0, 1), (0, 0))) + bkwd = vmap(backward, in_axes=(0, 1), out_axes=1) - lnB_future = jtu.tree_map(forward, ln_B, qs, ln_prior) - lnB_past = jtu.tree_map(backward, ln_B, qs) + lnB_future = jtu.tree_map(fwd, ln_B, qs, ln_prior) + lnB_past = jtu.tree_map(bkwd, ln_B, qs) return lnB_future, lnB_past @@ -178,6 +183,9 @@ def get_mmp_messages(ln_B, B, qs, ln_prior): @vmap(in_axes=(0, 1), out_axes=1) def forward(b, q, ln_prior): + + # t x d @ d x d + #TypeError: dot_general requires contracting dimensions to have the same shape, got (2,) and (3,). msg = log_stable(q[:-1] @ b.T) return jnp.concatenate([jnp.expand_dims(ln_prior, 0), msg], axis=0) @@ -191,7 +199,7 @@ def backward(b, q): return lnB_future, lnB_past -def run_mmp(A, obs, prior, blanket_dict, num_iter=1, tau=1.): +def run_mmp(A, B, obs, prior, blanket_dict, num_iter=1, tau=1.): qs = update_marginals(get_vmp_messages, obs, A, B, prior, num_iter=num_iter, tau=tau) return qs diff --git a/test/test_message_passing_jax.py b/test/test_message_passing_jax.py index 37068404..ec60c95f 100644 --- a/test/test_message_passing_jax.py +++ b/test/test_message_passing_jax.py @@ -20,144 +20,196 @@ from typing import Any, List -class TestMessagePassing(unittest.TestCase): - def test_fixed_point_iteration(self): - num_states_list = [ - [2, 2, 5], - [2, 2, 2], - [4, 4] - ] +blanket_dict = {} # @TODO: implement factorized likelihoods for marginal message passing - num_obs_list = [ - [5, 10], - [4, 3, 2], - [5, 10, 6] - ] +num_states = [3] +num_obs = [3] - for (num_states, num_obs) in zip(num_states_list, num_obs_list): +A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.0], + [0.0, 0.0, 1.0], + [0.5, 0.5, 0.0]] + ), (2, 3, 3) )] - # numpy version - prior = utils.random_single_categorical(num_states) - A = utils.random_A_matrix(num_obs, num_states) +B = [ jnp.broadcast_to(jnp.array([[0.0, 0.5, 0.0], + [0.0, 0.5, 1.0], + [1.0, 0.0, 0.0]] + ), (2, 3, 3))] - obs = utils.obj_array(len(num_obs)) - for m, obs_dim in enumerate(num_obs): - obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) +# for the single modality, a sequence over time of observations (one hot vectors) +obs = [ + jnp.broadcast_to(jnp.array([[1, 0, 0], + [0, 1, 0], + [0, 0, 1], + [1, 0, 0]])[:, None], (4, 2, 3) ) + ] - qs_numpy = fpi_numpy(A, obs, num_obs, num_states, prior=prior, num_iter=16, dF=1.0, dF_tol=-1.0) # set dF_tol to negative number so numpy version of FPI never stops early due to convergence +prior = [jnp.ones((2, 3)) / 3.] - # jax version - prior = [jnp.array(prior_f) for prior_f in prior] - A = [jnp.array(a_m) for a_m in A] - obs = [jnp.array(o_m) for o_m in obs] +qs_out = mmp_jax(A, B, obs, prior, blanket_dict, num_iter=1, tau=1.) - qs_jax = fpi_jax(A, obs, prior, num_iter=16) +# class TestMessagePassing(unittest.TestCase): - for f, _ in enumerate(qs_jax): - self.assertTrue(np.allclose(qs_numpy[f], qs_jax[f])) +# # def test_fixed_point_iteration(self): +# # num_states_list = [ +# # [2, 2, 5], +# # [2, 2, 2], +# # [4, 4] +# # ] +# # num_obs_list = [ +# # [5, 10], +# # [4, 3, 2], +# # [5, 10, 6] +# # ] - def test_fixed_point_iteration_factorized_fullyconnected(self): - """ - Test the factorized version of `run_vanilla_fpi`, named `run_factorized_fpi` - with multiple hidden state factors and multiple observation modalities. - """ +# # for (num_states, num_obs) in zip(num_states_list, num_obs_list): - num_states_list = [ - [2, 2, 5], - [2, 2, 2], - [4, 4] - ] +# # # numpy version +# # prior = utils.random_single_categorical(num_states) +# # A = utils.random_A_matrix(num_obs, num_states) - num_obs_list = [ - [5, 10], - [4, 3, 2], - [5, 10, 6] - ] +# # obs = utils.obj_array(len(num_obs)) +# # for m, obs_dim in enumerate(num_obs): +# # obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) - for (num_states, num_obs) in zip(num_states_list, num_obs_list): +# # qs_numpy = fpi_numpy(A, obs, num_obs, num_states, prior=prior, num_iter=16, dF=1.0, dF_tol=-1.0) # set dF_tol to negative number so numpy version of FPI never stops early due to convergence - # initialize arrays in numpy version - prior = utils.random_single_categorical(num_states) - A = utils.random_A_matrix(num_obs, num_states) +# # # jax version +# # prior = [jnp.array(prior_f) for prior_f in prior] +# # A = [jnp.array(a_m) for a_m in A] +# # obs = [jnp.array(o_m) for o_m in obs] - obs = utils.obj_array(len(num_obs)) - for m, obs_dim in enumerate(num_obs): - obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) +# # qs_jax = fpi_jax(A, obs, prior, num_iter=16) - # jax version - prior = [jnp.array(prior_f) for prior_f in prior] - A = [jnp.array(a_m) for a_m in A] - obs = [jnp.array(o_m) for o_m in obs] +# # for f, _ in enumerate(qs_jax): +# # self.assertTrue(np.allclose(qs_numpy[f], qs_jax[f])) - factor_lists = len(num_obs) * [list(range(len(num_states)))] - qs_jax = fpi_jax(A, obs, prior, num_iter=16) - qs_jax_factorized = fpi_jax_factorized(A, obs, prior, factor_lists, num_iter=16) +# # def test_fixed_point_iteration_factorized_fullyconnected(self): +# # """ +# # Test the factorized version of `run_vanilla_fpi`, named `run_factorized_fpi` +# # with multiple hidden state factors and multiple observation modalities. +# # """ - for f, _ in enumerate(qs_jax): - self.assertTrue(np.allclose(qs_jax[f], qs_jax_factorized[f])) +# # num_states_list = [ +# # [2, 2, 5], +# # [2, 2, 2], +# # [4, 4] +# # ] - def test_fixed_point_iteration_factorized_sparsegraph(self): - """ - Test the factorized version of `run_vanilla_fpi`, named `run_factorized_fpi` - with multiple hidden state factors and multiple observation modalities, and with sparse conditional dependence relationships between hidden states - and observation modalities - """ +# # num_obs_list = [ +# # [5, 10], +# # [4, 3, 2], +# # [5, 10, 6] +# # ] + +# # for (num_states, num_obs) in zip(num_states_list, num_obs_list): + +# # # initialize arrays in numpy version +# # prior = utils.random_single_categorical(num_states) +# # A = utils.random_A_matrix(num_obs, num_states) + +# # obs = utils.obj_array(len(num_obs)) +# # for m, obs_dim in enumerate(num_obs): +# # obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) + +# # # jax version +# # prior = [jnp.array(prior_f) for prior_f in prior] +# # A = [jnp.array(a_m) for a_m in A] +# # obs = [jnp.array(o_m) for o_m in obs] + +# # factor_lists = len(num_obs) * [list(range(len(num_states)))] + +# # qs_jax = fpi_jax(A, obs, prior, num_iter=16) +# # qs_jax_factorized = fpi_jax_factorized(A, obs, prior, factor_lists, num_iter=16) + +# # for f, _ in enumerate(qs_jax): +# # self.assertTrue(np.allclose(qs_jax[f], qs_jax_factorized[f])) + +# # def test_fixed_point_iteration_factorized_sparsegraph(self): +# # """ +# # Test the factorized version of `run_vanilla_fpi`, named `run_factorized_fpi` +# # with multiple hidden state factors and multiple observation modalities, and with sparse conditional dependence relationships between hidden states +# # and observation modalities +# # """ - num_states = [3, 4] - num_obs = [3, 3, 5] +# # num_states = [3, 4] +# # num_obs = [3, 3, 5] + +# # prior = utils.random_single_categorical(num_states) + +# # obs = utils.obj_array(len(num_obs)) +# # for m, obs_dim in enumerate(num_obs): +# # obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) + +# # A_factor_list = [[0], [1], [0, 1]] # modalities 0 and 1 only depend on factors 0 and 1, respectively +# # A_reduced = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_factor_list) - prior = utils.random_single_categorical(num_states) +# # # jax version +# # prior_jax = [jnp.array(prior_f) for prior_f in prior] +# # A_reduced_jax = [jnp.array(a_m) for a_m in A_reduced] +# # obs_jax = [jnp.array(o_m) for o_m in obs] - obs = utils.obj_array(len(num_obs)) - for m, obs_dim in enumerate(num_obs): - obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) +# # qs_out = fpi_jax_factorized(A_reduced_jax, obs_jax, prior_jax, A_factor_list, num_iter=16) - A_factor_list = [[0], [1], [0, 1]] # modalities 0 and 1 only depend on factors 0 and 1, respectively - A_reduced = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_factor_list) +# # A_full = utils.initialize_empty_A(num_obs, num_states) +# # for m, A_m in enumerate(A_full): +# # other_factors = list(set(range(len(num_states))) - set(A_factor_list[m])) # list of the factors that modality `m` does not depend on - # jax version - prior_jax = [jnp.array(prior_f) for prior_f in prior] - A_reduced_jax = [jnp.array(a_m) for a_m in A_reduced] - obs_jax = [jnp.array(o_m) for o_m in obs] +# # # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` +# # expanded_dims = [num_obs[m]] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] +# # tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] +# # A_full[m] = np.tile(A_reduced[m].reshape(expanded_dims), tile_dims) - qs_out = fpi_jax_factorized(A_reduced_jax, obs_jax, prior_jax, A_factor_list, num_iter=16) +# # # jax version +# # A_full_jax = [jnp.array(a_m) for a_m in A_full] - A_full = utils.initialize_empty_A(num_obs, num_states) - for m, A_m in enumerate(A_full): - other_factors = list(set(range(len(num_states))) - set(A_factor_list[m])) # list of the factors that modality `m` does not depend on +# # qs_validation = fpi_jax(A_full_jax, obs_jax, prior_jax, num_iter=16) - # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` - expanded_dims = [num_obs[m]] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] - tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] - A_full[m] = np.tile(A_reduced[m].reshape(expanded_dims), tile_dims) +# # for qs_f_val, qs_f_out in zip(qs_validation, qs_out): +# # self.assertTrue(np.allclose(qs_f_val, qs_f_out)) - # jax version - A_full_jax = [jnp.array(a_m) for a_m in A_full] +# def test_marginal_message_passing(self): - qs_validation = fpi_jax(A_full_jax, obs_jax, prior_jax, num_iter=16) +# blanket_dict = {} # @TODO: implement factorized likelihoods for marginal message passing - for qs_f_val, qs_f_out in zip(qs_validation, qs_out): - self.assertTrue(np.allclose(qs_f_val, qs_f_out)) +# num_states = [3] +# num_obs = [3] - def test_marginal_message_passing(self): - pass +# A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.0], +# [0.0, 0.0, 1.0], +# [0.5, 0.5, 0.0]] +# ), (2, 3, 3) )] + +# B = [ jnp.broadcast_to(jnp.array([[0.0, 0.5, 0.0], +# [0.0, 0.5, 1.0], +# [1.0, 0.0, 0.0]] +# ), (2, 3, 3))] + +# # for the single modality, a sequence over time of observations (one hot vectors) +# obs = [ +# jnp.broadcast_to(jnp.array([[1, 0, 0], +# [0, 1, 0], +# [0, 0, 1], +# [1, 0, 0]])[:, None], (4, 2, 3) ) +# ] + +# prior = [jnp.ones((2, 3)) / 3.] - # blanket_dict = {} # @TODO: implement factorized likelihoods for marginal message passing +# qs_out = mmp_jax(A, B, obs, prior, blanket_dict, num_iter=1, tau=1.) - # qs_out = mmp_jax(A, obs, prior, blanket_dict, num_iter=1, tau=1.) +# print(qs_out[0]) - # for qs_f_val, qs_f_out in zip(qs_validation, qs_out): - # self.assertTrue(np.allclose(qs_f_val, qs_f_out).all()) +# # for qs_f_val, qs_f_out in zip(qs_validation, qs_out): +# # self.assertTrue(np.allclose(qs_f_val, qs_f_out).all()) - def test_vmp(self): - pass +# def test_vmp(self): +# pass -if __name__ == "__main__": - unittest.main() +# if __name__ == "__main__": +# unittest.main() From 5fe83a996cfeb8d22a08b576fd19961e57194558 Mon Sep 17 00:00:00 2001 From: conorheins Date: Wed, 24 May 2023 12:23:30 +0200 Subject: [PATCH 099/232] - added in part in `update_marginals()` where we vmap across batch dimension and time dimension - zero'd out backwards message for debugging purposes in mmp_messages --- pymdp/jax/algos.py | 21 ++++++++++++++------- 1 file changed, 14 insertions(+), 7 deletions(-) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index 4f29f060..e37b37d5 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -126,7 +126,13 @@ def update_marginals(get_messages, obs, A, B, prior, num_iter=1, tau=1.): # log likelihoods -> $\ln(A)$ for all time steps # for $k > t$ we have $\ln(A) = 0$ - log_likelihoods = vmap(compute_log_likelihood, (0, None))(obs, A) # this gives a sequence of log-likelihoods (one for each `t`) + def get_log_likelihood(obs_t, A): + + # mapping over batch dimension + return vmap(compute_log_likelihood)(obs_t, A) + + # mapping over time dimension of obs array + log_likelihoods = vmap(get_log_likelihood, (0, None))(obs, A) # this gives a sequence of log-likelihoods (one for each `t`) # log marginals -> $\ln(q(s_t))$ for all time steps and factors ln_qs = jtu.tree_map( lambda p: jnp.broadcast_to(jnp.zeros_like(p), (T,) + p.shape), prior) @@ -167,6 +173,7 @@ def forward(ln_b, q, ln_prior): # @vmap(in_axes=(0, 1), out_axes=1) def backward(ln_b, q): + # q_i B_ij msg = q[1:] @ ln_b return jnp.pad(msg, ((0, 1), (0, 0))) bkwd = vmap(backward, in_axes=(0, 1), out_axes=1) @@ -181,18 +188,18 @@ def run_vmp(A, obs, prior, blanket_dict, num_iter=1, tau=1.): def get_mmp_messages(ln_B, B, qs, ln_prior): - @vmap(in_axes=(0, 1), out_axes=1) + # @vmap(in_axes=(0, 1), out_axes=1) def forward(b, q, ln_prior): # t x d @ d x d #TypeError: dot_general requires contracting dimensions to have the same shape, got (2,) and (3,). - msg = log_stable(q[:-1] @ b.T) + msg = log_stable(q[:-1] @ b.T) / 2. return jnp.concatenate([jnp.expand_dims(ln_prior, 0), msg], axis=0) - @vmap(in_axes=(0, 1), out_axes=1) + # @vmap(in_axes=(0, 1), out_axes=1) def backward(b, q): - msg = log_stable(q[1:] @ b) - return jnp.pad(msg, ((0, 1), (0, 0))) + msg = log_stable(q[1:] @ b) / 2. + return jnp.zeros_like(jnp.pad(msg, ((0, 1), (0, 0)))) lnB_future = jtu.tree_map(forward, B, qs, ln_prior) lnB_past = jtu.tree_map(backward, B, qs) @@ -200,7 +207,7 @@ def backward(b, q): return lnB_future, lnB_past def run_mmp(A, B, obs, prior, blanket_dict, num_iter=1, tau=1.): - qs = update_marginals(get_vmp_messages, obs, A, B, prior, num_iter=num_iter, tau=tau) + qs = update_marginals(get_mmp_messages, obs, A, B, prior, num_iter=num_iter, tau=tau) return qs if __name__ == "__main__": From a838f29326d6beee731cdacb27ea224fcca7a14a Mon Sep 17 00:00:00 2001 From: conorheins Date: Wed, 24 May 2023 12:23:49 +0200 Subject: [PATCH 100/232] unit-testing both MMP and VMP in unit test file --- test/test_message_passing_jax.py | 36 ++++++++++++++++++++------------ 1 file changed, 23 insertions(+), 13 deletions(-) diff --git a/test/test_message_passing_jax.py b/test/test_message_passing_jax.py index ec60c95f..14d3d2b8 100644 --- a/test/test_message_passing_jax.py +++ b/test/test_message_passing_jax.py @@ -10,12 +10,14 @@ import numpy as np import jax.numpy as jnp +import jax.tree_util as jtu from pymdp.jax.algos import run_vanilla_fpi as fpi_jax from pymdp.jax.algos import run_factorized_fpi as fpi_jax_factorized from pymdp.algos import run_vanilla_fpi as fpi_numpy from pymdp.algos import run_mmp as mmp_numpy from pymdp.jax.algos import run_mmp as mmp_jax +from pymdp.jax.algos import run_vmp as vmp_jax from pymdp import utils, maths from typing import Any, List @@ -26,27 +28,35 @@ num_states = [3] num_obs = [3] -A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.0], - [0.0, 0.0, 1.0], - [0.5, 0.5, 0.0]] - ), (2, 3, 3) )] +A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.], + [0.0, 0.0, 1.], + [0.5, 0.5, 0.]] + ), (2, 3, 3) )] -B = [ jnp.broadcast_to(jnp.array([[0.0, 0.5, 0.0], - [0.0, 0.5, 1.0], - [1.0, 0.0, 0.0]] +B = [ jnp.broadcast_to(jnp.array([[0.0, 0.75, 0.0], + [0.0, 0.25, 1.0], + [1.0, 0.0, 0.0]] ), (2, 3, 3))] # for the single modality, a sequence over time of observations (one hot vectors) obs = [ - jnp.broadcast_to(jnp.array([[1, 0, 0], - [0, 1, 0], - [0, 0, 1], - [1, 0, 0]])[:, None], (4, 2, 3) ) - ] + jnp.broadcast_to(jnp.array([[1., 0., 0.], + [0., 1., 0.], + [0., 0., 1.], + [1., 0., 0.]])[:, None], (4, 2, 3) ) + ] prior = [jnp.ones((2, 3)) / 3.] -qs_out = mmp_jax(A, B, obs, prior, blanket_dict, num_iter=1, tau=1.) +for t in range(4): + loc_obs = jtu.tree_map( lambda o: o[:t+1], obs) + qs_out = vmp_jax(A, B, loc_obs, prior, blanket_dict, num_iter=16, tau=1.) + print(qs_out[0][:,0,:].round(3)) + +for t in range(4): + loc_obs = jtu.tree_map( lambda o: o[:t+1], obs) + qs_out = mmp_jax(A, B, loc_obs, prior, blanket_dict, num_iter=16, tau=1.) + print(qs_out[0][:,0,:].round(3)) # class TestMessagePassing(unittest.TestCase): From 3b423581829ad30c6d3e8349d5c5105a08a60981 Mon Sep 17 00:00:00 2001 From: conorheins Date: Wed, 24 May 2023 13:06:58 +0200 Subject: [PATCH 101/232] - basic unit-tests for run_vmp and run_mmp - special weighting of forward messages for MMP Co-authored-by: Dimitrije Markovic --- pymdp/jax/algos.py | 28 ++- test/test_message_passing_jax.py | 356 +++++++++++++++++-------------- 2 files changed, 214 insertions(+), 170 deletions(-) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index e37b37d5..a4922bb3 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -183,26 +183,32 @@ def backward(ln_b, q): return lnB_future, lnB_past -def run_vmp(A, obs, prior, blanket_dict, num_iter=1, tau=1.): +def run_vmp(A, B, obs, prior, blanket_dict, num_iter=1, tau=1.): qs = update_marginals(get_vmp_messages, obs, A, B, prior, num_iter=num_iter, tau=tau) + return qs def get_mmp_messages(ln_B, B, qs, ln_prior): - # @vmap(in_axes=(0, 1), out_axes=1) def forward(b, q, ln_prior): + if len(q) > 1: + msg = log_stable(q[:-1] @ b.T) + n = len(msg) + if n > 1: # this is the case where there are at least 3 observations. If you have two observations, then you weight the single past message from t = 0 by 1.0 + msg = msg * jnp.pad( 0.5 * jnp.ones(n-1), (0, 1), constant_values=1.)[:, None] + return jnp.concatenate([jnp.expand_dims(ln_prior, 0), msg], axis=0) # @TODO: look up whether we want to decrease influence of prior by half as well + else: # this is case where this is a single observation / single-timestep posterior + return jnp.expand_dims(ln_prior, 0) - # t x d @ d x d - #TypeError: dot_general requires contracting dimensions to have the same shape, got (2,) and (3,). - msg = log_stable(q[:-1] @ b.T) / 2. - return jnp.concatenate([jnp.expand_dims(ln_prior, 0), msg], axis=0) + fwd = vmap(forward, in_axes=(0, 1, 0), out_axes=1) - # @vmap(in_axes=(0, 1), out_axes=1) def backward(b, q): - msg = log_stable(q[1:] @ b) / 2. - return jnp.zeros_like(jnp.pad(msg, ((0, 1), (0, 0)))) + msg = log_stable(q[1:] @ b) * 0.5 + return jnp.pad(msg, ((0, 1), (0, 0))) + + bkwd = vmap(backward, in_axes=(0, 1), out_axes=1) - lnB_future = jtu.tree_map(forward, B, qs, ln_prior) - lnB_past = jtu.tree_map(backward, B, qs) + lnB_future = jtu.tree_map(fwd, B, qs, ln_prior) + lnB_past = jtu.tree_map(bkwd, B, qs) return lnB_future, lnB_past diff --git a/test/test_message_passing_jax.py b/test/test_message_passing_jax.py index 14d3d2b8..a8ea50c6 100644 --- a/test/test_message_passing_jax.py +++ b/test/test_message_passing_jax.py @@ -22,204 +22,242 @@ from typing import Any, List +# blanket_dict = {} # @TODO: implement factorized likelihoods for marginal message passing -blanket_dict = {} # @TODO: implement factorized likelihoods for marginal message passing +# num_states = [3] +# num_obs = [3] + +# A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.], +# [0.0, 0.0, 1.], +# [0.5, 0.5, 0.]] +# ), (2, 3, 3) )] -num_states = [3] -num_obs = [3] +# B = [ jnp.broadcast_to(jnp.array([[0.0, 0.75, 0.0], +# [0.0, 0.25, 1.0], +# [1.0, 0.0, 0.0]] +# ), (2, 3, 3))] -A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.], - [0.0, 0.0, 1.], - [0.5, 0.5, 0.]] - ), (2, 3, 3) )] +# # for the single modality, a sequence over time of observations (one hot vectors) +# obs = [ +# jnp.broadcast_to(jnp.array([[1., 0., 0.], +# [0., 1., 0.], +# [0., 0., 1.], +# [1., 0., 0.]])[:, None], (4, 2, 3) ) +# ] + +# prior = [jnp.ones((2, 3)) / 3.] + +# for t in range(4): +# loc_obs = jtu.tree_map( lambda o: o[:t+1], obs) +# qs_out = vmp_jax(A, B, loc_obs, prior, blanket_dict, num_iter=16, tau=1.) +# print(qs_out[0][:,0,:].round(3)) + +# for t in range(4): +# loc_obs = jtu.tree_map( lambda o: o[:t+1], obs) +# qs_out = mmp_jax(A, B, loc_obs, prior, blanket_dict, num_iter=16, tau=1.) +# print(qs_out[0][:,0,:].round(3)) + +class TestMessagePassing(unittest.TestCase): + + def test_fixed_point_iteration(self): + num_states_list = [ + [2, 2, 5], + [2, 2, 2], + [4, 4] + ] + + num_obs_list = [ + [5, 10], + [4, 3, 2], + [5, 10, 6] + ] + + for (num_states, num_obs) in zip(num_states_list, num_obs_list): + + # numpy version + prior = utils.random_single_categorical(num_states) + A = utils.random_A_matrix(num_obs, num_states) + + obs = utils.obj_array(len(num_obs)) + for m, obs_dim in enumerate(num_obs): + obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) + + qs_numpy = fpi_numpy(A, obs, num_obs, num_states, prior=prior, num_iter=16, dF=1.0, dF_tol=-1.0) # set dF_tol to negative number so numpy version of FPI never stops early due to convergence + + # jax version + prior = [jnp.array(prior_f) for prior_f in prior] + A = [jnp.array(a_m) for a_m in A] + obs = [jnp.array(o_m) for o_m in obs] + + qs_jax = fpi_jax(A, obs, prior, num_iter=16) + + for f, _ in enumerate(qs_jax): + self.assertTrue(np.allclose(qs_numpy[f], qs_jax[f])) + + + def test_fixed_point_iteration_factorized_fullyconnected(self): + """ + Test the factorized version of `run_vanilla_fpi`, named `run_factorized_fpi` + with multiple hidden state factors and multiple observation modalities. + """ + + num_states_list = [ + [2, 2, 5], + [2, 2, 2], + [4, 4] + ] + + num_obs_list = [ + [5, 10], + [4, 3, 2], + [5, 10, 6] + ] + + for (num_states, num_obs) in zip(num_states_list, num_obs_list): + + # initialize arrays in numpy version + prior = utils.random_single_categorical(num_states) + A = utils.random_A_matrix(num_obs, num_states) + + obs = utils.obj_array(len(num_obs)) + for m, obs_dim in enumerate(num_obs): + obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) + + # jax version + prior = [jnp.array(prior_f) for prior_f in prior] + A = [jnp.array(a_m) for a_m in A] + obs = [jnp.array(o_m) for o_m in obs] + + factor_lists = len(num_obs) * [list(range(len(num_states)))] + + qs_jax = fpi_jax(A, obs, prior, num_iter=16) + qs_jax_factorized = fpi_jax_factorized(A, obs, prior, factor_lists, num_iter=16) + + for f, _ in enumerate(qs_jax): + self.assertTrue(np.allclose(qs_jax[f], qs_jax_factorized[f])) -B = [ jnp.broadcast_to(jnp.array([[0.0, 0.75, 0.0], - [0.0, 0.25, 1.0], - [1.0, 0.0, 0.0]] - ), (2, 3, 3))] - -# for the single modality, a sequence over time of observations (one hot vectors) -obs = [ - jnp.broadcast_to(jnp.array([[1., 0., 0.], - [0., 1., 0.], - [0., 0., 1.], - [1., 0., 0.]])[:, None], (4, 2, 3) ) - ] - -prior = [jnp.ones((2, 3)) / 3.] - -for t in range(4): - loc_obs = jtu.tree_map( lambda o: o[:t+1], obs) - qs_out = vmp_jax(A, B, loc_obs, prior, blanket_dict, num_iter=16, tau=1.) - print(qs_out[0][:,0,:].round(3)) - -for t in range(4): - loc_obs = jtu.tree_map( lambda o: o[:t+1], obs) - qs_out = mmp_jax(A, B, loc_obs, prior, blanket_dict, num_iter=16, tau=1.) - print(qs_out[0][:,0,:].round(3)) - -# class TestMessagePassing(unittest.TestCase): - -# # def test_fixed_point_iteration(self): -# # num_states_list = [ -# # [2, 2, 5], -# # [2, 2, 2], -# # [4, 4] -# # ] - -# # num_obs_list = [ -# # [5, 10], -# # [4, 3, 2], -# # [5, 10, 6] -# # ] + def test_fixed_point_iteration_factorized_sparsegraph(self): + """ + Test the factorized version of `run_vanilla_fpi`, named `run_factorized_fpi` + with multiple hidden state factors and multiple observation modalities, and with sparse conditional dependence relationships between hidden states + and observation modalities + """ + + num_states = [3, 4] + num_obs = [3, 3, 5] -# # for (num_states, num_obs) in zip(num_states_list, num_obs_list): + prior = utils.random_single_categorical(num_states) -# # # numpy version -# # prior = utils.random_single_categorical(num_states) -# # A = utils.random_A_matrix(num_obs, num_states) + obs = utils.obj_array(len(num_obs)) + for m, obs_dim in enumerate(num_obs): + obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) -# # obs = utils.obj_array(len(num_obs)) -# # for m, obs_dim in enumerate(num_obs): -# # obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) + A_factor_list = [[0], [1], [0, 1]] # modalities 0 and 1 only depend on factors 0 and 1, respectively + A_reduced = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_factor_list) -# # qs_numpy = fpi_numpy(A, obs, num_obs, num_states, prior=prior, num_iter=16, dF=1.0, dF_tol=-1.0) # set dF_tol to negative number so numpy version of FPI never stops early due to convergence + # jax version + prior_jax = [jnp.array(prior_f) for prior_f in prior] + A_reduced_jax = [jnp.array(a_m) for a_m in A_reduced] + obs_jax = [jnp.array(o_m) for o_m in obs] -# # # jax version -# # prior = [jnp.array(prior_f) for prior_f in prior] -# # A = [jnp.array(a_m) for a_m in A] -# # obs = [jnp.array(o_m) for o_m in obs] + qs_out = fpi_jax_factorized(A_reduced_jax, obs_jax, prior_jax, A_factor_list, num_iter=16) -# # qs_jax = fpi_jax(A, obs, prior, num_iter=16) + A_full = utils.initialize_empty_A(num_obs, num_states) + for m, A_m in enumerate(A_full): + other_factors = list(set(range(len(num_states))) - set(A_factor_list[m])) # list of the factors that modality `m` does not depend on -# # for f, _ in enumerate(qs_jax): -# # self.assertTrue(np.allclose(qs_numpy[f], qs_jax[f])) + # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` + expanded_dims = [num_obs[m]] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] + tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] + A_full[m] = np.tile(A_reduced[m].reshape(expanded_dims), tile_dims) + # jax version + A_full_jax = [jnp.array(a_m) for a_m in A_full] -# # def test_fixed_point_iteration_factorized_fullyconnected(self): -# # """ -# # Test the factorized version of `run_vanilla_fpi`, named `run_factorized_fpi` -# # with multiple hidden state factors and multiple observation modalities. -# # """ + qs_validation = fpi_jax(A_full_jax, obs_jax, prior_jax, num_iter=16) -# # num_states_list = [ -# # [2, 2, 5], -# # [2, 2, 2], -# # [4, 4] -# # ] + for qs_f_val, qs_f_out in zip(qs_validation, qs_out): + self.assertTrue(np.allclose(qs_f_val, qs_f_out)) -# # num_obs_list = [ -# # [5, 10], -# # [4, 3, 2], -# # [5, 10, 6] -# # ] + def test_marginal_message_passing(self): -# # for (num_states, num_obs) in zip(num_states_list, num_obs_list): + blanket_dict = {} # @TODO: implement factorized likelihoods for message passing -# # # initialize arrays in numpy version -# # prior = utils.random_single_categorical(num_states) -# # A = utils.random_A_matrix(num_obs, num_states) + num_states = [3] + num_obs = [3] -# # obs = utils.obj_array(len(num_obs)) -# # for m, obs_dim in enumerate(num_obs): -# # obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) - -# # # jax version -# # prior = [jnp.array(prior_f) for prior_f in prior] -# # A = [jnp.array(a_m) for a_m in A] -# # obs = [jnp.array(o_m) for o_m in obs] - -# # factor_lists = len(num_obs) * [list(range(len(num_states)))] - -# # qs_jax = fpi_jax(A, obs, prior, num_iter=16) -# # qs_jax_factorized = fpi_jax_factorized(A, obs, prior, factor_lists, num_iter=16) - -# # for f, _ in enumerate(qs_jax): -# # self.assertTrue(np.allclose(qs_jax[f], qs_jax_factorized[f])) + A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.], + [0.0, 0.0, 1.], + [0.5, 0.5, 0.]] + ), (2, 3, 3) )] -# # def test_fixed_point_iteration_factorized_sparsegraph(self): -# # """ -# # Test the factorized version of `run_vanilla_fpi`, named `run_factorized_fpi` -# # with multiple hidden state factors and multiple observation modalities, and with sparse conditional dependence relationships between hidden states -# # and observation modalities -# # """ - -# # num_states = [3, 4] -# # num_obs = [3, 3, 5] + B = [ jnp.broadcast_to(jnp.array([[0.0, 0.75, 0.0], + [0.0, 0.25, 1.0], + [1.0, 0.0, 0.0]] + ), (2, 3, 3))] -# # prior = utils.random_single_categorical(num_states) + # for the single modality, a sequence over time of observations (one hot vectors) + obs = [ + jnp.broadcast_to(jnp.array([[1., 0., 0.], + [0., 1., 0.], + [0., 0., 1.], + [1., 0., 0.]])[:, None], (4, 2, 3) ) + ] -# # obs = utils.obj_array(len(num_obs)) -# # for m, obs_dim in enumerate(num_obs): -# # obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) + prior = [jnp.ones((2, 3)) / 3.] -# # A_factor_list = [[0], [1], [0, 1]] # modalities 0 and 1 only depend on factors 0 and 1, respectively -# # A_reduced = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_factor_list) + qs_out = mmp_jax(A, B, obs, prior, blanket_dict, num_iter=16, tau=1.) -# # # jax version -# # prior_jax = [jnp.array(prior_f) for prior_f in prior] -# # A_reduced_jax = [jnp.array(a_m) for a_m in A_reduced] -# # obs_jax = [jnp.array(o_m) for o_m in obs] + print('test') -# # qs_out = fpi_jax_factorized(A_reduced_jax, obs_jax, prior_jax, A_factor_list, num_iter=16) + # from pymdp.jax.maths import log_stable + # from jax import nn -# # A_full = utils.initialize_empty_A(num_obs, num_states) -# # for m, A_m in enumerate(A_full): -# # other_factors = list(set(range(len(num_states))) - set(A_factor_list[m])) # list of the factors that modality `m` does not depend on + # x = log_stable(B[0][0] @ qs_out[0][-2, 0]) + # print( x ) + # print(nn.softmax(x)) -# # # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` -# # expanded_dims = [num_obs[m]] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] -# # tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] -# # A_full[m] = np.tile(A_reduced[m].reshape(expanded_dims), tile_dims) + # y = log_stable(A[0][0, 0]) + # print(nn.softmax(x + y)) -# # # jax version -# # A_full_jax = [jnp.array(a_m) for a_m in A_full] + # print(qs_out[0][-1,0,:]) -# # qs_validation = fpi_jax(A_full_jax, obs_jax, prior_jax, num_iter=16) + self.assertTrue(qs_out[0].shape[0] == obs[0].shape[0]) -# # for qs_f_val, qs_f_out in zip(qs_validation, qs_out): -# # self.assertTrue(np.allclose(qs_f_val, qs_f_out)) + def test_variational_message_passing(self): -# def test_marginal_message_passing(self): + blanket_dict = {} # @TODO: implement factorized likelihoods for message passing -# blanket_dict = {} # @TODO: implement factorized likelihoods for marginal message passing + num_states = [3] + num_obs = [3] -# num_states = [3] -# num_obs = [3] + A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.], + [0.0, 0.0, 1.], + [0.5, 0.5, 0.]] + ), (2, 3, 3) )] -# A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.0], -# [0.0, 0.0, 1.0], -# [0.5, 0.5, 0.0]] -# ), (2, 3, 3) )] + B = [ jnp.broadcast_to(jnp.array([[0.0, 0.75, 0.0], + [0.0, 0.25, 1.0], + [1.0, 0.0, 0.0]] + ), (2, 3, 3))] -# B = [ jnp.broadcast_to(jnp.array([[0.0, 0.5, 0.0], -# [0.0, 0.5, 1.0], -# [1.0, 0.0, 0.0]] -# ), (2, 3, 3))] - -# # for the single modality, a sequence over time of observations (one hot vectors) -# obs = [ -# jnp.broadcast_to(jnp.array([[1, 0, 0], -# [0, 1, 0], -# [0, 0, 1], -# [1, 0, 0]])[:, None], (4, 2, 3) ) -# ] - -# prior = [jnp.ones((2, 3)) / 3.] + # for the single modality, a sequence over time of observations (one hot vectors) + obs = [ + jnp.broadcast_to(jnp.array([[1., 0., 0.], + [0., 1., 0.], + [0., 0., 1.], + [1., 0., 0.]])[:, None], (4, 2, 3) ) + ] -# qs_out = mmp_jax(A, B, obs, prior, blanket_dict, num_iter=1, tau=1.) + prior = [jnp.ones((2, 3)) / 3.] -# print(qs_out[0]) - -# # for qs_f_val, qs_f_out in zip(qs_validation, qs_out): -# # self.assertTrue(np.allclose(qs_f_val, qs_f_out).all()) + qs_out = vmp_jax(A, B, obs, prior, blanket_dict, num_iter=16, tau=1.) -# def test_vmp(self): -# pass + self.assertTrue(qs_out[0].shape[0] == obs[0].shape[0]) -# if __name__ == "__main__": -# unittest.main() +if __name__ == "__main__": + unittest.main() From 992b4e67576047884e6557b02fdec25e515f8414 Mon Sep 17 00:00:00 2001 From: conorheins Date: Wed, 24 May 2023 13:12:42 +0200 Subject: [PATCH 102/232] cleaned up loose comments /debugging leftovers in unit-test for `mmp` and `vmp` in jax --- test/test_message_passing_jax.py | 49 -------------------------------- 1 file changed, 49 deletions(-) diff --git a/test/test_message_passing_jax.py b/test/test_message_passing_jax.py index a8ea50c6..fe827898 100644 --- a/test/test_message_passing_jax.py +++ b/test/test_message_passing_jax.py @@ -22,41 +22,6 @@ from typing import Any, List -# blanket_dict = {} # @TODO: implement factorized likelihoods for marginal message passing - -# num_states = [3] -# num_obs = [3] - -# A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.], -# [0.0, 0.0, 1.], -# [0.5, 0.5, 0.]] -# ), (2, 3, 3) )] - -# B = [ jnp.broadcast_to(jnp.array([[0.0, 0.75, 0.0], -# [0.0, 0.25, 1.0], -# [1.0, 0.0, 0.0]] -# ), (2, 3, 3))] - -# # for the single modality, a sequence over time of observations (one hot vectors) -# obs = [ -# jnp.broadcast_to(jnp.array([[1., 0., 0.], -# [0., 1., 0.], -# [0., 0., 1.], -# [1., 0., 0.]])[:, None], (4, 2, 3) ) -# ] - -# prior = [jnp.ones((2, 3)) / 3.] - -# for t in range(4): -# loc_obs = jtu.tree_map( lambda o: o[:t+1], obs) -# qs_out = vmp_jax(A, B, loc_obs, prior, blanket_dict, num_iter=16, tau=1.) -# print(qs_out[0][:,0,:].round(3)) - -# for t in range(4): -# loc_obs = jtu.tree_map( lambda o: o[:t+1], obs) -# qs_out = mmp_jax(A, B, loc_obs, prior, blanket_dict, num_iter=16, tau=1.) -# print(qs_out[0][:,0,:].round(3)) - class TestMessagePassing(unittest.TestCase): def test_fixed_point_iteration(self): @@ -208,20 +173,6 @@ def test_marginal_message_passing(self): qs_out = mmp_jax(A, B, obs, prior, blanket_dict, num_iter=16, tau=1.) - print('test') - - # from pymdp.jax.maths import log_stable - # from jax import nn - - # x = log_stable(B[0][0] @ qs_out[0][-2, 0]) - # print( x ) - # print(nn.softmax(x)) - - # y = log_stable(A[0][0, 0]) - # print(nn.softmax(x + y)) - - # print(qs_out[0][-1,0,:]) - self.assertTrue(qs_out[0].shape[0] == obs[0].shape[0]) def test_variational_message_passing(self): From ba0a294f629ee8ba4b6974a222e2320ac2a52d0b Mon Sep 17 00:00:00 2001 From: conorheins Date: Mon, 29 May 2023 13:34:03 +0200 Subject: [PATCH 103/232] changed assertion statement to accommodate cases like pruned policies, but did this in sparse likelihoods branch to short-term help out @tverbele (See Issue #118) --- pymdp/agent.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pymdp/agent.py b/pymdp/agent.py index 07dbb877..bba29d6e 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -193,7 +193,7 @@ def __init__( all_policies = np.vstack(self.policies) - assert all([n_c == max_action for (n_c, max_action) in zip(self.num_controls, list(np.max(all_policies, axis =0)+1))]), "Maximum number of actions is not consistent with `num_controls`" + assert all([n_c >= max_action for (n_c, max_action) in zip(self.num_controls, list(np.max(all_policies, axis =0)+1))]), "Maximum number of actions is not consistent with `num_controls`" # Construct prior preferences (uniform if not specified) From a2181a588e999c9446c9d8a6214fdcbe5c7cd9c3 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 15 Jun 2023 17:05:54 +0200 Subject: [PATCH 104/232] WIP: adding policy conditioning to run MMP/run VMP functions Co-authored-by: Dimitrije Markovic --- pymdp/jax/algos.py | 13 +- test/test_message_passing_jax.py | 321 ++++++++++++++++++------------- 2 files changed, 199 insertions(+), 135 deletions(-) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index a4922bb3..63697b91 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -117,11 +117,19 @@ def mirror_gradient_descent_step(tau, ln_A, lnB_past, lnB_future, ln_qs): return qs +# B^1.shape = (3,3,num_actions), B^2.shape = (4,4, num_actions), B^3.shape = (2,2, actions) +# B =jtu.tree_map(lambda b, actions: b[..., actions], actions)) def update_marginals(get_messages, obs, A, B, prior, num_iter=1, tau=1.): nf = len(prior) T = obs[0].shape[0] factors = list(range(nf)) + + # B = [ B^1, B^2, B^3] + # B^1.shape = (3,3), B^2.shape = (4,4), B^3.shape = (2,2) + # B^1.shape = (5,3,3), B^2.shape = (5,4,4), B^3.shape = (5,2,2) + + # B = [ [B^1]_{tij}, [B^2]_{tij} ] ln_B = jtu.tree_map(log_stable, B) # log likelihoods -> $\ln(A)$ for all time steps # for $k > t$ we have $\ln(A) = 0$ @@ -167,14 +175,15 @@ def get_vmp_messages(ln_B, B, qs, ln_prior): # @vmap(in_axes=(0, 1, 0), out_axes=1) def forward(ln_b, q, ln_prior): - msg = q[:-1] @ ln_b.T + msg = lax.batch_matmul(q[:-1], ln_b.transpose(0, 2, 1)) return jnp.concatenate([jnp.expand_dims(ln_prior, 0), msg], axis=0) + fwd = vmap(forward, in_axes=(0, 1, 0), out_axes=1) # @vmap(in_axes=(0, 1), out_axes=1) def backward(ln_b, q): # q_i B_ij - msg = q[1:] @ ln_b + msg = lax.batch_matmul(q[1:], ln_b) return jnp.pad(msg, ((0, 1), (0, 0))) bkwd = vmap(backward, in_axes=(0, 1), out_axes=1) diff --git a/test/test_message_passing_jax.py b/test/test_message_passing_jax.py index fe827898..ad5a2560 100644 --- a/test/test_message_passing_jax.py +++ b/test/test_message_passing_jax.py @@ -22,189 +22,244 @@ from typing import Any, List -class TestMessagePassing(unittest.TestCase): - def test_fixed_point_iteration(self): - num_states_list = [ - [2, 2, 5], - [2, 2, 2], - [4, 4] - ] +num_states = [3] +num_obs = [3] - num_obs_list = [ - [5, 10], - [4, 3, 2], - [5, 10, 6] - ] +A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.], + [0.0, 0.0, 1.], + [0.5, 0.5, 0.]] + ), (2, 3, 3) )] - for (num_states, num_obs) in zip(num_states_list, num_obs_list): +# create two B matrices, one for each action +B_1 = jnp.broadcast_to(jnp.array([[0.0, 0.75, 0.0], + [0.0, 0.25, 1.0], + [1.0, 0.0, 0.0]] + ), (2, 3, 3)) - # numpy version - prior = utils.random_single_categorical(num_states) - A = utils.random_A_matrix(num_obs, num_states) +B_2 = jnp.broadcast_to(jnp.array([[0.0, 0.25, 0.0], + [0.0, 0.75, 0.0], + [1.0, 0.0, 1.0]] + ), (2, 3, 3)) - obs = utils.obj_array(len(num_obs)) - for m, obs_dim in enumerate(num_obs): - obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) +B = [jnp.stack([B_1, B_2], axis=-1)] - qs_numpy = fpi_numpy(A, obs, num_obs, num_states, prior=prior, num_iter=16, dF=1.0, dF_tol=-1.0) # set dF_tol to negative number so numpy version of FPI never stops early due to convergence +# create a policy-dependent sequence of B matrices - # jax version - prior = [jnp.array(prior_f) for prior_f in prior] - A = [jnp.array(a_m) for a_m in A] - obs = [jnp.array(o_m) for o_m in obs] +policy = jnp.array([0, 1, 0]) +B_policy = jtu.tree_map(lambda b: b[..., policy].transpose(0, 3, 1, 2), B) - qs_jax = fpi_jax(A, obs, prior, num_iter=16) - for f, _ in enumerate(qs_jax): - self.assertTrue(np.allclose(qs_numpy[f], qs_jax[f])) +# for the single modality, a sequence over time of observations (one hot vectors) +obs = [ + jnp.broadcast_to(jnp.array([[1., 0., 0.], + [0., 1., 0.], + [0., 0., 1.], + [1., 0., 0.]])[:, None], (4, 2, 3) ) + ] +prior = [jnp.ones((2, 3)) / 3.] - def test_fixed_point_iteration_factorized_fullyconnected(self): - """ - Test the factorized version of `run_vanilla_fpi`, named `run_factorized_fpi` - with multiple hidden state factors and multiple observation modalities. - """ +qs_out = mmp_jax(A, B_policy, obs, prior, {}, num_iter=16, tau=1.) - num_states_list = [ - [2, 2, 5], - [2, 2, 2], - [4, 4] - ] + +# class TestMessagePassing(unittest.TestCase): + +# def test_fixed_point_iteration(self): +# num_states_list = [ +# [2, 2, 5], +# [2, 2, 2], +# [4, 4] +# ] + +# num_obs_list = [ +# [5, 10], +# [4, 3, 2], +# [5, 10, 6] +# ] + +# for (num_states, num_obs) in zip(num_states_list, num_obs_list): + +# # numpy version +# prior = utils.random_single_categorical(num_states) +# A = utils.random_A_matrix(num_obs, num_states) + +# obs = utils.obj_array(len(num_obs)) +# for m, obs_dim in enumerate(num_obs): +# obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) + +# qs_numpy = fpi_numpy(A, obs, num_obs, num_states, prior=prior, num_iter=16, dF=1.0, dF_tol=-1.0) # set dF_tol to negative number so numpy version of FPI never stops early due to convergence + +# # jax version +# prior = [jnp.array(prior_f) for prior_f in prior] +# A = [jnp.array(a_m) for a_m in A] +# obs = [jnp.array(o_m) for o_m in obs] + +# qs_jax = fpi_jax(A, obs, prior, num_iter=16) - num_obs_list = [ - [5, 10], - [4, 3, 2], - [5, 10, 6] - ] +# for f, _ in enumerate(qs_jax): +# self.assertTrue(np.allclose(qs_numpy[f], qs_jax[f])) - for (num_states, num_obs) in zip(num_states_list, num_obs_list): - # initialize arrays in numpy version - prior = utils.random_single_categorical(num_states) - A = utils.random_A_matrix(num_obs, num_states) +# def test_fixed_point_iteration_factorized_fullyconnected(self): +# """ +# Test the factorized version of `run_vanilla_fpi`, named `run_factorized_fpi` +# with multiple hidden state factors and multiple observation modalities. +# """ - obs = utils.obj_array(len(num_obs)) - for m, obs_dim in enumerate(num_obs): - obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) +# num_states_list = [ +# [2, 2, 5], +# [2, 2, 2], +# [4, 4] +# ] - # jax version - prior = [jnp.array(prior_f) for prior_f in prior] - A = [jnp.array(a_m) for a_m in A] - obs = [jnp.array(o_m) for o_m in obs] +# num_obs_list = [ +# [5, 10], +# [4, 3, 2], +# [5, 10, 6] +# ] - factor_lists = len(num_obs) * [list(range(len(num_states)))] +# for (num_states, num_obs) in zip(num_states_list, num_obs_list): - qs_jax = fpi_jax(A, obs, prior, num_iter=16) - qs_jax_factorized = fpi_jax_factorized(A, obs, prior, factor_lists, num_iter=16) +# # initialize arrays in numpy version +# prior = utils.random_single_categorical(num_states) +# A = utils.random_A_matrix(num_obs, num_states) - for f, _ in enumerate(qs_jax): - self.assertTrue(np.allclose(qs_jax[f], qs_jax_factorized[f])) +# obs = utils.obj_array(len(num_obs)) +# for m, obs_dim in enumerate(num_obs): +# obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) - def test_fixed_point_iteration_factorized_sparsegraph(self): - """ - Test the factorized version of `run_vanilla_fpi`, named `run_factorized_fpi` - with multiple hidden state factors and multiple observation modalities, and with sparse conditional dependence relationships between hidden states - and observation modalities - """ +# # jax version +# prior = [jnp.array(prior_f) for prior_f in prior] +# A = [jnp.array(a_m) for a_m in A] +# obs = [jnp.array(o_m) for o_m in obs] + +# factor_lists = len(num_obs) * [list(range(len(num_states)))] + +# qs_jax = fpi_jax(A, obs, prior, num_iter=16) +# qs_jax_factorized = fpi_jax_factorized(A, obs, prior, factor_lists, num_iter=16) + +# for f, _ in enumerate(qs_jax): +# self.assertTrue(np.allclose(qs_jax[f], qs_jax_factorized[f])) + +# def test_fixed_point_iteration_factorized_sparsegraph(self): +# """ +# Test the factorized version of `run_vanilla_fpi`, named `run_factorized_fpi` +# with multiple hidden state factors and multiple observation modalities, and with sparse conditional dependence relationships between hidden states +# and observation modalities +# """ - num_states = [3, 4] - num_obs = [3, 3, 5] +# num_states = [3, 4] +# num_obs = [3, 3, 5] - prior = utils.random_single_categorical(num_states) +# prior = utils.random_single_categorical(num_states) - obs = utils.obj_array(len(num_obs)) - for m, obs_dim in enumerate(num_obs): - obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) +# obs = utils.obj_array(len(num_obs)) +# for m, obs_dim in enumerate(num_obs): +# obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) - A_factor_list = [[0], [1], [0, 1]] # modalities 0 and 1 only depend on factors 0 and 1, respectively - A_reduced = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_factor_list) +# A_factor_list = [[0], [1], [0, 1]] # modalities 0 and 1 only depend on factors 0 and 1, respectively +# A_reduced = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_factor_list) - # jax version - prior_jax = [jnp.array(prior_f) for prior_f in prior] - A_reduced_jax = [jnp.array(a_m) for a_m in A_reduced] - obs_jax = [jnp.array(o_m) for o_m in obs] +# # jax version +# prior_jax = [jnp.array(prior_f) for prior_f in prior] +# A_reduced_jax = [jnp.array(a_m) for a_m in A_reduced] +# obs_jax = [jnp.array(o_m) for o_m in obs] - qs_out = fpi_jax_factorized(A_reduced_jax, obs_jax, prior_jax, A_factor_list, num_iter=16) +# qs_out = fpi_jax_factorized(A_reduced_jax, obs_jax, prior_jax, A_factor_list, num_iter=16) - A_full = utils.initialize_empty_A(num_obs, num_states) - for m, A_m in enumerate(A_full): - other_factors = list(set(range(len(num_states))) - set(A_factor_list[m])) # list of the factors that modality `m` does not depend on +# A_full = utils.initialize_empty_A(num_obs, num_states) +# for m, A_m in enumerate(A_full): +# other_factors = list(set(range(len(num_states))) - set(A_factor_list[m])) # list of the factors that modality `m` does not depend on - # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` - expanded_dims = [num_obs[m]] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] - tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] - A_full[m] = np.tile(A_reduced[m].reshape(expanded_dims), tile_dims) +# # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` +# expanded_dims = [num_obs[m]] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] +# tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] +# A_full[m] = np.tile(A_reduced[m].reshape(expanded_dims), tile_dims) - # jax version - A_full_jax = [jnp.array(a_m) for a_m in A_full] +# # jax version +# A_full_jax = [jnp.array(a_m) for a_m in A_full] - qs_validation = fpi_jax(A_full_jax, obs_jax, prior_jax, num_iter=16) +# qs_validation = fpi_jax(A_full_jax, obs_jax, prior_jax, num_iter=16) - for qs_f_val, qs_f_out in zip(qs_validation, qs_out): - self.assertTrue(np.allclose(qs_f_val, qs_f_out)) +# for qs_f_val, qs_f_out in zip(qs_validation, qs_out): +# self.assertTrue(np.allclose(qs_f_val, qs_f_out)) - def test_marginal_message_passing(self): +# def test_marginal_message_passing(self): - blanket_dict = {} # @TODO: implement factorized likelihoods for message passing +# blanket_dict = {} # @TODO: implement factorized likelihoods for message passing - num_states = [3] - num_obs = [3] +# num_states = [3] +# num_obs = [3] - A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.], - [0.0, 0.0, 1.], - [0.5, 0.5, 0.]] - ), (2, 3, 3) )] +# A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.], +# [0.0, 0.0, 1.], +# [0.5, 0.5, 0.]] +# ), (2, 3, 3) )] - B = [ jnp.broadcast_to(jnp.array([[0.0, 0.75, 0.0], - [0.0, 0.25, 1.0], - [1.0, 0.0, 0.0]] - ), (2, 3, 3))] +# # create two B matrices, one for each action +# B_1 = jnp.broadcast_to(jnp.array([[0.0, 0.75, 0.0], +# [0.0, 0.25, 1.0], +# [1.0, 0.0, 0.0]] +# ), (2, 3, 3)) + +# B_2 = jnp.broadcast_to(jnp.array([[0.0, 0.25, 0.0], +# [0.0, 0.75, 0.0], +# [1.0, 0.0, 1.0]] +# ), (2, 3, 3)) + +# B = [jnp.stack([B_1, B_2], axis=-1)] + +# # create a policy-dependent sequence of B matrices - # for the single modality, a sequence over time of observations (one hot vectors) - obs = [ - jnp.broadcast_to(jnp.array([[1., 0., 0.], - [0., 1., 0.], - [0., 0., 1.], - [1., 0., 0.]])[:, None], (4, 2, 3) ) - ] +# policy = jnp.array([0, 1, 0]) +# B_policy = jtu.tree_map(lambda b: b[..., policy].transpose(0, 3, 1, 2), B) + + +# # for the single modality, a sequence over time of observations (one hot vectors) +# obs = [ +# jnp.broadcast_to(jnp.array([[1., 0., 0.], +# [0., 1., 0.], +# [0., 0., 1.], +# [1., 0., 0.]])[:, None], (4, 2, 3) ) +# ] - prior = [jnp.ones((2, 3)) / 3.] +# prior = [jnp.ones((2, 3)) / 3.] - qs_out = mmp_jax(A, B, obs, prior, blanket_dict, num_iter=16, tau=1.) +# qs_out = mmp_jax(A, B_policy, obs, prior, blanket_dict, num_iter=16, tau=1.) - self.assertTrue(qs_out[0].shape[0] == obs[0].shape[0]) +# self.assertTrue(qs_out[0].shape[0] == obs[0].shape[0]) - def test_variational_message_passing(self): + # def test_variational_message_passing(self): - blanket_dict = {} # @TODO: implement factorized likelihoods for message passing + # blanket_dict = {} # @TODO: implement factorized likelihoods for message passing - num_states = [3] - num_obs = [3] + # num_states = [3] + # num_obs = [3] - A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.], - [0.0, 0.0, 1.], - [0.5, 0.5, 0.]] - ), (2, 3, 3) )] + # A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.], + # [0.0, 0.0, 1.], + # [0.5, 0.5, 0.]] + # ), (2, 3, 3) )] - B = [ jnp.broadcast_to(jnp.array([[0.0, 0.75, 0.0], - [0.0, 0.25, 1.0], - [1.0, 0.0, 0.0]] - ), (2, 3, 3))] + # B = [ jnp.broadcast_to(jnp.array([[0.0, 0.75, 0.0], + # [0.0, 0.25, 1.0], + # [1.0, 0.0, 0.0]] + # ), (2, 3, 3))] - # for the single modality, a sequence over time of observations (one hot vectors) - obs = [ - jnp.broadcast_to(jnp.array([[1., 0., 0.], - [0., 1., 0.], - [0., 0., 1.], - [1., 0., 0.]])[:, None], (4, 2, 3) ) - ] + # # for the single modality, a sequence over time of observations (one hot vectors) + # obs = [ + # jnp.broadcast_to(jnp.array([[1., 0., 0.], + # [0., 1., 0.], + # [0., 0., 1.], + # [1., 0., 0.]])[:, None], (4, 2, 3) ) + # ] - prior = [jnp.ones((2, 3)) / 3.] + # prior = [jnp.ones((2, 3)) / 3.] - qs_out = vmp_jax(A, B, obs, prior, blanket_dict, num_iter=16, tau=1.) + # qs_out = vmp_jax(A, B, obs, prior, blanket_dict, num_iter=16, tau=1.) - self.assertTrue(qs_out[0].shape[0] == obs[0].shape[0]) + # self.assertTrue(qs_out[0].shape[0] == obs[0].shape[0]) if __name__ == "__main__": From 686927301321172edf015932b4b2e7205f8f7075 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 15 Jun 2023 17:23:42 +0200 Subject: [PATCH 105/232] replace standard @ matrix multiplies with `lax.batch_matmul` to get messages for different action-conditioned B matrices --- pymdp/jax/algos.py | 18 ++++++------------ 1 file changed, 6 insertions(+), 12 deletions(-) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index 63697b91..4ec25b8f 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -117,19 +117,11 @@ def mirror_gradient_descent_step(tau, ln_A, lnB_past, lnB_future, ln_qs): return qs -# B^1.shape = (3,3,num_actions), B^2.shape = (4,4, num_actions), B^3.shape = (2,2, actions) -# B =jtu.tree_map(lambda b, actions: b[..., actions], actions)) def update_marginals(get_messages, obs, A, B, prior, num_iter=1, tau=1.): nf = len(prior) T = obs[0].shape[0] factors = list(range(nf)) - - # B = [ B^1, B^2, B^3] - # B^1.shape = (3,3), B^2.shape = (4,4), B^3.shape = (2,2) - # B^1.shape = (5,3,3), B^2.shape = (5,4,4), B^3.shape = (5,2,2) - - # B = [ [B^1]_{tij}, [B^2]_{tij} ] ln_B = jtu.tree_map(log_stable, B) # log likelihoods -> $\ln(A)$ for all time steps # for $k > t$ we have $\ln(A) = 0$ @@ -175,7 +167,7 @@ def get_vmp_messages(ln_B, B, qs, ln_prior): # @vmap(in_axes=(0, 1, 0), out_axes=1) def forward(ln_b, q, ln_prior): - msg = lax.batch_matmul(q[:-1], ln_b.transpose(0, 2, 1)) + msg = lax.batch_matmul(q[:-1, None], ln_b.transpose(0, 2, 1)).squeeze() return jnp.concatenate([jnp.expand_dims(ln_prior, 0), msg], axis=0) fwd = vmap(forward, in_axes=(0, 1, 0), out_axes=1) @@ -183,7 +175,7 @@ def forward(ln_b, q, ln_prior): # @vmap(in_axes=(0, 1), out_axes=1) def backward(ln_b, q): # q_i B_ij - msg = lax.batch_matmul(q[1:], ln_b) + msg = lax.batch_matmul(q[1:, None], ln_b).squeeze() return jnp.pad(msg, ((0, 1), (0, 0))) bkwd = vmap(backward, in_axes=(0, 1), out_axes=1) @@ -200,7 +192,8 @@ def get_mmp_messages(ln_B, B, qs, ln_prior): def forward(b, q, ln_prior): if len(q) > 1: - msg = log_stable(q[:-1] @ b.T) + msg = lax.batch_matmul(q[:-1, None], b.transpose(0, 2, 1)).squeeze() + msg = log_stable(msg) n = len(msg) if n > 1: # this is the case where there are at least 3 observations. If you have two observations, then you weight the single past message from t = 0 by 1.0 msg = msg * jnp.pad( 0.5 * jnp.ones(n-1), (0, 1), constant_values=1.)[:, None] @@ -211,7 +204,8 @@ def forward(b, q, ln_prior): fwd = vmap(forward, in_axes=(0, 1, 0), out_axes=1) def backward(b, q): - msg = log_stable(q[1:] @ b) * 0.5 + msg = lax.batch_matmul(q[:-1, None], b.transpose(0, 2, 1)).squeeze() + msg = log_stable(msg) * 0.5 return jnp.pad(msg, ((0, 1), (0, 0))) bkwd = vmap(backward, in_axes=(0, 1), out_axes=1) From cc36b4ab135a1e636f7cdbbb612e1df9a4c10daf Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 15 Jun 2023 17:24:42 +0200 Subject: [PATCH 106/232] add action-conditioned B matrices for unit tests --- test/test_message_passing_jax.py | 339 ++++++++++++++----------------- 1 file changed, 155 insertions(+), 184 deletions(-) diff --git a/test/test_message_passing_jax.py b/test/test_message_passing_jax.py index ad5a2560..78a598ba 100644 --- a/test/test_message_passing_jax.py +++ b/test/test_message_passing_jax.py @@ -21,245 +21,216 @@ from pymdp import utils, maths from typing import Any, List - - -num_states = [3] -num_obs = [3] - -A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.], - [0.0, 0.0, 1.], - [0.5, 0.5, 0.]] - ), (2, 3, 3) )] - -# create two B matrices, one for each action -B_1 = jnp.broadcast_to(jnp.array([[0.0, 0.75, 0.0], - [0.0, 0.25, 1.0], - [1.0, 0.0, 0.0]] - ), (2, 3, 3)) - -B_2 = jnp.broadcast_to(jnp.array([[0.0, 0.25, 0.0], - [0.0, 0.75, 0.0], - [1.0, 0.0, 1.0]] - ), (2, 3, 3)) - -B = [jnp.stack([B_1, B_2], axis=-1)] - -# create a policy-dependent sequence of B matrices - -policy = jnp.array([0, 1, 0]) -B_policy = jtu.tree_map(lambda b: b[..., policy].transpose(0, 3, 1, 2), B) - - -# for the single modality, a sequence over time of observations (one hot vectors) -obs = [ - jnp.broadcast_to(jnp.array([[1., 0., 0.], - [0., 1., 0.], - [0., 0., 1.], - [1., 0., 0.]])[:, None], (4, 2, 3) ) - ] - -prior = [jnp.ones((2, 3)) / 3.] - -qs_out = mmp_jax(A, B_policy, obs, prior, {}, num_iter=16, tau=1.) - -# class TestMessagePassing(unittest.TestCase): +class TestMessagePassing(unittest.TestCase): -# def test_fixed_point_iteration(self): -# num_states_list = [ -# [2, 2, 5], -# [2, 2, 2], -# [4, 4] -# ] + def test_fixed_point_iteration(self): + num_states_list = [ + [2, 2, 5], + [2, 2, 2], + [4, 4] + ] -# num_obs_list = [ -# [5, 10], -# [4, 3, 2], -# [5, 10, 6] -# ] + num_obs_list = [ + [5, 10], + [4, 3, 2], + [5, 10, 6] + ] -# for (num_states, num_obs) in zip(num_states_list, num_obs_list): + for (num_states, num_obs) in zip(num_states_list, num_obs_list): -# # numpy version -# prior = utils.random_single_categorical(num_states) -# A = utils.random_A_matrix(num_obs, num_states) + # numpy version + prior = utils.random_single_categorical(num_states) + A = utils.random_A_matrix(num_obs, num_states) -# obs = utils.obj_array(len(num_obs)) -# for m, obs_dim in enumerate(num_obs): -# obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) + obs = utils.obj_array(len(num_obs)) + for m, obs_dim in enumerate(num_obs): + obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) -# qs_numpy = fpi_numpy(A, obs, num_obs, num_states, prior=prior, num_iter=16, dF=1.0, dF_tol=-1.0) # set dF_tol to negative number so numpy version of FPI never stops early due to convergence + qs_numpy = fpi_numpy(A, obs, num_obs, num_states, prior=prior, num_iter=16, dF=1.0, dF_tol=-1.0) # set dF_tol to negative number so numpy version of FPI never stops early due to convergence -# # jax version -# prior = [jnp.array(prior_f) for prior_f in prior] -# A = [jnp.array(a_m) for a_m in A] -# obs = [jnp.array(o_m) for o_m in obs] + # jax version + prior = [jnp.array(prior_f) for prior_f in prior] + A = [jnp.array(a_m) for a_m in A] + obs = [jnp.array(o_m) for o_m in obs] -# qs_jax = fpi_jax(A, obs, prior, num_iter=16) + qs_jax = fpi_jax(A, obs, prior, num_iter=16) -# for f, _ in enumerate(qs_jax): -# self.assertTrue(np.allclose(qs_numpy[f], qs_jax[f])) + for f, _ in enumerate(qs_jax): + self.assertTrue(np.allclose(qs_numpy[f], qs_jax[f])) -# def test_fixed_point_iteration_factorized_fullyconnected(self): -# """ -# Test the factorized version of `run_vanilla_fpi`, named `run_factorized_fpi` -# with multiple hidden state factors and multiple observation modalities. -# """ + def test_fixed_point_iteration_factorized_fullyconnected(self): + """ + Test the factorized version of `run_vanilla_fpi`, named `run_factorized_fpi` + with multiple hidden state factors and multiple observation modalities. + """ -# num_states_list = [ -# [2, 2, 5], -# [2, 2, 2], -# [4, 4] -# ] + num_states_list = [ + [2, 2, 5], + [2, 2, 2], + [4, 4] + ] -# num_obs_list = [ -# [5, 10], -# [4, 3, 2], -# [5, 10, 6] -# ] + num_obs_list = [ + [5, 10], + [4, 3, 2], + [5, 10, 6] + ] -# for (num_states, num_obs) in zip(num_states_list, num_obs_list): + for (num_states, num_obs) in zip(num_states_list, num_obs_list): -# # initialize arrays in numpy version -# prior = utils.random_single_categorical(num_states) -# A = utils.random_A_matrix(num_obs, num_states) + # initialize arrays in numpy version + prior = utils.random_single_categorical(num_states) + A = utils.random_A_matrix(num_obs, num_states) -# obs = utils.obj_array(len(num_obs)) -# for m, obs_dim in enumerate(num_obs): -# obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) + obs = utils.obj_array(len(num_obs)) + for m, obs_dim in enumerate(num_obs): + obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) -# # jax version -# prior = [jnp.array(prior_f) for prior_f in prior] -# A = [jnp.array(a_m) for a_m in A] -# obs = [jnp.array(o_m) for o_m in obs] + # jax version + prior = [jnp.array(prior_f) for prior_f in prior] + A = [jnp.array(a_m) for a_m in A] + obs = [jnp.array(o_m) for o_m in obs] -# factor_lists = len(num_obs) * [list(range(len(num_states)))] + factor_lists = len(num_obs) * [list(range(len(num_states)))] -# qs_jax = fpi_jax(A, obs, prior, num_iter=16) -# qs_jax_factorized = fpi_jax_factorized(A, obs, prior, factor_lists, num_iter=16) + qs_jax = fpi_jax(A, obs, prior, num_iter=16) + qs_jax_factorized = fpi_jax_factorized(A, obs, prior, factor_lists, num_iter=16) -# for f, _ in enumerate(qs_jax): -# self.assertTrue(np.allclose(qs_jax[f], qs_jax_factorized[f])) + for f, _ in enumerate(qs_jax): + self.assertTrue(np.allclose(qs_jax[f], qs_jax_factorized[f])) -# def test_fixed_point_iteration_factorized_sparsegraph(self): -# """ -# Test the factorized version of `run_vanilla_fpi`, named `run_factorized_fpi` -# with multiple hidden state factors and multiple observation modalities, and with sparse conditional dependence relationships between hidden states -# and observation modalities -# """ + def test_fixed_point_iteration_factorized_sparsegraph(self): + """ + Test the factorized version of `run_vanilla_fpi`, named `run_factorized_fpi` + with multiple hidden state factors and multiple observation modalities, and with sparse conditional dependence relationships between hidden states + and observation modalities + """ -# num_states = [3, 4] -# num_obs = [3, 3, 5] + num_states = [3, 4] + num_obs = [3, 3, 5] -# prior = utils.random_single_categorical(num_states) + prior = utils.random_single_categorical(num_states) -# obs = utils.obj_array(len(num_obs)) -# for m, obs_dim in enumerate(num_obs): -# obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) + obs = utils.obj_array(len(num_obs)) + for m, obs_dim in enumerate(num_obs): + obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) -# A_factor_list = [[0], [1], [0, 1]] # modalities 0 and 1 only depend on factors 0 and 1, respectively -# A_reduced = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_factor_list) + A_factor_list = [[0], [1], [0, 1]] # modalities 0 and 1 only depend on factors 0 and 1, respectively + A_reduced = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_factor_list) -# # jax version -# prior_jax = [jnp.array(prior_f) for prior_f in prior] -# A_reduced_jax = [jnp.array(a_m) for a_m in A_reduced] -# obs_jax = [jnp.array(o_m) for o_m in obs] + # jax version + prior_jax = [jnp.array(prior_f) for prior_f in prior] + A_reduced_jax = [jnp.array(a_m) for a_m in A_reduced] + obs_jax = [jnp.array(o_m) for o_m in obs] -# qs_out = fpi_jax_factorized(A_reduced_jax, obs_jax, prior_jax, A_factor_list, num_iter=16) + qs_out = fpi_jax_factorized(A_reduced_jax, obs_jax, prior_jax, A_factor_list, num_iter=16) -# A_full = utils.initialize_empty_A(num_obs, num_states) -# for m, A_m in enumerate(A_full): -# other_factors = list(set(range(len(num_states))) - set(A_factor_list[m])) # list of the factors that modality `m` does not depend on + A_full = utils.initialize_empty_A(num_obs, num_states) + for m, A_m in enumerate(A_full): + other_factors = list(set(range(len(num_states))) - set(A_factor_list[m])) # list of the factors that modality `m` does not depend on -# # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` -# expanded_dims = [num_obs[m]] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] -# tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] -# A_full[m] = np.tile(A_reduced[m].reshape(expanded_dims), tile_dims) + # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` + expanded_dims = [num_obs[m]] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] + tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] + A_full[m] = np.tile(A_reduced[m].reshape(expanded_dims), tile_dims) -# # jax version -# A_full_jax = [jnp.array(a_m) for a_m in A_full] + # jax version + A_full_jax = [jnp.array(a_m) for a_m in A_full] -# qs_validation = fpi_jax(A_full_jax, obs_jax, prior_jax, num_iter=16) + qs_validation = fpi_jax(A_full_jax, obs_jax, prior_jax, num_iter=16) -# for qs_f_val, qs_f_out in zip(qs_validation, qs_out): -# self.assertTrue(np.allclose(qs_f_val, qs_f_out)) + for qs_f_val, qs_f_out in zip(qs_validation, qs_out): + self.assertTrue(np.allclose(qs_f_val, qs_f_out)) -# def test_marginal_message_passing(self): + def test_marginal_message_passing(self): -# blanket_dict = {} # @TODO: implement factorized likelihoods for message passing + blanket_dict = {} # @TODO: implement factorized likelihoods for message passing -# num_states = [3] -# num_obs = [3] + num_states = [3] + num_obs = [3] -# A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.], -# [0.0, 0.0, 1.], -# [0.5, 0.5, 0.]] -# ), (2, 3, 3) )] + A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.], + [0.0, 0.0, 1.], + [0.5, 0.5, 0.]] + ), (2, 3, 3) )] -# # create two B matrices, one for each action -# B_1 = jnp.broadcast_to(jnp.array([[0.0, 0.75, 0.0], -# [0.0, 0.25, 1.0], -# [1.0, 0.0, 0.0]] -# ), (2, 3, 3)) + # create two B matrices, one for each action + B_1 = jnp.broadcast_to(jnp.array([[0.0, 0.75, 0.0], + [0.0, 0.25, 1.0], + [1.0, 0.0, 0.0]] + ), (2, 3, 3)) -# B_2 = jnp.broadcast_to(jnp.array([[0.0, 0.25, 0.0], -# [0.0, 0.75, 0.0], -# [1.0, 0.0, 1.0]] -# ), (2, 3, 3)) + B_2 = jnp.broadcast_to(jnp.array([[0.0, 0.25, 0.0], + [0.0, 0.75, 0.0], + [1.0, 0.0, 1.0]] + ), (2, 3, 3)) -# B = [jnp.stack([B_1, B_2], axis=-1)] - -# # create a policy-dependent sequence of B matrices + B = [jnp.stack([B_1, B_2], axis=-1)] # actions are in the last dimension -# policy = jnp.array([0, 1, 0]) -# B_policy = jtu.tree_map(lambda b: b[..., policy].transpose(0, 3, 1, 2), B) + # create a policy-dependent sequence of B matrices, but now we store the sequence dimension (action indices) in the first dimension (0th dimension is still batch dimension) + policy = jnp.array([0, 1, 0]) + B_policy = jtu.tree_map(lambda b: b[..., policy].transpose(0, 3, 1, 2), B) -# # for the single modality, a sequence over time of observations (one hot vectors) -# obs = [ -# jnp.broadcast_to(jnp.array([[1., 0., 0.], -# [0., 1., 0.], -# [0., 0., 1.], -# [1., 0., 0.]])[:, None], (4, 2, 3) ) -# ] + # for the single modality, a sequence over time of observations (one hot vectors) + obs = [ + jnp.broadcast_to(jnp.array([[1., 0., 0.], + [0., 1., 0.], + [0., 0., 1.], + [1., 0., 0.]])[:, None], (4, 2, 3) ) + ] -# prior = [jnp.ones((2, 3)) / 3.] + prior = [jnp.ones((2, 3)) / 3.] -# qs_out = mmp_jax(A, B_policy, obs, prior, blanket_dict, num_iter=16, tau=1.) + qs_out = mmp_jax(A, B_policy, obs, prior, blanket_dict, num_iter=16, tau=1.) -# self.assertTrue(qs_out[0].shape[0] == obs[0].shape[0]) + self.assertTrue(qs_out[0].shape[0] == obs[0].shape[0]) - # def test_variational_message_passing(self): + def test_variational_message_passing(self): - # blanket_dict = {} # @TODO: implement factorized likelihoods for message passing + blanket_dict = {} # @TODO: implement factorized likelihoods for message passing - # num_states = [3] - # num_obs = [3] + num_states = [3] + num_obs = [3] + + A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.], + [0.0, 0.0, 1.], + [0.5, 0.5, 0.]] + ), (2, 3, 3) )] + + # create two B matrices, one for each action + B_1 = jnp.broadcast_to(jnp.array([[0.0, 0.75, 0.0], + [0.0, 0.25, 1.0], + [1.0, 0.0, 0.0]] + ), (2, 3, 3)) + + B_2 = jnp.broadcast_to(jnp.array([[0.0, 0.25, 0.0], + [0.0, 0.75, 0.0], + [1.0, 0.0, 1.0]] + ), (2, 3, 3)) + + B = [jnp.stack([B_1, B_2], axis=-1)] - # A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.], - # [0.0, 0.0, 1.], - # [0.5, 0.5, 0.]] - # ), (2, 3, 3) )] + # create a policy-dependent sequence of B matrices - # B = [ jnp.broadcast_to(jnp.array([[0.0, 0.75, 0.0], - # [0.0, 0.25, 1.0], - # [1.0, 0.0, 0.0]] - # ), (2, 3, 3))] + policy = jnp.array([0, 1, 0]) + B_policy = jtu.tree_map(lambda b: b[..., policy].transpose(0, 3, 1, 2), B) - # # for the single modality, a sequence over time of observations (one hot vectors) - # obs = [ - # jnp.broadcast_to(jnp.array([[1., 0., 0.], - # [0., 1., 0.], - # [0., 0., 1.], - # [1., 0., 0.]])[:, None], (4, 2, 3) ) - # ] + # for the single modality, a sequence over time of observations (one hot vectors) + obs = [ + jnp.broadcast_to(jnp.array([[1., 0., 0.], + [0., 1., 0.], + [0., 0., 1.], + [1., 0., 0.]])[:, None], (4, 2, 3) ) + ] - # prior = [jnp.ones((2, 3)) / 3.] + prior = [jnp.ones((2, 3)) / 3.] - # qs_out = vmp_jax(A, B, obs, prior, blanket_dict, num_iter=16, tau=1.) + qs_out = vmp_jax(A, B_policy, obs, prior, blanket_dict, num_iter=16, tau=1.) - # self.assertTrue(qs_out[0].shape[0] == obs[0].shape[0]) + self.assertTrue(qs_out[0].shape[0] == obs[0].shape[0]) if __name__ == "__main__": From 67ccca484cacaa48472f1ddab190fcd5e5be92d8 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 15 Jun 2023 18:09:40 +0200 Subject: [PATCH 107/232] working on vectorizing MMP/VMP across policies + multiple modalities / hidden state factors --- pymdp/jax/algos.py | 2 +- test/test_message_passing_jax.py | 85 +++++++++++++++++++++++++++++++- 2 files changed, 84 insertions(+), 3 deletions(-) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index 4ec25b8f..3c3199ef 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -133,7 +133,7 @@ def get_log_likelihood(obs_t, A): # mapping over time dimension of obs array log_likelihoods = vmap(get_log_likelihood, (0, None))(obs, A) # this gives a sequence of log-likelihoods (one for each `t`) - + # log marginals -> $\ln(q(s_t))$ for all time steps and factors ln_qs = jtu.tree_map( lambda p: jnp.broadcast_to(jnp.zeros_like(p), (T,) + p.shape), prior) diff --git a/test/test_message_passing_jax.py b/test/test_message_passing_jax.py index 78a598ba..40f20645 100644 --- a/test/test_message_passing_jax.py +++ b/test/test_message_passing_jax.py @@ -11,6 +11,7 @@ import numpy as np import jax.numpy as jnp import jax.tree_util as jtu +from jax import vmap from pymdp.jax.algos import run_vanilla_fpi as fpi_jax from pymdp.jax.algos import run_factorized_fpi as fpi_jax_factorized @@ -231,12 +232,92 @@ def test_variational_message_passing(self): qs_out = vmp_jax(A, B_policy, obs, prior, blanket_dict, num_iter=16, tau=1.) self.assertTrue(qs_out[0].shape[0] == obs[0].shape[0]) + + def test_vmap_message_passing_across_policies(self): + + blanket_dict = {} # @TODO: implement factorized likelihoods for message passing + + num_states = [3] + num_obs = [3] + + A_tensor = jnp.stack([jnp.array([[0.5, 0.5, 0.], + [0.0, 0.0, 1.], + [0.5, 0.5, 0.]] + ), jnp.array([[1./3, 1./3, 1./3], + [1./3, 1./3, 1./3], + [1./3, 1./3, 1./3]] + )], axis=-1) + + A = [ jnp.broadcast_to(A_tensor, (2, 3, 3, 2)) ] + + # create two B matrices, one for each action + B_1 = jnp.broadcast_to(jnp.array([[0.0, 0.75, 0.0], + [0.0, 0.25, 1.0], + [1.0, 0.0, 0.0]] + ), (2, 3, 3)) + + B_2 = jnp.broadcast_to(jnp.array([[0.0, 0.25, 0.0], + [0.0, 0.75, 0.0], + [1.0, 0.0, 1.0]] + ), (2, 3, 3)) + B_uncontrollable = jnp.expand_dims( + jnp.broadcast_to( + jnp.array([[1.0, 0.0], [0.0, 1.0]]), (2, 2, 2) + ), + -1 + ) -if __name__ == "__main__": - unittest.main() + B = [jnp.stack([B_1, B_2], axis=-1), B_uncontrollable] + # create a policy-dependent sequence of B matrices + + policy_1 = jnp.array([ [0, 0], + [1, 0], + [1, 0] ] + ) + policy_2 = jnp.array([ [1, 0], + [1, 0], + [1, 0] ] + ) + + policy_3 = jnp.array([ [1, 0], + [0, 0], + [1, 0] ] + ) + + policy_4 = jnp.array([ [0, 0], + [0, 0], + [1, 0] ] + ) + + all_policies = [policy_1, policy_2, policy_3, policy_4] + all_policies = list(jnp.stack([policy_1, policy_2, policy_3, policy_4]).transpose(2, 0, 1)) # `n_factors` lists, each with matrix of shape `(n_policies, n_time_steps)` + + # for the single modality, a sequence over time of observations (one hot vectors) + obs = [jnp.broadcast_to(jnp.array([[1., 0., 0.], + [0., 1., 0.], + [0., 0., 1.], + [1., 0., 0.]])[:, None], (4, 2, 3) )] + + prior = [jnp.ones((2, 3)) / 3., jnp.ones((2, 2)) / 2.] + + def test(action_sequence): + print(len(B), len(action_sequence)) + B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) + print(B_policy[0].shape, B_policy[1].shape) + + return vmp_jax(A, B_policy, obs, prior, blanket_dict, num_iter=16, tau=1.) + + # qs_out = vmp_jax(A, B_policy, obs, prior, blanket_dict, num_iter=16, tau=1.) + qs_out = vmap(test)(all_policies) + + # self.assertTrue(qs_out[0].shape[0] == obs[0].shape[0]) + self.assertTrue(False==True) + +if __name__ == "__main__": + unittest.main() From 4b775a0783909391d6dac71f81336079b2c26dc3 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Thu, 15 Jun 2023 18:43:11 +0200 Subject: [PATCH 108/232] fixed marginal message passing --- pymdp/jax/algos.py | 6 ++++-- test/test_message_passing_jax.py | 15 +++++---------- 2 files changed, 9 insertions(+), 12 deletions(-) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index 3c3199ef..4f248005 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -18,11 +18,13 @@ def marginal_log_likelihood(qs, log_likelihood, i): parallel_ndim = len(x.shape[:-1]) + tpl = (-2,) for (f, q) in enumerate(qs[1:]): if (f + 1) != i: - x = jnp.expand_dims(x, -1) * q + x = jnp.expand_dims(x, -1) * jnp.expand_dims(q, tpl) else: - x = jnp.expand_dims(x, -1) * jnp.ones_like(q) + x = jnp.expand_dims(x, -1) * jnp.expand_dims(jnp.ones_like(q), tpl) + tpl = tpl + (tpl[f] - 1,) joint = log_likelihood * x dims = (f + parallel_ndim for f in range(len(qs)) if f != i) diff --git a/test/test_message_passing_jax.py b/test/test_message_passing_jax.py index 40f20645..3014ce3c 100644 --- a/test/test_message_passing_jax.py +++ b/test/test_message_passing_jax.py @@ -287,13 +287,8 @@ def test_vmap_message_passing_across_policies(self): [1, 0] ] ) - policy_4 = jnp.array([ [0, 0], - [0, 0], - [1, 0] ] - ) - - all_policies = [policy_1, policy_2, policy_3, policy_4] - all_policies = list(jnp.stack([policy_1, policy_2, policy_3, policy_4]).transpose(2, 0, 1)) # `n_factors` lists, each with matrix of shape `(n_policies, n_time_steps)` + all_policies = [policy_1, policy_2, policy_3] + all_policies = list(jnp.stack(all_policies).transpose(2, 0, 1)) # `n_factors` lists, each with matrix of shape `(n_policies, n_time_steps)` # for the single modality, a sequence over time of observations (one hot vectors) obs = [jnp.broadcast_to(jnp.array([[1., 0., 0.], @@ -310,11 +305,11 @@ def test(action_sequence): return vmp_jax(A, B_policy, obs, prior, blanket_dict, num_iter=16, tau=1.) - # qs_out = vmp_jax(A, B_policy, obs, prior, blanket_dict, num_iter=16, tau=1.) qs_out = vmap(test)(all_policies) + print(qs_out[0].shape, qs_out[1].shape) + + self.assertTrue(qs_out[0].shape[1] == obs[0].shape[0]) - # self.assertTrue(qs_out[0].shape[0] == obs[0].shape[0]) - self.assertTrue(False==True) if __name__ == "__main__": unittest.main() From f52da1a9e46848b9c3ad68489e11b33686e6f1e5 Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 16 Jun 2023 12:18:34 +0200 Subject: [PATCH 109/232] unit test for multiple hidden state factors, control state factors, and observation modalities with temporal message passing routiens in jax (MMP, VMP) --- test/test_message_passing_jax.py | 91 +++++++++++++++++++++++++++++--- 1 file changed, 83 insertions(+), 8 deletions(-) diff --git a/test/test_message_passing_jax.py b/test/test_message_passing_jax.py index 3014ce3c..04ee77a5 100644 --- a/test/test_message_passing_jax.py +++ b/test/test_message_passing_jax.py @@ -11,7 +11,7 @@ import numpy as np import jax.numpy as jnp import jax.tree_util as jtu -from jax import vmap +from jax import vmap, nn from pymdp.jax.algos import run_vanilla_fpi as fpi_jax from pymdp.jax.algos import run_factorized_fpi as fpi_jax_factorized @@ -290,7 +290,7 @@ def test_vmap_message_passing_across_policies(self): all_policies = [policy_1, policy_2, policy_3] all_policies = list(jnp.stack(all_policies).transpose(2, 0, 1)) # `n_factors` lists, each with matrix of shape `(n_policies, n_time_steps)` - # for the single modality, a sequence over time of observations (one hot vectors) + # for the single modality, a sequence over time of observations (one hot vectors) obs = [jnp.broadcast_to(jnp.array([[1., 0., 0.], [0., 1., 0.], [0., 0., 1.], @@ -298,18 +298,93 @@ def test_vmap_message_passing_across_policies(self): prior = [jnp.ones((2, 3)) / 3., jnp.ones((2, 2)) / 2.] + ### First do VMP def test(action_sequence): - print(len(B), len(action_sequence)) - B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) - print(B_policy[0].shape, B_policy[1].shape) - + B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) return vmp_jax(A, B_policy, obs, prior, blanket_dict, num_iter=16, tau=1.) - qs_out = vmap(test)(all_policies) - print(qs_out[0].shape, qs_out[1].shape) + self.assertTrue(qs_out[0].shape[1] == obs[0].shape[0]) + ### Then do MMP + def test(action_sequence): + B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) + return mmp_jax(A, B_policy, obs, prior, blanket_dict, num_iter=16, tau=1.) + qs_out = vmap(test)(all_policies) self.assertTrue(qs_out[0].shape[1] == obs[0].shape[0]) + + def test_message_passing_multiple_modalities_factors(self): + + blanket_dict = {} # @TODO: implement factorized likelihoods for message passing + + num_states_list = [ + [2, 2, 5], + [2, 2, 2], + [4, 4] + ] + + num_controls_list = [ + [2, 1, 3], + [2, 1, 2], + [1, 3] + ] + + num_obs_list = [ + [5, 10], + [4, 3, 2], + [5, 2, 6, 3] + ] + + batch_dim, T = 2, 4 # batch dimension (e.g. number of agents, parallel realizations, etc.) and time steps + n_policies = 3 + for (num_states, num_controls, num_obs) in zip(num_states_list, num_controls_list, num_obs_list): + + # initialize arrays in numpy + A_numpy = utils.random_A_matrix(num_obs, num_states) + B_numpy = utils.random_B_matrix(num_states, num_controls) + + A = [] + for mod_i in range(len(num_obs)): + broadcast_shape = (batch_dim,) + tuple(A_numpy[mod_i].shape) + A.append(jnp.broadcast_to(A_numpy[mod_i], broadcast_shape)) + + B = [] + for fac_i in range(len(num_states)): + broadcast_shape = (batch_dim,) + tuple(B_numpy[fac_i].shape) + B.append(jnp.broadcast_to(B_numpy[fac_i], broadcast_shape)) + + prior_numpy = utils.random_single_categorical(num_states) + prior = [] + for fac_i in range(len(num_states)): + broadcast_shape = (batch_dim,) + tuple(prior_numpy[fac_i].shape) + prior.append(jnp.broadcast_to(prior_numpy[fac_i], broadcast_shape)) + + # initialization observation sequences in jax + obs_seq = [] + for n_obs in num_obs: + obs_ints = np.random.randint(0, high=n_obs, size=(T,1)) + obs_array_mod_i = jnp.broadcast_to(nn.one_hot(obs_ints, num_classes=n_obs), (T, batch_dim, n_obs)) + obs_seq.append(obs_array_mod_i) + + # create random policies + policies = [] + for n_controls in num_controls: + policies.append(jnp.array(np.random.randint(0, high=n_controls, size=(n_policies, T-1)))) + + print([p.shape for p in policies]) + ### First do VMP + def test(action_sequence): + B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) + return vmp_jax(A, B_policy, obs_seq, prior, blanket_dict, num_iter=16, tau=1.) + qs_out = vmap(test)(policies) + self.assertTrue(qs_out[0].shape[1] == obs_seq[0].shape[0]) + + ### Then do MMP + def test(action_sequence): + B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) + return mmp_jax(A, B_policy, obs_seq, prior, blanket_dict, num_iter=16, tau=1.) + qs_out = vmap(test)(policies) + self.assertTrue(qs_out[0].shape[1] == obs_seq[0].shape[0]) if __name__ == "__main__": unittest.main() From 218893d312acea32fdcc2d36e52cd6307bb4fa24 Mon Sep 17 00:00:00 2001 From: conorheins Date: Fri, 16 Jun 2023 12:18:55 +0200 Subject: [PATCH 110/232] delete unnecessary print statement at the end of algos.py module --- pymdp/jax/algos.py | 1 - 1 file changed, 1 deletion(-) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index 4f248005..8be37a90 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -227,7 +227,6 @@ def run_mmp(A, B, obs, prior, blanket_dict, num_iter=1, tau=1.): A = [jnp.ones((5, 2, 2, 5))/5, jnp.ones((10, 2, 2, 5))/10] qs = jit(run_vanilla_fpi)(A, obs, prior) - print(qs) # test if differentiable from functools import partial From 05dbafb5f6821590c26ee57be975cbbe7320d7ad Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 22 Jun 2023 17:42:46 +0200 Subject: [PATCH 111/232] - bumped version of jax in the requirements and setup.py, and added jax module into setup.py, and added additional dependencies (e.g. equinox, numpyro, optax) into setup.py - sparse conditional dependency relationships in observation likelihoood tensors now enabled in `run_vmp()` and `run_mmp()` in jax, with unit tests Co-authored-by: Dimitrije Markovic --- pymdp/__init__.py | 1 + pymdp/jax/__init__.py | 1 - pymdp/jax/algos.py | 25 ++++--- pymdp/jax/learning.py | 2 +- requirements.txt | 4 +- setup.py | 11 ++- test/test_message_passing_jax.py | 112 ++++++++++++++++++++++++++----- 7 files changed, 120 insertions(+), 36 deletions(-) diff --git a/pymdp/__init__.py b/pymdp/__init__.py index 52606d70..8692e691 100644 --- a/pymdp/__init__.py +++ b/pymdp/__init__.py @@ -7,3 +7,4 @@ from . import learning from . import algos from . import default_models +from . import jax diff --git a/pymdp/jax/__init__.py b/pymdp/jax/__init__.py index d5094bc6..e69de29b 100644 --- a/pymdp/jax/__init__.py +++ b/pymdp/jax/__init__.py @@ -1 +0,0 @@ -from . import algos diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index 8be37a90..13d35610 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -80,7 +80,7 @@ def scan_fn(carry, t): def run_factorized_fpi(A, obs, prior, factor_lists, num_iter=1): """ - @TODO: Run the sparsity-leveraging fixed point iteration algorithm (jaxified) + Run the fixed point iteration algorithm with sparse dependencies between factors and outcomes (stored in `factor_lists`) """ nf = len(prior) @@ -119,7 +119,8 @@ def mirror_gradient_descent_step(tau, ln_A, lnB_past, lnB_future, ln_qs): return qs -def update_marginals(get_messages, obs, A, B, prior, num_iter=1, tau=1.): +def update_marginals(get_messages, obs, A, B, prior, A_dependencies, num_iter=1, tau=1.,): + """" Version of marginal update that uses a sparse dependency matrix for A """ nf = len(prior) T = obs[0].shape[0] @@ -129,9 +130,8 @@ def update_marginals(get_messages, obs, A, B, prior, num_iter=1, tau=1.): # for $k > t$ we have $\ln(A) = 0$ def get_log_likelihood(obs_t, A): - # mapping over batch dimension - return vmap(compute_log_likelihood)(obs_t, A) + return vmap(compute_log_likelihood_per_modality)(obs_t, A) # mapping over time dimension of obs array log_likelihoods = vmap(get_log_likelihood, (0, None))(obs, A) # this gives a sequence of log-likelihoods (one for each `t`) @@ -153,9 +153,7 @@ def scan_fn(carry, iter): mgds = jtu.Partial(mirror_gradient_descent_step, tau) - # @TODO: Change to allow factorized updates - mll = jtu.Partial(marginal_log_likelihood, qs, log_likelihoods) - ln_As = jtu.tree_map(mll, factors) + ln_As = all_marginal_log_likelihood(qs, log_likelihoods, A_dependencies) qs = jtu.tree_map(mgds, ln_As, lnB_past, lnB_future, ln_qs) @@ -186,10 +184,15 @@ def backward(ln_b, q): return lnB_future, lnB_past -def run_vmp(A, B, obs, prior, blanket_dict, num_iter=1, tau=1.): - qs = update_marginals(get_vmp_messages, obs, A, B, prior, num_iter=num_iter, tau=tau) +def run_vmp(A, B, obs, prior, A_dependencies, num_iter=1, tau=1.): + ''' + Run variational message passing (VMP) on a sequence of observations + ''' + + qs = update_marginals(get_vmp_messages, obs, A, B, prior, A_dependencies, num_iter=num_iter, tau=tau) return qs + def get_mmp_messages(ln_B, B, qs, ln_prior): def forward(b, q, ln_prior): @@ -217,8 +220,8 @@ def backward(b, q): return lnB_future, lnB_past -def run_mmp(A, B, obs, prior, blanket_dict, num_iter=1, tau=1.): - qs = update_marginals(get_mmp_messages, obs, A, B, prior, num_iter=num_iter, tau=tau) +def run_mmp(A, B, obs, prior, A_dependencies, num_iter=1, tau=1.): + qs = update_marginals(get_mmp_messages, obs, A, B, prior, A_dependencies, num_iter=num_iter, tau=tau) return qs if __name__ == "__main__": diff --git a/pymdp/jax/learning.py b/pymdp/jax/learning.py index 80e3bea6..3b18cb49 100644 --- a/pymdp/jax/learning.py +++ b/pymdp/jax/learning.py @@ -4,7 +4,7 @@ import numpy as np from .maths import multidimensional_outer -from jax.tree_utils import tree_map +from jax.tree_util import tree_map from jax import vmap def update_obs_likelihood_dirichlet_m(pA_m, A_m, obs_m, qs, lr=1.0): diff --git a/requirements.txt b/requirements.txt index dbeae96f..8b59e2b1 100644 --- a/requirements.txt +++ b/requirements.txt @@ -24,8 +24,8 @@ xlsxwriter>=1.4.3 sphinx-rtd-theme>=0.4 myst-nb>=0.13.1 autograd>=1.3 -jax>=0.3 -jaxlib>=0.3 +jax>=0.3.4 +jaxlib>=0.3.4 equinox>=0.9 numpyro>=0.1 arviz>=0.13 diff --git a/setup.py b/setup.py index 4f0bd10a..03e2cbae 100644 --- a/setup.py +++ b/setup.py @@ -41,13 +41,18 @@ 'sphinx-rtd-theme>=0.4', 'myst-nb>=0.13.1', 'autograd>=1.3', - 'jax>=0.3', - 'jaxlib>=0.3' + 'jax>=0.3.4', + 'jaxlib>=0.3.4', + 'equinox>=0.9', + 'numpyro>=0.1', + 'arviz>=0.13', + 'optax>=0.1' ], packages=[ "pymdp", "pymdp.envs", - "pymdp.algos" + "pymdp.algos", + "pymdp.jax" ], include_package_data=True, keywords=[ diff --git a/test/test_message_passing_jax.py b/test/test_message_passing_jax.py index 04ee77a5..7358fbcc 100644 --- a/test/test_message_passing_jax.py +++ b/test/test_message_passing_jax.py @@ -147,8 +147,6 @@ def test_fixed_point_iteration_factorized_sparsegraph(self): def test_marginal_message_passing(self): - blanket_dict = {} # @TODO: implement factorized likelihoods for message passing - num_states = [3] num_obs = [3] @@ -185,14 +183,13 @@ def test_marginal_message_passing(self): prior = [jnp.ones((2, 3)) / 3.] - qs_out = mmp_jax(A, B_policy, obs, prior, blanket_dict, num_iter=16, tau=1.) + A_dependencies = [list(range(len(num_states))) for _ in range(len(num_obs))] + qs_out = mmp_jax(A, B_policy, obs, prior, A_dependencies, num_iter=16, tau=1.) self.assertTrue(qs_out[0].shape[0] == obs[0].shape[0]) def test_variational_message_passing(self): - blanket_dict = {} # @TODO: implement factorized likelihoods for message passing - num_states = [3] num_obs = [3] @@ -229,15 +226,14 @@ def test_variational_message_passing(self): prior = [jnp.ones((2, 3)) / 3.] - qs_out = vmp_jax(A, B_policy, obs, prior, blanket_dict, num_iter=16, tau=1.) + A_dependencies = [list(range(len(num_states))) for _ in range(len(num_obs))] + qs_out = vmp_jax(A, B_policy, obs, prior, A_dependencies, num_iter=16, tau=1.) self.assertTrue(qs_out[0].shape[0] == obs[0].shape[0]) def test_vmap_message_passing_across_policies(self): - blanket_dict = {} # @TODO: implement factorized likelihoods for message passing - - num_states = [3] + num_states = [3, 2] num_obs = [3] A_tensor = jnp.stack([jnp.array([[0.5, 0.5, 0.], @@ -298,24 +294,24 @@ def test_vmap_message_passing_across_policies(self): prior = [jnp.ones((2, 3)) / 3., jnp.ones((2, 2)) / 2.] + A_dependencies = [list(range(len(num_states))) for _ in range(len(num_obs))] + ### First do VMP def test(action_sequence): B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) - return vmp_jax(A, B_policy, obs, prior, blanket_dict, num_iter=16, tau=1.) + return vmp_jax(A, B_policy, obs, prior, A_dependencies, num_iter=16, tau=1.) qs_out = vmap(test)(all_policies) self.assertTrue(qs_out[0].shape[1] == obs[0].shape[0]) ### Then do MMP def test(action_sequence): B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) - return mmp_jax(A, B_policy, obs, prior, blanket_dict, num_iter=16, tau=1.) + return mmp_jax(A, B_policy, obs, prior, A_dependencies, num_iter=16, tau=1.) qs_out = vmap(test)(all_policies) self.assertTrue(qs_out[0].shape[1] == obs[0].shape[0]) def test_message_passing_multiple_modalities_factors(self): - blanket_dict = {} # @TODO: implement factorized likelihoods for message passing - num_states_list = [ [2, 2, 5], [2, 2, 2], @@ -370,21 +366,101 @@ def test_message_passing_multiple_modalities_factors(self): policies = [] for n_controls in num_controls: policies.append(jnp.array(np.random.randint(0, high=n_controls, size=(n_policies, T-1)))) - - print([p.shape for p in policies]) - ### First do VMP + + A_dependencies = [list(range(len(num_states))) for _ in range(len(num_obs))] + ### First do VMP def test(action_sequence): B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) - return vmp_jax(A, B_policy, obs_seq, prior, blanket_dict, num_iter=16, tau=1.) + return vmp_jax(A, B_policy, obs_seq, prior, A_dependencies, num_iter=16, tau=1.) qs_out = vmap(test)(policies) self.assertTrue(qs_out[0].shape[1] == obs_seq[0].shape[0]) ### Then do MMP def test(action_sequence): B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) - return mmp_jax(A, B_policy, obs_seq, prior, blanket_dict, num_iter=16, tau=1.) + return mmp_jax(A, B_policy, obs_seq, prior, A_dependencies, num_iter=16, tau=1.) qs_out = vmap(test)(policies) self.assertTrue(qs_out[0].shape[1] == obs_seq[0].shape[0]) + + def test_A_dependencies_message_passing(self): + """ Test variational message passing with A dependencies """ + + num_states_list = [ + [2, 2, 5], + [2, 2, 2], + [4, 4] + ] + + num_controls_list = [ + [2, 1, 3], + [2, 1, 2], + [1, 3] + ] + + num_obs_list = [ + [5, 10], + [4, 3, 2], + [5, 2, 6, 3] + ] + + A_dependencies_list = [ + [[0, 1], [1,2]], + [[0], [1], [2]], + [[0,1], [1], [0], [1]] + ] + + batch_dim, T = 13, 4 # batch dimension (e.g. number of agents, parallel realizations, etc.) and time steps + n_policies = 3 + + for (num_states, A_dependencies, num_controls, num_obs) in zip(num_states_list, A_dependencies_list, num_controls_list, num_obs_list): + + A_reduced_numpy = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_dependencies) + A_reduced = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(A_reduced_numpy)) + + A_full_numpy = [] + for m, no in enumerate(num_obs): + other_factors = list(set(range(len(num_states))) - set(A_dependencies[m])) # list of the factors that modality `m` does not depend on + + # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` + expanded_dims = [no] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] + tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] + A_full_numpy.append(np.tile(A_reduced_numpy[m].reshape(expanded_dims), tile_dims)) + + A_full = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(A_full_numpy)) + + B_numpy = utils.random_B_matrix(num_states, num_controls) + B = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(B_numpy)) + + prior_numpy = utils.random_single_categorical(num_states) + prior = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(prior_numpy)) + + # initialization observation sequences in jax + obs_seq = [] + for n_obs in num_obs: + obs_ints = np.random.randint(0, high=n_obs, size=(T,1)) + obs_array_mod_i = jnp.broadcast_to(nn.one_hot(obs_ints, num_classes=n_obs), (T, batch_dim, n_obs)) + obs_seq.append(obs_array_mod_i) + + # create random policies + policies = [] + for n_controls in num_controls: + policies.append(jnp.array(np.random.randint(0, high=n_controls, size=(n_policies, T-1)))) + + ### First do VMP + def test_full(action_sequence): + B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) + dependencies_fully_connected = [list(range(len(num_states))) for _ in range(len(num_obs))] + return vmp_jax(A_full, B_policy, obs_seq, prior, dependencies_fully_connected, num_iter=16, tau=1.) + + def test_sparse(action_sequence): + B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) + return vmp_jax(A_reduced, B_policy, obs_seq, prior, A_dependencies, num_iter=16, tau=1) + + qs_full = vmap(test_full)(policies) + qs_reduced = vmap(test_sparse)(policies) + + for f in range(len(qs_full)): + self.assertTrue(jnp.allclose(qs_full[f], qs_reduced[f])) if __name__ == "__main__": unittest.main() From 67e944b14a553033190591d95062831427c88e3c Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Mon, 10 Jul 2023 12:37:41 +0200 Subject: [PATCH 112/232] implementing variational filtering updates --- pymdp/jax/algos.py | 43 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index 13d35610..1a530caf 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -163,6 +163,44 @@ def scan_fn(carry, iter): return qs +def update_variational_filtering(get_messages, obs, A, B, prior, A_dependencies, num_iter=1, tau=1.,): + """Online variational filtering belief update that uses a sparse dependency matrix for A""" + + nf = len(prior) + T = obs[0].shape[0] + factors = list(range(nf)) + ln_B = jtu.tree_map(log_stable, B) + + def get_log_likelihood(obs_t, A): + # mapping over batch dimension + return vmap(compute_log_likelihood_per_modality)(obs_t, A) + + # mapping over time dimension of obs array + log_likelihoods = vmap(get_log_likelihood, (0, None))(obs, A) # this gives a sequence of log-likelihoods (one for each `t`) + + + # log prior -> $\ln(p(s_1))$ for all factors + ln_prior = jtu.tree_map(log_stable, prior) + + def scan_fn(carry, iter): + qs = carry + + ln_qs = jtu.tree_map(log_stable, qs) + # messages from future $m_+(s_t)$ and past $m_-(s_t)$ for all time steps and factors. For t = T we have that $m_+(s_T) = 0$ + lnB_past, lnB_future = get_messages(ln_B, B, qs, ln_prior) + + mgds = jtu.Partial(mirror_gradient_descent_step, tau) + + ln_As = all_marginal_log_likelihood(qs, log_likelihoods, A_dependencies) + + qs = jtu.tree_map(mgds, ln_As, lnB_past, lnB_future, ln_qs) + + return qs, None + + qs, _ = lax.scan(scan_fn, qs, jnp.arange(num_iter)) + + return qs + def get_vmp_messages(ln_B, B, qs, ln_prior): # @vmap(in_axes=(0, 1, 0), out_axes=1) @@ -224,6 +262,11 @@ def run_mmp(A, B, obs, prior, A_dependencies, num_iter=1, tau=1.): qs = update_marginals(get_mmp_messages, obs, A, B, prior, A_dependencies, num_iter=num_iter, tau=tau) return qs +def run_online_filtering(A, B, obs, prior, A_dependencies, num_iter=1, tau=1.): + """Runs online filtering (and smoothin) correponsing to belief propagation""" + qs = update_marginals(get_mmp_messages, obs, A, B, prior, A_dependencies, num_iter=num_iter, tau=tau) + return qs + if __name__ == "__main__": prior = [jnp.ones(2)/2, jnp.ones(2)/2, nn.softmax(jnp.array([0, -80., -80., -80, -80.]))] obs = [nn.one_hot(0, 5), nn.one_hot(5, 10)] From 4d94af80b909f47d8e220cb3ae7938dfe281faae Mon Sep 17 00:00:00 2001 From: Dimitrije Markovic <5038100+dimarkov@users.noreply.github.com> Date: Tue, 18 Jul 2023 10:22:11 +0200 Subject: [PATCH 113/232] implementation of online variational filtering --- examples/test_ovf.ipynb | 194 ++++++++++++++++++++++++++++++++++++++++ pymdp/jax/algos.py | 69 +++++++++----- 2 files changed, 239 insertions(+), 24 deletions(-) create mode 100644 examples/test_ovf.ipynb diff --git a/examples/test_ovf.ipynb b/examples/test_ovf.ipynb new file mode 100644 index 00000000..c83f882b --- /dev/null +++ b/examples/test_ovf.ipynb @@ -0,0 +1,194 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np \n", + "import jax.numpy as jnp\n", + "import jax.tree_util as jtu\n", + "\n", + "from jax import nn, vmap\n", + "from pymdp.jax.algos import update_variational_filtering\n", + "from pymdp import utils" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "num_states_list = [ \n", + " [2, 2, 5],\n", + " [2, 2, 2],\n", + " [4, 4]\n", + "]\n", + "\n", + "num_controls_list = [\n", + " [2, 1, 3],\n", + " [2, 1, 2],\n", + " [1, 3]\n", + "]\n", + "\n", + "num_obs_list = [\n", + " [5, 10],\n", + " [4, 3, 2],\n", + " [5, 2, 6, 3]\n", + "]\n", + "\n", + "A_dependencies_list = [\n", + " [[0, 1], [1, 2]],\n", + " [[0], [1], [2]],\n", + " [[0,1], [1], [0], [1]]\n", + "]\n", + "\n", + "batch_dim, T = 13, 4 # batch dimension (e.g. number of agents, parallel realizations, etc.) and time steps\n", + "n_policies = 3" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(3, 13, 2) (3, 13, 2) (3, 4, 13, 2, 2)\n", + "(3, 13, 2) (3, 13, 2) (3, 4, 13, 2, 2)\n", + "(3, 13, 5) (3, 13, 5) (3, 4, 13, 5, 5)\n", + "(3, 13, 2) (3, 13, 2) (3, 4, 13, 2, 2)\n", + "(3, 13, 2) (3, 13, 2) (3, 4, 13, 2, 2)\n", + "(3, 13, 2) (3, 13, 2) (3, 4, 13, 2, 2)\n", + "(3, 13, 4) (3, 13, 4) (3, 4, 13, 4, 4)\n", + "(3, 13, 4) (3, 13, 4) (3, 4, 13, 4, 4)\n" + ] + } + ], + "source": [ + "for (num_states, A_dependencies, num_controls, num_obs) in zip(num_states_list, A_dependencies_list, num_controls_list, num_obs_list):\n", + " \n", + " A_reduced_numpy = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_dependencies)\n", + " A_reduced = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(A_reduced_numpy))\n", + " \n", + " A_full_numpy = []\n", + " for m, no in enumerate(num_obs):\n", + " other_factors = list(set(range(len(num_states))) - set(A_dependencies[m])) # list of the factors that modality `m` does not depend on\n", + "\n", + " # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors`\n", + " expanded_dims = [no] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)]\n", + " tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)]\n", + " A_full_numpy.append(np.tile(A_reduced_numpy[m].reshape(expanded_dims), tile_dims))\n", + " \n", + " A_full = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(A_full_numpy))\n", + "\n", + " B_numpy = utils.random_B_matrix(num_states, num_controls)\n", + " B = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(B_numpy))\n", + "\n", + " prior_numpy = utils.random_single_categorical(num_states)\n", + " prior = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(prior_numpy))\n", + " \n", + " # initialization observation sequences in jax\n", + " obs_seq = []\n", + " for n_obs in num_obs:\n", + " obs_ints = np.random.randint(0, high=n_obs, size=(T,1))\n", + " obs_array_mod_i = jnp.broadcast_to(nn.one_hot(obs_ints, num_classes=n_obs), (T, batch_dim, n_obs))\n", + " obs_seq.append(obs_array_mod_i)\n", + "\n", + " # create random policies\n", + " policies = []\n", + " for n_controls in num_controls:\n", + " policies.append(jnp.array(np.random.randint(0, high=n_controls, size=(n_policies, T-1))))\n", + "\n", + " def test_sparse(action_sequence):\n", + " B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(3, 0, 1, 2), B, action_sequence)\n", + " qs, ps, qss = update_variational_filtering(obs_seq, A_reduced, B_policy, prior, A_dependencies)\n", + " return qs, ps, qss\n", + "\n", + " qs_pi, ps_pi, qss_pi = vmap(test_sparse)(policies)\n", + "\n", + " for qs, ps, qss in zip(qs_pi, ps_pi, qss_pi):\n", + " print(qs.shape, ps.shape, qss.shape)\n", + "\n", + "#Note: qs is of dimension [num_actions x num_agents x dim_state_f] * num_factors\n", + "#Note: qss is of dimension [num_actions x time_steps x num_agents x dim_state_f x dim_state_f]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array([0.10571534, 0.03540028, 0.4963476 , 0.36253685], dtype=float32)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qs_pi[0][0, 0]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array([[0.6461534 , 0.09652454, 0.22822888, 0.02909314],\n", + " [0.33564523, 0.26329154, 0.30335486, 0.09770837],\n", + " [0.4735609 , 0.18010727, 0.23158638, 0.11474543],\n", + " [0.50991637, 0.20105273, 0.18791321, 0.10111766]], dtype=float32)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qss_pi[0][0, 0, 0]" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "befit", + "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.11.3" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index 1a530caf..78b945be 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -163,14 +163,43 @@ def scan_fn(carry, iter): return qs -def update_variational_filtering(get_messages, obs, A, B, prior, A_dependencies, num_iter=1, tau=1.,): +def variational_filtering_step(prior, Bs, ln_As, A_dependencies): + + ln_prior = jtu.tree_map(log_stable, prior) + + marg_ln_As = all_marginal_log_likelihood(prior, ln_As, A_dependencies) + + # compute posterior + post = jtu.tree_map( + lambda x, y: nn.softmax(x + y, -1), marg_ln_As, ln_prior + ) + + # compute prediction + pred = jtu.tree_map( + lambda x, y: jnp.sum(x * jnp.expand_dims(y, -2), -1), Bs, post + ) + + # compute reverse conditional distribution + cond = jtu.tree_map( + lambda x, y, z: x * jnp.expand_dims(y, -2) / jnp.expand_dims(z, -1), + Bs, + post, + pred + ) + + return post, pred, cond + +def update_variational_filtering(obs, A, B, prior, A_dependencies, **kwargs): """Online variational filtering belief update that uses a sparse dependency matrix for A""" - nf = len(prior) T = obs[0].shape[0] - factors = list(range(nf)) - ln_B = jtu.tree_map(log_stable, B) - + def pad(x): + npad = [(0, 0)] * jnp.ndim(x) + npad[0] = (0, 1) + return jnp.pad(x, npad, constant_values=1.) + + B = jtu.tree_map(pad, B) + def get_log_likelihood(obs_t, A): # mapping over batch dimension return vmap(compute_log_likelihood_per_modality)(obs_t, A) @@ -178,28 +207,20 @@ def get_log_likelihood(obs_t, A): # mapping over time dimension of obs array log_likelihoods = vmap(get_log_likelihood, (0, None))(obs, A) # this gives a sequence of log-likelihoods (one for each `t`) - - # log prior -> $\ln(p(s_1))$ for all factors - ln_prior = jtu.tree_map(log_stable, prior) - def scan_fn(carry, iter): - qs = carry - - ln_qs = jtu.tree_map(log_stable, qs) - # messages from future $m_+(s_t)$ and past $m_-(s_t)$ for all time steps and factors. For t = T we have that $m_+(s_T) = 0$ - lnB_past, lnB_future = get_messages(ln_B, B, qs, ln_prior) - - mgds = jtu.Partial(mirror_gradient_descent_step, tau) - - ln_As = all_marginal_log_likelihood(qs, log_likelihoods, A_dependencies) - - qs = jtu.tree_map(mgds, ln_As, lnB_past, lnB_future, ln_qs) + _, prior = carry + Bs, ln_As = iter - return qs, None + post, pred, cond = variational_filtering_step(prior, Bs, ln_As, A_dependencies) + + return (post, pred), cond - qs, _ = lax.scan(scan_fn, qs, jnp.arange(num_iter)) + init = (prior, prior) + iterator = (B, log_likelihoods) + # get q_T(s_t), p_T(s_{t+1}) and the history q_{T}(s_{t}|s_{t+1})q_{T-1}(s_{t-1}|s_{t}) ... + (qs, ps), qss = lax.scan(scan_fn, init, iterator) - return qs + return qs, ps, qss def get_vmp_messages(ln_B, B, qs, ln_prior): @@ -220,7 +241,7 @@ def backward(ln_b, q): lnB_future = jtu.tree_map(fwd, ln_B, qs, ln_prior) lnB_past = jtu.tree_map(bkwd, ln_B, qs) - return lnB_future, lnB_past + return lnB_future, lnB_past def run_vmp(A, B, obs, prior, A_dependencies, num_iter=1, tau=1.): ''' From d9bc4befad5cb207af2fb0e169c7ca34a5063c02 Mon Sep 17 00:00:00 2001 From: conorheins Date: Tue, 1 Aug 2023 19:22:52 +0200 Subject: [PATCH 114/232] - added options to `update_posterior_states` to switch between MP algos Co-authored-by: Dimitrije Markovic --- pymdp/jax/inference.py | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/pymdp/jax/inference.py b/pymdp/jax/inference.py index 92edf30a..36776b1a 100644 --- a/pymdp/jax/inference.py +++ b/pymdp/jax/inference.py @@ -2,9 +2,16 @@ # -*- coding: utf-8 -*- # pylint: disable=no-member -from .algos import run_vanilla_fpi +from .algos import run_vanilla_fpi, run_mmp, run_vmp, run_online_filtering -def update_posterior_states(A, obs, prior=None, num_iter=16): +def update_posterior_states(A, B, obs, actions, prior=None, A_dependencies=None, num_iter=16, method='fpi'): - return run_vanilla_fpi(A, obs, prior, num_iter=num_iter) + if method == 'fpi': + return run_vanilla_fpi(A, obs, prior, num_iter=num_iter) + if method == 'vmp': + return run_vmp(A, B, obs, prior, A_dependencies, num_iter=num_iter) + if method == 'mmp': + return run_mmp(A, B, obs, prior, A_dependencies, num_iter=num_iter) + if method == "ovf": + return run_online_filtering(A, B, obs, prior, A_dependencies, num_iter=num_iter) From 5bca9346a2aadfeb6b6cd20fe0b86610dcc7a5d1 Mon Sep 17 00:00:00 2001 From: conorheins Date: Wed, 2 Aug 2023 14:56:44 +0200 Subject: [PATCH 115/232] added new default inference parameter into parameter set for "VANILLA" inference method when initializing `Agent`: "compute_vfe" (defaults to `True`) --- pymdp/agent.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pymdp/agent.py b/pymdp/agent.py index 01513f69..35bdba75 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -932,7 +932,7 @@ def _get_default_params(self): method = self.inference_algo default_params = None if method == "VANILLA": - default_params = {"num_iter": 10, "dF": 1.0, "dF_tol": 0.001} + default_params = {"num_iter": 10, "dF": 1.0, "dF_tol": 0.001, "compute_vfe": True} elif method == "MMP": default_params = {"num_iter": 10, "grad_descent": True, "tau": 0.25} elif method == "VMP": From 273defe3425e0093069749e26a69d67d42a03d0a Mon Sep 17 00:00:00 2001 From: conorheins Date: Wed, 2 Aug 2023 14:58:04 +0200 Subject: [PATCH 116/232] new input argument in `run_vanilla_fpi` and `run_vanilla_fpi_factorized`, that indicates whether the stop condition should be based on reaching the final variational iteration or a pre-specified free-energy difference tolerance (difference in free energies between two subsequent iterations), or whether just on reaching the final variational iteration. @tverbele see here --- pymdp/algos/fpi.py | 67 +++++++++++++++++++++++++++++++--------------- 1 file changed, 45 insertions(+), 22 deletions(-) diff --git a/pymdp/algos/fpi.py b/pymdp/algos/fpi.py index 6e87480f..e007d9a9 100644 --- a/pymdp/algos/fpi.py +++ b/pymdp/algos/fpi.py @@ -8,7 +8,7 @@ from itertools import chain from copy import deepcopy -def run_vanilla_fpi(A, obs, num_obs, num_states, prior=None, num_iter=10, dF=1.0, dF_tol=0.001): +def run_vanilla_fpi(A, obs, num_obs, num_states, prior=None, num_iter=10, dF=1.0, dF_tol=0.001, compute_vfe=True): """ Update marginal posterior beliefs over hidden states using mean-field variational inference, via fixed point iteration. @@ -37,6 +37,9 @@ def run_vanilla_fpi(A, obs, num_obs, num_states, prior=None, num_iter=10, dF=1.0 Threshold value of the time derivative of the variational free energy (dF/dt), to be checked at each iteration. If dF <= dF_tol, the iterations are halted pre-emptively and the final marginal posterior belief(s) is(are) returned + compute_vfe: bool, default True + Whether to compute the variational free energy at each iteration. If False, the function runs through + all variational iterations. Returns ---------- @@ -81,7 +84,8 @@ def run_vanilla_fpi(A, obs, num_obs, num_states, prior=None, num_iter=10, dF=1.0 =========== Step 3 =========== Initialize initial free energy """ - prev_vfe = calc_free_energy(qs, prior, n_factors) + if compute_vfe: + prev_vfe = calc_free_energy(qs, prior, n_factors) """ =========== Step 4 =========== @@ -101,8 +105,14 @@ def run_vanilla_fpi(A, obs, num_obs, num_states, prior=None, num_iter=10, dF=1.0 Run the FPI scheme """ + # change stop condition for fixed point iterations based on whether we are computing the variational free energy or not + condition_check_both = lambda curr_iter, dF: curr_iter < num_iter and dF >= dF_tol + condition_check_just_numiter = lambda curr_iter, dF: curr_iter < num_iter + check_stop_condition = condition_check_both if compute_vfe else condition_check_just_numiter + curr_iter = 0 - while curr_iter < num_iter and dF >= dF_tol: + + while check_stop_condition(curr_iter, dF): # Initialise variational free energy vfe = 0 @@ -134,19 +144,20 @@ def run_vanilla_fpi(A, obs, num_obs, num_states, prior=None, num_iter=10, dF=1.0 # qL = spm_dot(likelihood, qs, [factor]) # qs[factor] = softmax(qL + prior[factor]) - # calculate new free energy - vfe = calc_free_energy(qs, prior, n_factors, likelihood) + if compute_vfe: + # calculate new free energy + vfe = calc_free_energy(qs, prior, n_factors, likelihood) - # print(f'VFE at iteration {curr_iter}: {vfe}\n') - # stopping condition - time derivative of free energy - dF = np.abs(prev_vfe - vfe) - prev_vfe = vfe + # print(f'VFE at iteration {curr_iter}: {vfe}\n') + # stopping condition - time derivative of free energy + dF = np.abs(prev_vfe - vfe) + prev_vfe = vfe curr_iter += 1 return qs -def run_vanilla_fpi_factorized(A, obs, num_obs, num_states, mb_dict, prior=None, num_iter=10, dF=1.0, dF_tol=0.001): +def run_vanilla_fpi_factorized(A, obs, num_obs, num_states, mb_dict, prior=None, num_iter=10, dF=1.0, dF_tol=0.001, compute_vfe=True): """ Update marginal posterior beliefs over hidden states using mean-field variational inference, via fixed point iteration. @@ -178,6 +189,9 @@ def run_vanilla_fpi_factorized(A, obs, num_obs, num_states, mb_dict, prior=None, Threshold value of the time derivative of the variational free energy (dF/dt), to be checked at each iteration. If dF <= dF_tol, the iterations are halted pre-emptively and the final marginal posterior belief(s) is(are) returned + compute_vfe: bool, default True + Whether to compute the variational free energy at each iteration. If False, the function runs through + all variational iterations. Returns ---------- @@ -248,16 +262,24 @@ def run_vanilla_fpi_factorized(A, obs, num_obs, num_states, mb_dict, prior=None, """ A_factor_list, A_modality_list = mb_dict['A_factor_list'], mb_dict['A_modality_list'] - joint_loglikelihood = np.zeros(tuple(num_states)) - for m in range(n_modalities): - reshape_dims = n_factors*[1] - for _f_id in A_factor_list[m]: - reshape_dims[_f_id] = num_states[_f_id] - joint_loglikelihood += log_likelihood[m].reshape(reshape_dims) # add up all the log-likelihoods after reshaping them to the global common dimensions of all hidden state factors + if compute_vfe: + joint_loglikelihood = np.zeros(tuple(num_states)) + for m in range(n_modalities): + reshape_dims = n_factors*[1] + for _f_id in A_factor_list[m]: + reshape_dims[_f_id] = num_states[_f_id] + + joint_loglikelihood += log_likelihood[m].reshape(reshape_dims) # add up all the log-likelihoods after reshaping them to the global common dimensions of all hidden state factors curr_iter = 0 - while curr_iter < num_iter and dF >= dF_tol: + + # change stop condition for fixed point iterations based on whether we are computing the variational free energy or not + condition_check_both = lambda curr_iter, dF: curr_iter < num_iter and dF >= dF_tol + condition_check_just_numiter = lambda curr_iter, dF: curr_iter < num_iter + check_stop_condition = condition_check_both if compute_vfe else condition_check_just_numiter + + while check_stop_condition(curr_iter, dF): # vfe = 0 @@ -287,12 +309,13 @@ def run_vanilla_fpi_factorized(A, obs, num_obs, num_states, mb_dict, prior=None, # calculate new free energy, leaving out the accuracy term # vfe += calc_free_energy(qs, prior, n_factors) - vfe = calc_free_energy(qs, prior, n_factors, likelihood=joint_loglikelihood) + if compute_vfe: + vfe = calc_free_energy(qs, prior, n_factors, likelihood=joint_loglikelihood) - # print(f'VFE at iteration {curr_iter}: {vfe}\n') - # stopping condition - time derivative of free energy - dF = np.abs(prev_vfe - vfe) - prev_vfe = vfe + # print(f'VFE at iteration {curr_iter}: {vfe}\n') + # stopping condition - time derivative of free energy + dF = np.abs(prev_vfe - vfe) + prev_vfe = vfe curr_iter += 1 From 7fbc2b7919eea6fa22b510c3e0702941ca1cb655 Mon Sep 17 00:00:00 2001 From: conorheins Date: Wed, 2 Aug 2023 15:09:20 +0200 Subject: [PATCH 117/232] added in quick unit tests to `test_inference` and `test_fpi` to make sure the `compute_vfe=False` flag works as intended --- test/test_fpi.py | 9 ++++++++- test/test_inference.py | 36 ++++++++++++++++++++++++++++++++++++ 2 files changed, 44 insertions(+), 1 deletion(-) diff --git a/test/test_fpi.py b/test/test_fpi.py index 33b167b2..d60f944e 100644 --- a/test/test_fpi.py +++ b/test/test_fpi.py @@ -116,7 +116,14 @@ def test_factorized_fpi_multi_factor_multi_modality(self): for qs_f_val, qs_f_out in zip(qs_validation, qs_out): self.assertTrue(np.isclose(qs_f_val, qs_f_out).all()) - + + # test it also without computing VFE (i.e. with `compute_vfe=False`) + qs_out = run_vanilla_fpi_factorized(A, obs, num_obs, num_states, mb_dict, prior=prior, compute_vfe=False) + qs_validation = run_vanilla_fpi(A, obs, num_obs, num_states, prior=prior, compute_vfe=False) + + for qs_f_val, qs_f_out in zip(qs_validation, qs_out): + self.assertTrue(np.isclose(qs_f_val, qs_f_out).all()) + def test_factorized_fpi_multi_factor_multi_modality_with_condind(self): """ Test the sparsified version of `run_vanilla_fpi`, named `run_vanilla_fpi_factorized` diff --git a/test/test_inference.py b/test/test_inference.py index 10be48de..6528ab6d 100644 --- a/test/test_inference.py +++ b/test/test_inference.py @@ -173,6 +173,42 @@ def test_update_posterior_states_factorized(self): for qs_f_val, qs_f_out in zip(qs_validation, qs_out): self.assertTrue(np.isclose(qs_f_val, qs_f_out).all()) + def test_update_posterior_states_factorized_noVFE_compute(self): + """ + Tests the version of `update_posterior_states` where an `mb_dict` is provided as an argument to factorize + the fixed-point iteration (FPI) algorithm. + + In this version, we always run the total number of iterations because we don't compute the variational free energy over the course of convergence/optimization. + """ + + num_states = [3, 4] + num_obs = [3, 3, 5] + + prior = utils.random_single_categorical(num_states) + + obs_index_tuple = tuple([np.random.randint(obs_dim) for obs_dim in num_obs]) + + mb_dict = {'A_factor_list': [[0], [1], [0, 1]], + 'A_modality_list': [[0, 2], [1, 2]]} + + A_reduced = utils.random_A_matrix(num_obs, num_states, A_factor_list=mb_dict['A_factor_list']) + + qs_out = inference.update_posterior_states_factorized(A_reduced, obs_index_tuple, num_obs, num_states, mb_dict, prior=prior, compute_vfe=False) + + A_full = utils.initialize_empty_A(num_obs, num_states) + for m, A_m in enumerate(A_full): + other_factors = list(set(range(len(num_states))) - set(mb_dict['A_factor_list'][m])) # list of the factors that modality `m` does not depend on + + # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` + expanded_dims = [num_obs[m]] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] + tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] + A_full[m] = np.tile(A_reduced[m].reshape(expanded_dims), tile_dims) + + qs_validation = inference.update_posterior_states(A_full, obs_index_tuple, prior=prior, compute_vfe=False) + + for qs_f_val, qs_f_out in zip(qs_validation, qs_out): + self.assertTrue(np.isclose(qs_f_val, qs_f_out).all()) + if __name__ == "__main__": unittest.main() \ No newline at end of file From 33a76e04a670279c4ca3a3cf40d69bfdef532f4e Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 3 Aug 2023 17:00:54 +0100 Subject: [PATCH 118/232] - added distributional observations argument into `run_vanilla_fpi()` (jaxified algo) - added distributional observations vs. one-hot observations argument into the `log_likelihood` compjuting functions in the `jax` backend - unit test of jax version of run_vanilla_fpi that uses discrete observations Co-authored-by: Dimitrije Markovic --- pymdp/jax/algos.py | 4 ++-- pymdp/jax/maths.py | 17 +++++++------ test/test_inference_jax.py | 49 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 61 insertions(+), 9 deletions(-) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index 78b945be..63538249 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -49,13 +49,13 @@ def mll_factors(qs, ll_m, factor_list_m) -> List: loc_factors = list(range(loc_nf)) return jtu.tree_map(marginal_ll_f, loc_factors) -def run_vanilla_fpi(A, obs, prior, num_iter=1): +def run_vanilla_fpi(A, obs, prior, num_iter=1, distr_obs=True): """ Vanilla fixed point iteration (jaxified) """ nf = len(prior) factors = list(range(nf)) # Step 1: Compute log likelihoods for each factor - ll = compute_log_likelihood(obs, A) + ll = compute_log_likelihood(obs, A, distr_obs=distr_obs) # log_likelihoods = [ll] * nf # Step 2: Map prior to log space and create initial log-posterior diff --git a/pymdp/jax/maths.py b/pymdp/jax/maths.py index a6b6b8a0..4f334637 100644 --- a/pymdp/jax/maths.py +++ b/pymdp/jax/maths.py @@ -6,23 +6,26 @@ def log_stable(x): return jnp.log(jnp.clip(x, a_min=MINVAL)) -def compute_log_likelihood_single_modality(o_m, A_m): +def compute_log_likelihood_single_modality(o_m, A_m, distr_obs=True): """ Compute observation likelihood for a single modality (observation and likelihood)""" - expanded_obs = jnp.expand_dims(o_m, tuple(range(1, A_m.ndim))) - likelihood = (expanded_obs * A_m).sum(axis=0) + if distr_obs: + expanded_obs = jnp.expand_dims(o_m, tuple(range(1, A_m.ndim))) + likelihood = (expanded_obs * A_m).sum(axis=0) + else: + likelihood = A_m[o_m] return log_stable(likelihood) -def compute_log_likelihood(obs, A): +def compute_log_likelihood(obs, A, distr_obs=True): """ Compute likelihood over hidden states across observations from different modalities """ - result = tree_util.tree_map(compute_log_likelihood_single_modality, obs, A) + result = tree_util.tree_map(lambda o, a: compute_log_likelihood_single_modality(o, a, distr_obs=distr_obs), obs, A) ll = jnp.sum(jnp.stack(result), 0) return ll -def compute_log_likelihood_per_modality(obs, A): +def compute_log_likelihood_per_modality(obs, A, distr_obs=True): """ Compute likelihood over hidden states across observations from different modalities, and return them per modality """ - ll_all = tree_util.tree_map(compute_log_likelihood_single_modality, obs, A) + ll_all = tree_util.tree_map(lambda o, a: compute_log_likelihood_single_modality(o, a, distr_obs=distr_obs), obs, A) return ll_all diff --git a/test/test_inference_jax.py b/test/test_inference_jax.py index bcf8347f..e426c870 100644 --- a/test/test_inference_jax.py +++ b/test/test_inference_jax.py @@ -180,6 +180,55 @@ def test_fixed_point_iteration_multistate_multiobs(self): for f, _ in enumerate(qs_jax): self.assertTrue(np.allclose(qs_numpy[f], qs_jax[f])) + + def test_fixed_point_iteration_index_observations(self): + """ + Tests the jax-ified version of mean-field fixed-point iteration against the original NumPy version. + In this version there are multiple hidden state factors and multiple observation modalities. + + Test the jax version with index-based observations (not one-hots) + """ + + ''' Start by creating a collection of random generative models with different + cardinalities and dimensionalities of hidden state factors and observation modalities''' + + num_states_list = [ + [2, 2, 5], + [2, 2, 2], + [4, 4] + ] + + num_obs_list = [ + [5, 10], + [4, 3, 2], + [5, 10, 6] + ] + + for (num_states, num_obs) in zip(num_states_list, num_obs_list): + + # numpy version + prior = utils.random_single_categorical(num_states) + A = utils.random_A_matrix(num_obs, num_states) + + obs = utils.obj_array(len(num_obs)) + for m, obs_dim in enumerate(num_obs): + obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) + + qs_numpy = fpi_numpy(A, obs, num_obs, num_states, prior=prior, num_iter=16, dF=1.0, dF_tol=-1.0) # set dF_tol to negative number so numpy version of FPI never stops early due to convergence + + obs_idx = [] + for ob in obs: + obs_idx.append(np.where(ob)[0][0]) + + # jax version + prior = [jnp.array(prior_f) for prior_f in prior] + A = [jnp.array(a_m) for a_m in A] + # obs = [jnp.array(o_m) for o_m in obs] + + qs_jax = fpi_jax(A, obs_idx, prior, num_iter=16, distr_obs=False) + + for f, _ in enumerate(qs_jax): + self.assertTrue(np.allclose(qs_numpy[f], qs_jax[f])) if __name__ == "__main__": unittest.main() \ No newline at end of file From ff4b150ce753070720353eb4e3a392ead2a99b7d Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 3 Aug 2023 17:09:45 +0100 Subject: [PATCH 119/232] added new arguments to `infer_states()` method of `Agent`, like `past_actions` and `empirical_prior` --- pymdp/jax/agent.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index c952ec68..f1a327bd 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -143,15 +143,18 @@ def learning(self, *args, **kwargs): raise NotImplementedError @vmap - def infer_states(self, observations, empirical_prior): + def infer_states(self, observations, past_actions, empirical_prior): """ Update approximate posterior over hidden states by solving variational inference problem, given an observation. Parameters ---------- - observation: ``list`` or ``tuple`` of ints - The observation input. Each entry ``observation[m]`` stores the index of the discrete - observation for modality ``m``. + observations: ``list`` or ``tuple`` of ints + The observation input. Each entry ``observation[m]`` stores one-hot vectors representing the observations for modality ``m``. + past_actions: ``list`` or ``tuple`` of ints + The action input. Each entry ``past_actions[f]`` stores indices (or one-hots?) representing the actions for control factor ``f``. + empirical_prior: ``list`` or ``tuple`` of ``jax.numpy.ndarray`` of dtype object + Empirical prior beliefs over hidden states. Depending on the inference algorithm chosen, the resulting ``empirical_prior`` variable will have additional sub-structure to reflect whether Returns --------- From f47fc6693addcaab5bc73644bc426213cf37e017 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 3 Aug 2023 17:25:26 +0100 Subject: [PATCH 120/232] made a skeleton of across-trial and -block active inference loop, that in theory should accomodate the different types of message passing algorithms, especially the ones that need the past history of observations and actions. Also sketched out how to deal with stitching information from adjacent blocks, depending on the assumptions of the task/sequence structure. --- examples/building_up_agent_loop.ipynb | 85 +++++++++++++++++++++++++++ 1 file changed, 85 insertions(+) create mode 100644 examples/building_up_agent_loop.ipynb diff --git a/examples/building_up_agent_loop.ipynb b/examples/building_up_agent_loop.ipynb new file mode 100644 index 00000000..412a05f4 --- /dev/null +++ b/examples/building_up_agent_loop.ipynb @@ -0,0 +1,85 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import jax\n", + "import jax.numpy as jnp\n", + "import jax.tree_util as jtu\n", + "from jax import random as jr\n", + "from pymdp.jax.agent import Agent as AIFAgent" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def scan(f, init, xs, length=None):\n", + " if xs is None:\n", + " xs = [None] * length\n", + " carry = init\n", + " ys = []\n", + " for x in xs:\n", + " carry, y = f(carry, x)\n", + " ys.append(y)\n", + " \n", + " return carry, jnp.stack(ys)\n", + "\n", + "def evolve_trials(agent, env, num_timesteps):\n", + "\n", + " def step_fn(carry, xs):\n", + " actions = carry['actions']\n", + " outcomes = carry['outcomes']\n", + " beliefs = agent.infer_states(outcomes, actions, *carry['args'])\n", + " q_pi, _ = agent.infer_policies(beliefs)\n", + " actions_t = agent.sample_action(q_pi)\n", + "\n", + " outcome_t = env.step(actions_t)\n", + " outcomes = jtu.tree_map(lambda prev_o, new_o: jnp.stack([prev_o, jnp.expand_dims(new_o, 0)], 0), outcomes, outcome_t)\n", + "\n", + " actions = jnp.stack([actions, jnp.expand_dims(actions_t, 0)], 0) if actions is not None else actions_t\n", + " args = agent.update_empirical_prior(actions_t, beliefs)\n", + " # (pred, [cond_1, ..., cond_{t-1}])\n", + "\n", + " # ovf beliefs = (post_T, [cond_1, cond_2, ..., cond_{T-1}])\n", + " # else beliefs = (post_T, post_{T-1}, ..., post_1)\n", + " return {'args': args, 'outcomes': outcomes, 'beliefs': beliefs, 'actions': actions}, None\n", + "\n", + " outcome_0 = env.step()\n", + " init = ((agent.D, None), outcome_0, None, None)\n", + " last, _ = scan(step_fn, init, range(num_timesteps))\n", + "\n", + " return last\n", + "\n", + "def step_fn(carry, b):\n", + " agent = carry\n", + " output = evolve_trials(agent, b)\n", + "\n", + " # How to deal with contiguous blocks of trials? Two options we can imagine: \n", + " # A) you use final posterior (over current and past timesteps) to compute the smoothing distribution over qs_{t=0} and update pD, and then pass pD as the initial state prior ($D = \\mathbb{E}_{pD}[qs_{t=0}]$);\n", + " # B) we don't assume that blocks 'reset time', and are really just adjacent chunks of one long sequence, so you set the initial state prior to be the final output (`output['beliefs']`) passed through\n", + " # the transition model entailed by the action taken at the last timestep of the previous block.\n", + " \n", + " agent = agent.learning(**output)\n", + " \n", + " return agent, output\n", + "\n", + "init_agent = agent\n", + "agent, squences = scan(step_fn, init_agent, range(num_blocks) )" + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} From b04d003923d179186e1fece376ca0bf98a947b1e Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 3 Aug 2023 17:28:56 +0100 Subject: [PATCH 121/232] more edits from @dimarkov --- examples/building_up_agent_loop.ipynb | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/examples/building_up_agent_loop.ipynb b/examples/building_up_agent_loop.ipynb index 412a05f4..06328933 100644 --- a/examples/building_up_agent_loop.ipynb +++ b/examples/building_up_agent_loop.ipynb @@ -30,7 +30,7 @@ " \n", " return carry, jnp.stack(ys)\n", "\n", - "def evolve_trials(agent, env, num_timesteps):\n", + "def evolve_trials(agent, env, block_idx, num_timesteps):\n", "\n", " def step_fn(carry, xs):\n", " actions = carry['actions']\n", @@ -54,11 +54,11 @@ " init = ((agent.D, None), outcome_0, None, None)\n", " last, _ = scan(step_fn, init, range(num_timesteps))\n", "\n", - " return last\n", + " return last, env\n", "\n", - "def step_fn(carry, b):\n", - " agent = carry\n", - " output = evolve_trials(agent, b)\n", + "def step_fn(carry, block_idx):\n", + " agent, env = carry\n", + " output, env = evolve_trials(agent, env, block_idx, num_timesteps)\n", "\n", " # How to deal with contiguous blocks of trials? Two options we can imagine: \n", " # A) you use final posterior (over current and past timesteps) to compute the smoothing distribution over qs_{t=0} and update pD, and then pass pD as the initial state prior ($D = \\mathbb{E}_{pD}[qs_{t=0}]$);\n", @@ -67,10 +67,10 @@ " \n", " agent = agent.learning(**output)\n", " \n", - " return agent, output\n", + " return (agent, env), output\n", "\n", - "init_agent = agent\n", - "agent, squences = scan(step_fn, init_agent, range(num_blocks) )" + "init = (agent, env)\n", + "agent, squences = scan(step_fn, init, range(num_blocks) )" ] } ], From 6cee2b17c73d0da5711fe406ec6be31d54f7a1e8 Mon Sep 17 00:00:00 2001 From: Dimitrije Markovic <5038100+dimarkov@users.noreply.github.com> Date: Tue, 12 Sep 2023 16:36:10 +0200 Subject: [PATCH 122/232] update online varaitional filtering --- examples/test_ovf.ipynb | 2 +- pymdp/jax/algos.py | 11 +++++++---- pymdp/jax/inference.py | 13 ++++++++++--- 3 files changed, 18 insertions(+), 8 deletions(-) diff --git a/examples/test_ovf.ipynb b/examples/test_ovf.ipynb index c83f882b..a64e8dd2 100644 --- a/examples/test_ovf.ipynb +++ b/examples/test_ovf.ipynb @@ -122,7 +122,7 @@ " print(qs.shape, ps.shape, qss.shape)\n", "\n", "#Note: qs is of dimension [num_actions x num_agents x dim_state_f] * num_factors\n", - "#Note: qss is of dimension [num_actions x time_steps x num_agents x dim_state_f x dim_state_f]" + "#Note: qss is of dimension [num_actions x time_steps x num_agents x dim_state_f x dim_state_f] * num_factors" ] }, { diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index 78b945be..b5e58c64 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -166,20 +166,23 @@ def scan_fn(carry, iter): def variational_filtering_step(prior, Bs, ln_As, A_dependencies): ln_prior = jtu.tree_map(log_stable, prior) - + + #TODO: put this inside scan + #### marg_ln_As = all_marginal_log_likelihood(prior, ln_As, A_dependencies) - # compute posterior + # compute posterior q(z_t) -> n x 1 x d post = jtu.tree_map( lambda x, y: nn.softmax(x + y, -1), marg_ln_As, ln_prior ) + #### - # compute prediction + # compute prediction p(z_{t+1}) = \int p(z_{t+1}|z_t) q(z_t) -> n x d x 1 pred = jtu.tree_map( lambda x, y: jnp.sum(x * jnp.expand_dims(y, -2), -1), Bs, post ) - # compute reverse conditional distribution + # compute reverse conditional distribution q(z_t|z_{t+1}) cond = jtu.tree_map( lambda x, y, z: x * jnp.expand_dims(y, -2) / jnp.expand_dims(z, -1), Bs, diff --git a/pymdp/jax/inference.py b/pymdp/jax/inference.py index 92edf30a..477a2c44 100644 --- a/pymdp/jax/inference.py +++ b/pymdp/jax/inference.py @@ -2,9 +2,16 @@ # -*- coding: utf-8 -*- # pylint: disable=no-member -from .algos import run_vanilla_fpi +from .algos import run_vanilla_fpi, run_mmp, run_vmp, run_online_filtering -def update_posterior_states(A, obs, prior=None, num_iter=16): +def update_posterior_states(A, B, obs, prior=None, num_iter=16, method='vmp'): - return run_vanilla_fpi(A, obs, prior, num_iter=num_iter) + if method == 'fpi': + return run_vanilla_fpi(A, obs, prior, num_iter=num_iter) + if method == 'vmp': + return run_vmp(A, B, obs, prior, A_dependencies, num_iter=num_iter) + if method == 'mmp': + return run_mmp(A, B, obs, prior, A_dependencies, num_iter=num_iter) + if method == "ovf": + return run_online_filtering(A, B, obs, prior, A_dependencies, num_iter=num_iter) From ef45cf425706b7ede66994b434280ac1e76ccedf Mon Sep 17 00:00:00 2001 From: conorheins Date: Tue, 12 Sep 2023 17:08:37 +0200 Subject: [PATCH 123/232] unit test for @dimarkov's online variational filtering implementation, working for both sparse and full A matrix dependency graphs --- test/test_message_passing_jax.py | 94 ++++++++++++++++++++++++++++++++ 1 file changed, 94 insertions(+) diff --git a/test/test_message_passing_jax.py b/test/test_message_passing_jax.py index 7358fbcc..cccd9212 100644 --- a/test/test_message_passing_jax.py +++ b/test/test_message_passing_jax.py @@ -15,6 +15,7 @@ from pymdp.jax.algos import run_vanilla_fpi as fpi_jax from pymdp.jax.algos import run_factorized_fpi as fpi_jax_factorized +from pymdp.jax.algos import update_variational_filtering as ovf_jax from pymdp.algos import run_vanilla_fpi as fpi_numpy from pymdp.algos import run_mmp as mmp_numpy from pymdp.jax.algos import run_mmp as mmp_jax @@ -461,6 +462,99 @@ def test_sparse(action_sequence): for f in range(len(qs_full)): self.assertTrue(jnp.allclose(qs_full[f], qs_reduced[f])) + + def test_online_variational_filtering(self): + """ Unit test for @dimarkov's implementation of online variational filtering, also where it's conditional on actions (vmapped across policies) """ + + num_states_list = [ + [2, 2, 5], + [2, 2, 2], + [4, 4] + ] + + num_controls_list = [ + [2, 1, 3], + [2, 1, 2], + [1, 3] + ] + + num_obs_list = [ + [5, 10], + [4, 3, 2], + [5, 2, 6, 3] + ] + + A_dependencies_list = [ + [[0, 1], [1, 2]], + [[0], [1], [2]], + [[0,1], [1], [0], [1]], + ] + + batch_dim, T = 13, 4 # batch dimension (e.g. number of agents, parallel realizations, etc.) and time steps + n_policies = 3 + + for (num_states, A_dependencies, num_controls, num_obs) in zip(num_states_list, A_dependencies_list, num_controls_list, num_obs_list): + + A_reduced_numpy = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_dependencies) + A_reduced = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(A_reduced_numpy)) + + A_full_numpy = [] + for m, no in enumerate(num_obs): + other_factors = list(set(range(len(num_states))) - set(A_dependencies[m])) # list of the factors that modality `m` does not depend on + + # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` + expanded_dims = [no] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] + tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] + A_full_numpy.append(np.tile(A_reduced_numpy[m].reshape(expanded_dims), tile_dims)) + + A_full = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(A_full_numpy)) + + B_numpy = utils.random_B_matrix(num_states, num_controls) + B = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(B_numpy)) + + prior_numpy = utils.random_single_categorical(num_states) + prior = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(prior_numpy)) + + # initialization observation sequences in jax + obs_seq = [] + for n_obs in num_obs: + obs_ints = np.random.randint(0, high=n_obs, size=(T,1)) + obs_array_mod_i = jnp.broadcast_to(nn.one_hot(obs_ints, num_classes=n_obs), (T, batch_dim, n_obs)) + obs_seq.append(obs_array_mod_i) + + # create random policies + policies = [] + for n_controls in num_controls: + policies.append(jnp.array(np.random.randint(0, high=n_controls, size=(n_policies, T-1)))) + + def test_sparse(action_sequence): + B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(3, 0, 1, 2), B, action_sequence) + qs, ps, qss = ovf_jax(obs_seq, A_reduced, B_policy, prior, A_dependencies) + return qs, ps, qss + + qs_pi_sparse, ps_pi_sparse, qss_pi_sparse = vmap(test_sparse)(policies) + + for f, (qs, ps, qss) in enumerate(zip(qs_pi_sparse, ps_pi_sparse, qss_pi_sparse)): + self.assertTrue(qs.shape == (n_policies, batch_dim, num_states[f])) + self.assertTrue(ps.shape == (n_policies, batch_dim, num_states[f])) + self.assertTrue(qss.shape == (n_policies, T, batch_dim, num_states[f], num_states[f])) + + #Note: qs/ps are of dimension [n_policies x num_agents x dim_state_f] * num_factors + #Note: qss is of dimension [n_policies x time_steps x num_agents x dim_state_f x dim_state_f] * num_factors + + def test_full(action_sequence): + B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(3, 0, 1, 2), B, action_sequence) + dependencies_fully_connected = [list(range(len(num_states))) for _ in range(len(num_obs))] + qs, ps, qss = ovf_jax(obs_seq, A_full, B_policy, prior, dependencies_fully_connected) + return qs, ps, qss + + qs_pi_full, ps_pi_full, qss_pi_full = vmap(test_full)(policies) + + # test that the sparse and fully connected versions of OVF give the same results + for (qs_sparse, ps_sparse, qss_sparse, qs_full, ps_full, qss_full) in zip(qs_pi_sparse, ps_pi_sparse, qss_pi_sparse, qs_pi_full, ps_pi_full, qss_pi_full): + self.assertTrue(np.allclose(qs_sparse, qs_full)) + self.assertTrue(np.allclose(ps_sparse, ps_full)) + self.assertTrue(np.allclose(qss_sparse, qss_full)) if __name__ == "__main__": unittest.main() From 6624134170149747f5c7f34c47fee9cf659b3379 Mon Sep 17 00:00:00 2001 From: conorheins Date: Tue, 12 Sep 2023 18:07:44 +0200 Subject: [PATCH 124/232] Integrating online-variatonal filtering into agent loop with actions / observations (result of livecoding session with @dimarkov) --- examples/building_up_agent_loop.ipynb | 60 ++++++++ examples/test_ovf.ipynb | 194 -------------------------- pymdp/jax/agent.py | 34 +++-- pymdp/jax/algos.py | 2 +- pymdp/jax/control.py | 13 ++ pymdp/jax/inference.py | 7 +- 6 files changed, 105 insertions(+), 205 deletions(-) delete mode 100644 examples/test_ovf.ipynb diff --git a/examples/building_up_agent_loop.ipynb b/examples/building_up_agent_loop.ipynb index 06328933..70a9df48 100644 --- a/examples/building_up_agent_loop.ipynb +++ b/examples/building_up_agent_loop.ipynb @@ -1,5 +1,65 @@ { "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def scan(f, init, xs, length=None):\n", + " if xs is None:\n", + " xs = [None] * length\n", + " carry = init\n", + " ys = []\n", + " for x in xs:\n", + " carry, y = f(carry, x)\n", + " ys.append(y)\n", + " \n", + " return carry, jnp.stack(ys)\n", + "\n", + "def evolve_trials(agent, env, block_idx, num_timesteps):\n", + "\n", + " def step_fn(carry, xs):\n", + " actions = carry['actions']\n", + " outcomes = carry['outcomes']\n", + " beliefs = agent.infer_states(outcomes, actions, *carry['args'])\n", + " q_pi, _ = agent.infer_policies(beliefs)\n", + " actions_t = agent.sample_action(q_pi)\n", + "\n", + " outcome_t = env.step(actions_t)\n", + " outcomes = jtu.tree_map(lambda prev_o, new_o: jnp.stack([prev_o, jnp.expand_dims(new_o, 0)], 0), outcomes, outcome_t)\n", + "\n", + " actions = jnp.stack([actions, jnp.expand_dims(actions_t, 0)], 0) if actions is not None else actions_t\n", + " args = agent.update_empirical_prior(actions_t, beliefs)\n", + " # (pred, [cond_1, ..., cond_{t-1}])\n", + "\n", + " # ovf beliefs = (post_T, [cond_1, cond_2, ..., cond_{T-1}])\n", + " # else beliefs = (post_T, post_{T-1}, ..., post_1)\n", + " return {'args': args, 'outcomes': outcomes, 'beliefs': beliefs, 'actions': actions}, None\n", + "\n", + " outcome_0 = env.step()\n", + " init = ((agent.D, None), outcome_0, None, None)\n", + " last, _ = scan(step_fn, init, range(num_timesteps))\n", + "\n", + " return last, env\n", + "\n", + "def step_fn(carry, block_idx):\n", + " agent, env = carry\n", + " output, env = evolve_trials(agent, env, block_idx, num_timesteps)\n", + "\n", + " # How to deal with contiguous blocks of trials? Two options we can imagine: \n", + " # A) you use final posterior (over current and past timesteps) to compute the smoothing distribution over qs_{t=0} and update pD, and then pass pD as the initial state prior ($D = \\mathbb{E}_{pD}[qs_{t=0}]$);\n", + " # B) we don't assume that blocks 'reset time', and are really just adjacent chunks of one long sequence, so you set the initial state prior to be the final output (`output['beliefs']`) passed through\n", + " # the transition model entailed by the action taken at the last timestep of the previous block.\n", + " \n", + " agent = agent.learning(**output)\n", + " \n", + " return (agent, env), output\n", + "\n", + "init = (agent, env)\n", + "agent, squences = scan(step_fn, init, range(num_blocks) )" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/examples/test_ovf.ipynb b/examples/test_ovf.ipynb deleted file mode 100644 index a2fc5f24..00000000 --- a/examples/test_ovf.ipynb +++ /dev/null @@ -1,194 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np \n", - "import jax.numpy as jnp\n", - "import jax.tree_util as jtu\n", - "\n", - "from jax import nn, vmap\n", - "from pymdp.jax.algos import update_variational_filtering\n", - "from pymdp import utils" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "num_states_list = [ \n", - " [2, 2, 5],\n", - " [2, 2, 2],\n", - " [4, 4]\n", - "]\n", - "\n", - "num_controls_list = [\n", - " [2, 1, 3],\n", - " [2, 1, 2],\n", - " [1, 3]\n", - "]\n", - "\n", - "num_obs_list = [\n", - " [5, 10],\n", - " [4, 3, 2],\n", - " [5, 2, 6, 3]\n", - "]\n", - "\n", - "A_dependencies_list = [\n", - " [[0, 1], [1, 2]],\n", - " [[0], [1], [2]],\n", - " [[0,1], [1], [0], [1]]\n", - "]\n", - "\n", - "batch_dim, T = 13, 4 # batch dimension (e.g. number of agents, parallel realizations, etc.) and time steps\n", - "n_policies = 3" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(3, 13, 2) (3, 13, 2) (3, 4, 13, 2, 2)\n", - "(3, 13, 2) (3, 13, 2) (3, 4, 13, 2, 2)\n", - "(3, 13, 5) (3, 13, 5) (3, 4, 13, 5, 5)\n", - "(3, 13, 2) (3, 13, 2) (3, 4, 13, 2, 2)\n", - "(3, 13, 2) (3, 13, 2) (3, 4, 13, 2, 2)\n", - "(3, 13, 2) (3, 13, 2) (3, 4, 13, 2, 2)\n", - "(3, 13, 4) (3, 13, 4) (3, 4, 13, 4, 4)\n", - "(3, 13, 4) (3, 13, 4) (3, 4, 13, 4, 4)\n" - ] - } - ], - "source": [ - "for (num_states, A_dependencies, num_controls, num_obs) in zip(num_states_list, A_dependencies_list, num_controls_list, num_obs_list):\n", - " \n", - " A_reduced_numpy = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_dependencies)\n", - " A_reduced = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(A_reduced_numpy))\n", - " \n", - " A_full_numpy = []\n", - " for m, no in enumerate(num_obs):\n", - " other_factors = list(set(range(len(num_states))) - set(A_dependencies[m])) # list of the factors that modality `m` does not depend on\n", - "\n", - " # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors`\n", - " expanded_dims = [no] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)]\n", - " tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)]\n", - " A_full_numpy.append(np.tile(A_reduced_numpy[m].reshape(expanded_dims), tile_dims))\n", - " \n", - " A_full = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(A_full_numpy))\n", - "\n", - " B_numpy = utils.random_B_matrix(num_states, num_controls)\n", - " B = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(B_numpy))\n", - "\n", - " prior_numpy = utils.random_single_categorical(num_states)\n", - " prior = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(prior_numpy))\n", - " \n", - " # initialization observation sequences in jax\n", - " obs_seq = []\n", - " for n_obs in num_obs:\n", - " obs_ints = np.random.randint(0, high=n_obs, size=(T,1))\n", - " obs_array_mod_i = jnp.broadcast_to(nn.one_hot(obs_ints, num_classes=n_obs), (T, batch_dim, n_obs))\n", - " obs_seq.append(obs_array_mod_i)\n", - "\n", - " # create random policies\n", - " policies = []\n", - " for n_controls in num_controls:\n", - " policies.append(jnp.array(np.random.randint(0, high=n_controls, size=(n_policies, T-1))))\n", - "\n", - " def test_sparse(action_sequence):\n", - " B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(3, 0, 1, 2), B, action_sequence)\n", - " qs, ps, qss = update_variational_filtering(obs_seq, A_reduced, B_policy, prior, A_dependencies)\n", - " return qs, ps, qss\n", - "\n", - " qs_pi, ps_pi, qss_pi = vmap(test_sparse)(policies)\n", - "\n", - " for qs, ps, qss in zip(qs_pi, ps_pi, qss_pi):\n", - " print(qs.shape, ps.shape, qss.shape)\n", - "\n", - "#Note: qs is of dimension [num_actions x num_agents x dim_state_f] * num_factors\n", - "#Note: qss is of dimension [num_actions x time_steps x num_agents x dim_state_f x dim_state_f] * num_factors" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Array([0.53155464, 0.35527015, 0.11002955, 0.00314568], dtype=float32)" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "qs_pi[0][0, 0]" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Array([[0.0357749 , 0.6993571 , 0.23594394, 0.02892413],\n", - " [0.42679253, 0.24267888, 0.28946787, 0.04106063],\n", - " [0.10010052, 0.7042426 , 0.16021933, 0.03543761],\n", - " [0.03736041, 0.56587505, 0.37230095, 0.02446355]], dtype=float32)" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "qss_pi[0][0, 0, 0]" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "befit", - "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.11.3" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 89655518..eaa056a2 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -143,7 +143,7 @@ def learning(self, *args, **kwargs): raise NotImplementedError @vmap - def infer_states(self, observations, past_actions, empirical_prior): + def infer_states(self, observations, past_actions, empirical_prior, *args): """ Update approximate posterior over hidden states by solving variational inference problem, given an observation. @@ -154,8 +154,8 @@ def infer_states(self, observations, past_actions, empirical_prior): past_actions: ``list`` or ``tuple`` of ints The action input. Each entry ``past_actions[f]`` stores indices (or one-hots?) representing the actions for control factor ``f``. empirical_prior: ``list`` or ``tuple`` of ``jax.numpy.ndarray`` of dtype object - Empirical prior beliefs over hidden states. Depending on the inference algorithm chosen, the resulting ``empirical_prior`` variable will have additional sub-structure to reflect whether - + Empirical prior beliefs over hidden states. Depending on the inference algorithm chosen, the resulting ``empirical_prior`` variable may be a matrix (or list of matrices) + of additional dimensions to encode extra conditioning variables like timepoint and policy. Returns --------- qs: ``numpy.ndarray`` of dtype object @@ -167,20 +167,38 @@ def infer_states(self, observations, past_actions, empirical_prior): """ o_vec = [nn.one_hot(o, self.A[i].shape[0]) for i, o in enumerate(observations)] - qs = inference.update_posterior_states( + output = inference.update_posterior_states( self.A, self.B, o_vec, prior=empirical_prior, - num_iter=self.num_iter + A_dependencies=self.A_dependencies, + num_iter=self.num_iter, + method=self.method ) - return qs + return output @vmap - def update_empirical_prior(self, action, qs): + def update_empirical_prior(self, action, beliefs): # return empirical_prior - return control.compute_expected_state(qs, self.B, action) + qs = beliefs[0] + + # @TODO -- have this be handled within the single compute_expected_state function, rahter than have two functions + pred = control.compute_expected_state(qs, self.B, action) + if self.inference_algo == 'ovf': + pred, Bs = control.compute_expected_state_and_Bs(qs, self.B, action) + # compute reverse conditional distribution q(z_t|z_{t+1}) + cond = jtu.tree_map( + lambda x, y, z: x * jnp.expand_dims(y, -2) / jnp.expand_dims(z, -1), + Bs, + qs, + pred + ) + beliefs[1].append(cond) + return (pred, beliefs[1]) + else: + pred @vmap def infer_policies(self, qs: List): diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index cb88eefb..42e6b985 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -287,7 +287,7 @@ def run_mmp(A, B, obs, prior, A_dependencies, num_iter=1, tau=1.): return qs def run_online_filtering(A, B, obs, prior, A_dependencies, num_iter=1, tau=1.): - """Runs online filtering (and smoothin) correponsing to belief propagation""" + """Runs online filtering (HAVE TO REPLACE WITH OVF CODE)""" qs = update_marginals(get_mmp_messages, obs, A, B, prior, A_dependencies, num_iter=num_iter, tau=tau) return qs diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index 5e95ba52..74055079 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -152,6 +152,19 @@ def compute_expected_state(qs_prior, B, u_t): return qs_next +def compute_expected_state_and_Bs(qs_prior, B, u_t): + """ + Compute posterior over next state, given belief about previous state, transition model and action... + """ + assert len(u_t) == len(B) + qs_next = [] + Bs = [] + for qs_f, B_f, u_f in zip(qs_prior, B, u_t): + qs_next.append( B_f[..., u_f].dot(qs_f) ) + Bs.append(B_f[..., u_f]) + + return qs_next, Bs + def factor_dot(A, qs): """ Dot product of a multidimensional array with `x`. diff --git a/pymdp/jax/inference.py b/pymdp/jax/inference.py index d4145b42..73ccd9b4 100644 --- a/pymdp/jax/inference.py +++ b/pymdp/jax/inference.py @@ -12,6 +12,9 @@ def update_posterior_states(A, B, obs, prior=None, A_dependencies=None, num_iter return run_vmp(A, B, obs, prior, A_dependencies, num_iter=num_iter) if method == 'mmp': return run_mmp(A, B, obs, prior, A_dependencies, num_iter=num_iter) - if method == "ovf": - return run_online_filtering(A, B, obs, prior, A_dependencies, num_iter=num_iter) + # if method == "ovf": + # prior, cond_prev = prior[0], prior[1] + # qs, pred, cond = run_online_filtering(A, B, obs, prior, cond_prev, A_dependencies, num_iter=num_iter) + # cond = [cond, cond_prev] + # return qs, pred, cond From 1a3838a3f954ed1ba288a2ffe4e524fa1fe25b3c Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 21 Sep 2023 18:07:03 +0200 Subject: [PATCH 125/232] changed comments in building_up_agent_loop.ipynb to reflect current data structures --- examples/building_up_agent_loop.ipynb | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/examples/building_up_agent_loop.ipynb b/examples/building_up_agent_loop.ipynb index 70a9df48..fdc95110 100644 --- a/examples/building_up_agent_loop.ipynb +++ b/examples/building_up_agent_loop.ipynb @@ -30,11 +30,9 @@ " outcomes = jtu.tree_map(lambda prev_o, new_o: jnp.stack([prev_o, jnp.expand_dims(new_o, 0)], 0), outcomes, outcome_t)\n", "\n", " actions = jnp.stack([actions, jnp.expand_dims(actions_t, 0)], 0) if actions is not None else actions_t\n", - " args = agent.update_empirical_prior(actions_t, beliefs)\n", - " # (pred, [cond_1, ..., cond_{t-1}])\n", - "\n", - " # ovf beliefs = (post_T, [cond_1, cond_2, ..., cond_{T-1}])\n", - " # else beliefs = (post_T, post_{T-1}, ..., post_1)\n", + " args = agent.update_empirical_prior(actions_t, beliefs[0])\n", + " # args = (pred_{t+1}, [post_1, post_{2}, ..., post_{t}])\n", + " # beliefs = [post_1, post_{2}, ..., post_{t}]\n", " return {'args': args, 'outcomes': outcomes, 'beliefs': beliefs, 'actions': actions}, None\n", "\n", " outcome_0 = env.step()\n", From 699e03ae690891ba41ac2ab3e04e34caf1bc5d5f Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 21 Sep 2023 18:07:38 +0200 Subject: [PATCH 126/232] changed methods of agent (infer_stsates and update_empirical_prior) to accommodate new data structure for beliefs and args, within the agent_loop --- pymdp/jax/agent.py | 28 ++++++++-------------------- 1 file changed, 8 insertions(+), 20 deletions(-) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index eaa056a2..318ca73b 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -171,7 +171,8 @@ def infer_states(self, observations, past_actions, empirical_prior, *args): self.A, self.B, o_vec, - prior=empirical_prior, + prior=empirical_prior[0], + qs_hist=empirical_prior[1], A_dependencies=self.A_dependencies, num_iter=self.num_iter, method=self.method @@ -180,25 +181,12 @@ def infer_states(self, observations, past_actions, empirical_prior, *args): return output @vmap - def update_empirical_prior(self, action, beliefs): - # return empirical_prior - qs = beliefs[0] - - # @TODO -- have this be handled within the single compute_expected_state function, rahter than have two functions - pred = control.compute_expected_state(qs, self.B, action) - if self.inference_algo == 'ovf': - pred, Bs = control.compute_expected_state_and_Bs(qs, self.B, action) - # compute reverse conditional distribution q(z_t|z_{t+1}) - cond = jtu.tree_map( - lambda x, y, z: x * jnp.expand_dims(y, -2) / jnp.expand_dims(z, -1), - Bs, - qs, - pred - ) - beliefs[1].append(cond) - return (pred, beliefs[1]) - else: - pred + def update_empirical_prior(self, action, qs): + # return empirical_prior, and the history of posterior beliefs (filtering distributions) held about hidden states at times 1, 2 ... t + + pred = control.compute_expected_state(qs[-1], self.B, action) + + return (pred, qs) @vmap def infer_policies(self, qs: List): From 3374f38504ca0d64f4a7c675b3162e0a252e33f3 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 21 Sep 2023 18:07:58 +0200 Subject: [PATCH 127/232] renamed `factor_lists` to `A_dependencies` in `algos.run_factorize_fpi` --- pymdp/jax/algos.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index 42e6b985..ade3a305 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -78,9 +78,9 @@ def scan_fn(carry, t): qs = jtu.tree_map(nn.softmax, res) return qs -def run_factorized_fpi(A, obs, prior, factor_lists, num_iter=1): +def run_factorized_fpi(A, obs, prior, A_dependencies, num_iter=1): """ - Run the fixed point iteration algorithm with sparse dependencies between factors and outcomes (stored in `factor_lists`) + Run the fixed point iteration algorithm with sparse dependencies between factors and outcomes (stored in `A_dependencies`) """ nf = len(prior) @@ -96,7 +96,7 @@ def run_factorized_fpi(A, obs, prior, factor_lists, num_iter=1): def scan_fn(carry, t): log_q = carry q = jtu.tree_map(nn.softmax, log_q) - marginal_ll = all_marginal_log_likelihood(q, log_likelihoods, factor_lists) + marginal_ll = all_marginal_log_likelihood(q, log_likelihoods, A_dependencies) log_q = jtu.tree_map(add, marginal_ll, log_prior) return log_q, None From b018b8d0f1240d9e5e6b3ea0ba99e8f3ad466441 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 21 Sep 2023 18:08:31 +0200 Subject: [PATCH 128/232] when method for inference == `fpi` or `ovf`, we append the history of beliefs to a growing list over time, to make it consistent with data structures used in VMP and MMP --- pymdp/jax/inference.py | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-) diff --git a/pymdp/jax/inference.py b/pymdp/jax/inference.py index 73ccd9b4..d625399e 100644 --- a/pymdp/jax/inference.py +++ b/pymdp/jax/inference.py @@ -2,19 +2,15 @@ # -*- coding: utf-8 -*- # pylint: disable=no-member -from .algos import run_vanilla_fpi, run_mmp, run_vmp, run_online_filtering +from .algos import run_factorized_fpi, run_mmp, run_vmp -def update_posterior_states(A, B, obs, prior=None, A_dependencies=None, num_iter=16, method='fpi'): +def update_posterior_states(A, B, obs, prior=None, qs_hist=None, A_dependencies=None, num_iter=16, method='fpi'): - if method == 'fpi': - return run_vanilla_fpi(A, obs, prior, num_iter=num_iter) + if method == 'fpi' or method == "ovf": + qs = run_factorized_fpi(A, obs, prior, A_dependencies, num_iter=num_iter) + return qs_hist.append(qs) if method == 'vmp': return run_vmp(A, B, obs, prior, A_dependencies, num_iter=num_iter) if method == 'mmp': return run_mmp(A, B, obs, prior, A_dependencies, num_iter=num_iter) - # if method == "ovf": - # prior, cond_prev = prior[0], prior[1] - # qs, pred, cond = run_online_filtering(A, B, obs, prior, cond_prev, A_dependencies, num_iter=num_iter) - # cond = [cond, cond_prev] - # return qs, pred, cond From 94a826c7dab391df0d0d1920fea7b2bd80f7b81f Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 28 Sep 2023 17:34:57 +0200 Subject: [PATCH 129/232] -pass `past_actions` into inference.update_posterior_states() - format the outputs of all message passing schemes in `update_posterior_states()` they have a common data structure (list of inferences over simulation time) - simplified agent loop in demo/scratchpad notebook in order to test that `agent.infer_states()` works properly Co-authored-by: Dimitrije Markovic --- examples/building_up_agent_loop.ipynb | 162 +++++++++++++++++--------- pymdp/jax/agent.py | 1 + pymdp/jax/inference.py | 25 ++-- 3 files changed, 122 insertions(+), 66 deletions(-) diff --git a/examples/building_up_agent_loop.ipynb b/examples/building_up_agent_loop.ipynb index fdc95110..70989bbb 100644 --- a/examples/building_up_agent_loop.ipynb +++ b/examples/building_up_agent_loop.ipynb @@ -2,7 +2,21 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import jax\n", + "import jax.numpy as jnp\n", + "import jax.tree_util as jtu\n", + "from jax import random as jr\n", + "from pymdp.jax.agent import Agent as AIFAgent\n", + "from pymdp.utils import random_A_matrix, random_B_matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -23,14 +37,16 @@ " actions = carry['actions']\n", " outcomes = carry['outcomes']\n", " beliefs = agent.infer_states(outcomes, actions, *carry['args'])\n", - " q_pi, _ = agent.infer_policies(beliefs)\n", + " # q_pi, _ = agent.infer_policies(beliefs)\n", + " q_pi = jnp.ones((1, len(agent.policies)))/len(agent.policies)\n", " actions_t = agent.sample_action(q_pi)\n", "\n", " outcome_t = env.step(actions_t)\n", " outcomes = jtu.tree_map(lambda prev_o, new_o: jnp.stack([prev_o, jnp.expand_dims(new_o, 0)], 0), outcomes, outcome_t)\n", "\n", " actions = jnp.stack([actions, jnp.expand_dims(actions_t, 0)], 0) if actions is not None else actions_t\n", - " args = agent.update_empirical_prior(actions_t, beliefs[0])\n", + " # args = agent.update_empirical_prior(actions_t, beliefs[0])\n", + " args = (beliefs[0][-1], beliefs[0])\n", " # args = (pred_{t+1}, [post_1, post_{2}, ..., post_{t}])\n", " # beliefs = [post_1, post_{2}, ..., post_{t}]\n", " return {'args': args, 'outcomes': outcomes, 'beliefs': beliefs, 'actions': actions}, None\n", @@ -54,8 +70,37 @@ " \n", " return (agent, env), output\n", "\n", - "init = (agent, env)\n", - "agent, squences = scan(step_fn, init, range(num_blocks) )" + "# define an agent and environment here\n", + "batch_size = 10\n", + "num_obs = [3, 3]\n", + "num_states = [3, 3]\n", + "num_controls = [2, 2]\n", + "num_blocks = 2\n", + "num_timesteps = 5\n", + "\n", + "A_np = random_A_matrix(num_obs=num_obs, num_states=num_states)\n", + "B_np = random_B_matrix(num_states=num_states, num_controls=num_controls)\n", + "A = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_size,) + x.shape), list(A_np))\n", + "B = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_size,) + x.shape), list(B_np))\n", + "C = [jnp.zeros((batch_size, no)) for no in num_obs]\n", + "D = [jnp.ones((batch_size, ns)) / ns for ns in num_states]\n", + "E = jnp.ones((batch_size, 4 )) / 4 \n", + "\n", + "class TestEnv:\n", + " def __init__(self, num_obs, prng_key=jr.PRNGKey(0)):\n", + " self.num_obs=num_obs\n", + " self.key = prng_key\n", + " def step(self, actions=None):\n", + " # return a list of random observations for each agent or parallel realization (each entry in batch_dim)\n", + " obs = [jr.randint(self.key, 0, no, (batch_size,)) for no in self.num_obs]\n", + " self.key, _ = jr.split(self.key)\n", + " return obs\n", + "\n", + "agents = AIFAgent(A, B, C, D, E)\n", + "env = TestEnv(num_obs)\n", + "\n", + "init = (agents, env)\n", + "agent, sequences = scan(step_fn, init, range(num_blocks) )\n" ] }, { @@ -64,77 +109,78 @@ "metadata": {}, "outputs": [], "source": [ - "import jax\n", - "import jax.numpy as jnp\n", - "import jax.tree_util as jtu\n", - "from jax import random as jr\n", - "from pymdp.jax.agent import Agent as AIFAgent" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def scan(f, init, xs, length=None):\n", - " if xs is None:\n", - " xs = [None] * length\n", - " carry = init\n", - " ys = []\n", - " for x in xs:\n", - " carry, y = f(carry, x)\n", - " ys.append(y)\n", + "# def scan(f, init, xs, length=None):\n", + "# if xs is None:\n", + "# xs = [None] * length\n", + "# carry = init\n", + "# ys = []\n", + "# for x in xs:\n", + "# carry, y = f(carry, x)\n", + "# ys.append(y)\n", " \n", - " return carry, jnp.stack(ys)\n", + "# return carry, jnp.stack(ys)\n", "\n", - "def evolve_trials(agent, env, block_idx, num_timesteps):\n", + "# def evolve_trials(agent, env, block_idx, num_timesteps):\n", "\n", - " def step_fn(carry, xs):\n", - " actions = carry['actions']\n", - " outcomes = carry['outcomes']\n", - " beliefs = agent.infer_states(outcomes, actions, *carry['args'])\n", - " q_pi, _ = agent.infer_policies(beliefs)\n", - " actions_t = agent.sample_action(q_pi)\n", + "# def step_fn(carry, xs):\n", + "# actions = carry['actions']\n", + "# outcomes = carry['outcomes']\n", + "# beliefs = agent.infer_states(outcomes, actions, *carry['args'])\n", + "# q_pi, _ = agent.infer_policies(beliefs)\n", + "# actions_t = agent.sample_action(q_pi)\n", "\n", - " outcome_t = env.step(actions_t)\n", - " outcomes = jtu.tree_map(lambda prev_o, new_o: jnp.stack([prev_o, jnp.expand_dims(new_o, 0)], 0), outcomes, outcome_t)\n", + "# outcome_t = env.step(actions_t)\n", + "# outcomes = jtu.tree_map(lambda prev_o, new_o: jnp.stack([prev_o, jnp.expand_dims(new_o, 0)], 0), outcomes, outcome_t)\n", "\n", - " actions = jnp.stack([actions, jnp.expand_dims(actions_t, 0)], 0) if actions is not None else actions_t\n", - " args = agent.update_empirical_prior(actions_t, beliefs)\n", - " # (pred, [cond_1, ..., cond_{t-1}])\n", + "# actions = jnp.stack([actions, jnp.expand_dims(actions_t, 0)], 0) if actions is not None else actions_t\n", + "# args = agent.update_empirical_prior(actions_t, beliefs)\n", + "# # (pred, [cond_1, ..., cond_{t-1}])\n", "\n", - " # ovf beliefs = (post_T, [cond_1, cond_2, ..., cond_{T-1}])\n", - " # else beliefs = (post_T, post_{T-1}, ..., post_1)\n", - " return {'args': args, 'outcomes': outcomes, 'beliefs': beliefs, 'actions': actions}, None\n", + "# # ovf beliefs = (post_T, [cond_1, cond_2, ..., cond_{T-1}])\n", + "# # else beliefs = (post_T, post_{T-1}, ..., post_1)\n", + "# return {'args': args, 'outcomes': outcomes, 'beliefs': beliefs, 'actions': actions}, None\n", "\n", - " outcome_0 = env.step()\n", - " init = ((agent.D, None), outcome_0, None, None)\n", - " last, _ = scan(step_fn, init, range(num_timesteps))\n", + "# outcome_0 = env.step()\n", + "# init = ((agent.D, None), outcome_0, None, None)\n", + "# last, _ = scan(step_fn, init, range(num_timesteps))\n", "\n", - " return last, env\n", + "# return last, env\n", "\n", - "def step_fn(carry, block_idx):\n", - " agent, env = carry\n", - " output, env = evolve_trials(agent, env, block_idx, num_timesteps)\n", + "# def step_fn(carry, block_idx):\n", + "# agent, env = carry\n", + "# output, env = evolve_trials(agent, env, block_idx, num_timesteps)\n", "\n", - " # How to deal with contiguous blocks of trials? Two options we can imagine: \n", - " # A) you use final posterior (over current and past timesteps) to compute the smoothing distribution over qs_{t=0} and update pD, and then pass pD as the initial state prior ($D = \\mathbb{E}_{pD}[qs_{t=0}]$);\n", - " # B) we don't assume that blocks 'reset time', and are really just adjacent chunks of one long sequence, so you set the initial state prior to be the final output (`output['beliefs']`) passed through\n", - " # the transition model entailed by the action taken at the last timestep of the previous block.\n", + "# # How to deal with contiguous blocks of trials? Two options we can imagine: \n", + "# # A) you use final posterior (over current and past timesteps) to compute the smoothing distribution over qs_{t=0} and update pD, and then pass pD as the initial state prior ($D = \\mathbb{E}_{pD}[qs_{t=0}]$);\n", + "# # B) we don't assume that blocks 'reset time', and are really just adjacent chunks of one long sequence, so you set the initial state prior to be the final output (`output['beliefs']`) passed through\n", + "# # the transition model entailed by the action taken at the last timestep of the previous block.\n", " \n", - " agent = agent.learning(**output)\n", + "# agent = agent.learning(**output)\n", " \n", - " return (agent, env), output\n", + "# return (agent, env), output\n", "\n", - "init = (agent, env)\n", - "agent, squences = scan(step_fn, init, range(num_blocks) )" + "# init = (agent, env)\n", + "# agent, squences = scan(step_fn, init, range(num_blocks) )" ] } ], "metadata": { + "kernelspec": { + "display_name": "jax_pymdp_test", + "language": "python", + "name": "python3" + }, "language_info": { - "name": "python" + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" }, "orig_nbformat": 4 }, diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 318ca73b..0e7b0a6b 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -171,6 +171,7 @@ def infer_states(self, observations, past_actions, empirical_prior, *args): self.A, self.B, o_vec, + past_actions, prior=empirical_prior[0], qs_hist=empirical_prior[1], A_dependencies=self.A_dependencies, diff --git a/pymdp/jax/inference.py b/pymdp/jax/inference.py index d625399e..2a5effaf 100644 --- a/pymdp/jax/inference.py +++ b/pymdp/jax/inference.py @@ -3,14 +3,23 @@ # pylint: disable=no-member from .algos import run_factorized_fpi, run_mmp, run_vmp +from jax import tree_util as jtu -def update_posterior_states(A, B, obs, prior=None, qs_hist=None, A_dependencies=None, num_iter=16, method='fpi'): +def update_posterior_states(A, B, obs, past_actions, prior=None, qs_hist=None, A_dependencies=None, num_iter=16, method='fpi'): if method == 'fpi' or method == "ovf": - qs = run_factorized_fpi(A, obs, prior, A_dependencies, num_iter=num_iter) - return qs_hist.append(qs) - if method == 'vmp': - return run_vmp(A, B, obs, prior, A_dependencies, num_iter=num_iter) - if method == 'mmp': - return run_mmp(A, B, obs, prior, A_dependencies, num_iter=num_iter) - + # format obs to select only last observation + curr_obs = jtu.tree_map(lambda x: x[-1], obs) + qs = run_factorized_fpi(A, curr_obs, prior, A_dependencies, num_iter=num_iter) + else: + # format B matrices using action sequences here + B = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(3, 0, 1, 2), B, past_actions) # assumes there is a batch dimension + + # outputs of both VMP and MMP should be a list of hidden state factors, where each qs[f].shape = (T, batch_dim, num_states_f) + if method == 'vmp': + qs = run_vmp(A, B, obs, prior, A_dependencies, num_iter=num_iter) + if method == 'mmp': + qs = run_mmp(A, B, obs, prior, A_dependencies, num_iter=num_iter) + + return qs_hist.append(qs) + From b9e49d1b7ccd68b1308bd585df20e35cb7df32ed Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Fri, 29 Sep 2023 12:56:06 +0200 Subject: [PATCH 130/232] updated agent and algos for the inference loop to work --- examples/building_up_agent_loop.ipynb | 46 ++++++++++++++++++--------- pymdp/jax/agent.py | 22 +++++++++---- pymdp/jax/inference.py | 11 +++++-- 3 files changed, 56 insertions(+), 23 deletions(-) diff --git a/examples/building_up_agent_loop.ipynb b/examples/building_up_agent_loop.ipynb index 70989bbb..c7a94e2e 100644 --- a/examples/building_up_agent_loop.ipynb +++ b/examples/building_up_agent_loop.ipynb @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -27,9 +27,11 @@ " ys = []\n", " for x in xs:\n", " carry, y = f(carry, x)\n", - " ys.append(y)\n", + " if y is not None:\n", + " ys.append(y)\n", " \n", - " return carry, jnp.stack(ys)\n", + " ys = None if len(ys) < 1 else jtu.tree_map(lambda *x: jnp.stack(x).swapaxes(1, 2), *ys)\n", + " return carry, ys\n", "\n", "def evolve_trials(agent, env, block_idx, num_timesteps):\n", "\n", @@ -38,21 +40,32 @@ " outcomes = carry['outcomes']\n", " beliefs = agent.infer_states(outcomes, actions, *carry['args'])\n", " # q_pi, _ = agent.infer_policies(beliefs)\n", - " q_pi = jnp.ones((1, len(agent.policies)))/len(agent.policies)\n", + " q_pi = jnp.ones((batch_size, len(agent.policies)))/len(agent.policies)\n", " actions_t = agent.sample_action(q_pi)\n", "\n", " outcome_t = env.step(actions_t)\n", - " outcomes = jtu.tree_map(lambda prev_o, new_o: jnp.stack([prev_o, jnp.expand_dims(new_o, 0)], 0), outcomes, outcome_t)\n", - "\n", - " actions = jnp.stack([actions, jnp.expand_dims(actions_t, 0)], 0) if actions is not None else actions_t\n", - " # args = agent.update_empirical_prior(actions_t, beliefs[0])\n", - " args = (beliefs[0][-1], beliefs[0])\n", + " outcomes = jtu.tree_map(\n", + " lambda prev_o, new_o: jnp.concatenate([prev_o, jnp.expand_dims(new_o, -1)], -1), outcomes, outcome_t\n", + " )\n", + "\n", + " if actions is not None:\n", + " actions = jnp.concatenate([actions, jnp.expand_dims(actions_t, -2)], -2)\n", + " else:\n", + " actions = jnp.expand_dims(actions_t, -2)\n", + " \n", + " # args = agent.update_empirical_prior(actions_t, beliefs)\n", + " args = (jtu.tree_map( lambda x: x[:, -1], beliefs), beliefs)\n", " # args = (pred_{t+1}, [post_1, post_{2}, ..., post_{t}])\n", " # beliefs = [post_1, post_{2}, ..., post_{t}]\n", " return {'args': args, 'outcomes': outcomes, 'beliefs': beliefs, 'actions': actions}, None\n", "\n", - " outcome_0 = env.step()\n", - " init = ((agent.D, None), outcome_0, None, None)\n", + " outcome_0 = jtu.tree_map(lambda x: jnp.expand_dims(x, -1), env.step())\n", + " init = {\n", + " 'args': (agent.D, None,),\n", + " 'outcomes': outcome_0, \n", + " 'beliefs': [],\n", + " 'actions': None\n", + " }\n", " last, _ = scan(step_fn, init, range(num_timesteps))\n", "\n", " return last, env\n", @@ -60,13 +73,14 @@ "def step_fn(carry, block_idx):\n", " agent, env = carry\n", " output, env = evolve_trials(agent, env, block_idx, num_timesteps)\n", + " output.pop('args') \n", "\n", " # How to deal with contiguous blocks of trials? Two options we can imagine: \n", " # A) you use final posterior (over current and past timesteps) to compute the smoothing distribution over qs_{t=0} and update pD, and then pass pD as the initial state prior ($D = \\mathbb{E}_{pD}[qs_{t=0}]$);\n", " # B) we don't assume that blocks 'reset time', and are really just adjacent chunks of one long sequence, so you set the initial state prior to be the final output (`output['beliefs']`) passed through\n", " # the transition model entailed by the action taken at the last timestep of the previous block.\n", " \n", - " agent = agent.learning(**output)\n", + " # agent = agent.learning(**output)\n", " \n", " return (agent, env), output\n", "\n", @@ -92,7 +106,7 @@ " self.key = prng_key\n", " def step(self, actions=None):\n", " # return a list of random observations for each agent or parallel realization (each entry in batch_dim)\n", - " obs = [jr.randint(self.key, 0, no, (batch_size,)) for no in self.num_obs]\n", + " obs = [jr.randint(self.key, (batch_size,), 0, no) for no in self.num_obs]\n", " self.key, _ = jr.split(self.key)\n", " return obs\n", "\n", @@ -100,7 +114,9 @@ "env = TestEnv(num_obs)\n", "\n", "init = (agents, env)\n", - "agent, sequences = scan(step_fn, init, range(num_blocks) )\n" + "(agents, env), sequences = scan(step_fn, init, range(num_blocks) )\n", + "\n", + "# NOTE: all elements of sequences will have dimensionality blocks, trials, batch_size, ...\n" ] }, { @@ -180,7 +196,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.4" + "version": "3.10.10" }, "orig_nbformat": 4 }, diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 0e7b0a6b..8764417c 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -41,8 +41,9 @@ class Agent(Module): gamma: jnp.ndarray qs: Optional[List] q_pi: Optional[List] - + # static parameters not leaves of the PyTree + A_dependencies: Optional[List] = static_field() num_iter: int = static_field() num_obs: List = static_field() num_modalities: int = static_field() @@ -65,6 +66,7 @@ def __init__( C, D, E, + A_dependencies=None, qs=None, q_pi=None, policy_len=1, @@ -75,7 +77,7 @@ def __init__( use_states_info_gain=True, use_param_info_gain=False, action_selection="deterministic", - inference_algo="VANILLA", + inference_algo="fpi", num_iter=16, ): ### PyTree leaves @@ -89,6 +91,14 @@ def __init__( self.qs = qs self.q_pi = q_pi + if A_dependencies is not None: + self.A_dependencies = A_dependencies + else: + num_factors = len(B) + num_modalities = len(A) + self.A_dependencies = [list(range(num_factors)) for _ in range(num_modalities)] + + batch_dim = (self.A[0].shape[0],) self.gamma = jnp.broadcast_to(gamma, batch_dim) @@ -143,7 +153,7 @@ def learning(self, *args, **kwargs): raise NotImplementedError @vmap - def infer_states(self, observations, past_actions, empirical_prior, *args): + def infer_states(self, observations, past_actions, empirical_prior, qs_hist): """ Update approximate posterior over hidden states by solving variational inference problem, given an observation. @@ -172,11 +182,11 @@ def infer_states(self, observations, past_actions, empirical_prior, *args): self.B, o_vec, past_actions, - prior=empirical_prior[0], - qs_hist=empirical_prior[1], + prior=empirical_prior, + qs_hist=qs_hist, A_dependencies=self.A_dependencies, num_iter=self.num_iter, - method=self.method + method=self.inference_algo ) return output diff --git a/pymdp/jax/inference.py b/pymdp/jax/inference.py index 2a5effaf..427d3c2b 100644 --- a/pymdp/jax/inference.py +++ b/pymdp/jax/inference.py @@ -2,6 +2,7 @@ # -*- coding: utf-8 -*- # pylint: disable=no-member +import jax.numpy as jnp from .algos import run_factorized_fpi, run_mmp, run_vmp from jax import tree_util as jtu @@ -13,6 +14,7 @@ def update_posterior_states(A, B, obs, past_actions, prior=None, qs_hist=None, A qs = run_factorized_fpi(A, curr_obs, prior, A_dependencies, num_iter=num_iter) else: # format B matrices using action sequences here + # TODO: past_actions can be None B = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(3, 0, 1, 2), B, past_actions) # assumes there is a batch dimension # outputs of both VMP and MMP should be a list of hidden state factors, where each qs[f].shape = (T, batch_dim, num_states_f) @@ -20,6 +22,11 @@ def update_posterior_states(A, B, obs, past_actions, prior=None, qs_hist=None, A qs = run_vmp(A, B, obs, prior, A_dependencies, num_iter=num_iter) if method == 'mmp': qs = run_mmp(A, B, obs, prior, A_dependencies, num_iter=num_iter) - - return qs_hist.append(qs) + + if qs_hist is not None: + qs_hist = jtu.tree_map(lambda x, y: jnp.concatenate([x, jnp.expand_dims(y, 0)], 0), qs_hist, qs) + else: + qs_hist = jtu.tree_map(lambda x: jnp.expand_dims(x, 0), qs) + + return qs_hist From d33c2fbf163055b2159cf6950219edddf623cd1a Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 5 Oct 2023 18:19:26 +0200 Subject: [PATCH 131/232] - added `pA` and `pB` as properties of `AIFAgent` - added more arguments to `infer_policies()` method, and indexed out `qs` to only get the latest belief --- pymdp/jax/agent.py | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 8764417c..98ce672a 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -41,6 +41,9 @@ class Agent(Module): gamma: jnp.ndarray qs: Optional[List] q_pi: Optional[List] + + pA: List + pB: List # static parameters not leaves of the PyTree A_dependencies: Optional[List] = static_field() @@ -66,6 +69,8 @@ def __init__( C, D, E, + pA, + pB, A_dependencies=None, qs=None, q_pi=None, @@ -88,6 +93,8 @@ def __init__( self.D = D # self.empirical_prior = D self.E = E + self.pA = pA + self.pB = pB self.qs = qs self.q_pi = q_pi @@ -215,13 +222,19 @@ def infer_policies(self, qs: List): Negative expected free energies of each policy, i.e. a vector containing one negative expected free energy per policy. """ + latest_belief = jtu.tree_map(lambda x: x[-1], qs) # only get the posterior belief held at the current timepoint q_pi, G = control.update_posterior_policies( self.policies, - qs, + latest_belief, self.A, self.B, self.C, - gamma = self.gamma + self.pA, + self.pB, + gamma=self.gamma, + use_utility=self.use_utility, + use_states_info_gain=self.use_states_info_gain, + use_param_info_gain=self.use_param_info_gain ) return q_pi, G From 1a89088964ad92faa7be0f65e5aa484d601bfdfa Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 5 Oct 2023 18:20:33 +0200 Subject: [PATCH 132/232] - wrote `scan`-abble version of compute negative expected free energy in `control` -`jax`-ified version of Dirichlet over A information gain - added placholder (returns `0.0` for now) function for Dirichlet over B information gain --- pymdp/jax/control.py | 116 ++++++++++++++++++++++++++++++++++++------- 1 file changed, 99 insertions(+), 17 deletions(-) diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index 74055079..18082fa2 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -126,11 +126,11 @@ def construct_policies(num_states, num_controls = None, policy_len=1, control_fa return jnp.stack(policies) -def update_posterior_policies(policy_matrix, qs_init, A, B, C, gamma=16.0): +def update_posterior_policies(policy_matrix, qs_init, A, B, C, pA, pB, gamma=16.0, use_utility=True, use_states_info_gain=True, use_param_info_gain=False): # policy --> n_levels_factor_f x 1 # factor --> n_levels_factor_f x n_policies ## vmap across policies - compute_G_fixed_states = partial(compute_G_policy, qs_init, A, B, C) + compute_G_fixed_states = partial(compute_G_policy, qs_init, A, B, C, pA, pB, use_utility=use_utility, use_states_info_gain=use_states_info_gain, use_param_info_gain=use_param_info_gain) # only in the case of policy-dependent qs_inits # in_axes_list = (1,) * n_factors @@ -216,28 +216,110 @@ def compute_expected_utility(qo, C): return util -def compute_G_policy(qs_init, A, B, C, policy_i): +def calc_pA_info_gain(pA, qo, qs): + """ + Compute expected Dirichlet information gain about parameters ``pA`` for a given posterior predictive distribution over observations ``qo`` and states ``qs``. - qs = qs_init - neg_G = 0. - for t_step in range(policy_i.shape[0]): + Parameters + ---------- + pA: ``numpy.ndarray`` of dtype object + Dirichlet parameters over observation model (same shape as ``A``) + qo: ``list`` of ``numpy.ndarray`` of dtype object + Predictive posterior beliefs over observations; stores the beliefs about + observations expected under the policy at some arbitrary time ``t`` + qs: ``list`` of ``numpy.ndarray`` of dtype object + Predictive posterior beliefs over hidden states, stores the beliefs about + hidden states expected under the policy at some arbitrary time ``t`` + + Returns + ------- + infogain_pA: float + Surprise (about Dirichlet parameters) expected for the pair of posterior predictive distributions ``qo`` and ``qs`` + """ - qs = compute_expected_state(qs, B, policy_i[t_step]) + wA = jtu.tree_map(spm_wnorm, pA) + wA_per_modality = jtu.tree_map(lambda wa, pa: wa * (pa > 0.), wA, pA) + pA_infogain_per_modality = jtu.tree_map(lambda wa, qo: qo.dot(factor_dot(wa, qs)[...,None]), wA_per_modality, qo) + infogain_pA = jtu.tree_reduce(lambda x, y: x + y, pA_infogain_per_modality)[0] + return infogain_pA + +def calc_pB_info_gain(pB, qs_t, qs_t_minus_1): + """ Placeholder, not implemented yet """ + # """ + # Compute expected Dirichlet information gain about parameters ``pB`` under a given policy + + # Parameters + # ---------- + # pB: ``numpy.ndarray`` of dtype object + # Dirichlet parameters over transition model (same shape as ``B``) + # qs_pi: ``list`` of ``numpy.ndarray`` of dtype object + # Predictive posterior beliefs over hidden states expected under the policy, where ``qs_pi[t]`` stores the beliefs about + # hidden states expected under the policy at time ``t`` + # qs_prev: ``numpy.ndarray`` of dtype object + # Posterior over hidden states at beginning of trajectory (before receiving observations) + # policy: 2D ``numpy.ndarray`` + # Array that stores actions entailed by a policy over time. Shape is ``(num_timesteps, num_factors)`` where ``num_timesteps`` is the temporal + # depth of the policy and ``num_factors`` is the number of control factors. + + # Returns + # ------- + # infogain_pB: float + # Surprise (about dirichlet parameters) expected under the policy in question + # """ - qo = compute_expected_obs(qs, A) + # n_steps = len(qs_pi) - info_gain = compute_info_gain(qs, qo, A) - utility = compute_expected_utility(qo, C) + # num_factors = len(pB) + # wB = utils.obj_array(num_factors) + # for factor, pB_f in enumerate(pB): + # wB[factor] = spm_wnorm(pB_f) - # if we're doing scan we'll need some of those control-flow workarounds from lax - # jnp.where(conditition, f_eval_if_true, 0) - # calculate pA info gain - # calculate pB info gain - - # Q(s, A) = E_{Q(o)}[D_KL(Q(s|o, \pi) Q(A| o, pi)|| Q(s|pi) Q(A))] + # pB_infogain = 0 + + # for t in range(n_steps): + # # the 'past posterior' used for the information gain about pB here is the posterior + # # over expected states at the timestep previous to the one under consideration + # # if we're on the first timestep, we just use the latest posterior in the + # # entire action-perception cycle as the previous posterior + # if t == 0: + # previous_qs = qs_prev + # # otherwise, we use the expected states for the timestep previous to the timestep under consideration + # else: + # previous_qs = qs_pi[t - 1] - neg_G += info_gain + utility + # # get the list of action-indices for the current timestep + # policy_t = policy[t, :] + # for factor, a_i in enumerate(policy_t): + # wB_factor_t = wB[factor][:, :, int(a_i)] * (pB[factor][:, :, int(a_i)] > 0).astype("float") + # pB_infogain -= qs_pi[t][factor].dot(wB_factor_t.dot(previous_qs[factor])) + return 0. +def compute_G_policy(qs_init, A, B, C, pA, pB, policy_i, use_utility=True, use_states_info_gain=True, use_param_info_gain=False): + """ Write a version of compute_G_policy that does the same computations as `compute_G_policy` but using `lax.scan` instead of a for loop. """ + + def scan_body(carry, t): + + qs, neg_G = carry + + qs_next = compute_expected_state(qs, B, policy_i[t]) + + qo = compute_expected_obs(qs_next, A) + + info_gain = compute_info_gain(qs_next, qo, A) if use_states_info_gain else 0. + + utility = compute_expected_utility(qo, C) if use_utility else 0. + + param_info_gain = calc_pA_info_gain(pA, qo, qs_next) if use_param_info_gain else 0. + param_info_gain += calc_pB_info_gain(pB, qs_next, qs) if use_param_info_gain else 0. + + neg_G += info_gain + utility + param_info_gain + + return (qs_next, neg_G), None + + qs = qs_init + neg_G = 0. + final_state, _ = lax.scan(scan_body, (qs, neg_G), jnp.arange(policy_i.shape[0])) + qs_final, neg_G = final_state return neg_G From 06944c6cd90d01831cd3b624b49a4f5df3dd40f0 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 5 Oct 2023 18:20:56 +0200 Subject: [PATCH 133/232] added `spm_wnorm` (expectation of a logarithm of Dirichlet distribution) to `jax.maths` --- pymdp/jax/maths.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/pymdp/jax/maths.py b/pymdp/jax/maths.py index 4f334637..7beb6d3e 100644 --- a/pymdp/jax/maths.py +++ b/pymdp/jax/maths.py @@ -70,6 +70,18 @@ def multidimensional_outer(arrs): return x +def spm_wnorm(A): + """ + Returns Expectation of logarithm of Dirichlet parameters over a set of + Categorical distributions, stored in the columns of A. + """ + A = jnp.clip(A, a_min=MINVAL) + norm = 1. / A.sum(axis=0) + avg = 1. / A + wA = norm - avg + return wA + + if __name__ == '__main__': obs = [0, 1, 2] obs_vec = [ nn.one_hot(o, 3) for o in obs] From 9115c1df6b165eef2a0f93d97e1e6796692759d0 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 5 Oct 2023 18:21:27 +0200 Subject: [PATCH 134/232] `-infer_policies()` now working in agent loop demo notebook -initialized agent with `pA` and `pB` --- examples/building_up_agent_loop.ipynb | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/examples/building_up_agent_loop.ipynb b/examples/building_up_agent_loop.ipynb index c7a94e2e..066bafc3 100644 --- a/examples/building_up_agent_loop.ipynb +++ b/examples/building_up_agent_loop.ipynb @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -39,8 +39,7 @@ " actions = carry['actions']\n", " outcomes = carry['outcomes']\n", " beliefs = agent.infer_states(outcomes, actions, *carry['args'])\n", - " # q_pi, _ = agent.infer_policies(beliefs)\n", - " q_pi = jnp.ones((batch_size, len(agent.policies)))/len(agent.policies)\n", + " q_pi, _ = agent.infer_policies(beliefs)\n", " actions_t = agent.sample_action(q_pi)\n", "\n", " outcome_t = env.step(actions_t)\n", @@ -100,6 +99,9 @@ "D = [jnp.ones((batch_size, ns)) / ns for ns in num_states]\n", "E = jnp.ones((batch_size, 4 )) / 4 \n", "\n", + "pA = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_size,) + x.shape), list(A_np))\n", + "pB = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_size,) + x.shape), list(B_np))\n", + "\n", "class TestEnv:\n", " def __init__(self, num_obs, prng_key=jr.PRNGKey(0)):\n", " self.num_obs=num_obs\n", @@ -110,7 +112,7 @@ " self.key, _ = jr.split(self.key)\n", " return obs\n", "\n", - "agents = AIFAgent(A, B, C, D, E)\n", + "agents = AIFAgent(A, B, C, D, E, pA, pB, use_param_info_gain=True)\n", "env = TestEnv(num_obs)\n", "\n", "init = (agents, env)\n", @@ -121,7 +123,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -196,7 +198,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.10" + "version": "3.11.4" }, "orig_nbformat": 4 }, From 74fa17ca62a32335f1a56a7507586158ad8360eb Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Thu, 5 Oct 2023 18:28:03 +0200 Subject: [PATCH 135/232] fixed inference in the loop --- examples/building_up_agent_loop.ipynb | 21 ++++++++----- pymdp/jax/algos.py | 45 +++++++++++++-------------- pymdp/jax/inference.py | 18 +++++++++-- 3 files changed, 50 insertions(+), 34 deletions(-) diff --git a/examples/building_up_agent_loop.ipynb b/examples/building_up_agent_loop.ipynb index c7a94e2e..e950feb9 100644 --- a/examples/building_up_agent_loop.ipynb +++ b/examples/building_up_agent_loop.ipynb @@ -16,21 +16,23 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ - "def scan(f, init, xs, length=None):\n", + "def scan(f, init, xs, length=None, unroll=1):\n", " if xs is None:\n", " xs = [None] * length\n", " carry = init\n", " ys = []\n", " for x in xs:\n", - " carry, y = f(carry, x)\n", + " for _ in range(unroll):\n", + " carry, y = f(carry, x)\n", " if y is not None:\n", " ys.append(y)\n", " \n", - " ys = None if len(ys) < 1 else jtu.tree_map(lambda *x: jnp.stack(x).swapaxes(1, 2), *ys)\n", + " ys = None if len(ys) < 1 else jtu.tree_map(lambda *x: jnp.stack(x), *ys)\n", + "\n", " return carry, ys\n", "\n", "def evolve_trials(agent, env, block_idx, num_timesteps):\n", @@ -52,9 +54,10 @@ " actions = jnp.concatenate([actions, jnp.expand_dims(actions_t, -2)], -2)\n", " else:\n", " actions = jnp.expand_dims(actions_t, -2)\n", - " \n", + "\n", " # args = agent.update_empirical_prior(actions_t, beliefs)\n", - " args = (jtu.tree_map( lambda x: x[:, -1], beliefs), beliefs)\n", + " args = (jtu.tree_map( lambda x: x[:, -1], beliefs), beliefs) \n", + " \n", " # args = (pred_{t+1}, [post_1, post_{2}, ..., post_{t}])\n", " # beliefs = [post_1, post_{2}, ..., post_{t}]\n", " return {'args': args, 'outcomes': outcomes, 'beliefs': beliefs, 'actions': actions}, None\n", @@ -110,18 +113,20 @@ " self.key, _ = jr.split(self.key)\n", " return obs\n", "\n", - "agents = AIFAgent(A, B, C, D, E)\n", + "agents = AIFAgent(A, B, C, D, E, inference_algo='mmp')\n", "env = TestEnv(num_obs)\n", "\n", "init = (agents, env)\n", "(agents, env), sequences = scan(step_fn, init, range(num_blocks) )\n", "\n", + "sequences = jtu.tree_map(lambda x: x.swapaxes(1, 2), sequences)\n", + "\n", "# NOTE: all elements of sequences will have dimensionality blocks, trials, batch_size, ...\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index ade3a305..9c98ebe1 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -112,8 +112,7 @@ def mirror_gradient_descent_step(tau, ln_A, lnB_past, lnB_future, ln_qs): u_{k+1} = u_{k} - \nabla_p F_k p_k = softmax(u_k) """ - - err = ln_A + lnB_past + lnB_future - ln_qs + err = ln_A - ln_qs + lnB_past + lnB_future ln_qs = ln_qs + tau * err qs = nn.softmax(ln_qs - ln_qs.mean(axis=-1, keepdims=True)) @@ -130,8 +129,9 @@ def update_marginals(get_messages, obs, A, B, prior, A_dependencies, num_iter=1, # for $k > t$ we have $\ln(A) = 0$ def get_log_likelihood(obs_t, A): - # mapping over batch dimension - return vmap(compute_log_likelihood_per_modality)(obs_t, A) + # # mapping over batch dimension + # return vmap(compute_log_likelihood_per_modality)(obs_t, A) + return compute_log_likelihood_per_modality(obs_t, A) # mapping over time dimension of obs array log_likelihoods = vmap(get_log_likelihood, (0, None))(obs, A) # this gives a sequence of log-likelihoods (one for each `t`) @@ -227,23 +227,22 @@ def scan_fn(carry, iter): def get_vmp_messages(ln_B, B, qs, ln_prior): - # @vmap(in_axes=(0, 1, 0), out_axes=1) def forward(ln_b, q, ln_prior): - msg = lax.batch_matmul(q[:-1, None], ln_b.transpose(0, 2, 1)).squeeze() + msg = vmap(lambda x, y: y @ x)(q[:-1], ln_b) return jnp.concatenate([jnp.expand_dims(ln_prior, 0), msg], axis=0) - fwd = vmap(forward, in_axes=(0, 1, 0), out_axes=1) - - # @vmap(in_axes=(0, 1), out_axes=1) def backward(ln_b, q): # q_i B_ij - msg = lax.batch_matmul(q[1:, None], ln_b).squeeze() + msg = vmap(lambda x, y: x @ y)(q[1:], ln_b) return jnp.pad(msg, ((0, 1), (0, 0))) - bkwd = vmap(backward, in_axes=(0, 1), out_axes=1) - - lnB_future = jtu.tree_map(fwd, ln_B, qs, ln_prior) - lnB_past = jtu.tree_map(bkwd, ln_B, qs) + if ln_B is not None: + lnB_future = jtu.tree_map(forward, ln_B, qs, ln_prior) + lnB_past = jtu.tree_map(backward, ln_B, qs) + else: + lnB_future = jtu.tree_map(lambda x: 0., qs) + lnB_past = jtu.tree_map(lambda x: 0., qs) + return lnB_future, lnB_past def run_vmp(A, B, obs, prior, A_dependencies, num_iter=1, tau=1.): @@ -259,7 +258,7 @@ def get_mmp_messages(ln_B, B, qs, ln_prior): def forward(b, q, ln_prior): if len(q) > 1: - msg = lax.batch_matmul(q[:-1, None], b.transpose(0, 2, 1)).squeeze() + msg = vmap(lambda x, y: y @ x)(q[:-1], b) msg = log_stable(msg) n = len(msg) if n > 1: # this is the case where there are at least 3 observations. If you have two observations, then you weight the single past message from t = 0 by 1.0 @@ -268,17 +267,17 @@ def forward(b, q, ln_prior): else: # this is case where this is a single observation / single-timestep posterior return jnp.expand_dims(ln_prior, 0) - fwd = vmap(forward, in_axes=(0, 1, 0), out_axes=1) - def backward(b, q): - msg = lax.batch_matmul(q[:-1, None], b.transpose(0, 2, 1)).squeeze() + msg = vmap(lambda x, y: x @ y)(q[1:], b) msg = log_stable(msg) * 0.5 return jnp.pad(msg, ((0, 1), (0, 0))) - - bkwd = vmap(backward, in_axes=(0, 1), out_axes=1) - - lnB_future = jtu.tree_map(fwd, B, qs, ln_prior) - lnB_past = jtu.tree_map(bkwd, B, qs) + + if ln_B is not None: + lnB_future = jtu.tree_map(forward, B, qs, ln_prior) + lnB_past = jtu.tree_map(backward, B, qs) + else: + lnB_future = jtu.tree_map(lambda x: 0., qs) + lnB_past = jtu.tree_map(lambda x: 0., qs) return lnB_future, lnB_past diff --git a/pymdp/jax/inference.py b/pymdp/jax/inference.py index 427d3c2b..68032cc6 100644 --- a/pymdp/jax/inference.py +++ b/pymdp/jax/inference.py @@ -15,7 +15,12 @@ def update_posterior_states(A, B, obs, past_actions, prior=None, qs_hist=None, A else: # format B matrices using action sequences here # TODO: past_actions can be None - B = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(3, 0, 1, 2), B, past_actions) # assumes there is a batch dimension + if past_actions is not None: + nf = len(B) + actions_tree = [past_actions[:, i] for i in range(nf)] + B = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(2, 0, 1), B, actions_tree) + else: + B = None # outputs of both VMP and MMP should be a list of hidden state factors, where each qs[f].shape = (T, batch_dim, num_states_f) if method == 'vmp': @@ -24,9 +29,16 @@ def update_posterior_states(A, B, obs, past_actions, prior=None, qs_hist=None, A qs = run_mmp(A, B, obs, prior, A_dependencies, num_iter=num_iter) if qs_hist is not None: - qs_hist = jtu.tree_map(lambda x, y: jnp.concatenate([x, jnp.expand_dims(y, 0)], 0), qs_hist, qs) + if method == 'fpi' or method == "ovf": + qs_hist = jtu.tree_map(lambda x, y: jnp.concatenate([x, jnp.expand_dims(y, 0)], 0), qs_hist, qs) + else: + #TODO: return entire history of beliefs + qs_hist = qs else: - qs_hist = jtu.tree_map(lambda x: jnp.expand_dims(x, 0), qs) + if method == 'fpi' or method == "ovf": + qs_hist = jtu.tree_map(lambda x: jnp.expand_dims(x, 0), qs) + else: + qs_hist = qs return qs_hist From baf4e1195f5ea47916b307d7466b2114c4bc595c Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 5 Oct 2023 18:44:33 +0200 Subject: [PATCH 136/232] removed unroll parameter from for-loop semantic implementation `scan` --- examples/building_up_agent_loop.ipynb | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/examples/building_up_agent_loop.ipynb b/examples/building_up_agent_loop.ipynb index 597f9152..3d8ebaf8 100644 --- a/examples/building_up_agent_loop.ipynb +++ b/examples/building_up_agent_loop.ipynb @@ -20,14 +20,13 @@ "metadata": {}, "outputs": [], "source": [ - "def scan(f, init, xs, length=None, unroll=1):\n", + "def scan(f, init, xs, length=None):\n", " if xs is None:\n", " xs = [None] * length\n", " carry = init\n", " ys = []\n", " for x in xs:\n", - " for _ in range(unroll):\n", - " carry, y = f(carry, x)\n", + " carry, y = f(carry, x)\n", " if y is not None:\n", " ys.append(y)\n", " \n", From 25394f7f5aea605fc28924388d71ce01b93b9254 Mon Sep 17 00:00:00 2001 From: conorheins Date: Sun, 15 Oct 2023 15:11:18 +0200 Subject: [PATCH 137/232] jax translation of dirichlet updates over A, also compatible with sparse dependencies bewteen hidden state factors and observation modalities --- pymdp/jax/learning.py | 71 ++++++------------------------------------- 1 file changed, 9 insertions(+), 62 deletions(-) diff --git a/pymdp/jax/learning.py b/pymdp/jax/learning.py index 3b18cb49..99ced86f 100644 --- a/pymdp/jax/learning.py +++ b/pymdp/jax/learning.py @@ -6,78 +6,25 @@ from .maths import multidimensional_outer from jax.tree_util import tree_map from jax import vmap +import jax.numpy as jnp -def update_obs_likelihood_dirichlet_m(pA_m, A_m, obs_m, qs, lr=1.0): +def update_obs_likelihood_dirichlet_m(pA_m, A_m, obs_m, qs, dependencies_m, lr=1.0): """ JAX version of ``pymdp.learning.update_obs_likelihood_dirichlet_m`` """ - dfda = vmap(multidimensional_outer)([obs_m]+ qs) - # dfda = dfda * (A_m > 0) + # relevant_factors = [qs[f] for f in dependencies_m] + relevant_factors = tree_map(lambda f_idx: qs[f_idx], dependencies_m) + + dfda = multidimensional_outer([obs_m]+ relevant_factors) dfda = jnp.where(A_m > 0, dfda, 0.0) qA_m = pA_m + (lr * dfda) return qA_m -def update_obs_likelihood_dirichlet(pA, A, obs, qs, lr=1.0): +def update_obs_likelihood_dirichlet(pA, A, obs, qs, A_dependencies, lr=1.0): """ JAX version of ``pymdp.learning.update_obs_likelihood_dirichlet`` """ - update_A_fn = lambda pA_m, A_m, obs_m: update_obs_likelihood_dirichlet_m(pA_m, A_m, obs_m, qs, lr=lr) - qA = tree_map(update_A_fn, pA, A, obs) - - # qA=[] - # for (pA_m, A_m, o_m) in zip(pA, A, obs): - # qA_m = update_obs_likelihood_dirichlet_m(pA_m, A_m, o_m, qs, lr=lr) - # qA.append(qA_m) - - return qA - -def update_obs_likelihood_dirichlet(pA, A, obs, qs, lr=1.0, modalities="all"): - """ - Update Dirichlet parameters of the observation likelihood distribution. - - Parameters - ----------- - pA: ``numpy.ndarray`` of dtype object - Prior Dirichlet parameters over observation model (same shape as ``A``) - A: ``numpy.ndarray`` of dtype object - Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of - stores an ``numpy.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store - the probability of observation level ``i`` given hidden state levels ``j, k, ...`` - obs: 1D ``numpy.ndarray``, ``numpy.ndarray`` of dtype object, ``int`` or ``tuple`` - The observation (generated by the environment). If single modality, this can be a 1D ``numpy.ndarray`` - (one-hot vector representation) or an ``int`` (observation index) - If multi-modality, this can be ``numpy.ndarray`` of dtype object whose entries are 1D one-hot vectors, - or a ``tuple`` (of ``int``) - qs: 1D ``numpy.ndarray`` or ``numpy.ndarray`` of dtype object, default None - Marginal posterior beliefs over hidden states at current timepoint. - lr: float, default 1.0 - Learning rate, scale of the Dirichlet pseudo-count update. - modalities: ``list``, default "all" - Indices (ranging from 0 to ``n_modalities - 1``) of the observation modalities to include - in learning. Defaults to "all", meaning that modality-specific sub-arrays of ``pA`` - are all updated using the corresponding observations. - - Returns - ----------- - qA: ``numpy.ndarray`` of dtype object - Posterior Dirichlet parameters over observation model (same shape as ``A``), after having updated it with observations. - """ - - - num_modalities = len(pA) - num_observations = [pA[modality].shape[0] for modality in range(num_modalities)] - - obs_processed = utils.process_observation(obs, num_modalities, num_observations) - obs = utils.to_obj_array(obs_processed) - - if modalities == "all": - modalities = list(range(num_modalities)) - - qA = copy.deepcopy(pA) - - for modality in modalities: - dfda = maths.spm_cross(obs[modality], qs) - dfda = dfda * (A[modality] > 0).astype("float") - qA[modality] = qA[modality] + (lr * dfda) + update_A_fn = lambda pA_m, A_m, obs_m, dependencies_m: update_obs_likelihood_dirichlet_m(pA_m, A_m, obs_m, qs, dependencies_m, lr=lr) + qA = tree_map(update_A_fn, pA, A, obs, A_dependencies) return qA From 91afcc108865c49309321353ef1863eca6f04304 Mon Sep 17 00:00:00 2001 From: conorheins Date: Sun, 15 Oct 2023 15:11:26 +0200 Subject: [PATCH 138/232] unit test of jax-ified version of A matrix learning --- test/test_learning_jax.py | 141 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 141 insertions(+) create mode 100644 test/test_learning_jax.py diff --git a/test/test_learning_jax.py b/test/test_learning_jax.py new file mode 100644 index 00000000..f99c877b --- /dev/null +++ b/test/test_learning_jax.py @@ -0,0 +1,141 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +""" Unit Tests +__author__: Dimitrije Markovic, Conor Heins +""" + +import os +import unittest + +import numpy as np +import jax.numpy as jnp +import jax.tree_util as jtu + +from pymdp.learning import update_obs_likelihood_dirichlet as update_pA_numpy +from pymdp.learning import update_obs_likelihood_dirichlet_factorized as update_pA_numpy_factorized +from pymdp.jax.learning import update_obs_likelihood_dirichlet as update_pA_jax +from pymdp import utils, maths + +class TestLearningJax(unittest.TestCase): + + def test_update_observation_likelihood_fullyconnected(self): + """ + Testing JAX-ified version of updating Dirichlet posterior over observation likelihood parameters (qA is posterior, pA is prior, and A is expectation + of likelihood wrt to current posterior over A, i.e. $A = E_{Q(A)}[P(o|s,A)]$. + + This is the so-called 'fully-connected' version where all hidden state factors drive each modality (i.e. A_dependencies is a list of lists of hidden state factors) + """ + + num_obs_list = [ [5], + [10, 3, 2], + [2, 4, 4, 2], + [10] + ] + num_states_list = [ [2,3,4], + [2], + [4,5], + [3] + ] + + A_dependencies_list = [ [ [0,1,2] ], + [ [0], [0], [0] ], + [ [0,1], [0,1], [0,1], [0,1] ], + [ [0] ] + ] + + for (num_obs, num_states, A_dependencies) in zip(num_obs_list, num_states_list, A_dependencies_list): + # create numpy arrays to test numpy version of learning + + # create A matrix initialization (expected initial value of P(o|s, A)) and prior over A (pA) + A_np = utils.random_A_matrix(num_obs, num_states) + pA_np = utils.dirichlet_like(A_np, scale = 3.0) + + # create random observations + obs_np = utils.obj_array(len(num_obs)) + for m, obs_dim in enumerate(num_obs): + obs_np[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) + + # create random state posterior + qs_np = utils.random_single_categorical(num_states) + + l_rate = 1.0 + + # run numpy version of learning + qA_np_test = update_pA_numpy(pA_np, A_np, obs_np, qs_np, lr=l_rate) + + pA_jax = jtu.tree_map(lambda x: jnp.array(x), list(pA_np)) + A_jax = jtu.tree_map(lambda x: jnp.array(x), list(A_np)) + obs_jax = jtu.tree_map(lambda x: jnp.array(x), list(obs_np)) + qs_jax = jtu.tree_map(lambda x: jnp.array(x), list(qs_np)) + + qA_jax_test = update_pA_jax(pA_jax, A_jax, obs_jax, qs_jax, A_dependencies, lr=l_rate) + + for modality, obs_dim in enumerate(num_obs): + self.assertTrue(np.allclose(qA_jax_test[modality],qA_np_test[modality])) + + def test_update_observation_likelihood_factorized(self): + """ + Testing JAX-ified version of updating Dirichlet posterior over observation likelihood parameters (qA is posterior, pA is prior, and A is expectation + of likelihood wrt to current posterior over A, i.e. $A = E_{Q(A)}[P(o|s,A)]$. + + This is the factorized version where only some hidden state factors drive each modality (i.e. A_dependencies is a list of lists of hidden state factors) + """ + + num_obs_list = [ [5], + [10, 3, 2], + [2, 4, 4, 2], + [10] + ] + num_states_list = [ [2,3,4], + [2, 5, 2], + [4,5], + [3] + ] + + A_dependencies_list = [ [ [0,1] ], + [ [0, 1], [1], [1, 2] ], + [ [0,1], [0], [0,1], [1] ], + [ [0] ] + ] + + for (num_obs, num_states, A_dependencies) in zip(num_obs_list, num_states_list, A_dependencies_list): + # create numpy arrays to test numpy version of learning + + # create A matrix initialization (expected initial value of P(o|s, A)) and prior over A (pA) + A_np = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_dependencies) + pA_np = utils.dirichlet_like(A_np, scale = 3.0) + + # create random observations + obs_np = utils.obj_array(len(num_obs)) + for m, obs_dim in enumerate(num_obs): + obs_np[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) + + # create random state posterior + qs_np = utils.random_single_categorical(num_states) + + l_rate = 1.0 + + # run numpy version of learning + qA_np_test = update_pA_numpy_factorized(pA_np, A_np, obs_np, qs_np, A_dependencies, lr=l_rate) + + pA_jax = jtu.tree_map(lambda x: jnp.array(x), list(pA_np)) + A_jax = jtu.tree_map(lambda x: jnp.array(x), list(A_np)) + obs_jax = jtu.tree_map(lambda x: jnp.array(x), list(obs_np)) + qs_jax = jtu.tree_map(lambda x: jnp.array(x), list(qs_np)) + + qA_jax_test = update_pA_jax(pA_jax, A_jax, obs_jax, qs_jax, A_dependencies, lr=l_rate) + + for modality, obs_dim in enumerate(num_obs): + self.assertTrue(np.allclose(qA_jax_test[modality],qA_np_test[modality])) + +if __name__ == "__main__": + unittest.main() + + + + + + + + From c9cbed5e20abf7714fe2f5193210b07264f4ea16 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 19 Oct 2023 17:49:24 +0200 Subject: [PATCH 139/232] got last belief for update_empirical_prior Co-authored-by: Dimitrije Markovic --- pymdp/jax/agent.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 98ce672a..33f67085 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -202,7 +202,8 @@ def infer_states(self, observations, past_actions, empirical_prior, qs_hist): def update_empirical_prior(self, action, qs): # return empirical_prior, and the history of posterior beliefs (filtering distributions) held about hidden states at times 1, 2 ... t - pred = control.compute_expected_state(qs[-1], self.B, action) + qs_last = jtu.tree_map( lambda x: x[-1], qs) + pred = control.compute_expected_state(qs_last, self.B, action) return (pred, qs) From 0bad5d6ae335418015ee426dcb2b69ed030e65c0 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Thu, 19 Oct 2023 17:49:58 +0200 Subject: [PATCH 140/232] updated agent --- pymdp/jax/agent.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 98ce672a..628edcc2 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -196,6 +196,9 @@ def infer_states(self, observations, past_actions, empirical_prior, qs_hist): method=self.inference_algo ) + # if ovf_smooth: + # output = inference.smoothing(output) + return output @vmap From 6bc88f5df07feb15df28d4b3e9784d8ae4c278ad Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Thu, 19 Oct 2023 17:51:19 +0200 Subject: [PATCH 141/232] updated notebook --- examples/building_up_agent_loop.ipynb | 65 +-------------------------- 1 file changed, 2 insertions(+), 63 deletions(-) diff --git a/examples/building_up_agent_loop.ipynb b/examples/building_up_agent_loop.ipynb index 3d8ebaf8..c3ad11bf 100644 --- a/examples/building_up_agent_loop.ipynb +++ b/examples/building_up_agent_loop.ipynb @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -53,8 +53,7 @@ " else:\n", " actions = jnp.expand_dims(actions_t, -2)\n", "\n", - " # args = agent.update_empirical_prior(actions_t, beliefs)\n", - " args = (jtu.tree_map( lambda x: x[:, -1], beliefs), beliefs) \n", + " args = agent.update_empirical_prior(actions_t, beliefs)\n", " \n", " # args = (pred_{t+1}, [post_1, post_{2}, ..., post_{t}])\n", " # beliefs = [post_1, post_{2}, ..., post_{t}]\n", @@ -124,66 +123,6 @@ "\n", "# NOTE: all elements of sequences will have dimensionality blocks, trials, batch_size, ...\n" ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# def scan(f, init, xs, length=None):\n", - "# if xs is None:\n", - "# xs = [None] * length\n", - "# carry = init\n", - "# ys = []\n", - "# for x in xs:\n", - "# carry, y = f(carry, x)\n", - "# ys.append(y)\n", - " \n", - "# return carry, jnp.stack(ys)\n", - "\n", - "# def evolve_trials(agent, env, block_idx, num_timesteps):\n", - "\n", - "# def step_fn(carry, xs):\n", - "# actions = carry['actions']\n", - "# outcomes = carry['outcomes']\n", - "# beliefs = agent.infer_states(outcomes, actions, *carry['args'])\n", - "# q_pi, _ = agent.infer_policies(beliefs)\n", - "# actions_t = agent.sample_action(q_pi)\n", - "\n", - "# outcome_t = env.step(actions_t)\n", - "# outcomes = jtu.tree_map(lambda prev_o, new_o: jnp.stack([prev_o, jnp.expand_dims(new_o, 0)], 0), outcomes, outcome_t)\n", - "\n", - "# actions = jnp.stack([actions, jnp.expand_dims(actions_t, 0)], 0) if actions is not None else actions_t\n", - "# args = agent.update_empirical_prior(actions_t, beliefs)\n", - "# # (pred, [cond_1, ..., cond_{t-1}])\n", - "\n", - "# # ovf beliefs = (post_T, [cond_1, cond_2, ..., cond_{T-1}])\n", - "# # else beliefs = (post_T, post_{T-1}, ..., post_1)\n", - "# return {'args': args, 'outcomes': outcomes, 'beliefs': beliefs, 'actions': actions}, None\n", - "\n", - "# outcome_0 = env.step()\n", - "# init = ((agent.D, None), outcome_0, None, None)\n", - "# last, _ = scan(step_fn, init, range(num_timesteps))\n", - "\n", - "# return last, env\n", - "\n", - "# def step_fn(carry, block_idx):\n", - "# agent, env = carry\n", - "# output, env = evolve_trials(agent, env, block_idx, num_timesteps)\n", - "\n", - "# # How to deal with contiguous blocks of trials? Two options we can imagine: \n", - "# # A) you use final posterior (over current and past timesteps) to compute the smoothing distribution over qs_{t=0} and update pD, and then pass pD as the initial state prior ($D = \\mathbb{E}_{pD}[qs_{t=0}]$);\n", - "# # B) we don't assume that blocks 'reset time', and are really just adjacent chunks of one long sequence, so you set the initial state prior to be the final output (`output['beliefs']`) passed through\n", - "# # the transition model entailed by the action taken at the last timestep of the previous block.\n", - " \n", - "# agent = agent.learning(**output)\n", - " \n", - "# return (agent, env), output\n", - "\n", - "# init = (agent, env)\n", - "# agent, squences = scan(step_fn, init, range(num_blocks) )" - ] } ], "metadata": { From 38efc71c172a03c1a8b428f2d4f18de6caf04d16 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 19 Oct 2023 18:42:32 +0200 Subject: [PATCH 142/232] Can now compute gradients through AIF agent-environment loop -- cool! Co-authored-by: Dimitrije Markovic --- examples/building_up_agent_loop.ipynb | 50 ++++++++++++++++++++------- 1 file changed, 38 insertions(+), 12 deletions(-) diff --git a/examples/building_up_agent_loop.ipynb b/examples/building_up_agent_loop.ipynb index c3ad11bf..772aa34e 100644 --- a/examples/building_up_agent_loop.ipynb +++ b/examples/building_up_agent_loop.ipynb @@ -16,11 +16,20 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2, 10, 5, 4)\n", + "(2, 10, 5, 2)\n" + ] + } + ], "source": [ - "def scan(f, init, xs, length=None):\n", + "def scan(f, init, xs, length=None, axis=0):\n", " if xs is None:\n", " xs = [None] * length\n", " carry = init\n", @@ -30,7 +39,7 @@ " if y is not None:\n", " ys.append(y)\n", " \n", - " ys = None if len(ys) < 1 else jtu.tree_map(lambda *x: jnp.stack(x), *ys)\n", + " ys = None if len(ys) < 1 else jtu.tree_map(lambda *x: jnp.stack(x,axis=axis), *ys)\n", "\n", " return carry, ys\n", "\n", @@ -54,11 +63,16 @@ " actions = jnp.expand_dims(actions_t, -2)\n", "\n", " args = agent.update_empirical_prior(actions_t, beliefs)\n", + "\n", + " ### @ NOTE !!!!: Shape of policy_probs = (num_blocks, num_trials, batch_size, num_policies) if scan axis = 0, but size of `actions` will \n", + " ### be (num_blocks, batch_size, num_trials, num_controls) -- so we need to 1) swap axes to both to have the same first three dimensiosn aligned,\n", + " # 2) use the action indices (the integers stored in the last dimension of `actions`) to index into the policy_probs array\n", " \n", " # args = (pred_{t+1}, [post_1, post_{2}, ..., post_{t}])\n", " # beliefs = [post_1, post_{2}, ..., post_{t}]\n", - " return {'args': args, 'outcomes': outcomes, 'beliefs': beliefs, 'actions': actions}, None\n", + " return {'args': args, 'outcomes': outcomes, 'beliefs': beliefs, 'actions': actions},{'policy_probs': q_pi}\n", "\n", + " \n", " outcome_0 = jtu.tree_map(lambda x: jnp.expand_dims(x, -1), env.step())\n", " init = {\n", " 'args': (agent.D, None,),\n", @@ -66,14 +80,15 @@ " 'beliefs': [],\n", " 'actions': None\n", " }\n", - " last, _ = scan(step_fn, init, range(num_timesteps))\n", + " last, q_pis_ = scan(step_fn, init, range(num_timesteps), axis=1)\n", "\n", - " return last, env\n", + " return last, q_pis_, env\n", "\n", "def step_fn(carry, block_idx):\n", " agent, env = carry\n", - " output, env = evolve_trials(agent, env, block_idx, num_timesteps)\n", - " output.pop('args') \n", + " output, q_pis_, env = evolve_trials(agent, env, block_idx, num_timesteps)\n", + " output.pop('args') \n", + " output.update(q_pis_) \n", "\n", " # How to deal with contiguous blocks of trials? Two options we can imagine: \n", " # A) you use final posterior (over current and past timesteps) to compute the smoothing distribution over qs_{t=0} and update pD, and then pass pD as the initial state prior ($D = \\mathbb{E}_{pD}[qs_{t=0}]$);\n", @@ -115,11 +130,22 @@ "\n", "agents = AIFAgent(A, B, C, D, E, pA, pB, use_param_info_gain=True, inference_algo='mmp')\n", "env = TestEnv(num_obs)\n", - "\n", "init = (agents, env)\n", "(agents, env), sequences = scan(step_fn, init, range(num_blocks) )\n", + "print(sequences['policy_probs'].shape)\n", + "print(sequences['actions'].shape)\n", + "# def loss_fn(agents):\n", + "# env = TestEnv(num_obs)\n", + "# init = (agents, env)\n", + "# (agents, env), sequences = scan(step_fn, init, range(num_blocks)) \n", + "\n", + "# return jnp.sum(jnp.log(sequences['policy_probs']))\n", + "\n", + "# dLoss_dAgents = jax.grad(loss_fn)(agents)\n", + "# print(dLoss_dAgents.A[0].shape)\n", + "\n", "\n", - "sequences = jtu.tree_map(lambda x: x.swapaxes(1, 2), sequences)\n", + "# sequences = jtu.tree_map(lambda x: x.swapaxes(1, 2), sequences)\n", "\n", "# NOTE: all elements of sequences will have dimensionality blocks, trials, batch_size, ...\n" ] @@ -141,7 +167,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.10" + "version": "3.11.4" }, "orig_nbformat": 4 }, From 7ebf1f9f71f2523d0e36d537225bc30d4c9f4f39 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 19 Oct 2023 22:26:44 +0200 Subject: [PATCH 143/232] example of scanning over method calls of a class that does in-place updates for @dimarkov --- test/scan_over_class_inplace_updates.py | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 test/scan_over_class_inplace_updates.py diff --git a/test/scan_over_class_inplace_updates.py b/test/scan_over_class_inplace_updates.py new file mode 100644 index 00000000..6addc748 --- /dev/null +++ b/test/scan_over_class_inplace_updates.py @@ -0,0 +1,25 @@ +from jax import numpy as jnp +from jax.lax import scan + +class myClass(object): + + params: jnp.ndarray + + def __init__(self, params): + self.params = params + + def update(self, delta_params): + self.params += delta_params + +myClass_instance = myClass(jnp.array([1., 2., 3.])) + +def body(carry, t): + myClass_instance.update(all_updates[t]) + return None, None + +all_updates = jnp.ones((5, 3)) + +scan(body, None, jnp.arange(5)) + +# print out the values of the params after the scan +print(myClass_instance.params) \ No newline at end of file From c280d685f9c779e1c8ae3e58942d166d41b75b97 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 26 Oct 2023 20:37:48 +0200 Subject: [PATCH 144/232] - updates over Dirichlet posterior over A (q(A)) compatible with multi-timestep posteriors (i.e., smoothing distributions) -- only working though for `mmp` and `vmp`, haven't tested `ovf` as inference method yet - added general learning function in `Agent` class, that will wrap all other learning update methods (e.g. update_A(), update_B(), ...) - added in expected value of a dirichlet distribution into `jax.maths` - `update_obs_likelihood_dirichlet_m()` in `jax.learning` now vmaps over time dimension and sums to get time-lapsed variational update Co-authored-by: Dimitrije Markovic --- examples/building_up_agent_loop.ipynb | 10 +++--- pymdp/jax/agent.py | 47 ++++++++++++++++++++++--- pymdp/jax/learning.py | 16 +++++++-- pymdp/jax/maths.py | 8 +++++ test/scan_over_class_inplace_updates.py | 25 ------------- 5 files changed, 69 insertions(+), 37 deletions(-) delete mode 100644 test/scan_over_class_inplace_updates.py diff --git a/examples/building_up_agent_loop.ipynb b/examples/building_up_agent_loop.ipynb index 772aa34e..e75ca4d5 100644 --- a/examples/building_up_agent_loop.ipynb +++ b/examples/building_up_agent_loop.ipynb @@ -74,6 +74,7 @@ "\n", " \n", " outcome_0 = jtu.tree_map(lambda x: jnp.expand_dims(x, -1), env.step())\n", + " # qs_hist = jtu.tree_map(lambda x: jnp.expand_dims(x, -2), agent.D) # add a time dimension to the initial state prior\n", " init = {\n", " 'args': (agent.D, None,),\n", " 'outcomes': outcome_0, \n", @@ -87,15 +88,16 @@ "def step_fn(carry, block_idx):\n", " agent, env = carry\n", " output, q_pis_, env = evolve_trials(agent, env, block_idx, num_timesteps)\n", - " output.pop('args') \n", - " output.update(q_pis_) \n", + " args = output.pop('args')\n", + " output['beliefs'] = agent.infer_states(output['outcomes'], output['actions'], *args)\n", + " output.update(q_pis_)\n", "\n", " # How to deal with contiguous blocks of trials? Two options we can imagine: \n", " # A) you use final posterior (over current and past timesteps) to compute the smoothing distribution over qs_{t=0} and update pD, and then pass pD as the initial state prior ($D = \\mathbb{E}_{pD}[qs_{t=0}]$);\n", " # B) we don't assume that blocks 'reset time', and are really just adjacent chunks of one long sequence, so you set the initial state prior to be the final output (`output['beliefs']`) passed through\n", " # the transition model entailed by the action taken at the last timestep of the previous block.\n", - " \n", - " # agent = agent.learning(**output)\n", + " # print(output['beliefs'].shape)\n", + " agent = agent.learning(**output)\n", " \n", " return (agent, env), output\n", "\n", diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 6f94894b..aea2dbad 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -11,7 +11,7 @@ import jax.tree_util as jtu from jax import nn, vmap from . import inference, control, learning, utils, maths -from equinox import Module, static_field +from equinox import Module, static_field, tree_at from typing import Any, List, AnyStr, Optional @@ -61,6 +61,11 @@ class Agent(Module): use_states_info_gain: bool = static_field() use_param_info_gain: bool = static_field() action_selection: AnyStr = static_field() + learn_A: bool = static_field() + learn_B: bool = static_field() + learn_C: bool = static_field() + learn_D: bool = static_field() + learn_E: bool = static_field() def __init__( self, @@ -84,6 +89,11 @@ def __init__( action_selection="deterministic", inference_algo="fpi", num_iter=16, + learn_A=True, + learn_B=True, + learn_C=False, + learn_D=True, + learn_E=False ): ### PyTree leaves @@ -123,6 +133,13 @@ def __init__( self.use_states_info_gain = use_states_info_gain self.use_param_info_gain = use_param_info_gain + # learning parameters + self.learn_A = learn_A + self.learn_B = learn_B + self.learn_C = learn_C + self.learn_D = learn_D + self.learn_E = learn_E + """ Determine number of observation modalities and their respective dimensions """ self.num_obs = [self.A[m].shape[1] for m in range(len(self.A))] self.num_modalities = len(self.num_obs) @@ -150,14 +167,34 @@ def _construct_policies(self): ) @vmap - def learning(self, *args, **kwargs): + def learning(self, beliefs, outcomes, **kwargs): + + if self.learn_A: + o_vec_seq = jtu.tree_map(lambda o, dim: nn.one_hot(o, dim), outcomes, self.num_obs) + # qA = learning.update_A(self.A, beliefs, o_vec_seq, self.A_dependencies) + qA = learning.update_obs_likelihood_dirichlet(self.pA, self.A, o_vec_seq, beliefs, self.A_dependencies, lr=1.) + E_qA = jtu.tree_map(lambda x: maths.dirichlet_expected_value(x), qA) + # if self.learn_B: + # self.qB = learning.update_B(self.B, *args, **kwargs) + # self.B = jtu.tree_map(lambda x: maths.dirichlet_expected_value(x), self.qB) + # if self.learn_C: + # self.qC = learning.update_C(self.C, *args, **kwargs) + # self.C = jtu.tree_map(lambda x: maths.dirichlet_expected_value(x), self.qC) + # if self.learn_D: + # self.qD = learning.update_D(self.D, *args, **kwargs) + # self.D = jtu.tree_map(lambda x: maths.dirichlet_expected_value(x), self.qD) + # if self.learn_E: + # self.qE = learning.update_E(self.E, *args, **kwargs) + # self.E = maths.dirichlet_expected_value(self.qE) + # do stuff # variables = ... # parameters = ... # varibles = {'A': jnp.ones(5)} - # return Agent(variables, parameters) - raise NotImplementedError + agent = tree_at(lambda x: (x.A, x.pA), self, (E_qA, qA)) + + return agent @vmap def infer_states(self, observations, past_actions, empirical_prior, qs_hist): @@ -183,7 +220,7 @@ def infer_states(self, observations, past_actions, empirical_prior, qs_hist): at timepoint ``t_idx``. """ - o_vec = [nn.one_hot(o, self.A[i].shape[0]) for i, o in enumerate(observations)] + o_vec = [nn.one_hot(o, self.num_obs[m]) for m, o in enumerate(observations)] output = inference.update_posterior_states( self.A, self.B, diff --git a/pymdp/jax/learning.py b/pymdp/jax/learning.py index 99ced86f..299bce09 100644 --- a/pymdp/jax/learning.py +++ b/pymdp/jax/learning.py @@ -10,12 +10,22 @@ def update_obs_likelihood_dirichlet_m(pA_m, A_m, obs_m, qs, dependencies_m, lr=1.0): """ JAX version of ``pymdp.learning.update_obs_likelihood_dirichlet_m`` """ + # pA_m - parameters of the dirichlet from the prior + # pA_m.shape = (no_m x num_states[k] x num_states[j] x ... x num_states[n]) where (k, j, n) are indices of the hidden state factors that are parents of modality m + + # \alpha^{*} = \alpha_{0} + \kappa * \sum_{t=t_begin}^{t=T} o_{m,t} \otimes \mathbf{s}_{f \in parents(m), t} + + # \alpha^{*} is the VFE-minimizing solution for the parameters of q(A) + # \alpha_{0} are the Dirichlet parameters of p(A) + # o_{m,t} = observation (one-hot vector) of modality m at time t + # \mathbf{s}_{f \in parents(m), t} = categorical parameters of marginal posteriors over hidden state factors that are parents of modality m, at time t + # \otimes is a multidimensional outer product, not just a outer product of two vectors + # \kappa is an optional learning rate - # relevant_factors = [qs[f] for f in dependencies_m] relevant_factors = tree_map(lambda f_idx: qs[f_idx], dependencies_m) - dfda = multidimensional_outer([obs_m]+ relevant_factors) - dfda = jnp.where(A_m > 0, dfda, 0.0) + dfda = vmap(multidimensional_outer)([obs_m]+ relevant_factors).sum(axis=0) + # dfda = jnp.where(A_m > 0, dfda, 0.0) # this doesn't make sense qA_m = pA_m + (lr * dfda) return qA_m diff --git a/pymdp/jax/maths.py b/pymdp/jax/maths.py index 7beb6d3e..0b4db6d6 100644 --- a/pymdp/jax/maths.py +++ b/pymdp/jax/maths.py @@ -81,6 +81,14 @@ def spm_wnorm(A): wA = norm - avg return wA +def dirichlet_expected_value(dir_arr): + """ + Returns Expectation of Dirichlet parameters over a set of + Categorical distributions, stored in the columns of A. + """ + dir_arr = jnp.clip(dir_arr, a_min=MINVAL) + expected_val = jnp.divide(dir_arr, dir_arr.sum(axis=0, keepdims=True)) + return expected_val if __name__ == '__main__': obs = [0, 1, 2] diff --git a/test/scan_over_class_inplace_updates.py b/test/scan_over_class_inplace_updates.py deleted file mode 100644 index 6addc748..00000000 --- a/test/scan_over_class_inplace_updates.py +++ /dev/null @@ -1,25 +0,0 @@ -from jax import numpy as jnp -from jax.lax import scan - -class myClass(object): - - params: jnp.ndarray - - def __init__(self, params): - self.params = params - - def update(self, delta_params): - self.params += delta_params - -myClass_instance = myClass(jnp.array([1., 2., 3.])) - -def body(carry, t): - myClass_instance.update(all_updates[t]) - return None, None - -all_updates = jnp.ones((5, 3)) - -scan(body, None, jnp.arange(5)) - -# print out the values of the params after the scan -print(myClass_instance.params) \ No newline at end of file From 16ee148d8e504f660ffac1edcb5510b1cfe7c773 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 2 Nov 2023 17:45:40 +0100 Subject: [PATCH 145/232] - new additions to `jax.pymdp.control` that take into account `A_dependencies` and `B_dependencies` - `Agent` now takes arguments related to `B_dependencies`, and passes `B_dependencies` into inference- and control-calling methods Co-authored-by: Dimitrije Markovic --- pymdp/jax/agent.py | 54 ++++++++++++++++++++++++----- pymdp/jax/control.py | 82 ++++++++++++++++++++++++++------------------ 2 files changed, 94 insertions(+), 42 deletions(-) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index aea2dbad..c3af4ce9 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -47,6 +47,7 @@ class Agent(Module): # static parameters not leaves of the PyTree A_dependencies: Optional[List] = static_field() + B_dependencies: Optional[List] = static_field() num_iter: int = static_field() num_obs: List = static_field() num_modalities: int = static_field() @@ -77,6 +78,7 @@ def __init__( pA, pB, A_dependencies=None, + B_dependencies=None, qs=None, q_pi=None, policy_len=1, @@ -108,13 +110,40 @@ def __init__( self.qs = qs self.q_pi = q_pi + element_size = lambda x: x.shape[1] + self.num_factors = len(self.B) + self.num_states = jtu.tree_map(element_size, self.B) + + self.num_modalities = len(self.A) + self.num_obs = jtu.tree_map(element_size, self.A) + + # Ensure consistency of A_dependencies with num_states and num_factors if A_dependencies is not None: self.A_dependencies = A_dependencies + else: + # assume full dependence of A matrices and state factors + self.A_dependencies = [list(range(self.num_factors)) for _ in range(self.num_modalities)] + + for m in range(self.num_modalities): + factor_dims = tuple([self.num_states[f] for f in self.A_dependencies[m]]) + assert self.A[m].shape[2:] == factor_dims, f"Please input an `A_dependencies` whose {m}-th indices correspond to the hidden state factors that line up with lagging dimensions of A[{m}]..." + if self.pA != None: + assert self.pA[m].shape[2:] == factor_dims, f"Please input an `A_dependencies` whose {m}-th indices correspond to the hidden state factors that line up with lagging dimensions of pA[{m}]..." + assert max(self.A_dependencies[m]) <= (self.num_factors - 1), f"Check modality {m} of `A_dependencies` - must be consistent with `num_states` and `num_factors`..." + + # Ensure consistency of B_dependencies with num_states and num_factors + if B_dependencies is not None: + self.B_dependencies else: num_factors = len(B) - num_modalities = len(A) - self.A_dependencies = [list(range(num_factors)) for _ in range(num_modalities)] + self.B_dependencies = [[f] for f in range(self.num_factors)] # defaults to having all factors depend only on themselves + for f in range(self.num_factors): + factor_dims = tuple([self.num_states[f] for f in self.B_dependencies[f]]) + assert self.B[f].shape[2:-1] == factor_dims, f"Please input a `B_dependencies` whose {f}-th indices pick out the hidden state factors that line up with the all-but-final lagging dimensions of B[{f}]..." + if self.pB != None: + assert self.pB[f].shape[2:-1] == factor_dims, f"Please input a `B_dependencies` whose {f}-th indices pick out the hidden state factors that line up with the all-but-final lagging dimensions of pB[{f}]..." + assert max(self.B_dependencies[f]) <= (self.num_factors - 1), f"Check factor {f} of `B_dependencies` - must be consistent with `num_states` and `num_factors`..." batch_dim = (self.A[0].shape[0],) @@ -144,17 +173,23 @@ def __init__( self.num_obs = [self.A[m].shape[1] for m in range(len(self.A))] self.num_modalities = len(self.num_obs) - # Determine number of hidden state factors and their dimensionalities - self.num_states = [self.B[f].shape[1] for f in range(len(self.B))] - self.num_factors = len(self.num_states) - # If no `num_controls` are given, then this is inferred from the shapes of the input B matrices self.num_controls = [self.B[f].shape[-1] for f in range(self.num_factors)] # Users have the option to make only certain factors controllable. # default behaviour is to make all hidden state factors controllable # (i.e. self.num_states == self.num_controls) - self.control_fac_idx = control_fac_idx + # Users have the option to make only certain factors controllable. + # default behaviour is to make all hidden state factors controllable, i.e. `self.num_factors == len(self.num_controls)` + if control_fac_idx == None: + self.control_fac_idx = [f for f in range(self.num_factors) if self.num_controls[f] > 1] + else: + assert max(control_fac_idx) <= (self.num_factors - 1), "Check control_fac_idx - must be consistent with `num_states` and `num_factors`..." + self.control_fac_idx = control_fac_idx + + for factor_idx in self.control_fac_idx: + assert self.num_controls[factor_idx] > 1, "Control factor (and B matrix) dimensions are not consistent with user-given control_fac_idx" + if policies is not None: self.policies = policies else: @@ -229,6 +264,7 @@ def infer_states(self, observations, past_actions, empirical_prior, qs_hist): prior=empirical_prior, qs_hist=qs_hist, A_dependencies=self.A_dependencies, + B_dependencies=self.B_dependencies, num_iter=self.num_iter, method=self.inference_algo ) @@ -243,7 +279,7 @@ def update_empirical_prior(self, action, qs): # return empirical_prior, and the history of posterior beliefs (filtering distributions) held about hidden states at times 1, 2 ... t qs_last = jtu.tree_map( lambda x: x[-1], qs) - pred = control.compute_expected_state(qs_last, self.B, action) + pred = control.compute_expected_state(qs_last, self.B, action, B_dependencies=self.B_dependencies) return (pred, qs) @@ -272,6 +308,8 @@ def infer_policies(self, qs: List): self.C, self.pA, self.pB, + A_dependencies=self.A_dependencies, + B_dependencies=self.B_dependencies, gamma=self.gamma, use_utility=self.use_utility, use_states_info_gain=self.use_states_info_gain, diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index 18082fa2..badb8acd 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -126,11 +126,12 @@ def construct_policies(num_states, num_controls = None, policy_len=1, control_fa return jnp.stack(policies) -def update_posterior_policies(policy_matrix, qs_init, A, B, C, pA, pB, gamma=16.0, use_utility=True, use_states_info_gain=True, use_param_info_gain=False): +def update_posterior_policies(policy_matrix, qs_init, A, B, C, pA, pB, A_dependencies, B_dependencies, gamma=16.0, use_utility=True, use_states_info_gain=True, use_param_info_gain=False): # policy --> n_levels_factor_f x 1 # factor --> n_levels_factor_f x n_policies ## vmap across policies - compute_G_fixed_states = partial(compute_G_policy, qs_init, A, B, C, pA, pB, use_utility=use_utility, use_states_info_gain=use_states_info_gain, use_param_info_gain=use_param_info_gain) + compute_G_fixed_states = partial(compute_G_policy, qs_init, A, B, C, pA, pB, A_dependencies, B_dependencies, + use_utility=use_utility, use_states_info_gain=use_states_info_gain, use_param_info_gain=use_param_info_gain) # only in the case of policy-dependent qs_inits # in_axes_list = (1,) * n_factors @@ -141,14 +142,16 @@ def update_posterior_policies(policy_matrix, qs_init, A, B, C, pA, pB, gamma=16. return nn.softmax(gamma * neg_efe_all_policies), neg_efe_all_policies -def compute_expected_state(qs_prior, B, u_t): +def compute_expected_state(qs_prior, B, u_t, B_dependencies=None): """ Compute posterior over next state, given belief about previous state, transition model and action... """ assert len(u_t) == len(B) qs_next = [] - for qs_f, B_f, u_f in zip(qs_prior, B, u_t): - qs_next.append( B_f[..., u_f].dot(qs_f) ) + for B_f, u_f, deps in zip(B, u_t, B_dependencies): + # qs_next.append( B_f[..., u_f].dot(qs_f) ) + qs_next_f = factor_dot(B_f[...,u_f], qs_prior[deps]) + qs_next.append(qs_next_f) return qs_next @@ -186,27 +189,38 @@ def factor_dot(A, qs): return res -def compute_expected_obs(qs, A): +def compute_expected_obs(qs, A, A_dependencies): + """" + New version of expected observation (computation of Q(o|pi)) that takes into account sparse dependencies between observation + modalities and hidden state factors + """ qo = [] - for A_m in A: - qo.append( factor_dot(A_m, qs) ) + for A_m, deps in zip(A, A_dependencies): + relevant_factors = jtu.tree_map(lambda idx: qs[idx], deps) + qo.append( factor_dot(A_m, relevant_factors) ) return qo -def compute_info_gain(qs, qo, A): +def compute_info_gain(qs, qo, A, A_dependencies): + """" + New version of expected information gain that takes into account sparse dependencies between observation + modalities and hidden state factors + """ - x = qs[0] - for q in qs[1:]: - x = jnp.expand_dims(x, -1) * q - qs_H_A = 0 # expected entropy of the likelihood, under Q(s) H_qo = 0 # marginal entropy of Q(o) - for a, o in zip(A, qo): - qs_H_A -= (a * log_stable(a)).sum(0) + for a, o, deps in zip(A, qo, A_dependencies): + relevant_factors = jtu.tree_map(lambda idx: qs[idx], deps) + qs_joint_relevant = relevant_factors[0] + for q in relevant_factors[1:]: + qs_joint_relevant = jnp.expand_dims(qs_joint_relevant, -1) * q + H_A_m = -(a * log_stable(a)).sum(0) + qs_H_A += (H_A_m * qs_joint_relevant).sum() + H_qo -= (o * log_stable(o)).sum() - return H_qo - (qs_H_A * x).sum() + return H_qo - qs_H_A def compute_expected_utility(qo, C): @@ -294,16 +308,16 @@ def calc_pB_info_gain(pB, qs_t, qs_t_minus_1): # pB_infogain -= qs_pi[t][factor].dot(wB_factor_t.dot(previous_qs[factor])) return 0. -def compute_G_policy(qs_init, A, B, C, pA, pB, policy_i, use_utility=True, use_states_info_gain=True, use_param_info_gain=False): +def compute_G_policy(qs_init, A, B, C, pA, pB, A_dependencies, B_dependencies, policy_i, use_utility=True, use_states_info_gain=True, use_param_info_gain=False): """ Write a version of compute_G_policy that does the same computations as `compute_G_policy` but using `lax.scan` instead of a for loop. """ def scan_body(carry, t): qs, neg_G = carry - qs_next = compute_expected_state(qs, B, policy_i[t]) + qs_next = compute_expected_state(qs, B, policy_i[t], B_dependencies) - qo = compute_expected_obs(qs_next, A) + qo = compute_expected_obs(qs_next, A, A_dependencies) info_gain = compute_info_gain(qs_next, qo, A) if use_states_info_gain else 0. @@ -323,21 +337,21 @@ def scan_body(carry, t): return neg_G -if __name__ == '__main__': +# if __name__ == '__main__': - from jax import random - key = random.PRNGKey(1) - num_obs = [3, 4] +# from jax import random +# key = random.PRNGKey(1) +# num_obs = [3, 4] - A = [random.uniform(key, shape = (no, 2, 2)) for no in num_obs] - B = [random.uniform(key, shape = (2, 2, 2)), random.uniform(key, shape = (2, 2, 2))] - C = [log_stable(jnp.array([0.8, 0.1, 0.1])), log_stable(jnp.ones(4)/4)] - policy_1 = jnp.array([[0, 1], - [1, 1]]) - policy_2 = jnp.array([[1, 0], - [0, 0]]) - policy_matrix = jnp.stack([policy_1, policy_2]) # 2 x 2 x 2 tensor +# A = [random.uniform(key, shape = (no, 2, 2)) for no in num_obs] +# B = [random.uniform(key, shape = (2, 2, 2)), random.uniform(key, shape = (2, 2, 2))] +# C = [log_stable(jnp.array([0.8, 0.1, 0.1])), log_stable(jnp.ones(4)/4)] +# policy_1 = jnp.array([[0, 1], +# [1, 1]]) +# policy_2 = jnp.array([[1, 0], +# [0, 0]]) +# policy_matrix = jnp.stack([policy_1, policy_2]) # 2 x 2 x 2 tensor - qs_init = [jnp.ones(2)/2, jnp.ones(2)/2] - neg_G_all_policies = jit(update_posterior_policies)(policy_matrix, qs_init, A, B, C) - print(neg_G_all_policies) +# qs_init = [jnp.ones(2)/2, jnp.ones(2)/2] +# neg_G_all_policies = jit(update_posterior_policies)(policy_matrix, qs_init, A, B, C) +# print(neg_G_all_policies) From e9f2875b18b6150c4cc8001cf93ff0eb066df902 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 2 Nov 2023 18:02:04 +0100 Subject: [PATCH 146/232] - new version of expected information gain (over states, i.e. `qs`) that takes into account sparse A_dependencies and uses efficient einstein summation (`jnp.einsum`) to speed up computation - new version of `factor_dot` where leading dimension get contracted in case dimensions are aligned Co-authored-by: Dimitrije Markovic --- pymdp/jax/control.py | 22 +++++++++++++++++----- 1 file changed, 17 insertions(+), 5 deletions(-) diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index badb8acd..eb44cb50 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -173,17 +173,16 @@ def factor_dot(A, qs): Parameters ---------- - - `x` [1D numpy.ndarray] - either vector or array of arrays - The alternative array to perform the dot product with + - `qs` [list of 1D numpy.ndarray] - list of jnp.ndarrays Returns ------- - `Y` [1D numpy.ndarray] - the result of the dot product """ - dims = list(range(A.ndim - len(qs),len(qs)+A.ndim - len(qs))) + dims = list(range(A.ndim - len(qs),len(qs) + A.ndim - len(qs))) - arg_list = [A, list(range(A.ndim))] + list(chain(*([qs[f],[dims[f]]] for f in range(len(qs))))) + [[0]] + arg_list = [A, list(range(A.ndim))] + list(chain(*([qs[f],[dims[f]]] for f in range(len(qs))))) + [[0 if A.ndim > len(dims) else None]] res = jnp.einsum(*arg_list) @@ -202,12 +201,25 @@ def compute_expected_obs(qs, A, A_dependencies): return qo + def compute_info_gain(qs, qo, A, A_dependencies): """" New version of expected information gain that takes into account sparse dependencies between observation modalities and hidden state factors """ - + + def compute_info_gain_for_modality(qo_m, A_m, m): + H_qo = - (qo_m * log_stable(qo_m)).sum() + H_A_m = - (A_m * log_stable(A_m)).sum(0) + deps = A_dependencies[m] + einsum(H_A_m, ) + + dims = list(range(A.ndim - len(qs),len(qs)+A.ndim - len(qs))) + + arg_list = [A, list(range(A.ndim))] + list(chain(*([qs[f],[dims[f]]] for f in range(len(qs))))) + [[0]] + + res = jnp.einsum(*arg_list) + qs_H_A = 0 # expected entropy of the likelihood, under Q(s) H_qo = 0 # marginal entropy of Q(o) for a, o, deps in zip(A, qo, A_dependencies): From e07bbb21c80be6a06e31dd06739f31e1774c1e3a Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Thu, 2 Nov 2023 18:03:09 +0100 Subject: [PATCH 147/232] added keep_dim to factor_dot --- pymdp/jax/control.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index badb8acd..3e9403c1 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -168,7 +168,7 @@ def compute_expected_state_and_Bs(qs_prior, B, u_t): return qs_next, Bs -def factor_dot(A, qs): +def factor_dot(A, qs, keep_dims=None): """ Dot product of a multidimensional array with `x`. Parameters @@ -183,7 +183,7 @@ def factor_dot(A, qs): dims = list(range(A.ndim - len(qs),len(qs)+A.ndim - len(qs))) - arg_list = [A, list(range(A.ndim))] + list(chain(*([qs[f],[dims[f]]] for f in range(len(qs))))) + [[0]] + arg_list = [A, list(range(A.ndim))] + list(chain(*([qs[f],[dims[f]]] for f in range(len(qs))))) + [keep_dims] res = jnp.einsum(*arg_list) From 7ef6f92b12c4391dc68ed732850d9bfa34ee5080 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 16 Nov 2023 18:18:50 +0100 Subject: [PATCH 148/232] - removed enforced ordering in random_A_matrix utility Co-authored-by: Dimitrije Markovic --- pymdp/utils.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/pymdp/utils.py b/pymdp/utils.py index 60bc41e0..825bcb5b 100644 --- a/pymdp/utils.py +++ b/pymdp/utils.py @@ -100,7 +100,8 @@ def random_A_matrix(num_obs, num_states, A_factor_list=None): A = obj_array(num_modalities) for modality, modality_obs in enumerate(num_obs): - lagging_dimensions = [ns for i, ns in enumerate(num_states) if i in A_factor_list[modality]] + # lagging_dimensions = [ns for i, ns in enumerate(num_states) if i in A_factor_list[modality]] # enforces sortedness of A_factor_list + lagging_dimensions = [num_states[idx] for idx in A_factor_list[modality]] modality_shape = [modality_obs] + lagging_dimensions modality_dist = np.random.rand(*modality_shape) A[modality] = norm_dist(modality_dist) From 631ad212597d3fe2f8346cd27a9f89d652791a99 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 16 Nov 2023 18:19:08 +0100 Subject: [PATCH 149/232] - info gain and expected obs with factorization Co-authored-by: Dimitrije Markovic --- pymdp/jax/control.py | 82 ++++++++++++++------------------------------ 1 file changed, 26 insertions(+), 56 deletions(-) diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index 91175a20..79620373 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -10,7 +10,6 @@ from functools import partial from jax import lax, jit, vmap, nn from itertools import chain -from opt_einsum import contract from pymdp.jax.maths import * # import pymdp.jax.utils as utils @@ -170,77 +169,48 @@ def compute_expected_state_and_Bs(qs_prior, B, u_t): return qs_next, Bs -@partial(jit, static_argnames=['keep_dims']) -def factor_dot(M, xs, keep_dims: Optional[Tuple[int]] = None): - """ Dot product of a multidimensional array with `x`. - - Parameters - ---------- - - `qs` [list of 1D numpy.ndarray] - list of jnp.ndarrays - - Returns - ------- - - `Y` [1D numpy.ndarray] - the result of the dot product - """ - d = len(keep_dims) if keep_dims is not None else 0 - assert M.ndim == len(xs) + d - - all_dims = list(range(M.ndim)) - dims = all_dims if keep_dims is None else [i for i in range(M.ndim) if i not in keep_dims] - matrix = [[xs[f], [dims[f]]] for f in range(len(xs))] - args = [M, all_dims] - for row in matrix: - args.extend(row) - - args += [keep_dims] - return contract(*args, backend='jax') - def compute_expected_obs(qs, A, A_dependencies): - """" + """ New version of expected observation (computation of Q(o|pi)) that takes into account sparse dependencies between observation modalities and hidden state factors """ + + def compute_expected_obs_modality(A_m, m): + deps = A_dependencies[m] + relevant_factors = [qs[idx] for idx in deps] + return factor_dot(A_m, relevant_factors, keep_dims=(0,)) - qo = [] - for A_m, deps in zip(A, A_dependencies): - relevant_factors = jtu.tree_map(lambda idx: qs[idx], deps) - qo.append( factor_dot(A_m, relevant_factors) ) - - return qo - + return jtu.tree_map(compute_expected_obs_modality, A, list(range(len(A)))) def compute_info_gain(qs, qo, A, A_dependencies): - """" - New version of expected information gain that takes into account sparse dependencies between observation - modalities and hidden state factors + """ + New version of expected information gain that takes into account sparse dependencies between observation modalities and hidden state factors. """ def compute_info_gain_for_modality(qo_m, A_m, m): H_qo = - (qo_m * log_stable(qo_m)).sum() H_A_m = - (A_m * log_stable(A_m)).sum(0) deps = A_dependencies[m] - einsum(H_A_m, ) - - dims = list(range(A.ndim - len(qs),len(qs)+A.ndim - len(qs))) - - arg_list = [A, list(range(A.ndim))] + list(chain(*([qs[f],[dims[f]]] for f in range(len(qs))))) + [[0]] + relevant_factors = [qs[idx] for idx in deps] + qs_H_A_m = factor_dot(H_A_m, relevant_factors) + return H_qo - qs_H_A_m + + info_gains_per_modality = jtu.tree_map(compute_info_gain_for_modality, qo, A, list(range(len(A)))) + + return jtu.tree_reduce(lambda x,y: x+y, info_gains_per_modality) - res = jnp.einsum(*arg_list) +# qs_H_A = 0 # expected entropy of the likelihood, under Q(s) +# H_qo = 0 # marginal entropy of Q(o) +# for a, o, deps in zip(A, qo, A_dependencies): +# relevant_factors = jtu.tree_map(lambda idx: qs[idx], deps) +# qs_joint_relevant = relevant_factors[0] +# for q in relevant_factors[1:]: +# qs_joint_relevant = jnp.expand_dims(qs_joint_relevant, -1) * q +# H_A_m = -(a * log_stable(a)).sum(0) +# qs_H_A += (H_A_m * qs_joint_relevant).sum() - qs_H_A = 0 # expected entropy of the likelihood, under Q(s) - H_qo = 0 # marginal entropy of Q(o) - for a, o, deps in zip(A, qo, A_dependencies): - relevant_factors = jtu.tree_map(lambda idx: qs[idx], deps) - qs_joint_relevant = relevant_factors[0] - for q in relevant_factors[1:]: - qs_joint_relevant = jnp.expand_dims(qs_joint_relevant, -1) * q - H_A_m = -(a * log_stable(a)).sum(0) - qs_H_A += (H_A_m * qs_joint_relevant).sum() +# H_qo -= (o * log_stable(o)).sum() - H_qo -= (o * log_stable(o)).sum() - - return H_qo - qs_H_A - def compute_expected_utility(qo, C): util = 0. From 2ef1287db9ad6985e047f1f3779a82c5d13c5e28 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 16 Nov 2023 18:19:21 +0100 Subject: [PATCH 150/232] -moved factor_dot in pymdp.jax.maths Co-authored-by: Dimitrije Markovic --- pymdp/jax/maths.py | 31 ++++++++++++++++++++++++++++++- 1 file changed, 30 insertions(+), 1 deletion(-) diff --git a/pymdp/jax/maths.py b/pymdp/jax/maths.py index 0b4db6d6..ff23841a 100644 --- a/pymdp/jax/maths.py +++ b/pymdp/jax/maths.py @@ -1,11 +1,40 @@ -from jax import tree_util, nn, jit import jax.numpy as jnp +from functools import partial +from typing import Optional, Tuple +from jax import tree_util, nn, jit +from opt_einsum import contract + MINVAL = jnp.finfo(float).eps def log_stable(x): return jnp.log(jnp.clip(x, a_min=MINVAL)) +@partial(jit, static_argnames=['keep_dims']) +def factor_dot(M, xs, keep_dims: Optional[Tuple[int]] = None): + """ Dot product of a multidimensional array with `x`. + + Parameters + ---------- + - `qs` [list of 1D numpy.ndarray] - list of jnp.ndarrays + + Returns + ------- + - `Y` [1D numpy.ndarray] - the result of the dot product + """ + d = len(keep_dims) if keep_dims is not None else 0 + assert M.ndim == len(xs) + d + + all_dims = list(range(M.ndim)) + dims = all_dims if keep_dims is None else [i for i in range(M.ndim) if i not in keep_dims] + matrix = [[xs[f], [dims[f]]] for f in range(len(xs))] + args = [M, all_dims] + for row in matrix: + args.extend(row) + + args += [keep_dims] + return contract(*args, backend='jax') + def compute_log_likelihood_single_modality(o_m, A_m, distr_obs=True): """ Compute observation likelihood for a single modality (observation and likelihood)""" if distr_obs: From b333dca90d850bd3ff2fcb58b33f6e04eb7b70a5 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 16 Nov 2023 18:19:32 +0100 Subject: [PATCH 151/232] unit tests for expected info gain and expected obs, factorized Co-authored-by: Dimitrije Markovic --- test/test_control_jax.py | 144 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 144 insertions(+) create mode 100644 test/test_control_jax.py diff --git a/test/test_control_jax.py b/test/test_control_jax.py new file mode 100644 index 00000000..1d767343 --- /dev/null +++ b/test/test_control_jax.py @@ -0,0 +1,144 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +""" Unit Tests +__author__: Dimitrije Markovic, Conor Heins +""" + +import os +import unittest +import pytest + +import numpy as np +import jax.numpy as jnp +import jax.random as jr +import jax.tree_util as jtu + +import pymdp.jax.control as ctl_jax +import pymdp.control as ctl_np + +from pymdp.jax.maths import factor_dot +from pymdp import utils + +cfg = {"source_key": 0, "num_models": 4} + +def generate_model_params(): + """ + Generate random model dimensions + """ + rng_keys = jr.split(jr.PRNGKey(cfg["source_key"]), cfg["num_models"]) + num_factors_list = [ jr.randint(key, (1,), 1, 10)[0].item() for key in rng_keys ] + num_states_list = [ jr.randint(key, (nf,), 1, 5).tolist() for nf, key in zip(num_factors_list, rng_keys) ] + + rng_keys = jr.split(rng_keys[-1], cfg["num_models"]) + num_modalities_list = [ jr.randint(key, (1,), 1, 10)[0].item() for key in rng_keys ] + num_obs_list = [ jr.randint(key, (nm,), 1, 5).tolist() for nm, key in zip(num_modalities_list, rng_keys) ] + + rng_keys = jr.split(rng_keys[-1], cfg["num_models"]) + A_deps_list = [] + for nf, nm, model_key in zip(num_factors_list, num_modalities_list, rng_keys): + keys_model_i = jr.split(model_key, nm) + A_deps_model_i = [jr.randint(key, (nm,), 0, nf).tolist() for key in keys_model_i] + A_deps_list.append(A_deps_model_i) + + return {'nf_list': num_factors_list, + 'ns_list': num_states_list, + 'nm_list': num_modalities_list, + 'no_list': num_obs_list, + 'A_deps_list': A_deps_list} + +class TestControlJax(unittest.TestCase): + + def test_get_expected_obs_factorized(self): + """ + Tests the jax-ified version of computations of expected observations under some hidden states and policy + """ + gm_params = generate_model_params() + num_factors_list, num_states_list, num_modalities_list, num_obs_list, A_deps_list = gm_params['nf_list'], gm_params['ns_list'], gm_params['nm_list'], gm_params['no_list'], gm_params['A_deps_list'] + for (num_states, num_obs, A_deps) in zip(num_states_list, num_obs_list, A_deps_list): + + qs_numpy = utils.random_single_categorical(num_states) + qs_jax = list(qs_numpy) + + A_np = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_deps) + A_jax = jtu.tree_map(lambda x: jnp.array(x), list(A_np)) + + qo_test = ctl_jax.compute_expected_obs(qs_jax, A_jax, A_deps) + qo_validation = ctl_np.get_expected_obs_factorized([qs_numpy], A_np, A_deps) # need to wrap `qs` in list because `get_expected_obs_factorized` expects a list of `qs` (representing multiple timesteps) + + for qo_m, qo_val_m in zip(qo_test, qo_validation[0]): # need to extract first index of `qo_validation` because `get_expected_obs_factorized` returns a list of `qo` (representing multiple timesteps) + self.assertTrue(np.allclose(qo_m, qo_val_m)) + + def test_info_gain_factorized(self): + """ + Unit test the `calc_states_info_gain_factorized` function by qualitatively checking that in the T-Maze (contextual bandit) + example, the state info gain is higher for the policy that leads to visiting the cue, which is higher than state info gain + for visiting the bandit arm, which in turn is higher than the state info gain for the policy that leads to staying in the start state. + """ + + num_states = [2, 3] + num_obs = [3, 3, 3] + + A_dependencies = [[0, 1], [0, 1], [1]] + A = [] + for m, obs in enumerate(num_obs): + lagging_dimensions = [ns for i, ns in enumerate(num_states) if i in A_dependencies[m]] + modality_shape = [obs] + lagging_dimensions + A.append(np.zeros(modality_shape)) + if m == 0: + A[m][:, :, 0] = np.ones( (num_obs[m], num_states[0]) ) / num_obs[m] + A[m][:, :, 1] = np.ones( (num_obs[m], num_states[0]) ) / num_obs[m] + A[m][:, :, 2] = np.array([[0.9, 0.1], [0.0, 0.0], [0.1, 0.9]]) # cue statistics + if m == 1: + A[m][2, :, 0] = np.ones(num_states[0]) + A[m][0:2, :, 1] = np.array([[0.6, 0.4], [0.6, 0.4]]) # bandit statistics (mapping between reward-state (first hidden state factor) and rewards (Good vs Bad)) + A[m][2, :, 2] = np.ones(num_states[0]) + if m == 2: + A[m] = np.eye(obs) + + qs_start = list(utils.obj_array_uniform(num_states)) + qs_start[1] = np.array([1., 0., 0.]) # agent believes it's in the start state + + A = [jnp.array(A_m) for A_m in A] + qs_start = [jnp.array(qs) for qs in qs_start] + qo_start = ctl_jax.compute_expected_obs(qs_start, A, A_dependencies) + + start_info_gain = ctl_jax.compute_info_gain(qs_start, qo_start, A, A_dependencies) + + qs_arm = list(utils.obj_array_uniform(num_states)) + qs_arm[1] = np.array([0., 1., 0.]) # agent believes it's in the arm-visiting state + qs_arm = [jnp.array(qs) for qs in qs_arm] + qo_arm = ctl_jax.compute_expected_obs(qs_arm, A, A_dependencies) + + arm_info_gain = ctl_jax.compute_info_gain(qs_arm, qo_arm, A, A_dependencies) + + qs_cue = utils.obj_array_uniform(num_states) + qs_cue[1] = np.array([0., 0., 1.]) # agent believes it's in the cue-visiting state + qs_cue = [jnp.array(qs) for qs in qs_cue] + + qo_cue = ctl_jax.compute_expected_obs(qs_cue, A, A_dependencies) + cue_info_gain = ctl_jax.compute_info_gain(qs_cue, qo_cue, A, A_dependencies) + + self.assertGreater(arm_info_gain, start_info_gain) + self.assertGreater(cue_info_gain, arm_info_gain) + + gm_params = generate_model_params() + num_factors_list, num_states_list, num_modalities_list, num_obs_list, A_deps_list = gm_params['nf_list'], gm_params['ns_list'], gm_params['nm_list'], gm_params['no_list'], gm_params['A_deps_list'] + for (num_states, num_obs, A_deps) in zip(num_states_list, num_obs_list, A_deps_list): + + qs_numpy = utils.random_single_categorical(num_states) + qs_jax = list(qs_numpy) + + A_np = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_deps) + A_jax = jtu.tree_map(lambda x: jnp.array(x), list(A_np)) + + qo = ctl_jax.compute_expected_obs(qs_jax, A_jax, A_deps) + + info_gain = ctl_jax.compute_info_gain(qs_jax, qo, A_jax, A_deps) + info_gain_validation = ctl_np.calc_states_info_gain_factorized(A_np, [qs_numpy], A_deps) + + self.assertTrue(np.allclose(info_gain, info_gain_validation)) + + +if __name__ == "__main__": + unittest.main() \ No newline at end of file From 6d9f6fafef4dfe0a6a558b8772e4a233754c68f4 Mon Sep 17 00:00:00 2001 From: conorheins Date: Tue, 21 Nov 2023 19:22:00 +0100 Subject: [PATCH 152/232] factorized version of marginal message passing that takes advantage of sparse conditional dependencies between observation modalities and hidden state factors, and interactions between hidden state factors in the B tensors --- pymdp/agent.py | 49 +++++++------- pymdp/algos/__init__.py | 2 +- pymdp/algos/mmp.py | 141 +++++++++++++++++++++++++++++++++++++++- pymdp/control.py | 119 +++++++++++++++++++++++++++++++++ pymdp/inference.py | 81 ++++++++++++++++++++++- pymdp/maths.py | 17 +++++ test/test_agent.py | 12 ++-- 7 files changed, 388 insertions(+), 33 deletions(-) diff --git a/pymdp/agent.py b/pymdp/agent.py index 35bdba75..ad61e6b6 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -500,9 +500,11 @@ def infer_states(self, observation, distr_obs=False): latest_obs = self.prev_obs latest_actions = self.prev_actions - qs, F = inference.update_posterior_states_full( + qs, F = inference.update_posterior_states_full_factorized( self.A, + self.mb_dict, self.B, + self.B_factor_list, latest_obs, self.policies, latest_actions, @@ -575,7 +577,7 @@ def _infer_states_test(self, observation, distr_obs=False): else: return qs - def infer_policies(self): + def infer_policies_old(self): """ Perform policy inference by optimizing a posterior (categorical) distribution over policies. This distribution is computed as the softmax of ``G * gamma + lnE`` where ``G`` is the negative expected @@ -635,7 +637,7 @@ def infer_policies(self): self.G = G return q_pi, G - def infer_policies_factorized(self): + def infer_policies(self): """ Perform policy inference by optimizing a posterior (categorical) distribution over policies. This distribution is computed as the softmax of ``G * gamma + lnE`` where ``G`` is the negative expected @@ -670,26 +672,27 @@ def infer_policies_factorized(self): gamma = self.gamma ) elif self.inference_algo == "MMP": - Raise(NotImplementedError("Factorized inference not implemented for MMP")) - - # future_qs_seq = self.get_future_qs() - - # q_pi, G = control.update_posterior_policies_full( - # future_qs_seq, - # self.A, - # self.B, - # self.C, - # self.policies, - # self.use_utility, - # self.use_states_info_gain, - # self.use_param_info_gain, - # self.latest_belief, - # self.pA, - # self.pB, - # F = self.F, - # E = self.E, - # gamma = self.gamma - # ) + + future_qs_seq = self.get_future_qs() + + q_pi, G = control.update_posterior_policies_full_factorized( + future_qs_seq, + self.A, + self.B, + self.C, + self.A_factor_list, + self.B_factor_list, + self.policies, + self.use_utility, + self.use_states_info_gain, + self.use_param_info_gain, + self.latest_belief, + self.pA, + self.pB, + F = self.F, + E = self.E, + gamma = self.gamma + ) if hasattr(self, "q_pi_hist"): self.q_pi_hist.append(q_pi) diff --git a/pymdp/algos/__init__.py b/pymdp/algos/__init__.py index 0cf505f9..bb08cc41 100644 --- a/pymdp/algos/__init__.py +++ b/pymdp/algos/__init__.py @@ -1,2 +1,2 @@ from .fpi import run_vanilla_fpi, run_vanilla_fpi_factorized -from .mmp import run_mmp, _run_mmp_testing +from .mmp import run_mmp, run_mmp_factorized, _run_mmp_testing diff --git a/pymdp/algos/mmp.py b/pymdp/algos/mmp.py index e38b5b7f..d24f318a 100644 --- a/pymdp/algos/mmp.py +++ b/pymdp/algos/mmp.py @@ -7,7 +7,6 @@ from pymdp.maths import spm_dot, spm_norm, softmax, calc_free_energy, spm_log_single import copy - def run_mmp( lh_seq, B, policy, prev_actions=None, prior=None, num_iter=10, grad_descent=True, tau=0.25, last_timestep = False): """ @@ -90,6 +89,7 @@ def run_mmp( # likelihood if t < past_len: lnA = spm_log_single(spm_dot(lh_seq[t], qs_seq[t], [f])) + print(f'Enumerated version: lnA at time {t}: {lnA}') else: lnA = np.zeros(num_states[f]) @@ -131,6 +131,145 @@ def run_mmp( return qs_seq, F +def run_mmp_factorized( + lh_seq, mb_dict, B, B_factor_list, policy, prev_actions=None, prior=None, num_iter=10, grad_descent=True, tau=0.25, last_timestep = False): + """ + Marginal message passing scheme for updating marginal posterior beliefs about hidden states over time, + conditioned on a particular policy. + + Parameters + ---------- + lh_seq: ``numpy.ndarray`` of dtype object + Log likelihoods of hidden states under a sequence of observations over time. This is assumed to already be log-transformed. Each ``lh_seq[t]`` contains + the log likelihood of hidden states for a particular observation at time ``t`` + mb_dict: ``dict`` + B: ``numpy.ndarray`` of dtype object + Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. + Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability + of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. + B_factor_list: ``list`` of ``list`` of ``int`` + policy: 2D ``numpy.ndarray`` + Matrix of shape ``(policy_len, num_control_factors)`` that indicates the indices of each action (control state index) upon timestep ``t`` and control_factor ``f` in the element ``policy[t,f]`` for a given policy. + prev_actions: ``numpy.ndarray``, default None + If provided, should be a matrix of previous actions of shape ``(infer_len, num_control_factors)`` that indicates the indices of each action (control state index) taken in the past (up until the current timestep). + prior: ``numpy.ndarray`` of dtype object, default None + If provided, the prior beliefs about initial states (at t = 0, relative to ``infer_len``). If ``None``, this defaults + to a flat (uninformative) prior over hidden states. + numiter: int, default 10 + Number of variational iterations. + grad_descent: Bool, default True + Flag for whether to use gradient descent (free energy gradient updates) instead of fixed point solution to the posterior beliefs + tau: float, default 0.25 + Decay constant for use in ``grad_descent`` version. Tunes the size of the gradient descent updates to the posterior. + last_timestep: Bool, default False + Flag for whether we are at the last timestep of belief updating + + Returns + --------- + qs_seq: ``numpy.ndarray`` of dtype object + Posterior beliefs over hidden states under the policy. Nesting structure is timepoints, factors, + where e.g. ``qs_seq[t][f]`` stores the marginal belief about factor ``f`` at timepoint ``t`` under the policy in question. + F: float + Variational free energy of the policy. + """ + + # window + past_len = len(lh_seq) + future_len = policy.shape[0] + + if last_timestep: + infer_len = past_len + future_len - 1 + else: + infer_len = past_len + future_len + + future_cutoff = past_len + future_len - 2 + + # dimensions + _, num_states, _, num_factors = get_model_dimensions(A=None, B=B) + + # beliefs + qs_seq = obj_array(infer_len) + for t in range(infer_len): + qs_seq[t] = obj_array_uniform(num_states) + + # last message + qs_T = obj_array_zeros(num_states) + + # prior + if prior is None: + prior = obj_array_uniform(num_states) + + # transposed transition + trans_B = obj_array(num_factors) + + for f in range(num_factors): + trans_B[f] = spm_norm(np.swapaxes(B[f],0,1)) + + if prev_actions is not None: + policy = np.vstack((prev_actions, policy)) + + A_factor_list, A_modality_list = mb_dict['A_factor_list'], mb_dict['A_modality_list'] + + joint_lh_seq = obj_array(len(lh_seq)) + num_modalities = len(A_factor_list) + for t in range(len(lh_seq)): + joint_loglikelihood = np.zeros(tuple(num_states)) + for m in range(num_modalities): + reshape_dims = num_factors*[1] + for _f_id in A_factor_list[m]: + reshape_dims[_f_id] = num_states[_f_id] + joint_loglikelihood += lh_seq[t][m].reshape(reshape_dims) # add up all the log-likelihoods after reshaping them to the global common dimensions of all hidden state factors + joint_lh_seq[t] = joint_loglikelihood + + for itr in range(num_iter): + F = 0.0 # reset variational free energy (accumulated over time and factors, but reset per iteration) + for t in range(infer_len): + for f in range(num_factors): + # likelihood + lnA = np.zeros(num_states[f]) + if t < past_len: + for m in A_modality_list[f]: + lnA += spm_log_single(spm_dot(lh_seq[t][m], qs_seq[t][A_factor_list[m]], [A_factor_list[m].index(f)])) + print(f'Factorized version: lnA at time {t}: {lnA}') + + # past message + if t == 0: + lnB_past = spm_log_single(prior[f]) + else: + past_msg = spm_dot(B[f][...,int(policy[t - 1, f])], qs_seq[t-1][B_factor_list[f]]) + lnB_past = spm_log_single(past_msg) + + # future message + if t >= future_cutoff: + lnB_future = qs_T[f] + else: + future_msg = spm_dot(trans_B[f][...,int(policy[t, f])], qs_seq[t+1][B_factor_list[f]]) + lnB_future = spm_log_single(future_msg) + + # inference + if grad_descent: + sx = qs_seq[t][f] # save this as a separate variable so that it can be used in VFE computation + lnqs = spm_log_single(sx) + coeff = 1 if (t >= future_cutoff) else 2 + err = (coeff * lnA + lnB_past + lnB_future) - coeff * lnqs + lnqs = lnqs + tau * (err - err.mean()) + qs_seq[t][f] = softmax(lnqs) + if (t == 0) or (t == (infer_len-1)): + F += sx.dot(0.5*err) + else: + F += sx.dot(0.5*(err - (num_factors - 1)*lnA/num_factors)) # @NOTE: not sure why Karl does this in SPM_MDP_VB_X, we should look into this + else: + qs_seq[t][f] = softmax(lnA + lnB_past + lnB_future) + + if not grad_descent: + + if t < past_len: + F += calc_free_energy(qs_seq[t], prior, num_factors, likelihood = spm_log_single(joint_lh_seq[t]) ) + else: + F += calc_free_energy(qs_seq[t], prior, num_factors) + + return qs_seq, F + def _run_mmp_testing( lh_seq, B, policy, prev_actions=None, prior=None, num_iter=10, grad_descent=True, tau=0.25, last_timestep = False): """ diff --git a/pymdp/control.py b/pymdp/control.py index 0998b96f..03df4785 100644 --- a/pymdp/control.py +++ b/pymdp/control.py @@ -121,6 +121,125 @@ def update_posterior_policies_full( return q_pi, G +def update_posterior_policies_full_factorized( + qs_seq_pi, + A, + B, + C, + A_factor_list, + B_factor_list, + policies, + use_utility=True, + use_states_info_gain=True, + use_param_info_gain=False, + prior=None, + pA=None, + pB=None, + F = None, + E = None, + gamma=16.0 +): + """ + Update posterior beliefs about policies by computing expected free energy of each policy and integrating that + with the variational free energy of policies ``F`` and prior over policies ``E``. This is intended to be used in conjunction + with the ``update_posterior_states_full`` method of ``inference.py``, since the full posterior over future timesteps, under all policies, is + assumed to be provided in the input array ``qs_seq_pi``. + + Parameters + ---------- + qs_seq_pi: ``numpy.ndarray`` of dtype object + Posterior beliefs over hidden states for each policy. Nesting structure is policies, timepoints, factors, + where e.g. ``qs_seq_pi[p][t][f]`` stores the marginal belief about factor ``f`` at timepoint ``t`` under policy ``p``. + A: ``numpy.ndarray`` of dtype object + Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of + stores an ``numpy.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store + the probability of observation level ``i`` given hidden state levels ``j, k, ...`` + B: ``numpy.ndarray`` of dtype object + Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. + Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability + of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. + C: ``numpy.ndarray`` of dtype object + Prior over observations or 'prior preferences', storing the "value" of each outcome in terms of relative log probabilities. + This is softmaxed to form a proper probability distribution before being used to compute the expected utility term of the expected free energy. + A_factor_list: ``list`` of ``list``s of ``int`` + ``list`` that stores the indices of the hidden state factor indices that each observation modality depends on. For example, if ``A_factor_list[m] = [0, 1]``, then + observation modality ``m`` depends on hidden state factors 0 and 1. + B_factor_list: ``list`` of ``list``s of ``int`` + ``list`` that stores the indices of the hidden state factor indices that each hidden state factor depends on. For example, if ``B_factor_list[f] = [0, 1]``, then + the transitions in hidden state factor ``f`` depend on hidden state factors 0 and 1. + policies: ``list`` of 2D ``numpy.ndarray`` + ``list`` that stores each policy in ``policies[p_idx]``. Shape of ``policies[p_idx]`` is ``(num_timesteps, num_factors)`` where `num_timesteps` is the temporal + depth of the policy and ``num_factors`` is the number of control factors. + use_utility: ``Bool``, default ``True`` + Boolean flag that determines whether expected utility should be incorporated into computation of EFE. + use_states_info_gain: ``Bool``, default ``True`` + Boolean flag that determines whether state epistemic value (info gain about hidden states) should be incorporated into computation of EFE. + use_param_info_gain: ``Bool``, default ``False`` + Boolean flag that determines whether parameter epistemic value (info gain about generative model parameters) should be incorporated into computation of EFE. + prior: ``numpy.ndarray`` of dtype object, default ``None`` + If provided, this is a ``numpy`` object array with one sub-array per hidden state factor, that stores the prior beliefs about initial states. + If ``None``, this defaults to a flat (uninformative) prior over hidden states. + pA: ``numpy.ndarray`` of dtype object, default ``None`` + Dirichlet parameters over observation model (same shape as ``A``) + pB: ``numpy.ndarray`` of dtype object, default ``None`` + Dirichlet parameters over transition model (same shape as ``B``) + F: 1D ``numpy.ndarray``, default ``None`` + Vector of variational free energies for each policy + E: 1D ``numpy.ndarray``, default ``None`` + Vector of prior probabilities of each policy (what's referred to in the active inference literature as "habits"). If ``None``, this defaults to a flat (uninformative) prior over policies. + gamma: ``float``, default 16.0 + Prior precision over policies, scales the contribution of the expected free energy to the posterior over policies + + Returns + ---------- + q_pi: 1D ``numpy.ndarray`` + Posterior beliefs over policies, i.e. a vector containing one posterior probability per policy. + G: 1D ``numpy.ndarray`` + Negative expected free energies of each policy, i.e. a vector containing one negative expected free energy per policy. + """ + + num_obs, num_states, num_modalities, num_factors = utils.get_model_dimensions(A, B) + horizon = len(qs_seq_pi[0]) + num_policies = len(qs_seq_pi) + + qo_seq = utils.obj_array(horizon) + for t in range(horizon): + qo_seq[t] = utils.obj_array_zeros(num_obs) + + # initialise expected observations + qo_seq_pi = utils.obj_array(num_policies) + + # initialize (negative) expected free energies for all policies + G = np.zeros(num_policies) + + if F is None: + F = spm_log_single(np.ones(num_policies) / num_policies) + + if E is None: + lnE = spm_log_single(np.ones(num_policies) / num_policies) + else: + lnE = spm_log_single(E) + + for p_idx, policy in enumerate(policies): + + qo_seq_pi[p_idx] = get_expected_obs_factorized(qs_seq_pi[p_idx], A, A_factor_list) + + if use_utility: + G[p_idx] += calc_expected_utility(qo_seq_pi[p_idx], C) + + if use_states_info_gain: + G[p_idx] += calc_states_info_gain_factorized(A, qs_seq_pi[p_idx], A_factor_list) + + if use_param_info_gain: + if pA is not None: + G[idx] += calc_pA_info_gain_factorized(pA, qo_seq_pi[p_idx], qs_seq_pi[p_idx], A_factor_list) + if pB is not None: + G[idx] += calc_pB_info_gain_interactions(pB, qs_seq_pi[p_idx], qs, B_factor_list, policy) + + q_pi = softmax(G * gamma - F + lnE) + + return q_pi, G + def update_posterior_policies( qs, diff --git a/pymdp/inference.py b/pymdp/inference.py index a84f7609..59d3ec69 100644 --- a/pymdp/inference.py +++ b/pymdp/inference.py @@ -5,8 +5,8 @@ import numpy as np from pymdp import utils -from pymdp.maths import get_joint_likelihood_seq -from pymdp.algos import run_vanilla_fpi, run_vanilla_fpi_factorized, run_mmp, _run_mmp_testing +from pymdp.maths import get_joint_likelihood_seq, get_joint_likelihood_seq_by_modality +from pymdp.algos import run_vanilla_fpi, run_vanilla_fpi_factorized, run_mmp, run_mmp_factorized, _run_mmp_testing VANILLA = "VANILLA" VMP = "VMP" @@ -86,6 +86,83 @@ def update_posterior_states_full( return qs_seq_pi, F +def update_posterior_states_full_factorized( + A, + mb_dict, + B, + B_factor_list, + prev_obs, + policies, + prev_actions=None, + prior=None, + policy_sep_prior = True, + **kwargs, +): + """ + Update posterior over hidden states using marginal message passing + + Parameters + ---------- + A: ``numpy.ndarray`` of dtype object + Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of + stores an ``numpy.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store + the probability of observation level ``i`` given hidden state levels ``j, k, ...`` + mb_dict: ``Dict`` + B: ``numpy.ndarray`` of dtype object + Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. + Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability + of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. + B_factor_list: ``list`` of ``list`` + prev_obs: ``list`` + List of observations over time. Each observation in the list can be an ``int``, a ``list`` of ints, a ``tuple`` of ints, a one-hot vector or an object array of one-hot vectors. + policies: ``list`` of 2D ``numpy.ndarray`` + List that stores each policy in ``policies[p_idx]``. Shape of ``policies[p_idx]`` is ``(num_timesteps, num_factors)`` where `num_timesteps` is the temporal + depth of the policy and ``num_factors`` is the number of control factors. + prior: ``numpy.ndarray`` of dtype object, default ``None`` + If provided, this a ``numpy.ndarray`` of dtype object, with one sub-array per hidden state factor, that stores the prior beliefs about initial states. + If ``None``, this defaults to a flat (uninformative) prior over hidden states. + policy_sep_prior: ``Bool``, default ``True`` + Flag determining whether the prior beliefs from the past are unconditioned on policy, or separated by /conditioned on the policy variable. + **kwargs: keyword arguments + Optional keyword arguments for the function ``algos.mmp.run_mmp`` + + Returns + --------- + qs_seq_pi: ``numpy.ndarray`` of dtype object + Posterior beliefs over hidden states for each policy. Nesting structure is policies, timepoints, factors, + where e.g. ``qs_seq_pi[p][t][f]`` stores the marginal belief about factor ``f`` at timepoint ``t`` under policy ``p``. + F: 1D ``numpy.ndarray`` + Vector of variational free energies for each policy + """ + + num_obs, num_states, num_modalities, num_factors = utils.get_model_dimensions(A, B) + + prev_obs = utils.process_observation_seq(prev_obs, num_modalities, num_obs) + + lh_seq = get_joint_likelihood_seq_by_modality(A, prev_obs, num_states) + + if prev_actions is not None: + prev_actions = np.stack(prev_actions,0) + + qs_seq_pi = utils.obj_array(len(policies)) + F = np.zeros(len(policies)) # variational free energy of policies + + for p_idx, policy in enumerate(policies): + + # get sequence and the free energy for policy + qs_seq_pi[p_idx], F[p_idx] = run_mmp_factorized( + lh_seq, + mb_dict, + B, + B_factor_list, + policy, + prev_actions=prev_actions, + prior= prior[p_idx] if policy_sep_prior else prior, + **kwargs + ) + + return qs_seq_pi, F + def _update_posterior_states_full_test( A, B, diff --git a/pymdp/maths.py b/pymdp/maths.py index c5d38fa4..6f2fd3b8 100644 --- a/pymdp/maths.py +++ b/pymdp/maths.py @@ -250,6 +250,23 @@ def get_joint_likelihood_seq(A, obs, num_states): ll_seq[t] = get_joint_likelihood(A, obs_t, num_states) return ll_seq +def get_joint_likelihood_seq_by_modality(A, obs, num_states): + """ + Returns joint likelihoods for each modality separately + """ + + ll_seq = utils.obj_array(len(obs)) + n_modalities = len(A) + + for t, obs_t in enumerate(obs): + likelihood = utils.obj_array(n_modalities) + obs_t_obj = utils.to_obj_array(obs_t) + for (m, A_m) in enumerate(A): + likelihood[m] = dot_likelihood(A_m, obs_t_obj[m]) + ll_seq[t] = likelihood + + return ll_seq + def spm_norm(A): """ diff --git a/test/test_agent.py b/test/test_agent.py index e9a44b0e..161bca56 100644 --- a/test/test_agent.py +++ b/test/test_agent.py @@ -164,7 +164,7 @@ def test_agent_infer_states(self): policies = control.construct_policies(num_states, num_controls, policy_len = planning_horizon) - qs_pi_validation, _ = inference.update_posterior_states_full(A, B, [o], policies, prior = agent.D, policy_sep_prior = False) + qs_pi_validation, _ = inference.update_posterior_states_full_factorized(A, agent.mb_dict, B, agent.B_factor_list, [o], policies, prior = agent.D, policy_sep_prior = False) for p_idx in range(len(policies)): for t in range(planning_horizon+backwards_horizon): @@ -280,7 +280,7 @@ def test_agent_with_A_learning_vanilla_factorized(self): print(t) qx = agent.infer_states(obs_seq[t]) - agent.infer_policies_factorized() + agent.infer_policies() agent.sample_action() # compute the predicted update to the action-conditioned slice of qB @@ -662,7 +662,7 @@ def test_agent_distributional_obs(self): policies = control.construct_policies(num_states, num_controls, policy_len = planning_horizon) - qs_pi_validation, _ = inference.update_posterior_states_full(A, B, [p_o], policies, prior = agent.D, policy_sep_prior = False) + qs_pi_validation, _ = inference.update_posterior_states_full_factorized(A, agent.mb_dict, B, agent.B_factor_list, [p_o], policies, prior = agent.D, policy_sep_prior = False) for p_idx in range(len(policies)): for t in range(planning_horizon+backwards_horizon): @@ -758,7 +758,7 @@ def test_actinfloop_factorized(self): for t in range(5): qs_out = agent.infer_states(obs_seq[t]) - agent.infer_policies_factorized() + agent.infer_policies() agent.sample_action() """ Test to make sure it works even when generative model sparsity is not taken advantage of """ @@ -773,7 +773,7 @@ def test_actinfloop_factorized(self): for t in range(5): qs_out = agent.infer_states(obs_seq[t]) - agent.infer_policies_factorized() + agent.infer_policies() agent.sample_action() """ Test with pA and pB learning & information gain """ @@ -797,7 +797,7 @@ def test_actinfloop_factorized(self): for t in range(5): qs_out = agent.infer_states(obs_seq[t]) - agent.infer_policies_factorized() + agent.infer_policies() agent.sample_action() agent.update_A(obs_seq[t]) if t > 0: From d9ec8b4833199d8736ac0507969dcc8cfeba997e Mon Sep 17 00:00:00 2001 From: Tim Verbelen Date: Tue, 14 Nov 2023 11:03:52 +0100 Subject: [PATCH 153/232] add inductive inference to infer_policies_factorized --- pymdp/agent.py | 8 ++++ pymdp/control.py | 106 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 114 insertions(+) diff --git a/pymdp/agent.py b/pymdp/agent.py index ad61e6b6..53b1cfdd 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -37,6 +37,7 @@ def __init__( C=None, D=None, E = None, + H = None, pA=None, pB = None, pD = None, @@ -248,6 +249,12 @@ def __init__( else: self.E = self._construct_E_prior() + # Construct I for backwards induction (if H specified) + if H is not None: + self.I = control.backwards_induction(H, B, B_factor_list, threshold=1/16, depth=5) + else: + self.I = None + self.edge_handling_params = {} self.edge_handling_params['use_BMA'] = use_BMA # creates a 'D-like' moving prior self.edge_handling_params['policy_sep_prior'] = policy_sep_prior # carries forward last timesteps posterior, in a policy-conditioned way @@ -669,6 +676,7 @@ def infer_policies(self): self.pA, self.pB, E = self.E, + I = self.I, gamma = self.gamma ) elif self.inference_algo == "MMP": diff --git a/pymdp/control.py b/pymdp/control.py index 03df4785..d0c877fd 100644 --- a/pymdp/control.py +++ b/pymdp/control.py @@ -346,6 +346,7 @@ def update_posterior_policies_factorized( pA=None, pB=None, E = None, + I = None, gamma=16.0 ): """ @@ -421,6 +422,9 @@ def update_posterior_policies_factorized( if use_states_info_gain: G[idx] += calc_states_info_gain_factorized(A, qs_pi, A_factor_list) + if I is not None: + G[idx] += calc_inductive_cost(qs, qs_pi, I) + if use_param_info_gain: if pA is not None: G[idx] += calc_pA_info_gain_factorized(pA, qo_pi, qs_pi, A_factor_list) @@ -580,6 +584,49 @@ def get_expected_obs_factorized(qs_pi, A, A_factor_list): return qo_pi +def calc_inductive_cost(qs, qs_pi, I, epsilon=1e-3): + """ + Computes the inductive cost of a state. + + Parameters + ---------- + qs: ``numpy.ndarray`` of dtype object + Marginal posterior beliefs over hidden states at a given timepoint. + qs_pi: ``list`` of ``numpy.ndarray`` of dtype object + Predictive posterior beliefs over hidden states expected under the policy, where ``qs_pi[t]`` stores the beliefs about + states expected under the policy at time ``t`` + I: ``numpy.ndarray`` of dtype object + For each state factor, contains a 2D ``numpy.ndarray`` whose element i,j yields the probability + of reaching the goal state backwards from state j after i steps. + + Returns + ------- + inductive_cost: float + Cost of visited this state using backwards induction under the policy in question + """ + n_steps = len(qs_pi) + + # initialise inductive cost + inductive_cost = 0 + + # loop over time points and modalities + num_factors = len(I) + + for t in range(n_steps): + for factor in range(num_factors): + # we also assume precise beliefs here?! + idx = np.argmax(qs[factor]) + # m = arg max_n p_n < sup p + # i.e. find first I idx equals 1 and m is the index before + m = np.where(I[factor][:, idx] == 1)[0] + # we might find no path to goal (i.e. when no goal specified) + if len(m) > 0: + m = np.max(m[0]-1, 0) + I_m = (1-I[factor][m, :]) * np.log(epsilon) + inductive_cost += I_m.dot(qs_pi[t][factor]) + + return inductive_cost + def calc_expected_utility(qo_pi, C): """ Computes the expected utility of a policy, using the observation distribution expected under that policy and a prior preference vector. @@ -1175,3 +1222,62 @@ def _select_highest_test(options_array, seed=None): return int(same_prob[rng.choice(len(same_prob))]) return int(same_prob[0]) + + +def backwards_induction(H, B, B_factor_list, threshold, depth): + """ + Runs backwards induction of reaching a goal state H given a transition model B. + + Parameters + ---------- + H: ``numpy.ndarray`` of dtype object + Prior over states + B: ``numpy.ndarray`` of dtype object + Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. + Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability + of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. + B_factor_list: ``list`` of ``list`` of ``int`` + List of lists of hidden state factors each hidden state factor depends on. Each element ``B_factor_list[i]`` is a list of the factor indices that factor i's dynamics depend on. + threshold: ``float`` + The threshold for pruning transitions that are below a certain probability + depth: ``int`` + The temporal depth of the backward induction + + Returns + ---------- + I: ``numpy.ndarray`` of dtype object + For each state factor, contains a 2D ``numpy.ndarray`` whose element i,j yields the probability + of reaching the goal state backwards from state j after i steps. + """ + # TODO can this be done with arbitrary B_factor_list? + + num_factors = len(H) + I = utils.obj_array(num_factors) + for factor in range(num_factors): + I[factor] = np.zeros((depth, H[factor].shape[0])) + I[factor][0, :] = H[factor] + + bf = factor + if B_factor_list is not None: + if len(B_factor_list[factor]) > 1: + raise ValueError("Backwards induction with factorized transition model not yet implemented") + bf = B_factor_list[factor][0] + + num_states, _, _ = B[bf].shape + b = np.zeros((num_states, num_states)) + + for state in range(num_states): + for next_state in range(num_states): + # If there exists an action that allows transitioning + # from state to next_state, with probability larger than threshold + # set b[state, next_state] to 1 + if np.any(B[bf][next_state, state, :] > threshold): + b[next_state, state] = 1 + + for i in range(1, depth): + I[factor][i, :] = np.dot(b, I[factor][i-1, :]) + I[factor][i, :] = np.where(I[factor][i, :] > 0.1, 1.0, 0.0) + + return I + + From 91ebd9c7a2b3d3735f17e262923f38e6b3176364 Mon Sep 17 00:00:00 2001 From: conorheins Date: Tue, 21 Nov 2023 20:25:54 +0100 Subject: [PATCH 154/232] inductive inference now incorporated into all policy inference functiosn in `Agent` --- pymdp/agent.py | 35 +++++++++++++++++++---------------- 1 file changed, 19 insertions(+), 16 deletions(-) diff --git a/pymdp/agent.py b/pymdp/agent.py index 53b1cfdd..75bafc46 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -36,11 +36,11 @@ def __init__( B, C=None, D=None, - E = None, - H = None, + E=None, + H=None, pA=None, - pB = None, - pD = None, + pB=None, + pD=None, num_controls=None, policy_len=1, inference_horizon=1, @@ -61,10 +61,10 @@ def __init__( lr_pB=1.0, lr_pD=1.0, use_BMA = True, - policy_sep_prior = False, - save_belief_hist = False, - A_factor_list = None, - B_factor_list = None + policy_sep_prior=False, + save_belief_hist=False, + A_factor_list=None, + B_factor_list=None ): ### Constant parameters ### @@ -611,8 +611,9 @@ def infer_policies_old(self): self.use_param_info_gain, self.pA, self.pB, - E = self.E, - gamma = self.gamma + E=self.E, + I=self.I, + gamma=self.gamma ) elif self.inference_algo == "MMP": @@ -632,6 +633,7 @@ def infer_policies_old(self): self.pB, F = self.F, E = self.E, + I=self.I, gamma = self.gamma ) @@ -675,9 +677,9 @@ def infer_policies(self): self.use_param_info_gain, self.pA, self.pB, - E = self.E, - I = self.I, - gamma = self.gamma + E=self.E, + I=self.I, + gamma=self.gamma ) elif self.inference_algo == "MMP": @@ -697,9 +699,10 @@ def infer_policies(self): self.latest_belief, self.pA, self.pB, - F = self.F, - E = self.E, - gamma = self.gamma + F=self.F, + E=self.E, + I=self.I, + gamma=self.gamma ) if hasattr(self, "q_pi_hist"): From 272644925d9aa50f7ffa65e733e230697be3bfdd Mon Sep 17 00:00:00 2001 From: conorheins Date: Tue, 21 Nov 2023 20:26:33 +0100 Subject: [PATCH 155/232] incorporated @tverbele's inductive inference implementation into all policy inference functions in control.py --- pymdp/control.py | 139 +++++++++++++++++++++++++++++------------------ 1 file changed, 85 insertions(+), 54 deletions(-) diff --git a/pymdp/control.py b/pymdp/control.py index d0c877fd..892c02f3 100644 --- a/pymdp/control.py +++ b/pymdp/control.py @@ -21,8 +21,9 @@ def update_posterior_policies_full( prior=None, pA=None, pB=None, - F = None, - E = None, + F=None, + E=None, + I=None, gamma=16.0 ): """ @@ -67,6 +68,9 @@ def update_posterior_policies_full( Vector of variational free energies for each policy E: 1D ``numpy.ndarray``, default ``None`` Vector of prior probabilities of each policy (what's referred to in the active inference literature as "habits"). If ``None``, this defaults to a flat (uninformative) prior over policies. + I: ``numpy.ndarray`` of dtype object + For each state factor, contains a 2D ``numpy.ndarray`` whose element i,j yields the probability + of reaching the goal state backwards from state j after i steps. gamma: ``float``, default 16.0 Prior precision over policies, scales the contribution of the expected free energy to the posterior over policies @@ -100,6 +104,9 @@ def update_posterior_policies_full( else: lnE = spm_log_single(E) + if I is not None: + init_qs_all_pi = [qs_seq_pi[p][0] for p in range(num_policies)] + qs_bma = inference.average_states_over_policies(init_qs_all_pi, softmax(E)) for p_idx, policy in enumerate(policies): @@ -116,6 +123,9 @@ def update_posterior_policies_full( G[p_idx] += calc_pA_info_gain(pA, qo_seq_pi[p_idx], qs_seq_pi[p_idx]) if pB is not None: G[p_idx] += calc_pB_info_gain(pB, qs_seq_pi[p_idx], prior, policy) + + if I is not None: + G[p_idx] += calc_inductive_cost(qs_bma, qs_seq_pi[p_idx], I) q_pi = softmax(G * gamma - F + lnE) @@ -135,8 +145,9 @@ def update_posterior_policies_full_factorized( prior=None, pA=None, pB=None, - F = None, - E = None, + F=None, + E=None, + I=None, gamma=16.0 ): """ @@ -187,6 +198,9 @@ def update_posterior_policies_full_factorized( Vector of variational free energies for each policy E: 1D ``numpy.ndarray``, default ``None`` Vector of prior probabilities of each policy (what's referred to in the active inference literature as "habits"). If ``None``, this defaults to a flat (uninformative) prior over policies. + I: ``numpy.ndarray`` of dtype object + For each state factor, contains a 2D ``numpy.ndarray`` whose element i,j yields the probability + of reaching the goal state backwards from state j after i steps. gamma: ``float``, default 16.0 Prior precision over policies, scales the contribution of the expected free energy to the posterior over policies @@ -220,6 +234,10 @@ def update_posterior_policies_full_factorized( else: lnE = spm_log_single(E) + if I is not None: + init_qs_all_pi = [qs_seq_pi[p][0] for p in range(num_policies)] + qs_bma = inference.average_states_over_policies(init_qs_all_pi, softmax(E)) + for p_idx, policy in enumerate(policies): qo_seq_pi[p_idx] = get_expected_obs_factorized(qs_seq_pi[p_idx], A, A_factor_list) @@ -235,7 +253,10 @@ def update_posterior_policies_full_factorized( G[idx] += calc_pA_info_gain_factorized(pA, qo_seq_pi[p_idx], qs_seq_pi[p_idx], A_factor_list) if pB is not None: G[idx] += calc_pB_info_gain_interactions(pB, qs_seq_pi[p_idx], qs, B_factor_list, policy) - + + if I is not None: + G[p_idx] += calc_inductive_cost(qs_bma, qs_seq_pi[p_idx], I) + q_pi = softmax(G * gamma - F + lnE) return q_pi, G @@ -252,7 +273,8 @@ def update_posterior_policies( use_param_info_gain=False, pA=None, pB=None, - E = None, + E=None, + I=None, gamma=16.0 ): """ @@ -292,6 +314,9 @@ def update_posterior_policies( Dirichlet parameters over transition model (same shape as ``B``) E: 1D ``numpy.ndarray``, optional Vector of prior probabilities of each policy (what's referred to in the active inference literature as "habits") + I: ``numpy.ndarray`` of dtype object + For each state factor, contains a 2D ``numpy.ndarray`` whose element i,j yields the probability + of reaching the goal state backwards from state j after i steps. gamma: float, default 16.0 Prior precision over policies, scales the contribution of the expected free energy to the posterior over policies @@ -327,6 +352,9 @@ def update_posterior_policies( G[idx] += calc_pA_info_gain(pA, qo_pi, qs_pi) if pB is not None: G[idx] += calc_pB_info_gain(pB, qs_pi, qs, policy) + + if I is not None: + G[idx] += calc_inductive_cost(qs, qs_pi, I) q_pi = softmax(G * gamma + lnE) @@ -345,8 +373,8 @@ def update_posterior_policies_factorized( use_param_info_gain=False, pA=None, pB=None, - E = None, - I = None, + E=None, + I=None, gamma=16.0 ): """ @@ -392,6 +420,9 @@ def update_posterior_policies_factorized( Dirichlet parameters over transition model (same shape as ``B``) E: 1D ``numpy.ndarray``, optional Vector of prior probabilities of each policy (what's referred to in the active inference literature as "habits") + I: ``numpy.ndarray`` of dtype object + For each state factor, contains a 2D ``numpy.ndarray`` whose element i,j yields the probability + of reaching the goal state backwards from state j after i steps. gamma: float, default 16.0 Prior precision over policies, scales the contribution of the expected free energy to the posterior over policies @@ -422,14 +453,14 @@ def update_posterior_policies_factorized( if use_states_info_gain: G[idx] += calc_states_info_gain_factorized(A, qs_pi, A_factor_list) - if I is not None: - G[idx] += calc_inductive_cost(qs, qs_pi, I) - if use_param_info_gain: if pA is not None: G[idx] += calc_pA_info_gain_factorized(pA, qo_pi, qs_pi, A_factor_list) if pB is not None: G[idx] += calc_pB_info_gain_interactions(pB, qs_pi, qs, B_factor_list, policy) + + if I is not None: + G[idx] += calc_inductive_cost(qs, qs_pi, I) q_pi = softmax(G * gamma + lnE) @@ -584,49 +615,6 @@ def get_expected_obs_factorized(qs_pi, A, A_factor_list): return qo_pi -def calc_inductive_cost(qs, qs_pi, I, epsilon=1e-3): - """ - Computes the inductive cost of a state. - - Parameters - ---------- - qs: ``numpy.ndarray`` of dtype object - Marginal posterior beliefs over hidden states at a given timepoint. - qs_pi: ``list`` of ``numpy.ndarray`` of dtype object - Predictive posterior beliefs over hidden states expected under the policy, where ``qs_pi[t]`` stores the beliefs about - states expected under the policy at time ``t`` - I: ``numpy.ndarray`` of dtype object - For each state factor, contains a 2D ``numpy.ndarray`` whose element i,j yields the probability - of reaching the goal state backwards from state j after i steps. - - Returns - ------- - inductive_cost: float - Cost of visited this state using backwards induction under the policy in question - """ - n_steps = len(qs_pi) - - # initialise inductive cost - inductive_cost = 0 - - # loop over time points and modalities - num_factors = len(I) - - for t in range(n_steps): - for factor in range(num_factors): - # we also assume precise beliefs here?! - idx = np.argmax(qs[factor]) - # m = arg max_n p_n < sup p - # i.e. find first I idx equals 1 and m is the index before - m = np.where(I[factor][:, idx] == 1)[0] - # we might find no path to goal (i.e. when no goal specified) - if len(m) > 0: - m = np.max(m[0]-1, 0) - I_m = (1-I[factor][m, :]) * np.log(epsilon) - inductive_cost += I_m.dot(qs_pi[t][factor]) - - return inductive_cost - def calc_expected_utility(qo_pi, C): """ Computes the expected utility of a policy, using the observation distribution expected under that policy and a prior preference vector. @@ -918,6 +906,49 @@ def calc_pB_info_gain_interactions(pB, qs_pi, qs_prev, B_factor_list, policy): return pB_infogain +def calc_inductive_cost(qs, qs_pi, I, epsilon=1e-3): + """ + Computes the inductive cost of a state. + + Parameters + ---------- + qs: ``numpy.ndarray`` of dtype object + Marginal posterior beliefs over hidden states at a given timepoint. + qs_pi: ``list`` of ``numpy.ndarray`` of dtype object + Predictive posterior beliefs over hidden states expected under the policy, where ``qs_pi[t]`` stores the beliefs about + states expected under the policy at time ``t`` + I: ``numpy.ndarray`` of dtype object + For each state factor, contains a 2D ``numpy.ndarray`` whose element i,j yields the probability + of reaching the goal state backwards from state j after i steps. + + Returns + ------- + inductive_cost: float + Cost of visited this state using backwards induction under the policy in question + """ + n_steps = len(qs_pi) + + # initialise inductive cost + inductive_cost = 0 + + # loop over time points and modalities + num_factors = len(I) + + for t in range(n_steps): + for factor in range(num_factors): + # we also assume precise beliefs here?! + idx = np.argmax(qs[factor]) + # m = arg max_n p_n < sup p + # i.e. find first I idx equals 1 and m is the index before + m = np.where(I[factor][:, idx] == 1)[0] + # we might find no path to goal (i.e. when no goal specified) + if len(m) > 0: + m = np.max(m[0]-1, 0) + I_m = (1-I[factor][m, :]) * np.log(epsilon) + inductive_cost += I_m.dot(qs_pi[t][factor]) + + return inductive_cost + def construct_policies(num_states, num_controls = None, policy_len=1, control_fac_idx=None): """ Generate a ``list`` of policies. The returned array ``policies`` is a ``list`` that stores one policy per entry. From 03846880dabce7edfd49aef04ac5be87695cb9da Mon Sep 17 00:00:00 2001 From: conorheins Date: Tue, 21 Nov 2023 20:27:02 +0100 Subject: [PATCH 156/232] finished docstrings for factorized versions of MMP with A and B factor lists --- pymdp/algos/mmp.py | 5 ++++- pymdp/inference.py | 5 ++++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/pymdp/algos/mmp.py b/pymdp/algos/mmp.py index d24f318a..9d16c641 100644 --- a/pymdp/algos/mmp.py +++ b/pymdp/algos/mmp.py @@ -142,12 +142,15 @@ def run_mmp_factorized( lh_seq: ``numpy.ndarray`` of dtype object Log likelihoods of hidden states under a sequence of observations over time. This is assumed to already be log-transformed. Each ``lh_seq[t]`` contains the log likelihood of hidden states for a particular observation at time ``t`` - mb_dict: ``dict`` + mb_dict: ``Dict`` + Dictionary with two keys (``A_factor_list`` and ``A_modality_list``), that stores the factor indices that influence each modality (``A_factor_list``) + and the modality indices influenced by each factor (``A_modality_list``). B: ``numpy.ndarray`` of dtype object Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. B_factor_list: ``list`` of ``list`` of ``int`` + List of lists of hidden state factors each hidden state factor depends on. Each element ``B_factor_list[i]`` is a list of the factor indices that factor i's dynamics depend on. policy: 2D ``numpy.ndarray`` Matrix of shape ``(policy_len, num_control_factors)`` that indicates the indices of each action (control state index) upon timestep ``t`` and control_factor ``f` in the element ``policy[t,f]`` for a given policy. prev_actions: ``numpy.ndarray``, default None diff --git a/pymdp/inference.py b/pymdp/inference.py index 59d3ec69..1b5296b5 100644 --- a/pymdp/inference.py +++ b/pymdp/inference.py @@ -108,11 +108,14 @@ def update_posterior_states_full_factorized( stores an ``numpy.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store the probability of observation level ``i`` given hidden state levels ``j, k, ...`` mb_dict: ``Dict`` + Dictionary with two keys (``A_factor_list`` and ``A_modality_list``), that stores the factor indices that influence each modality (``A_factor_list``) + and the modality indices influenced by each factor (``A_modality_list``). B: ``numpy.ndarray`` of dtype object Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. - B_factor_list: ``list`` of ``list`` + B_factor_list: ``list`` of ``list`` of ``int`` + List of lists of hidden state factors each hidden state factor depends on. Each element ``B_factor_list[i]`` is a list of the factor indices that factor i's dynamics depend on. prev_obs: ``list`` List of observations over time. Each observation in the list can be an ``int``, a ``list`` of ints, a ``tuple`` of ints, a one-hot vector or an object array of one-hot vectors. policies: ``list`` of 2D ``numpy.ndarray`` From 2f93147a7a5579bca0dceb193b282d3c775d0ba0 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 30 Nov 2023 18:01:23 +0100 Subject: [PATCH 157/232] - B tensor learning - sampling from policies rather than actions - fixes in bugs with EFE rollouts --- pymdp/jax/agent.py | 13 ++++----- pymdp/jax/control.py | 35 ++++++++++++++++-------- pymdp/jax/inference.py | 2 +- pymdp/jax/learning.py | 61 ++++++++++++++---------------------------- 4 files changed, 52 insertions(+), 59 deletions(-) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index c3af4ce9..877ed59b 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -202,16 +202,17 @@ def _construct_policies(self): ) @vmap - def learning(self, beliefs, outcomes, **kwargs): + def learning(self, beliefs, outcomes, actions, **kwargs): if self.learn_A: o_vec_seq = jtu.tree_map(lambda o, dim: nn.one_hot(o, dim), outcomes, self.num_obs) - # qA = learning.update_A(self.A, beliefs, o_vec_seq, self.A_dependencies) qA = learning.update_obs_likelihood_dirichlet(self.pA, self.A, o_vec_seq, beliefs, self.A_dependencies, lr=1.) E_qA = jtu.tree_map(lambda x: maths.dirichlet_expected_value(x), qA) - # if self.learn_B: - # self.qB = learning.update_B(self.B, *args, **kwargs) - # self.B = jtu.tree_map(lambda x: maths.dirichlet_expected_value(x), self.qB) + if self.learn_B: + actions_seq = [actions[...,i] for i in range(actions.shape[-1])] # as many elements as there are control factors, where each element is a jnp.ndarray of shape (n_timesteps, ) + actions_onehot = jtu.tree_map(lambda a, dim: nn.one_hot(a, dim, axis=-1), actions_seq, self.num_controls) + qB = learning.update_state_likelihood_dirichlet(self.pB, self.B, beliefs, actions_onehot, self.B_dependencies) + E_qB = jtu.tree_map(lambda x: maths.dirichlet_expected_value(x), qB) # if self.learn_C: # self.qC = learning.update_C(self.C, *args, **kwargs) # self.C = jtu.tree_map(lambda x: maths.dirichlet_expected_value(x), self.qC) @@ -227,7 +228,7 @@ def learning(self, beliefs, outcomes, **kwargs): # parameters = ... # varibles = {'A': jnp.ones(5)} - agent = tree_at(lambda x: (x.A, x.pA), self, (E_qA, qA)) + agent = tree_at(lambda x: (x.A, x.pA, x.B, x.pB), self, (E_qA, qA, E_qB, qB)) return agent diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index 79620373..233f45b7 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -9,6 +9,7 @@ from typing import Tuple, Optional from functools import partial from jax import lax, jit, vmap, nn +from jax import random as jr from itertools import chain from pymdp.jax.maths import * @@ -34,7 +35,7 @@ def get_marginals(q_pi, policies, num_controls): action_marginals: ``list`` of ``jax.numpy.ndarrays`` List of arrays corresponding to marginal probability of each action possible action """ - num_factors = len(num_controls) + num_factors = len(num_controls) action_marginals = [] for factor_i in range(num_factors): @@ -43,7 +44,6 @@ def get_marginals(q_pi, policies, num_controls): return action_marginals - def sample_action(q_pi, policies, num_controls, action_selection="deterministic", alpha=16.0, rng_key=None): """ Samples an action from posterior marginals, one action per control factor. @@ -76,12 +76,25 @@ def sample_action(q_pi, policies, num_controls, action_selection="deterministic" if action_selection == 'deterministic': selected_policy = jtu.tree_map(lambda x: jnp.argmax(x, -1), marginal) elif action_selection == 'stochastic': - selected_policy = jtu.tree_map( lambda x: random.categorical(rng_key, alpha * log_stable(x)), marginal) + selected_policy = jtu.tree_map(lambda x: jr.categorical(rng_key, nn.softmax(alpha * log_stable(x))), marginal) else: raise NotImplementedError return jnp.array(selected_policy) +def sample_policy(q_pi, policies, num_controls, action_selection="deterministic", alpha = 16.0, rng_key=None): + + num_factors = len(num_controls) + + if action_selection == "deterministic": + policy_idx = jnp.argmax(q_pi) + elif action_selection == "stochastic": + p_policies = nn.softmax(log_stable(q_pi) * alpha) + policy_idx = jr.categorical(rng_key, p_policies) + + selected_policy = jtu.tree_map(lambda f: policies[policy_idx][0,f], list(range(num_factors))) + + return jnp.array(selected_policy) def construct_policies(num_states, num_controls = None, policy_len=1, control_fac_idx=None): """ @@ -150,8 +163,8 @@ def compute_expected_state(qs_prior, B, u_t, B_dependencies=None): assert len(u_t) == len(B) qs_next = [] for B_f, u_f, deps in zip(B, u_t, B_dependencies): - # qs_next.append( B_f[..., u_f].dot(qs_f) ) - qs_next_f = factor_dot(B_f[...,u_f], qs_prior[deps]) + relevant_factors = [qs_prior[idx] for idx in deps] + qs_next_f = factor_dot(B_f[...,u_f], relevant_factors, keep_dims=(0,)) qs_next.append(qs_next_f) return qs_next @@ -242,7 +255,7 @@ def calc_pA_info_gain(pA, qo, qs): wA = jtu.tree_map(spm_wnorm, pA) wA_per_modality = jtu.tree_map(lambda wa, pa: wa * (pa > 0.), wA, pA) - pA_infogain_per_modality = jtu.tree_map(lambda wa, qo: qo.dot(factor_dot(wa, qs)[...,None]), wA_per_modality, qo) + pA_infogain_per_modality = jtu.tree_map(lambda wa, qo: qo.dot(factor_dot(wa, qs, keep_dims=(0,))[...,None]), wA_per_modality, qo) infogain_pA = jtu.tree_reduce(lambda x, y: x + y, pA_infogain_per_modality)[0] return infogain_pA @@ -308,7 +321,7 @@ def scan_body(carry, t): qo = compute_expected_obs(qs_next, A, A_dependencies) - info_gain = compute_info_gain(qs_next, qo, A) if use_states_info_gain else 0. + info_gain = compute_info_gain(qs_next, qo, A, A_dependencies) if use_states_info_gain else 0. utility = compute_expected_utility(qo, C) if use_utility else 0. @@ -328,12 +341,12 @@ def scan_body(carry, t): # if __name__ == '__main__': -# from jax import random -# key = random.PRNGKey(1) +# from jax import random as jr +# key = jr.PRNGKey(1) # num_obs = [3, 4] -# A = [random.uniform(key, shape = (no, 2, 2)) for no in num_obs] -# B = [random.uniform(key, shape = (2, 2, 2)), random.uniform(key, shape = (2, 2, 2))] +# A = [jr.uniform(key, shape = (no, 2, 2)) for no in num_obs] +# B = [jr.uniform(key, shape = (2, 2, 2)), jr.uniform(key, shape = (2, 2, 2))] # C = [log_stable(jnp.array([0.8, 0.1, 0.1])), log_stable(jnp.ones(4)/4)] # policy_1 = jnp.array([[0, 1], # [1, 1]]) diff --git a/pymdp/jax/inference.py b/pymdp/jax/inference.py index 68032cc6..ef0f5323 100644 --- a/pymdp/jax/inference.py +++ b/pymdp/jax/inference.py @@ -6,7 +6,7 @@ from .algos import run_factorized_fpi, run_mmp, run_vmp from jax import tree_util as jtu -def update_posterior_states(A, B, obs, past_actions, prior=None, qs_hist=None, A_dependencies=None, num_iter=16, method='fpi'): +def update_posterior_states(A, B, obs, past_actions, prior=None, qs_hist=None, A_dependencies=None, B_dependencies=None, num_iter=16, method='fpi'): if method == 'fpi' or method == "ovf": # format obs to select only last observation diff --git a/pymdp/jax/learning.py b/pymdp/jax/learning.py index 299bce09..5591397c 100644 --- a/pymdp/jax/learning.py +++ b/pymdp/jax/learning.py @@ -25,7 +25,6 @@ def update_obs_likelihood_dirichlet_m(pA_m, A_m, obs_m, qs, dependencies_m, lr=1 relevant_factors = tree_map(lambda f_idx: qs[f_idx], dependencies_m) dfda = vmap(multidimensional_outer)([obs_m]+ relevant_factors).sum(axis=0) - # dfda = jnp.where(A_m > 0, dfda, 0.0) # this doesn't make sense qA_m = pA_m + (lr * dfda) return qA_m @@ -38,53 +37,33 @@ def update_obs_likelihood_dirichlet(pA, A, obs, qs, A_dependencies, lr=1.0): return qA -def update_state_likelihood_dirichlet( - pB, B, actions, qs, qs_prev, lr=1.0, factors="all" -): - """ - Update Dirichlet parameters of the transition distribution. +def update_state_likelihood_dirichlet_f(pB_f, B_f, actions_f, current_qs, qs_seq, dependencies_f, lr=1.0): + """ JAX version of ``pymdp.learning.update_state_likelihood_dirichlet_f`` """ + # pB_f - parameters of the dirichlet from the prior + # pB_f.shape = (num_states[f] x num_states[f] x num_actions[f]) where f is the index of the hidden state factor - Parameters - ----------- - pB: ``numpy.ndarray`` of dtype object - Prior Dirichlet parameters over transition model (same shape as ``B``) - B: ``numpy.ndarray`` of dtype object - Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. - Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability - of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. - actions: 1D ``numpy.ndarray`` - A vector with length equal to the number of control factors, where each element contains the index of the action (for that control factor) performed at - a given timestep. - qs: 1D ``numpy.ndarray`` or ``numpy.ndarray`` of dtype object - Marginal posterior beliefs over hidden states at current timepoint. - qs_prev: 1D ``numpy.ndarray`` or ``numpy.ndarray`` of dtype object - Marginal posterior beliefs over hidden states at previous timepoint. - lr: float, default ``1.0`` - Learning rate, scale of the Dirichlet pseudo-count update. - factors: ``list``, default "all" - Indices (ranging from 0 to ``n_factors - 1``) of the hidden state factors to include - in learning. Defaults to "all", meaning that factor-specific sub-arrays of ``pB`` - are all updated using the corresponding hidden state distributions and actions. + # \alpha^{*} = \alpha_{0} + \kappa * \sum_{t=t_begin}^{t=T} \mathbf{s}_{f, t} \otimes \mathbf{s}_{f, t-1} \otimes \mathbf{a}_{f, t-1} - Returns - ----------- - qB: ``numpy.ndarray`` of dtype object - Posterior Dirichlet parameters over transition model (same shape as ``B``), after having updated it with state beliefs and actions. - """ + # \alpha^{*} is the VFE-minimizing solution for the parameters of q(B) + # \alpha_{0} are the Dirichlet parameters of p(B) + # \mathbf{s}_{f, t} = categorical parameters of marginal posteriors over hidden state factor f, at time t + # \mathbf{a}_{f, t-1} = categorical parameters of marginal posteriors over control factor f, at time t-1 + # \otimes is a multidimensional outer product, not just a outer product of two vectors + # \kappa is an optional learning rate - num_factors = len(pB) + past_qs = tree_map(lambda f_idx: qs_seq[f_idx][:-1], dependencies_f) + dfdb = vmap(multidimensional_outer)([current_qs[1:]] + past_qs + [actions_f]).sum(axis=0) + qB_f = pB_f + (lr * dfdb) - qB = copy.deepcopy(pB) - - if factors == "all": - factors = list(range(num_factors)) + return qB_f - for factor in factors: - dfdb = maths.spm_cross(qs[factor], qs_prev[factor]) - dfdb *= (B[factor][:, :, actions[factor]] > 0).astype("float") - qB[factor][:,:,int(actions[factor])] += (lr*dfdb) +def update_state_likelihood_dirichlet(pB, B, beliefs, actions_onehot, B_dependencies, lr=1.0): + + update_B_f_fn = lambda pB_f, B_f, action_f, qs_f, dependencies_f: update_state_likelihood_dirichlet_f(pB_f, B_f, action_f, qs_f, beliefs, dependencies_f, lr=lr) + qB = tree_map(update_B_f_fn, pB, B, actions_onehot, beliefs, B_dependencies) return qB + def update_state_prior_dirichlet( pD, qs, lr=1.0, factors="all" From 39ecc24a144f22ae982c4ee6cc939a743dd2b16b Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 30 Nov 2023 18:01:50 +0100 Subject: [PATCH 158/232] updates to building_up_agent_loop.ipynb testing out B matrix learning --- examples/building_up_agent_loop.ipynb | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/examples/building_up_agent_loop.ipynb b/examples/building_up_agent_loop.ipynb index e75ca4d5..f39a8717 100644 --- a/examples/building_up_agent_loop.ipynb +++ b/examples/building_up_agent_loop.ipynb @@ -24,7 +24,9 @@ "output_type": "stream", "text": [ "(2, 10, 5, 4)\n", - "(2, 10, 5, 2)\n" + "[1 0]\n", + "(10, 3, 3, 3)\n", + "(10, 3, 3, 2)\n" ] } ], @@ -130,12 +132,15 @@ " self.key, _ = jr.split(self.key)\n", " return obs\n", "\n", - "agents = AIFAgent(A, B, C, D, E, pA, pB, use_param_info_gain=True, inference_algo='mmp')\n", + "agents = AIFAgent(A, B, C, D, E, pA, pB, use_param_info_gain=True, inference_algo='fpi')\n", "env = TestEnv(num_obs)\n", "init = (agents, env)\n", "(agents, env), sequences = scan(step_fn, init, range(num_blocks) )\n", "print(sequences['policy_probs'].shape)\n", - "print(sequences['actions'].shape)\n", + "print(sequences['actions'][0][0][0])\n", + "\n", + "print(agents.A[0].shape)\n", + "print(agents.B[0].shape)\n", "# def loss_fn(agents):\n", "# env = TestEnv(num_obs)\n", "# init = (agents, env)\n", From a80e43502ef7f2283cce55a441e80e340dcd7e30 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Thu, 30 Nov 2023 18:02:52 +0100 Subject: [PATCH 159/232] modifying function calls --- examples/building_up_agent_loop.ipynb | 2 +- pymdp/jax/agent.py | 29 +++++++++++++++++++-------- 2 files changed, 22 insertions(+), 9 deletions(-) diff --git a/examples/building_up_agent_loop.ipynb b/examples/building_up_agent_loop.ipynb index e75ca4d5..90ef6e6d 100644 --- a/examples/building_up_agent_loop.ipynb +++ b/examples/building_up_agent_loop.ipynb @@ -70,7 +70,7 @@ " \n", " # args = (pred_{t+1}, [post_1, post_{2}, ..., post_{t}])\n", " # beliefs = [post_1, post_{2}, ..., post_{t}]\n", - " return {'args': args, 'outcomes': outcomes, 'beliefs': beliefs, 'actions': actions},{'policy_probs': q_pi}\n", + " return {'args': args, 'outcomes': outcomes, 'beliefs': beliefs, 'actions': actions}, {'policy_probs': q_pi}\n", "\n", " \n", " outcome_0 = jtu.tree_map(lambda x: jnp.expand_dims(x, -1), env.step())\n", diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index c3af4ce9..c796060f 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -9,7 +9,7 @@ import jax.numpy as jnp import jax.tree_util as jtu -from jax import nn, vmap +from jax import nn, vmap, random from . import inference, control, learning, utils, maths from equinox import Module, static_field, tree_at @@ -202,7 +202,7 @@ def _construct_policies(self): ) @vmap - def learning(self, beliefs, outcomes, **kwargs): + def learning(self, beliefs, outcomes, actions, **kwargs): if self.learn_A: o_vec_seq = jtu.tree_map(lambda o, dim: nn.one_hot(o, dim), outcomes, self.num_obs) @@ -264,7 +264,7 @@ def infer_states(self, observations, past_actions, empirical_prior, qs_hist): prior=empirical_prior, qs_hist=qs_hist, A_dependencies=self.A_dependencies, - B_dependencies=self.B_dependencies, + # B_dependencies=self.B_dependencies, num_iter=self.num_iter, method=self.inference_algo ) @@ -344,7 +344,7 @@ def action_probabilities(self, q_pi: jnp.ndarray): return jnp.stack(marginals, -2) - def sample_action(self, q_pi: jnp.ndarray): + def sample_action(self, key, q_pi: jnp.ndarray, actions: jnp.ndarray = None): """ Sample or select a discrete action from the posterior over control states. @@ -352,13 +352,26 @@ def sample_action(self, q_pi: jnp.ndarray): ---------- action: 1D ``jax.numpy.ndarray`` Vector containing the indices of the actions for each control factor + action_probs: 2D ``jax.numpy.ndarray`` + Array of action probabilities """ - sample_action = lambda x: control.sample_action(x, self.policies, self.num_controls, self.action_selection) - - action = vmap(sample_action)(q_pi) + marginals = lambda x: control.get_marginals(x, self.policies, self.num_controls) + action_probs = vmap(marginals)(q_pi) + + if actions is None: + if self.action_selection == 'deterministic': + selected_actions = jtu.tree_map(lambda x: jnp.argmax(x, -1), action_probs) + elif self.action_selection == 'stochastic': + selected_actions = jtu.tree_map( + lambda x: random.categorical(key, alpha * log_stable(x)), action_probs + ) + else: + raise NotImplementedError + else: + selected_actions = action - return action + return selected_actions, action_probs def _get_default_params(self): method = self.inference_algo From a0580667fa52369ff391a66a428c749ec97c555c Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 30 Nov 2023 18:26:33 +0100 Subject: [PATCH 160/232] pass rng key into evolve trials, tested with sampling_mode = 'full' --- examples/building_up_agent_loop.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/examples/building_up_agent_loop.ipynb b/examples/building_up_agent_loop.ipynb index f39a8717..e6694c03 100644 --- a/examples/building_up_agent_loop.ipynb +++ b/examples/building_up_agent_loop.ipynb @@ -45,14 +45,14 @@ "\n", " return carry, ys\n", "\n", - "def evolve_trials(agent, env, block_idx, num_timesteps):\n", + "def evolve_trials(agent, env, block_idx, num_timesteps, prng_key=jr.PRNGKey(0)):\n", "\n", " def step_fn(carry, xs):\n", " actions = carry['actions']\n", " outcomes = carry['outcomes']\n", " beliefs = agent.infer_states(outcomes, actions, *carry['args'])\n", " q_pi, _ = agent.infer_policies(beliefs)\n", - " actions_t = agent.sample_action(q_pi)\n", + " actions_t = agent.sample_action(q_pi, rng_key=prng_key)\n", "\n", " outcome_t = env.step(actions_t)\n", " outcomes = jtu.tree_map(\n", @@ -132,7 +132,7 @@ " self.key, _ = jr.split(self.key)\n", " return obs\n", "\n", - "agents = AIFAgent(A, B, C, D, E, pA, pB, use_param_info_gain=True, inference_algo='fpi')\n", + "agents = AIFAgent(A, B, C, D, E, pA, pB, use_param_info_gain=True, inference_algo='fpi', sampling_mode='full')\n", "env = TestEnv(num_obs)\n", "init = (agents, env)\n", "(agents, env), sequences = scan(step_fn, init, range(num_blocks) )\n", From 4ce264d39196f89e17f5d025982bbc9e68182b0a Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 30 Nov 2023 18:27:29 +0100 Subject: [PATCH 161/232] added action sampling precision/inv temperature `alpha` and `sampling_mode` (sample from policies or action marginals) as inputs to `Agent` module --- pymdp/jax/agent.py | 28 ++++++++++++++++++++-------- 1 file changed, 20 insertions(+), 8 deletions(-) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 877ed59b..98f0d077 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -39,6 +39,7 @@ class Agent(Module): E: jnp.ndarray # empirical_prior: List gamma: jnp.ndarray + alpha: jnp.ndarray qs: Optional[List] q_pi: Optional[List] @@ -54,14 +55,16 @@ class Agent(Module): num_states: List = static_field() num_factors: int = static_field() num_controls: List = static_field() - inference_algo: AnyStr = static_field() control_fac_idx: Any = static_field() policy_len: int = static_field() policies: Any = static_field() use_utility: bool = static_field() use_states_info_gain: bool = static_field() use_param_info_gain: bool = static_field() - action_selection: AnyStr = static_field() + action_selection: AnyStr = static_field() # determinstic or stochastic + sampling_mode : AnyStr = static_field() # whether to sample from full posterior over policies ("full") or from marginal posterior over actions ("marginal") + inference_algo: AnyStr = static_field() # fpi, vmp, mmp, ovf + learn_A: bool = static_field() learn_B: bool = static_field() learn_C: bool = static_field() @@ -85,10 +88,12 @@ def __init__( control_fac_idx=None, policies=None, gamma=16.0, + alpha=16.0, use_utility=True, use_states_info_gain=True, use_param_info_gain=False, action_selection="deterministic", + sampling_mode="marginal", inference_algo="fpi", num_iter=16, learn_A=True, @@ -148,6 +153,7 @@ def __init__( batch_dim = (self.A[0].shape[0],) self.gamma = jnp.broadcast_to(gamma, batch_dim) + self.alpha = jnp.broadcast_to(alpha, batch_dim) ### Static parameters ### @@ -158,6 +164,7 @@ def __init__( # policy parameters self.policy_len = policy_len self.action_selection = action_selection + self.sampling_mode = sampling_mode self.use_utility = use_utility self.use_states_info_gain = use_states_info_gain self.use_param_info_gain = use_param_info_gain @@ -344,8 +351,7 @@ def action_probabilities(self, q_pi: jnp.ndarray): return jnp.stack(marginals, -2) - - def sample_action(self, q_pi: jnp.ndarray): + def sample_action(self, q_pi: jnp.ndarray, rng_key=None): """ Sample or select a discrete action from the posterior over control states. @@ -353,14 +359,20 @@ def sample_action(self, q_pi: jnp.ndarray): ---------- action: 1D ``jax.numpy.ndarray`` Vector containing the indices of the actions for each control factor - """ + """ - sample_action = lambda x: control.sample_action(x, self.policies, self.num_controls, self.action_selection) + if (rng_key is None) and (self.action_selection == "stochastic"): + raise ValueError("Please provide a random number generator key to sample actions stochastically") - action = vmap(sample_action)(q_pi) + if self.sampling_mode == "marginal": + sample_action = lambda x, alpha: control.sample_action(x, self.policies, self.num_controls, self.action_selection, alpha, rng_key=rng_key) + action = vmap(sample_action)(q_pi, self.alpha) + elif self.sampling_mode == "full": + sample_policy = lambda x, alpha: control.sample_policy(x, self.policies, self.num_controls, self.action_selection, alpha, rng_key=rng_key) + action = vmap(sample_policy)(q_pi, self.alpha) return action - + def _get_default_params(self): method = self.inference_algo default_params = None From 52590765d48ba8969297dbc6a7cd91b4c1ad872a Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 30 Nov 2023 18:45:51 +0100 Subject: [PATCH 162/232] now we vmap decorate `sample_action` --- pymdp/jax/agent.py | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 98f0d077..14f8a880 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -351,10 +351,31 @@ def action_probabilities(self, q_pi: jnp.ndarray): return jnp.stack(marginals, -2) + @vmap def sample_action(self, q_pi: jnp.ndarray, rng_key=None): """ Sample or select a discrete action from the posterior over control states. + Returns + ---------- + action: 1D ``jax.numpy.ndarray`` + Vector containing the indices of the actions for each control factor + """ + + if (rng_key is None) and (self.action_selection == "stochastic"): + raise ValueError("Please provide a random number generator key to sample actions stochastically") + + if self.sampling_mode == "marginal": + action = control.sample_action(q_pi, self.policies, self.num_controls, self.action_selection, self.alpha, rng_key=rng_key) + elif self.sampling_mode == "full": + action = control.sample_policy(q_pi, self.policies, self.num_controls, self.action_selection, self.alpha, rng_key=rng_key) + + return action + + def sample_action_old(self, q_pi: jnp.ndarray, rng_key=None): + """ + Sample or select a discrete action from the posterior over control states. + Returns ---------- action: 1D ``jax.numpy.ndarray`` From c39f05fe1540f3104fa49f464619ea824b1010e2 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 30 Nov 2023 18:46:21 +0100 Subject: [PATCH 163/232] split prng_key into batch_size different keys, one for each parallel agent --- examples/building_up_agent_loop.ipynb | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/examples/building_up_agent_loop.ipynb b/examples/building_up_agent_loop.ipynb index e6694c03..66085555 100644 --- a/examples/building_up_agent_loop.ipynb +++ b/examples/building_up_agent_loop.ipynb @@ -24,7 +24,7 @@ "output_type": "stream", "text": [ "(2, 10, 5, 4)\n", - "[1 0]\n", + "[1 1]\n", "(10, 3, 3, 3)\n", "(10, 3, 3, 2)\n" ] @@ -47,12 +47,14 @@ "\n", "def evolve_trials(agent, env, block_idx, num_timesteps, prng_key=jr.PRNGKey(0)):\n", "\n", + " batch_keys = jr.split(prng_key, batch_size)\n", " def step_fn(carry, xs):\n", " actions = carry['actions']\n", " outcomes = carry['outcomes']\n", " beliefs = agent.infer_states(outcomes, actions, *carry['args'])\n", " q_pi, _ = agent.infer_policies(beliefs)\n", - " actions_t = agent.sample_action(q_pi, rng_key=prng_key)\n", + " # actions_t = agent.sample_action(q_pi, rng_key=prng_key)\n", + " actions_t = agent._sample_action(q_pi, rng_key=batch_keys)\n", "\n", " outcome_t = env.step(actions_t)\n", " outcomes = jtu.tree_map(\n", @@ -132,13 +134,12 @@ " self.key, _ = jr.split(self.key)\n", " return obs\n", "\n", - "agents = AIFAgent(A, B, C, D, E, pA, pB, use_param_info_gain=True, inference_algo='fpi', sampling_mode='full')\n", + "agents = AIFAgent(A, B, C, D, E, pA, pB, use_param_info_gain=True, inference_algo='fpi', sampling_mode='marginal', action_selection='stochastic')\n", "env = TestEnv(num_obs)\n", "init = (agents, env)\n", "(agents, env), sequences = scan(step_fn, init, range(num_blocks) )\n", "print(sequences['policy_probs'].shape)\n", "print(sequences['actions'][0][0][0])\n", - "\n", "print(agents.A[0].shape)\n", "print(agents.B[0].shape)\n", "# def loss_fn(agents):\n", From e0d8aeec364ddca0a2cd625c6b10c7cb84c4aaa7 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Wed, 6 Dec 2023 16:31:53 +0100 Subject: [PATCH 164/232] updated notebook --- examples/building_up_agent_loop.ipynb | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/examples/building_up_agent_loop.ipynb b/examples/building_up_agent_loop.ipynb index c7897246..6ad1ad99 100644 --- a/examples/building_up_agent_loop.ipynb +++ b/examples/building_up_agent_loop.ipynb @@ -2,11 +2,10 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ - "import jax\n", "import jax.numpy as jnp\n", "import jax.tree_util as jtu\n", "from jax import random as jr\n", @@ -16,7 +15,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -53,8 +52,7 @@ " outcomes = carry['outcomes']\n", " beliefs = agent.infer_states(outcomes, actions, *carry['args'])\n", " q_pi, _ = agent.infer_policies(beliefs)\n", - " # actions_t = agent.sample_action(q_pi, rng_key=prng_key)\n", - " actions_t = agent._sample_action(q_pi, rng_key=batch_keys)\n", + " actions_t = agent.sample_action(q_pi, rng_key=batch_keys)\n", "\n", " outcome_t = env.step(actions_t)\n", " outcomes = jtu.tree_map(\n", @@ -175,7 +173,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.4" + "version": "3.11.6" }, "orig_nbformat": 4 }, From e0de653d94cf47530d1d36b9331f58517687307e Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Thu, 7 Dec 2023 16:50:07 +0100 Subject: [PATCH 165/232] updated sampling and marginalisation computations --- pymdp/jax/agent.py | 39 ++++++++++++++++++++++++++++----------- pymdp/jax/control.py | 7 ++----- 2 files changed, 30 insertions(+), 16 deletions(-) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 57f16024..1a04f264 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -7,6 +7,7 @@ """ +import itertools import jax.numpy as jnp import jax.tree_util as jtu from jax import nn, vmap, random @@ -14,6 +15,7 @@ from equinox import Module, static_field, tree_at from typing import Any, List, AnyStr, Optional +from jaxtyping import Array class Agent(Module): """ @@ -36,10 +38,10 @@ class Agent(Module): B: List C: List D: List - E: jnp.ndarray + E: Array # empirical_prior: List - gamma: jnp.ndarray - alpha: jnp.ndarray + gamma: Array + alpha: Array qs: Optional[List] q_pi: Optional[List] @@ -325,8 +327,13 @@ def infer_policies(self, qs: List): return q_pi, G + @property + def unique_multiactions(self): + return jnp.unique(self.policies[:, 0], axis=0) + + @vmap - def action_probabilities(self, q_pi: jnp.ndarray): + def action_probabilities(self, q_pi: Array): """ Compute probabilities of discrete actions from the posterior over policies. @@ -341,17 +348,27 @@ def action_probabilities(self, q_pi: jnp.ndarray): Vector containing probabilities of possible actions for different factors """ - marginals = control.get_marginals(q_pi, self.policies, self.num_controls) + if self.sampling_mode == "marginal": + marginals = control.get_marginals(q_pi, self.policies, self.num_controls) + outer = lambda a, b: jnp.outer(a, b).reshape(-1) + marginals = jtu.tree_reduce(outer, marginals) - # make all arrays same length (add 0 probability) - lengths = jtu.tree_map(lambda x: len(x), marginals) - max_length = max(lengths) - marginals = jtu.tree_map(lambda x: jnp.pad(x, (0, max_length - len(x))), marginals) + elif self.sampling_mode == "full": + locs = jnp.all( + self.policies[:, 0] == jnp.expand_dims(self.unique_multiactions, -2), + -1 + ) + marginals = jnp.where(locs, q_pi, 0.).sum(-1) - return jnp.stack(marginals, -2) + assert jnp.isclose(jnp.sum(marginals), 1.) + return marginals @vmap - def sample_action(self, q_pi: jnp.ndarray, rng_key=None): + def multiaction_to_category(self, multiaction: Array): + return jnp.argmax(jnp.all(self.unique_multiactions == multiaction, -1)) + + @vmap + def sample_action(self, q_pi: Array, rng_key=None): """ Sample or select a discrete action from the posterior over control states. diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index 233f45b7..7734686d 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -84,17 +84,14 @@ def sample_action(q_pi, policies, num_controls, action_selection="deterministic" def sample_policy(q_pi, policies, num_controls, action_selection="deterministic", alpha = 16.0, rng_key=None): - num_factors = len(num_controls) - if action_selection == "deterministic": policy_idx = jnp.argmax(q_pi) elif action_selection == "stochastic": p_policies = nn.softmax(log_stable(q_pi) * alpha) policy_idx = jr.categorical(rng_key, p_policies) - selected_policy = jtu.tree_map(lambda f: policies[policy_idx][0,f], list(range(num_factors))) - - return jnp.array(selected_policy) + selected_multiaction = policies[policy_idx, 0] + return selected_multiaction def construct_policies(num_states, num_controls = None, policy_len=1, control_fac_idx=None): """ From bc9794689adda00c279e2337dd532ac915d98113 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Thu, 7 Dec 2023 16:50:19 +0100 Subject: [PATCH 166/232] updated notebook --- examples/building_up_agent_loop.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/building_up_agent_loop.ipynb b/examples/building_up_agent_loop.ipynb index 6ad1ad99..abb6dc48 100644 --- a/examples/building_up_agent_loop.ipynb +++ b/examples/building_up_agent_loop.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -15,7 +15,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "metadata": {}, "outputs": [ { From 6563aae1c37427b2e8ea381c736f51fa28eb4748 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Thu, 7 Dec 2023 17:00:55 +0100 Subject: [PATCH 167/232] renamed the method to multiaction_probabilities --- pymdp/jax/agent.py | 21 ++++++++------------- 1 file changed, 8 insertions(+), 13 deletions(-) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 1a04f264..e68afbe2 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -209,6 +209,10 @@ def _construct_policies(self): self.num_states, self.num_controls, self.policy_len, self.control_fac_idx ) + @property + def unique_multiactions(self): + return jnp.unique(self.policies[:, 0], axis=0) + @vmap def learning(self, beliefs, outcomes, actions, **kwargs): @@ -327,15 +331,10 @@ def infer_policies(self, qs: List): return q_pi, G - @property - def unique_multiactions(self): - return jnp.unique(self.policies[:, 0], axis=0) - - @vmap - def action_probabilities(self, q_pi: Array): + def multiaction_probabilities(self, q_pi: Array): """ - Compute probabilities of discrete actions from the posterior over policies. + Compute probabilities of unique multi-actions from the posterior over policies. Parameters ---------- @@ -344,8 +343,8 @@ def action_probabilities(self, q_pi: Array): Returns ---------- - action: 2D ``jax.numpy.ndarray`` - Vector containing probabilities of possible actions for different factors + multi-action: 1D ``jax.numpy.ndarray`` + Vector containing probabilities of possible multi-actions for different factors """ if self.sampling_mode == "marginal": @@ -363,10 +362,6 @@ def action_probabilities(self, q_pi: Array): assert jnp.isclose(jnp.sum(marginals), 1.) return marginals - @vmap - def multiaction_to_category(self, multiaction: Array): - return jnp.argmax(jnp.all(self.unique_multiactions == multiaction, -1)) - @vmap def sample_action(self, q_pi: Array, rng_key=None): """ From 12a28a5c71e50c5e6e52d12166e6da3f0a00f492 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 7 Dec 2023 18:04:38 +0100 Subject: [PATCH 168/232] incorporated `B_dependencies` into VMP and MMP in `algos.py` (UNTESTED) --- pymdp/jax/algos.py | 34 ++++++++++++++++++++++------------ pymdp/jax/inference.py | 7 ++++--- 2 files changed, 26 insertions(+), 15 deletions(-) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index 9c98ebe1..eead824d 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -118,7 +118,7 @@ def mirror_gradient_descent_step(tau, ln_A, lnB_past, lnB_future, ln_qs): return qs -def update_marginals(get_messages, obs, A, B, prior, A_dependencies, num_iter=1, tau=1.,): +def update_marginals(get_messages, obs, A, B, prior, A_dependencies, B_dependencies, num_iter=1, tau=1.,): """" Version of marginal update that uses a sparse dependency matrix for A """ nf = len(prior) @@ -149,7 +149,8 @@ def scan_fn(carry, iter): ln_qs = jtu.tree_map(log_stable, qs) # messages from future $m_+(s_t)$ and past $m_-(s_t)$ for all time steps and factors. For t = T we have that $m_+(s_T) = 0$ - lnB_past, lnB_future = get_messages(ln_B, B, qs, ln_prior) + + lnB_past, lnB_future = get_messages(ln_B, B, qs, ln_prior, B_dependencies) mgds = jtu.Partial(mirror_gradient_descent_step, tau) @@ -225,10 +226,15 @@ def scan_fn(carry, iter): return qs, ps, qss -def get_vmp_messages(ln_B, B, qs, ln_prior): +def get_vmp_messages(ln_B, B, qs, ln_prior, B_dependencies): + num_factors = len(ln_B) + get_deps = lambda x, f_idx: [x[f] for f in f_idx] + all_deps_except_f = jtu.tree_map(lambda deps, f: [d for d in deps if d != f], B_dependencies, list(range(num_factors))) + ln_B_marg = jtu.tree_map(lambda b, deps, f: factor_dot(b, get_deps(qs, deps), keepdims=(0,1,f)), ln_B, all_deps_except_f, list(range(num_factors))) # shape = (T, states_f, states_f) + def forward(ln_b, q, ln_prior): - msg = vmap(lambda x, y: y @ x)(q[:-1], ln_b) + msg = vmap(lambda x, y: y @ x)(q[:-1], ln_b) # ln_b has shape (num_states, num_states) qs[:-1] has shape (T-1, num_states) return jnp.concatenate([jnp.expand_dims(ln_prior, 0), msg], axis=0) def backward(ln_b, q): @@ -237,25 +243,29 @@ def backward(ln_b, q): return jnp.pad(msg, ((0, 1), (0, 0))) if ln_B is not None: - lnB_future = jtu.tree_map(forward, ln_B, qs, ln_prior) - lnB_past = jtu.tree_map(backward, ln_B, qs) + lnB_future = jtu.tree_map(forward, ln_B_marg, qs, ln_prior) + lnB_past = jtu.tree_map(backward, ln_B_marg, qs) else: lnB_future = jtu.tree_map(lambda x: 0., qs) lnB_past = jtu.tree_map(lambda x: 0., qs) return lnB_future, lnB_past -def run_vmp(A, B, obs, prior, A_dependencies, num_iter=1, tau=1.): +def run_vmp(A, B, obs, prior, A_dependencies, B_dependencies, num_iter=1, tau=1.): ''' Run variational message passing (VMP) on a sequence of observations ''' - qs = update_marginals(get_vmp_messages, obs, A, B, prior, A_dependencies, num_iter=num_iter, tau=tau) + qs = update_marginals(get_vmp_messages, obs, A, B, prior, A_dependencies, B_dependencies, num_iter=num_iter, tau=tau) return qs +def get_mmp_messages(ln_B, B, qs, ln_prior, B_dependencies): + + num_factors = len(ln_B) + get_deps = lambda x, f_idx: [x[f] for f in f_idx] + all_deps_except_f = jtu.tree_map(lambda f: [d for d in B_dependencies[f] if d != f], list(range(num_factors))) + B_marg = jtu.tree_map(lambda b, f: factor_dot(b, get_deps(qs, all_deps_except_f[f]), keepdims=(0,1,f)), B, list(range(num_factors))) # shape = (T, states_f_{t+1}, states_f_{t}) -def get_mmp_messages(ln_B, B, qs, ln_prior): - def forward(b, q, ln_prior): if len(q) > 1: msg = vmap(lambda x, y: y @ x)(q[:-1], b) @@ -273,8 +283,8 @@ def backward(b, q): return jnp.pad(msg, ((0, 1), (0, 0))) if ln_B is not None: - lnB_future = jtu.tree_map(forward, B, qs, ln_prior) - lnB_past = jtu.tree_map(backward, B, qs) + lnB_future = jtu.tree_map(forward, B_marg, qs, ln_prior) + lnB_past = jtu.tree_map(backward, B_marg, qs) else: lnB_future = jtu.tree_map(lambda x: 0., qs) lnB_past = jtu.tree_map(lambda x: 0., qs) diff --git a/pymdp/jax/inference.py b/pymdp/jax/inference.py index ef0f5323..ea3734a3 100644 --- a/pymdp/jax/inference.py +++ b/pymdp/jax/inference.py @@ -18,15 +18,16 @@ def update_posterior_states(A, B, obs, past_actions, prior=None, qs_hist=None, A if past_actions is not None: nf = len(B) actions_tree = [past_actions[:, i] for i in range(nf)] - B = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(2, 0, 1), B, actions_tree) + + B = jtu.tree_map(lambda b, a_idx: jnp.moveaxis(b[..., a_idx], 0, -1), B, actions_tree) # this needs to be changed in case of `B_dependencies` because we have more than 3 dims in the B tensors else: B = None # outputs of both VMP and MMP should be a list of hidden state factors, where each qs[f].shape = (T, batch_dim, num_states_f) if method == 'vmp': - qs = run_vmp(A, B, obs, prior, A_dependencies, num_iter=num_iter) + qs = run_vmp(A, B, obs, prior, A_dependencies, B_dependencies, num_iter=num_iter) if method == 'mmp': - qs = run_mmp(A, B, obs, prior, A_dependencies, num_iter=num_iter) + qs = run_mmp(A, B, obs, prior, A_dependencies, B_dependencies, num_iter=num_iter) if qs_hist is not None: if method == 'fpi' or method == "ovf": From 1531cdf498b09796bc063485ef6d6f4f37e7e99c Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Fri, 8 Dec 2023 17:23:38 +0100 Subject: [PATCH 169/232] changed how the maximal size of unique multi-actions is computed --- pymdp/jax/agent.py | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index e68afbe2..aa0072bf 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -7,7 +7,7 @@ """ -import itertools +import math as pymath import jax.numpy as jnp import jax.tree_util as jtu from jax import nn, vmap, random @@ -51,6 +51,7 @@ class Agent(Module): # static parameters not leaves of the PyTree A_dependencies: Optional[List] = static_field() B_dependencies: Optional[List] = static_field() + batch_size: int = static_field() num_iter: int = static_field() num_obs: List = static_field() num_modalities: int = static_field() @@ -151,10 +152,10 @@ def __init__( assert self.pB[f].shape[2:-1] == factor_dims, f"Please input a `B_dependencies` whose {f}-th indices pick out the hidden state factors that line up with the all-but-final lagging dimensions of pB[{f}]..." assert max(self.B_dependencies[f]) <= (self.num_factors - 1), f"Check factor {f} of `B_dependencies` - must be consistent with `num_states` and `num_factors`..." - batch_dim = (self.A[0].shape[0],) + self.batch_size = self.A[0].shape[0] - self.gamma = jnp.broadcast_to(gamma, batch_dim) - self.alpha = jnp.broadcast_to(alpha, batch_dim) + self.gamma = jnp.broadcast_to(gamma, (self.batch_size,)) + self.alpha = jnp.broadcast_to(alpha, (self.batch_size,)) ### Static parameters ### @@ -211,7 +212,8 @@ def _construct_policies(self): @property def unique_multiactions(self): - return jnp.unique(self.policies[:, 0], axis=0) + size = pymath.prod(self.num_controls) + return jnp.unique(self.policies[:, 0], axis=0, size=size, fill_value=-1) @vmap def learning(self, beliefs, outcomes, actions, **kwargs): @@ -359,7 +361,7 @@ def multiaction_probabilities(self, q_pi: Array): ) marginals = jnp.where(locs, q_pi, 0.).sum(-1) - assert jnp.isclose(jnp.sum(marginals), 1.) + # assert jnp.isclose(jnp.sum(marginals), 1.) # this fails inside scan return marginals @vmap From 070899b88f576976b73781f3f65d0deab17b3da4 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Wed, 13 Dec 2023 16:29:09 +0100 Subject: [PATCH 170/232] fixed mmp --- pymdp/jax/agent.py | 2 +- pymdp/jax/algos.py | 67 ++++++++++++++++++++++++++++++++++-------- pymdp/jax/inference.py | 2 +- 3 files changed, 57 insertions(+), 14 deletions(-) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index aa0072bf..48076020 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -279,7 +279,7 @@ def infer_states(self, observations, past_actions, empirical_prior, qs_hist): prior=empirical_prior, qs_hist=qs_hist, A_dependencies=self.A_dependencies, - # B_dependencies=self.B_dependencies, + B_dependencies=self.B_dependencies, num_iter=self.num_iter, method=self.inference_algo ) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index eead824d..bcd6621c 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -1,10 +1,11 @@ import jax.numpy as jnp -from jax import jit, vmap, grad, lax, nn import jax.tree_util as jtu + +from jax import jit, vmap, grad, lax, nn # from jax.config import config # config.update("jax_enable_x64", True) -from pymdp.jax.maths import compute_log_likelihood, compute_log_likelihood_per_modality, log_stable, MINVAL +from .maths import compute_log_likelihood, compute_log_likelihood_per_modality, log_stable, MINVAL, factor_dot from typing import Any, List def add(x, y): @@ -228,10 +229,17 @@ def scan_fn(carry, iter): def get_vmp_messages(ln_B, B, qs, ln_prior, B_dependencies): - num_factors = len(ln_B) + num_factors = len(qs) get_deps = lambda x, f_idx: [x[f] for f in f_idx] - all_deps_except_f = jtu.tree_map(lambda deps, f: [d for d in deps if d != f], B_dependencies, list(range(num_factors))) - ln_B_marg = jtu.tree_map(lambda b, deps, f: factor_dot(b, get_deps(qs, deps), keepdims=(0,1,f)), ln_B, all_deps_except_f, list(range(num_factors))) # shape = (T, states_f, states_f) + all_deps_except_f = jtu.tree_map( + lambda deps, f: [d for d in deps if d != f], B_dependencies, list(range(num_factors)) + ) + ln_B_marg = jtu.tree_map( + lambda b, deps, f: factor_dot(b, get_deps(qs, deps), keepdims=(0,1,f)), + ln_B, + all_deps_except_f, + list(range(num_factors)) + ) # shape = (T, states_f, states_f) def forward(ln_b, q, ln_prior): msg = vmap(lambda x, y: y @ x)(q[:-1], ln_b) # ln_b has shape (num_states, num_states) qs[:-1] has shape (T-1, num_states) @@ -256,15 +264,40 @@ def run_vmp(A, B, obs, prior, A_dependencies, B_dependencies, num_iter=1, tau=1. Run variational message passing (VMP) on a sequence of observations ''' - qs = update_marginals(get_vmp_messages, obs, A, B, prior, A_dependencies, B_dependencies, num_iter=num_iter, tau=tau) + qs = update_marginals( + get_vmp_messages, + obs, + A, + B, + prior, + A_dependencies, + B_dependencies, + num_iter=num_iter, + tau=tau + ) return qs def get_mmp_messages(ln_B, B, qs, ln_prior, B_dependencies): - num_factors = len(ln_B) + num_factors = len(qs) + factors = list(range(num_factors)) get_deps = lambda x, f_idx: [x[f] for f in f_idx] - all_deps_except_f = jtu.tree_map(lambda f: [d for d in B_dependencies[f] if d != f], list(range(num_factors))) - B_marg = jtu.tree_map(lambda b, f: factor_dot(b, get_deps(qs, all_deps_except_f[f]), keepdims=(0,1,f)), B, list(range(num_factors))) # shape = (T, states_f_{t+1}, states_f_{t}) + all_deps_except_f = jtu.tree_map( + lambda f: [d for d in B_dependencies[f] if d != f], + factors + ) + position = jtu.tree_map( + lambda f: B_dependencies[f].index(f), + factors + ) + if B is not None: + B_marg = jtu.tree_map( + lambda b, f: factor_dot(b, get_deps(qs, all_deps_except_f[f]), keep_dims=(0, 1, 2 + position[f])), + B, + factors + ) # shape = (T, states_f_{t+1}, states_f_{t}) + else: + B_marg = None def forward(b, q, ln_prior): if len(q) > 1: @@ -282,7 +315,7 @@ def backward(b, q): msg = log_stable(msg) * 0.5 return jnp.pad(msg, ((0, 1), (0, 0))) - if ln_B is not None: + if B_marg is not None: lnB_future = jtu.tree_map(forward, B_marg, qs, ln_prior) lnB_past = jtu.tree_map(backward, B_marg, qs) else: @@ -291,8 +324,18 @@ def backward(b, q): return lnB_future, lnB_past -def run_mmp(A, B, obs, prior, A_dependencies, num_iter=1, tau=1.): - qs = update_marginals(get_mmp_messages, obs, A, B, prior, A_dependencies, num_iter=num_iter, tau=tau) +def run_mmp(A, B, obs, prior, A_dependencies, B_dependencies, num_iter=1, tau=1.): + qs = update_marginals( + get_mmp_messages, + obs, + A, + B, + prior, + A_dependencies, + B_dependencies, + num_iter=num_iter, + tau=tau + ) return qs def run_online_filtering(A, B, obs, prior, A_dependencies, num_iter=1, tau=1.): diff --git a/pymdp/jax/inference.py b/pymdp/jax/inference.py index ea3734a3..dba306d0 100644 --- a/pymdp/jax/inference.py +++ b/pymdp/jax/inference.py @@ -19,7 +19,7 @@ def update_posterior_states(A, B, obs, past_actions, prior=None, qs_hist=None, A nf = len(B) actions_tree = [past_actions[:, i] for i in range(nf)] - B = jtu.tree_map(lambda b, a_idx: jnp.moveaxis(b[..., a_idx], 0, -1), B, actions_tree) # this needs to be changed in case of `B_dependencies` because we have more than 3 dims in the B tensors + B = jtu.tree_map(lambda b, a_idx: jnp.moveaxis(b[..., a_idx], -1, 0), B, actions_tree) # this needs to be changed in case of `B_dependencies` because we have more than 3 dims in the B tensors else: B = None From 2d9d799937de5987a603f003c02506e381bd7de2 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 14 Dec 2023 16:36:43 +0100 Subject: [PATCH 171/232] fixed VMP with B dependencies in same way @dimarkov did for MMP --- pymdp/jax/algos.py | 29 +++++++++++++++++++---------- 1 file changed, 19 insertions(+), 10 deletions(-) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index bcd6621c..307f14e4 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -230,16 +230,25 @@ def scan_fn(carry, iter): def get_vmp_messages(ln_B, B, qs, ln_prior, B_dependencies): num_factors = len(qs) - get_deps = lambda x, f_idx: [x[f] for f in f_idx] - all_deps_except_f = jtu.tree_map( - lambda deps, f: [d for d in deps if d != f], B_dependencies, list(range(num_factors)) + factors = list(range(num_factors)) + get_deps = lambda x, f_idx: [x[f] for f in f_idx] # function that effectively "slices" a list with a set of indices `f_idx` + all_deps_except_f = jtu.tree_map( # this is a list of lists, where each list contains all dependencies of a factor except itself + lambda f: [d for d in B_dependencies[f] if d != f], + factors + ) + position = jtu.tree_map( # this is a list of integers, where each integer is the position of the self-factor in its dependencies list + lambda f: B_dependencies[f].index(f), + factors ) - ln_B_marg = jtu.tree_map( - lambda b, deps, f: factor_dot(b, get_deps(qs, deps), keepdims=(0,1,f)), - ln_B, - all_deps_except_f, - list(range(num_factors)) - ) # shape = (T, states_f, states_f) + + if ln_B is not None: + ln_B_marg = jtu.tree_map( # this is a list of matrices, where each matrix is the marginal transition tensor for factor f + lambda b, f: factor_dot(b, get_deps(qs, all_deps_except_f[f]), keep_dims=(0, 1, 2 + position[f])), + ln_B, + factors + ) # shape = (T, states_f_{t+1}, states_f_{t}) + else: + ln_B_marg = None def forward(ln_b, q, ln_prior): msg = vmap(lambda x, y: y @ x)(q[:-1], ln_b) # ln_b has shape (num_states, num_states) qs[:-1] has shape (T-1, num_states) @@ -250,7 +259,7 @@ def backward(ln_b, q): msg = vmap(lambda x, y: x @ y)(q[1:], ln_b) return jnp.pad(msg, ((0, 1), (0, 0))) - if ln_B is not None: + if ln_B_marg is not None: lnB_future = jtu.tree_map(forward, ln_B_marg, qs, ln_prior) lnB_past = jtu.tree_map(backward, ln_B_marg, qs) else: From dfcf184bea71d8ed893aea27f2ac58c2abd21f46 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Thu, 21 Dec 2023 14:53:12 +0100 Subject: [PATCH 172/232] simple code formating changes --- pymdp/jax/agent.py | 1 + pymdp/jax/algos.py | 8 ++++++-- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 48076020..7176b64f 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -222,6 +222,7 @@ def learning(self, beliefs, outcomes, actions, **kwargs): o_vec_seq = jtu.tree_map(lambda o, dim: nn.one_hot(o, dim), outcomes, self.num_obs) qA = learning.update_obs_likelihood_dirichlet(self.pA, self.A, o_vec_seq, beliefs, self.A_dependencies, lr=1.) E_qA = jtu.tree_map(lambda x: maths.dirichlet_expected_value(x), qA) + if self.learn_B: actions_seq = [actions[...,i] for i in range(actions.shape[-1])] # as many elements as there are control factors, where each element is a jnp.ndarray of shape (n_timesteps, ) actions_onehot = jtu.tree_map(lambda a, dim: nn.one_hot(a, dim, axis=-1), actions_seq, self.num_controls) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index 307f14e4..fb1235a2 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -232,11 +232,15 @@ def get_vmp_messages(ln_B, B, qs, ln_prior, B_dependencies): num_factors = len(qs) factors = list(range(num_factors)) get_deps = lambda x, f_idx: [x[f] for f in f_idx] # function that effectively "slices" a list with a set of indices `f_idx` - all_deps_except_f = jtu.tree_map( # this is a list of lists, where each list contains all dependencies of a factor except itself + + # make a list of lists, where each list contains all dependencies of a factor except itself + all_deps_except_f = jtu.tree_map( lambda f: [d for d in B_dependencies[f] if d != f], factors ) - position = jtu.tree_map( # this is a list of integers, where each integer is the position of the self-factor in its dependencies list + + # make list of integers, where each integer is the position of the self-factor in its dependencies list + position = jtu.tree_map( lambda f: B_dependencies[f].index(f), factors ) From 575612d8677ca44fa3d66c1f65e68486ec2394bd Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Thu, 21 Dec 2023 18:44:29 +0100 Subject: [PATCH 173/232] simple code formating changes --- pymdp/jax/inference.py | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/pymdp/jax/inference.py b/pymdp/jax/inference.py index dba306d0..cd5c8132 100644 --- a/pymdp/jax/inference.py +++ b/pymdp/jax/inference.py @@ -6,7 +6,18 @@ from .algos import run_factorized_fpi, run_mmp, run_vmp from jax import tree_util as jtu -def update_posterior_states(A, B, obs, past_actions, prior=None, qs_hist=None, A_dependencies=None, B_dependencies=None, num_iter=16, method='fpi'): +def update_posterior_states( + A, + B, + obs, + past_actions, + prior=None, + qs_hist=None, + A_dependencies=None, + B_dependencies=None, + num_iter=16, + method='fpi' + ): if method == 'fpi' or method == "ovf": # format obs to select only last observation From 851d5fdb96dfbd11ca379945d55653f7ada60ca7 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Tue, 26 Dec 2023 18:26:00 +0100 Subject: [PATCH 174/232] code formating changes --- pymdp/jax/agent.py | 68 ++++++++++++++++++++++---------------------- pymdp/jax/control.py | 2 ++ 2 files changed, 36 insertions(+), 34 deletions(-) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 7176b64f..b0f04417 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -12,9 +12,9 @@ import jax.tree_util as jtu from jax import nn, vmap, random from . import inference, control, learning, utils, maths -from equinox import Module, static_field, tree_at +from equinox import Module, field, tree_at -from typing import Any, List, AnyStr, Optional +from typing import List, Optional from jaxtyping import Array class Agent(Module): @@ -34,45 +34,45 @@ class Agent(Module): observations and takes actions as inputs, would entail a dynamic agent-environment interaction. """ - A: List - B: List - C: List - D: List + A: List[Array] + B: List[Array] + C: List[Array] + D: List[Array] E: Array # empirical_prior: List gamma: Array alpha: Array - qs: Optional[List] - q_pi: Optional[List] + qs: Optional[List[Array]] + q_pi: Optional[List[Array]] - pA: List - pB: List + pA: List[Array] + pB: List[Array] # static parameters not leaves of the PyTree - A_dependencies: Optional[List] = static_field() - B_dependencies: Optional[List] = static_field() - batch_size: int = static_field() - num_iter: int = static_field() - num_obs: List = static_field() - num_modalities: int = static_field() - num_states: List = static_field() - num_factors: int = static_field() - num_controls: List = static_field() - control_fac_idx: Any = static_field() - policy_len: int = static_field() - policies: Any = static_field() - use_utility: bool = static_field() - use_states_info_gain: bool = static_field() - use_param_info_gain: bool = static_field() - action_selection: AnyStr = static_field() # determinstic or stochastic - sampling_mode : AnyStr = static_field() # whether to sample from full posterior over policies ("full") or from marginal posterior over actions ("marginal") - inference_algo: AnyStr = static_field() # fpi, vmp, mmp, ovf - - learn_A: bool = static_field() - learn_B: bool = static_field() - learn_C: bool = static_field() - learn_D: bool = static_field() - learn_E: bool = static_field() + A_dependencies: Optional[List] = field(static=True) + B_dependencies: Optional[List] = field(static=True) + batch_size: int = field(static=True) + num_iter: int = field(static=True) + num_obs: List[int] = field(static=True) + num_modalities: int = field(static=True) + num_states: List[int] = field(static=True) + num_factors: int = field(static=True) + num_controls: List[int] = field(static=True) + control_fac_idx: Optional[List[int]] = field(static=True) + policy_len: int = field(static=True) + policies: Array = field(static=True) + use_utility: bool = field(static=True) + use_states_info_gain: bool = field(static=True) + use_param_info_gain: bool = field(static=True) + action_selection: str = field(static=True) # determinstic or stochastic + sampling_mode : str = field(static=True) # whether to sample from full posterior over policies ("full") or from marginal posterior over actions ("marginal") + inference_algo: str = field(static=True) # fpi, vmp, mmp, ovf + + learn_A: bool = field(static=True) + learn_B: bool = field(static=True) + learn_C: bool = field(static=True) + learn_D: bool = field(static=True) + learn_E: bool = field(static=True) def __init__( self, diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index 7734686d..75d128ab 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -157,6 +157,8 @@ def compute_expected_state(qs_prior, B, u_t, B_dependencies=None): """ Compute posterior over next state, given belief about previous state, transition model and action... """ + #Note: this algorithm is only correct if each factor depends only on itself. For any interactions, + # we will have empirical priors with codependent factors. assert len(u_t) == len(B) qs_next = [] for B_f, u_f, deps in zip(B, u_t, B_dependencies): From c97b6ee6dcb4009f954b0db904d000840c54a5d7 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Tue, 26 Dec 2023 18:26:32 +0100 Subject: [PATCH 175/232] example for runing pymdp with large observation and latent spaces --- examples/testing_large_latent_spaces.ipynb | 387 +++++++++++++++++++++ 1 file changed, 387 insertions(+) create mode 100644 examples/testing_large_latent_spaces.ipynb diff --git a/examples/testing_large_latent_spaces.ipynb b/examples/testing_large_latent_spaces.ipynb new file mode 100644 index 00000000..f87b5cd6 --- /dev/null +++ b/examples/testing_large_latent_spaces.ipynb @@ -0,0 +1,387 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "# Set cuda device to use\n", + "os.environ[\"CUDA_DEVICE_ORDER\"] = \"PCI_BUS_ID\"\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\"\n", + "\n", + "# do not prealocate memory\n", + "os.environ[\"XLA_PYTHON_CLIENT_PREALLOCATE\"] = \"false\"\n", + "os.environ[\"XLA_PYTHON_CLIENT_ALLOCATOR\"] = \"platform\"" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import jax.numpy as jnp\n", + "import jax.tree_util as jtu\n", + "import equinox as eqx\n", + "from functools import partial\n", + "from jax import vmap, lax, nn, jit\n", + "from jax import random as jr\n", + "from pymdp.jax.agent import Agent as AIFAgent\n", + "from pymdp.utils import random_A_matrix, random_B_matrix\n", + "from opt_einsum import contract" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# @partial(jit, static_argnames=['dims', 'keep_dims'])\n", + "def factor_dot(M, xs, dims, keep_dims = None):\n", + " \"\"\" Dot product of a multidimensional array with `x`.\n", + " \n", + " Parameters\n", + " ----------\n", + " - `qs` [list of 1D numpy.ndarray] - list of jnp.ndarrays\n", + " \n", + " Returns \n", + " -------\n", + " - `Y` [1D numpy.ndarray] - the result of the dot product\n", + " \"\"\"\n", + " all_dims = list(range(M.ndim))\n", + " matrix = [[xs[f], dims[f]] for f in range(len(xs))]\n", + " args = [M, all_dims]\n", + " for row in matrix:\n", + " args.extend(row)\n", + "\n", + " args += [keep_dims]\n", + " return contract(*args, backend='jax', optimize='auto')\n", + "\n", + "@vmap\n", + "def get_marginals(posterior):\n", + " d = posterior.ndim - 1\n", + " marginals = []\n", + " for i in range(d):\n", + " marginals.append( jnp.sum(posterior, axis=(j + 1 for j in range(d) if j != i)) )\n", + "\n", + " return marginals\n", + "\n", + "@vmap\n", + "def merge_marginals(marginals):\n", + " q = marginals[0]\n", + " for m in marginals[1:]:\n", + " q = jnp.expand_dims(q, -1) * m\n", + " \n", + " return q" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0, 2, 3)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def make_tuple(i, d, ext):\n", + " l = [i,]\n", + " l.extend(d + i for i in ext)\n", + " return tuple(l)\n", + "\n", + "make_tuple(0, 1, (1, 2))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "@partial(vmap, in_axes=(0, 0, None, None))\n", + "def delta_A(beliefs, outcomes, deps, num_obs):\n", + " def merge(beliefs, outcomes):\n", + " y = nn.one_hot(outcomes, num_obs)\n", + " d = beliefs.ndim\n", + " marg_beliefs = jnp.sum(beliefs, axis=(i for i in range(d) if i not in deps))\n", + " axis = ( - (i+1) for i in range(len(deps)))\n", + " return jnp.expand_dims(y, axis) * marg_beliefs\n", + " \n", + " return vmap(merge, in_axes=(0, None))(beliefs, outcomes)\n", + " \n", + "@partial(vmap, in_axes=(0, 0, 0, None))\n", + "def delta_B(post_b, cond_b, action, num_actions):\n", + " a = nn.one_hot(action, num_actions)\n", + " all_dims = tuple(range(cond_b.ndim - 1))\n", + " fd = lambda x, y: factor_dot(x, [y], ((0,),), keep_dims=all_dims)\n", + " b = vmap(fd)(cond_b, post_b)\n", + " return b * a\n", + "\n", + "@partial(vmap, in_axes=(None, 0))\n", + "def get_reverse_conditionals(B, beliefs):\n", + " all_dims = tuple(range(B.ndim - 1))\n", + " dims = tuple((i,) for i in all_dims[1:-1])\n", + " fd = lambda x, y: factor_dot(x, y, dims, keep_dims=all_dims)\n", + " joint = vmap(fd)(B, beliefs)\n", + " pred = joint.sum(axis=all_dims[2:], keepdims=True)\n", + " return joint / pred\n", + "\n", + "@partial(vmap, in_axes=(0, 0, None))\n", + "def get_reverse_predictive(post, cond, deps):\n", + " def pred(post, cond, deps):\n", + " d = post.ndim\n", + " dims = tuple(make_tuple(i, d, deps[i]) for i in range(len(deps)))\n", + " keep_dims = dims[0][1:]\n", + " for row in dims[1:]:\n", + " keep_dims.extend(row)\n", + " \n", + " unique_dims = tuple(set(keep_dims))\n", + "\n", + " return factor_dot(post, cond, dims, keep_dims=unique_dims)\n", + " \n", + " out = vmap(pred, in_axes=(0, 0, None))(post, cond, deps)\n", + " return out\n", + "\n", + "def learning(agent, beliefs, actions, outcomes, lag=1):\n", + " A_deps = agent.A_dependencies\n", + " B_deps = agent.B_dependencies\n", + " num_obs = agent.num_obs\n", + " posterior_beliefs = merge_marginals( jtu.tree_map(lambda x: x[..., -1, :], beliefs) )\n", + " qA = agent.pA\n", + " qB = agent.pB\n", + " def step_fn(carry, xs):\n", + " posterior_beliefs, qA, qB = carry\n", + " obs, acts, filter_beliefs = xs\n", + " # learn A matrix\n", + " qA = jtu.tree_map(\n", + " lambda qa, o, m: qa + delta_A(posterior_beliefs, o, A_deps[m], num_obs[m]).sum(0), \n", + " qA, \n", + " obs, \n", + " list(range(len(num_obs)))\n", + " )\n", + "\n", + " # learn B matrix\n", + " conditional_beliefs = jtu.tree_map(\n", + " lambda b, f: get_reverse_conditionals(b, [filter_beliefs[i] for i in B_deps[f]]),\n", + " agent.B, \n", + " list(range(len(agent.B))) \n", + " )\n", + " post_marg = get_marginals(posterior_beliefs)\n", + " acts = [acts[..., i] for i in range(acts.shape[-1])]\n", + "\n", + " qB = jtu.tree_map(\n", + " lambda qb, pb, cb, a, nc: qb + delta_B(pb, cb, a, nc).sum(0),\n", + " qB,\n", + " post_marg,\n", + " conditional_beliefs,\n", + " acts,\n", + " agent.num_controls \n", + " )\n", + "\n", + " # compute posterior beliefs for the next time step\n", + " get_transition = lambda cb, a: cb[..., a]\n", + " conditional_beliefs = jtu.tree_map(\n", + " lambda cb, a: vmap(get_transition)(cb, a), conditional_beliefs, acts\n", + " )\n", + " posterior_beliefs = get_reverse_predictive(posterior_beliefs, conditional_beliefs, B_deps)\n", + "\n", + " return (posterior_beliefs, qA, qB), None\n", + "\n", + " first_outcomes = jtu.tree_map(lambda x: x[..., 0], outcomes)\n", + " outcomes = jtu.tree_map(lambda x: jnp.flipud(x.swapaxes(0, 1))[1:lag+1], outcomes)\n", + " actions = jnp.flipud(actions.swapaxes(0, 1))[:lag]\n", + " beliefs = jtu.tree_map(lambda x: jnp.flipud(jnp.moveaxis(x, 2, 0))[1:lag+1], beliefs)\n", + " iters = (outcomes, actions, beliefs)\n", + " (last_beliefs, qA, qB), _ = lax.scan(step_fn, (posterior_beliefs, qA, qB), iters)\n", + "\n", + " # update A with the first outcome \n", + " qA = jtu.tree_map(\n", + " lambda qa, o, m: qa + delta_A(last_beliefs, o, A_deps[m], num_obs[m]).sum(0), \n", + " qA, \n", + " first_outcomes, \n", + " list(range(len(num_obs)))\n", + " )\n", + "\n", + " E_qA = jtu.tree_map(lambda qa: qa / qa.sum(0), qA)\n", + " E_qB =jtu.tree_map(lambda qb: qb / qb.sum(0), qB)\n", + " E_qA = agent.A\n", + " E_qB = agent.B\n", + " agent = eqx.tree_at(lambda x: (x.A, x.pA, x.B, x.pB), agent, (E_qA, qA, E_qB, qB))\n", + "\n", + " return agent" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "class TestEnv:\n", + " def __init__(self, num_agents, num_obs, prng_key=jr.PRNGKey(0)):\n", + " self.num_obs = num_obs\n", + " self.num_agents = num_agents\n", + " self.key = prng_key\n", + " \n", + " def step(self, actions=None):\n", + " # return a list of random observations for each agent or parallel realization (each entry in batch_dim)\n", + " obs = [jr.randint(self.key, (self.num_agents,), 0, no) for no in self.num_obs]\n", + " self.key, _ = jr.split(self.key)\n", + " return obs\n", + " \n", + "def update_agent_state(agent, env, args, key, outcomes, actions):\n", + " beliefs = agent.infer_states(outcomes, actions, *args)\n", + " # q_pi, _ = agent.infer_policies(beliefs)\n", + " q_pi = jnp.ones((agent.batch_size, 6)) / 6\n", + " batch_keys = jr.split(key, agent.batch_size)\n", + " actions = agent.sample_action(q_pi, rng_key=batch_keys)\n", + "\n", + " outcomes = env.step(actions)\n", + " outcomes = jtu.tree_map(lambda x: jnp.expand_dims(x, -1), outcomes)\n", + " args = agent.update_empirical_prior(actions, beliefs)\n", + " args = (args[0], None) # remove belief history from args\n", + " latest_belief = jtu.tree_map(lambda x: x[:, 0], beliefs)\n", + "\n", + " return args, latest_belief, outcomes, actions\n", + "\n", + "def evolve_trials(agent, env, batch_size, num_timesteps, prng_key=jr.PRNGKey(0)):\n", + "\n", + " def step_fn(carry, xs):\n", + " actions = carry['actions']\n", + " outcomes = carry['outcomes']\n", + " key = carry['key']\n", + " key, _key = jr.split(key)\n", + " vect_uas = vmap(partial(update_agent_state, agent, env))\n", + " keys = jr.split(_key, batch_size)\n", + " args, beliefs, outcomes, actions = vect_uas(carry['args'], keys, outcomes, actions)\n", + " output = {\n", + " 'args': args, \n", + " 'outcomes': outcomes, \n", + " 'actions': actions,\n", + " 'key': key\n", + " }\n", + "\n", + " return output, {'beliefs': beliefs, 'actions': actions[..., 0, :], 'outcomes': outcomes}\n", + "\n", + " \n", + " outcome_0 = jtu.tree_map(lambda x: jnp.expand_dims(x, -1), env.step())\n", + " outcome_0 = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_size,) + x.shape), outcome_0)\n", + " prior = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_size,) + x.shape), agent.D)\n", + " init = {\n", + " 'args': (prior, None),\n", + " 'outcomes': outcome_0,\n", + " 'actions': - jnp.ones((batch_size, 1, 1), dtype=jnp.int32),\n", + " 'key': prng_key\n", + " }\n", + "\n", + " last, sequences = lax.scan(step_fn, init, jnp.arange(num_timesteps))\n", + " sequences['outcomes'] = jtu.tree_map(\n", + " lambda x, y: jnp.concatenate([jnp.expand_dims(x.squeeze(), 0), y.squeeze()]), \n", + " outcome_0, \n", + " sequences['outcomes']\n", + " )\n", + "\n", + " return last, sequences\n", + "\n", + "@partial(jit, static_argnums=(1, 2, 3, 4))\n", + "def training_step(agent, env, batch_size, num_timesteps, lag=1):\n", + " output, sequences = evolve_trials(agent, env, batch_size, num_timesteps)\n", + " args = output.pop('args')\n", + " \n", + " outcomes = jtu.tree_map(lambda x: x.swapaxes(0, 1), sequences['outcomes'])\n", + " actions = sequences['actions'].swapaxes(0, 1)\n", + " beliefs = jtu.tree_map(lambda x: jnp.moveaxis(x, [0, 2], [1, 1]), sequences['beliefs'])\n", + "\n", + " def update_beliefs(outcomes, actions, args):\n", + " return agent.infer_states(outcomes, actions, *args)\n", + "\n", + " # update beliefs with the last action-outcome pair\n", + " last_belief = vmap(update_beliefs)(\n", + " output['outcomes'], \n", + " output['actions'],\n", + " args\n", + " )\n", + "\n", + " beliefs = jtu.tree_map(lambda x, y: jnp.concatenate([x, y], -2), beliefs, last_belief)\n", + " agent = learning(agent, beliefs, actions, outcomes, lag=lag)\n", + "\n", + " return agent\n", + "\n", + "# define an agent and environment here\n", + "batch_size = 64\n", + "num_agents = 1\n", + "num_obs = [256, 256, 256 ** 2]\n", + "num_states = [3062]\n", + "num_controls = [6]\n", + "num_blocks = 1\n", + "num_timesteps = 25\n", + "\n", + "A_np = random_A_matrix(num_obs=num_obs, num_states=num_states)\n", + "B_np = random_B_matrix(num_states=num_states, num_controls=num_controls)\n", + "A = jtu.tree_map(lambda x: jnp.broadcast_to(x, (num_agents,) + x.shape), list(A_np))\n", + "B = jtu.tree_map(lambda x: jnp.broadcast_to(x, (num_agents,) + x.shape), list(B_np))\n", + "C = [jnp.zeros((num_agents, no)) for no in num_obs]\n", + "D = [jnp.ones((num_agents, ns)) / ns for ns in num_states]\n", + "E = jnp.ones((num_agents, 4 )) / 4 \n", + "\n", + "pA = jtu.tree_map(lambda x: jnp.broadcast_to(jnp.ones_like(x), (num_agents,) + x.shape), list(A_np))\n", + "pB = jtu.tree_map(lambda x: jnp.broadcast_to(jnp.ones_like(x), (num_agents,) + x.shape), list(B_np))\n", + "\n", + "agents = AIFAgent(A, B, C, D, E, pA, pB, use_param_info_gain=True, inference_algo='fpi', sampling_mode='marginal', action_selection='stochastic', num_iter=1)\n", + "env = TestEnv(num_agents, num_obs)\n", + "agents = training_step(agents, env, batch_size, num_timesteps, lag=25)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10.9 s ± 24.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "agents = lax.stop_gradient(agents)\n", + "%timeit training_step(agents, env, batch_size, num_timesteps, lag=25).A[0].block_until_ready()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "jax_pymdp_test", + "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.11.7" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} From a323baddfe7b27aadc629f4ca4828f5b980f5205 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Tue, 2 Jan 2024 15:36:43 +0100 Subject: [PATCH 176/232] rewrite marginal log likleihood using factor_dot --- pymdp/jax/algos.py | 22 ++-------------------- 1 file changed, 2 insertions(+), 20 deletions(-) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index fb1235a2..1e059c06 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -12,24 +12,8 @@ def add(x, y): return x + y def marginal_log_likelihood(qs, log_likelihood, i): - if i == 0: - x = jnp.ones_like(qs[0]) - else: - x = qs[0] - - parallel_ndim = len(x.shape[:-1]) - - tpl = (-2,) - for (f, q) in enumerate(qs[1:]): - if (f + 1) != i: - x = jnp.expand_dims(x, -1) * jnp.expand_dims(q, tpl) - else: - x = jnp.expand_dims(x, -1) * jnp.expand_dims(jnp.ones_like(q), tpl) - tpl = tpl + (tpl[f] - 1,) - - joint = log_likelihood * x - dims = (f + parallel_ndim for f in range(len(qs)) if f != i) - return joint.sum(dims) + xs = [q for j, q in enumerate(qs) if j != i] + return factor_dot(log_likelihood, xs, keep_dims=(i,)) def all_marginal_log_likelihood(qs, log_likelihoods, all_factor_lists): qL_marginals = jtu.tree_map(lambda ll_m, factor_list_m: mll_factors(qs, ll_m, factor_list_m), log_likelihoods, all_factor_lists) @@ -84,8 +68,6 @@ def run_factorized_fpi(A, obs, prior, A_dependencies, num_iter=1): Run the fixed point iteration algorithm with sparse dependencies between factors and outcomes (stored in `A_dependencies`) """ - nf = len(prior) - factors = list(range(nf)) # Step 1: Compute log likelihoods for each factor log_likelihoods = compute_log_likelihood_per_modality(obs, A) From cdc59b464f8f7c6264799d860d024948373c1e06 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Tue, 2 Jan 2024 23:17:00 +0100 Subject: [PATCH 177/232] updated factor_dot --- pymdp/jax/maths.py | 24 ++++++++++++++++++++---- 1 file changed, 20 insertions(+), 4 deletions(-) diff --git a/pymdp/jax/maths.py b/pymdp/jax/maths.py index ff23841a..e1fef410 100644 --- a/pymdp/jax/maths.py +++ b/pymdp/jax/maths.py @@ -1,7 +1,7 @@ import jax.numpy as jnp from functools import partial -from typing import Optional, Tuple +from typing import Optional, Tuple, List from jax import tree_util, nn, jit from opt_einsum import contract @@ -24,10 +24,26 @@ def factor_dot(M, xs, keep_dims: Optional[Tuple[int]] = None): """ d = len(keep_dims) if keep_dims is not None else 0 assert M.ndim == len(xs) + d + keep_dims = () if keep_dims is None else keep_dims + dims = tuple((i,) for i in range(M.ndim) if i not in keep_dims) + return factor_dot_flex(M, xs, dims, keep_dims=keep_dims) - all_dims = list(range(M.ndim)) - dims = all_dims if keep_dims is None else [i for i in range(M.ndim) if i not in keep_dims] - matrix = [[xs[f], [dims[f]]] for f in range(len(xs))] +@partial(jit, static_argnames=['dims', 'keep_dims']) +def factor_dot_flex(M, xs, dims: List[Tuple[int]], keep_dims: Optional[Tuple[int]] = None): + """ Dot product of a multidimensional array with `x`. + + Parameters + ---------- + - `M` [numpy.ndarray] - tensor + - 'xs' [list of numpyr.ndarray] - list of tensors + - 'dims' [list of tuples] - list of dimensions of xs tensors in tensor M + - 'keep_dims' [tuple] - tuple of integers denoting dimesions to keep + Returns + ------- + - `Y` [1D numpy.ndarray] - the result of the dot product + """ + all_dims = tuple(range(M.ndim)) + matrix = [[xs[f], dims[f]] for f in range(len(xs))] args = [M, all_dims] for row in matrix: args.extend(row) From e4da1d61f07359f44af6af8ce3b103510f4f673d Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Tue, 2 Jan 2024 23:17:19 +0100 Subject: [PATCH 178/232] fixed MMP algorithm --- pymdp/jax/algos.py | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index 1e059c06..bb155b0b 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -5,7 +5,7 @@ # from jax.config import config # config.update("jax_enable_x64", True) -from .maths import compute_log_likelihood, compute_log_likelihood_per_modality, log_stable, MINVAL, factor_dot +from .maths import compute_log_likelihood, compute_log_likelihood_per_modality, log_stable, MINVAL, factor_dot, factor_dot_flex from typing import Any, List def add(x, y): @@ -20,7 +20,9 @@ def all_marginal_log_likelihood(qs, log_likelihoods, all_factor_lists): num_factors = len(qs) - qL_all = [0.] * num_factors + # insted of a double loop we could have a list defining m to f mapping + # which could be resolved with a single tree_map cast + qL_all = [jnp.zeros(1)] * num_factors for m, factor_list_m in enumerate(all_factor_lists): for l, f in enumerate(factor_list_m): qL_all[f] += qL_marginals[m][l] @@ -106,7 +108,6 @@ def update_marginals(get_messages, obs, A, B, prior, A_dependencies, B_dependenc nf = len(prior) T = obs[0].shape[0] - factors = list(range(nf)) ln_B = jtu.tree_map(log_stable, B) # log likelihoods -> $\ln(A)$ for all time steps # for $k > t$ we have $\ln(A) = 0$ @@ -137,7 +138,7 @@ def scan_fn(carry, iter): mgds = jtu.Partial(mirror_gradient_descent_step, tau) - ln_As = all_marginal_log_likelihood(qs, log_likelihoods, A_dependencies) + ln_As = vmap(all_marginal_log_likelihood, in_axes=(0, 0, None))(qs, log_likelihoods, A_dependencies) qs = jtu.tree_map(mgds, ln_As, lnB_past, lnB_future, ln_qs) @@ -272,27 +273,26 @@ def run_vmp(A, B, obs, prior, A_dependencies, B_dependencies, num_iter=1, tau=1. ) return qs -def get_mmp_messages(ln_B, B, qs, ln_prior, B_dependencies): +def get_mmp_messages(ln_B, B, qs, ln_prior, B_deps): num_factors = len(qs) factors = list(range(num_factors)) - get_deps = lambda x, f_idx: [x[f] for f in f_idx] + get_deps = lambda x, f_idx: [x[f][:-1] for f in f_idx] all_deps_except_f = jtu.tree_map( - lambda f: [d for d in B_dependencies[f] if d != f], + lambda f: [d for d in B_deps[f] if d != f], factors ) position = jtu.tree_map( - lambda f: B_dependencies[f].index(f), + lambda f: B_deps[f].index(f), factors ) - if B is not None: - B_marg = jtu.tree_map( - lambda b, f: factor_dot(b, get_deps(qs, all_deps_except_f[f]), keep_dims=(0, 1, 2 + position[f])), - B, - factors - ) # shape = (T, states_f_{t+1}, states_f_{t}) - else: - B_marg = None + + dims = jtu.tree_map(lambda f: tuple((0,) + (2 + B_deps[f].index(i),) for i in all_deps_except_f[f]), factors) + def func(b, f): + xs = get_deps(qs, all_deps_except_f[f]) + return factor_dot_flex(b, xs, dims[f], keep_dims=(0, 1, 2 + position[f]) ) + + B_marg = jtu.tree_map(func, B, factors) if B is not None else None def forward(b, q, ln_prior): if len(q) > 1: From 75808af9ed44feb5905b55294d24c43a3b83e328 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Tue, 2 Jan 2024 23:19:34 +0100 Subject: [PATCH 179/232] added partial vmap --- pymdp/jax/agent.py | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index b0f04417..d4d58ede 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -16,6 +16,7 @@ from typing import List, Optional from jaxtyping import Array +from functools import partial class Agent(Module): """ @@ -248,7 +249,7 @@ def learning(self, beliefs, outcomes, actions, **kwargs): return agent @vmap - def infer_states(self, observations, past_actions, empirical_prior, qs_hist): + def infer_states(self, observations, past_actions, empirical_prior, qs_hist): """ Update approximate posterior over hidden states by solving variational inference problem, given an observation. @@ -285,12 +286,9 @@ def infer_states(self, observations, past_actions, empirical_prior, qs_hist): method=self.inference_algo ) - # if ovf_smooth: - # output = inference.smoothing(output) - return output - @vmap + @partial(vmap, in_axes=(0, 0, 0)) def update_empirical_prior(self, action, qs): # return empirical_prior, and the history of posterior beliefs (filtering distributions) held about hidden states at times 1, 2 ... t @@ -392,7 +390,7 @@ def _get_default_params(self): method = self.inference_algo default_params = None if method == "VANILLA": - default_params = {"num_iter": 10, "dF": 1.0, "dF_tol": 0.001} + default_params = {"num_iter": 8, "dF": 1.0, "dF_tol": 0.001} elif method == "MMP": raise NotImplementedError("MMP is not implemented") elif method == "VMP": From 20ba71b1dbb30fde6a6c77ec9ba96b5dd6d77fd5 Mon Sep 17 00:00:00 2001 From: Conor Heins Date: Tue, 9 Jan 2024 18:49:58 +0100 Subject: [PATCH 180/232] inductive planning algorithm now in jax - see `inductive_inference_example.ipynb` for application in random generative model --- examples/inductive_inference_example.ipynb | 141 +++++++++++++++++++ pymdp/jax/control.py | 149 ++++++++++++++++++++- 2 files changed, 289 insertions(+), 1 deletion(-) create mode 100644 examples/inductive_inference_example.ipynb diff --git a/examples/inductive_inference_example.ipynb b/examples/inductive_inference_example.ipynb new file mode 100644 index 00000000..1cf566bd --- /dev/null +++ b/examples/inductive_inference_example.ipynb @@ -0,0 +1,141 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from pymdp.jax import control\n", + "import jax.numpy as jnp\n", + "import jax.tree_util as jtu\n", + "from jax import nn, vmap, random, lax\n", + "\n", + "from typing import List, Optional\n", + "from jaxtyping import Array\n", + "from jax import random as jr" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Set up generative model (random one with trivial observation model)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Set up a generative model\n", + "num_states = [5, 3]\n", + "num_controls = [2, 2]\n", + "\n", + "# make some arbitrary policies (policy depth 3, 2 control factors)\n", + "policy_1 = jnp.array([[0, 1],\n", + " [1, 1],\n", + " [0, 0]])\n", + "policy_2 = jnp.array([[1, 0],\n", + " [0, 0],\n", + " [1, 1]])\n", + "policy_matrix = jnp.stack([policy_1, policy_2]) \n", + "\n", + "# observation modalities (isomorphic/identical to hidden states, just need to include for the need to include likleihood model)\n", + "num_obs = [5, 3]\n", + "num_factors = len(num_states)\n", + "num_modalities = len(num_obs)\n", + "\n", + "# sample parameters of the model (A, B, C)\n", + "key = jr.PRNGKey(1)\n", + "factor_keys = jr.split(key, num_factors)\n", + "\n", + "d = [0.1* jr.uniform(factor_key, (ns,)) for factor_key, ns in zip(factor_keys, num_states)]\n", + "qs_init = [jr.dirichlet(factor_key, d_f) for factor_key, d_f in zip(factor_keys, d)]\n", + "A = [jnp.eye(no) for no in num_obs]\n", + "\n", + "factor_keys = jr.split(factor_keys[-1], num_factors)\n", + "b = [jr.uniform(factor_keys[f], shape=(num_controls[f], num_states[f], num_states[f])) for f in range(num_factors)]\n", + "b_sparse = [jnp.where(b_f < 0.75, 1e-5, b_f) for b_f in b]\n", + "B = [jnp.swapaxes(jr.dirichlet(factor_keys[f], b_sparse[f]), 2, 0) for f in range(num_factors)]\n", + "\n", + "modality_keys = jr.split(factor_keys[-1], num_modalities)\n", + "C = [nn.one_hot(jr.randint(modality_keys[m], shape=(1,), minval=0, maxval=num_obs[m]), num_obs[m]) for m in range(num_modalities)]\n", + "\n", + "# trivial dependencies -- factor 1 drives modality 1, etc.\n", + "A_dependencies = [[0], [1]]\n", + "B_dependencies = [[0], [1]]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate sparse constraints vectors `H` and inductive matrix `I`, using inductive parameters like depth and threshold " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# generate random constraints (H vector)\n", + "factor_keys = jr.split(key, num_factors)\n", + "H = [jr.uniform(factor_key, (ns,)) for factor_key, ns in zip(factor_keys, num_states)]\n", + "H = [jnp.where(h < 0.75, 0., 1.) for h in H]\n", + "\n", + "# depth and threshold for inductive planning algorithm. I made policy-depth equal to inductive planning depth, out of ignorance -- need to ask Tim or Tommaso about this\n", + "inductive_depth, inductive_threshold = 3, 0.5\n", + "I = control.generate_I_matrix(H, B, inductive_threshold, inductive_depth)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Evaluate posterior probability of policies and negative EFE using new version of `update_posterior_policies`\n", + "#### This function no longer computes info gain (for both states and parameters) since deterministic model is assumed, and includes new inductive matrix `I` and `inductive_epsilon` parameter" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# evaluate Q(pi) and negative EFE using the inductive planning algorithm\n", + "q_pi, neg_efe = control.update_posterior_policies_inductive(policy_matrix, qs_init, A, B, C, A_dependencies, B_dependencies, I, gamma=16.0, use_utility=True, use_inductive=True, inductive_epsilon=1e-3)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "atari_env", + "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.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index 75d128ab..230b185a 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -6,11 +6,12 @@ import itertools import jax.numpy as jnp import jax.tree_util as jtu -from typing import Tuple, Optional +from typing import List, Tuple, Optional from functools import partial from jax import lax, jit, vmap, nn from jax import random as jr from itertools import chain +from jaxtyping import Array from pymdp.jax.maths import * # import pymdp.jax.utils as utils @@ -337,6 +338,152 @@ def scan_body(carry, t): qs_final, neg_G = final_state return neg_G +def compute_G_policy_inductive(qs_init, A, B, C, A_dependencies, B_dependencies, I, policy_i, use_utility=True, use_inductive=True, inductive_epsilon=1e-3): + """ + Write a version of compute_G_policy that does the same computations as `compute_G_policy` but using `lax.scan` instead of a for loop. + @NOTE: THis one further includes computations used for inductive planning, which only works in case of deterministic generative models so info gain is excluded (for now) + """ + + def scan_body(carry, t): + + qs, neg_G = carry + + qs_next = compute_expected_state(qs, B, policy_i[t], B_dependencies) + + qo = compute_expected_obs(qs_next, A, A_dependencies) + + # info_gain = compute_info_gain(qs_next, qo, A, A_dependencies) if use_states_info_gain else 0. + + utility = compute_expected_utility(qo, C) if use_utility else 0. + + inductive_value = calc_inductive_value_t(qs_init, qs_next, I, epsilon=inductive_epsilon) if use_inductive else 0. + + neg_G = utility + inductive_value + + # param_info_gain = calc_pA_info_gain(pA, qo, qs_next) if use_param_info_gain else 0. + # param_info_gain += calc_pB_info_gain(pB, qs_next, qs) if use_param_info_gain else 0. + + # neg_G += info_gain + utility + param_info_gain + + return (qs_next, neg_G), None + + qs = qs_init + neg_G = 0. + final_state, _ = lax.scan(scan_body, (qs, neg_G), jnp.arange(policy_i.shape[0])) + qs_final, neg_G = final_state + return neg_G + +def update_posterior_policies_inductive(policy_matrix, qs_init, A, B, C, A_dependencies, B_dependencies, I, gamma=16.0, use_utility=True, use_inductive=True, inductive_epsilon=1e-3): + # policy --> n_levels_factor_f x 1 + # factor --> n_levels_factor_f x n_policies + ## vmap across policies + compute_G_fixed_states = partial(compute_G_policy_inductive, qs_init, A, B, C, A_dependencies, B_dependencies, I, + use_utility=use_utility, use_inductive=use_inductive, inductive_epsilon=inductive_epsilon) + + # only in the case of policy-dependent qs_inits + # in_axes_list = (1,) * n_factors + # all_efe_of_policies = vmap(compute_G_policy, in_axes=(in_axes_list, 0))(qs_init_pi, policy_matrix) + + # policies needs to be an NDarray of shape (n_policies, n_timepoints, n_control_factors) + neg_efe_all_policies = vmap(compute_G_fixed_states)(policy_matrix) + + return nn.softmax(gamma * neg_efe_all_policies), neg_efe_all_policies + +def generate_I_matrix(H: List[Array], B: List[Array], threshold: float, depth: int): + """ + Generates the `I` matrices used in inductive planning. These matrices stores the probability of reaching the goal state backwards from state j (columns) after i (rows) steps. + Parameters + ---------- + H: ``list`` of ``jax.numpy.ndarray`` + Constraints over desired states (1 if you want to reach that state, 0 otherwise) + B: ``list`` of ``jax.numpy.ndarray`` + Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. + Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability + of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. + threshold: ``float`` + The threshold for pruning transitions that are below a certain probability + depth: ``int`` + The temporal depth of the backward induction + + Returns + ---------- + I: ``numpy.ndarray`` of dtype object + For each state factor, contains a 2D ``numpy.ndarray`` whose element i,j yields the probability + of reaching the goal state backwards from state j after i steps. + """ + + num_factors = len(H) + I = [] + for f in range(num_factors): + """ + For each factor, we need to compute the probability of reaching the goal state + """ + + # If there exists an action that allows transitioning + # from state to next_state, with probability larger than threshold + # set b_reachable[current_state, previous_state] to 1 + b_reachable = jnp.where(B[f] > threshold, 1.0, 0.0).sum(axis=-1) + b_reachable = jnp.where(b_reachable > 0., 1.0, 0.0) + + def step_fn(carry, i): + I_prev = carry + I_next = jnp.dot(b_reachable, I_prev) + I_next = jnp.where(I_next > 0.1, 1.0, 0.0) # clamp I_next to 1.0 if it's above 0.1, 0 otherwise + return I_next, I_next + + _, I_f = lax.scan(step_fn, H[f], jnp.arange(depth-1)) + I_f = jnp.concatenate([H[f][None,...], I_f], axis=0) + + I.append(I_f) + + return I + +def calc_inductive_value_t(qs, qs_next, I, epsilon=1e-3): + """ + Computes the inductive value of a state at a particular time (translation of @tverbele's `numpy` implementation of inductive planning, formerly + called `calc_inductive_cost`). + + Parameters + ---------- + qs: ``list`` of ``jax.numpy.ndarray`` + Marginal posterior beliefs over hidden states at a given timepoint. + qs_next: ```list`` of ``jax.numpy.ndarray`` + Predictive posterior beliefs over hidden states expected under the policy. + I: ``numpy.ndarray`` of dtype object + For each state factor, contains a 2D ``numpy.ndarray`` whose element i,j yields the probability + of reaching the goal state backwards from state j after i steps. + + Returns + ------- + inductive_val: float + Value (negative inductive cost) of visiting this state using backwards induction under the policy in question + """ + + # initialise inductive value + inductive_val = 0. + + log_eps = log_stable(epsilon) + for f in range(len(qs)): + # we also assume precise beliefs here?! + idx = jnp.argmax(qs[f]) + # m = arg max_n p_n < sup p + + # i.e. find first entry at which I_idx equals 1, and then m is the index before that + m = jnp.maximum(jnp.argmax(I[f][:, idx])-1, 0) + I_m = (1.-I[f][m, :]) * log_eps + path_available = jnp.clip(I[f][:,idx].sum(0), a_min=0, a_max=1) # if there are any 1's at all in that column of I, then this == 1, otherwise 0 + inductive_val += path_available * I_m.dot(qs_next[f]) # scaling by path_available will nullify the addition of inductive value in the case we find no path to goal (i.e. when no goal specified) + + # The below is the straight translation from numpy, but unfortunately doesn't work due to non-statically sized arrays (AKA the call to jnp.where) + # # i.e. find first I idx equals 1 and m is the index before + # m = jnp.where(I[f][:, idx] == 1)[0] + # # we might find no path to goal (i.e. when no goal specified) + # if len(m) > 0: + # m = jnp.maximum(m[0]-1, 0) + # I_m = (1.-I[f][m, :]) * log_eps + # inductive_val += I_m.dot(qs_next[f]) + + return inductive_val # if __name__ == '__main__': From 2410dc37f26b6c23c7da06a406a8cdcbf085d45f Mon Sep 17 00:00:00 2001 From: Conor Heins Date: Wed, 10 Jan 2024 14:25:05 +0100 Subject: [PATCH 181/232] demo of inductive planning in simple 7 x 7 gridworld --- examples/inductive_inference_gridworld.ipynb | 176 +++++++++++++++++++ 1 file changed, 176 insertions(+) create mode 100644 examples/inductive_inference_gridworld.ipynb diff --git a/examples/inductive_inference_gridworld.ipynb b/examples/inductive_inference_gridworld.ipynb new file mode 100644 index 00000000..ed7cb3f8 --- /dev/null +++ b/examples/inductive_inference_gridworld.ipynb @@ -0,0 +1,176 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import jax.numpy as jnp\n", + "import jax.tree_util as jtu\n", + "from jax import nn, vmap, random, lax\n", + "from typing import List, Optional\n", + "from jaxtyping import Array\n", + "from jax import random as jr\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from pymdp.envs import GridWorldEnv\n", + "from pymdp.jax import control as j_control" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Grid world generative model" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "num_rows, num_columns = 7, 7\n", + "num_states = [num_rows*num_columns] # number of states equals the number of grid locations\n", + "num_obs = [num_rows*num_columns] # number of observations equals the number of grid locations (fully observable)\n", + "\n", + "# construct A arrays\n", + "A = [jnp.eye(num_states[0])]\n", + "A_dependencies = [[0]]\n", + "\n", + "# construct B arrays\n", + "grid_world = GridWorldEnv(shape=[num_rows, num_columns])\n", + "B = [jnp.array(grid_world.get_transition_dist())] # easy way to get the generative model parameters is to extract them from one of pre-made GridWorldEnv classes\n", + "B_dependencies = [[0]]\n", + "num_controls = [grid_world.n_control] # number of control states equals the number of actions\n", + " \n", + "# create mapping from gridworld coordinates to linearly-index states\n", + "grid = np.arange(grid_world.n_states).reshape(grid_world.shape)\n", + "it = np.nditer(grid, flags=[\"multi_index\"])\n", + "coord_to_idx_map = {}\n", + "while not it.finished:\n", + " coord_to_idx_map[it.multi_index] = it.iterindex\n", + " it.iternext()\n", + "\n", + "# construct C arrays\n", + "desired_position = (6,6) # lower corner\n", + "desired_state_id = coord_to_idx_map[desired_position]\n", + "desired_obs_id = jnp.argmax(A[0][:, desired_state_id]) # throw this in there, in case there is some indeterminism between states and observations\n", + "C = [nn.one_hot(desired_obs_id, num_obs[0])]\n", + "\n", + "# construct D arrays\n", + "starting_position = (3, 3) # middle\n", + "# starting_position = (0, 0) # upper left corner\n", + "starting_state_id = coord_to_idx_map[starting_position]\n", + "starting_obs_id = jnp.argmax(A[0][:, starting_state_id]) # throw this in there, in case there is some indeterminism between states and observations\n", + "D = [nn.one_hot(starting_state_id, num_states[0])]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Planning parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "planning_horizon, inductive_threshold = 1, 0.1\n", + "inductive_depth = 7\n", + "policy_matrix = j_control.construct_policies(num_states, num_controls, policy_len=planning_horizon)\n", + "\n", + "# inductive planning goal states\n", + "H = [nn.one_hot(desired_state_id, num_states[0])]\n", + "\n", + "# depth and threshold for inductive planning algorithm. I made policy-depth equal to inductive planning depth, out of ignorance -- need to ask Tim or Tommaso about this\n", + "I = j_control.generate_I_matrix(H, B, inductive_threshold, inductive_depth)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run active inference" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Grid position at time 0: (3, 3)\n", + "Grid position at time 1: (3, 4)\n", + "Grid position at time 2: (3, 5)\n", + "Grid position at time 3: (3, 6)\n", + "Grid position at time 4: (4, 6)\n", + "Grid position at time 5: (5, 6)\n", + "Grid position at time 6: (6, 6)\n" + ] + } + ], + "source": [ + "# T = 14 # needed if you start further away from the goal (e.g. in upper left corner)\n", + "T = 7 # can get away with fewer timesteps if you start closer to the goal (e.g. in the middle)\n", + "\n", + "qs_init = [nn.one_hot(starting_state_id, num_states[0])] # same as D\n", + "obs = nn.one_hot(starting_obs_id, num_obs[0])\n", + "state = starting_state_id\n", + "\n", + "for t in range(T):\n", + "\n", + " print('Grid position at time {}: {}'.format(t, np.unravel_index(state, grid_world.shape)))\n", + "\n", + " # update posterior beliefs over states\n", + " qs = [A[0][jnp.argmax(obs),:]] # trivial inference step\n", + "\n", + " # evaluate Q(pi) and negative EFE using the inductive planning algorithm\n", + " q_pi, neg_efe = j_control.update_posterior_policies_inductive(policy_matrix, qs, A, B, C, A_dependencies, B_dependencies, I, gamma=16.0, use_utility=True, use_inductive=True, inductive_epsilon=1e-3)\n", + "\n", + " # select action\n", + " action = jnp.argmax(q_pi)\n", + "\n", + " # use action to affect environment\n", + " state = jnp.argmax(B[0][:,state,action])\n", + " obs = nn.one_hot(jnp.argmax(A[0][:,state]), num_obs[0])\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "atari_env", + "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.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 7316942ff4735afaca5c521ab7e5f7ef9d6a8a44 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 11 Jan 2024 14:19:18 +0100 Subject: [PATCH 182/232] added back other components of EFE computation into update_posterior_policies_inductive --- pymdp/jax/control.py | 32 ++++++++++++-------------------- 1 file changed, 12 insertions(+), 20 deletions(-) diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index 230b185a..b5afe8e7 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -167,6 +167,7 @@ def compute_expected_state(qs_prior, B, u_t, B_dependencies=None): qs_next_f = factor_dot(B_f[...,u_f], relevant_factors, keep_dims=(0,)) qs_next.append(qs_next_f) + # P(s'|s, u) = \sum_{s, u} P(s'|s) P(s|u) P(u|pi)P(pi) because u pi return qs_next def compute_expected_state_and_Bs(qs_prior, B, u_t): @@ -338,10 +339,10 @@ def scan_body(carry, t): qs_final, neg_G = final_state return neg_G -def compute_G_policy_inductive(qs_init, A, B, C, A_dependencies, B_dependencies, I, policy_i, use_utility=True, use_inductive=True, inductive_epsilon=1e-3): +def compute_G_policy_inductive(qs_init, A, B, C, pA, pB, A_dependencies, B_dependencies, I, policy_i, inductive_epsilon=1e-3, use_utility=True, use_states_info_gain=True, use_param_info_gain=False, use_inductive=False): """ Write a version of compute_G_policy that does the same computations as `compute_G_policy` but using `lax.scan` instead of a for loop. - @NOTE: THis one further includes computations used for inductive planning, which only works in case of deterministic generative models so info gain is excluded (for now) + This one further adds computations used for inductive planning. """ def scan_body(carry, t): @@ -352,18 +353,16 @@ def scan_body(carry, t): qo = compute_expected_obs(qs_next, A, A_dependencies) - # info_gain = compute_info_gain(qs_next, qo, A, A_dependencies) if use_states_info_gain else 0. + info_gain = compute_info_gain(qs_next, qo, A, A_dependencies) if use_states_info_gain else 0. utility = compute_expected_utility(qo, C) if use_utility else 0. inductive_value = calc_inductive_value_t(qs_init, qs_next, I, epsilon=inductive_epsilon) if use_inductive else 0. - neg_G = utility + inductive_value - - # param_info_gain = calc_pA_info_gain(pA, qo, qs_next) if use_param_info_gain else 0. - # param_info_gain += calc_pB_info_gain(pB, qs_next, qs) if use_param_info_gain else 0. + param_info_gain = calc_pA_info_gain(pA, qo, qs_next) if use_param_info_gain else 0. + param_info_gain += calc_pB_info_gain(pB, qs_next, qs) if use_param_info_gain else 0. - # neg_G += info_gain + utility + param_info_gain + neg_G += info_gain + utility + param_info_gain + inductive_value return (qs_next, neg_G), None @@ -373,12 +372,12 @@ def scan_body(carry, t): qs_final, neg_G = final_state return neg_G -def update_posterior_policies_inductive(policy_matrix, qs_init, A, B, C, A_dependencies, B_dependencies, I, gamma=16.0, use_utility=True, use_inductive=True, inductive_epsilon=1e-3): +def update_posterior_policies_inductive(policy_matrix, qs_init, A, B, C, pA, pB, A_dependencies, B_dependencies, I, gamma=16.0, inductive_epsilon=1e-3, use_utility=True, use_states_info_gain=True, use_param_info_gain=False, use_inductive=True): # policy --> n_levels_factor_f x 1 # factor --> n_levels_factor_f x n_policies ## vmap across policies - compute_G_fixed_states = partial(compute_G_policy_inductive, qs_init, A, B, C, A_dependencies, B_dependencies, I, - use_utility=use_utility, use_inductive=use_inductive, inductive_epsilon=inductive_epsilon) + compute_G_fixed_states = partial(compute_G_policy_inductive, qs_init, A, B, C, pA, pB, A_dependencies, B_dependencies, I, inductive_epsilon=inductive_epsilon, + use_utility=use_utility, use_states_info_gain=use_states_info_gain, use_param_info_gain=use_param_info_gain, use_inductive=use_inductive) # only in the case of policy-dependent qs_inits # in_axes_list = (1,) * n_factors @@ -452,6 +451,8 @@ def calc_inductive_value_t(qs, qs_next, I, epsilon=1e-3): I: ``numpy.ndarray`` of dtype object For each state factor, contains a 2D ``numpy.ndarray`` whose element i,j yields the probability of reaching the goal state backwards from state j after i steps. + epsilon: ``float`` + Value that tunes the strength of the inductive value (how much it contributes to the expected free energy of policies) Returns ------- @@ -474,15 +475,6 @@ def calc_inductive_value_t(qs, qs_next, I, epsilon=1e-3): path_available = jnp.clip(I[f][:,idx].sum(0), a_min=0, a_max=1) # if there are any 1's at all in that column of I, then this == 1, otherwise 0 inductive_val += path_available * I_m.dot(qs_next[f]) # scaling by path_available will nullify the addition of inductive value in the case we find no path to goal (i.e. when no goal specified) - # The below is the straight translation from numpy, but unfortunately doesn't work due to non-statically sized arrays (AKA the call to jnp.where) - # # i.e. find first I idx equals 1 and m is the index before - # m = jnp.where(I[f][:, idx] == 1)[0] - # # we might find no path to goal (i.e. when no goal specified) - # if len(m) > 0: - # m = jnp.maximum(m[0]-1, 0) - # I_m = (1.-I[f][m, :]) * log_eps - # inductive_val += I_m.dot(qs_next[f]) - return inductive_val # if __name__ == '__main__': From 86d4cec906bd75467700cb4dabb3029844721e85 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 11 Jan 2024 14:19:34 +0100 Subject: [PATCH 183/232] inductive inference gridworld notebook now working with AIFAgent class instance --- examples/inductive_inference_gridworld.ipynb | 108 +++++++++++++------ 1 file changed, 74 insertions(+), 34 deletions(-) diff --git a/examples/inductive_inference_gridworld.ipynb b/examples/inductive_inference_gridworld.ipynb index ed7cb3f8..f8dcdbab 100644 --- a/examples/inductive_inference_gridworld.ipynb +++ b/examples/inductive_inference_gridworld.ipynb @@ -23,7 +23,8 @@ "import numpy as np\n", "\n", "from pymdp.envs import GridWorldEnv\n", - "from pymdp.jax import control as j_control" + "from pymdp.jax import control as j_control\n", + "from pymdp.jax.agent import Agent as AIFAgent\n" ] }, { @@ -43,14 +44,15 @@ "num_states = [num_rows*num_columns] # number of states equals the number of grid locations\n", "num_obs = [num_rows*num_columns] # number of observations equals the number of grid locations (fully observable)\n", "\n", + "# establish number of agents\n", + "n_batches = 1\n", + "\n", "# construct A arrays\n", - "A = [jnp.eye(num_states[0])]\n", - "A_dependencies = [[0]]\n", + "A = [jnp.broadcast_to(jnp.eye(num_states[0]), (n_batches,) + (num_obs[0], num_states[0]))] # fully observable (identity observation matrix\n", "\n", "# construct B arrays\n", "grid_world = GridWorldEnv(shape=[num_rows, num_columns])\n", - "B = [jnp.array(grid_world.get_transition_dist())] # easy way to get the generative model parameters is to extract them from one of pre-made GridWorldEnv classes\n", - "B_dependencies = [[0]]\n", + "B = [jnp.broadcast_to(jnp.array(grid_world.get_transition_dist()), (n_batches,) + (num_states[0], num_states[0], grid_world.n_control))] # easy way to get the generative model parameters is to extract them from one of pre-made GridWorldEnv classes\n", "num_controls = [grid_world.n_control] # number of control states equals the number of actions\n", " \n", "# create mapping from gridworld coordinates to linearly-index states\n", @@ -65,14 +67,14 @@ "desired_position = (6,6) # lower corner\n", "desired_state_id = coord_to_idx_map[desired_position]\n", "desired_obs_id = jnp.argmax(A[0][:, desired_state_id]) # throw this in there, in case there is some indeterminism between states and observations\n", - "C = [nn.one_hot(desired_obs_id, num_obs[0])]\n", + "C = [jnp.broadcast_to(nn.one_hot(desired_obs_id, num_obs[0]), (n_batches, num_obs[0]))]\n", "\n", "# construct D arrays\n", "starting_position = (3, 3) # middle\n", "# starting_position = (0, 0) # upper left corner\n", "starting_state_id = coord_to_idx_map[starting_position]\n", "starting_obs_id = jnp.argmax(A[0][:, starting_state_id]) # throw this in there, in case there is some indeterminism between states and observations\n", - "D = [nn.one_hot(starting_state_id, num_states[0])]" + "D = [jnp.broadcast_to(nn.one_hot(starting_state_id, num_states[0]), (n_batches, num_states[0]))]" ] }, { @@ -93,35 +95,64 @@ "policy_matrix = j_control.construct_policies(num_states, num_controls, policy_len=planning_horizon)\n", "\n", "# inductive planning goal states\n", - "H = [nn.one_hot(desired_state_id, num_states[0])]\n", + "H = [jnp.broadcast_to(nn.one_hot(desired_state_id, num_states[0]), (n_batches, num_states[0]))] # list of factor-specific goal vectors (shape of each is (n_batches, num_states[f]))\n", "\n", - "# depth and threshold for inductive planning algorithm. I made policy-depth equal to inductive planning depth, out of ignorance -- need to ask Tim or Tommaso about this\n", - "I = j_control.generate_I_matrix(H, B, inductive_threshold, inductive_depth)" + "# # depth and threshold for inductive planning algorithm. I made policy-depth equal to inductive planning depth, out of ignorance -- need to ask Tim or Tommaso about this\n", + "# I = j_control.generate_I_matrix(H, B, inductive_threshold, inductive_depth)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Run active inference" + "### Initialize an `Agent()`" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, + "outputs": [], + "source": [ + "def generate_all_Is(H, B, inductive_threshold, inductive_depth):\n", + " \"\"\"\n", + " Generate all I matrices for all planning depths up to inductive_depth\n", + " \"\"\"\n", + "\n", + " vmapped_generate_I = vmap(j_control.generate_I_matrix, in_axes=(0, 0, None, None))\n", + " return vmapped_generate_I(H, B, inductive_threshold, inductive_depth)\n", + "\n", + "I = generate_all_Is(H, B, inductive_threshold, inductive_depth)\n", + "\n", + "# create agent\n", + "agent = AIFAgent(A, B, C, D, E=None, pA=None, pB=None, policies=policy_matrix, policy_len=planning_horizon, \n", + " inductive_depth=inductive_depth, inductive_threshold=inductive_threshold,\n", + " H=H, I=I, use_utility=True, use_states_info_gain=False, use_param_info_gain=False, use_inductive=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run active inference" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Grid position at time 0: (3, 3)\n", - "Grid position at time 1: (3, 4)\n", - "Grid position at time 2: (3, 5)\n", - "Grid position at time 3: (3, 6)\n", - "Grid position at time 4: (4, 6)\n", - "Grid position at time 5: (5, 6)\n", - "Grid position at time 6: (6, 6)\n" + "Grid position for agent 1 at time 0: (3, 3)\n", + "Grid position for agent 1 at time 1: (3, 4)\n", + "Grid position for agent 1 at time 2: (3, 5)\n", + "Grid position for agent 1 at time 3: (3, 6)\n", + "Grid position for agent 1 at time 4: (4, 6)\n", + "Grid position for agent 1 at time 5: (5, 6)\n", + "Grid position for agent 1 at time 6: (6, 6)\n" ] } ], @@ -129,26 +160,35 @@ "# T = 14 # needed if you start further away from the goal (e.g. in upper left corner)\n", "T = 7 # can get away with fewer timesteps if you start closer to the goal (e.g. in the middle)\n", "\n", - "qs_init = [nn.one_hot(starting_state_id, num_states[0])] # same as D\n", - "obs = nn.one_hot(starting_obs_id, num_obs[0])\n", - "state = starting_state_id\n", + "qs_init = [jnp.broadcast_to(nn.one_hot(starting_state_id, num_states[0]), (n_batches, num_states[0]))] # same as D\n", + "# obs = [jnp.broadcast_to(nn.one_hot(starting_obs_id, num_obs[0]), (n_batches, num_obs[0]))]\n", + "obs_idx = [jnp.broadcast_to(starting_obs_id, (n_batches,))] # list of len (num_modalities), each list element of shape (n_batches,)\n", + "obs_idx = jtu.tree_map(lambda x: jnp.expand_dims(x, -1), obs_idx) # list of len (num_modalities), elements each of shape (n_batches,1), this adds a trivial \"time dimension\"\n", "\n", - "for t in range(T):\n", + "state = jnp.broadcast_to(starting_state_id, (n_batches,))\n", + "infer_args = (agent.D, None,)\n", + "batch_keys = jr.split(jr.PRNGKey(0), n_batches)\n", + "batch_to_track = 0\n", "\n", - " print('Grid position at time {}: {}'.format(t, np.unravel_index(state, grid_world.shape)))\n", - "\n", - " # update posterior beliefs over states\n", - " qs = [A[0][jnp.argmax(obs),:]] # trivial inference step\n", + "for t in range(T):\n", "\n", - " # evaluate Q(pi) and negative EFE using the inductive planning algorithm\n", - " q_pi, neg_efe = j_control.update_posterior_policies_inductive(policy_matrix, qs, A, B, C, A_dependencies, B_dependencies, I, gamma=16.0, use_utility=True, use_inductive=True, inductive_epsilon=1e-3)\n", + " print('Grid position for agent {} at time {}: {}'.format(batch_to_track+1, t, np.unravel_index(state[batch_to_track], grid_world.shape)))\n", "\n", - " # select action\n", - " action = jnp.argmax(q_pi)\n", + " if t == 0:\n", + " actions = None\n", + " else:\n", + " actions = actions_t\n", + " beliefs = agent.infer_states(obs_idx, actions, *infer_args)\n", + " q_pi, _ = agent.infer_policies(beliefs)\n", + " actions_t = agent.sample_action(q_pi, rng_key=batch_keys)\n", + " infer_args = agent.update_empirical_prior(actions_t, beliefs)\n", "\n", - " # use action to affect environment\n", - " state = jnp.argmax(B[0][:,state,action])\n", - " obs = nn.one_hot(jnp.argmax(A[0][:,state]), num_obs[0])\n" + " # get next state and observation from the grid world (need to vmap everything over batches)\n", + " state = vmap(lambda b, s, a: jnp.argmax(b[:, s, a]), in_axes=(0,0,0))(B[0], state, actions_t)\n", + " next_obs = vmap(lambda a, s: jnp.argmax(a[:, s]), in_axes=(0,0))(A[0], state)\n", + " obs_idx = [next_obs]\n", + " obs_idx = jtu.tree_map(lambda x: jnp.expand_dims(x, -1), obs_idx) # add a trivial time dimension to the observation to enable indexing during agent.infer_states\n", + "\n" ] } ], @@ -168,7 +208,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.5" + "version": "3.11.4" } }, "nbformat": 4, From fd7317e79ced296400318bb8305c69223aab552a Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 11 Jan 2024 14:20:07 +0100 Subject: [PATCH 184/232] added arguments relevant to inductive_inference into the Agent() constructor -- unfortunately we now pass in `I` because I couldn't get the initialization to work within __init__() --- pymdp/jax/agent.py | 62 +++++++++++++++++++++++++++++++++++++--------- 1 file changed, 50 insertions(+), 12 deletions(-) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index d4d58ede..3a3ac66a 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -46,6 +46,13 @@ class Agent(Module): qs: Optional[List[Array]] q_pi: Optional[List[Array]] + # parameters used for inductive inference + inductive_threshold: Array # threshold for inductive inference (the threshold for pruning transitions that are below a certain probability) + inductive_epsilon: Array # epsilon for inductive inference (trade-off/weight for how much inductive value contributes to EFE of policies) + + H: List[Array] # H vectors (one per hidden state factor) used for inductive inference -- these encode goal states or constraints + # I: List[Array] # I matrices (one per hidden state factor) used for inductive inference -- these encode the 'reachability' matrices of goal states encoded in `self.H` + pA: List[Array] pB: List[Array] @@ -60,12 +67,15 @@ class Agent(Module): num_factors: int = field(static=True) num_controls: List[int] = field(static=True) control_fac_idx: Optional[List[int]] = field(static=True) - policy_len: int = field(static=True) - policies: Array = field(static=True) - use_utility: bool = field(static=True) - use_states_info_gain: bool = field(static=True) - use_param_info_gain: bool = field(static=True) - action_selection: str = field(static=True) # determinstic or stochastic + policy_len: int = field(static=True) # depth of planning during roll-outs (i.e. number of timesteps to look ahead when computing expected free energy of policies) + inductive_depth: int = field(static=True) # depth of inductive inference (i.e. number of future timesteps to use when computing inductive `I` matrix) + policies: Array = field(static=True) # matrix of all possible policies (each row is a policy of shape (num_controls[0], num_controls[1], ..., num_controls[num_control_factors-1]) + I: Array = field(static=False) # I matrices (one per hidden state factor) used for inductive inference -- these encode the 'reachability' matrices of goal states encoded in `self.H` + use_utility: bool = field(static=True) # flag for whether to use expected utility ("reward" or "preference satisfaction") when computing expected free energy + use_states_info_gain: bool = field(static=True) # flag for whether to use state information gain ("salience") when computing expected free energy + use_param_info_gain: bool = field(static=True) # flag for whether to use parameter information gain ("novelty") when computing expected free energy + use_inductive: bool = field(static=True) # flag for whether to use inductive inference ("intentional inference") when computing expected free energy + action_selection: str = field(static=True) # determinstic or stochastic action selection sampling_mode : str = field(static=True) # whether to sample from full posterior over policies ("full") or from marginal posterior over actions ("marginal") inference_algo: str = field(static=True) # fpi, vmp, mmp, ovf @@ -88,14 +98,20 @@ def __init__( B_dependencies=None, qs=None, q_pi=None, + H=None, policy_len=1, control_fac_idx=None, policies=None, + I=None, gamma=16.0, alpha=16.0, + inductive_depth=1, + inductive_threshold=0.1, + inductive_epsilon=1e-3, use_utility=True, use_states_info_gain=True, use_param_info_gain=False, + use_inductive=False, action_selection="deterministic", sampling_mode="marginal", inference_algo="fpi", @@ -107,7 +123,6 @@ def __init__( learn_E=False ): ### PyTree leaves - self.A = A self.B = B self.C = C @@ -157,12 +172,13 @@ def __init__( self.gamma = jnp.broadcast_to(gamma, (self.batch_size,)) self.alpha = jnp.broadcast_to(alpha, (self.batch_size,)) + self.inductive_threshold = jnp.broadcast_to(inductive_threshold, (self.batch_size,)) + self.inductive_epsilon = jnp.broadcast_to(inductive_epsilon, (self.batch_size,)) ### Static parameters ### - self.num_iter = num_iter - self.inference_algo = inference_algo + self.inductive_depth = inductive_depth # policy parameters self.policy_len = policy_len @@ -171,6 +187,17 @@ def __init__( self.use_utility = use_utility self.use_states_info_gain = use_states_info_gain self.use_param_info_gain = use_param_info_gain + self.use_inductive = use_inductive + + self.H = H + if I is not None: + self.I = I + else: + if self.use_inductive and self.H is not None: + print("Using inductive inference...") + self._construct_I() + else: + self.I = jtu.tree_map(lambda x: jnp.zeros_like(x), self.D) # learning parameters self.learn_A = learn_A @@ -211,6 +238,10 @@ def _construct_policies(self): self.num_states, self.num_controls, self.policy_len, self.control_fac_idx ) + @vmap + def _construct_I(self): + self.I = control.generate_I_matrix(self.H, self.B, self.inductive_threshold, self.inductive_depth) + @property def unique_multiactions(self): size = pymath.prod(self.num_controls) @@ -229,6 +260,10 @@ def learning(self, beliefs, outcomes, actions, **kwargs): actions_onehot = jtu.tree_map(lambda a, dim: nn.one_hot(a, dim, axis=-1), actions_seq, self.num_controls) qB = learning.update_state_likelihood_dirichlet(self.pB, self.B, beliefs, actions_onehot, self.B_dependencies) E_qB = jtu.tree_map(lambda x: maths.dirichlet_expected_value(x), qB) + + # if you have updated your beliefs about transitions, you need to re-compute the I matrix used for inductive inferenece + if self.use_inductive and self.H is not None: + I_updated = control.generate_I_matrix(self.H, E_qB, self.inductive_threshold, self.inductive_depth) # if self.learn_C: # self.qC = learning.update_C(self.C, *args, **kwargs) # self.C = jtu.tree_map(lambda x: maths.dirichlet_expected_value(x), self.qC) @@ -244,7 +279,7 @@ def learning(self, beliefs, outcomes, actions, **kwargs): # parameters = ... # varibles = {'A': jnp.ones(5)} - agent = tree_at(lambda x: (x.A, x.pA, x.B, x.pB), self, (E_qA, qA, E_qB, qB)) + agent = tree_at(lambda x: (x.A, x.pA, x.B, x.pB, x.I), self, (E_qA, qA, E_qB, qB, I_updated)) return agent @@ -314,7 +349,7 @@ def infer_policies(self, qs: List): """ latest_belief = jtu.tree_map(lambda x: x[-1], qs) # only get the posterior belief held at the current timepoint - q_pi, G = control.update_posterior_policies( + q_pi, G = control.update_posterior_policies_inductive( self.policies, latest_belief, self.A, @@ -324,10 +359,13 @@ def infer_policies(self, qs: List): self.pB, A_dependencies=self.A_dependencies, B_dependencies=self.B_dependencies, + I = self.I, gamma=self.gamma, + inductive_epsilon=self.inductive_epsilon, use_utility=self.use_utility, use_states_info_gain=self.use_states_info_gain, - use_param_info_gain=self.use_param_info_gain + use_param_info_gain=self.use_param_info_gain, + use_inductive=self.use_inductive ) return q_pi, G From de56a7c720b0bdc5f7d692cc3de297cec65b19c3 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 11 Jan 2024 15:44:36 +0100 Subject: [PATCH 185/232] fixed initialization of `I` matrix in constructor for `Agent()`, now we don't need to pass it in as an input to constructor, it is created automatically from `H` --- examples/inductive_inference_gridworld.ipynb | 42 ++++---------------- pymdp/jax/agent.py | 21 ++++------ 2 files changed, 15 insertions(+), 48 deletions(-) diff --git a/examples/inductive_inference_gridworld.ipynb b/examples/inductive_inference_gridworld.ipynb index f8dcdbab..60a606aa 100644 --- a/examples/inductive_inference_gridworld.ipynb +++ b/examples/inductive_inference_gridworld.ipynb @@ -36,7 +36,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -86,7 +86,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -95,10 +95,7 @@ "policy_matrix = j_control.construct_policies(num_states, num_controls, policy_len=planning_horizon)\n", "\n", "# inductive planning goal states\n", - "H = [jnp.broadcast_to(nn.one_hot(desired_state_id, num_states[0]), (n_batches, num_states[0]))] # list of factor-specific goal vectors (shape of each is (n_batches, num_states[f]))\n", - "\n", - "# # depth and threshold for inductive planning algorithm. I made policy-depth equal to inductive planning depth, out of ignorance -- need to ask Tim or Tommaso about this\n", - "# I = j_control.generate_I_matrix(H, B, inductive_threshold, inductive_depth)" + "H = [jnp.broadcast_to(nn.one_hot(desired_state_id, num_states[0]), (n_batches, num_states[0]))] # list of factor-specific goal vectors (shape of each is (n_batches, num_states[f]))" ] }, { @@ -110,24 +107,14 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "def generate_all_Is(H, B, inductive_threshold, inductive_depth):\n", - " \"\"\"\n", - " Generate all I matrices for all planning depths up to inductive_depth\n", - " \"\"\"\n", - "\n", - " vmapped_generate_I = vmap(j_control.generate_I_matrix, in_axes=(0, 0, None, None))\n", - " return vmapped_generate_I(H, B, inductive_threshold, inductive_depth)\n", - "\n", - "I = generate_all_Is(H, B, inductive_threshold, inductive_depth)\n", - "\n", "# create agent\n", "agent = AIFAgent(A, B, C, D, E=None, pA=None, pB=None, policies=policy_matrix, policy_len=planning_horizon, \n", " inductive_depth=inductive_depth, inductive_threshold=inductive_threshold,\n", - " H=H, I=I, use_utility=True, use_states_info_gain=False, use_param_info_gain=False, use_inductive=True)" + " H=H, use_utility=True, use_states_info_gain=False, use_param_info_gain=False, use_inductive=True)" ] }, { @@ -139,29 +126,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Grid position for agent 1 at time 0: (3, 3)\n", - "Grid position for agent 1 at time 1: (3, 4)\n", - "Grid position for agent 1 at time 2: (3, 5)\n", - "Grid position for agent 1 at time 3: (3, 6)\n", - "Grid position for agent 1 at time 4: (4, 6)\n", - "Grid position for agent 1 at time 5: (5, 6)\n", - "Grid position for agent 1 at time 6: (6, 6)\n" - ] - } - ], + "outputs": [], "source": [ "# T = 14 # needed if you start further away from the goal (e.g. in upper left corner)\n", "T = 7 # can get away with fewer timesteps if you start closer to the goal (e.g. in the middle)\n", "\n", "qs_init = [jnp.broadcast_to(nn.one_hot(starting_state_id, num_states[0]), (n_batches, num_states[0]))] # same as D\n", - "# obs = [jnp.broadcast_to(nn.one_hot(starting_obs_id, num_obs[0]), (n_batches, num_obs[0]))]\n", "obs_idx = [jnp.broadcast_to(starting_obs_id, (n_batches,))] # list of len (num_modalities), each list element of shape (n_batches,)\n", "obs_idx = jtu.tree_map(lambda x: jnp.expand_dims(x, -1), obs_idx) # list of len (num_modalities), elements each of shape (n_batches,1), this adds a trivial \"time dimension\"\n", "\n", diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 3a3ac66a..2937951e 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -51,7 +51,7 @@ class Agent(Module): inductive_epsilon: Array # epsilon for inductive inference (trade-off/weight for how much inductive value contributes to EFE of policies) H: List[Array] # H vectors (one per hidden state factor) used for inductive inference -- these encode goal states or constraints - # I: List[Array] # I matrices (one per hidden state factor) used for inductive inference -- these encode the 'reachability' matrices of goal states encoded in `self.H` + I: List[Array] # I matrices (one per hidden state factor) used for inductive inference -- these encode the 'reachability' matrices of goal states encoded in `self.H` pA: List[Array] pB: List[Array] @@ -70,7 +70,6 @@ class Agent(Module): policy_len: int = field(static=True) # depth of planning during roll-outs (i.e. number of timesteps to look ahead when computing expected free energy of policies) inductive_depth: int = field(static=True) # depth of inductive inference (i.e. number of future timesteps to use when computing inductive `I` matrix) policies: Array = field(static=True) # matrix of all possible policies (each row is a policy of shape (num_controls[0], num_controls[1], ..., num_controls[num_control_factors-1]) - I: Array = field(static=False) # I matrices (one per hidden state factor) used for inductive inference -- these encode the 'reachability' matrices of goal states encoded in `self.H` use_utility: bool = field(static=True) # flag for whether to use expected utility ("reward" or "preference satisfaction") when computing expected free energy use_states_info_gain: bool = field(static=True) # flag for whether to use state information gain ("salience") when computing expected free energy use_param_info_gain: bool = field(static=True) # flag for whether to use parameter information gain ("novelty") when computing expected free energy @@ -102,7 +101,6 @@ def __init__( policy_len=1, control_fac_idx=None, policies=None, - I=None, gamma=16.0, alpha=16.0, inductive_depth=1, @@ -129,6 +127,7 @@ def __init__( self.D = D # self.empirical_prior = D self.E = E + self.H = H self.pA = pA self.pB = pB self.qs = qs @@ -188,16 +187,12 @@ def __init__( self.use_states_info_gain = use_states_info_gain self.use_param_info_gain = use_param_info_gain self.use_inductive = use_inductive - - self.H = H - if I is not None: - self.I = I + + if self.use_inductive and self.H is not None: + print("Using inductive inference...") + self.I = self._construct_I() else: - if self.use_inductive and self.H is not None: - print("Using inductive inference...") - self._construct_I() - else: - self.I = jtu.tree_map(lambda x: jnp.zeros_like(x), self.D) + self.I = jtu.tree_map(lambda x: jnp.expand_dims(jnp.zeros_like(x), 1), self.D) # learning parameters self.learn_A = learn_A @@ -240,7 +235,7 @@ def _construct_policies(self): @vmap def _construct_I(self): - self.I = control.generate_I_matrix(self.H, self.B, self.inductive_threshold, self.inductive_depth) + return control.generate_I_matrix(self.H, self.B, self.inductive_threshold, self.inductive_depth) @property def unique_multiactions(self): From 7fe2c9add18b1b55da34b6181a95ab8aed68ef07 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 11 Jan 2024 15:48:42 +0100 Subject: [PATCH 186/232] inductive planning demo with `n_batches > 1` --- examples/inductive_inference_gridworld.ipynb | 49 ++++++++++++++++---- 1 file changed, 39 insertions(+), 10 deletions(-) diff --git a/examples/inductive_inference_gridworld.ipynb b/examples/inductive_inference_gridworld.ipynb index 60a606aa..cc20002f 100644 --- a/examples/inductive_inference_gridworld.ipynb +++ b/examples/inductive_inference_gridworld.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -36,7 +36,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -44,8 +44,8 @@ "num_states = [num_rows*num_columns] # number of states equals the number of grid locations\n", "num_obs = [num_rows*num_columns] # number of observations equals the number of grid locations (fully observable)\n", "\n", - "# establish number of agents\n", - "n_batches = 1\n", + "# number of agents\n", + "n_batches = 5\n", "\n", "# construct A arrays\n", "A = [jnp.broadcast_to(jnp.eye(num_states[0]), (n_batches,) + (num_obs[0], num_states[0]))] # fully observable (identity observation matrix\n", @@ -86,7 +86,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -107,9 +107,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using inductive inference...\n" + ] + } + ], "source": [ "# create agent\n", "agent = AIFAgent(A, B, C, D, E=None, pA=None, pB=None, policies=policy_matrix, policy_len=planning_horizon, \n", @@ -126,9 +134,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Grid position for agent 2 at time 0: (3, 3)\n", + "Grid position for agent 2 at time 1: (3, 4)\n", + "Grid position for agent 2 at time 2: (3, 5)\n", + "Grid position for agent 2 at time 3: (3, 6)\n", + "Grid position for agent 2 at time 4: (4, 6)\n", + "Grid position for agent 2 at time 5: (5, 6)\n", + "Grid position for agent 2 at time 6: (6, 6)\n" + ] + } + ], "source": [ "# T = 14 # needed if you start further away from the goal (e.g. in upper left corner)\n", "T = 7 # can get away with fewer timesteps if you start closer to the goal (e.g. in the middle)\n", @@ -140,7 +162,7 @@ "state = jnp.broadcast_to(starting_state_id, (n_batches,))\n", "infer_args = (agent.D, None,)\n", "batch_keys = jr.split(jr.PRNGKey(0), n_batches)\n", - "batch_to_track = 0\n", + "batch_to_track = 1\n", "\n", "for t in range(T):\n", "\n", @@ -162,6 +184,13 @@ " obs_idx = jtu.tree_map(lambda x: jnp.expand_dims(x, -1), obs_idx) # add a trivial time dimension to the observation to enable indexing during agent.infer_states\n", "\n" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From aca84a4339a92507c5a0b1aabefb049d93dcf856 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 11 Jan 2024 21:53:04 +0100 Subject: [PATCH 187/232] added in policy prior `E` into computation of `q_pi` posterior over policies --- examples/inductive_inference_gridworld.ipynb | 17 +++++------------ pymdp/jax/agent.py | 8 +++++++- pymdp/jax/control.py | 8 ++++---- 3 files changed, 16 insertions(+), 17 deletions(-) diff --git a/examples/inductive_inference_gridworld.ipynb b/examples/inductive_inference_gridworld.ipynb index cc20002f..011922c8 100644 --- a/examples/inductive_inference_gridworld.ipynb +++ b/examples/inductive_inference_gridworld.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -36,7 +36,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -86,7 +86,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -107,7 +107,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -134,7 +134,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -184,13 +184,6 @@ " obs_idx = jtu.tree_map(lambda x: jnp.expand_dims(x, -1), obs_idx) # add a trivial time dimension to the observation to enable indexing during agent.infer_states\n", "\n" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 2937951e..bce0b680 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -126,7 +126,6 @@ def __init__( self.C = C self.D = D # self.empirical_prior = D - self.E = E self.H = H self.pA = pA self.pB = pB @@ -226,6 +225,12 @@ def __init__( self.policies = policies else: self._construct_policies() + + # set E to uniform/uninformative prior over policies if not given + if E is None: + self.E = jnp.ones((self.batch_size, len(self.policies)))/ len(self.policies) + else: + self.E = E def _construct_policies(self): @@ -350,6 +355,7 @@ def infer_policies(self, qs: List): self.A, self.B, self.C, + self.E, self.pA, self.pB, A_dependencies=self.A_dependencies, diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index b5afe8e7..4a05f9ed 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -138,7 +138,7 @@ def construct_policies(num_states, num_controls = None, policy_len=1, control_fa return jnp.stack(policies) -def update_posterior_policies(policy_matrix, qs_init, A, B, C, pA, pB, A_dependencies, B_dependencies, gamma=16.0, use_utility=True, use_states_info_gain=True, use_param_info_gain=False): +def update_posterior_policies(policy_matrix, qs_init, A, B, C, E, pA, pB, A_dependencies, B_dependencies, gamma=16.0, use_utility=True, use_states_info_gain=True, use_param_info_gain=False): # policy --> n_levels_factor_f x 1 # factor --> n_levels_factor_f x n_policies ## vmap across policies @@ -152,7 +152,7 @@ def update_posterior_policies(policy_matrix, qs_init, A, B, C, pA, pB, A_depende # policies needs to be an NDarray of shape (n_policies, n_timepoints, n_control_factors) neg_efe_all_policies = vmap(compute_G_fixed_states)(policy_matrix) - return nn.softmax(gamma * neg_efe_all_policies), neg_efe_all_policies + return nn.softmax(gamma * neg_efe_all_policies + log_stable(E)), neg_efe_all_policies def compute_expected_state(qs_prior, B, u_t, B_dependencies=None): """ @@ -372,7 +372,7 @@ def scan_body(carry, t): qs_final, neg_G = final_state return neg_G -def update_posterior_policies_inductive(policy_matrix, qs_init, A, B, C, pA, pB, A_dependencies, B_dependencies, I, gamma=16.0, inductive_epsilon=1e-3, use_utility=True, use_states_info_gain=True, use_param_info_gain=False, use_inductive=True): +def update_posterior_policies_inductive(policy_matrix, qs_init, A, B, C, E, pA, pB, A_dependencies, B_dependencies, I, gamma=16.0, inductive_epsilon=1e-3, use_utility=True, use_states_info_gain=True, use_param_info_gain=False, use_inductive=True): # policy --> n_levels_factor_f x 1 # factor --> n_levels_factor_f x n_policies ## vmap across policies @@ -386,7 +386,7 @@ def update_posterior_policies_inductive(policy_matrix, qs_init, A, B, C, pA, pB, # policies needs to be an NDarray of shape (n_policies, n_timepoints, n_control_factors) neg_efe_all_policies = vmap(compute_G_fixed_states)(policy_matrix) - return nn.softmax(gamma * neg_efe_all_policies), neg_efe_all_policies + return nn.softmax(gamma * neg_efe_all_policies + log_stable(E)), neg_efe_all_policies def generate_I_matrix(H: List[Array], B: List[Array], threshold: float, depth: int): """ From 2fc1c6943bc048706e7b3ffc5141830686ecdfa7 Mon Sep 17 00:00:00 2001 From: Tim Verbelen Date: Tue, 21 Nov 2023 08:16:41 +0100 Subject: [PATCH 188/232] add sophisticated policy search method --- pymdp/control.py | 137 ++++++++++++++++++++++++++++++++++++++++++++++- pymdp/maths.py | 34 ++++++++++++ 2 files changed, 170 insertions(+), 1 deletion(-) diff --git a/pymdp/control.py b/pymdp/control.py index 892c02f3..d3fbc463 100644 --- a/pymdp/control.py +++ b/pymdp/control.py @@ -5,7 +5,7 @@ import itertools import numpy as np -from pymdp.maths import softmax, softmax_obj_arr, spm_dot, spm_wnorm, spm_MDP_G, spm_log_single, spm_log_obj_array +from pymdp.maths import softmax, softmax_obj_arr, spm_dot, spm_wnorm, spm_MDP_G, spm_log_single, kl_div, entropy from pymdp import utils import copy @@ -1310,5 +1310,140 @@ def backwards_induction(H, B, B_factor_list, threshold, depth): I[factor][i, :] = np.where(I[factor][i, :] > 0.1, 1.0, 0.0) return I + +def calc_ambiguity_factorized(qs_pi, A, A_factor_list): + """ + Computes the Ambiguity term. + + Parameters + ---------- + qs_pi: ``list`` of ``numpy.ndarray`` of dtype object + Predictive posterior beliefs over hidden states expected under the policy, where ``qs_pi[t]`` stores the beliefs about + hidden states expected under the policy at time ``t`` + A: ``numpy.ndarray`` of dtype object + Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of + stores an ``numpy.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store + the probability of observation level ``i`` given hidden state levels ``j, k, ...`` + A_factor_list: ``list`` of ``list`` of ``int`` + List of lists, where ``A_factor_list[m]`` is a list of the hidden state factor indices that observation modality with the index ``m`` depends on + + Returns + ------- + ambiguity: float + """ + + n_steps = len(qs_pi) + + ambiguity = 0 + # TODO check if we do this correctly! + H = entropy(A) + for t in range(n_steps): + for m, H_m in enumerate(H): + factor_idx = A_factor_list[m] + # TODO why does spm_dot return an array here? + # joint_x = maths.spm_cross(qs_pi[t][factor_idx]) + # ambiguity += (H_m * joint_x).sum() + ambiguity += np.sum(spm_dot(H_m, qs_pi[t][factor_idx])) + + return ambiguity +def sophisticated_inference_search(qs, policies, A, B, C, A_factor_list, B_factor_list, I=None, horizon=1, + policy_prune_threshold=1/16, state_prune_threshold=1/16, prune_penalty=512, gamma=16, n=0): + """ + Performs sophisticated inference to find the optimal policy for a given generative model and prior preferences. + Parameters + ---------- + qs: ``numpy.ndarray`` of dtype object + Marginal posterior beliefs over hidden states at a given timepoint. + policies: ``list`` of 1D ``numpy.ndarray`` + ``list`` that stores each policy as a 1D array in ``policies[p_idx]``. Shape of ``policies[p_idx]`` + is ``(num_factors)`` where ``num_factors`` is the number of control factors. + A: ``numpy.ndarray`` of dtype object + Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of + stores an ``numpy.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store + the probability of observation level ``i`` given hidden state levels ``j, k, ...`` + B: ``numpy.ndarray`` of dtype object + Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. + Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability + of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. + C: ``numpy.ndarray`` of dtype object + Prior over observations or 'prior preferences', storing the "value" of each outcome in terms of relative log probabilities. + This is softmaxed to form a proper probability distribution before being used to compute the expected utility term of the expected free energy. + A_factor_list: ``list`` of ``list`` of ``int`` + List of lists, where ``A_factor_list[m]`` is a list of the hidden state factor indices that observation modality with the index ``m`` depends on + B_factor_list: ``list`` of ``list`` of ``int`` + List of lists of hidden state factors each hidden state factor depends on. Each element ``B_factor_list[i]`` is a list of the factor indices that factor i's dynamics depend on. + I: ``numpy.ndarray`` of dtype object + For each state factor, contains a 2D ``numpy.ndarray`` whose element i,j yields the probability + of reaching the goal state backwards from state j after i steps. + horizon: ``int`` + The temporal depth of the policy + policy_prune_threshold: ``float`` + The threshold for pruning policies that are below a certain probability + state_prune_threshold: ``float`` + The threshold for pruning states in the expectation that are below a certain probability + prune_penalty: ``float`` + Penalty to add to the EFE when a policy is pruned + gamma: ``float``, default 16.0 + Prior precision over policies, scales the contribution of the expected free energy to the posterior over policies + n: ``int`` + timestep in the future we are calculating + + Returns + ---------- + q_pi: 1D ``numpy.ndarray`` + Posterior beliefs over policies, i.e. a vector containing one posterior probability per policy. + + G: 1D ``numpy.ndarray`` + Negative expected free energies of each policy, i.e. a vector containing one negative expected free energy per policy. + """ + + n_policies = len(policies) + G = np.zeros(n_policies) + q_pi = np.zeros((n_policies, 1)) + qs_pi = utils.obj_array(n_policies) + + for idx, policy in enumerate(policies): + qs_pi[idx] = get_expected_states_interactions(qs, B, B_factor_list, policy) + qo_pi = get_expected_obs_factorized(qs_pi[idx], A, A_factor_list) + + C_prob = softmax_obj_arr(C) + G[idx] += -kl_div(qo_pi[0], C_prob) + G[idx] += -calc_ambiguity_factorized(qs_pi[idx], A, A_factor_list) + if I is not None: + G[idx] += calc_inductive_cost(qs, qs_pi[idx], I) + + q_pi = softmax(G * gamma) + + if n < horizon - 1: + # ignore low probability actions in the search tree + # TODO shouldnt we have to add extra penalty for branches no longer considered? + # or assume these are already low EFE (high NEFE) anyway? + policies_to_consider = list(np.where(q_pi >= policy_prune_threshold)[0]) + for idx in range(n_policies): + if idx not in policies_to_consider: + G[idx] -= prune_penalty + else : + # average over states + qs_next = qs_pi[idx][0] + for k in itertools.product(*[range(s.shape[0]) for s in qs_next]): + prob = 1.0 + for i in range(len(k)): + prob *= qs_pi[idx][0][i][k[i]] + + # ignore low probability states in the search tree + if prob < state_prune_threshold: + continue + + qs_one_hot = utils.obj_array(len(qs)) + for i in range(len(qs)): + qs_one_hot[i] = utils.onehot(k[i], qs_next[i].shape[0]) + + q_pi_next, G_next = sophisticated_inference_search(qs_one_hot, policies, A, B, C, A_factor_list, B_factor_list, I, + horizon, policy_prune_threshold, state_prune_threshold, n=n+1) + G_weighted = np.dot(q_pi_next, G_next) * prob + G[idx] += G_weighted + + q_pi = softmax(G * gamma) + return q_pi, G \ No newline at end of file diff --git a/pymdp/maths.py b/pymdp/maths.py index 6f2fd3b8..7b2eacdb 100644 --- a/pymdp/maths.py +++ b/pymdp/maths.py @@ -552,3 +552,37 @@ def spm_MDP_G(A, x): return G +def kl_div(P,Q): + """ + Parameters + ---------- + P : Categorical probability distribution + Q : Categorical probability distribution + + Returns + ------- + The KL-divergence of P and Q + + """ + dkl = 0 + for i in range(len(P)): + dkl += np.dot(P[i], np.log(P[i] + EPS_VAL) - np.log(Q[i] + EPS_VAL)) + return(dkl) + +def entropy(A): + """ + Compute the entropy term H of the likelihood matrix, + i.e. one entropy value per column + """ + entropies = np.empty(len(A), dtype=object) + for i in range(len(A)): + if len(A[i].shape) > 2: + obs_dim = A[i].shape[0] + s_dim = A[i].size // obs_dim + A_merged = A[i].reshape(obs_dim, s_dim) + else: + A_merged = A[i] + + H = - np.diag(np.matmul(A_merged.T, np.log(A_merged + EPS_VAL))) + entropies[i] = H.reshape(*A[i].shape[1:]) + return entropies \ No newline at end of file From 6672861bb343d3476542edc1526766a81106efcd Mon Sep 17 00:00:00 2001 From: Tim Verbelen Date: Tue, 21 Nov 2023 08:17:06 +0100 Subject: [PATCH 189/232] fix is None check --- pymdp/agent.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pymdp/agent.py b/pymdp/agent.py index 75bafc46..ce5f9dad 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -186,7 +186,7 @@ def __init__( # Again, the use can specify a set of possible policies, or # all possible combinations of actions and timesteps will be considered - if policies == None: + if policies is None: policies = self._construct_policies() self.policies = policies From 417482b1004f47d9a9fb43eedd3684e11d16a9cc Mon Sep 17 00:00:00 2001 From: Tim Verbelen Date: Tue, 21 Nov 2023 08:21:35 +0100 Subject: [PATCH 190/232] only keep infer_policies function in Agent, which calls factorized if implemented --- pymdp/agent.py | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/pymdp/agent.py b/pymdp/agent.py index ce5f9dad..e8c5687c 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -129,6 +129,7 @@ def __init__( self.num_controls = num_controls # checking that `A_factor_list` and `B_factor_list` are consistent with `num_factors`, `num_states`, and lagging dimensions of `A` and `B` tensors + self.factorized = False if A_factor_list == None: self.A_factor_list = self.num_modalities * [list(range(self.num_factors))] # defaults to having all modalities depend on all factors for m in range(self.num_modalities): @@ -137,6 +138,7 @@ def __init__( if self.pA != None: assert self.pA[m].shape[1:] == factor_dims, f"Please input an `A_factor_list` whose {m}-th indices pick out the hidden state factors that line up with lagging dimensions of pA{m}..." else: + self.factorized = True for m in range(self.num_modalities): assert max(A_factor_list[m]) <= (self.num_factors - 1), f"Check modality {m} of A_factor_list - must be consistent with `num_states` and `num_factors`..." factor_dims = tuple([self.num_states[f] for f in A_factor_list[m]]) @@ -164,6 +166,7 @@ def __init__( if self.pB != None: assert self.pB[f].shape[1:-1] == factor_dims, f"Please input a `B_factor_list` whose {f}-th indices pick out the hidden state factors that line up with the all-but-final lagging dimensions of pB{f}..." else: + self.factorized = True for f in range(self.num_factors): assert max(B_factor_list[f]) <= (self.num_factors - 1), f"Check factor {f} of B_factor_list - must be consistent with `num_states` and `num_factors`..." factor_dims = tuple([self.num_states[f] for f in B_factor_list[f]]) @@ -600,22 +603,26 @@ def infer_policies_old(self): """ if self.inference_algo == "VANILLA": - q_pi, G = control.update_posterior_policies( + q_pi, G = control.update_posterior_policies_factorized( self.qs, self.A, self.B, self.C, + self.A_factor_list, + self.B_factor_list, self.policies, self.use_utility, self.use_states_info_gain, self.use_param_info_gain, self.pA, self.pB, - E=self.E, - I=self.I, - gamma=self.gamma + E = self.E, + I = self.I, + gamma = self.gamma ) elif self.inference_algo == "MMP": + if self.factorized: + raise NotImplementedError("Factorized inference not implemented for MMP") future_qs_seq = self.get_future_qs() From a4546f3c75e10150a2cffb56d47b9e836eeaa733 Mon Sep 17 00:00:00 2001 From: Tim Verbelen Date: Tue, 21 Nov 2023 08:32:13 +0100 Subject: [PATCH 191/232] add sophisticated inference as a flag for pymdp Agent --- pymdp/agent.py | 84 +++++++++++++++++++++++++++++++++++--------------- 1 file changed, 59 insertions(+), 25 deletions(-) diff --git a/pymdp/agent.py b/pymdp/agent.py index e8c5687c..b9cb70c6 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -60,11 +60,16 @@ def __init__( factors_to_learn="all", lr_pB=1.0, lr_pD=1.0, - use_BMA = True, + use_BMA=True, policy_sep_prior=False, save_belief_hist=False, A_factor_list=None, - B_factor_list=None + B_factor_list=None, + sophisticated=False, + si_horizon=3, + si_policy_prune_threshold=1/16, + si_state_prune_threshold=1/16, + si_prune_penalty=512 ): ### Constant parameters ### @@ -86,6 +91,15 @@ def __init__( self.lr_pB = lr_pB self.lr_pD = lr_pD + # sophisticated inference parameters + self.sophisticated = sophisticated + if self.sophisticated: + assert self.policy_len == 1, "Sophisticated inference only works with policy_len = 1" + self.si_horizon = si_horizon + self.si_policy_prune_threshold = si_policy_prune_threshold + self.si_state_prune_threshold = si_state_prune_threshold + self.si_prune_penalty = si_prune_penalty + # Initialise observation model (A matrices) if not isinstance(A, np.ndarray): raise TypeError( @@ -603,26 +617,28 @@ def infer_policies_old(self): """ if self.inference_algo == "VANILLA": - q_pi, G = control.update_posterior_policies_factorized( + q_pi, G = control.update_posterior_policies( self.qs, self.A, self.B, self.C, - self.A_factor_list, - self.B_factor_list, self.policies, self.use_utility, self.use_states_info_gain, self.use_param_info_gain, self.pA, self.pB, - E = self.E, - I = self.I, - gamma = self.gamma + E=self.E, + I=self.I, + gamma=self.gamma ) elif self.inference_algo == "MMP": if self.factorized: raise NotImplementedError("Factorized inference not implemented for MMP") + + if self.sophisticated: + raise NotImplementedError("Sophisticated inference not implemented for MMP") + future_qs_seq = self.get_future_qs() @@ -671,23 +687,41 @@ def infer_policies(self): """ if self.inference_algo == "VANILLA": - q_pi, G = control.update_posterior_policies_factorized( - self.qs, - self.A, - self.B, - self.C, - self.A_factor_list, - self.B_factor_list, - self.policies, - self.use_utility, - self.use_states_info_gain, - self.use_param_info_gain, - self.pA, - self.pB, - E=self.E, - I=self.I, - gamma=self.gamma - ) + if self.sophisticated: + q_pi, G = control.sophisticated_inference_search( + self.qs, + self.policies, + self.A, + self.B, + self.C, + self.A_factor_list, + self.B_factor_list, + self.I, + self.si_horizon, + self.si_policy_prune_threshold, + self.si_state_prune_threshold, + self.si_prune_penalty, + self.gamma, + n=0 + ) + else: + q_pi, G = control.update_posterior_policies_factorized( + self.qs, + self.A, + self.B, + self.C, + self.A_factor_list, + self.B_factor_list, + self.policies, + self.use_utility, + self.use_states_info_gain, + self.use_param_info_gain, + self.pA, + self.pB, + E = self.E, + I = self.I, + gamma = self.gamma + ) elif self.inference_algo == "MMP": future_qs_seq = self.get_future_qs() From b52903a22f3469f474bd2fdddf6427b34d8f9ff2 Mon Sep 17 00:00:00 2001 From: Tim Verbelen Date: Wed, 22 Nov 2023 11:48:26 +0100 Subject: [PATCH 192/232] implement si by explicitly branching observations --- pymdp/agent.py | 31 ++++++++++++- pymdp/control.py | 117 ++++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 145 insertions(+), 3 deletions(-) diff --git a/pymdp/agent.py b/pymdp/agent.py index b9cb70c6..7ed644a2 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -268,8 +268,10 @@ def __init__( # Construct I for backwards induction (if H specified) if H is not None: + self.H = H self.I = control.backwards_induction(H, B, B_factor_list, threshold=1/16, depth=5) else: + self.H = None self.I = None self.edge_handling_params = {} @@ -688,7 +690,28 @@ def infer_policies(self): if self.inference_algo == "VANILLA": if self.sophisticated: - q_pi, G = control.sophisticated_inference_search( + # q_pi, G = control.sophisticated_inference_search( + # self.qs, + # self.policies, + # self.A, + # self.B, + # self.C, + # self.A_factor_list, + # self.B_factor_list, + # self.I, + # self.si_horizon, + # self.si_policy_prune_threshold, + # self.si_state_prune_threshold, + # self.si_prune_penalty, + # 1.0, + # n=0 + # ) + + # print("Sophisticated 1") + # for i in range(len(self.policies)): + # print(G[i], [(p[0], p[1]) for p in self.policies[i]]) + + q_pi, G = control.sophisticated_inference_search2( self.qs, self.policies, self.A, @@ -701,9 +724,13 @@ def infer_policies(self): self.si_policy_prune_threshold, self.si_state_prune_threshold, self.si_prune_penalty, - self.gamma, + 1.0, n=0 ) + + # print("Sophisticated 2") + # for i in range(len(self.policies)): + # print(G[i], [(p[0], p[1]) for p in self.policies[i]]) else: q_pi, G = control.update_posterior_policies_factorized( self.qs, diff --git a/pymdp/control.py b/pymdp/control.py index d3fbc463..993b0c8f 100644 --- a/pymdp/control.py +++ b/pymdp/control.py @@ -6,6 +6,7 @@ import itertools import numpy as np from pymdp.maths import softmax, softmax_obj_arr, spm_dot, spm_wnorm, spm_MDP_G, spm_log_single, kl_div, entropy +from pymdp.inference import update_posterior_states_factorized from pymdp import utils import copy @@ -1414,7 +1415,7 @@ def sophisticated_inference_search(qs, policies, A, B, C, A_factor_list, B_facto if I is not None: G[idx] += calc_inductive_cost(qs, qs_pi[idx], I) - q_pi = softmax(G * gamma) + q_pi = softmax(G * gamma) if n < horizon - 1: # ignore low probability actions in the search tree @@ -1445,5 +1446,119 @@ def sophisticated_inference_search(qs, policies, A, B, C, A_factor_list, B_facto G_weighted = np.dot(q_pi_next, G_next) * prob G[idx] += G_weighted + q_pi = softmax(G * gamma) + return q_pi, G + + +def sophisticated_inference_search2(qs, policies, A, B, C, A_factor_list, B_factor_list, I=None, horizon=1, + policy_prune_threshold=1/16, state_prune_threshold=1/16, prune_penalty=512, gamma=16, n=0): + """ + Performs sophisticated inference to find the optimal policy for a given generative model and prior preferences. + + Parameters + ---------- + qs: ``numpy.ndarray`` of dtype object + Marginal posterior beliefs over hidden states at a given timepoint. + policies: ``list`` of 1D ``numpy.ndarray`` + ``list`` that stores each policy as a 1D array in ``policies[p_idx]``. Shape of ``policies[p_idx]`` + is ``(num_factors)`` where ``num_factors`` is the number of control factors. + A: ``numpy.ndarray`` of dtype object + Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of + stores an ``numpy.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store + the probability of observation level ``i`` given hidden state levels ``j, k, ...`` + B: ``numpy.ndarray`` of dtype object + Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. + Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability + of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. + C: ``numpy.ndarray`` of dtype object + Prior over observations or 'prior preferences', storing the "value" of each outcome in terms of relative log probabilities. + This is softmaxed to form a proper probability distribution before being used to compute the expected utility term of the expected free energy. + A_factor_list: ``list`` of ``list`` of ``int`` + List of lists, where ``A_factor_list[m]`` is a list of the hidden state factor indices that observation modality with the index ``m`` depends on + B_factor_list: ``list`` of ``list`` of ``int`` + List of lists of hidden state factors each hidden state factor depends on. Each element ``B_factor_list[i]`` is a list of the factor indices that factor i's dynamics depend on. + I: ``numpy.ndarray`` of dtype object + For each state factor, contains a 2D ``numpy.ndarray`` whose element i,j yields the probability + of reaching the goal state backwards from state j after i steps. + horizon: ``int`` + The temporal depth of the policy + policy_prune_threshold: ``float`` + The threshold for pruning policies that are below a certain probability + state_prune_threshold: ``float`` + The threshold for pruning states in the expectation that are below a certain probability + prune_penalty: ``float`` + Penalty to add to the EFE when a policy is pruned + gamma: ``float``, default 16.0 + Prior precision over policies, scales the contribution of the expected free energy to the posterior over policies + n: ``int`` + timestep in the future we are calculating + + Returns + ---------- + q_pi: 1D ``numpy.ndarray`` + Posterior beliefs over policies, i.e. a vector containing one posterior probability per policy. + + G: 1D ``numpy.ndarray`` + Negative expected free energies of each policy, i.e. a vector containing one negative expected free energy per policy. + """ + + n_policies = len(policies) + G = np.zeros(n_policies) + q_pi = np.zeros((n_policies, 1)) + qs_pi = utils.obj_array(n_policies) + qo_pi = utils.obj_array(n_policies) + + for idx, policy in enumerate(policies): + qs_pi[idx] = get_expected_states_interactions(qs, B, B_factor_list, policy) + qo_pi[idx] = get_expected_obs_factorized(qs_pi[idx], A, A_factor_list) + + G[idx] += calc_expected_utility(qo_pi[idx], C) + G[idx] += calc_states_info_gain_factorized(A, qs_pi[idx], A_factor_list) + + if I is not None: + G[idx] += calc_inductive_cost(qs, qs_pi[idx], I) + + q_pi = softmax(G * gamma) + + if n < horizon - 1: + # ignore low probability actions in the search tree + # TODO shouldnt we have to add extra penalty for branches no longer considered? + # or assume these are already low EFE (high NEFE) anyway? + policies_to_consider = list(np.where(q_pi >= policy_prune_threshold)[0]) + for idx in range(n_policies): + if idx not in policies_to_consider: + G[idx] -= prune_penalty + else : + # average over outcomes + qo_next = qo_pi[idx][0] + for k in itertools.product(*[range(s.shape[0]) for s in qo_next]): + prob = 1.0 + for i in range(len(k)): + prob *= qo_pi[idx][0][i][k[i]] + + # ignore low probability states in the search tree + if prob < state_prune_threshold: + continue + + qo_one_hot = utils.obj_array(len(qo_next)) + for i in range(len(qo_one_hot)): + qo_one_hot[i] = utils.onehot(k[i], qo_next[i].shape[0]) + + num_obs = [A[m].shape[0] for m in range(len(A))] + num_states = [B[f].shape[0] for f in range(len(B))] + A_modality_list = [] + for f in range(len(B)): + A_modality_list.append( [m for m in range(len(A)) if f in A_factor_list[m]] ) + mb_dict = { + 'A_factor_list': A_factor_list, + 'A_modality_list': A_modality_list + } + inference_params = {"num_iter": 10, "dF": 1.0, "dF_tol": 0.001, "compute_vfe": False} + qs_next = update_posterior_states_factorized(A, qo_one_hot, num_obs, num_states, mb_dict, qs_pi[idx][0], **inference_params) + q_pi_next, G_next = sophisticated_inference_search2(qs_next, policies, A, B, C, A_factor_list, B_factor_list, I, + horizon, policy_prune_threshold, state_prune_threshold, n=n+1) + G_weighted = np.dot(q_pi_next, G_next) * prob + G[idx] += G_weighted + q_pi = softmax(G * gamma) return q_pi, G \ No newline at end of file From e9357ac70c6fe9ab8ab5dcf6ca68da35382b7d97 Mon Sep 17 00:00:00 2001 From: Tim Verbelen Date: Mon, 4 Dec 2023 08:38:56 +0100 Subject: [PATCH 193/232] expose parameters for inductive inference --- pymdp/agent.py | 6 ++++-- pymdp/control.py | 1 + 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/pymdp/agent.py b/pymdp/agent.py index 7ed644a2..078d73fe 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -69,7 +69,9 @@ def __init__( si_horizon=3, si_policy_prune_threshold=1/16, si_state_prune_threshold=1/16, - si_prune_penalty=512 + si_prune_penalty=512, + ii_depth=10, + ii_threshold=1/16, ): ### Constant parameters ### @@ -269,7 +271,7 @@ def __init__( # Construct I for backwards induction (if H specified) if H is not None: self.H = H - self.I = control.backwards_induction(H, B, B_factor_list, threshold=1/16, depth=5) + self.I = control.backwards_induction(H, B, B_factor_list, threshold=ii_threshold, depth=ii_depth) else: self.H = None self.I = None diff --git a/pymdp/control.py b/pymdp/control.py index 993b0c8f..1e6a2fc3 100644 --- a/pymdp/control.py +++ b/pymdp/control.py @@ -1309,6 +1309,7 @@ def backwards_induction(H, B, B_factor_list, threshold, depth): for i in range(1, depth): I[factor][i, :] = np.dot(b, I[factor][i-1, :]) I[factor][i, :] = np.where(I[factor][i, :] > 0.1, 1.0, 0.0) + # TODO stop when all 1s? return I From 3591c76ef23a1c39abef7dd187600b8514e23c3f Mon Sep 17 00:00:00 2001 From: Tim Verbelen Date: Fri, 12 Jan 2024 10:41:51 +0100 Subject: [PATCH 194/232] cleanup si a bit --- pymdp/agent.py | 28 +----------- pymdp/control.py | 115 ++++------------------------------------------- 2 files changed, 10 insertions(+), 133 deletions(-) diff --git a/pymdp/agent.py b/pymdp/agent.py index 078d73fe..c7748bde 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -692,28 +692,7 @@ def infer_policies(self): if self.inference_algo == "VANILLA": if self.sophisticated: - # q_pi, G = control.sophisticated_inference_search( - # self.qs, - # self.policies, - # self.A, - # self.B, - # self.C, - # self.A_factor_list, - # self.B_factor_list, - # self.I, - # self.si_horizon, - # self.si_policy_prune_threshold, - # self.si_state_prune_threshold, - # self.si_prune_penalty, - # 1.0, - # n=0 - # ) - - # print("Sophisticated 1") - # for i in range(len(self.policies)): - # print(G[i], [(p[0], p[1]) for p in self.policies[i]]) - - q_pi, G = control.sophisticated_inference_search2( + q_pi, G = control.sophisticated_inference_search( self.qs, self.policies, self.A, @@ -727,12 +706,9 @@ def infer_policies(self): self.si_state_prune_threshold, self.si_prune_penalty, 1.0, + self.inference_params, n=0 ) - - # print("Sophisticated 2") - # for i in range(len(self.policies)): - # print(G[i], [(p[0], p[1]) for p in self.policies[i]]) else: q_pi, G = control.update_posterior_policies_factorized( self.qs, diff --git a/pymdp/control.py b/pymdp/control.py index 1e6a2fc3..6a7231ce 100644 --- a/pymdp/control.py +++ b/pymdp/control.py @@ -1348,111 +1348,11 @@ def calc_ambiguity_factorized(qs_pi, A, A_factor_list): ambiguity += np.sum(spm_dot(H_m, qs_pi[t][factor_idx])) return ambiguity - -def sophisticated_inference_search(qs, policies, A, B, C, A_factor_list, B_factor_list, I=None, horizon=1, - policy_prune_threshold=1/16, state_prune_threshold=1/16, prune_penalty=512, gamma=16, n=0): - """ - Performs sophisticated inference to find the optimal policy for a given generative model and prior preferences. - - Parameters - ---------- - qs: ``numpy.ndarray`` of dtype object - Marginal posterior beliefs over hidden states at a given timepoint. - policies: ``list`` of 1D ``numpy.ndarray`` - ``list`` that stores each policy as a 1D array in ``policies[p_idx]``. Shape of ``policies[p_idx]`` - is ``(num_factors)`` where ``num_factors`` is the number of control factors. - A: ``numpy.ndarray`` of dtype object - Sensory likelihood mapping or 'observation model', mapping from hidden states to observations. Each element ``A[m]`` of - stores an ``numpy.ndarray`` multidimensional array for observation modality ``m``, whose entries ``A[m][i, j, k, ...]`` store - the probability of observation level ``i`` given hidden state levels ``j, k, ...`` - B: ``numpy.ndarray`` of dtype object - Dynamics likelihood mapping or 'transition model', mapping from hidden states at ``t`` to hidden states at ``t+1``, given some control state ``u``. - Each element ``B[f]`` of this object array stores a 3-D tensor for hidden state factor ``f``, whose entries ``B[f][s, v, u]`` store the probability - of hidden state level ``s`` at the current time, given hidden state level ``v`` and action ``u`` at the previous time. - C: ``numpy.ndarray`` of dtype object - Prior over observations or 'prior preferences', storing the "value" of each outcome in terms of relative log probabilities. - This is softmaxed to form a proper probability distribution before being used to compute the expected utility term of the expected free energy. - A_factor_list: ``list`` of ``list`` of ``int`` - List of lists, where ``A_factor_list[m]`` is a list of the hidden state factor indices that observation modality with the index ``m`` depends on - B_factor_list: ``list`` of ``list`` of ``int`` - List of lists of hidden state factors each hidden state factor depends on. Each element ``B_factor_list[i]`` is a list of the factor indices that factor i's dynamics depend on. - I: ``numpy.ndarray`` of dtype object - For each state factor, contains a 2D ``numpy.ndarray`` whose element i,j yields the probability - of reaching the goal state backwards from state j after i steps. - horizon: ``int`` - The temporal depth of the policy - policy_prune_threshold: ``float`` - The threshold for pruning policies that are below a certain probability - state_prune_threshold: ``float`` - The threshold for pruning states in the expectation that are below a certain probability - prune_penalty: ``float`` - Penalty to add to the EFE when a policy is pruned - gamma: ``float``, default 16.0 - Prior precision over policies, scales the contribution of the expected free energy to the posterior over policies - n: ``int`` - timestep in the future we are calculating - - Returns - ---------- - q_pi: 1D ``numpy.ndarray`` - Posterior beliefs over policies, i.e. a vector containing one posterior probability per policy. - - G: 1D ``numpy.ndarray`` - Negative expected free energies of each policy, i.e. a vector containing one negative expected free energy per policy. - """ - - n_policies = len(policies) - G = np.zeros(n_policies) - q_pi = np.zeros((n_policies, 1)) - qs_pi = utils.obj_array(n_policies) - - for idx, policy in enumerate(policies): - qs_pi[idx] = get_expected_states_interactions(qs, B, B_factor_list, policy) - qo_pi = get_expected_obs_factorized(qs_pi[idx], A, A_factor_list) - - C_prob = softmax_obj_arr(C) - G[idx] += -kl_div(qo_pi[0], C_prob) - G[idx] += -calc_ambiguity_factorized(qs_pi[idx], A, A_factor_list) - if I is not None: - G[idx] += calc_inductive_cost(qs, qs_pi[idx], I) - - q_pi = softmax(G * gamma) - - if n < horizon - 1: - # ignore low probability actions in the search tree - # TODO shouldnt we have to add extra penalty for branches no longer considered? - # or assume these are already low EFE (high NEFE) anyway? - policies_to_consider = list(np.where(q_pi >= policy_prune_threshold)[0]) - for idx in range(n_policies): - if idx not in policies_to_consider: - G[idx] -= prune_penalty - else : - # average over states - qs_next = qs_pi[idx][0] - for k in itertools.product(*[range(s.shape[0]) for s in qs_next]): - prob = 1.0 - for i in range(len(k)): - prob *= qs_pi[idx][0][i][k[i]] - - # ignore low probability states in the search tree - if prob < state_prune_threshold: - continue - qs_one_hot = utils.obj_array(len(qs)) - for i in range(len(qs)): - qs_one_hot[i] = utils.onehot(k[i], qs_next[i].shape[0]) - - q_pi_next, G_next = sophisticated_inference_search(qs_one_hot, policies, A, B, C, A_factor_list, B_factor_list, I, - horizon, policy_prune_threshold, state_prune_threshold, n=n+1) - G_weighted = np.dot(q_pi_next, G_next) * prob - G[idx] += G_weighted - q_pi = softmax(G * gamma) - return q_pi, G - - -def sophisticated_inference_search2(qs, policies, A, B, C, A_factor_list, B_factor_list, I=None, horizon=1, - policy_prune_threshold=1/16, state_prune_threshold=1/16, prune_penalty=512, gamma=16, n=0): +def sophisticated_inference_search(qs, policies, A, B, C, A_factor_list, B_factor_list, I=None, horizon=1, + policy_prune_threshold=1/16, state_prune_threshold=1/16, prune_penalty=512, gamma=16, + inference_params = {"num_iter": 10, "dF": 1.0, "dF_tol": 0.001, "compute_vfe": False}, n=0): """ Performs sophisticated inference to find the optimal policy for a given generative model and prior preferences. @@ -1460,7 +1360,8 @@ def sophisticated_inference_search2(qs, policies, A, B, C, A_factor_list, B_fact ---------- qs: ``numpy.ndarray`` of dtype object Marginal posterior beliefs over hidden states at a given timepoint. - policies: ``list`` of 1D ``numpy.ndarray`` + policies: ``list`` of 1D ``numpy.ndarray`` inference_params = {"num_iter": 10, "dF": 1.0, "dF_tol": 0.001, "compute_vfe": False} + ``list`` that stores each policy as a 1D array in ``policies[p_idx]``. Shape of ``policies[p_idx]`` is ``(num_factors)`` where ``num_factors`` is the number of control factors. A: ``numpy.ndarray`` of dtype object @@ -1554,10 +1455,10 @@ def sophisticated_inference_search2(qs, policies, A, B, C, A_factor_list, B_fact 'A_factor_list': A_factor_list, 'A_modality_list': A_modality_list } - inference_params = {"num_iter": 10, "dF": 1.0, "dF_tol": 0.001, "compute_vfe": False} qs_next = update_posterior_states_factorized(A, qo_one_hot, num_obs, num_states, mb_dict, qs_pi[idx][0], **inference_params) - q_pi_next, G_next = sophisticated_inference_search2(qs_next, policies, A, B, C, A_factor_list, B_factor_list, I, - horizon, policy_prune_threshold, state_prune_threshold, n=n+1) + q_pi_next, G_next = sophisticated_inference_search(qs_next, policies, A, B, C, A_factor_list, B_factor_list, I, + horizon, policy_prune_threshold, state_prune_threshold, + prune_penalty, gamma, inference_params, n+1) G_weighted = np.dot(q_pi_next, G_next) * prob G[idx] += G_weighted From 7200f3f5ac78f047de7d3761f627e87b51b83cb9 Mon Sep 17 00:00:00 2001 From: Tim Verbelen Date: Fri, 12 Jan 2024 11:40:47 +0100 Subject: [PATCH 195/232] fix index in update_posterior_policies_full_factorized --- pymdp/control.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pymdp/control.py b/pymdp/control.py index 6a7231ce..3489ce03 100644 --- a/pymdp/control.py +++ b/pymdp/control.py @@ -251,9 +251,9 @@ def update_posterior_policies_full_factorized( if use_param_info_gain: if pA is not None: - G[idx] += calc_pA_info_gain_factorized(pA, qo_seq_pi[p_idx], qs_seq_pi[p_idx], A_factor_list) + G[p_idx] += calc_pA_info_gain_factorized(pA, qo_seq_pi[p_idx], qs_seq_pi[p_idx], A_factor_list) if pB is not None: - G[idx] += calc_pB_info_gain_interactions(pB, qs_seq_pi[p_idx], qs, B_factor_list, policy) + G[p_idx] += calc_pB_info_gain_interactions(pB, qs_seq_pi[p_idx], qs_seq_pi[p_idx], B_factor_list, policy) if I is not None: G[p_idx] += calc_inductive_cost(qs_bma, qs_seq_pi[p_idx], I) From 9e5c366bd5af2b58ed66c903218613596c6a9426 Mon Sep 17 00:00:00 2001 From: Tim Verbelen Date: Fri, 12 Jan 2024 11:41:55 +0100 Subject: [PATCH 196/232] fix import average_states_over_policies --- pymdp/control.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pymdp/control.py b/pymdp/control.py index 3489ce03..c5497964 100644 --- a/pymdp/control.py +++ b/pymdp/control.py @@ -6,7 +6,7 @@ import itertools import numpy as np from pymdp.maths import softmax, softmax_obj_arr, spm_dot, spm_wnorm, spm_MDP_G, spm_log_single, kl_div, entropy -from pymdp.inference import update_posterior_states_factorized +from pymdp.inference import update_posterior_states_factorized, average_states_over_policies from pymdp import utils import copy @@ -107,7 +107,7 @@ def update_posterior_policies_full( if I is not None: init_qs_all_pi = [qs_seq_pi[p][0] for p in range(num_policies)] - qs_bma = inference.average_states_over_policies(init_qs_all_pi, softmax(E)) + qs_bma = average_states_over_policies(init_qs_all_pi, softmax(E)) for p_idx, policy in enumerate(policies): @@ -237,7 +237,7 @@ def update_posterior_policies_full_factorized( if I is not None: init_qs_all_pi = [qs_seq_pi[p][0] for p in range(num_policies)] - qs_bma = inference.average_states_over_policies(init_qs_all_pi, softmax(E)) + qs_bma = average_states_over_policies(init_qs_all_pi, softmax(E)) for p_idx, policy in enumerate(policies): From 0ca364d0231496c552e05fd23185d36ea046d67f Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Fri, 12 Jan 2024 11:59:00 +0100 Subject: [PATCH 197/232] resolved merge conflict --- examples/testing_large_latent_spaces.ipynb | 162 ++++++++++++++++----- pymdp/jax/agent.py | 21 ++- pymdp/jax/algos.py | 83 ++++++----- 3 files changed, 187 insertions(+), 79 deletions(-) diff --git a/examples/testing_large_latent_spaces.ipynb b/examples/testing_large_latent_spaces.ipynb index f87b5cd6..7dffa920 100644 --- a/examples/testing_large_latent_spaces.ipynb +++ b/examples/testing_large_latent_spaces.ipynb @@ -25,8 +25,9 @@ "import jax.numpy as jnp\n", "import jax.tree_util as jtu\n", "import equinox as eqx\n", + "import numpy as np\n", "from functools import partial\n", - "from jax import vmap, lax, nn, jit\n", + "from jax import vmap, lax, nn, jit, remat\n", "from jax import random as jr\n", "from pymdp.jax.agent import Agent as AIFAgent\n", "from pymdp.utils import random_A_matrix, random_B_matrix\n", @@ -142,9 +143,9 @@ " def pred(post, cond, deps):\n", " d = post.ndim\n", " dims = tuple(make_tuple(i, d, deps[i]) for i in range(len(deps)))\n", - " keep_dims = dims[0][1:]\n", + " keep_dims = list(dims[0][1:])\n", " for row in dims[1:]:\n", - " keep_dims.extend(row)\n", + " keep_dims.extend(list(row[1:]))\n", " \n", " unique_dims = tuple(set(keep_dims))\n", "\n", @@ -160,16 +161,18 @@ " posterior_beliefs = merge_marginals( jtu.tree_map(lambda x: x[..., -1, :], beliefs) )\n", " qA = agent.pA\n", " qB = agent.pB\n", + "\n", " def step_fn(carry, xs):\n", " posterior_beliefs, qA, qB = carry\n", " obs, acts, filter_beliefs = xs\n", " # learn A matrix\n", - " qA = jtu.tree_map(\n", - " lambda qa, o, m: qa + delta_A(posterior_beliefs, o, A_deps[m], num_obs[m]).sum(0), \n", - " qA, \n", - " obs, \n", - " list(range(len(num_obs)))\n", - " )\n", + " if agent.learn_A:\n", + " qA = jtu.tree_map(\n", + " lambda qa, o, m: qa + delta_A(posterior_beliefs, o, A_deps[m], num_obs[m]).sum(0), \n", + " qA, \n", + " obs, \n", + " list(range(len(num_obs)))\n", + " )\n", "\n", " # learn B matrix\n", " conditional_beliefs = jtu.tree_map(\n", @@ -206,18 +209,22 @@ " (last_beliefs, qA, qB), _ = lax.scan(step_fn, (posterior_beliefs, qA, qB), iters)\n", "\n", " # update A with the first outcome \n", - " qA = jtu.tree_map(\n", - " lambda qa, o, m: qa + delta_A(last_beliefs, o, A_deps[m], num_obs[m]).sum(0), \n", - " qA, \n", - " first_outcomes, \n", - " list(range(len(num_obs)))\n", - " )\n", + " if agent.learn_A:\n", + " qA = jtu.tree_map(\n", + " lambda qa, o, m: qa + delta_A(last_beliefs, o, A_deps[m], num_obs[m]).sum(0), \n", + " qA, \n", + " first_outcomes, \n", + " list(range(len(num_obs)))\n", + " )\n", "\n", - " E_qA = jtu.tree_map(lambda qa: qa / qa.sum(0), qA)\n", + " if qA is not None:\n", + " E_qA = jtu.tree_map(lambda qa: qa / qa.sum(0), qA)\n", + " else:\n", + " E_qA = agent.A\n", " E_qB =jtu.tree_map(lambda qb: qb / qb.sum(0), qB)\n", - " E_qA = agent.A\n", - " E_qB = agent.B\n", - " agent = eqx.tree_at(lambda x: (x.A, x.pA, x.B, x.pB), agent, (E_qA, qA, E_qB, qB))\n", + " agent = eqx.tree_at(\n", + " lambda x: (x.A, x.pA, x.B, x.pB), agent, (E_qA, qA, E_qB, qB), is_leaf=lambda x: x is None\n", + " )\n", "\n", " return agent" ] @@ -238,8 +245,15 @@ " # return a list of random observations for each agent or parallel realization (each entry in batch_dim)\n", " obs = [jr.randint(self.key, (self.num_agents,), 0, no) for no in self.num_obs]\n", " self.key, _ = jr.split(self.key)\n", - " return obs\n", - " \n", + " return obs" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ "def update_agent_state(agent, env, args, key, outcomes, actions):\n", " beliefs = agent.infer_states(outcomes, actions, *args)\n", " # q_pi, _ = agent.infer_policies(beliefs)\n", @@ -281,7 +295,7 @@ " init = {\n", " 'args': (prior, None),\n", " 'outcomes': outcome_0,\n", - " 'actions': - jnp.ones((batch_size, 1, 1), dtype=jnp.int32),\n", + " 'actions': - jnp.ones((batch_size, 1, agent.policies.shape[-1]), dtype=jnp.int32),\n", " 'key': prng_key\n", " }\n", "\n", @@ -314,50 +328,122 @@ " )\n", "\n", " beliefs = jtu.tree_map(lambda x, y: jnp.concatenate([x, y], -2), beliefs, last_belief)\n", + " # agent, beliefs, actions, outcomes = lax.stop_gradient((agent, beliefs, actions, outcomes))\n", " agent = learning(agent, beliefs, actions, outcomes, lag=lag)\n", "\n", - " return agent\n", + " return agent" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# define an agent and environment here\n", + "batch_size = 16\n", + "num_agents = 1\n", + "\n", + "num_pixels = 32\n", + "# y_pos paddle 1, y_pos paddle 2, (x_pos, y_pos) ball\n", + "num_obs = [num_pixels, num_pixels, num_pixels, num_pixels]\n", + "num_states = [num_pixels, num_pixels, num_pixels, num_pixels, 96]\n", + "num_controls = [1, 1, 1, 1, 6]\n", + "num_blocks = 1\n", + "num_timesteps = 25\n", + "\n", + "action_lists = [jnp.zeros(6, dtype=jnp.int32)] * 4\n", + "action_lists += [jnp.arange(6, dtype=jnp.int32)]\n", "\n", + "policies = jnp.expand_dims(jnp.stack(action_lists, -1), -2)\n", + "num_policies = len(policies)\n", + "\n", + "A_dependencies = [[0], [1], [2], [3]]\n", + "B_dependencies = [[0, 4], [1, 4], [2, 4], [3, 4], [4]]\n", + "\n", + "A_np = [np.eye(o) for o in num_obs]\n", + "B_np = list(random_B_matrix(num_states=num_states, num_controls=num_controls, B_factor_list=B_dependencies))\n", + "A = jtu.tree_map(lambda x: jnp.broadcast_to(x, (num_agents,) + x.shape), A_np)\n", + "B = jtu.tree_map(lambda x: jnp.broadcast_to(x, (num_agents,) + x.shape), B_np)\n", + "C = [jnp.zeros((num_agents, no)) for no in num_obs]\n", + "D = [jnp.ones((num_agents, ns)) / ns for ns in num_states]\n", + "E = jnp.ones((num_agents, num_policies )) / num_policies\n", + "\n", + "pA = None # jtu.tree_map(lambda x: jnp.broadcast_to(jnp.ones_like(x), (num_agents,) + x.shape), A_np)\n", + "pB = jtu.tree_map(lambda x: jnp.broadcast_to(jnp.ones_like(x), (num_agents,) + x.shape), B_np)\n", + "\n", + "agents = AIFAgent(A, B, C, D, E, pA, pB, learn_A=False, policies=policies, A_dependencies=A_dependencies, B_dependencies=B_dependencies, use_param_info_gain=True, inference_algo='fpi', sampling_mode='marginal', action_selection='deterministic', num_iter=8)\n", + "env = TestEnv(num_agents, num_obs)\n", + "agents = training_step(agents, env, batch_size, num_timesteps, lag=25)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# agents = lax.stop_gradient(agents)\n", + "%timeit training_step(agents, env, batch_size, num_timesteps, lag=25).A[0].block_until_ready()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ "# define an agent and environment here\n", - "batch_size = 64\n", + "batch_size = 16\n", "num_agents = 1\n", - "num_obs = [256, 256, 256 ** 2]\n", - "num_states = [3062]\n", - "num_controls = [6]\n", + "\n", + "num_pixels = 32\n", + "# y_pos paddle 1, y_pos paddle 2, (x_pos, y_pos) ball\n", + "num_obs = [num_pixels, num_pixels, num_pixels, num_pixels]\n", + "num_states = [num_pixels, 2, num_pixels, 2, num_pixels, num_pixels, 24]\n", + "num_controls = [1, 6, 1, 6, 1, 1, 6]\n", "num_blocks = 1\n", "num_timesteps = 25\n", "\n", - "A_np = random_A_matrix(num_obs=num_obs, num_states=num_states)\n", - "B_np = random_B_matrix(num_states=num_states, num_controls=num_controls)\n", - "A = jtu.tree_map(lambda x: jnp.broadcast_to(x, (num_agents,) + x.shape), list(A_np))\n", - "B = jtu.tree_map(lambda x: jnp.broadcast_to(x, (num_agents,) + x.shape), list(B_np))\n", + "action_lists = [jnp.zeros(6, dtype=jnp.int32), jnp.arange(6, dtype=jnp.int32)] * 2\n", + "action_lists += [jnp.zeros(6, dtype=jnp.int32), jnp.zeros(6, dtype=jnp.int32), jnp.arange(6, dtype=jnp.int32)]\n", + "\n", + "policies = jnp.expand_dims(jnp.stack(action_lists, -1), -2)\n", + "num_policies = len(policies)\n", + "\n", + "A_dependencies = [[0], [2], [4], [5]]\n", + "B_dependencies = [[0, 1], [1], [2, 3], [3], [4, 6], [5, 6], [6]]\n", + "\n", + "A_np = [np.eye(o) for o in num_obs]\n", + "B_np = list(random_B_matrix(num_states=num_states, num_controls=num_controls, B_factor_list=B_dependencies))\n", + "A = jtu.tree_map(lambda x: jnp.broadcast_to(x, (num_agents,) + x.shape), A_np)\n", + "B = jtu.tree_map(lambda x: jnp.broadcast_to(x, (num_agents,) + x.shape), B_np)\n", "C = [jnp.zeros((num_agents, no)) for no in num_obs]\n", "D = [jnp.ones((num_agents, ns)) / ns for ns in num_states]\n", - "E = jnp.ones((num_agents, 4 )) / 4 \n", + "E = jnp.ones((num_agents, num_policies )) / num_policies\n", "\n", - "pA = jtu.tree_map(lambda x: jnp.broadcast_to(jnp.ones_like(x), (num_agents,) + x.shape), list(A_np))\n", - "pB = jtu.tree_map(lambda x: jnp.broadcast_to(jnp.ones_like(x), (num_agents,) + x.shape), list(B_np))\n", + "pA = None # jtu.tree_map(lambda x: jnp.broadcast_to(jnp.ones_like(x), (num_agents,) + x.shape), A_np)\n", + "pB = jtu.tree_map(lambda x: jnp.broadcast_to(jnp.ones_like(x), (num_agents,) + x.shape), B_np)\n", "\n", - "agents = AIFAgent(A, B, C, D, E, pA, pB, use_param_info_gain=True, inference_algo='fpi', sampling_mode='marginal', action_selection='stochastic', num_iter=1)\n", + "agents = AIFAgent(A, B, C, D, E, pA, pB, learn_A=False, policies=policies, A_dependencies=A_dependencies, B_dependencies=B_dependencies, use_param_info_gain=True, inference_algo='fpi', sampling_mode='marginal', action_selection='deterministic', num_iter=8)\n", "env = TestEnv(num_agents, num_obs)\n", "agents = training_step(agents, env, batch_size, num_timesteps, lag=25)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "10.9 s ± 24.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + "31.4 s ± 15.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" ] } ], "source": [ - "agents = lax.stop_gradient(agents)\n", "%timeit training_step(agents, env, batch_size, num_timesteps, lag=25).A[0].block_until_ready()" ] } diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index bce0b680..eda9be4e 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -254,9 +254,10 @@ def learning(self, beliefs, outcomes, actions, **kwargs): o_vec_seq = jtu.tree_map(lambda o, dim: nn.one_hot(o, dim), outcomes, self.num_obs) qA = learning.update_obs_likelihood_dirichlet(self.pA, self.A, o_vec_seq, beliefs, self.A_dependencies, lr=1.) E_qA = jtu.tree_map(lambda x: maths.dirichlet_expected_value(x), qA) + agent = tree_at(lambda x: (x.A, x.pA), self, (E_qA, qA)) if self.learn_B: - actions_seq = [actions[...,i] for i in range(actions.shape[-1])] # as many elements as there are control factors, where each element is a jnp.ndarray of shape (n_timesteps, ) + actions_seq = [actions[..., i] for i in range(actions.shape[-1])] # as many elements as there are control factors, where each element is a jnp.ndarray of shape (n_timesteps, ) actions_onehot = jtu.tree_map(lambda a, dim: nn.one_hot(a, dim, axis=-1), actions_seq, self.num_controls) qB = learning.update_state_likelihood_dirichlet(self.pB, self.B, beliefs, actions_onehot, self.B_dependencies) E_qB = jtu.tree_map(lambda x: maths.dirichlet_expected_value(x), qB) @@ -264,6 +265,7 @@ def learning(self, beliefs, outcomes, actions, **kwargs): # if you have updated your beliefs about transitions, you need to re-compute the I matrix used for inductive inferenece if self.use_inductive and self.H is not None: I_updated = control.generate_I_matrix(self.H, E_qB, self.inductive_threshold, self.inductive_depth) + # if self.learn_C: # self.qC = learning.update_C(self.C, *args, **kwargs) # self.C = jtu.tree_map(lambda x: maths.dirichlet_expected_value(x), self.qC) @@ -284,7 +286,7 @@ def learning(self, beliefs, outcomes, actions, **kwargs): return agent @vmap - def infer_states(self, observations, past_actions, empirical_prior, qs_hist): + def infer_states(self, observations, past_actions, empirical_prior, qs_hist, mask=None): """ Update approximate posterior over hidden states by solving variational inference problem, given an observation. @@ -306,10 +308,18 @@ def infer_states(self, observations, past_actions, empirical_prior, qs_hist): ``qs[p_idx][t_idx][f_idx]`` refers to beliefs about marginal factor ``f_idx`` expected under policy ``p_idx`` at timepoint ``t_idx``. """ - - o_vec = [nn.one_hot(o, self.num_obs[m]) for m, o in enumerate(observations)] + if mask is None: + o_vec = [nn.one_hot(o, self.num_obs[m]) for m, o in enumerate(observations)] + A = self.A + else: + A = [] + o_vec = [] + for i, m in enumerate(mask): + o_vec.append( m * nn.one_hot(observations[i], self.num_obs[i]) * (1 - m) / self.num_obs[i] ) + A.append(m * self.A[i] + (1 - m) * jnp.ones_like(self.A[i]) / self.num_obs[i]) + output = inference.update_posterior_states( - self.A, + A, self.B, o_vec, past_actions, @@ -328,6 +338,7 @@ def update_empirical_prior(self, action, qs): # return empirical_prior, and the history of posterior beliefs (filtering distributions) held about hidden states at times 1, 2 ... t qs_last = jtu.tree_map( lambda x: x[-1], qs) + # this computation of the predictive prior is correct only for fully factorised Bs. pred = control.compute_expected_state(qs_last, self.B, action, B_dependencies=self.B_dependencies) return (pred, qs) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index bb155b0b..11fcee5a 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -106,7 +106,6 @@ def mirror_gradient_descent_step(tau, ln_A, lnB_past, lnB_future, ln_qs): def update_marginals(get_messages, obs, A, B, prior, A_dependencies, B_dependencies, num_iter=1, tau=1.,): """" Version of marginal update that uses a sparse dependency matrix for A """ - nf = len(prior) T = obs[0].shape[0] ln_B = jtu.tree_map(log_stable, B) # log likelihoods -> $\ln(A)$ for all time steps @@ -274,46 +273,58 @@ def run_vmp(A, B, obs, prior, A_dependencies, B_dependencies, num_iter=1, tau=1. return qs def get_mmp_messages(ln_B, B, qs, ln_prior, B_deps): - + num_factors = len(qs) factors = list(range(num_factors)) - get_deps = lambda x, f_idx: [x[f][:-1] for f in f_idx] - all_deps_except_f = jtu.tree_map( - lambda f: [d for d in B_deps[f] if d != f], - factors - ) - position = jtu.tree_map( - lambda f: B_deps[f].index(f), - factors - ) - dims = jtu.tree_map(lambda f: tuple((0,) + (2 + B_deps[f].index(i),) for i in all_deps_except_f[f]), factors) - def func(b, f): - xs = get_deps(qs, all_deps_except_f[f]) - return factor_dot_flex(b, xs, dims[f], keep_dims=(0, 1, 2 + position[f]) ) + get_deps_forw = lambda x, f_idx: [x[f][:-1] for f in f_idx] + get_deps_back = lambda x, f_idx: [x[f][1:] for f in f_idx] + + def forward(b, ln_prior, f): + xs = get_deps_forw(qs, B_deps[f]) + dims = tuple((0, 2 + i) for i in range(len(B_deps[f]))) + msg = log_stable(factor_dot_flex(b, xs, dims, keep_dims=(0, 1) )) + # append log_prior as a first message + msg = jnp.concatenate([jnp.expand_dims(ln_prior, 0), msg], axis=0) + # mutliply with 1/2 all but the last msg + T = len(msg) + if T > 1: + msg = msg * jnp.pad( 0.5 * jnp.ones(T - 1), (0, 1), constant_values=1.)[:, None] + + return msg - B_marg = jtu.tree_map(func, B, factors) if B is not None else None - - def forward(b, q, ln_prior): - if len(q) > 1: - msg = vmap(lambda x, y: y @ x)(q[:-1], b) - msg = log_stable(msg) - n = len(msg) - if n > 1: # this is the case where there are at least 3 observations. If you have two observations, then you weight the single past message from t = 0 by 1.0 - msg = msg * jnp.pad( 0.5 * jnp.ones(n-1), (0, 1), constant_values=1.)[:, None] - return jnp.concatenate([jnp.expand_dims(ln_prior, 0), msg], axis=0) # @TODO: look up whether we want to decrease influence of prior by half as well - else: # this is case where this is a single observation / single-timestep posterior - return jnp.expand_dims(ln_prior, 0) - - def backward(b, q): - msg = vmap(lambda x, y: x @ y)(q[1:], b) - msg = log_stable(msg) * 0.5 + def backward(Bs, xs): + msg = 0. + for i, b in enumerate(Bs): + b_norm = b / (b.sum(-1, keepdims=True) + 1e-16) + msg += log_stable(vmap(lambda x, y: y @ x)(b_norm, xs[i])) * .5 + return jnp.pad(msg, ((0, 1), (0, 0))) - - if B_marg is not None: - lnB_future = jtu.tree_map(forward, B_marg, qs, ln_prior) - lnB_past = jtu.tree_map(backward, B_marg, qs) - else: + + inv_B_deps = [[i for i, d in enumerate(B_deps) if f in d] for f in factors] + + def marg(inv_deps, f): + B_marg = [] + for i in inv_deps: + b = B[i] + keep_dims = (0, 1, 2 + B_deps[i].index(f)) + dims = [] + idxs = [] + for j, d in enumerate(B_deps[i]): + if f != d: + dims.append((0, 2 + j)) + idxs.append(d) + xs = get_deps_forw(qs, idxs) + B_marg.append( factor_dot_flex(b, xs, tuple(dims), keep_dims=keep_dims) ) + + return B_marg + + B_marg = jtu.tree_map(lambda f: marg(inv_B_deps[f], f), factors) + + if B is not None: + lnB_future = jtu.tree_map(forward, B, ln_prior, factors) + lnB_past = jtu.tree_map(lambda f: backward(B_marg[f], get_deps_back(qs, inv_B_deps[f])), factors) + else: lnB_future = jtu.tree_map(lambda x: 0., qs) lnB_past = jtu.tree_map(lambda x: 0., qs) From 98885c838cfbff40a418f1d86b0825edd6a47366 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Thu, 18 Jan 2024 09:31:44 +0100 Subject: [PATCH 198/232] added one hot form for observations --- pymdp/jax/agent.py | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index eda9be4e..87293f26 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -74,6 +74,7 @@ class Agent(Module): use_states_info_gain: bool = field(static=True) # flag for whether to use state information gain ("salience") when computing expected free energy use_param_info_gain: bool = field(static=True) # flag for whether to use parameter information gain ("novelty") when computing expected free energy use_inductive: bool = field(static=True) # flag for whether to use inductive inference ("intentional inference") when computing expected free energy + onehot_obs: bool = field(static=True) action_selection: str = field(static=True) # determinstic or stochastic action selection sampling_mode : str = field(static=True) # whether to sample from full posterior over policies ("full") or from marginal posterior over actions ("marginal") inference_algo: str = field(static=True) # fpi, vmp, mmp, ovf @@ -110,6 +111,7 @@ def __init__( use_states_info_gain=True, use_param_info_gain=False, use_inductive=False, + onehot_obs=True, action_selection="deterministic", sampling_mode="marginal", inference_algo="fpi", @@ -132,6 +134,8 @@ def __init__( self.qs = qs self.q_pi = q_pi + self.onehot_obs = onehot_obs + element_size = lambda x: x.shape[1] self.num_factors = len(self.B) self.num_states = jtu.tree_map(element_size, self.B) @@ -308,15 +312,16 @@ def infer_states(self, observations, past_actions, empirical_prior, qs_hist, mas ``qs[p_idx][t_idx][f_idx]`` refers to beliefs about marginal factor ``f_idx`` expected under policy ``p_idx`` at timepoint ``t_idx``. """ - if mask is None: + if not self.onehot_obs: o_vec = [nn.one_hot(o, self.num_obs[m]) for m, o in enumerate(observations)] - A = self.A else: - A = [] - o_vec = [] + o_vec = observations + + A = self.A + if mask is not None: for i, m in enumerate(mask): - o_vec.append( m * nn.one_hot(observations[i], self.num_obs[i]) * (1 - m) / self.num_obs[i] ) - A.append(m * self.A[i] + (1 - m) * jnp.ones_like(self.A[i]) / self.num_obs[i]) + o_vec[i] = m * o_vec[i] + (1 - m) * o_vec[i] / self.num_obs[i] + A[i] = m * A[i] + (1 - m) * jnp.ones_like(A[i]) / self.num_obs[i] output = inference.update_posterior_states( A, From 3cb01404df84ad7e3da4a014ad6025b75999b942 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Tue, 13 Feb 2024 09:57:36 +0100 Subject: [PATCH 199/232] updated notebooks and default agent settings --- examples/building_up_agent_loop.ipynb | 2 +- examples/inductive_inference_example.ipynb | 17 +++++++++++------ examples/inductive_inference_gridworld.ipynb | 14 +++----------- pymdp/jax/agent.py | 11 ++++++++--- pymdp/jax/control.py | 4 ++-- 5 files changed, 25 insertions(+), 23 deletions(-) diff --git a/examples/building_up_agent_loop.ipynb b/examples/building_up_agent_loop.ipynb index abb6dc48..cdb45e55 100644 --- a/examples/building_up_agent_loop.ipynb +++ b/examples/building_up_agent_loop.ipynb @@ -132,7 +132,7 @@ " self.key, _ = jr.split(self.key)\n", " return obs\n", "\n", - "agents = AIFAgent(A, B, C, D, E, pA, pB, use_param_info_gain=True, inference_algo='fpi', sampling_mode='marginal', action_selection='stochastic')\n", + "agents = AIFAgent(A, B, C, D, E, pA, pB, use_param_info_gain=True, use_inductive=False, inference_algo='fpi', sampling_mode='marginal', action_selection='stochastic')\n", "env = TestEnv(num_obs)\n", "init = (agents, env)\n", "(agents, env), sequences = scan(step_fn, init, range(num_blocks) )\n", diff --git a/examples/inductive_inference_example.ipynb b/examples/inductive_inference_example.ipynb index 1cf566bd..d4745fb4 100644 --- a/examples/inductive_inference_example.ipynb +++ b/examples/inductive_inference_example.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -32,7 +32,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -84,7 +84,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -108,12 +108,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# evaluate Q(pi) and negative EFE using the inductive planning algorithm\n", - "q_pi, neg_efe = control.update_posterior_policies_inductive(policy_matrix, qs_init, A, B, C, A_dependencies, B_dependencies, I, gamma=16.0, use_utility=True, use_inductive=True, inductive_epsilon=1e-3)" + "\n", + "E = jnp.ones(policy_matrix.shape[0])\n", + "pA = jtu.tree_map(lambda a: jnp.ones_like(a), A)\n", + "pB = jtu.tree_map(lambda b: jnp.ones_like(b), B)\n", + "\n", + "q_pi, neg_efe = control.update_posterior_policies_inductive(policy_matrix, qs_init, A, B, C, E, pA, pB, A_dependencies, B_dependencies, I, gamma=16.0, use_utility=True, use_inductive=True, inductive_epsilon=1e-3)" ] } ], @@ -133,7 +138,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.5" + "version": "3.11.7" } }, "nbformat": 4, diff --git a/examples/inductive_inference_gridworld.ipynb b/examples/inductive_inference_gridworld.ipynb index 011922c8..99fb2f27 100644 --- a/examples/inductive_inference_gridworld.ipynb +++ b/examples/inductive_inference_gridworld.ipynb @@ -109,15 +109,7 @@ "cell_type": "code", "execution_count": 4, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using inductive inference...\n" - ] - } - ], + "outputs": [], "source": [ "# create agent\n", "agent = AIFAgent(A, B, C, D, E=None, pA=None, pB=None, policies=policy_matrix, policy_len=planning_horizon, \n", @@ -134,7 +126,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -202,7 +194,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.4" + "version": "3.11.7" } }, "nbformat": 4, diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 87293f26..5032300a 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -99,6 +99,7 @@ def __init__( qs=None, q_pi=None, H=None, + I=None, policy_len=1, control_fac_idx=None, policies=None, @@ -111,7 +112,7 @@ def __init__( use_states_info_gain=True, use_param_info_gain=False, use_inductive=False, - onehot_obs=True, + onehot_obs=False, action_selection="deterministic", sampling_mode="marginal", inference_algo="fpi", @@ -192,8 +193,10 @@ def __init__( self.use_inductive = use_inductive if self.use_inductive and self.H is not None: - print("Using inductive inference...") + # print("Using inductive inference...") self.I = self._construct_I() + elif self.use_inductive and I is not None: + self.I = I else: self.I = jtu.tree_map(lambda x: jnp.expand_dims(jnp.zeros_like(x), 1), self.D) @@ -269,6 +272,8 @@ def learning(self, beliefs, outcomes, actions, **kwargs): # if you have updated your beliefs about transitions, you need to re-compute the I matrix used for inductive inferenece if self.use_inductive and self.H is not None: I_updated = control.generate_I_matrix(self.H, E_qB, self.inductive_threshold, self.inductive_depth) + else: + I_updated = self.I # if self.learn_C: # self.qC = learning.update_C(self.C, *args, **kwargs) @@ -320,7 +325,7 @@ def infer_states(self, observations, past_actions, empirical_prior, qs_hist, mas A = self.A if mask is not None: for i, m in enumerate(mask): - o_vec[i] = m * o_vec[i] + (1 - m) * o_vec[i] / self.num_obs[i] + o_vec[i] = m * o_vec[i] + (1 - m) * jnp.ones_like(o_vec[i]) / self.num_obs[i] A[i] = m * A[i] + (1 - m) * jnp.ones_like(A[i]) / self.num_obs[i] output = inference.update_posterior_states( diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index 4a05f9ed..a6bf1a50 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -471,8 +471,8 @@ def calc_inductive_value_t(qs, qs_next, I, epsilon=1e-3): # i.e. find first entry at which I_idx equals 1, and then m is the index before that m = jnp.maximum(jnp.argmax(I[f][:, idx])-1, 0) - I_m = (1.-I[f][m, :]) * log_eps - path_available = jnp.clip(I[f][:,idx].sum(0), a_min=0, a_max=1) # if there are any 1's at all in that column of I, then this == 1, otherwise 0 + I_m = (1. - I[f][m, :]) * log_eps + path_available = jnp.clip(I[f][:, idx].sum(0), a_min=0, a_max=1) # if there are any 1's at all in that column of I, then this == 1, otherwise 0 inductive_val += path_available * I_m.dot(qs_next[f]) # scaling by path_available will nullify the addition of inductive value in the case we find no path to goal (i.e. when no goal specified) return inductive_val From 93e14b3613c292c5a83a3b7f13332d85e8b011b9 Mon Sep 17 00:00:00 2001 From: conorheins Date: Sat, 30 Mar 2024 14:18:38 +0100 Subject: [PATCH 200/232] initial unit tests for jax-translated message passing algorithms --- test/test_message_passing_jax.py | 975 ++++++++++++++++++------------- 1 file changed, 561 insertions(+), 414 deletions(-) diff --git a/test/test_message_passing_jax.py b/test/test_message_passing_jax.py index cccd9212..6332548c 100644 --- a/test/test_message_passing_jax.py +++ b/test/test_message_passing_jax.py @@ -12,6 +12,7 @@ import jax.numpy as jnp import jax.tree_util as jtu from jax import vmap, nn +from jax import random as jr from pymdp.jax.algos import run_vanilla_fpi as fpi_jax from pymdp.jax.algos import run_factorized_fpi as fpi_jax_factorized @@ -22,22 +23,69 @@ from pymdp.jax.algos import run_vmp as vmp_jax from pymdp import utils, maths -from typing import Any, List - +from typing import Any, List, Dict + + +def make_model_configs(source_seed=0, num_models=4) -> Dict: + rng_keys = jr.split(jr.PRNGKey(source_seed), num_models) + num_factors_list = [ jr.randint(key, (1,), 1, 7)[0].item() for key in rng_keys ] # list of total numbers of hidden state factors per model + num_states_list = [ jr.randint(key, (nf,), 2, 5).tolist() for nf, key in zip(num_factors_list, rng_keys) ] + num_controls_list = [ jr.randint(key, (nf,), 1, 3).tolist() for nf, key in zip(num_factors_list, rng_keys) ] + + rng_keys = jr.split(rng_keys[-1], num_models) + num_modalities_list = [ jr.randint(key, (1,), 1, 10)[0].item() for key in rng_keys ] + num_obs_list = [ jr.randint(key, (nm,), 1, 5).tolist() for nm, key in zip(num_modalities_list, rng_keys) ] + + rng_keys = jr.split(rng_keys[-1], num_models) + A_deps_list, B_deps_list = [], [] + for nf, nm, model_key in zip(num_factors_list, num_modalities_list, rng_keys): + modality_keys_model_i = jr.split(model_key, nm) + num_f_per_modality = [jr.randint(key, shape=(), minval=1, maxval=nf+1).item() for key in modality_keys_model_i] # this is the number of factors that each modality depends on + A_deps_model_i = [sorted(jr.choice(key, a=nf, shape=(num_f_m,), replace=False).tolist()) for key, num_f_m in zip(modality_keys_model_i, num_f_per_modality)] + A_deps_list.append(A_deps_model_i) + + factor_keys_model_i = jr.split(modality_keys_model_i[-1], nf) + num_f_per_factor = [jr.randint(key, shape=(), minval=1, maxval=nf+1).item() for key in factor_keys_model_i] # this is the number of factors that each factor depends on + B_deps_model_i = [sorted(jr.choice(key, a=nf, shape=(num_f_f,), replace=False).tolist()) for key, num_f_f in zip(factor_keys_model_i, num_f_per_factor)] + B_deps_list.append(B_deps_model_i) + + return {'nf_list': num_factors_list, + 'ns_list': num_states_list, + 'nc_list': num_controls_list, + 'nm_list': num_modalities_list, + 'no_list': num_obs_list, + 'A_deps_list': A_deps_list, + 'B_deps_list': B_deps_list + } + +def make_A_full(A_reduced: List[np.ndarray], A_dependencies: List[List[int]], num_obs: List[int], num_states: List[int]) -> np.ndarray: + """ + Given a reduced A matrix, `A_reduced`, and a list of dependencies between hidden state factors and observation modalities, `A_dependencies`, + return a full A matrix, `A_full`, where `A_full[m]` is the full A matrix for modality `m`. This means all redundant conditional independencies + between observation modalities `m` and all hidden state factors (i.e. `range(len(num_states))`) are represented as lagging dimensions in `A_full`. + """ + A_full = utils.initialize_empty_A(num_obs, num_states) # initialize the full likelihood tensor (ALL modalities might depend on ALL factors) + all_factors = range(len(num_states)) # indices of all hidden state factors + for m, A_m in enumerate(A_full): + + # Step 1. Extract the list of the factors that modality `m` does NOT depend on + non_dependent_factors = list(set(all_factors) - set(A_dependencies[m])) + + # Step 2. broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `non_dependent_factors`, to give it the full shape of `(num_obs[m], *num_states)` + expanded_dims = [num_obs[m]] + [1 if f in non_dependent_factors else ns for (f, ns) in enumerate(num_states)] + tile_dims = [1] + [ns if f in non_dependent_factors else 1 for (f, ns) in enumerate(num_states)] + A_full[m] = np.tile(A_reduced[m].reshape(expanded_dims), tile_dims) + + return A_full + class TestMessagePassing(unittest.TestCase): def test_fixed_point_iteration(self): - num_states_list = [ - [2, 2, 5], - [2, 2, 2], - [4, 4] - ] - - num_obs_list = [ - [5, 10], - [4, 3, 2], - [5, 10, 6] - ] + cfg = {'source_seed': 0, + 'num_models': 4 + } + gm_params = make_model_configs(**cfg) + num_states_list, num_obs_list = gm_params['ns_list'], gm_params['no_list'] for (num_states, num_obs) in zip(num_states_list, num_obs_list): @@ -67,18 +115,11 @@ def test_fixed_point_iteration_factorized_fullyconnected(self): Test the factorized version of `run_vanilla_fpi`, named `run_factorized_fpi` with multiple hidden state factors and multiple observation modalities. """ - - num_states_list = [ - [2, 2, 5], - [2, 2, 2], - [4, 4] - ] - - num_obs_list = [ - [5, 10], - [4, 3, 2], - [5, 10, 6] - ] + cfg = {'source_seed': 1, + 'num_models': 4 + } + gm_params = make_model_configs(**cfg) + num_states_list, num_obs_list = gm_params['ns_list'], gm_params['no_list'] for (num_states, num_obs) in zip(num_states_list, num_obs_list): @@ -109,452 +150,558 @@ def test_fixed_point_iteration_factorized_sparsegraph(self): with multiple hidden state factors and multiple observation modalities, and with sparse conditional dependence relationships between hidden states and observation modalities """ - - num_states = [3, 4] - num_obs = [3, 3, 5] - - prior = utils.random_single_categorical(num_states) + cfg = {'source_seed': 3, + 'num_models': 4 + } + gm_params = make_model_configs(**cfg) - obs = utils.obj_array(len(num_obs)) - for m, obs_dim in enumerate(num_obs): - obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) + num_states_list, num_obs_list, A_dependencies_list = gm_params['ns_list'], gm_params['no_list'], gm_params['A_deps_list'] - A_factor_list = [[0], [1], [0, 1]] # modalities 0 and 1 only depend on factors 0 and 1, respectively - A_reduced = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_factor_list) + for (num_states, num_obs, a_deps_i) in zip(num_states_list, num_obs_list, A_dependencies_list): + + prior = utils.random_single_categorical(num_states) - # jax version - prior_jax = [jnp.array(prior_f) for prior_f in prior] - A_reduced_jax = [jnp.array(a_m) for a_m in A_reduced] - obs_jax = [jnp.array(o_m) for o_m in obs] + obs = utils.obj_array(len(num_obs)) + for m, obs_dim in enumerate(num_obs): + obs[m] = utils.onehot(np.random.randint(obs_dim), obs_dim) - qs_out = fpi_jax_factorized(A_reduced_jax, obs_jax, prior_jax, A_factor_list, num_iter=16) + A_reduced = utils.random_A_matrix(num_obs, num_states, A_factor_list=a_deps_i) - A_full = utils.initialize_empty_A(num_obs, num_states) - for m, A_m in enumerate(A_full): - other_factors = list(set(range(len(num_states))) - set(A_factor_list[m])) # list of the factors that modality `m` does not depend on + # jax version + prior_jax = [jnp.array(prior_f) for prior_f in prior] + A_reduced_jax = [jnp.array(a_m) for a_m in A_reduced] + obs_jax = [jnp.array(o_m) for o_m in obs] - # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` - expanded_dims = [num_obs[m]] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] - tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] - A_full[m] = np.tile(A_reduced[m].reshape(expanded_dims), tile_dims) + qs_out = fpi_jax_factorized(A_reduced_jax, obs_jax, prior_jax, a_deps_i, num_iter=16) - # jax version - A_full_jax = [jnp.array(a_m) for a_m in A_full] + # create the full A matrix, where all hidden state factors are represented in the lagging dimensions of each sub-A array + A_full = make_A_full(A_reduced, a_deps_i, num_obs, num_states) + + # jax version + A_full_jax = [jnp.array(a_m) for a_m in A_full] - qs_validation = fpi_jax(A_full_jax, obs_jax, prior_jax, num_iter=16) + qs_validation = fpi_jax(A_full_jax, obs_jax, prior_jax, num_iter=16) - for qs_f_val, qs_f_out in zip(qs_validation, qs_out): - self.assertTrue(np.allclose(qs_f_val, qs_f_out)) + for qs_f_val, qs_f_out in zip(qs_validation, qs_out): + self.assertTrue(np.allclose(qs_f_val, qs_f_out)) def test_marginal_message_passing(self): - num_states = [3] - num_obs = [3] + cfg = {'source_seed': 5, + 'num_models': 4 + } + gm_params = make_model_configs(**cfg) - A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.], - [0.0, 0.0, 1.], - [0.5, 0.5, 0.]] - ), (2, 3, 3) )] + num_states_list, num_obs_list, num_controls_list, A_dependencies_list, B_dependencies_list = gm_params['ns_list'], gm_params['no_list'], gm_params['nc_list'], \ + gm_params['A_deps_list'], gm_params['B_deps_list'] - # create two B matrices, one for each action - B_1 = jnp.broadcast_to(jnp.array([[0.0, 0.75, 0.0], - [0.0, 0.25, 1.0], - [1.0, 0.0, 0.0]] - ), (2, 3, 3)) - - B_2 = jnp.broadcast_to(jnp.array([[0.0, 0.25, 0.0], - [0.0, 0.75, 0.0], - [1.0, 0.0, 1.0]] - ), (2, 3, 3)) - - B = [jnp.stack([B_1, B_2], axis=-1)] # actions are in the last dimension + batch_size = 3 + n_timesteps = 4 - # create a policy-dependent sequence of B matrices, but now we store the sequence dimension (action indices) in the first dimension (0th dimension is still batch dimension) - policy = jnp.array([0, 1, 0]) - B_policy = jtu.tree_map(lambda b: b[..., policy].transpose(0, 3, 1, 2), B) + for num_states, num_obs, A_deps, B_deps in zip(num_states_list, num_obs_list, A_dependencies_list, B_dependencies_list): - - # for the single modality, a sequence over time of observations (one hot vectors) - obs = [ - jnp.broadcast_to(jnp.array([[1., 0., 0.], - [0., 1., 0.], - [0., 0., 1.], - [1., 0., 0.]])[:, None], (4, 2, 3) ) - ] + # create a version of a_deps_i where each sub-list is sorted + prior = [jr.dirichlet(key, alpha=jnp.ones((ns,)), shape=(batch_size,)) for ns, key in zip(num_states, jr.split(jr.PRNGKey(0), len(num_states)))] - prior = [jnp.ones((2, 3)) / 3.] + obs = [jr.categorical(key, p=jnp.ones(no) / no, shape=(n_timesteps,batch_size)) for no, key in zip(num_obs, jr.split(jr.PRNGKey(1), len(num_obs)))] + obs = jtu.tree_map(lambda x: nn.one_hot(x, num_classes=x.shape[-1]), obs) - A_dependencies = [list(range(len(num_states))) for _ in range(len(num_obs))] - qs_out = mmp_jax(A, B_policy, obs, prior, A_dependencies, num_iter=16, tau=1.) + A_sub_shapes = [ [ns for f, ns in enumerate(num_states) if f in a_deps_i] for a_deps_i in A_deps ] + A_sampling_keys = jr.split(jr.PRNGKey(2), len(num_obs)) + A = [jr.dirichlet(key, alpha=jnp.ones(no), shape=factor_shapes) for no, factor_shapes, key in zip(num_obs, A_sub_shapes, A_sampling_keys)] + A = jtu.tree_map(lambda a: jnp.moveaxis(a, -1, 0), A) # move observations into leading dimensions + A = jtu.tree_map(lambda a: jnp.broadcast_to(a, (batch_size,) + x.shape), A) - self.assertTrue(qs_out[0].shape[0] == obs[0].shape[0]) + B_sub_shapes = [ [ns for f, ns in enumerate(num_states) if f in b_deps_i] + [nc] for nc, b_deps_i in zip(num_controls, B_deps) ] + B_sampling_keys = jr.split(jr.PRNGKey(3), len(num_states)) + B = [jr.dirichlet(key, alpha=jnp.ones(ns), shape=factor_shapes) for ns, factor_shapes, key in zip(num_states, B_sub_shapes, B_sampling_keys)] + B = jtu.tree_map(lambda b: jnp.moveaxis(b, (-2, -1), (0, 1)), B) # move s_{t+1} and actions to first two leading dimensions + B = jtu.tree_map(lambda b: jnp.broadcast_to(b, (batch_size,) + x.shape), B) - def test_variational_message_passing(self): + # A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.], + # [0.0, 0.0, 1.], + # [0.5, 0.5, 0.]] + # ), (2, 3, 3) )] - num_states = [3] - num_obs = [3] + # # create two B matrices, one for each action + # B_1 = jnp.broadcast_to(jnp.array([[0.0, 0.75, 0.0], + # [0.0, 0.25, 1.0], + # [1.0, 0.0, 0.0]] + # ), (2, 3, 3)) + + # B_2 = jnp.broadcast_to(jnp.array([[0.0, 0.25, 0.0], + # [0.0, 0.75, 0.0], + # [1.0, 0.0, 1.0]] + # ), (2, 3, 3)) + + # B = [jnp.stack([B_1, B_2], axis=-1)] # actions are in the last dimension - A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.], - [0.0, 0.0, 1.], - [0.5, 0.5, 0.]] - ), (2, 3, 3) )] + # # create a policy-dependent sequence of B matrices, but now we store the sequence dimension (action indices) in the first dimension (0th dimension is still batch dimension) + # policy = jnp.array([0, 1, 0]) + # B_policy = jtu.tree_map(lambda b: b[..., policy].transpose(0, 3, 1, 2), B) - # create two B matrices, one for each action - B_1 = jnp.broadcast_to(jnp.array([[0.0, 0.75, 0.0], - [0.0, 0.25, 1.0], - [1.0, 0.0, 0.0]] - ), (2, 3, 3)) - B_2 = jnp.broadcast_to(jnp.array([[0.0, 0.25, 0.0], - [0.0, 0.75, 0.0], - [1.0, 0.0, 1.0]] - ), (2, 3, 3)) + # # for the single modality, a sequence over time of observations (one hot vectors) + # obs = [ + # jnp.broadcast_to(jnp.array([[1., 0., 0.], + # [0., 1., 0.], + # [0., 0., 1.], + # [1., 0., 0.]])[:, None], (4, 2, 3) ) + # ] + + # prior = [jnp.ones((2, 3)) / 3.] + + # A_dependencies = [list(range(len(num_states))) for _ in range(len(num_obs))] + # qs_out = mmp_jax(A, B_policy, obs, prior, A_dependencies, num_iter=16, tau=1.) + + # self.assertTrue(qs_out[0].shape[0] == obs[0].shape[0]) + + # def test_variational_message_passing(self): + + # num_states = [3] + # num_obs = [3] + + # A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.], + # [0.0, 0.0, 1.], + # [0.5, 0.5, 0.]] + # ), (2, 3, 3) )] + + # # create two B matrices, one for each action + # B_1 = jnp.broadcast_to(jnp.array([[0.0, 0.75, 0.0], + # [0.0, 0.25, 1.0], + # [1.0, 0.0, 0.0]] + # ), (2, 3, 3)) - B = [jnp.stack([B_1, B_2], axis=-1)] + # B_2 = jnp.broadcast_to(jnp.array([[0.0, 0.25, 0.0], + # [0.0, 0.75, 0.0], + # [1.0, 0.0, 1.0]] + # ), (2, 3, 3)) + + # B = [jnp.stack([B_1, B_2], axis=-1)] - # create a policy-dependent sequence of B matrices + # # create a policy-dependent sequence of B matrices - policy = jnp.array([0, 1, 0]) - B_policy = jtu.tree_map(lambda b: b[..., policy].transpose(0, 3, 1, 2), B) + # policy = jnp.array([0, 1, 0]) + # B_policy = jtu.tree_map(lambda b: b[..., policy].transpose(0, 3, 1, 2), B) - # for the single modality, a sequence over time of observations (one hot vectors) - obs = [ - jnp.broadcast_to(jnp.array([[1., 0., 0.], - [0., 1., 0.], - [0., 0., 1.], - [1., 0., 0.]])[:, None], (4, 2, 3) ) - ] + # # for the single modality, a sequence over time of observations (one hot vectors) + # obs = [ + # jnp.broadcast_to(jnp.array([[1., 0., 0.], + # [0., 1., 0.], + # [0., 0., 1.], + # [1., 0., 0.]])[:, None], (4, 2, 3) ) + # ] - prior = [jnp.ones((2, 3)) / 3.] + # prior = [jnp.ones((2, 3)) / 3.] - A_dependencies = [list(range(len(num_states))) for _ in range(len(num_obs))] - qs_out = vmp_jax(A, B_policy, obs, prior, A_dependencies, num_iter=16, tau=1.) + # A_dependencies = [list(range(len(num_states))) for _ in range(len(num_obs))] + # qs_out = vmp_jax(A, B_policy, obs, prior, A_dependencies, num_iter=16, tau=1.) - self.assertTrue(qs_out[0].shape[0] == obs[0].shape[0]) + # self.assertTrue(qs_out[0].shape[0] == obs[0].shape[0]) - def test_vmap_message_passing_across_policies(self): - - num_states = [3, 2] - num_obs = [3] - - A_tensor = jnp.stack([jnp.array([[0.5, 0.5, 0.], - [0.0, 0.0, 1.], - [0.5, 0.5, 0.]] - ), jnp.array([[1./3, 1./3, 1./3], - [1./3, 1./3, 1./3], - [1./3, 1./3, 1./3]] - )], axis=-1) - - A = [ jnp.broadcast_to(A_tensor, (2, 3, 3, 2)) ] - - # create two B matrices, one for each action - B_1 = jnp.broadcast_to(jnp.array([[0.0, 0.75, 0.0], - [0.0, 0.25, 1.0], - [1.0, 0.0, 0.0]] - ), (2, 3, 3)) + # def test_vmap_variational_message_passing_across_policies(self): + + # num_states = [3, 2] + # num_obs = [3] + + # A_tensor = jnp.stack([jnp.array([[0.5, 0.5, 0.], + # [0.0, 0.0, 1.], + # [0.5, 0.5, 0.]] + # ), jnp.array([[1./3, 1./3, 1./3], + # [1./3, 1./3, 1./3], + # [1./3, 1./3, 1./3]] + # )], axis=-1) + + # A = [ jnp.broadcast_to(A_tensor, (2, 3, 3, 2)) ] + + # # create two B matrices, one for each action + # B_1 = jnp.broadcast_to(jnp.array([[0.0, 0.75, 0.0], + # [0.0, 0.25, 1.0], + # [1.0, 0.0, 0.0]] + # ), (2, 3, 3)) - B_2 = jnp.broadcast_to(jnp.array([[0.0, 0.25, 0.0], - [0.0, 0.75, 0.0], - [1.0, 0.0, 1.0]] - ), (2, 3, 3)) + # B_2 = jnp.broadcast_to(jnp.array([[0.0, 0.25, 0.0], + # [0.0, 0.75, 0.0], + # [1.0, 0.0, 1.0]] + # ), (2, 3, 3)) - B_uncontrollable = jnp.expand_dims( - jnp.broadcast_to( - jnp.array([[1.0, 0.0], [0.0, 1.0]]), (2, 2, 2) - ), - -1 - ) - - B = [jnp.stack([B_1, B_2], axis=-1), B_uncontrollable] - - # create a policy-dependent sequence of B matrices - - policy_1 = jnp.array([ [0, 0], - [1, 0], - [1, 0] ] - ) - - policy_2 = jnp.array([ [1, 0], - [1, 0], - [1, 0] ] - ) + # B_uncontrollable = jnp.expand_dims( + # jnp.broadcast_to( + # jnp.array([[1.0, 0.0], [0.0, 1.0]]), (2, 2, 2) + # ), + # -1 + # ) + + # B = [jnp.stack([B_1, B_2], axis=-1), B_uncontrollable] + + # # create a policy-dependent sequence of B matrices + + # policy_1 = jnp.array([ [0, 0], + # [1, 0], + # [1, 0] ] + # ) + + # policy_2 = jnp.array([ [1, 0], + # [1, 0], + # [1, 0] ] + # ) - policy_3 = jnp.array([ [1, 0], - [0, 0], - [1, 0] ] - ) + # policy_3 = jnp.array([ [1, 0], + # [0, 0], + # [1, 0] ] + # ) - all_policies = [policy_1, policy_2, policy_3] - all_policies = list(jnp.stack(all_policies).transpose(2, 0, 1)) # `n_factors` lists, each with matrix of shape `(n_policies, n_time_steps)` - - # for the single modality, a sequence over time of observations (one hot vectors) - obs = [jnp.broadcast_to(jnp.array([[1., 0., 0.], - [0., 1., 0.], - [0., 0., 1.], - [1., 0., 0.]])[:, None], (4, 2, 3) )] - - prior = [jnp.ones((2, 3)) / 3., jnp.ones((2, 2)) / 2.] - - A_dependencies = [list(range(len(num_states))) for _ in range(len(num_obs))] - - ### First do VMP - def test(action_sequence): - B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) - return vmp_jax(A, B_policy, obs, prior, A_dependencies, num_iter=16, tau=1.) - qs_out = vmap(test)(all_policies) - self.assertTrue(qs_out[0].shape[1] == obs[0].shape[0]) - - ### Then do MMP - def test(action_sequence): - B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) - return mmp_jax(A, B_policy, obs, prior, A_dependencies, num_iter=16, tau=1.) - qs_out = vmap(test)(all_policies) - self.assertTrue(qs_out[0].shape[1] == obs[0].shape[0]) + # all_policies = [policy_1, policy_2, policy_3] + # all_policies = list(jnp.stack(all_policies).transpose(2, 0, 1)) # `n_factors` lists, each with matrix of shape `(n_policies, n_time_steps)` + + # # for the single modality, a sequence over time of observations (one hot vectors) + # obs = [jnp.broadcast_to(jnp.array([[1., 0., 0.], + # [0., 1., 0.], + # [0., 0., 1.], + # [1., 0., 0.]])[:, None], (4, 2, 3) )] + + # prior = [jnp.ones((2, 3)) / 3., jnp.ones((2, 2)) / 2.] + + # A_dependencies = [list(range(len(num_states))) for _ in range(len(num_obs))] + + # ### First do VMP + # def test(action_sequence): + # B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) + # return vmp_jax(A, B_policy, obs, prior, A_dependencies, num_iter=16, tau=1.) + # qs_out = vmap(test)(all_policies) + # self.assertTrue(qs_out[0].shape[1] == obs[0].shape[0]) + + # ### Then do MMP + # def test(action_sequence): + # B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) + # return mmp_jax(A, B_policy, obs, prior, A_dependencies, num_iter=16, tau=1.) + # qs_out = vmap(test)(all_policies) + # self.assertTrue(qs_out[0].shape[1] == obs[0].shape[0]) - def test_message_passing_multiple_modalities_factors(self): - - num_states_list = [ - [2, 2, 5], - [2, 2, 2], - [4, 4] - ] - - num_controls_list = [ - [2, 1, 3], - [2, 1, 2], - [1, 3] - ] - - num_obs_list = [ - [5, 10], - [4, 3, 2], - [5, 2, 6, 3] - ] - - batch_dim, T = 2, 4 # batch dimension (e.g. number of agents, parallel realizations, etc.) and time steps - n_policies = 3 - - for (num_states, num_controls, num_obs) in zip(num_states_list, num_controls_list, num_obs_list): - - # initialize arrays in numpy - A_numpy = utils.random_A_matrix(num_obs, num_states) - B_numpy = utils.random_B_matrix(num_states, num_controls) - - A = [] - for mod_i in range(len(num_obs)): - broadcast_shape = (batch_dim,) + tuple(A_numpy[mod_i].shape) - A.append(jnp.broadcast_to(A_numpy[mod_i], broadcast_shape)) + # def test_variational_message_passing_multiple_modalities_factors(self): + + # num_states_list = [ + # [2, 2, 5], + # [2, 2, 2], + # [4, 4] + # ] + + # num_controls_list = [ + # [2, 1, 3], + # [2, 1, 2], + # [1, 3] + # ] + + # num_obs_list = [ + # [5, 10], + # [4, 3, 2], + # [5, 2, 6, 3] + # ] + + # batch_dim, T = 2, 4 # batch dimension (e.g. number of agents, parallel realizations, etc.) and time steps + # n_policies = 3 + + # for (num_states, num_controls, num_obs) in zip(num_states_list, num_controls_list, num_obs_list): + + # # initialize arrays in numpy + # A_numpy = utils.random_A_matrix(num_obs, num_states) + # B_numpy = utils.random_B_matrix(num_states, num_controls) + + # A = [] + # for mod_i in range(len(num_obs)): + # broadcast_shape = (batch_dim,) + tuple(A_numpy[mod_i].shape) + # A.append(jnp.broadcast_to(A_numpy[mod_i], broadcast_shape)) - B = [] - for fac_i in range(len(num_states)): - broadcast_shape = (batch_dim,) + tuple(B_numpy[fac_i].shape) - B.append(jnp.broadcast_to(B_numpy[fac_i], broadcast_shape)) - - prior_numpy = utils.random_single_categorical(num_states) - prior = [] - for fac_i in range(len(num_states)): - broadcast_shape = (batch_dim,) + tuple(prior_numpy[fac_i].shape) - prior.append(jnp.broadcast_to(prior_numpy[fac_i], broadcast_shape)) - - # initialization observation sequences in jax - obs_seq = [] - for n_obs in num_obs: - obs_ints = np.random.randint(0, high=n_obs, size=(T,1)) - obs_array_mod_i = jnp.broadcast_to(nn.one_hot(obs_ints, num_classes=n_obs), (T, batch_dim, n_obs)) - obs_seq.append(obs_array_mod_i) - - # create random policies - policies = [] - for n_controls in num_controls: - policies.append(jnp.array(np.random.randint(0, high=n_controls, size=(n_policies, T-1)))) + # B = [] + # for fac_i in range(len(num_states)): + # broadcast_shape = (batch_dim,) + tuple(B_numpy[fac_i].shape) + # B.append(jnp.broadcast_to(B_numpy[fac_i], broadcast_shape)) + + # prior_numpy = utils.random_single_categorical(num_states) + # prior = [] + # for fac_i in range(len(num_states)): + # broadcast_shape = (batch_dim,) + tuple(prior_numpy[fac_i].shape) + # prior.append(jnp.broadcast_to(prior_numpy[fac_i], broadcast_shape)) + + # # initialization observation sequences in jax + # obs_seq = [] + # for n_obs in num_obs: + # obs_ints = np.random.randint(0, high=n_obs, size=(T,1)) + # obs_array_mod_i = jnp.broadcast_to(nn.one_hot(obs_ints, num_classes=n_obs), (T, batch_dim, n_obs)) + # obs_seq.append(obs_array_mod_i) + + # # create random policies + # policies = [] + # for n_controls in num_controls: + # policies.append(jnp.array(np.random.randint(0, high=n_controls, size=(n_policies, T-1)))) - A_dependencies = [list(range(len(num_states))) for _ in range(len(num_obs))] - ### First do VMP - def test(action_sequence): - B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) - return vmp_jax(A, B_policy, obs_seq, prior, A_dependencies, num_iter=16, tau=1.) - qs_out = vmap(test)(policies) - self.assertTrue(qs_out[0].shape[1] == obs_seq[0].shape[0]) - - ### Then do MMP - def test(action_sequence): - B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) - return mmp_jax(A, B_policy, obs_seq, prior, A_dependencies, num_iter=16, tau=1.) - qs_out = vmap(test)(policies) - self.assertTrue(qs_out[0].shape[1] == obs_seq[0].shape[0]) + # A_dependencies = [list(range(len(num_states))) for _ in range(len(num_obs))] + # ### First do VMP + # def test(action_sequence): + # B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) + # return vmp_jax(A, B_policy, obs_seq, prior, A_dependencies, num_iter=16, tau=1.) + # qs_out = vmap(test)(policies) + # self.assertTrue(qs_out[0].shape[1] == obs_seq[0].shape[0]) + + # ### Then do MMP + # def test(action_sequence): + # B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) + # return mmp_jax(A, B_policy, obs_seq, prior, A_dependencies, num_iter=16, tau=1.) + # qs_out = vmap(test)(policies) + # self.assertTrue(qs_out[0].shape[1] == obs_seq[0].shape[0]) - def test_A_dependencies_message_passing(self): - """ Test variational message passing with A dependencies """ - - num_states_list = [ - [2, 2, 5], - [2, 2, 2], - [4, 4] - ] - - num_controls_list = [ - [2, 1, 3], - [2, 1, 2], - [1, 3] - ] - - num_obs_list = [ - [5, 10], - [4, 3, 2], - [5, 2, 6, 3] - ] - - A_dependencies_list = [ - [[0, 1], [1,2]], - [[0], [1], [2]], - [[0,1], [1], [0], [1]] - ] - - batch_dim, T = 13, 4 # batch dimension (e.g. number of agents, parallel realizations, etc.) and time steps - n_policies = 3 - - for (num_states, A_dependencies, num_controls, num_obs) in zip(num_states_list, A_dependencies_list, num_controls_list, num_obs_list): + # def test_A_dependencies_variational_message_passing(self): + # """ Test variational message passing with A dependencies """ + + # num_states_list = [ + # [2, 2, 5], + # [2, 2, 2], + # [4, 4] + # ] + + # num_controls_list = [ + # [2, 1, 3], + # [2, 1, 2], + # [1, 3] + # ] + + # num_obs_list = [ + # [5, 10], + # [4, 3, 2], + # [5, 2, 6, 3] + # ] + + # A_dependencies_list = [ + # [[0, 1], [1,2]], + # [[0], [1], [2]], + # [[0,1], [1], [0], [1]] + # ] + + # batch_dim, T = 13, 4 # batch dimension (e.g. number of agents, parallel realizations, etc.) and time steps + # n_policies = 3 + + # for (num_states, A_dependencies, num_controls, num_obs) in zip(num_states_list, A_dependencies_list, num_controls_list, num_obs_list): + + # A_reduced_numpy = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_dependencies) + # A_reduced = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(A_reduced_numpy)) + + # A_full_numpy = [] + # for m, no in enumerate(num_obs): + # other_factors = list(set(range(len(num_states))) - set(A_dependencies[m])) # list of the factors that modality `m` does not depend on + + # # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` + # expanded_dims = [no] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] + # tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] + # A_full_numpy.append(np.tile(A_reduced_numpy[m].reshape(expanded_dims), tile_dims)) + + # A_full = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(A_full_numpy)) + + # B_numpy = utils.random_B_matrix(num_states, num_controls) + # B = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(B_numpy)) + + # prior_numpy = utils.random_single_categorical(num_states) + # prior = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(prior_numpy)) + + # # initialization observation sequences in jax + # obs_seq = [] + # for n_obs in num_obs: + # obs_ints = np.random.randint(0, high=n_obs, size=(T,1)) + # obs_array_mod_i = jnp.broadcast_to(nn.one_hot(obs_ints, num_classes=n_obs), (T, batch_dim, n_obs)) + # obs_seq.append(obs_array_mod_i) + + # # create random policies + # policies = [] + # for n_controls in num_controls: + # policies.append(jnp.array(np.random.randint(0, high=n_controls, size=(n_policies, T-1)))) + + # ### First do VMP + # def test_full(action_sequence): + # B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) + # dependencies_fully_connected = [list(range(len(num_states))) for _ in range(len(num_obs))] + # return vmp_jax(A_full, B_policy, obs_seq, prior, dependencies_fully_connected, num_iter=16, tau=1.) + + # def test_sparse(action_sequence): + # B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) + # return vmp_jax(A_reduced, B_policy, obs_seq, prior, A_dependencies, num_iter=16, tau=1) + + # qs_full = vmap(test_full)(policies) + # qs_reduced = vmap(test_sparse)(policies) + + # for f in range(len(qs_full)): + # self.assertTrue(jnp.allclose(qs_full[f], qs_reduced[f])) + + # def test_B_dependencies_variational_message_passing(self): + # """ Test variational message passing with B dependencies """ + + # num_states_list = [ + # [2, 2, 5], + # [2, 2, 2], + # [4, 4] + # ] + + # num_controls_list = [ + # [2, 1, 3], + # [2, 1, 2], + # [1, 3] + # ] + + # num_obs_list = [ + # [5, 10], + # [4, 3, 2], + # [5, 2, 6, 3] + # ] + + # A_dependencies_list = [ + # [[0, 1], [1,2]], + # [[0], [1], [2]], + # [[0,1], [1], [0], [1]] + # ] + + # batch_dim, T = 13, 4 # batch dimension (e.g. number of agents, parallel realizations, etc.) and time steps + # n_policies = 3 + + # for (num_states, A_dependencies, num_controls, num_obs) in zip(num_states_list, A_dependencies_list, num_controls_list, num_obs_list): - A_reduced_numpy = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_dependencies) - A_reduced = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(A_reduced_numpy)) + # A_reduced_numpy = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_dependencies) + # A_reduced = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(A_reduced_numpy)) - A_full_numpy = [] - for m, no in enumerate(num_obs): - other_factors = list(set(range(len(num_states))) - set(A_dependencies[m])) # list of the factors that modality `m` does not depend on - - # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` - expanded_dims = [no] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] - tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] - A_full_numpy.append(np.tile(A_reduced_numpy[m].reshape(expanded_dims), tile_dims)) + # A_full_numpy = [] + # for m, no in enumerate(num_obs): + # other_factors = list(set(range(len(num_states))) - set(A_dependencies[m])) # list of the factors that modality `m` does not depend on + + # # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` + # expanded_dims = [no] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] + # tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] + # A_full_numpy.append(np.tile(A_reduced_numpy[m].reshape(expanded_dims), tile_dims)) - A_full = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(A_full_numpy)) + # A_full = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(A_full_numpy)) - B_numpy = utils.random_B_matrix(num_states, num_controls) - B = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(B_numpy)) + # B_numpy = utils.random_B_matrix(num_states, num_controls) + # B = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(B_numpy)) - prior_numpy = utils.random_single_categorical(num_states) - prior = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(prior_numpy)) + # prior_numpy = utils.random_single_categorical(num_states) + # prior = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(prior_numpy)) - # initialization observation sequences in jax - obs_seq = [] - for n_obs in num_obs: - obs_ints = np.random.randint(0, high=n_obs, size=(T,1)) - obs_array_mod_i = jnp.broadcast_to(nn.one_hot(obs_ints, num_classes=n_obs), (T, batch_dim, n_obs)) - obs_seq.append(obs_array_mod_i) - - # create random policies - policies = [] - for n_controls in num_controls: - policies.append(jnp.array(np.random.randint(0, high=n_controls, size=(n_policies, T-1)))) - - ### First do VMP - def test_full(action_sequence): - B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) - dependencies_fully_connected = [list(range(len(num_states))) for _ in range(len(num_obs))] - return vmp_jax(A_full, B_policy, obs_seq, prior, dependencies_fully_connected, num_iter=16, tau=1.) + # # initialization observation sequences in jax + # obs_seq = [] + # for n_obs in num_obs: + # obs_ints = np.random.randint(0, high=n_obs, size=(T,1)) + # obs_array_mod_i = jnp.broadcast_to(nn.one_hot(obs_ints, num_classes=n_obs), (T, batch_dim, n_obs)) + # obs_seq.append(obs_array_mod_i) + + # # create random policies + # policies = [] + # for n_controls in num_controls: + # policies.append(jnp.array(np.random.randint(0, high=n_controls, size=(n_policies, T-1)))) + + # ### First do VMP + # def test_full(action_sequence): + # B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) + # dependencies_fully_connected = [list(range(len(num_states))) for _ in range(len(num_obs))] + # return vmp_jax(A_full, B_policy, obs_seq, prior, dependencies_fully_connected, num_iter=16, tau=1.) - def test_sparse(action_sequence): - B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) - return vmp_jax(A_reduced, B_policy, obs_seq, prior, A_dependencies, num_iter=16, tau=1) + # def test_sparse(action_sequence): + # B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(0, 3, 1, 2), B, action_sequence) + # return vmp_jax(A_reduced, B_policy, obs_seq, prior, A_dependencies, num_iter=16, tau=1) - qs_full = vmap(test_full)(policies) - qs_reduced = vmap(test_sparse)(policies) + # qs_full = vmap(test_full)(policies) + # qs_reduced = vmap(test_sparse)(policies) - for f in range(len(qs_full)): - self.assertTrue(jnp.allclose(qs_full[f], qs_reduced[f])) + # for f in range(len(qs_full)): + # self.assertTrue(jnp.allclose(qs_full[f], qs_reduced[f])) - def test_online_variational_filtering(self): - """ Unit test for @dimarkov's implementation of online variational filtering, also where it's conditional on actions (vmapped across policies) """ - - num_states_list = [ - [2, 2, 5], - [2, 2, 2], - [4, 4] - ] - - num_controls_list = [ - [2, 1, 3], - [2, 1, 2], - [1, 3] - ] - - num_obs_list = [ - [5, 10], - [4, 3, 2], - [5, 2, 6, 3] - ] - - A_dependencies_list = [ - [[0, 1], [1, 2]], - [[0], [1], [2]], - [[0,1], [1], [0], [1]], - ] - - batch_dim, T = 13, 4 # batch dimension (e.g. number of agents, parallel realizations, etc.) and time steps - n_policies = 3 - - for (num_states, A_dependencies, num_controls, num_obs) in zip(num_states_list, A_dependencies_list, num_controls_list, num_obs_list): + # def test_online_variational_filtering(self): + # """ Unit test for @dimarkov's implementation of online variational filtering, also where it's conditional on actions (vmapped across policies) """ + + # num_states_list = [ + # [2, 2, 5], + # [2, 2, 2], + # [4, 4] + # ] + + # num_controls_list = [ + # [2, 1, 3], + # [2, 1, 2], + # [1, 3] + # ] + + # num_obs_list = [ + # [5, 10], + # [4, 3, 2], + # [5, 2, 6, 3] + # ] + + # A_dependencies_list = [ + # [[0, 1], [1, 2]], + # [[0], [1], [2]], + # [[0,1], [1], [0], [1]], + # ] + + # batch_dim, T = 13, 4 # batch dimension (e.g. number of agents, parallel realizations, etc.) and time steps + # n_policies = 3 + + # for (num_states, A_dependencies, num_controls, num_obs) in zip(num_states_list, A_dependencies_list, num_controls_list, num_obs_list): - A_reduced_numpy = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_dependencies) - A_reduced = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(A_reduced_numpy)) + # A_reduced_numpy = utils.random_A_matrix(num_obs, num_states, A_factor_list=A_dependencies) + # A_reduced = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(A_reduced_numpy)) - A_full_numpy = [] - for m, no in enumerate(num_obs): - other_factors = list(set(range(len(num_states))) - set(A_dependencies[m])) # list of the factors that modality `m` does not depend on - - # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` - expanded_dims = [no] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] - tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] - A_full_numpy.append(np.tile(A_reduced_numpy[m].reshape(expanded_dims), tile_dims)) + # A_full_numpy = [] + # for m, no in enumerate(num_obs): + # other_factors = list(set(range(len(num_states))) - set(A_dependencies[m])) # list of the factors that modality `m` does not depend on + + # # broadcast or tile the reduced A matrix (`A_reduced`) along the dimensions of corresponding to `other_factors` + # expanded_dims = [no] + [1 if f in other_factors else ns for (f, ns) in enumerate(num_states)] + # tile_dims = [1] + [ns if f in other_factors else 1 for (f, ns) in enumerate(num_states)] + # A_full_numpy.append(np.tile(A_reduced_numpy[m].reshape(expanded_dims), tile_dims)) - A_full = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(A_full_numpy)) + # A_full = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(A_full_numpy)) - B_numpy = utils.random_B_matrix(num_states, num_controls) - B = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(B_numpy)) + # B_numpy = utils.random_B_matrix(num_states, num_controls) + # B = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(B_numpy)) - prior_numpy = utils.random_single_categorical(num_states) - prior = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(prior_numpy)) + # prior_numpy = utils.random_single_categorical(num_states) + # prior = jtu.tree_map(lambda x: jnp.broadcast_to(x, (batch_dim,) + x.shape), list(prior_numpy)) - # initialization observation sequences in jax - obs_seq = [] - for n_obs in num_obs: - obs_ints = np.random.randint(0, high=n_obs, size=(T,1)) - obs_array_mod_i = jnp.broadcast_to(nn.one_hot(obs_ints, num_classes=n_obs), (T, batch_dim, n_obs)) - obs_seq.append(obs_array_mod_i) - - # create random policies - policies = [] - for n_controls in num_controls: - policies.append(jnp.array(np.random.randint(0, high=n_controls, size=(n_policies, T-1)))) - - def test_sparse(action_sequence): - B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(3, 0, 1, 2), B, action_sequence) - qs, ps, qss = ovf_jax(obs_seq, A_reduced, B_policy, prior, A_dependencies) - return qs, ps, qss - - qs_pi_sparse, ps_pi_sparse, qss_pi_sparse = vmap(test_sparse)(policies) - - for f, (qs, ps, qss) in enumerate(zip(qs_pi_sparse, ps_pi_sparse, qss_pi_sparse)): - self.assertTrue(qs.shape == (n_policies, batch_dim, num_states[f])) - self.assertTrue(ps.shape == (n_policies, batch_dim, num_states[f])) - self.assertTrue(qss.shape == (n_policies, T, batch_dim, num_states[f], num_states[f])) - - #Note: qs/ps are of dimension [n_policies x num_agents x dim_state_f] * num_factors - #Note: qss is of dimension [n_policies x time_steps x num_agents x dim_state_f x dim_state_f] * num_factors + # # initialization observation sequences in jax + # obs_seq = [] + # for n_obs in num_obs: + # obs_ints = np.random.randint(0, high=n_obs, size=(T,1)) + # obs_array_mod_i = jnp.broadcast_to(nn.one_hot(obs_ints, num_classes=n_obs), (T, batch_dim, n_obs)) + # obs_seq.append(obs_array_mod_i) + + # # create random policies + # policies = [] + # for n_controls in num_controls: + # policies.append(jnp.array(np.random.randint(0, high=n_controls, size=(n_policies, T-1)))) + + # def test_sparse(action_sequence): + # B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(3, 0, 1, 2), B, action_sequence) + # qs, ps, qss = ovf_jax(obs_seq, A_reduced, B_policy, prior, A_dependencies) + # return qs, ps, qss + + # qs_pi_sparse, ps_pi_sparse, qss_pi_sparse = vmap(test_sparse)(policies) + + # for f, (qs, ps, qss) in enumerate(zip(qs_pi_sparse, ps_pi_sparse, qss_pi_sparse)): + # self.assertTrue(qs.shape == (n_policies, batch_dim, num_states[f])) + # self.assertTrue(ps.shape == (n_policies, batch_dim, num_states[f])) + # self.assertTrue(qss.shape == (n_policies, T, batch_dim, num_states[f], num_states[f])) + + # #Note: qs/ps are of dimension [n_policies x num_agents x dim_state_f] * num_factors + # #Note: qss is of dimension [n_policies x time_steps x num_agents x dim_state_f x dim_state_f] * num_factors - def test_full(action_sequence): - B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(3, 0, 1, 2), B, action_sequence) - dependencies_fully_connected = [list(range(len(num_states))) for _ in range(len(num_obs))] - qs, ps, qss = ovf_jax(obs_seq, A_full, B_policy, prior, dependencies_fully_connected) - return qs, ps, qss - - qs_pi_full, ps_pi_full, qss_pi_full = vmap(test_full)(policies) - - # test that the sparse and fully connected versions of OVF give the same results - for (qs_sparse, ps_sparse, qss_sparse, qs_full, ps_full, qss_full) in zip(qs_pi_sparse, ps_pi_sparse, qss_pi_sparse, qs_pi_full, ps_pi_full, qss_pi_full): - self.assertTrue(np.allclose(qs_sparse, qs_full)) - self.assertTrue(np.allclose(ps_sparse, ps_full)) - self.assertTrue(np.allclose(qss_sparse, qss_full)) + # def test_full(action_sequence): + # B_policy = jtu.tree_map(lambda b, a_idx: b[..., a_idx].transpose(3, 0, 1, 2), B, action_sequence) + # dependencies_fully_connected = [list(range(len(num_states))) for _ in range(len(num_obs))] + # qs, ps, qss = ovf_jax(obs_seq, A_full, B_policy, prior, dependencies_fully_connected) + # return qs, ps, qss + + # qs_pi_full, ps_pi_full, qss_pi_full = vmap(test_full)(policies) + + # # test that the sparse and fully connected versions of OVF give the same results + # for (qs_sparse, ps_sparse, qss_sparse, qs_full, ps_full, qss_full) in zip(qs_pi_sparse, ps_pi_sparse, qss_pi_sparse, qs_pi_full, ps_pi_full, qss_pi_full): + # self.assertTrue(np.allclose(qs_sparse, qs_full)) + # self.assertTrue(np.allclose(ps_sparse, ps_full)) + # self.assertTrue(np.allclose(qss_sparse, qss_full)) if __name__ == "__main__": unittest.main() From 575151c06565069eb684b1e4a39b7557b4788a56 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Sun, 21 Apr 2024 17:18:17 +0200 Subject: [PATCH 201/232] added A and B dependencies to compuations of parameteric inf gain --- pymdp/jax/control.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index a6bf1a50..30506d90 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -233,7 +233,7 @@ def compute_expected_utility(qo, C): return util -def calc_pA_info_gain(pA, qo, qs): +def calc_pA_info_gain(pA, qo, qs, A_dependencies): """ Compute expected Dirichlet information gain about parameters ``pA`` for a given posterior predictive distribution over observations ``qo`` and states ``qs``. @@ -256,11 +256,12 @@ def calc_pA_info_gain(pA, qo, qs): wA = jtu.tree_map(spm_wnorm, pA) wA_per_modality = jtu.tree_map(lambda wa, pa: wa * (pa > 0.), wA, pA) - pA_infogain_per_modality = jtu.tree_map(lambda wa, qo: qo.dot(factor_dot(wa, qs, keep_dims=(0,))[...,None]), wA_per_modality, qo) + fd = lambda x, i: factor_dot(x, [s for f, s in enumerate(qs) if f in A_dependencies[i]], keep_dims=(0,))[..., None] + pA_infogain_per_modality = jtu.tree_map(lambda wa, qo, m: qo.dot(fd(wa, m)), wA_per_modality, qo, list(range(len(qo)))) infogain_pA = jtu.tree_reduce(lambda x, y: x + y, pA_infogain_per_modality)[0] return infogain_pA -def calc_pB_info_gain(pB, qs_t, qs_t_minus_1): +def calc_pB_info_gain(pB, qs_t, qs_t_minus_1, B_dependencies): """ Placeholder, not implemented yet """ # """ # Compute expected Dirichlet information gain about parameters ``pB`` under a given policy @@ -359,8 +360,8 @@ def scan_body(carry, t): inductive_value = calc_inductive_value_t(qs_init, qs_next, I, epsilon=inductive_epsilon) if use_inductive else 0. - param_info_gain = calc_pA_info_gain(pA, qo, qs_next) if use_param_info_gain else 0. - param_info_gain += calc_pB_info_gain(pB, qs_next, qs) if use_param_info_gain else 0. + param_info_gain = calc_pA_info_gain(pA, qo, qs_next, A_dependencies) if use_param_info_gain else 0. + param_info_gain += calc_pB_info_gain(pB, qs_next, qs, B_dependencies) if use_param_info_gain else 0. neg_G += info_gain + utility + param_info_gain + inductive_value From 16903fff413e7fcca8798aea6002b15c92339263 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Sun, 21 Apr 2024 17:19:14 +0200 Subject: [PATCH 202/232] fixed learning updated --- pymdp/jax/agent.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 5032300a..d441f13e 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -256,12 +256,12 @@ def unique_multiactions(self): @vmap def learning(self, beliefs, outcomes, actions, **kwargs): - + agent = self if self.learn_A: o_vec_seq = jtu.tree_map(lambda o, dim: nn.one_hot(o, dim), outcomes, self.num_obs) qA = learning.update_obs_likelihood_dirichlet(self.pA, self.A, o_vec_seq, beliefs, self.A_dependencies, lr=1.) E_qA = jtu.tree_map(lambda x: maths.dirichlet_expected_value(x), qA) - agent = tree_at(lambda x: (x.A, x.pA), self, (E_qA, qA)) + agent = tree_at(lambda x: (x.A, x.pA), agent, (E_qA, qA)) if self.learn_B: actions_seq = [actions[..., i] for i in range(actions.shape[-1])] # as many elements as there are control factors, where each element is a jnp.ndarray of shape (n_timesteps, ) @@ -274,6 +274,8 @@ def learning(self, beliefs, outcomes, actions, **kwargs): I_updated = control.generate_I_matrix(self.H, E_qB, self.inductive_threshold, self.inductive_depth) else: I_updated = self.I + + agent = tree_at(lambda x: (x.B, x.pB, x.I), agent, (E_qB, qB, I_updated)) # if self.learn_C: # self.qC = learning.update_C(self.C, *args, **kwargs) @@ -290,7 +292,7 @@ def learning(self, beliefs, outcomes, actions, **kwargs): # parameters = ... # varibles = {'A': jnp.ones(5)} - agent = tree_at(lambda x: (x.A, x.pA, x.B, x.pB, x.I), self, (E_qA, qA, E_qB, qB, I_updated)) + # agent = tree_at(lambda x: (x.A, x.pA, x.B, x.pB, x.I), self, (E_qA, qA, E_qB, qB, I_updated)) return agent From 373bbfe0903eec29c8962d53f750c93752e6e690 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Mon, 22 Apr 2024 09:36:37 +0200 Subject: [PATCH 203/232] added a base environment class --- pymdp/jax/task.py | 79 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 79 insertions(+) create mode 100644 pymdp/jax/task.py diff --git a/pymdp/jax/task.py b/pymdp/jax/task.py new file mode 100644 index 00000000..f0ba1fb3 --- /dev/null +++ b/pymdp/jax/task.py @@ -0,0 +1,79 @@ +# Task environmnet +from typing import Optional, List, Dict +from jaxtyping import Array, PRNGKeyArray +from functools import partial + +from equinox import Module, field, tree_at +from jax import vmap, random as jr, tree_map as jtu +import jax.numpy as jnp + +def select_probs(positions, matrix, dependency_list, actions=None): + args = tuple(p for i, p in enumerate(positions) if i in dependency_list) + args += () if actions is None else (actions,) + + return matrix[..., *args] + +def cat_sample(key, p): + a = jnp.arange(p.shape[-1]) + if p.ndim > 1: + choice = lambda key, p: jr.choice(key, a, p=p) + keys = jr.split(key, len(p)) + return vmap(choice)(keys, p) + + return jr.choice(key, a, p=p) + +class PyMDPEnv(Module): + params: Dict + states: List[List[Array]] + dependencies: Dict = field(static=True) + + def __init__( + self, params: Dict, dependencies: Dict, init_state: List[Array] = None + ): + self.params = params + self.dependencies = dependencies + + if init_state is None: + init_state = jtu.tree_map(lambda x: jnp.argmax(x, -1), self.params["D"]) + + self.states = [init_state] + + def reset(self, key: Optional[PRNGKeyArray] = None): + if key is None: + states = [self.states[0]] + else: + probs = self.params["D"] + keys = list(jr.split(key, len(probs))) + states = [jtu.tree_map(cat_sample, keys, probs)] + + return tree_at(lambda x: x.states, self, states) + + @vmap + def step(self, key: PRNGKeyArray, actions: Optional[Array] = None): + # return a list of random observations and states + key_state, key_obs = jr.split(key) + states = self.states + if actions is not None: + actions = list(actions) + _select_probs = partial(select_probs, states[-1]) + state_probs = jtu.tree_map( + _select_probs, self.params["B"], self.dependencies["B"], actions + ) + + keys = list(jr.split(key_state, len(state_probs))) + new_states = jtu.tree_map(cat_sample, keys, state_probs) + + states.append(new_states) + + else: + new_states = states[-1] + + _select_probs = partial(select_probs, new_states) + obs_probs = jtu.tree_map( + _select_probs, self.params["A"], self.dependencies["A"] + ) + + keys = list(jr.split(key_obs, len(obs_probs))) + new_obs = jtu.tree_map(cat_sample, keys, obs_probs) + + return new_obs, tree_at(lambda x: (x.states), self, states) \ No newline at end of file From cdbdac349efd249fc66490f01d46877ef1929ff1 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Mon, 22 Apr 2024 09:37:10 +0200 Subject: [PATCH 204/232] removed unused args --- pymdp/jax/learning.py | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/pymdp/jax/learning.py b/pymdp/jax/learning.py index 5591397c..3e7039ea 100644 --- a/pymdp/jax/learning.py +++ b/pymdp/jax/learning.py @@ -8,7 +8,7 @@ from jax import vmap import jax.numpy as jnp -def update_obs_likelihood_dirichlet_m(pA_m, A_m, obs_m, qs, dependencies_m, lr=1.0): +def update_obs_likelihood_dirichlet_m(pA_m, obs_m, qs, dependencies_m, lr=1.0): """ JAX version of ``pymdp.learning.update_obs_likelihood_dirichlet_m`` """ # pA_m - parameters of the dirichlet from the prior # pA_m.shape = (no_m x num_states[k] x num_states[j] x ... x num_states[n]) where (k, j, n) are indices of the hidden state factors that are parents of modality m @@ -24,16 +24,15 @@ def update_obs_likelihood_dirichlet_m(pA_m, A_m, obs_m, qs, dependencies_m, lr=1 relevant_factors = tree_map(lambda f_idx: qs[f_idx], dependencies_m) - dfda = vmap(multidimensional_outer)([obs_m]+ relevant_factors).sum(axis=0) - qA_m = pA_m + (lr * dfda) + dfda = vmap(multidimensional_outer)([obs_m] + relevant_factors).sum(axis=0) - return qA_m + return pA_m + lr * dfda -def update_obs_likelihood_dirichlet(pA, A, obs, qs, A_dependencies, lr=1.0): +def update_obs_likelihood_dirichlet(pA, obs, qs, A_dependencies, lr=1.0): """ JAX version of ``pymdp.learning.update_obs_likelihood_dirichlet`` """ - update_A_fn = lambda pA_m, A_m, obs_m, dependencies_m: update_obs_likelihood_dirichlet_m(pA_m, A_m, obs_m, qs, dependencies_m, lr=lr) - qA = tree_map(update_A_fn, pA, A, obs, A_dependencies) + update_A_fn = lambda pA_m, obs_m, dependencies_m: update_obs_likelihood_dirichlet_m(pA_m, obs_m, qs, dependencies_m, lr=lr) + qA = tree_map(update_A_fn, pA, obs, A_dependencies) return qA From 16fe4b300ac23c536bf5bb843067128abc5c27b3 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Mon, 22 Apr 2024 09:37:39 +0200 Subject: [PATCH 205/232] removed unused args --- pymdp/jax/agent.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index d441f13e..521b2c61 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -259,7 +259,7 @@ def learning(self, beliefs, outcomes, actions, **kwargs): agent = self if self.learn_A: o_vec_seq = jtu.tree_map(lambda o, dim: nn.one_hot(o, dim), outcomes, self.num_obs) - qA = learning.update_obs_likelihood_dirichlet(self.pA, self.A, o_vec_seq, beliefs, self.A_dependencies, lr=1.) + qA = learning.update_obs_likelihood_dirichlet(self.pA, o_vec_seq, beliefs, self.A_dependencies, lr=1.) E_qA = jtu.tree_map(lambda x: maths.dirichlet_expected_value(x), qA) agent = tree_at(lambda x: (x.A, x.pA), agent, (E_qA, qA)) From 22f5519d990e79acf0bcaf588783a4ff657edfc7 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Wed, 24 Apr 2024 15:49:48 +0200 Subject: [PATCH 206/232] fixed tree_util import --- pymdp/jax/task.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pymdp/jax/task.py b/pymdp/jax/task.py index f0ba1fb3..5de0315e 100644 --- a/pymdp/jax/task.py +++ b/pymdp/jax/task.py @@ -4,7 +4,7 @@ from functools import partial from equinox import Module, field, tree_at -from jax import vmap, random as jr, tree_map as jtu +from jax import vmap, random as jr, tree_util as jtu import jax.numpy as jnp def select_probs(positions, matrix, dependency_list, actions=None): From ed533c629e19587e739bf097f79910ddb555a320 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Fri, 26 Apr 2024 13:35:03 +0200 Subject: [PATCH 207/232] added learning rate arguments to learning --- pymdp/jax/agent.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 521b2c61..6f60c3bc 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -255,18 +255,18 @@ def unique_multiactions(self): return jnp.unique(self.policies[:, 0], axis=0, size=size, fill_value=-1) @vmap - def learning(self, beliefs, outcomes, actions, **kwargs): + def learning(self, beliefs, outcomes, actions, lr_pA=1., lr_pB=1., **kwargs): agent = self if self.learn_A: o_vec_seq = jtu.tree_map(lambda o, dim: nn.one_hot(o, dim), outcomes, self.num_obs) - qA = learning.update_obs_likelihood_dirichlet(self.pA, o_vec_seq, beliefs, self.A_dependencies, lr=1.) + qA = learning.update_obs_likelihood_dirichlet(self.pA, o_vec_seq, beliefs, self.A_dependencies, lr=lr_pA) E_qA = jtu.tree_map(lambda x: maths.dirichlet_expected_value(x), qA) agent = tree_at(lambda x: (x.A, x.pA), agent, (E_qA, qA)) if self.learn_B: actions_seq = [actions[..., i] for i in range(actions.shape[-1])] # as many elements as there are control factors, where each element is a jnp.ndarray of shape (n_timesteps, ) actions_onehot = jtu.tree_map(lambda a, dim: nn.one_hot(a, dim, axis=-1), actions_seq, self.num_controls) - qB = learning.update_state_likelihood_dirichlet(self.pB, self.B, beliefs, actions_onehot, self.B_dependencies) + qB = learning.update_state_likelihood_dirichlet(self.pB, self.B, beliefs, actions_onehot, self.B_dependencies, lr=lr_pB) E_qB = jtu.tree_map(lambda x: maths.dirichlet_expected_value(x), qB) # if you have updated your beliefs about transitions, you need to re-compute the I matrix used for inductive inferenece From b5d53ca7b3890f7fc3973baa47f5b4c97d58e30f Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Fri, 26 Apr 2024 13:45:19 +0200 Subject: [PATCH 208/232] fix array comparisons to None --- pymdp/agent.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/pymdp/agent.py b/pymdp/agent.py index 01513f69..bd3712ee 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -133,14 +133,14 @@ def __init__( for m in range(self.num_modalities): factor_dims = tuple([self.num_states[f] for f in self.A_factor_list[m]]) assert self.A[m].shape[1:] == factor_dims, f"Please input an `A_factor_list` whose {m}-th indices pick out the hidden state factors that line up with lagging dimensions of A{m}..." - if self.pA != None: + if self.pA is not None: assert self.pA[m].shape[1:] == factor_dims, f"Please input an `A_factor_list` whose {m}-th indices pick out the hidden state factors that line up with lagging dimensions of pA{m}..." else: for m in range(self.num_modalities): assert max(A_factor_list[m]) <= (self.num_factors - 1), f"Check modality {m} of A_factor_list - must be consistent with `num_states` and `num_factors`..." factor_dims = tuple([self.num_states[f] for f in A_factor_list[m]]) assert self.A[m].shape[1:] == factor_dims, f"Check modality {m} of A_factor_list. It must coincide with lagging dimensions of A{m}..." - if self.pA != None: + if self.pA is not None: assert self.pA[m].shape[1:] == factor_dims, f"Check modality {m} of A_factor_list. It must coincide with lagging dimensions of pA{m}..." self.A_factor_list = A_factor_list @@ -160,14 +160,14 @@ def __init__( for f in range(self.num_factors): factor_dims = tuple([self.num_states[f] for f in self.B_factor_list[f]]) assert self.B[f].shape[1:-1] == factor_dims, f"Please input a `B_factor_list` whose {f}-th indices pick out the hidden state factors that line up with the all-but-final lagging dimensions of B{f}..." - if self.pB != None: + if self.pB is not None: assert self.pB[f].shape[1:-1] == factor_dims, f"Please input a `B_factor_list` whose {f}-th indices pick out the hidden state factors that line up with the all-but-final lagging dimensions of pB{f}..." else: for f in range(self.num_factors): assert max(B_factor_list[f]) <= (self.num_factors - 1), f"Check factor {f} of B_factor_list - must be consistent with `num_states` and `num_factors`..." factor_dims = tuple([self.num_states[f] for f in B_factor_list[f]]) assert self.B[f].shape[1:-1] == factor_dims, f"Check factor {f} of B_factor_list. It must coincide with all-but-final lagging dimensions of B{f}..." - if self.pB != None: + if self.pB is not None: assert self.pB[f].shape[1:-1] == factor_dims, f"Check factor {f} of B_factor_list. It must coincide with all-but-final lagging dimensions of pB{f}..." self.B_factor_list = B_factor_list @@ -357,10 +357,10 @@ def reset(self, init_qs=None): else: self.qs = init_qs - if self.pA != None: + if self.pA is not None: self.A = utils.norm_dist_obj_arr(self.pA) - if self.pB != None: + if self.pB is not None: self.B = utils.norm_dist_obj_arr(self.pB) return self.qs From af76d308e905d7f50d3f77f22c9f1f0ad4157d0d Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Fri, 26 Apr 2024 17:03:27 +0200 Subject: [PATCH 209/232] simplified calls to learning of B matrices --- pymdp/jax/agent.py | 8 +++++--- pymdp/jax/algos.py | 6 ++---- pymdp/jax/learning.py | 10 +++++----- 3 files changed, 12 insertions(+), 12 deletions(-) diff --git a/pymdp/jax/agent.py b/pymdp/jax/agent.py index 6f60c3bc..776a65dd 100644 --- a/pymdp/jax/agent.py +++ b/pymdp/jax/agent.py @@ -255,18 +255,20 @@ def unique_multiactions(self): return jnp.unique(self.policies[:, 0], axis=0, size=size, fill_value=-1) @vmap - def learning(self, beliefs, outcomes, actions, lr_pA=1., lr_pB=1., **kwargs): + def learning(self, beliefs_A, outcomes, actions, beliefs_B=None, lr_pA=1., lr_pB=1., **kwargs): agent = self if self.learn_A: o_vec_seq = jtu.tree_map(lambda o, dim: nn.one_hot(o, dim), outcomes, self.num_obs) - qA = learning.update_obs_likelihood_dirichlet(self.pA, o_vec_seq, beliefs, self.A_dependencies, lr=lr_pA) + qA = learning.update_obs_likelihood_dirichlet(self.pA, o_vec_seq, beliefs_A, self.A_dependencies, lr=lr_pA) E_qA = jtu.tree_map(lambda x: maths.dirichlet_expected_value(x), qA) agent = tree_at(lambda x: (x.A, x.pA), agent, (E_qA, qA)) if self.learn_B: + beliefs_B = beliefs_A if beliefs_B is None else beliefs_B actions_seq = [actions[..., i] for i in range(actions.shape[-1])] # as many elements as there are control factors, where each element is a jnp.ndarray of shape (n_timesteps, ) + assert beliefs_B[0].shape[0] == actions_seq[0].shape[0] + 1 actions_onehot = jtu.tree_map(lambda a, dim: nn.one_hot(a, dim, axis=-1), actions_seq, self.num_controls) - qB = learning.update_state_likelihood_dirichlet(self.pB, self.B, beliefs, actions_onehot, self.B_dependencies, lr=lr_pB) + qB = learning.update_state_likelihood_dirichlet(self.pB, beliefs_B, actions_onehot, self.B_dependencies, lr=lr_pB) E_qB = jtu.tree_map(lambda x: maths.dirichlet_expected_value(x), qB) # if you have updated your beliefs about transitions, you need to re-compute the I matrix used for inductive inferenece diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index 11fcee5a..fe9b2a56 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -301,8 +301,6 @@ def backward(Bs, xs): return jnp.pad(msg, ((0, 1), (0, 0))) - inv_B_deps = [[i for i, d in enumerate(B_deps) if f in d] for f in factors] - def marg(inv_deps, f): B_marg = [] for i in inv_deps: @@ -319,9 +317,9 @@ def marg(inv_deps, f): return B_marg - B_marg = jtu.tree_map(lambda f: marg(inv_B_deps[f], f), factors) - if B is not None: + inv_B_deps = [[i for i, d in enumerate(B_deps) if f in d] for f in factors] + B_marg = jtu.tree_map(lambda f: marg(inv_B_deps[f], f), factors) lnB_future = jtu.tree_map(forward, B, ln_prior, factors) lnB_past = jtu.tree_map(lambda f: backward(B_marg[f], get_deps_back(qs, inv_B_deps[f])), factors) else: diff --git a/pymdp/jax/learning.py b/pymdp/jax/learning.py index 3e7039ea..c075aab6 100644 --- a/pymdp/jax/learning.py +++ b/pymdp/jax/learning.py @@ -36,7 +36,7 @@ def update_obs_likelihood_dirichlet(pA, obs, qs, A_dependencies, lr=1.0): return qA -def update_state_likelihood_dirichlet_f(pB_f, B_f, actions_f, current_qs, qs_seq, dependencies_f, lr=1.0): +def update_state_likelihood_dirichlet_f(pB_f, actions_f, current_qs, qs_seq, dependencies_f, lr=1.0): """ JAX version of ``pymdp.learning.update_state_likelihood_dirichlet_f`` """ # pB_f - parameters of the dirichlet from the prior # pB_f.shape = (num_states[f] x num_states[f] x num_actions[f]) where f is the index of the hidden state factor @@ -52,14 +52,14 @@ def update_state_likelihood_dirichlet_f(pB_f, B_f, actions_f, current_qs, qs_seq past_qs = tree_map(lambda f_idx: qs_seq[f_idx][:-1], dependencies_f) dfdb = vmap(multidimensional_outer)([current_qs[1:]] + past_qs + [actions_f]).sum(axis=0) - qB_f = pB_f + (lr * dfdb) + qB_f = pB_f + lr * dfdb return qB_f -def update_state_likelihood_dirichlet(pB, B, beliefs, actions_onehot, B_dependencies, lr=1.0): +def update_state_likelihood_dirichlet(pB, beliefs, actions_onehot, B_dependencies, lr=1.0): - update_B_f_fn = lambda pB_f, B_f, action_f, qs_f, dependencies_f: update_state_likelihood_dirichlet_f(pB_f, B_f, action_f, qs_f, beliefs, dependencies_f, lr=lr) - qB = tree_map(update_B_f_fn, pB, B, actions_onehot, beliefs, B_dependencies) + update_B_f_fn = lambda pB_f, action_f, qs_f, dependencies_f: update_state_likelihood_dirichlet_f(pB_f, action_f, qs_f, beliefs, dependencies_f, lr=lr) + qB = tree_map(update_B_f_fn, pB, actions_onehot, beliefs, B_dependencies) return qB From a9874f10f1ebbbe38f84170776f031aa7b711673 Mon Sep 17 00:00:00 2001 From: Tim Verbelen Date: Fri, 3 May 2024 12:44:05 +0200 Subject: [PATCH 210/232] fix max --- pymdp/control.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pymdp/control.py b/pymdp/control.py index c5497964..a2379a7c 100644 --- a/pymdp/control.py +++ b/pymdp/control.py @@ -944,7 +944,7 @@ def calc_inductive_cost(qs, qs_pi, I, epsilon=1e-3): m = np.where(I[factor][:, idx] == 1)[0] # we might find no path to goal (i.e. when no goal specified) if len(m) > 0: - m = np.max(m[0]-1, 0) + m = max(m[0]-1, 0) I_m = (1-I[factor][m, :]) * np.log(epsilon) inductive_cost += I_m.dot(qs_pi[t][factor]) From 2f909ce88c3f5d5cb8a897336e1428d69dbc1db9 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Sun, 19 May 2024 15:45:28 +0200 Subject: [PATCH 211/232] fixed test failure do to missing time dimension --- test/test_learning_jax.py | 16 +++++++--------- 1 file changed, 7 insertions(+), 9 deletions(-) diff --git a/test/test_learning_jax.py b/test/test_learning_jax.py index f99c877b..cdb3b86c 100644 --- a/test/test_learning_jax.py +++ b/test/test_learning_jax.py @@ -65,14 +65,13 @@ def test_update_observation_likelihood_fullyconnected(self): qA_np_test = update_pA_numpy(pA_np, A_np, obs_np, qs_np, lr=l_rate) pA_jax = jtu.tree_map(lambda x: jnp.array(x), list(pA_np)) - A_jax = jtu.tree_map(lambda x: jnp.array(x), list(A_np)) - obs_jax = jtu.tree_map(lambda x: jnp.array(x), list(obs_np)) - qs_jax = jtu.tree_map(lambda x: jnp.array(x), list(qs_np)) + obs_jax = jtu.tree_map(lambda x: jnp.array(x)[None], list(obs_np)) + qs_jax = jtu.tree_map(lambda x: jnp.array(x)[None], list(qs_np)) - qA_jax_test = update_pA_jax(pA_jax, A_jax, obs_jax, qs_jax, A_dependencies, lr=l_rate) + qA_jax_test = update_pA_jax(pA_jax, obs_jax, qs_jax, A_dependencies, lr=l_rate) for modality, obs_dim in enumerate(num_obs): - self.assertTrue(np.allclose(qA_jax_test[modality],qA_np_test[modality])) + self.assertTrue(np.allclose(qA_jax_test[modality], qA_np_test[modality])) def test_update_observation_likelihood_factorized(self): """ @@ -120,11 +119,10 @@ def test_update_observation_likelihood_factorized(self): qA_np_test = update_pA_numpy_factorized(pA_np, A_np, obs_np, qs_np, A_dependencies, lr=l_rate) pA_jax = jtu.tree_map(lambda x: jnp.array(x), list(pA_np)) - A_jax = jtu.tree_map(lambda x: jnp.array(x), list(A_np)) - obs_jax = jtu.tree_map(lambda x: jnp.array(x), list(obs_np)) - qs_jax = jtu.tree_map(lambda x: jnp.array(x), list(qs_np)) + obs_jax = jtu.tree_map(lambda x: jnp.array(x)[None], list(obs_np)) + qs_jax = jtu.tree_map(lambda x: jnp.array(x)[None], list(qs_np)) - qA_jax_test = update_pA_jax(pA_jax, A_jax, obs_jax, qs_jax, A_dependencies, lr=l_rate) + qA_jax_test = update_pA_jax(pA_jax, obs_jax, qs_jax, A_dependencies, lr=l_rate) for modality, obs_dim in enumerate(num_obs): self.assertTrue(np.allclose(qA_jax_test[modality],qA_np_test[modality])) From 6534b4bf27f8b24b9edb92242066d4125641a183 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Sun, 19 May 2024 15:49:55 +0200 Subject: [PATCH 212/232] remove plots from test_demos --- test/test_demos.py | 100 ++++++++++++++++++++++----------------------- 1 file changed, 50 insertions(+), 50 deletions(-) diff --git a/test/test_demos.py b/test/test_demos.py index 35d98c79..f0552ea3 100644 --- a/test/test_demos.py +++ b/test/test_demos.py @@ -69,18 +69,18 @@ def test_tmaze_demo(self): '''test plotting of the observation likelihood (just plot one slice)''' A_gp = env.get_likelihood_dist() - plot_likelihood(A_gp[1][:,:,0],'Reward Right') + # plot_likelihood(A_gp[1][:,:,0],'Reward Right') '''test plotting of the transition likelihood (just plot one slice)''' B_gp = env.get_transition_dist() - plot_likelihood(B_gp[1][:,:,0],'Reward Condition Transitions') + # plot_likelihood(B_gp[1][:,:,0],'Reward Condition Transitions') A_gm = copy.deepcopy(A_gp) # make a copy of the true observation likelihood to initialize the observation model B_gm = copy.deepcopy(B_gp)# make a copy of the true transition likelihood to initialize the transition model control_fac_idx = [0] agent = Agent(A=A_gm, B=B_gm, control_fac_idx=control_fac_idx) - plot_beliefs(agent.D[0],"Beliefs about initial location") + # plot_beliefs(agent.D[0],"Beliefs about initial location") agent.C[1][1] = 3.0 # they like reward agent.C[1][2] = -3.0 # they don't like loss @@ -115,7 +115,7 @@ def test_tmaze_demo(self): self.assertEqual(obs[2], 1) # this tests that the cue observation is 'Cue Left' in case of 'Reward on Left' condition - plot_beliefs(qx[1],"Final posterior beliefs about reward condition") + # plot_beliefs(qx[1],"Final posterior beliefs about reward condition") def test_tmaze_learning_demo(self): """ @@ -206,7 +206,7 @@ def test_gridworld_genmodel_construction(self): labels = [state_mapping[i] for i in range(A.shape[1])] - plot_likelihood(A) + # plot_likelihood(A) P = {} dim = 3 @@ -240,18 +240,18 @@ def test_gridworld_genmodel_construction(self): self.assertTrue(B.shape[0] == 9) - fig, axes = plt.subplots(2,3, figsize = (15,8)) - a = list(actions.keys()) - count = 0 - for i in range(dim-1): - for j in range(dim): - if count >= 5: - break - g = sns.heatmap(B[:,:,count], cmap = "OrRd", linewidth = 2.5, cbar = False, ax = axes[i,j], xticklabels=labels, yticklabels=labels) - g.set_title(a[count]) - count +=1 - fig.delaxes(axes.flatten()[5]) - plt.tight_layout() + # fig, axes = plt.subplots(2,3, figsize = (15,8)) + # a = list(actions.keys()) + # count = 0 + # for i in range(dim-1): + # for j in range(dim): + # if count >= 5: + # break + # g = sns.heatmap(B[:,:,count], cmap = "OrRd", linewidth = 2.5, cbar = False, ax = axes[i,j], xticklabels=labels, yticklabels=labels) + # g.set_title(a[count]) + # count +=1 + # fig.delaxes(axes.flatten()[5]) + # plt.tight_layout() def test_gridworld_activeinference(self): """ @@ -266,38 +266,38 @@ def test_gridworld_activeinference(self): labels = [state_mapping[i] for i in range(A.shape[1])] - def plot_empirical_prior(B): - fig, axes = plt.subplots(3,2, figsize=(8, 10)) - actions = ['UP', 'RIGHT', 'DOWN', 'LEFT', 'STAY'] - count = 0 - for i in range(3): - for j in range(2): - if count >= 5: - break + # def plot_empirical_prior(B): + # fig, axes = plt.subplots(3,2, figsize=(8, 10)) + # actions = ['UP', 'RIGHT', 'DOWN', 'LEFT', 'STAY'] + # count = 0 + # for i in range(3): + # for j in range(2): + # if count >= 5: + # break - g = sns.heatmap(B[:,:,count], cmap="OrRd", linewidth=2.5, cbar=False, ax=axes[i,j]) + # g = sns.heatmap(B[:,:,count], cmap="OrRd", linewidth=2.5, cbar=False, ax=axes[i,j]) - g.set_title(actions[count]) - count += 1 - fig.delaxes(axes.flatten()[5]) - plt.tight_layout() + # g.set_title(actions[count]) + # count += 1 + # fig.delaxes(axes.flatten()[5]) + # plt.tight_layout() - def plot_transition(B): - fig, axes = plt.subplots(2,3, figsize = (15,8)) - a = list(actions.keys()) - count = 0 - for i in range(dim-1): - for j in range(dim): - if count >= 5: - break - g = sns.heatmap(B[:,:,count], cmap = "OrRd", linewidth = 2.5, cbar = False, ax = axes[i,j], xticklabels=labels, yticklabels=labels) - g.set_title(a[count]) - count +=1 - fig.delaxes(axes.flatten()[5]) - plt.tight_layout() + # def plot_transition(B): + # fig, axes = plt.subplots(2,3, figsize = (15,8)) + # a = list(actions.keys()) + # count = 0 + # for i in range(dim-1): + # for j in range(dim): + # if count >= 5: + # break + # g = sns.heatmap(B[:,:,count], cmap = "OrRd", linewidth = 2.5, cbar = False, ax = axes[i,j], xticklabels=labels, yticklabels=labels) + # g.set_title(a[count]) + # count +=1 + # fig.delaxes(axes.flatten()[5]) + # plt.tight_layout() A = np.eye(9) - plot_likelihood(A) + # plot_likelihood(A) P = {} dim = 3 @@ -330,7 +330,7 @@ def plot_transition(B): ns = int(P[s][a]) B[ns, s, a] = 1 - plot_transition(B) + # plot_transition(B) class GridWorldEnv(): @@ -362,18 +362,18 @@ def compute_free_energy(q,A, B): def softmax(x): return np.exp(x) / np.sum(np.exp(x)) - def perform_inference(likelihood, prior): - return softmax(log_stable(likelihood) + log_stable(prior)) + # def perform_inference(likelihood, prior): + # return softmax(log_stable(likelihood) + log_stable(prior)) Qs = np.ones(9) * 1/9 - plot_beliefs(Qs) + # plot_beliefs(Qs) REWARD_LOCATION = 7 reward_state = state_mapping[REWARD_LOCATION] C = np.zeros(num_states) C[REWARD_LOCATION] = 1. - plot_beliefs(C) + # plot_beliefs(C) def evaluate_policy(policy, Qs, A, B, C): # initialize expected free energy at 0 @@ -466,7 +466,7 @@ def infer_action(Qs, A, B, C, n_actions, policies): Qs = maths.softmax(log_stable(likelihood) + log_stable(prior)) - plot_beliefs(Qs, "Beliefs (Qs) at time {}".format(t)) + # plot_beliefs(Qs, "Beliefs (Qs) at time {}".format(t)) # self.assertEqual(np.argmax(Qs), REWARD_LOCATION) # @NOTE: This is not always true due to stochastic samplign!!! self.assertEqual(Qs.shape[0], B.shape[0]) From 89882ffac7e1639e7a56d6161c2acb21f0d64a96 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Sun, 19 May 2024 16:53:43 +0200 Subject: [PATCH 213/232] updated comments and fixed message passing test --- pymdp/jax/algos.py | 2 +- pymdp/jax/inference.py | 4 +- test/test_message_passing_jax.py | 74 +++++++++++++------------------- 3 files changed, 33 insertions(+), 47 deletions(-) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index fe9b2a56..59301f30 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -118,7 +118,7 @@ def get_log_likelihood(obs_t, A): # mapping over time dimension of obs array log_likelihoods = vmap(get_log_likelihood, (0, None))(obs, A) # this gives a sequence of log-likelihoods (one for each `t`) - + # log marginals -> $\ln(q(s_t))$ for all time steps and factors ln_qs = jtu.tree_map( lambda p: jnp.broadcast_to(jnp.zeros_like(p), (T,) + p.shape), prior) diff --git a/pymdp/jax/inference.py b/pymdp/jax/inference.py index cd5c8132..790ae354 100644 --- a/pymdp/jax/inference.py +++ b/pymdp/jax/inference.py @@ -30,7 +30,9 @@ def update_posterior_states( nf = len(B) actions_tree = [past_actions[:, i] for i in range(nf)] - B = jtu.tree_map(lambda b, a_idx: jnp.moveaxis(b[..., a_idx], -1, 0), B, actions_tree) # this needs to be changed in case of `B_dependencies` because we have more than 3 dims in the B tensors + # move time steps to the leading axis (leftmost) + # this assumes that a policy is always specified as the rightmost axis of Bs + B = jtu.tree_map(lambda b, a_idx: jnp.moveaxis(b[..., a_idx], -1, 0), B, actions_tree) else: B = None diff --git a/test/test_message_passing_jax.py b/test/test_message_passing_jax.py index 6332548c..e40c637f 100644 --- a/test/test_message_passing_jax.py +++ b/test/test_message_passing_jax.py @@ -7,6 +7,7 @@ import os import unittest +from functools import partial import numpy as np import jax.numpy as jnp @@ -195,66 +196,49 @@ def test_marginal_message_passing(self): num_states_list, num_obs_list, num_controls_list, A_dependencies_list, B_dependencies_list = gm_params['ns_list'], gm_params['no_list'], gm_params['nc_list'], \ gm_params['A_deps_list'], gm_params['B_deps_list'] - batch_size = 3 + batch_size = 10 n_timesteps = 4 - for num_states, num_obs, A_deps, B_deps in zip(num_states_list, num_obs_list, A_dependencies_list, B_dependencies_list): + for num_states, num_obs, num_controls, A_deps, B_deps in zip(num_states_list, num_obs_list, num_controls_list, A_dependencies_list, B_dependencies_list): # create a version of a_deps_i where each sub-list is sorted prior = [jr.dirichlet(key, alpha=jnp.ones((ns,)), shape=(batch_size,)) for ns, key in zip(num_states, jr.split(jr.PRNGKey(0), len(num_states)))] - obs = [jr.categorical(key, p=jnp.ones(no) / no, shape=(n_timesteps,batch_size)) for no, key in zip(num_obs, jr.split(jr.PRNGKey(1), len(num_obs)))] - obs = jtu.tree_map(lambda x: nn.one_hot(x, num_classes=x.shape[-1]), obs) + obs = [jr.categorical(key, logits=jnp.zeros(no), shape=(n_timesteps,batch_size)) for no, key in zip(num_obs, jr.split(jr.PRNGKey(1), len(num_obs)))] + obs = jtu.tree_map(lambda x, no: nn.one_hot(x, num_classes=no), obs, num_obs) A_sub_shapes = [ [ns for f, ns in enumerate(num_states) if f in a_deps_i] for a_deps_i in A_deps ] A_sampling_keys = jr.split(jr.PRNGKey(2), len(num_obs)) - A = [jr.dirichlet(key, alpha=jnp.ones(no), shape=factor_shapes) for no, factor_shapes, key in zip(num_obs, A_sub_shapes, A_sampling_keys)] + A = [jr.dirichlet(key, alpha=jnp.ones(no) / no, shape=factor_shapes) for no, factor_shapes, key in zip(num_obs, A_sub_shapes, A_sampling_keys)] A = jtu.tree_map(lambda a: jnp.moveaxis(a, -1, 0), A) # move observations into leading dimensions - A = jtu.tree_map(lambda a: jnp.broadcast_to(a, (batch_size,) + x.shape), A) + A = jtu.tree_map(lambda a: jnp.broadcast_to(a, (batch_size,) + a.shape), A) B_sub_shapes = [ [ns for f, ns in enumerate(num_states) if f in b_deps_i] + [nc] for nc, b_deps_i in zip(num_controls, B_deps) ] B_sampling_keys = jr.split(jr.PRNGKey(3), len(num_states)) - B = [jr.dirichlet(key, alpha=jnp.ones(ns), shape=factor_shapes) for ns, factor_shapes, key in zip(num_states, B_sub_shapes, B_sampling_keys)] - B = jtu.tree_map(lambda b: jnp.moveaxis(b, (-2, -1), (0, 1)), B) # move s_{t+1} and actions to first two leading dimensions - B = jtu.tree_map(lambda b: jnp.broadcast_to(b, (batch_size,) + x.shape), B) - - # A = [ jnp.broadcast_to(jnp.array([[0.5, 0.5, 0.], - # [0.0, 0.0, 1.], - # [0.5, 0.5, 0.]] - # ), (2, 3, 3) )] - - # # create two B matrices, one for each action - # B_1 = jnp.broadcast_to(jnp.array([[0.0, 0.75, 0.0], - # [0.0, 0.25, 1.0], - # [1.0, 0.0, 0.0]] - # ), (2, 3, 3)) - - # B_2 = jnp.broadcast_to(jnp.array([[0.0, 0.25, 0.0], - # [0.0, 0.75, 0.0], - # [1.0, 0.0, 1.0]] - # ), (2, 3, 3)) - - # B = [jnp.stack([B_1, B_2], axis=-1)] # actions are in the last dimension + B = [jr.dirichlet(key, alpha=jnp.ones(ns) / ns, shape=factor_shapes) for ns, factor_shapes, key in zip(num_states, B_sub_shapes, B_sampling_keys)] + B = jtu.tree_map(lambda b: jnp.moveaxis(b, -2, -1), B) # move u_t to the rightmost axis of the array + B = jtu.tree_map(lambda b: jnp.moveaxis(b, -2, 0), B) # s_t+1 to the leading dimension of the array + B = jtu.tree_map(lambda b: jnp.broadcast_to(b, (batch_size,) + b.shape), B) # # create a policy-dependent sequence of B matrices, but now we store the sequence dimension (action indices) in the first dimension (0th dimension is still batch dimension) - # policy = jnp.array([0, 1, 0]) - # B_policy = jtu.tree_map(lambda b: b[..., policy].transpose(0, 3, 1, 2), B) - - - # # for the single modality, a sequence over time of observations (one hot vectors) - # obs = [ - # jnp.broadcast_to(jnp.array([[1., 0., 0.], - # [0., 1., 0.], - # [0., 0., 1.], - # [1., 0., 0.]])[:, None], (4, 2, 3) ) - # ] - - # prior = [jnp.ones((2, 3)) / 3.] - - # A_dependencies = [list(range(len(num_states))) for _ in range(len(num_obs))] - # qs_out = mmp_jax(A, B_policy, obs, prior, A_dependencies, num_iter=16, tau=1.) - - # self.assertTrue(qs_out[0].shape[0] == obs[0].shape[0]) + policy = [] + key = jr.PRNGKey(11) + for nc in num_controls: + key, k = jr.split(key) + policy.append( jr.choice(k, jnp.arange(nc), shape=(n_timesteps - 1, 1)) ) + + policy = jnp.concatenate(policy, -1) + nf = len(B) + actions_tree = [policy[:, i] for i in range(nf)] + B_seq = jtu.tree_map(lambda b, a_idx: jnp.moveaxis(b[..., a_idx], -1, 0), B, actions_tree) + + mmp = vmap( + partial(mmp_jax, num_iter=16, tau=1.0), + in_axes=(0, 1, 1, 0, None, None) + ) + qs_out = mmp(A, B_seq, obs, prior, A_deps, B_deps) + + self.assertTrue(qs_out[0].shape[0] == obs[0].shape[1]) # def test_variational_message_passing(self): From b8b131e016a7d7cf72efd1fee268a37af1952887 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Sun, 19 May 2024 17:53:44 +0200 Subject: [PATCH 214/232] fixed initial message specification for mmp and t=1 --- pymdp/jax/algos.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pymdp/jax/algos.py b/pymdp/jax/algos.py index 59301f30..754d10ce 100644 --- a/pymdp/jax/algos.py +++ b/pymdp/jax/algos.py @@ -132,7 +132,7 @@ def scan_fn(carry, iter): ln_qs = jtu.tree_map(log_stable, qs) # messages from future $m_+(s_t)$ and past $m_-(s_t)$ for all time steps and factors. For t = T we have that $m_+(s_T) = 0$ - + lnB_past, lnB_future = get_messages(ln_B, B, qs, ln_prior, B_dependencies) mgds = jtu.Partial(mirror_gradient_descent_step, tau) @@ -323,7 +323,7 @@ def marg(inv_deps, f): lnB_future = jtu.tree_map(forward, B, ln_prior, factors) lnB_past = jtu.tree_map(lambda f: backward(B_marg[f], get_deps_back(qs, inv_B_deps[f])), factors) else: - lnB_future = jtu.tree_map(lambda x: 0., qs) + lnB_future = jtu.tree_map(lambda x: jnp.expand_dims(x, 0), ln_prior) lnB_past = jtu.tree_map(lambda x: 0., qs) return lnB_future, lnB_past From dd5f6c164af9dae30776ce8120bb219b28970926 Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Fri, 31 May 2024 13:48:57 +0200 Subject: [PATCH 215/232] added pB info gain computations and corrected the sign of info gain term comming from parameters --- pymdp/jax/control.py | 90 +++++++++++++++++--------------------------- 1 file changed, 34 insertions(+), 56 deletions(-) diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index 30506d90..1e3736b0 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -254,63 +254,41 @@ def calc_pA_info_gain(pA, qo, qs, A_dependencies): Surprise (about Dirichlet parameters) expected for the pair of posterior predictive distributions ``qo`` and ``qs`` """ - wA = jtu.tree_map(spm_wnorm, pA) - wA_per_modality = jtu.tree_map(lambda wa, pa: wa * (pa > 0.), wA, pA) + wA = lambda pa: spm_wnorm(pa) * (pa > 0.) fd = lambda x, i: factor_dot(x, [s for f, s in enumerate(qs) if f in A_dependencies[i]], keep_dims=(0,))[..., None] - pA_infogain_per_modality = jtu.tree_map(lambda wa, qo, m: qo.dot(fd(wa, m)), wA_per_modality, qo, list(range(len(qo)))) + pA_infogain_per_modality = jtu.tree_map( + lambda pa, qo, m: qo.dot(fd( wA(pa), m)), pA, qo, list(range(len(qo))) + ) infogain_pA = jtu.tree_reduce(lambda x, y: x + y, pA_infogain_per_modality)[0] return infogain_pA -def calc_pB_info_gain(pB, qs_t, qs_t_minus_1, B_dependencies): - """ Placeholder, not implemented yet """ - # """ - # Compute expected Dirichlet information gain about parameters ``pB`` under a given policy - - # Parameters - # ---------- - # pB: ``numpy.ndarray`` of dtype object - # Dirichlet parameters over transition model (same shape as ``B``) - # qs_pi: ``list`` of ``numpy.ndarray`` of dtype object - # Predictive posterior beliefs over hidden states expected under the policy, where ``qs_pi[t]`` stores the beliefs about - # hidden states expected under the policy at time ``t`` - # qs_prev: ``numpy.ndarray`` of dtype object - # Posterior over hidden states at beginning of trajectory (before receiving observations) - # policy: 2D ``numpy.ndarray`` - # Array that stores actions entailed by a policy over time. Shape is ``(num_timesteps, num_factors)`` where ``num_timesteps`` is the temporal - # depth of the policy and ``num_factors`` is the number of control factors. +def calc_pB_info_gain(pB, qs_t, qs_t_minus_1, B_dependencies, u_t_minus_1): + """ + Compute expected Dirichlet information gain about parameters ``pB`` under a given policy + + Parameters + ---------- + pB: ``Array`` of dtype object + Dirichlet parameters over transition model (same shape as ``B``) + qs_t: ``list`` of ``Array`` of dtype object + Predictive posterior beliefs over hidden states expected under the policy at time ``t`` + qs_t_minus_1: ``list`` of ``Array`` of dtype object + Posterior over hidden states at time ``t-1`` (before receiving observations) + u_t: "Array" + Actions in time step t-1 + + Returns + ------- + infogain_pB: float + Surprise (about Dirichlet parameters) expected under the policy in question + """ - # Returns - # ------- - # infogain_pB: float - # Surprise (about dirichlet parameters) expected under the policy in question - # """ - - # n_steps = len(qs_pi) - - # num_factors = len(pB) - # wB = utils.obj_array(num_factors) - # for factor, pB_f in enumerate(pB): - # wB[factor] = spm_wnorm(pB_f) - - # pB_infogain = 0 - - # for t in range(n_steps): - # # the 'past posterior' used for the information gain about pB here is the posterior - # # over expected states at the timestep previous to the one under consideration - # # if we're on the first timestep, we just use the latest posterior in the - # # entire action-perception cycle as the previous posterior - # if t == 0: - # previous_qs = qs_prev - # # otherwise, we use the expected states for the timestep previous to the timestep under consideration - # else: - # previous_qs = qs_pi[t - 1] - - # # get the list of action-indices for the current timestep - # policy_t = policy[t, :] - # for factor, a_i in enumerate(policy_t): - # wB_factor_t = wB[factor][:, :, int(a_i)] * (pB[factor][:, :, int(a_i)] > 0).astype("float") - # pB_infogain -= qs_pi[t][factor].dot(wB_factor_t.dot(previous_qs[factor])) - return 0. + wB = lambda pb: spm_wnorm(pb) * (pb > 0.) + fd = lambda x, i: factor_dot(x, [s for f, s in enumerate(qs_t_minus_1) if f in B_dependencies[i]], keep_dims=(0,))[..., None] + + pB_infogain_per_factor = jtu.tree_map(lambda pb, qs, f: qs.dot(fd(wB(pb[..., u_t_minus_1[f]]), f)), pB, qs_t, list(range(len(qs_t)))) + infogain_pB = jtu.tree_reduce(lambda x, y: x + y, pB_infogain_per_factor)[0] + return infogain_pB def compute_G_policy(qs_init, A, B, C, pA, pB, A_dependencies, B_dependencies, policy_i, use_utility=True, use_states_info_gain=True, use_param_info_gain=False): """ Write a version of compute_G_policy that does the same computations as `compute_G_policy` but using `lax.scan` instead of a for loop. """ @@ -328,7 +306,7 @@ def scan_body(carry, t): utility = compute_expected_utility(qo, C) if use_utility else 0. param_info_gain = calc_pA_info_gain(pA, qo, qs_next) if use_param_info_gain else 0. - param_info_gain += calc_pB_info_gain(pB, qs_next, qs) if use_param_info_gain else 0. + param_info_gain += calc_pB_info_gain(pB, qs_next, qs, policy_i[t]) if use_param_info_gain else 0. neg_G += info_gain + utility + param_info_gain @@ -361,16 +339,16 @@ def scan_body(carry, t): inductive_value = calc_inductive_value_t(qs_init, qs_next, I, epsilon=inductive_epsilon) if use_inductive else 0. param_info_gain = calc_pA_info_gain(pA, qo, qs_next, A_dependencies) if use_param_info_gain else 0. - param_info_gain += calc_pB_info_gain(pB, qs_next, qs, B_dependencies) if use_param_info_gain else 0. + param_info_gain += calc_pB_info_gain(pB, qs_next, qs, B_dependencies, policy_i[t]) if use_param_info_gain else 0. - neg_G += info_gain + utility + param_info_gain + inductive_value + neg_G += info_gain + utility - param_info_gain + inductive_value return (qs_next, neg_G), None qs = qs_init neg_G = 0. final_state, _ = lax.scan(scan_body, (qs, neg_G), jnp.arange(policy_i.shape[0])) - qs_final, neg_G = final_state + _, neg_G = final_state return neg_G def update_posterior_policies_inductive(policy_matrix, qs_init, A, B, C, E, pA, pB, A_dependencies, B_dependencies, I, gamma=16.0, inductive_epsilon=1e-3, use_utility=True, use_states_info_gain=True, use_param_info_gain=False, use_inductive=True): From d803236a46a290beebd8d2db3c0524ed743e927c Mon Sep 17 00:00:00 2001 From: dimarkov <5038100+dimarkov@users.noreply.github.com> Date: Fri, 31 May 2024 13:53:21 +0200 Subject: [PATCH 216/232] updated docstring --- pymdp/jax/control.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index 1e3736b0..1f642aa8 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -274,8 +274,8 @@ def calc_pB_info_gain(pB, qs_t, qs_t_minus_1, B_dependencies, u_t_minus_1): Predictive posterior beliefs over hidden states expected under the policy at time ``t`` qs_t_minus_1: ``list`` of ``Array`` of dtype object Posterior over hidden states at time ``t-1`` (before receiving observations) - u_t: "Array" - Actions in time step t-1 + u_t_minus_1: "Array" + Actions in time step t-1 for each factor Returns ------- From 84f4479e9d3182a6afa29261506ddab4987382dd Mon Sep 17 00:00:00 2001 From: Dimitrije Markovic <5038100+dimarkov@users.noreply.github.com> Date: Wed, 5 Jun 2024 09:51:50 +0200 Subject: [PATCH 217/232] use xlogy from scipy for computing entorpy terms --- pymdp/jax/control.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index 1f642aa8..af71e94a 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -8,6 +8,7 @@ import jax.tree_util as jtu from typing import List, Tuple, Optional from functools import partial +from jax.scipy.special import xlogy from jax import lax, jit, vmap, nn from jax import random as jr from itertools import chain @@ -202,8 +203,10 @@ def compute_info_gain(qs, qo, A, A_dependencies): """ def compute_info_gain_for_modality(qo_m, A_m, m): - H_qo = - (qo_m * log_stable(qo_m)).sum() - H_A_m = - (A_m * log_stable(A_m)).sum(0) + H_qo = - xlogy(qo_m, qo_m).sum() + # H_qo = - (qo_m * log_stable(qo_m)).sum() + H_A_m = - xlogy(A_m, A_m).sum(0) + # H_A_m = - (A_m * log_stable(A_m)).sum(0) deps = A_dependencies[m] relevant_factors = [qs[idx] for idx in deps] qs_H_A_m = factor_dot(H_A_m, relevant_factors) From fb2c6c8513683a616cba2e5aaeb380a44432b967 Mon Sep 17 00:00:00 2001 From: Dimitrije Markovic <5038100+dimarkov@users.noreply.github.com> Date: Wed, 5 Jun 2024 11:07:42 +0200 Subject: [PATCH 218/232] fix shapes in spm_cross when one component has only a singleton dimension --- pymdp/maths.py | 11 ++++------- test/test_control_jax.py | 2 +- 2 files changed, 5 insertions(+), 8 deletions(-) diff --git a/pymdp/maths.py b/pymdp/maths.py index 6f2fd3b8..59904be5 100644 --- a/pymdp/maths.py +++ b/pymdp/maths.py @@ -205,12 +205,9 @@ def spm_cross(x, y=None, *args): if y is not None and utils.is_obj_array(y): y = spm_cross(*list(y)) - reshape_dims = tuple(list(x.shape) + list(np.ones(y.ndim, dtype=int))) - A = x.reshape(reshape_dims) - - reshape_dims = tuple(list(np.ones(x.ndim, dtype=int)) + list(y.shape)) - B = y.reshape(reshape_dims) - z = np.squeeze(A * B) + A = np.expand_dims(x, tuple(range(-y.ndim, 0))) + B = np.expand_dims(y, tuple(range(x.ndim))) + z = A * B for x in args: z = spm_cross(z, x) @@ -534,7 +531,7 @@ def spm_MDP_G(A, x): for modality_idx, A_m in enumerate(A): index_vector = [slice(0, A_m.shape[0])] + list(i) po = spm_cross(po, A_m[tuple(index_vector)]) - + po = po.ravel() qo += qx[tuple(i)] * po G += qx[tuple(i)] * po.dot(np.log(po + np.exp(-16))) diff --git a/test/test_control_jax.py b/test/test_control_jax.py index 1d767343..75de6912 100644 --- a/test/test_control_jax.py +++ b/test/test_control_jax.py @@ -137,7 +137,7 @@ def test_info_gain_factorized(self): info_gain = ctl_jax.compute_info_gain(qs_jax, qo, A_jax, A_deps) info_gain_validation = ctl_np.calc_states_info_gain_factorized(A_np, [qs_numpy], A_deps) - self.assertTrue(np.allclose(info_gain, info_gain_validation)) + self.assertTrue(np.allclose(info_gain, info_gain_validation, atol=1e-5)) if __name__ == "__main__": From 65e11a737b21222c25a35205fcb707183de20ff0 Mon Sep 17 00:00:00 2001 From: conorheins Date: Wed, 5 Jun 2024 11:13:55 +0200 Subject: [PATCH 219/232] fixed assertion to allclose instead of exact equality in test_control.py unit tests for `test_get_expected_stats_interactions_{X}_factor` --- test/test_control.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/test_control.py b/test/test_control.py index 6cc8405f..468af7d0 100644 --- a/test/test_control.py +++ b/test/test_control.py @@ -116,7 +116,7 @@ def test_get_expected_states_interactions_single_factor(self): qs_pi_0 = control.get_expected_states_interactions(qs, B, B_factor_list, policies[0]) - self.assertTrue((qs_pi_0[0][0] == B[0][:,:,policies[0][0,0]].dot(qs[0])).all()) + self.assertTrue(np.allclose(qs_pi_0[0][0], B[0][:,:,policies[0][0,0]].dot(qs[0]))) def test_get_expected_states_interactions_multi_factor(self): """ @@ -136,7 +136,7 @@ def test_get_expected_states_interactions_multi_factor(self): qs_pi_0 = control.get_expected_states_interactions(qs, B, B_factor_list, policies[0]) - self.assertTrue((qs_pi_0[0][0] == B[0][:,:,policies[0][0,0]].dot(qs[0])).all()) + self.assertTrue(np.allclose(qs_pi_0[0][0], B[0][:,:,policies[0][0,0]].dot(qs[0]))) qs_next_validation = (B[1][..., policies[0][0,1]] * maths.spm_cross(qs)[None,...]).sum(axis=(1,2)) # how to compute equivalent of `spm_dot(B[...,past_action], qs)` self.assertTrue(np.allclose(qs_pi_0[0][1], qs_next_validation)) From 09b5d18755b2c3d3460dc2c8d96157610e84388d Mon Sep 17 00:00:00 2001 From: Dimitrije Markovic <5038100+dimarkov@users.noreply.github.com> Date: Wed, 5 Jun 2024 11:36:27 +0200 Subject: [PATCH 220/232] remove pandas and stubs that generate excel files --- pymdp/utils.py | 121 ----------------------------------------------- requirements.txt | 1 - 2 files changed, 122 deletions(-) diff --git a/pymdp/utils.py b/pymdp/utils.py index fa6da602..6842da09 100644 --- a/pymdp/utils.py +++ b/pymdp/utils.py @@ -484,127 +484,6 @@ def construct_full_a(A_reduced, original_factor_idx, num_states): return A -def create_A_matrix_stub(model_labels): - - dimensions = get_model_dimensions_from_labels(model_labels) - - obs_labels, state_labels = model_labels['observations'], model_labels['states'] - - state_combinations = pd.MultiIndex.from_product(list(state_labels.values()), names=list(state_labels.keys())) - num_rows = sum(dimensions.num_observations) - - cell_values = np.zeros((num_rows, len(state_combinations))) - - obs_combinations = [] - for modality in obs_labels.keys(): - levels_to_combine = [[modality]] + [obs_labels[modality]] - obs_combinations += list(itertools.product(*levels_to_combine)) - - - obs_combinations = pd.MultiIndex.from_tuples(obs_combinations, names = ["Modality", "Level"]) - - A_matrix = pd.DataFrame(cell_values, index = obs_combinations, columns=state_combinations) - - return A_matrix - -def create_B_matrix_stubs(model_labels): - - dimensions = get_model_dimensions_from_labels(model_labels) - - state_labels = model_labels['states'] - action_labels = model_labels['actions'] - - B_matrices = {} - - for f_idx, factor in enumerate(state_labels.keys()): - - control_fac_name = list(action_labels)[f_idx] - factor_list = [state_labels[factor]] + [action_labels[control_fac_name]] - - prev_state_action_combos = pd.MultiIndex.from_product(factor_list, names=[factor, list(action_labels.keys())[f_idx]]) - - num_state_action_combos = dimensions.num_states[f_idx] * dimensions.num_controls[f_idx] - - num_rows = dimensions.num_states[f_idx] - - cell_values = np.zeros((num_rows, num_state_action_combos)) - - next_state_list = state_labels[factor] - - B_matrix_f = pd.DataFrame(cell_values, index = next_state_list, columns=prev_state_action_combos) - - B_matrices[factor] = B_matrix_f - - return B_matrices - -def read_A_matrix(path, num_hidden_state_factors): - raw_table = pd.read_excel(path, header=None) - level_counts = { - "index": raw_table.iloc[0, :].dropna().index[0] + 1, - "header": raw_table.iloc[0, :].dropna().index[0] + num_hidden_state_factors - 1, - } - return pd.read_excel( - path, - index_col=list(range(level_counts["index"])), - header=list(range(level_counts["header"])) - ).astype(np.float64) - -def read_B_matrices(path): - - all_sheets = pd.read_excel(path, sheet_name = None, header=None) - - level_counts = {} - for sheet_name, raw_table in all_sheets.items(): - - level_counts[sheet_name] = { - "index": raw_table.iloc[0, :].dropna().index[0]+1, - "header": raw_table.iloc[0, :].dropna().index[0]+2, - } - - stub_dict = {} - for sheet_name, level_counts_sheet in level_counts.items(): - sheet_f = pd.read_excel( - path, - sheet_name = sheet_name, - index_col=list(range(level_counts_sheet["index"])), - header=list(range(level_counts_sheet["header"])) - ).astype(np.float64) - stub_dict[sheet_name] = sheet_f - - return stub_dict - -def convert_A_stub_to_ndarray(A_stub, model_labels): - """ - This function converts a multi-index pandas dataframe `A_stub` into an object array of different - A matrices, one per observation modality. - """ - dimensions = get_model_dimensions_from_labels(model_labels) - - A = obj_array(dimensions.num_observation_modalities) - - for g, modality_name in enumerate(model_labels['observations'].keys()): - A[g] = A_stub.loc[modality_name].to_numpy().reshape(dimensions.num_observations[g], *dimensions.num_states) - assert (A[g].sum(axis=0) == 1.0).all(), 'A matrix not normalized! Check your initialization....\n' - - return A - -def convert_B_stubs_to_ndarray(B_stubs, model_labels): - """ - This function converts a list of multi-index pandas dataframes `B_stubs` into an object array - of different B matrices, one per hidden state factor - """ - - dimensions = get_model_dimensions_from_labels(model_labels) - - B = obj_array(dimensions.num_control_factors) - - for f, factor_name in enumerate(B_stubs.keys()): - - B[f] = B_stubs[factor_name].to_numpy().reshape(dimensions.num_states[f], dimensions.num_states[f], dimensions.num_controls[f]) - assert (B[f].sum(axis=0) == 1.0).all(), 'B matrix not normalized! Check your initialization....\n' - - return B - # def build_belief_array(qx): # """ diff --git a/requirements.txt b/requirements.txt index 8b59e2b1..de815d0c 100644 --- a/requirements.txt +++ b/requirements.txt @@ -7,7 +7,6 @@ nose>=1.3.7 numpy>=1.19.5 openpyxl>=3.0.7 packaging>=20.8 -pandas>=1.2.4 Pillow>=8.2.0 pluggy>=0.13.1 py>=1.10.0 From acd71376aad482e487f518e99ef2fec676de7034 Mon Sep 17 00:00:00 2001 From: Dimitrije Markovic <5038100+dimarkov@users.noreply.github.com> Date: Wed, 5 Jun 2024 11:38:56 +0200 Subject: [PATCH 221/232] remove stubs from test_wrappers --- test/test_wrappers.py | 84 +------------------------------------------ 1 file changed, 1 insertion(+), 83 deletions(-) diff --git a/test/test_wrappers.py b/test/test_wrappers.py index 254d902b..86ff5996 100644 --- a/test/test_wrappers.py +++ b/test/test_wrappers.py @@ -5,7 +5,7 @@ import pandas as pd from pandas.testing import assert_frame_equal -from pymdp.utils import Dimensions, get_model_dimensions_from_labels, create_A_matrix_stub, read_A_matrix, create_B_matrix_stubs, read_B_matrices +from pymdp.utils import Dimensions, get_model_dimensions_from_labels tmp_path = Path('tmp_dir') @@ -62,88 +62,6 @@ def test_get_model_dimensions_from_labels(self): self.assertEqual(want.num_state_factors, got.num_state_factors) self.assertEqual(want.num_controls, got.num_controls) self.assertEqual(want.num_control_factors, got.num_control_factors) - - def test_A_matrix_stub(self): - """ - This tests the construction of a 2-modality, 2-hidden state factor pandas MultiIndex dataframe using - the `model_labels` dictionary, which contains the modality- and factor-specific levels, labeled with string - identifiers. - - Note: actions are ignored when creating an A matrix stub - """ - - model_labels = { - "observations": { - "grass_observation": [ - "wet", - "dry" - ], - "weather_observation": [ - "clear", - "rainy", - "cloudy" - ] - }, - "states": { - "weather_state": ["raining", "clear"], - "sprinkler_state": ["on", "off"], - }, - "actions": { - "actions": ["something", "nothing"], - } - } - - num_hidden_state_factors = len(model_labels["states"]) - - expected_A_matrix_stub = create_A_matrix_stub(model_labels) - - temporary_file_path = (tmp_path / "A_matrix_stub.xlsx").resolve() - expected_A_matrix_stub.to_excel(temporary_file_path) - actual_A_matrix_stub = read_A_matrix(temporary_file_path, num_hidden_state_factors) - - os.remove(temporary_file_path) - - frames_are_equal = assert_frame_equal(expected_A_matrix_stub, actual_A_matrix_stub) is None - self.assertTrue(frames_are_equal) - - def test_B_matrix_stub(self): - """ - This tests the construction of a 1-modality, 2-hidden state factor, 2 control factor pandas MultiIndex dataframe using - the `model_labels` dictionary, which contains the hidden-state-factor- and control-factor-specific levels, labeled with string - identifiers - """ - - model_labels = { - "observations": { - "reward outcome": [ - "win", - "loss" - ] - }, - "states": { - "location": ["start", "arm1", "arm2"], - "bandit_state": ["high_rew", "low_rew"] - }, - "actions": { - "arm_play": ["play_arm1", "play_arm2"], - "bandit_state_control": ["null"] - } - } - - B_stubs = create_B_matrix_stubs(model_labels) - - xls_path = (tmp_path / "B_matrix_stubs.xlsx").resolve() - - with pd.ExcelWriter(xls_path) as writer: - for factor_name, B_stub_f in B_stubs.items(): - B_stub_f.to_excel(writer,'%s' % factor_name) - - read_in_B_stubs = read_B_matrices(xls_path) - - os.remove(xls_path) - - all_stub_compares = [assert_frame_equal(stub_og, stub_read_in) for stub_og, stub_read_in in zip(*[B_stubs.values(), read_in_B_stubs.values()])] - self.assertTrue(all(stub_compare is None for stub_compare in all_stub_compares)) if __name__ == "__main__": unittest.main() From 8abd376316cae575d3b74403d7355c57bdc2f833 Mon Sep 17 00:00:00 2001 From: conorheins Date: Wed, 5 Jun 2024 11:37:21 +0200 Subject: [PATCH 222/232] added .item() to outputs of certain EFE calculations and action setters, to avoid numpy deprecation warnings about converting ndarray with ndim >0 to scalar (relevant if using numpy>=1.25) --- pymdp/control.py | 8 ++++---- test/test_SPM_validation.py | 2 +- test/test_control.py | 22 +++++++++++----------- test/test_demos.py | 4 ++-- 4 files changed, 18 insertions(+), 18 deletions(-) diff --git a/pymdp/control.py b/pymdp/control.py index 892c02f3..758427eb 100644 --- a/pymdp/control.py +++ b/pymdp/control.py @@ -349,9 +349,9 @@ def update_posterior_policies( if use_param_info_gain: if pA is not None: - G[idx] += calc_pA_info_gain(pA, qo_pi, qs_pi) + G[idx] += calc_pA_info_gain(pA, qo_pi, qs_pi).item() if pB is not None: - G[idx] += calc_pB_info_gain(pB, qs_pi, qs, policy) + G[idx] += calc_pB_info_gain(pB, qs_pi, qs, policy).item() if I is not None: G[idx] += calc_inductive_cost(qs, qs_pi, I) @@ -455,9 +455,9 @@ def update_posterior_policies_factorized( if use_param_info_gain: if pA is not None: - G[idx] += calc_pA_info_gain_factorized(pA, qo_pi, qs_pi, A_factor_list) + G[idx] += calc_pA_info_gain_factorized(pA, qo_pi, qs_pi, A_factor_list).item() if pB is not None: - G[idx] += calc_pB_info_gain_interactions(pB, qs_pi, qs, B_factor_list, policy) + G[idx] += calc_pB_info_gain_interactions(pB, qs_pi, qs, B_factor_list, policy).item() if I is not None: G[idx] += calc_inductive_cost(qs, qs_pi, I) diff --git a/test/test_SPM_validation.py b/test/test_SPM_validation.py index 8c0bc136..ee386378 100644 --- a/test/test_SPM_validation.py +++ b/test/test_SPM_validation.py @@ -49,7 +49,7 @@ def test_active_inference_SPM_1a(self): q_pi, G= agent.infer_policies() action = agent.sample_action() - actions_python[t] = action + actions_python[t] = action.item() xn_python = build_xn_vn_array(xn_t) vn_python = build_xn_vn_array(vn_t) diff --git a/test/test_control.py b/test/test_control.py index 468af7d0..14b09938 100644 --- a/test/test_control.py +++ b/test/test_control.py @@ -604,7 +604,7 @@ def test_pA_info_gain(self): for idx, policy in enumerate(policies): qs_pi = control.get_expected_states(qs, B, policy) qo_pi = control.get_expected_obs(qs_pi, A) - pA_info_gains[idx] += control.calc_pA_info_gain(pA, qo_pi, qs_pi) + pA_info_gains[idx] += control.calc_pA_info_gain(pA, qo_pi, qs_pi).item() self.assertGreater(pA_info_gains[1], pA_info_gains[0]) @@ -613,7 +613,7 @@ def test_pA_info_gain(self): for idx, policy in enumerate(policies): qs_pi = control.get_expected_states(qs, B, policy) qo_pi = control.get_expected_obs_factorized(qs_pi, A, A_factor_list=[[0]]) - pA_info_gains_fac[idx] += control.calc_pA_info_gain_factorized(pA, qo_pi, qs_pi, A_factor_list=[[0]]) + pA_info_gains_fac[idx] += control.calc_pA_info_gain_factorized(pA, qo_pi, qs_pi, A_factor_list=[[0]]).item() self.assertTrue(np.allclose(pA_info_gains_fac, pA_info_gains)) @@ -707,7 +707,7 @@ def test_update_posterior_policies_utility(self): qo_pi = control.get_expected_obs(qs_pi, A) lnC = maths.spm_log_single(maths.softmax(C[modality_idx][:, np.newaxis])) - efe_valid[idx] += qo_pi[t_idx][modality_idx].dot(lnC) + efe_valid[idx] += qo_pi[t_idx][modality_idx].dot(lnC).item() q_pi_valid = maths.softmax(efe_valid * 16.0) @@ -755,7 +755,7 @@ def test_update_posterior_policies_utility(self): for modality_idx in range(len(A)): lnC = maths.spm_log_single(maths.softmax(C[modality_idx][:, np.newaxis])) - efe_valid[idx] += qo_pi[t_idx][modality_idx].dot(lnC) + efe_valid[idx] += qo_pi[t_idx][modality_idx].dot(lnC).item() q_pi_valid = maths.softmax(efe_valid * 16.0) @@ -802,7 +802,7 @@ def test_update_posterior_policies_utility(self): for t_idx in range(3): for modality_idx in range(len(A)): lnC = maths.spm_log_single(maths.softmax(C[modality_idx][:, np.newaxis])) - efe_valid[idx] += qo_pi[t_idx][modality_idx].dot(lnC) + efe_valid[idx] += qo_pi[t_idx][modality_idx].dot(lnC).item() q_pi_valid = maths.softmax(efe_valid * 16.0) @@ -855,7 +855,7 @@ def test_temporal_C_matrix(self): for t_idx in range(3): for modality_idx in range(len(A)): lnC = maths.spm_log_single(maths.softmax(C[modality_idx][:, np.newaxis])) - efe_valid[idx] += qo_pi[t_idx][modality_idx].dot(lnC) + efe_valid[idx] += qo_pi[t_idx][modality_idx].dot(lnC).item() q_pi_valid = maths.softmax(efe_valid * 16.0) @@ -905,7 +905,7 @@ def test_temporal_C_matrix(self): for t_idx in range(3): for modality_idx in range(len(A)): lnC = maths.spm_log_single(maths.softmax(C[modality_idx][:, t_idx])) - efe_valid[idx] += qo_pi[t_idx][modality_idx].dot(lnC) + efe_valid[idx] += qo_pi[t_idx][modality_idx].dot(lnC).item() q_pi_valid = maths.softmax(efe_valid * 16.0) @@ -958,7 +958,7 @@ def test_temporal_C_matrix(self): lnC = maths.spm_log_single(maths.softmax(C[modality_idx][:, t_idx])) elif modality_idx == 1: lnC = maths.spm_log_single(maths.softmax(C[modality_idx][:, np.newaxis])) - efe_valid[idx] += qo_pi[t_idx][modality_idx].dot(lnC) + efe_valid[idx] += qo_pi[t_idx][modality_idx].dot(lnC).item() q_pi_valid = maths.softmax(efe_valid * 16.0) @@ -1143,7 +1143,7 @@ def test_update_posterior_policies_pA_infogain(self): qs_pi = control.get_expected_states(qs, B, policy) qo_pi = control.get_expected_obs(qs_pi, A) - efe_valid[idx] += control.calc_pA_info_gain(pA, qo_pi, qs_pi) + efe_valid[idx] += control.calc_pA_info_gain(pA, qo_pi, qs_pi).item() q_pi_valid = maths.softmax(efe_valid * 16.0) @@ -1188,7 +1188,7 @@ def test_update_posterior_policies_pA_infogain(self): qs_pi = control.get_expected_states(qs, B, policy) qo_pi = control.get_expected_obs(qs_pi, A) - efe_valid[idx] += control.calc_pA_info_gain(pA, qo_pi, qs_pi) + efe_valid[idx] += control.calc_pA_info_gain(pA, qo_pi, qs_pi).item() q_pi_valid = maths.softmax(efe_valid * 16.0) @@ -1231,7 +1231,7 @@ def test_update_posterior_policies_pA_infogain(self): qs_pi = control.get_expected_states(qs, B, policy) qo_pi = control.get_expected_obs(qs_pi, A) - efe_valid[idx] += control.calc_pA_info_gain(pA, qo_pi, qs_pi) + efe_valid[idx] += control.calc_pA_info_gain(pA, qo_pi, qs_pi).item() q_pi_valid = maths.softmax(efe_valid * 16.0) diff --git a/test/test_demos.py b/test/test_demos.py index f0552ea3..d29d3eb4 100644 --- a/test/test_demos.py +++ b/test/test_demos.py @@ -383,7 +383,7 @@ def evaluate_policy(policy, Qs, A, B, C): for t in range(len(policy)): # get action entailed by the policy at timestep `t` - u = int(policy[t]) + u = int(policy[t].item()) # work out expected state, given the action Qs_pi = B[:,:,u].dot(Qs) @@ -424,7 +424,7 @@ def infer_action(Qs, A, B, C, n_actions, policies): # sum probabilites of control states or actions for i, policy in enumerate(policies): # control state specified by policy - u = int(policy[0]) + u = int(policy[0].item()) # add probability of policy Qu[u] += Q_pi[i] From 031ab30acc25f59ada312d86bf1a02abc31d6d4f Mon Sep 17 00:00:00 2001 From: Dimitrije Markovic <5038100+dimarkov@users.noreply.github.com> Date: Wed, 5 Jun 2024 11:47:17 +0200 Subject: [PATCH 223/232] fix deprication warning for clip --- pymdp/jax/control.py | 2 +- pymdp/jax/maths.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index af71e94a..c10c827d 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -454,7 +454,7 @@ def calc_inductive_value_t(qs, qs_next, I, epsilon=1e-3): # i.e. find first entry at which I_idx equals 1, and then m is the index before that m = jnp.maximum(jnp.argmax(I[f][:, idx])-1, 0) I_m = (1. - I[f][m, :]) * log_eps - path_available = jnp.clip(I[f][:, idx].sum(0), a_min=0, a_max=1) # if there are any 1's at all in that column of I, then this == 1, otherwise 0 + path_available = jnp.clip(I[f][:, idx].sum(0), min=0, max=1) # if there are any 1's at all in that column of I, then this == 1, otherwise 0 inductive_val += path_available * I_m.dot(qs_next[f]) # scaling by path_available will nullify the addition of inductive value in the case we find no path to goal (i.e. when no goal specified) return inductive_val diff --git a/pymdp/jax/maths.py b/pymdp/jax/maths.py index e1fef410..58b34aff 100644 --- a/pymdp/jax/maths.py +++ b/pymdp/jax/maths.py @@ -8,7 +8,7 @@ MINVAL = jnp.finfo(float).eps def log_stable(x): - return jnp.log(jnp.clip(x, a_min=MINVAL)) + return jnp.log(jnp.clip(x, min=MINVAL)) @partial(jit, static_argnames=['keep_dims']) def factor_dot(M, xs, keep_dims: Optional[Tuple[int]] = None): From f903730e1f73e746396401689968ff232acedc90 Mon Sep 17 00:00:00 2001 From: Ran Wei Date: Wed, 8 May 2024 15:00:00 -0500 Subject: [PATCH 224/232] make safe obj_array_from_list to address issue #130 with test --- pymdp/utils.py | 5 ++++- test/test_utils.py | 28 ++++++++++++++++++++++++++++ 2 files changed, 32 insertions(+), 1 deletion(-) create mode 100644 test/test_utils.py diff --git a/pymdp/utils.py b/pymdp/utils.py index 6842da09..b371f553 100644 --- a/pymdp/utils.py +++ b/pymdp/utils.py @@ -296,7 +296,10 @@ def obj_array_from_list(list_input): """ Takes a list of `numpy.ndarray` and converts them to a `numpy.ndarray` of `dtype = object` """ - return np.array(list_input, dtype = object) + arr = obj_array(len(list_input)) + for i, item in enumerate(list_input): + arr[i] = item + return arr def process_observation_seq(obs_seq, n_modalities, n_observations): """ diff --git a/test/test_utils.py b/test/test_utils.py new file mode 100644 index 00000000..033dd8f6 --- /dev/null +++ b/test/test_utils.py @@ -0,0 +1,28 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +""" Agent Class + +__author__: Conor Heins, Alexander Tschantz, Daphne Demekas, Brennan Klein + +""" + +import unittest + +import numpy as np + +from pymdp import utils + +class TestUtils(unittest.TestCase): + def test_obj_array_from_list(self): + """ + Tests `obj_array_from_list` + """ + # make arrays with same leading dimensions. naive method trigger numpy broadcasting error. + arrs = [np.zeros((3, 6)), np.zeros((3, 4, 5))] + obs_arrs = utils.obj_array_from_list(arrs) + + self.assertTrue(all([np.all(a == b) for a, b in zip(arrs, obs_arrs)])) + +if __name__ == "__main__": + unittest.main() \ No newline at end of file From 55fcc5f63379a430f0370f819ce613b26738d9e6 Mon Sep 17 00:00:00 2001 From: Dimitrije Markovic <5038100+dimarkov@users.noreply.github.com> Date: Wed, 5 Jun 2024 12:52:37 +0200 Subject: [PATCH 225/232] fix sample policies and actions to pass correctly logits to categorical sampler --- pymdp/jax/control.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/pymdp/jax/control.py b/pymdp/jax/control.py index c10c827d..b02cafe0 100644 --- a/pymdp/jax/control.py +++ b/pymdp/jax/control.py @@ -78,7 +78,8 @@ def sample_action(q_pi, policies, num_controls, action_selection="deterministic" if action_selection == 'deterministic': selected_policy = jtu.tree_map(lambda x: jnp.argmax(x, -1), marginal) elif action_selection == 'stochastic': - selected_policy = jtu.tree_map(lambda x: jr.categorical(rng_key, nn.softmax(alpha * log_stable(x))), marginal) + logits = lambda x: alpha * log_stable(x) + selected_policy = jtu.tree_map(lambda x: jr.categorical(rng_key, logits(x)), marginal) else: raise NotImplementedError @@ -89,8 +90,8 @@ def sample_policy(q_pi, policies, num_controls, action_selection="deterministic" if action_selection == "deterministic": policy_idx = jnp.argmax(q_pi) elif action_selection == "stochastic": - p_policies = nn.softmax(log_stable(q_pi) * alpha) - policy_idx = jr.categorical(rng_key, p_policies) + log_p_policies = log_stable(q_pi) * alpha + policy_idx = jr.categorical(rng_key, log_p_policies) selected_multiaction = policies[policy_idx, 0] return selected_multiaction From e97d6c723c6904994ab04873e21bff7e00deda9e Mon Sep 17 00:00:00 2001 From: conorheins Date: Wed, 5 Jun 2024 17:48:13 +0200 Subject: [PATCH 226/232] added the numpy version of @dimarkov's `factor_dot_flex` into numpy `maths.py` library --- pymdp/maths.py | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/pymdp/maths.py b/pymdp/maths.py index 59904be5..68000fb4 100644 --- a/pymdp/maths.py +++ b/pymdp/maths.py @@ -12,6 +12,7 @@ from scipy import special from pymdp import utils from itertools import chain +from opt_einsum import contract EPS_VAL = 1e-16 # global constant for use in spm_log() function @@ -105,6 +106,28 @@ def spm_dot_classic(X, x, dims_to_omit=None): return Y +def factor_dot_flex(M, xs, dims, keep_dims=None): + """ Dot product of a multidimensional array with `x`. + + Parameters + ---------- + - `M` [numpy.ndarray] - tensor + - 'xs' [list of numpyr.ndarray] - list of tensors + - 'dims' [list of tuples] - list of dimensions of xs tensors in tensor M + - 'keep_dims' [tuple] - tuple of integers denoting dimesions to keep + Returns + ------- + - `Y` [1D numpy.ndarray] - the result of the dot product + """ + all_dims = tuple(range(M.ndim)) + matrix = [[xs[f], dims[f]] for f in range(len(xs))] + args = [M, all_dims] + for row in matrix: + args.extend(row) + + args += [keep_dims] + return contract(*args, backend='numpy') + def spm_dot_old(X, x, dims_to_omit=None, obs_mode=False): """ Dot product of a multidimensional array with `x`. The dimensions in `dims_to_omit` will not be summed across during the dot product From 4f4b7c4e730bc976961235810a73d5f2aaf519f9 Mon Sep 17 00:00:00 2001 From: conorheins Date: Wed, 5 Jun 2024 17:48:48 +0200 Subject: [PATCH 227/232] changed the backward messages in `run_mmp_factorized` to match how they are computed in `pymdp.jax.algos.get_mmp_messages` --- pymdp/algos/mmp.py | 28 +++++++++++++++++++++++++--- 1 file changed, 25 insertions(+), 3 deletions(-) diff --git a/pymdp/algos/mmp.py b/pymdp/algos/mmp.py index 036e3ea3..019e81df 100644 --- a/pymdp/algos/mmp.py +++ b/pymdp/algos/mmp.py @@ -4,7 +4,7 @@ import numpy as np from pymdp.utils import to_obj_array, get_model_dimensions, obj_array, obj_array_zeros, obj_array_uniform -from pymdp.maths import spm_dot, spm_norm, softmax, calc_free_energy, spm_log_single +from pymdp.maths import spm_dot, spm_norm, softmax, calc_free_energy, spm_log_single, factor_dot_flex import copy def run_mmp( @@ -224,6 +224,8 @@ def run_mmp_factorized( joint_loglikelihood += lh_seq[t][m].reshape(reshape_dims) # add up all the log-likelihoods after reshaping them to the global common dimensions of all hidden state factors joint_lh_seq[t] = joint_loglikelihood + # compute inverse B dependencies, which is a list that for each hidden state factor, lists the indices of the other hidden state factors that it 'drives' or is a parent of in the HMM graphical model + inv_B_deps = [[i for i, d in enumerate(B_factor_list) if f in d] for f in range(num_factors)] for itr in range(num_iter): F = 0.0 # reset variational free energy (accumulated over time and factors, but reset per iteration) for t in range(infer_len): @@ -246,8 +248,28 @@ def run_mmp_factorized( if t >= future_cutoff: lnB_future = qs_T[f] else: - future_msg = spm_dot(trans_B[f][...,int(policy[t, f])], qs_seq[t+1][B_factor_list[f]]) - lnB_future = spm_log_single(future_msg) + # list of future_msgs, one for each of the factors that factor f is driving + + B_marg_list = [] # list of the marginalized B matrices, that correspond to mapping between the factor of interest `f` and each of its children factors `i` + for i in inv_B_deps[f]: #loop over all the hidden state factors that are driven by f + b = B[i][...,int(policy[t,i])] + keep_dims = (0,1+B_factor_list[i].index(f)) + dims = [] + idxs = [] + for j, d in enumerate(B_factor_list[i]): # loop over the list of factors that drive each child `i` of factor-of-interest `f` (i.e. the co-parents of `f`, with respect to child `i`) + if f != d: + dims.append((1 + j,)) + idxs.append(d) + xs = [qs_seq[t+1][f_i] for f_i in idxs] + B_marg_list.append( factor_dot_flex(b, xs, tuple(dims), keep_dims=keep_dims) ) # marginalize out all parents of `i` besides `f` + + lnB_future = np.zeros(num_states[f]) + for i, b in enumerate(B_marg_list): + b_norm_T = spm_norm(b.T) + lnB_future += spm_log_single(b_norm_T.dot(qs_seq[t + 1][inv_B_deps[f][i]])) + + + lnB_future *= 0.5 # inference if grad_descent: From 09cffafeca34e0355ef344f6c814a5496435ed9f Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 6 Jun 2024 12:47:47 +0200 Subject: [PATCH 228/232] changed python versions used in CI checks to 3.10, 3.11, and 3.12 --- .github/workflows/python-package.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index 276827e4..744e9d54 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -15,7 +15,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - python-version: [3.8] + python-version: ["3.10", "3.11", "3.12"] steps: - uses: actions/checkout@v2 From b59cfcd2e0974ce6ce0e6da2a27f7b07726eafd6 Mon Sep 17 00:00:00 2001 From: Arun-Niranjan Date: Sat, 30 Dec 2023 16:56:01 +0000 Subject: [PATCH 229/232] Refactor get model dimensions from labels --- .gitignore | 3 +- pymdp/utils.py | 69 +++++++++++++++++++++++++++++----------------- test/test_utils.py | 58 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 103 insertions(+), 27 deletions(-) create mode 100644 test/test_utils.py diff --git a/.gitignore b/.gitignore index 778d69dd..5f24acf9 100644 --- a/.gitignore +++ b/.gitignore @@ -7,4 +7,5 @@ __pycache__ .ipynb_checkpoints/ .pytest_cache env/ -pymdp.egg-info \ No newline at end of file +pymdp.egg-info +inferactively_pymdp.egg-info diff --git a/pymdp/utils.py b/pymdp/utils.py index 60bc41e0..bd985cf5 100644 --- a/pymdp/utils.py +++ b/pymdp/utils.py @@ -16,6 +16,27 @@ EPS_VAL = 1e-16 # global constant for use in norm_dist() +class Dimensions(object): + """ + The Dimensions class stores all data related to the size and shape of a model. + """ + def __init__( + self, + num_observations=None, + num_observation_modalities=0, + num_states=None, + num_state_factors=0, + num_controls=None, + num_control_factors=0, + ): + self.num_observations=num_observations + self.num_observation_modalities=num_observation_modalities + self.num_states=num_states + self.num_state_factors=num_state_factors + self.num_controls=num_controls + self.num_control_factors=num_control_factors + + def sample(probabilities): probabilities = probabilities.squeeze() if len(probabilities) > 1 else probabilities sample_onehot = np.random.multinomial(1, probabilities) @@ -211,22 +232,22 @@ def get_model_dimensions(A=None, B=None, factorized=False): def get_model_dimensions_from_labels(model_labels): modalities = model_labels['observations'] - num_modalities = len(modalities.keys()) - num_obs = [len(modalities[modality]) for modality in modalities.keys()] - factors = model_labels['states'] - num_factors = len(factors.keys()) - num_states = [len(factors[factor]) for factor in factors.keys()] - if 'actions' in model_labels.keys(): + res = Dimensions( + num_observations=[len(modalities[modality]) for modality in modalities.keys()], + num_observation_modalities=len(modalities.keys()), + num_states=[len(factors[factor]) for factor in factors.keys()], + num_state_factors=len(factors.keys()), + ) + if 'actions' in model_labels.keys(): controls = model_labels['actions'] - num_control_fac = len(controls.keys()) - num_controls = [len(controls[cfac]) for cfac in controls.keys()] + res.num_controls=[len(controls[cfac]) for cfac in controls.keys()] + res.num_control_factors=len(controls.keys()) + + return res - return num_obs, num_modalities, num_states, num_factors, num_controls, num_control_fac - else: - return num_obs, num_modalities, num_states, num_factors def norm_dist(dist): @@ -464,21 +485,18 @@ def construct_full_a(A_reduced, original_factor_idx, num_states): def create_A_matrix_stub(model_labels): - num_obs, _, num_states, _= get_model_dimensions_from_labels(model_labels) + dimensions = get_model_dimensions_from_labels(model_labels) obs_labels, state_labels = model_labels['observations'], model_labels['states'] state_combinations = pd.MultiIndex.from_product(list(state_labels.values()), names=list(state_labels.keys())) - num_state_combos = np.prod(num_states) - # num_rows = (np.array(num_obs) * num_state_combos).sum() - num_rows = sum(num_obs) + num_rows = sum(dimensions.num_observations) cell_values = np.zeros((num_rows, len(state_combinations))) obs_combinations = [] for modality in obs_labels.keys(): levels_to_combine = [[modality]] + [obs_labels[modality]] - # obs_combinations += num_state_combos * list(itertools.product(*levels_to_combine)) obs_combinations += list(itertools.product(*levels_to_combine)) @@ -490,7 +508,7 @@ def create_A_matrix_stub(model_labels): def create_B_matrix_stubs(model_labels): - _, _, num_states, _, num_controls, _ = get_model_dimensions_from_labels(model_labels) + dimensions = get_model_dimensions_from_labels(model_labels) state_labels = model_labels['states'] action_labels = model_labels['actions'] @@ -504,9 +522,9 @@ def create_B_matrix_stubs(model_labels): prev_state_action_combos = pd.MultiIndex.from_product(factor_list, names=[factor, list(action_labels.keys())[f_idx]]) - num_state_action_combos = num_states[f_idx] * num_controls[f_idx] + num_state_action_combos = dimensions.num_states[f_idx] * dimensions.num_controls[f_idx] - num_rows = num_states[f_idx] + num_rows = dimensions.num_states[f_idx] cell_values = np.zeros((num_rows, num_state_action_combos)) @@ -559,13 +577,12 @@ def convert_A_stub_to_ndarray(A_stub, model_labels): This function converts a multi-index pandas dataframe `A_stub` into an object array of different A matrices, one per observation modality. """ + dimensions = get_model_dimensions_from_labels(model_labels) - num_obs, num_modalities, num_states, num_factors = get_model_dimensions_from_labels(model_labels) - - A = obj_array(num_modalities) + A = obj_array(dimensions.num_observation_modalities) for g, modality_name in enumerate(model_labels['observations'].keys()): - A[g] = A_stub.loc[modality_name].to_numpy().reshape(num_obs[g], *num_states) + A[g] = A_stub.loc[modality_name].to_numpy().reshape(dimensions.num_observations[g], *dimensions.num_states) assert (A[g].sum(axis=0) == 1.0).all(), 'A matrix not normalized! Check your initialization....\n' return A @@ -576,13 +593,13 @@ def convert_B_stubs_to_ndarray(B_stubs, model_labels): of different B matrices, one per hidden state factor """ - _, _, num_states, num_factors, num_controls, num_control_fac = get_model_dimensions_from_labels(model_labels) + dimensions = get_model_dimensions_from_labels(model_labels) - B = obj_array(num_factors) + B = obj_array(dimensions.num_control_factors) for f, factor_name in enumerate(B_stubs.keys()): - B[f] = B_stubs[factor_name].to_numpy().reshape(num_states[f], num_states[f], num_controls[f]) + B[f] = B_stubs[factor_name].to_numpy().reshape(dimensions.num_states[f], dimensions.num_states[f], dimensions.num_controls[f]) assert (B[f].sum(axis=0) == 1.0).all(), 'B matrix not normalized! Check your initialization....\n' return B diff --git a/test/test_utils.py b/test/test_utils.py new file mode 100644 index 00000000..0a1ed066 --- /dev/null +++ b/test/test_utils.py @@ -0,0 +1,58 @@ + +import unittest + +from pymdp.utils import get_model_dimensions_from_labels, Dimensions + +class TestUtils(unittest.TestCase): + def test_get_model_dimensions_from_labels(self): + """ + Tests model dimension extraction from labels including observations, states and actions. + """ + model_labels = { + "observations": { + "species_observation": [ + "absent", + "present", + ], + "budget_observation": [ + "high", + "medium", + "low", + ], + }, + "states": { + "species_state": [ + "extant", + "extinct", + ], + }, + "actions": { + "conservation_action": [ + "manage", + "survey", + "stop", + ], + }, + } + + want = Dimensions( + num_observations=[2, 3], + num_observation_modalities=2, + num_states=[2], + num_state_factors=1, + num_controls=[3], + num_control_factors=1, + ) + + got = get_model_dimensions_from_labels(model_labels) + + self.assertEqual(want.num_observations, got.num_observations) + self.assertEqual(want.num_observation_modalities, got.num_observation_modalities) + self.assertEqual(want.num_states, got.num_states) + self.assertEqual(want.num_state_factors, got.num_state_factors) + self.assertEqual(want.num_controls, got.num_controls) + self.assertEqual(want.num_control_factors, got.num_control_factors) + + +if __name__ == "__main__": + unittest.main() \ No newline at end of file From 1b5071083154a4235bf89abdd14378ce44bb5d94 Mon Sep 17 00:00:00 2001 From: Arun-Niranjan Date: Sat, 30 Dec 2023 17:03:50 +0000 Subject: [PATCH 230/232] Move unit test and update existing test for creating A matrix stub --- test/test_utils.py | 58 ---------------------------------------- test/test_wrappers.py | 62 ++++++++++++++++++++++++++++++++++++++----- 2 files changed, 56 insertions(+), 64 deletions(-) delete mode 100644 test/test_utils.py diff --git a/test/test_utils.py b/test/test_utils.py deleted file mode 100644 index 0a1ed066..00000000 --- a/test/test_utils.py +++ /dev/null @@ -1,58 +0,0 @@ - -import unittest - -from pymdp.utils import get_model_dimensions_from_labels, Dimensions - -class TestUtils(unittest.TestCase): - def test_get_model_dimensions_from_labels(self): - """ - Tests model dimension extraction from labels including observations, states and actions. - """ - model_labels = { - "observations": { - "species_observation": [ - "absent", - "present", - ], - "budget_observation": [ - "high", - "medium", - "low", - ], - }, - "states": { - "species_state": [ - "extant", - "extinct", - ], - }, - "actions": { - "conservation_action": [ - "manage", - "survey", - "stop", - ], - }, - } - - want = Dimensions( - num_observations=[2, 3], - num_observation_modalities=2, - num_states=[2], - num_state_factors=1, - num_controls=[3], - num_control_factors=1, - ) - - got = get_model_dimensions_from_labels(model_labels) - - self.assertEqual(want.num_observations, got.num_observations) - self.assertEqual(want.num_observation_modalities, got.num_observation_modalities) - self.assertEqual(want.num_states, got.num_states) - self.assertEqual(want.num_state_factors, got.num_state_factors) - self.assertEqual(want.num_controls, got.num_controls) - self.assertEqual(want.num_control_factors, got.num_control_factors) - - -if __name__ == "__main__": - unittest.main() \ No newline at end of file diff --git a/test/test_wrappers.py b/test/test_wrappers.py index db25c984..254d902b 100644 --- a/test/test_wrappers.py +++ b/test/test_wrappers.py @@ -1,15 +1,11 @@ import os import unittest from pathlib import Path -import shutil -import tempfile -import numpy as np -import itertools import pandas as pd from pandas.testing import assert_frame_equal -from pymdp.utils import create_A_matrix_stub, read_A_matrix, create_B_matrix_stubs, read_B_matrices +from pymdp.utils import Dimensions, get_model_dimensions_from_labels, create_A_matrix_stub, read_A_matrix, create_B_matrix_stubs, read_B_matrices tmp_path = Path('tmp_dir') @@ -18,11 +14,62 @@ class TestWrappers(unittest.TestCase): + def test_get_model_dimensions_from_labels(self): + """ + Tests model dimension extraction from labels including observations, states and actions. + """ + model_labels = { + "observations": { + "species_observation": [ + "absent", + "present", + ], + "budget_observation": [ + "high", + "medium", + "low", + ], + }, + "states": { + "species_state": [ + "extant", + "extinct", + ], + }, + "actions": { + "conservation_action": [ + "manage", + "survey", + "stop", + ], + }, + } + + want = Dimensions( + num_observations=[2, 3], + num_observation_modalities=2, + num_states=[2], + num_state_factors=1, + num_controls=[3], + num_control_factors=1, + ) + + got = get_model_dimensions_from_labels(model_labels) + + self.assertEqual(want.num_observations, got.num_observations) + self.assertEqual(want.num_observation_modalities, got.num_observation_modalities) + self.assertEqual(want.num_states, got.num_states) + self.assertEqual(want.num_state_factors, got.num_state_factors) + self.assertEqual(want.num_controls, got.num_controls) + self.assertEqual(want.num_control_factors, got.num_control_factors) + def test_A_matrix_stub(self): """ This tests the construction of a 2-modality, 2-hidden state factor pandas MultiIndex dataframe using the `model_labels` dictionary, which contains the modality- and factor-specific levels, labeled with string - identifiers + identifiers. + + Note: actions are ignored when creating an A matrix stub """ model_labels = { @@ -41,6 +88,9 @@ def test_A_matrix_stub(self): "weather_state": ["raining", "clear"], "sprinkler_state": ["on", "off"], }, + "actions": { + "actions": ["something", "nothing"], + } } num_hidden_state_factors = len(model_labels["states"]) From 51c799f678f74840a5d11415d796303fc3f05d59 Mon Sep 17 00:00:00 2001 From: Dimitrije Markovic <5038100+dimarkov@users.noreply.github.com> Date: Thu, 6 Jun 2024 13:28:25 +0200 Subject: [PATCH 231/232] added atol to output comparison --- test/test_message_passing_jax.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/test_message_passing_jax.py b/test/test_message_passing_jax.py index e40c637f..b27be336 100644 --- a/test/test_message_passing_jax.py +++ b/test/test_message_passing_jax.py @@ -143,7 +143,7 @@ def test_fixed_point_iteration_factorized_fullyconnected(self): qs_jax_factorized = fpi_jax_factorized(A, obs, prior, factor_lists, num_iter=16) for f, _ in enumerate(qs_jax): - self.assertTrue(np.allclose(qs_jax[f], qs_jax_factorized[f])) + self.assertTrue(np.allclose(qs_jax[f], qs_jax_factorized[f], atol=1e-6)) def test_fixed_point_iteration_factorized_sparsegraph(self): """ From 540e855a02db4764e8e5b807ab25feb5cf64b4a8 Mon Sep 17 00:00:00 2001 From: conorheins Date: Thu, 6 Jun 2024 13:35:08 +0200 Subject: [PATCH 232/232] removed `infer_policies_old` from `Agent` class in numpy backend --- pymdp/agent.py | 68 -------------------------------------------------- 1 file changed, 68 deletions(-) diff --git a/pymdp/agent.py b/pymdp/agent.py index b28d26e9..de8363c8 100644 --- a/pymdp/agent.py +++ b/pymdp/agent.py @@ -604,74 +604,6 @@ def _infer_states_test(self, observation, distr_obs=False): return qs, xn, vn else: return qs - - def infer_policies_old(self): - """ - Perform policy inference by optimizing a posterior (categorical) distribution over policies. - This distribution is computed as the softmax of ``G * gamma + lnE`` where ``G`` is the negative expected - free energy of policies, ``gamma`` is a policy precision and ``lnE`` is the (log) prior probability of policies. - This function returns the posterior over policies as well as the negative expected free energy of each policy. - - Returns - ---------- - q_pi: 1D ``numpy.ndarray`` - Posterior beliefs over policies, i.e. a vector containing one posterior probability per policy. - G: 1D ``numpy.ndarray`` - Negative expected free energies of each policy, i.e. a vector containing one negative expected free energy per policy. - """ - - if self.inference_algo == "VANILLA": - q_pi, G = control.update_posterior_policies( - self.qs, - self.A, - self.B, - self.C, - self.policies, - self.use_utility, - self.use_states_info_gain, - self.use_param_info_gain, - self.pA, - self.pB, - E=self.E, - I=self.I, - gamma=self.gamma - ) - elif self.inference_algo == "MMP": - if self.factorized: - raise NotImplementedError("Factorized inference not implemented for MMP") - - if self.sophisticated: - raise NotImplementedError("Sophisticated inference not implemented for MMP") - - - future_qs_seq = self.get_future_qs() - - q_pi, G = control.update_posterior_policies_full( - future_qs_seq, - self.A, - self.B, - self.C, - self.policies, - self.use_utility, - self.use_states_info_gain, - self.use_param_info_gain, - self.latest_belief, - self.pA, - self.pB, - F = self.F, - E = self.E, - I=self.I, - gamma = self.gamma - ) - - if hasattr(self, "q_pi_hist"): - self.q_pi_hist.append(q_pi) - if len(self.q_pi_hist) > self.inference_horizon: - self.q_pi_hist = self.q_pi_hist[-(self.inference_horizon-1):] - - self.q_pi = q_pi - self.G = G - return q_pi, G def infer_policies(self): """