11. Explain to me how seeding works with numba and multiple processes. One of the tests fails which may lead to unreproducable results. There is a potential bug in the way runs are seeded.

OUTPUT:

(This was really interesting and might be useful in the future of our project as well)

NUMBA RNG SEEDING FIX - Implementation Guide

PROBLEM:

Numba's JIT-compiled functions use their own internal RNG (Xoshiro128++),

which is completely separate from NumPy's RNG. Calling np.random.seed()

from Python only seeds NumPy's RNG, not Numba's.

SOLUTION:

Create a @njit function that seeds the RNG from within the JIT context.

CHANGE 1: Add to numba_optimized.py (after line ~35, after the dummy decorators)

@njit(cache=True)

def set_numba_seed(seed: int) -> None:

"""

Seed Numba's internal RNG from within a JIT context.

IMPORTANT: This must be called to get reproducible results from

Numba-accelerated functions. Calling np.random.seed() from Python

only affects NumPy's RNG, not Numba's internal Xoshiro128++ RNG.

Args:

seed: Integer seed value

Usage:

from numba_optimized import set_numba_seed

set_numba_seed(42) # Now Numba functions will be deterministic

"""

np.random.seed(seed)

CHANGE 2: Update the exports/imports

In numba_optimized.py, update the module docstring to include set_numba_seed:

"""

...

Usage:

from scripts.numba_optimized import (

PPKernel,

compute_all_pcfs_fast,

measure_cluster_sizes_fast,

set_numba_seed, # <-- ADD THIS

NUMBA_AVAILABLE

)

# Seed Numba's RNG for reproducibility

set_numba_seed(42)

# Create kernel once, reuse for all updates

kernel = PPKernel(rows, cols)

...

"""

CHANGE 3: Update pp_analysis.py - Import set_numba_seed

Find the import block (around line 20-30) and add set_numba_seed:

from scripts.numba_optimized import (

PPKernel,

compute_all_pcfs_fast,

measure_cluster_sizes_fast,

warmup_numba_kernels,

NUMBA_AVAILABLE,

)

from scripts.numba_optimized import (

PPKernel,

compute_all_pcfs_fast,

measure_cluster_sizes_fast,

warmup_numba_kernels,

set_numba_seed, # <-- ADD THIS

NUMBA_AVAILABLE,

)

CHANGE 4: Update run_single_simulation() in pp_analysis.py

Find the run_single_simulation function and add set_numba_seed call at the start:

def run_single_simulation(

prey_birth: float,

prey_death: float,

grid_size: int,

seed: int,

with_evolution: bool,

cfg: Config,

) -> Dict[str, Any]:

"""Run a single simulation and return results."""

# --- ADD THESE LINES AT THE VERY START OF THE FUNCTION ---

# Seed both NumPy and Numba RNGs for full reproducibility

np.random.seed(seed)

if NUMBA_AVAILABLE:

set_numba_seed(seed)

# --- END OF ADDITION ---

# ... rest of the function remains unchanged ...

CHANGE 5: Update run_single_simulation_fss() in pp_analysis.py (if it exists)

Same pattern - add seeding at the start:

def run_single_simulation_fss(...):

"""Run FSS simulation."""

# Seed both RNGs

np.random.seed(seed)

if NUMBA_AVAILABLE:

set_numba_seed(seed)

# ... rest unchanged ...

CHANGE 6: Update warmup_numba_kernels() in numba_optimized.py

Add a deterministic seed during warmup to avoid variability:

def warmup_numba_kernels(grid_size: int = 100):

"""

Pre-compile all Numba kernels.

"""

if not NUMBA_AVAILABLE:

return

# --- ADD THIS LINE ---

set_numba_seed(0) # Deterministic warmup

# --- END OF ADDITION ---

# Dummy data

grid = np.zeros((grid_size, grid_size), dtype=np.int32)

# ... rest unchanged ...

COMPLETE UPDATED numba_optimized.py (key sections only)

Here's how the top of your file should look after changes:

import numpy as np

from typing import Tuple, Dict, Optional

try:

from numba import njit, prange

NUMBA_AVAILABLE = True

except ImportError:

NUMBA_AVAILABLE = False

def njit(*args, **kwargs):

def decorator(func):

return func

return decorator

def prange(*args):

return range(*args)

@njit(cache=True)

def set_numba_seed(seed: int) -> None:

"""

np.random.seed(seed)

@njit(cache=True)

def _pp_async_kernel(...):

# ... unchanged ...

TESTING THE FIX

After making these changes, this test should pass:

def test_kernel_deterministic_with_seed():

"""Same seed should produce same results."""

from numba_optimized import PPKernel, set_numba_seed

results = []

for _ in range(2):

# Seed BOTH RNGs

np.random.seed(12345)

set_numba_seed(12345) # <-- This is the key!

grid = np.random.choice([0, 1, 2], (30, 30), p=[0.5, 0.3, 0.2]).astype(np.int32)

prey_death = np.full((30, 30), 0.05, dtype=np.float64)

prey_death[grid != 1] = np.nan

kernel = PPKernel(30, 30, "moore")

for _ in range(10):

kernel.update(grid, prey_death, 0.2, 0.05, 0.2, 0.1)

results.append(grid.copy())

assert np.array_equal(results[0], results[1]), "Results should be deterministic"

WHY THIS WORKS

1. When you call `set_numba_seed(seed)` from Python, it invokes the @njit function

2. Inside the JIT context, `np.random.seed(seed)` seeds Numba's internal RNG

3. All subsequent calls to `np.random.random()`, `np.random.randint()`, etc.

inside @njit functions will use this seeded state

4. The RNG state persists across JIT function calls until re-seeded

Note: Each worker process in parallel execution needs its own seed call.

For parallel simulations, use different seeds per worker (e.g., base_seed + worker_id).