aind-dynamic-foraging-models

AIND library for generative (RL) and descriptive (logistic regression) models of dynamic foraging tasks.

User documentation available on readthedocs.

Reinforcement Learning (RL) models with Maximum Likelihood Estimation (MLE) fitting

Overview

RL agents that can perform any dynamic foraging task in aind-behavior-gym and can fit behavior using MLE.

Code structure

• To add more generative models, please subclass DynamicForagingAgentMLEBase.

Implemented foragers

• ForagerQLearning: Simple Q-learning agents that incrementally update Q-values.
  • Available agent_kwargs:

      number_of_learning_rate: Literal[1, 2] = 2,
      number_of_forget_rate: Literal[0, 1] = 1,
      choice_kernel: Literal["none", "one_step", "full"] = "none",
      action_selection: Literal["softmax", "epsilon-greedy"] = "softmax",
    

• ForagerLossCounting: Loss counting agents with probabilistic loss_count_threshold.
  • Available agent_kwargs:

      win_stay_lose_switch: Literal[False, True] = False,
      choice_kernel: Literal["none", "one_step", "full"] = "none",
    

• Action selections (readthedoc)

Here is the full list of available foragers:

Usage

• Jupyter notebook
• See also these unittest functions.

RL model playground

Play with the generative models here.

Logistic regression

See this demo notebook.

Choosing logistic regression models

Su 2022

$$ logit(p(c_r)) \sim RewardedChoice+UnrewardedChoice $$

Bari 2019

$$ logit(p(c_r)) \sim RewardedChoice+Choice $$

Hattori 2019

$$ logit(p(c_r)) \sim RewardedChoice+UnrewardedChoice+Choice $$

Miller 2021

$$ logit(p(c_r)) \sim Choice + Reward+ Choice*Reward $$

Encodings

• Ignored trials are removed

Some observations:

1. $RewardedChoice$ and $UnrewardedChoice$ are orthogonal
2. $Choice = RewardedChoice + UnrewardedChoice$
3. $Choice * Reward = RewardedChoice - UnrewardedChoice$

Comparison

Regularization and optimization

The choice of optimizer depends on the penality term, as listed here.

• lbfgs - [l2, None]
• liblinear - [l1, l2]
• newton-cg - [l2, None]
• newton-cholesky - [l2, None]
• sag - [l2, None]
• saga - [elasticnet, l1, l2, None]

See also

• Foraging model simulation, model recovery, etc.: https://github.com/hanhou/Dynamic-Foraging

Installation

To install the package (logistic regression only), run

pip install aind-dynamic-foraging-models

To install the package with RL models, run

pip install aind-dynamic-foraging-models[rl]

To develop the code, clone the repo to your local machine, and run

pip install -e .[dev]

Contributing

Linters and testing

There are several libraries used to run linters, check documentation, and run tests.

• Please test your changes using the coverage library, which will run the tests and log a coverage report:

coverage run -m unittest discover && coverage report

• Use interrogate to check that modules, methods, etc. have been documented thoroughly:

interrogate .

• Use flake8 to check that code is up to standards (no unused imports, etc.):

flake8 .

• Use black to automatically format the code into PEP standards:

black .

• Use isort to automatically sort import statements:

isort .

Pull requests

For internal members, please create a branch. For external members, please fork the repository and open a pull request from the fork. We'll primarily use Angular style for commit messages. Roughly, they should follow the pattern:

<type>(<scope>): <short summary>

where scope (optional) describes the packages affected by the code changes and type (mandatory) is one of:

• build: Changes that affect build tools or external dependencies (example scopes: pyproject.toml, setup.py)
• ci: Changes to our CI configuration files and scripts (examples: .github/workflows/ci.yml)
• docs: Documentation only changes
• feat: A new feature
• fix: A bugfix
• perf: A code change that improves performance
• refactor: A code change that neither fixes a bug nor adds a feature
• test: Adding missing tests or correcting existing tests

Semantic Release

The table below, from semantic release, shows which commit message gets you which release type when semantic-release runs (using the default configuration):

Documentation

To generate the rst files source files for documentation, run

sphinx-apidoc -o doc_template/source/ src 

Then to create the documentation HTML files, run

sphinx-build -b html doc_template/source/ doc_template/build/html

More info on sphinx installation can be found here.

Hierarchical Bayesian fitting

aind_dynamic_foraging_models.hierarchical_bayes fits the foragers as hierarchical Bayesian models (population → subject → session) with NumPyro, as a partially-pooled counterpart to the per-session MLE fitting in generative_model.

pip install aind-dynamic-foraging-models[bayes]

• Start here: a worked end-to-end example on synthetic data with known ground truth -- simulate a cohort, fit it both ways, and check that the parameters come back: notebook/demo_hierarchical_bayes.ipynb
• Design decisions and their rationale: src/aind_dynamic_foraging_models/hierarchical_bayes/docs/design-decisions.md
• Validation against the reference Stan implementation, and performance measurements: src/aind_dynamic_foraging_models/hierarchical_bayes/benchmarks/RESULTS.md

GLM-HMM

aind_dynamic_foraging_models.glm_hmm fits an input-driven HMM with GLM emissions (Ashwood et al. 2022, Nat Neurosci 25:201) over left / right / ignore choices, on dynamax.

pip install aind-dynamic-foraging-models[glmhmm]

• Two emissions, both exactly normalised over the three outcomes: hurdle (per state, an engagement GLM on unsigned history and a side GLM on signed history) and reference (per state, one multinomial GLM with ignore as the zero-logit class, as in Faeze's ssm fits). How they differ, and which to use: glm_hmm/README.md.
• Regressors (design.py): RewC and UnrC lags (signed), Ignored and Rewarded lags (unsigned), and a bias; trial 0 of every session sees the bias alone.
• Fitting (model.py): EM over many variable-length sessions, bucketed by length with exact masking. The emission M-step is exact Newton with a Gaussian prior; pi and A use a Dirichlet MAP. Priors are arguments, so one model serves a near-flat global fit (GLOBAL_PRIOR) and per-subject MAP refits started from it (SUBJECT_PRIOR).
• Scoring: predictive_log_probs is the forward filter's one-step-ahead log p(y_t | y_<t) per class. It is the held-out quantity, and it never uses later trials. state_posteriors gives filtered and smoothed posteriors and Viterbi paths.
• tfp-nightly is pinned to one build in the extra: dynamax leaves it unpinned, and only some nightlies work with jax 0.6.1 and numpy 2.4.
• Device: float64 on the CPU by default; AIND_GLMHMM_DEVICE=gpu moves the fits to a GPU. GPU linear solves need the CUDA solver libraries pinned, as model._compute explains. A GPU is faster for a large pooled fit, but not for one mouse's refit.
• Validation: glm_hmm/recovery/ simulates from known parameters and refits them, and cross-checks the likelihood against ssm (RESULTS.md). The study version, including a factorial of designed strategies, is AllenNeuralDynamics/aind-dynamic-foraging-bfm-studies#50.