Making Your Models Fly

Computational Tools for Neuroeconomic Modeling

import numpy as np, jax.numpy as jnp
x = np.linspace(-1, 1, 1000000)
y = jnp.sin(x) + x**2

Gilles de Hollander

Today

• Why bother?
• A bit of computer science
• Computational graphs
• Optimizing code
• Example 1: Encoding models (e.g., PRF models)
• Example 2: Efficient coding models

Why bother?

Why bother?

Why bother?

Why bother?

The Deep learning Revolution

The Deep learning Revolution

A little bit of Computer Science

A little bit of Computer Science

; Simple function: add two numbers
section .text
  global _start
_start:
  mov eax, 5      ; Load 5 into register EAX
  add eax, 3      ; Add 3 to EAX (result = 8)
  ret             ; Return from function

 `10110000 00000101` (mov eax, 5)
 `00000000 00000011` (add eax, 3)
 `11000011`         (ret)

x86 Architecture

ARM Architecture

GPU Architecture

A little bit of Computer Science

• Your code (Python/Matlab/C++) needs to be 'translated to platform-specific byte-code.

Two main possibilities:

1. Compiled languages (C++, Rust)
2. Interpreted languages (Matlab/Python/R)

A little bit of Computer Science

# Python (interpreted)
result = np.dot(A, B)  # Calls BLAS (compiled C/Fortran)

The Future: Computational Graph Libraries

Exercise 1: DDM simulation in Tensorflow

First things first

• Visual Studio Code
• Conda environments:

conda env list
 * soglio
(* soglio_metal)
(* soglio_gpu)

Exercise 1: DDM simulation in Tensorflow

DDM simulation in Tensorflow

@tf.function
def ddm_tensorflow(n_trials=1000, max_t=10.0, dt=0.001, drift=0.1, noise=0.1, bound=1.0):
    n_steps = int(max_t / dt)

    # Generate all noise terms at once
    noise_terms = noise * tf.sqrt(dt) * tf.random.normal([n_trials, n_steps])

    # Create evidence trajectory (n_trials × n_steps)
    drift_terms = tf.ones([n_trials, n_steps]) * drift * dt
    evidence = tf.cumsum(drift_terms + noise_terms, axis=1)

    # Add initial zeros
    evidence = tf.pad(evidence, [[0, 0], [1, 0]], constant_values=0.0)

    # Find crossing times
    crossed_up = evidence >= bound
    crossed_down = evidence <= -bound
    crossed = crossed_up | crossed_down

    # Get first crossing time
    rts = tf.where(
        tf.reduce_any(crossed, axis=1),
        dt * tf.cast(tf.argmax(tf.cast(crossed, tf.int32), axis=1), tf.float32),
        tf.constant(max_t, dtype=tf.float32)
)

    # Determine responses
    responses = tf.where(tf.reduce_any(crossed_up, axis=1),
                        1,
                        tf.where(tf.reduce_any(crossed_down, axis=1),
                                0,
                                tf.random.uniform([n_trials], 0, 2, tf.int32)))

    return responses, rts

Graph demo

notebooks/1_computational_graphs.ipynb

Assignment 1

Open notebooks/2_ddm_fast_and_slow.ipynb