From 008374405f153254ac1a7e0f97b8e640a2ed82ce Mon Sep 17 00:00:00 2001 From: Luciano Paz Date: Wed, 5 Feb 2025 15:07:50 +0100 Subject: [PATCH 1/4] Add particle filter exercise notebook --- notebooks/exercises/particle_filter.ipynb | 463 ++++++++++++++++++++++ 1 file changed, 463 insertions(+) create mode 100644 notebooks/exercises/particle_filter.ipynb diff --git a/notebooks/exercises/particle_filter.ipynb b/notebooks/exercises/particle_filter.ipynb new file mode 100644 index 0000000..3975520 --- /dev/null +++ b/notebooks/exercises/particle_filter.ipynb @@ -0,0 +1,463 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "7df44352-d887-45dd-b6ae-79fb80d40e03", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "9a763464-20c6-4f7f-8cd8-2c2a39be03cb", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pytensor\n", + "from pytensor import tensor as pt\n", + "from pytensor.tensor import random as ptr\n", + "from pytensor.scan import until\n", + "import pymc as pm\n", + "from matplotlib import pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a5eb1196-2435-4990-984a-29def6d2df2b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(-1.33507789)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "seed = 42\n", + "def rng_ctor(seed_seq):\n", + " return np.random.Generator(np.random.Philox(seed_seq))\n", + "\n", + "rng = ptr.RandomStream(seed=seed, rng_ctor=rng_ctor)\n", + "rng.normal().eval()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "97a04566-f56c-4dc0-8c2e-60d49e2300fa", + "metadata": {}, + "outputs": [], + "source": [ + "def create_gaussian_particles(n_particles, mean=0, std=1):\n", + " mean, std = pt.broadcast_arrays(mean, std)\n", + " particles = rng.normal(loc=mean, scale=std, size=(n_particles, 3))\n", + " particles = pt.set_subtensor(particles[:, 2], particles[:, 2] % (2 * np.pi))\n", + " return particles\n", + "\n", + "def predict(heading_change, velocity, particles, heading_noise, velocity_noise, dt):\n", + " \"\"\" move according to control input u (heading change, velocity)\n", + " with noise Q (std heading change, std velocity)`\"\"\"\n", + "\n", + " N = particles.shape[0]\n", + " # update heading\n", + " particles = pt.inc_subtensor(\n", + " particles[:, 2], heading_change + rng.normal(size=N) * heading_noise\n", + " )\n", + " particles = pt.set_subtensor(particles[:, 2], particles[:, 2] % (2 * np.pi))\n", + "\n", + " # move in the (noisy) commanded direction\n", + " dist = (velocity * dt) + (pm.HalfNormal.dist(size=N) * velocity_noise)\n", + " particles = pt.inc_subtensor(particles[:, 0], pt.cos(particles[:, 2]) * dist)\n", + " particles = pt.inc_subtensor(particles[:, 1], pt.sin(particles[:, 2]) * dist)\n", + " return particles\n", + "\n", + "\n", + "def distances2(positions, landmarks):\n", + " # positions.shape (n_particles, dim)\n", + " # landmarks.shape (n_landmarks, dim)\n", + " # out.shape (n_particles, n_landmarks)\n", + " rel = positions[:, None, :] - landmarks[None, :, :]\n", + " return (rel**2).sum(axis=-1)\n", + "\n", + "\n", + "def distances(positions, landmarks):\n", + " return pt.sqrt(distances2(positions, landmarks))\n", + "\n", + "\n", + "def update(log_weights, particles, observed, sensor_noise, landmarks):\n", + " dist_to_land = distances(particles[..., :2], landmarks)\n", + " log_weights += pm.logprob.logp(\n", + " pm.Normal.dist(dist_to_land, sensor_noise),\n", + " observed\n", + " ).sum(axis=-1)\n", + "\n", + " log_weights -= pt.logsumexp(log_weights)\n", + " return log_weights\n", + "\n", + "def estimate(particles, log_weights):\n", + " \"\"\"returns mean and variance of the weighted particles\"\"\"\n", + "\n", + " pos = particles[:, :2]\n", + " mean = pt.sum(pos * pt.exp(log_weights)[..., None], axis=-2) / pt.exp(log_weights).sum(axis=-1)\n", + " var = pt.sum((pos - mean)**2 * pt.exp(log_weights)[..., None], axis=-2) / pt.exp(log_weights).sum(axis=-1)\n", + " return mean, pt.sqrt(var)\n", + "\n", + "\n", + "def neff(log_weights):\n", + " return 1 / pt.sum(pt.exp(log_weights)**2)\n", + "\n", + "def systematic_resample(particles, log_weights, n_particles):\n", + " # make n_particles subdivisions, and choose positions with a\n", + " # consistent random offset\n", + " n_particles = n_particles.eval()\n", + " positions = (rng.uniform() + pt.arange(n_particles)) / n_particles\n", + "\n", + " weights = pt.exp(log_weights)\n", + " cumulative_sum = pt.cumsum(weights)\n", + " indexes = pytensor.shared(np.zeros(n_particles, dtype='int'))\n", + " i = pytensor.shared(np.array([0]))\n", + " j = pytensor.shared(np.array([0]))\n", + " \n", + " def step(indexes, i, j, positions, cumulative_sum):\n", + " ii = i[0]\n", + " jj = j[0]\n", + " increments = pt.switch(positions[ii] < cumulative_sum[jj], [1, 0], [0, 1])\n", + " indexes_update = pt.set_subtensor(indexes[ii], jj)\n", + " i_update = i + increments[0]\n", + " j_update = j + increments[1]\n", + " return [], {indexes: indexes_update, i: i_update, j: j_update}, until(ii >= n_particles)\n", + "\n", + " _, updates = pytensor.scan(\n", + " step,\n", + " non_sequences=[indexes, i, j, positions, cumulative_sum],\n", + " n_steps=n_particles ** 2,\n", + " )\n", + " inds = updates[indexes]\n", + " return particles[inds], pt.full(n_particles, -np.log(n_particles), dtype=log_weights.dtype)\n", + "\n", + "\n", + "def no_resample(particles, log_weights):\n", + " return particles, log_weights\n", + "\n", + "\n", + "def particle_filter(\n", + " observed_distances,\n", + " landmarks,\n", + " heading_changes,\n", + " velocities,\n", + " heading_noise,\n", + " velocity_noise,\n", + " sensor_noise,\n", + " dt=1.,\n", + " n_particles=1000,\n", + " initial_particles=None,\n", + "):\n", + " if initial_particles is None:\n", + " initial_particles = create_gaussian_particles(n_particles=n_particles)\n", + "\n", + " initial_weights = -pt.ones(n_particles) * np.log(n_particles)\n", + " \n", + "\n", + " def step(heading_change, velocity, observed_distance, particles, log_weights):\n", + " particles = predict(\n", + " particles=particles,\n", + " heading_change=heading_change,\n", + " velocity=velocity,\n", + " heading_noise=heading_noise,\n", + " velocity_noise=velocity_noise,\n", + " dt=dt,\n", + " )\n", + " \n", + " # incorporate measurements\n", + " log_weights = update(\n", + " particles=particles,\n", + " log_weights=log_weights,\n", + " observed=observed_distance,\n", + " sensor_noise=sensor_noise,\n", + " landmarks=landmarks,\n", + " )\n", + " \n", + " # resample if too few effective particles\n", + " particles, log_weights = pytensor.ifelse(\n", + " neff(log_weights) < n_particles/2,\n", + " systematic_resample(\n", + " particles=particles,\n", + " log_weights=log_weights,\n", + " n_particles=pt.as_tensor_variable(n_particles),\n", + " ),\n", + " no_resample(particles, log_weights),\n", + " )\n", + " return particles, log_weights\n", + "\n", + " [particles, weights], _ = pytensor.scan(\n", + " step,\n", + " sequences=[\n", + " pt.as_tensor_variable(heading_changes),\n", + " pt.as_tensor_variable(velocities),\n", + " pt.as_tensor_variable(observed_distances),\n", + " ],\n", + " outputs_info=[\n", + " initial_particles,\n", + " initial_weights,\n", + " ],\n", + " )\n", + " return particles, weights" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "74f09e9b-9daf-4f23-b151-9a4a55705da7", + "metadata": {}, + "outputs": [], + "source": [ + "landmarks = np.array([[-1, 2], [5, 10], [12,14], [18,21]])\n", + "heading_noise = 0.05\n", + "velocity_noise = 0.2\n", + "sensor_noise = 0.1\n", + "dt = 0.1\n", + "\n", + "initial_position = np.array([0, 0, np.pi/4])\n", + "n_time = 30\n", + "intended_headings = np.zeros(n_time)\n", + "max_speed = 12\n", + "intended_velocities = np.concatenate(\n", + " [\n", + " np.linspace(0, max_speed, n_time // 3),\n", + " np.full(n_time - 2 * (n_time // 3), max_speed),\n", + " np.linspace(max_speed, 0, n_time // 3),\n", + " ],\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "4ff6e6ba-5d44-4f97-bd8e-7bec510bf16a", + "metadata": {}, + "outputs": [], + "source": [ + "true_positions, _ = pytensor.scan(\n", + " predict,\n", + " outputs_info=[pt.as_tensor_variable([initial_position])],\n", + " sequences=[\n", + " pt.as_tensor_variable(intended_headings),\n", + " pt.as_tensor_variable(intended_velocities),\n", + " ],\n", + " non_sequences=[heading_noise, velocity_noise, dt],\n", + ")\n", + "true_positions = true_positions[:, 0].eval()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "27d07690-906b-4b91-89b3-f6318e9daa4d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(true_positions[:, 0], true_positions[:, 1], color=\"C0\", label=\"True position\")\n", + "for true_position in true_positions:\n", + " plt.plot(\n", + " true_position[0],\n", + " true_position[1],\n", + " marker=(3, 0, np.rad2deg(true_position[2])),\n", + " color=\"C0\",\n", + " )\n", + "plt.legend();" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e62a0284-6658-4497-942f-e3675770efc5", + "metadata": {}, + "outputs": [], + "source": [ + "observed_distances = distances(true_positions[..., :2], landmarks)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "5d5ec6e3-af61-4241-918a-2539c613518f", + "metadata": {}, + "outputs": [], + "source": [ + "particles, log_weights = particle_filter(\n", + " observed_distances=observed_distances,\n", + " landmarks=landmarks,\n", + " heading_changes=intended_headings,\n", + " velocities=intended_velocities,\n", + " heading_noise=heading_noise,\n", + " velocity_noise=velocity_noise,\n", + " sensor_noise=sensor_noise,\n", + " dt=dt,\n", + " n_particles=1000,\n", + " initial_particles=None,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "30fab4f8-1701-4a14-8fb6-27bc4f101520", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/tensor/rewriting/shape.py:156: UserWarning: Failed to infer_shape from Op Mul.\n", + "Input shapes: [(TensorConstant(TensorType(int64, shape=()), data=array(30)), TensorConstant(TensorType(int64, shape=()), data=array(2)), TensorConstant(TensorType(int64, shape=()), data=array(3))), (TensorConstant(TensorType(int64, shape=()), data=array(30)), TensorConstant(TensorType(int64, shape=()), data=array(1000)), TensorConstant(TensorType(int64, shape=()), data=array(1)))]\n", + "Exception encountered during infer_shape: \n", + "Exception message: Could not broadcast dimensions. Incompatible shapes were [(TensorConstant(TensorType(int64, shape=()), data=array(30)), TensorConstant(TensorType(int64, shape=()), data=array(2)), TensorConstant(TensorType(int64, shape=()), data=array(3))), (TensorConstant(TensorType(int64, shape=()), data=array(30)), TensorConstant(TensorType(int64, shape=()), data=array(1000)), ScalarConstant(ScalarType(int64), data=1))].\n", + "Traceback: Traceback (most recent call last):\n", + " File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/tensor/rewriting/shape.py\", line 132, in get_node_infer_shape\n", + " o_shapes = shape_infer(\n", + " ^^^^^^^^^^^^\n", + " File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/tensor/elemwise.py\", line 771, in infer_shape\n", + " out_shape = broadcast_shape(*i_shapes, arrays_are_shapes=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/tensor/extra_ops.py\", line 1451, in broadcast_shape\n", + " return broadcast_shape_iter(arrays, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/tensor/extra_ops.py\", line 1532, in broadcast_shape_iter\n", + " raise ValueError(\n", + "ValueError: Could not broadcast dimensions. Incompatible shapes were [(TensorConstant(TensorType(int64, shape=()), data=array(30)), TensorConstant(TensorType(int64, shape=()), data=array(2)), TensorConstant(TensorType(int64, shape=()), data=array(3))), (TensorConstant(TensorType(int64, shape=()), data=array(30)), TensorConstant(TensorType(int64, shape=()), data=array(1000)), ScalarConstant(ScalarType(int64), data=1))].\n", + "\n", + " warn(msg)\n", + "/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/tensor/rewriting/shape.py:156: UserWarning: Failed to infer_shape from Op Composite{(sqr((i0 - i1)) * i2)}.\n", + "Input shapes: [(TensorConstant(TensorType(int64, shape=()), data=array(30)), TensorConstant(TensorType(int64, shape=()), data=array(2)), TensorConstant(TensorType(int64, shape=()), data=array(3))), (TensorConstant(TensorType(int64, shape=()), data=array(1)), Shape_i{0}.0, Cast{int64}.0), (TensorConstant(TensorType(int64, shape=()), data=array(30)), TensorConstant(TensorType(int64, shape=()), data=array(1000)), TensorConstant(TensorType(int64, shape=()), data=array(1)))]\n", + "Exception encountered during infer_shape: \n", + "Exception message: Could not broadcast dimensions. Incompatible shapes were [(TensorConstant(TensorType(int64, shape=()), data=array(30)), TensorConstant(TensorType(int64, shape=()), data=array(2)), TensorConstant(TensorType(int64, shape=()), data=array(3))), (ScalarConstant(ScalarType(int64), data=1), Shape_i{0}.0, Cast{int64}.0), (TensorConstant(TensorType(int64, shape=()), data=array(30)), TensorConstant(TensorType(int64, shape=()), data=array(1000)), ScalarConstant(ScalarType(int64), data=1))].\n", + "Traceback: Traceback (most recent call last):\n", + " File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/tensor/rewriting/shape.py\", line 132, in get_node_infer_shape\n", + " o_shapes = shape_infer(\n", + " ^^^^^^^^^^^^\n", + " File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/tensor/elemwise.py\", line 771, in infer_shape\n", + " out_shape = broadcast_shape(*i_shapes, arrays_are_shapes=True)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/tensor/extra_ops.py\", line 1451, in broadcast_shape\n", + " return broadcast_shape_iter(arrays, **kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/tensor/extra_ops.py\", line 1532, in broadcast_shape_iter\n", + " raise ValueError(\n", + "ValueError: Could not broadcast dimensions. Incompatible shapes were [(TensorConstant(TensorType(int64, shape=()), data=array(30)), TensorConstant(TensorType(int64, shape=()), data=array(2)), TensorConstant(TensorType(int64, shape=()), data=array(3))), (ScalarConstant(ScalarType(int64), data=1), Shape_i{0}.0, Cast{int64}.0), (TensorConstant(TensorType(int64, shape=()), data=array(30)), TensorConstant(TensorType(int64, shape=()), data=array(1000)), ScalarConstant(ScalarType(int64), data=1))].\n", + "\n", + " warn(msg)\n" + ] + }, + { + "ename": "IndexError", + "evalue": "index out of bounds\nApply node that caused the error: Subtensor{i}(*3-, ScalarFromTensor.0)\nToposort index: 6\nInputs types: [TensorType(float64, shape=(None,)), ScalarType(int64)]\nInputs shapes: [(1000,), ()]\nInputs strides: [(8,), ()]\nInputs values: ['not shown', 1000]\nOutputs clients: [[ExpandDims{axis=0}(Subtensor{i}.0)]]\n\nBacktrace when the node is created (use PyTensor flag traceback__limit=N to make it longer):\n File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/IPython/core/interactiveshell.py\", line 3577, in run_code\n exec(code_obj, self.user_global_ns, self.user_ns)\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1489974652.py\", line 1, in \n particles, log_weights = particle_filter(\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 142, in particle_filter\n [particles, weights], _ = pytensor.scan(\n File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/basic.py\", line 854, in scan\n raw_inner_outputs = fn(*args)\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 133, in step\n systematic_resample(\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 80, in systematic_resample\n _, updates = pytensor.scan(\n File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/basic.py\", line 854, in scan\n raw_inner_outputs = fn(*args)\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 74, in step\n increments = pt.switch(positions[ii] < cumulative_sum[jj], [1, 0], [0, 1])\n\nHINT: Use the PyTensor flag `exception_verbosity=high` for a debug print-out and storage map footprint of this Apply node.\nApply node that caused the error: Scan{scan_fn, while_loop=True, inplace=none}(16960, Subtensor{:stop}.0, Subtensor{:stop}.0, Subtensor{:stop}.0, Composite{(0.001 * (i0 + i1))}.0, CumOp{None, add}.0)\nToposort index: 35\nInputs types: [TensorType(int16, shape=()), TensorType(int64, shape=(1, None)), TensorType(int64, shape=(2, None)), TensorType(int64, shape=(1, None)), TensorType(float64, shape=(1000,)), TensorType(float64, shape=(None,))]\nInputs shapes: [(), (1, 1), (2, 1000), (1, 1), (1000,), (1000,)]\nInputs strides: [(), (8, 8), (8000, 8), (8, 8), (8,), (8,)]\nInputs values: [array(16960, dtype=int16), array([[0]]), 'not shown', array([[0]]), 'not shown', 'not shown']\nOutputs clients: [[], [Subtensor{i}(Scan{scan_fn, while_loop=True, inplace=none}.1, -1)], []]\n\nHINT: Re-running with most PyTensor optimizations disabled could provide a back-trace showing when this node was created. This can be done by setting the PyTensor flag 'optimizer=fast_compile'. If that does not work, PyTensor optimizations can be disabled with 'optimizer=None'.\nHINT: Use the PyTensor flag `exception_verbosity=high` for a debug print-out and storage map footprint of this Apply node.\nApply node that caused the error: Scan{scan_fn, while_loop=False, inplace=all}(30, [[0. ... ]], [[[ 2.1862 ... 144801 ]]], SetSubtensor{:stop}.0, SetSubtensor{:stop}.0, RNG(), RNG(), RNG(), SetSubtensor{:stop}.0, SetSubtensor{:stop}.0, SetSubtensor{:stop}.0)\nToposort index: 26\nInputs types: [TensorType(int64, shape=()), TensorType(float64, shape=(30, 1)), TensorType(float64, shape=(30, 1, 4)), TensorType(float64, shape=(30, 1000, 3)), TensorType(float64, shape=(30, 1000)), RandomGeneratorType, RandomGeneratorType, RandomGeneratorType, TensorType(int64, shape=(16961, None)), TensorType(int64, shape=(16961, None)), TensorType(int64, shape=(16961, None))]\nInputs shapes: [(), (30, 1), (30, 1, 4), (30, 1000, 3), (30, 1000), 'No shapes', 'No shapes', 'No shapes', (16961, 1), (16961, 1000), (16961, 1)]\nInputs strides: [(), (8, 8), (32, 32, 8), (24000, 24, 8), (8000, 8), 'No strides', 'No strides', 'No strides', (8, 8), (8000, 8), (8, 8)]\nInputs values: [array(30), 'not shown', 'not shown', 'not shown', 'not shown', Generator(Philox) at 0x12A2D1620, Generator(Philox) at 0x12A287920, Generator(PCG64) at 0x12A2D2420, 'not shown', 'not shown', 'not shown']\nOutputs clients: [[Subtensor{:stop, :stop}(Scan{scan_fn, while_loop=False, inplace=all}.0, 30, 2), output[2](Scan{scan_fn, while_loop=False, inplace=all}.0)], [Exp(Scan{scan_fn, while_loop=False, inplace=all}.1), output[3](Scan{scan_fn, while_loop=False, inplace=all}.1)], [], []]\n\nHINT: Re-running with most PyTensor optimizations disabled could provide a back-trace showing when this node was created. This can be done by setting the PyTensor flag 'optimizer=fast_compile'. If that does not work, PyTensor optimizations can be disabled with 'optimizer=None'.\nHINT: Use the PyTensor flag `exception_verbosity=high` for a debug print-out and storage map footprint of this Apply node.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1907\u001b[0m, in \u001b[0;36mScan.perform\u001b[0;34m(self, node, inputs, output_storage)\u001b[0m\n\u001b[1;32m 1906\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1907\u001b[0m \u001b[43mvm\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1908\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n", + "\u001b[0;31mIndexError\u001b[0m: index out of bounds", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1907\u001b[0m, in \u001b[0;36mScan.perform\u001b[0;34m(self, node, inputs, output_storage)\u001b[0m\n\u001b[1;32m 1906\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1907\u001b[0m \u001b[43mvm\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1908\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1649\u001b[0m, in \u001b[0;36mScan.make_thunk..rval\u001b[0;34m(p, i, o, n, allow_gc)\u001b[0m\n\u001b[1;32m 1646\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrval\u001b[39m(\n\u001b[1;32m 1647\u001b[0m p\u001b[38;5;241m=\u001b[39mp, i\u001b[38;5;241m=\u001b[39mnode_input_storage, o\u001b[38;5;241m=\u001b[39mnode_output_storage, n\u001b[38;5;241m=\u001b[39mnode, allow_gc\u001b[38;5;241m=\u001b[39mallow_gc\n\u001b[1;32m 1648\u001b[0m ):\n\u001b[0;32m-> 1649\u001b[0m r \u001b[38;5;241m=\u001b[39m \u001b[43mp\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1650\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m o \u001b[38;5;129;01min\u001b[39;00m node\u001b[38;5;241m.\u001b[39moutputs:\n", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1915\u001b[0m, in \u001b[0;36mScan.perform\u001b[0;34m(self, node, inputs, output_storage)\u001b[0m\n\u001b[1;32m 1913\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(vm, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mthunks\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m 1914\u001b[0m \u001b[38;5;66;03m# For the CVM\u001b[39;00m\n\u001b[0;32m-> 1915\u001b[0m \u001b[43mlink_utils\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mraise_with_op\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1916\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmaker\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfgraph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1917\u001b[0m \u001b[43m \u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnodes\u001b[49m\u001b[43m[\u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mposition_of_error\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1918\u001b[0m \u001b[43m \u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mthunks\u001b[49m\u001b[43m[\u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mposition_of_error\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1919\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1920\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1921\u001b[0m \u001b[38;5;66;03m# For the c linker\u001b[39;00m\n\u001b[1;32m 1922\u001b[0m \u001b[38;5;66;03m# We don't have access from python to all the\u001b[39;00m\n\u001b[1;32m 1923\u001b[0m \u001b[38;5;66;03m# temps values So for now, we just don't print\u001b[39;00m\n\u001b[1;32m 1924\u001b[0m \u001b[38;5;66;03m# the extra shapes/strides info\u001b[39;00m\n", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/link/utils.py:524\u001b[0m, in \u001b[0;36mraise_with_op\u001b[0;34m(fgraph, node, thunk, exc_info, storage_map)\u001b[0m\n\u001b[1;32m 522\u001b[0m \u001b[38;5;66;03m# Some exception need extra parameter in inputs. So forget the\u001b[39;00m\n\u001b[1;32m 523\u001b[0m \u001b[38;5;66;03m# extra long error message in that case.\u001b[39;00m\n\u001b[0;32m--> 524\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exc_value\u001b[38;5;241m.\u001b[39mwith_traceback(exc_trace)\n", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1907\u001b[0m, in \u001b[0;36mScan.perform\u001b[0;34m(self, node, inputs, output_storage)\u001b[0m\n\u001b[1;32m 1906\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1907\u001b[0m \u001b[43mvm\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1908\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n", + "\u001b[0;31mIndexError\u001b[0m: index out of bounds\nApply node that caused the error: Subtensor{i}(*3-, ScalarFromTensor.0)\nToposort index: 6\nInputs types: [TensorType(float64, shape=(None,)), ScalarType(int64)]\nInputs shapes: [(1000,), ()]\nInputs strides: [(8,), ()]\nInputs values: ['not shown', 1000]\nOutputs clients: [[ExpandDims{axis=0}(Subtensor{i}.0)]]\n\nBacktrace when the node is created (use PyTensor flag traceback__limit=N to make it longer):\n File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/IPython/core/interactiveshell.py\", line 3577, in run_code\n exec(code_obj, self.user_global_ns, self.user_ns)\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1489974652.py\", line 1, in \n particles, log_weights = particle_filter(\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 142, in particle_filter\n [particles, weights], _ = pytensor.scan(\n File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/basic.py\", line 854, in scan\n raw_inner_outputs = fn(*args)\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 133, in step\n systematic_resample(\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 80, in systematic_resample\n _, updates = pytensor.scan(\n File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/basic.py\", line 854, in scan\n raw_inner_outputs = fn(*args)\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 74, in step\n increments = pt.switch(positions[ii] < cumulative_sum[jj], [1, 0], [0, 1])\n\nHINT: Use the PyTensor flag `exception_verbosity=high` for a debug print-out and storage map footprint of this Apply node.", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/compile/function/types.py:960\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 958\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 959\u001b[0m outputs \u001b[38;5;241m=\u001b[39m (\n\u001b[0;32m--> 960\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvm\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 961\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m output_subset \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 962\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mvm(output_subset\u001b[38;5;241m=\u001b[39moutput_subset)\n\u001b[1;32m 963\u001b[0m )\n\u001b[1;32m 964\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1649\u001b[0m, in \u001b[0;36mScan.make_thunk..rval\u001b[0;34m(p, i, o, n, allow_gc)\u001b[0m\n\u001b[1;32m 1646\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrval\u001b[39m(\n\u001b[1;32m 1647\u001b[0m p\u001b[38;5;241m=\u001b[39mp, i\u001b[38;5;241m=\u001b[39mnode_input_storage, o\u001b[38;5;241m=\u001b[39mnode_output_storage, n\u001b[38;5;241m=\u001b[39mnode, allow_gc\u001b[38;5;241m=\u001b[39mallow_gc\n\u001b[1;32m 1648\u001b[0m ):\n\u001b[0;32m-> 1649\u001b[0m r \u001b[38;5;241m=\u001b[39m \u001b[43mp\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1650\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m o \u001b[38;5;129;01min\u001b[39;00m node\u001b[38;5;241m.\u001b[39moutputs:\n", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1915\u001b[0m, in \u001b[0;36mScan.perform\u001b[0;34m(self, node, inputs, output_storage)\u001b[0m\n\u001b[1;32m 1913\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(vm, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mthunks\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m 1914\u001b[0m \u001b[38;5;66;03m# For the CVM\u001b[39;00m\n\u001b[0;32m-> 1915\u001b[0m \u001b[43mlink_utils\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mraise_with_op\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1916\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmaker\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfgraph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1917\u001b[0m \u001b[43m \u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnodes\u001b[49m\u001b[43m[\u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mposition_of_error\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1918\u001b[0m \u001b[43m \u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mthunks\u001b[49m\u001b[43m[\u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mposition_of_error\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1919\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1920\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1921\u001b[0m \u001b[38;5;66;03m# For the c linker\u001b[39;00m\n\u001b[1;32m 1922\u001b[0m \u001b[38;5;66;03m# We don't have access from python to all the\u001b[39;00m\n\u001b[1;32m 1923\u001b[0m \u001b[38;5;66;03m# temps values So for now, we just don't print\u001b[39;00m\n\u001b[1;32m 1924\u001b[0m \u001b[38;5;66;03m# the extra shapes/strides info\u001b[39;00m\n", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/link/utils.py:524\u001b[0m, in \u001b[0;36mraise_with_op\u001b[0;34m(fgraph, node, thunk, exc_info, storage_map)\u001b[0m\n\u001b[1;32m 522\u001b[0m \u001b[38;5;66;03m# Some exception need extra parameter in inputs. So forget the\u001b[39;00m\n\u001b[1;32m 523\u001b[0m \u001b[38;5;66;03m# extra long error message in that case.\u001b[39;00m\n\u001b[0;32m--> 524\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exc_value\u001b[38;5;241m.\u001b[39mwith_traceback(exc_trace)\n", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1907\u001b[0m, in \u001b[0;36mScan.perform\u001b[0;34m(self, node, inputs, output_storage)\u001b[0m\n\u001b[1;32m 1906\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1907\u001b[0m \u001b[43mvm\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1908\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1649\u001b[0m, in \u001b[0;36mScan.make_thunk..rval\u001b[0;34m(p, i, o, n, allow_gc)\u001b[0m\n\u001b[1;32m 1646\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrval\u001b[39m(\n\u001b[1;32m 1647\u001b[0m p\u001b[38;5;241m=\u001b[39mp, i\u001b[38;5;241m=\u001b[39mnode_input_storage, o\u001b[38;5;241m=\u001b[39mnode_output_storage, n\u001b[38;5;241m=\u001b[39mnode, allow_gc\u001b[38;5;241m=\u001b[39mallow_gc\n\u001b[1;32m 1648\u001b[0m ):\n\u001b[0;32m-> 1649\u001b[0m r \u001b[38;5;241m=\u001b[39m \u001b[43mp\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1650\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m o \u001b[38;5;129;01min\u001b[39;00m node\u001b[38;5;241m.\u001b[39moutputs:\n", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1915\u001b[0m, in \u001b[0;36mScan.perform\u001b[0;34m(self, node, inputs, output_storage)\u001b[0m\n\u001b[1;32m 1913\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(vm, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mthunks\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m 1914\u001b[0m \u001b[38;5;66;03m# For the CVM\u001b[39;00m\n\u001b[0;32m-> 1915\u001b[0m \u001b[43mlink_utils\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mraise_with_op\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1916\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmaker\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfgraph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1917\u001b[0m \u001b[43m \u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnodes\u001b[49m\u001b[43m[\u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mposition_of_error\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1918\u001b[0m \u001b[43m \u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mthunks\u001b[49m\u001b[43m[\u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mposition_of_error\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1919\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1920\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1921\u001b[0m \u001b[38;5;66;03m# For the c linker\u001b[39;00m\n\u001b[1;32m 1922\u001b[0m \u001b[38;5;66;03m# We don't have access from python to all the\u001b[39;00m\n\u001b[1;32m 1923\u001b[0m \u001b[38;5;66;03m# temps values So for now, we just don't print\u001b[39;00m\n\u001b[1;32m 1924\u001b[0m \u001b[38;5;66;03m# the extra shapes/strides info\u001b[39;00m\n", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/link/utils.py:524\u001b[0m, in \u001b[0;36mraise_with_op\u001b[0;34m(fgraph, node, thunk, exc_info, storage_map)\u001b[0m\n\u001b[1;32m 522\u001b[0m \u001b[38;5;66;03m# Some exception need extra parameter in inputs. So forget the\u001b[39;00m\n\u001b[1;32m 523\u001b[0m \u001b[38;5;66;03m# extra long error message in that case.\u001b[39;00m\n\u001b[0;32m--> 524\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exc_value\u001b[38;5;241m.\u001b[39mwith_traceback(exc_trace)\n", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1907\u001b[0m, in \u001b[0;36mScan.perform\u001b[0;34m(self, node, inputs, output_storage)\u001b[0m\n\u001b[1;32m 1906\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1907\u001b[0m \u001b[43mvm\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1908\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n", + "\u001b[0;31mIndexError\u001b[0m: index out of bounds\nApply node that caused the error: Subtensor{i}(*3-, ScalarFromTensor.0)\nToposort index: 6\nInputs types: [TensorType(float64, shape=(None,)), ScalarType(int64)]\nInputs shapes: [(1000,), ()]\nInputs strides: [(8,), ()]\nInputs values: ['not shown', 1000]\nOutputs clients: [[ExpandDims{axis=0}(Subtensor{i}.0)]]\n\nBacktrace when the node is created (use PyTensor flag traceback__limit=N to make it longer):\n File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/IPython/core/interactiveshell.py\", line 3577, in run_code\n exec(code_obj, self.user_global_ns, self.user_ns)\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1489974652.py\", line 1, in \n particles, log_weights = particle_filter(\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 142, in particle_filter\n [particles, weights], _ = pytensor.scan(\n File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/basic.py\", line 854, in scan\n raw_inner_outputs = fn(*args)\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 133, in step\n systematic_resample(\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 80, in systematic_resample\n _, updates = pytensor.scan(\n File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/basic.py\", line 854, in scan\n raw_inner_outputs = fn(*args)\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 74, in step\n increments = pt.switch(positions[ii] < cumulative_sum[jj], [1, 0], [0, 1])\n\nHINT: Use the PyTensor flag `exception_verbosity=high` for a debug print-out and storage map footprint of this Apply node.\nApply node that caused the error: Scan{scan_fn, while_loop=True, inplace=none}(16960, Subtensor{:stop}.0, Subtensor{:stop}.0, Subtensor{:stop}.0, Composite{(0.001 * (i0 + i1))}.0, CumOp{None, add}.0)\nToposort index: 35\nInputs types: [TensorType(int16, shape=()), TensorType(int64, shape=(1, None)), TensorType(int64, shape=(2, None)), TensorType(int64, shape=(1, None)), TensorType(float64, shape=(1000,)), TensorType(float64, shape=(None,))]\nInputs shapes: [(), (1, 1), (2, 1000), (1, 1), (1000,), (1000,)]\nInputs strides: [(), (8, 8), (8000, 8), (8, 8), (8,), (8,)]\nInputs values: [array(16960, dtype=int16), array([[0]]), 'not shown', array([[0]]), 'not shown', 'not shown']\nOutputs clients: [[], [Subtensor{i}(Scan{scan_fn, while_loop=True, inplace=none}.1, -1)], []]\n\nHINT: Re-running with most PyTensor optimizations disabled could provide a back-trace showing when this node was created. This can be done by setting the PyTensor flag 'optimizer=fast_compile'. If that does not work, PyTensor optimizations can be disabled with 'optimizer=None'.\nHINT: Use the PyTensor flag `exception_verbosity=high` for a debug print-out and storage map footprint of this Apply node.", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[10], line 4\u001b[0m\n\u001b[1;32m 1\u001b[0m estimate_mean, estimate_std \u001b[38;5;241m=\u001b[39m estimate(particles, log_weights)\n\u001b[1;32m 3\u001b[0m func \u001b[38;5;241m=\u001b[39m pytensor\u001b[38;5;241m.\u001b[39mfunction([], [estimate_mean, estimate_std, particles, log_weights])\n\u001b[0;32m----> 4\u001b[0m mean, std, parts, lws \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/compile/function/types.py:973\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 971\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mvm, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mthunks\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m 972\u001b[0m thunk \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mvm\u001b[38;5;241m.\u001b[39mthunks[\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mvm\u001b[38;5;241m.\u001b[39mposition_of_error]\n\u001b[0;32m--> 973\u001b[0m \u001b[43mraise_with_op\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 974\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmaker\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfgraph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 975\u001b[0m \u001b[43m \u001b[49m\u001b[43mnode\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnodes\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mposition_of_error\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 976\u001b[0m \u001b[43m \u001b[49m\u001b[43mthunk\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mthunk\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 977\u001b[0m \u001b[43m \u001b[49m\u001b[43mstorage_map\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mgetattr\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvm\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstorage_map\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 978\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 979\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 980\u001b[0m \u001b[38;5;66;03m# old-style linkers raise their own exceptions\u001b[39;00m\n\u001b[1;32m 981\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m\n", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/link/utils.py:524\u001b[0m, in \u001b[0;36mraise_with_op\u001b[0;34m(fgraph, node, thunk, exc_info, storage_map)\u001b[0m\n\u001b[1;32m 519\u001b[0m warnings\u001b[38;5;241m.\u001b[39mwarn(\n\u001b[1;32m 520\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mexc_type\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m error does not allow us to add an extra error message\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 521\u001b[0m )\n\u001b[1;32m 522\u001b[0m \u001b[38;5;66;03m# Some exception need extra parameter in inputs. So forget the\u001b[39;00m\n\u001b[1;32m 523\u001b[0m \u001b[38;5;66;03m# extra long error message in that case.\u001b[39;00m\n\u001b[0;32m--> 524\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exc_value\u001b[38;5;241m.\u001b[39mwith_traceback(exc_trace)\n", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/compile/function/types.py:960\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 957\u001b[0m t0_fn \u001b[38;5;241m=\u001b[39m time\u001b[38;5;241m.\u001b[39mperf_counter()\n\u001b[1;32m 958\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 959\u001b[0m outputs \u001b[38;5;241m=\u001b[39m (\n\u001b[0;32m--> 960\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvm\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 961\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m output_subset \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 962\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mvm(output_subset\u001b[38;5;241m=\u001b[39moutput_subset)\n\u001b[1;32m 963\u001b[0m )\n\u001b[1;32m 964\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n\u001b[1;32m 965\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_restore_defaults()\n", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1649\u001b[0m, in \u001b[0;36mScan.make_thunk..rval\u001b[0;34m(p, i, o, n, allow_gc)\u001b[0m\n\u001b[1;32m 1646\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrval\u001b[39m(\n\u001b[1;32m 1647\u001b[0m p\u001b[38;5;241m=\u001b[39mp, i\u001b[38;5;241m=\u001b[39mnode_input_storage, o\u001b[38;5;241m=\u001b[39mnode_output_storage, n\u001b[38;5;241m=\u001b[39mnode, allow_gc\u001b[38;5;241m=\u001b[39mallow_gc\n\u001b[1;32m 1648\u001b[0m ):\n\u001b[0;32m-> 1649\u001b[0m r \u001b[38;5;241m=\u001b[39m \u001b[43mp\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1650\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m o \u001b[38;5;129;01min\u001b[39;00m node\u001b[38;5;241m.\u001b[39moutputs:\n\u001b[1;32m 1651\u001b[0m compute_map[o][\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1915\u001b[0m, in \u001b[0;36mScan.perform\u001b[0;34m(self, node, inputs, output_storage)\u001b[0m\n\u001b[1;32m 1909\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(vm, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mposition_of_error\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m 1910\u001b[0m \u001b[38;5;66;03m# this is a new vm-provided function or c linker\u001b[39;00m\n\u001b[1;32m 1911\u001b[0m \u001b[38;5;66;03m# they need this because the exception manipulation\u001b[39;00m\n\u001b[1;32m 1912\u001b[0m \u001b[38;5;66;03m# done by raise_with_op is not implemented in C.\u001b[39;00m\n\u001b[1;32m 1913\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(vm, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mthunks\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m 1914\u001b[0m \u001b[38;5;66;03m# For the CVM\u001b[39;00m\n\u001b[0;32m-> 1915\u001b[0m \u001b[43mlink_utils\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mraise_with_op\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1916\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmaker\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfgraph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1917\u001b[0m \u001b[43m \u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnodes\u001b[49m\u001b[43m[\u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mposition_of_error\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1918\u001b[0m \u001b[43m \u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mthunks\u001b[49m\u001b[43m[\u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mposition_of_error\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1919\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1920\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1921\u001b[0m \u001b[38;5;66;03m# For the c linker\u001b[39;00m\n\u001b[1;32m 1922\u001b[0m \u001b[38;5;66;03m# We don't have access from python to all the\u001b[39;00m\n\u001b[1;32m 1923\u001b[0m \u001b[38;5;66;03m# temps values So for now, we just don't print\u001b[39;00m\n\u001b[1;32m 1924\u001b[0m \u001b[38;5;66;03m# the extra shapes/strides info\u001b[39;00m\n\u001b[1;32m 1925\u001b[0m link_utils\u001b[38;5;241m.\u001b[39mraise_with_op(\n\u001b[1;32m 1926\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfn\u001b[38;5;241m.\u001b[39mmaker\u001b[38;5;241m.\u001b[39mfgraph, vm\u001b[38;5;241m.\u001b[39mnodes[vm\u001b[38;5;241m.\u001b[39mposition_of_error]\n\u001b[1;32m 1927\u001b[0m )\n", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/link/utils.py:524\u001b[0m, in \u001b[0;36mraise_with_op\u001b[0;34m(fgraph, node, thunk, exc_info, storage_map)\u001b[0m\n\u001b[1;32m 519\u001b[0m warnings\u001b[38;5;241m.\u001b[39mwarn(\n\u001b[1;32m 520\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mexc_type\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m error does not allow us to add an extra error message\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 521\u001b[0m )\n\u001b[1;32m 522\u001b[0m \u001b[38;5;66;03m# Some exception need extra parameter in inputs. So forget the\u001b[39;00m\n\u001b[1;32m 523\u001b[0m \u001b[38;5;66;03m# extra long error message in that case.\u001b[39;00m\n\u001b[0;32m--> 524\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exc_value\u001b[38;5;241m.\u001b[39mwith_traceback(exc_trace)\n", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1907\u001b[0m, in \u001b[0;36mScan.perform\u001b[0;34m(self, node, inputs, output_storage)\u001b[0m\n\u001b[1;32m 1904\u001b[0m t0_fn \u001b[38;5;241m=\u001b[39m time\u001b[38;5;241m.\u001b[39mperf_counter()\n\u001b[1;32m 1906\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1907\u001b[0m \u001b[43mvm\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1908\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n\u001b[1;32m 1909\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(vm, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mposition_of_error\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m 1910\u001b[0m \u001b[38;5;66;03m# this is a new vm-provided function or c linker\u001b[39;00m\n\u001b[1;32m 1911\u001b[0m \u001b[38;5;66;03m# they need this because the exception manipulation\u001b[39;00m\n\u001b[1;32m 1912\u001b[0m \u001b[38;5;66;03m# done by raise_with_op is not implemented in C.\u001b[39;00m\n", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1649\u001b[0m, in \u001b[0;36mScan.make_thunk..rval\u001b[0;34m(p, i, o, n, allow_gc)\u001b[0m\n\u001b[1;32m 1646\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrval\u001b[39m(\n\u001b[1;32m 1647\u001b[0m p\u001b[38;5;241m=\u001b[39mp, i\u001b[38;5;241m=\u001b[39mnode_input_storage, o\u001b[38;5;241m=\u001b[39mnode_output_storage, n\u001b[38;5;241m=\u001b[39mnode, allow_gc\u001b[38;5;241m=\u001b[39mallow_gc\n\u001b[1;32m 1648\u001b[0m ):\n\u001b[0;32m-> 1649\u001b[0m r \u001b[38;5;241m=\u001b[39m \u001b[43mp\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1650\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m o \u001b[38;5;129;01min\u001b[39;00m node\u001b[38;5;241m.\u001b[39moutputs:\n\u001b[1;32m 1651\u001b[0m compute_map[o][\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1915\u001b[0m, in \u001b[0;36mScan.perform\u001b[0;34m(self, node, inputs, output_storage)\u001b[0m\n\u001b[1;32m 1909\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(vm, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mposition_of_error\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m 1910\u001b[0m \u001b[38;5;66;03m# this is a new vm-provided function or c linker\u001b[39;00m\n\u001b[1;32m 1911\u001b[0m \u001b[38;5;66;03m# they need this because the exception manipulation\u001b[39;00m\n\u001b[1;32m 1912\u001b[0m \u001b[38;5;66;03m# done by raise_with_op is not implemented in C.\u001b[39;00m\n\u001b[1;32m 1913\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(vm, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mthunks\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m 1914\u001b[0m \u001b[38;5;66;03m# For the CVM\u001b[39;00m\n\u001b[0;32m-> 1915\u001b[0m \u001b[43mlink_utils\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mraise_with_op\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1916\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmaker\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfgraph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1917\u001b[0m \u001b[43m \u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnodes\u001b[49m\u001b[43m[\u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mposition_of_error\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1918\u001b[0m \u001b[43m \u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mthunks\u001b[49m\u001b[43m[\u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mposition_of_error\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1919\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1920\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1921\u001b[0m \u001b[38;5;66;03m# For the c linker\u001b[39;00m\n\u001b[1;32m 1922\u001b[0m \u001b[38;5;66;03m# We don't have access from python to all the\u001b[39;00m\n\u001b[1;32m 1923\u001b[0m \u001b[38;5;66;03m# temps values So for now, we just don't print\u001b[39;00m\n\u001b[1;32m 1924\u001b[0m \u001b[38;5;66;03m# the extra shapes/strides info\u001b[39;00m\n\u001b[1;32m 1925\u001b[0m link_utils\u001b[38;5;241m.\u001b[39mraise_with_op(\n\u001b[1;32m 1926\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfn\u001b[38;5;241m.\u001b[39mmaker\u001b[38;5;241m.\u001b[39mfgraph, vm\u001b[38;5;241m.\u001b[39mnodes[vm\u001b[38;5;241m.\u001b[39mposition_of_error]\n\u001b[1;32m 1927\u001b[0m )\n", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/link/utils.py:524\u001b[0m, in \u001b[0;36mraise_with_op\u001b[0;34m(fgraph, node, thunk, exc_info, storage_map)\u001b[0m\n\u001b[1;32m 519\u001b[0m warnings\u001b[38;5;241m.\u001b[39mwarn(\n\u001b[1;32m 520\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mexc_type\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m error does not allow us to add an extra error message\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 521\u001b[0m )\n\u001b[1;32m 522\u001b[0m \u001b[38;5;66;03m# Some exception need extra parameter in inputs. So forget the\u001b[39;00m\n\u001b[1;32m 523\u001b[0m \u001b[38;5;66;03m# extra long error message in that case.\u001b[39;00m\n\u001b[0;32m--> 524\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exc_value\u001b[38;5;241m.\u001b[39mwith_traceback(exc_trace)\n", + "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1907\u001b[0m, in \u001b[0;36mScan.perform\u001b[0;34m(self, node, inputs, output_storage)\u001b[0m\n\u001b[1;32m 1904\u001b[0m t0_fn \u001b[38;5;241m=\u001b[39m time\u001b[38;5;241m.\u001b[39mperf_counter()\n\u001b[1;32m 1906\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1907\u001b[0m \u001b[43mvm\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1908\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n\u001b[1;32m 1909\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(vm, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mposition_of_error\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m 1910\u001b[0m \u001b[38;5;66;03m# this is a new vm-provided function or c linker\u001b[39;00m\n\u001b[1;32m 1911\u001b[0m \u001b[38;5;66;03m# they need this because the exception manipulation\u001b[39;00m\n\u001b[1;32m 1912\u001b[0m \u001b[38;5;66;03m# done by raise_with_op is not implemented in C.\u001b[39;00m\n", + "\u001b[0;31mIndexError\u001b[0m: index out of bounds\nApply node that caused the error: Subtensor{i}(*3-, ScalarFromTensor.0)\nToposort index: 6\nInputs types: [TensorType(float64, shape=(None,)), ScalarType(int64)]\nInputs shapes: [(1000,), ()]\nInputs strides: [(8,), ()]\nInputs values: ['not shown', 1000]\nOutputs clients: [[ExpandDims{axis=0}(Subtensor{i}.0)]]\n\nBacktrace when the node is created (use PyTensor flag traceback__limit=N to make it longer):\n File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/IPython/core/interactiveshell.py\", line 3577, in run_code\n exec(code_obj, self.user_global_ns, self.user_ns)\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1489974652.py\", line 1, in \n particles, log_weights = particle_filter(\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 142, in particle_filter\n [particles, weights], _ = pytensor.scan(\n File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/basic.py\", line 854, in scan\n raw_inner_outputs = fn(*args)\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 133, in step\n systematic_resample(\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 80, in systematic_resample\n _, updates = pytensor.scan(\n File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/basic.py\", line 854, in scan\n raw_inner_outputs = fn(*args)\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 74, in step\n increments = pt.switch(positions[ii] < cumulative_sum[jj], [1, 0], [0, 1])\n\nHINT: Use the PyTensor flag `exception_verbosity=high` for a debug print-out and storage map footprint of this Apply node.\nApply node that caused the error: Scan{scan_fn, while_loop=True, inplace=none}(16960, Subtensor{:stop}.0, Subtensor{:stop}.0, Subtensor{:stop}.0, Composite{(0.001 * (i0 + i1))}.0, CumOp{None, add}.0)\nToposort index: 35\nInputs types: [TensorType(int16, shape=()), TensorType(int64, shape=(1, None)), TensorType(int64, shape=(2, None)), TensorType(int64, shape=(1, None)), TensorType(float64, shape=(1000,)), TensorType(float64, shape=(None,))]\nInputs shapes: [(), (1, 1), (2, 1000), (1, 1), (1000,), (1000,)]\nInputs strides: [(), (8, 8), (8000, 8), (8, 8), (8,), (8,)]\nInputs values: [array(16960, dtype=int16), array([[0]]), 'not shown', array([[0]]), 'not shown', 'not shown']\nOutputs clients: [[], [Subtensor{i}(Scan{scan_fn, while_loop=True, inplace=none}.1, -1)], []]\n\nHINT: Re-running with most PyTensor optimizations disabled could provide a back-trace showing when this node was created. This can be done by setting the PyTensor flag 'optimizer=fast_compile'. If that does not work, PyTensor optimizations can be disabled with 'optimizer=None'.\nHINT: Use the PyTensor flag `exception_verbosity=high` for a debug print-out and storage map footprint of this Apply node.\nApply node that caused the error: Scan{scan_fn, while_loop=False, inplace=all}(30, [[0. ... ]], [[[ 2.1862 ... 144801 ]]], SetSubtensor{:stop}.0, SetSubtensor{:stop}.0, RNG(), RNG(), RNG(), SetSubtensor{:stop}.0, SetSubtensor{:stop}.0, SetSubtensor{:stop}.0)\nToposort index: 26\nInputs types: [TensorType(int64, shape=()), TensorType(float64, shape=(30, 1)), TensorType(float64, shape=(30, 1, 4)), TensorType(float64, shape=(30, 1000, 3)), TensorType(float64, shape=(30, 1000)), RandomGeneratorType, RandomGeneratorType, RandomGeneratorType, TensorType(int64, shape=(16961, None)), TensorType(int64, shape=(16961, None)), TensorType(int64, shape=(16961, None))]\nInputs shapes: [(), (30, 1), (30, 1, 4), (30, 1000, 3), (30, 1000), 'No shapes', 'No shapes', 'No shapes', (16961, 1), (16961, 1000), (16961, 1)]\nInputs strides: [(), (8, 8), (32, 32, 8), (24000, 24, 8), (8000, 8), 'No strides', 'No strides', 'No strides', (8, 8), (8000, 8), (8, 8)]\nInputs values: [array(30), 'not shown', 'not shown', 'not shown', 'not shown', Generator(Philox) at 0x12A2D1620, Generator(Philox) at 0x12A287920, Generator(PCG64) at 0x12A2D2420, 'not shown', 'not shown', 'not shown']\nOutputs clients: [[Subtensor{:stop, :stop}(Scan{scan_fn, while_loop=False, inplace=all}.0, 30, 2), output[2](Scan{scan_fn, while_loop=False, inplace=all}.0)], [Exp(Scan{scan_fn, while_loop=False, inplace=all}.1), output[3](Scan{scan_fn, while_loop=False, inplace=all}.1)], [], []]\n\nHINT: Re-running with most PyTensor optimizations disabled could provide a back-trace showing when this node was created. This can be done by setting the PyTensor flag 'optimizer=fast_compile'. If that does not work, PyTensor optimizations can be disabled with 'optimizer=None'.\nHINT: Use the PyTensor flag `exception_verbosity=high` for a debug print-out and storage map footprint of this Apply node." + ] + } + ], + "source": [ + "estimate_mean, estimate_std = estimate(particles, log_weights)\n", + "\n", + "func = pytensor.function([], [estimate_mean, estimate_std, particles, log_weights])\n", + "mean, std, parts, lws = func()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c462f598-961e-42ff-9b27-20d87a8de753", + "metadata": {}, + "outputs": [], + "source": [ + "plt.plot(true_positions[:, 0], true_positions[:, 1], color=\"k\", label=\"True position\")\n", + "plt.errorbar(mean[:, 0], mean[:, 1], std[:, 0], std[:, 1], color=\"C0\", label=\"Estimate position\")\n", + "plt.scatter(parts[:, 0], parts[:, 1], c=1, s=np.exp(lws) * 10, cmap=\"greens\")\n", + "plt.legend();" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pymc", + "language": "python", + "name": "pymc" + }, + "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.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 9d454511c7057e507c1b5a222506e43fef62bcb5 Mon Sep 17 00:00:00 2001 From: Luciano Paz Date: Thu, 6 Feb 2025 11:52:52 +0100 Subject: [PATCH 2/4] Fix scan until condition and estimate broadcasting --- notebooks/exercises/particle_filter.ipynb | 148 ++++++---------------- 1 file changed, 38 insertions(+), 110 deletions(-) diff --git a/notebooks/exercises/particle_filter.ipynb b/notebooks/exercises/particle_filter.ipynb index 3975520..14ba0d9 100644 --- a/notebooks/exercises/particle_filter.ipynb +++ b/notebooks/exercises/particle_filter.ipynb @@ -66,9 +66,9 @@ " particles = pt.set_subtensor(particles[:, 2], particles[:, 2] % (2 * np.pi))\n", " return particles\n", "\n", - "def predict(heading_change, velocity, particles, heading_noise, velocity_noise, dt):\n", - " \"\"\" move according to control input u (heading change, velocity)\n", - " with noise Q (std heading change, std velocity)`\"\"\"\n", + "def temporal_evolution(heading_change, velocity, particles, heading_noise, velocity_noise, dt):\n", + " \"\"\" move according to control input (heading change, velocity)\n", + " with noise (std heading change, std velocity)`\"\"\"\n", "\n", " N = particles.shape[0]\n", " # update heading\n", @@ -96,7 +96,7 @@ " return pt.sqrt(distances2(positions, landmarks))\n", "\n", "\n", - "def update(log_weights, particles, observed, sensor_noise, landmarks):\n", + "def update_weights(log_weights, particles, observed, sensor_noise, landmarks):\n", " dist_to_land = distances(particles[..., :2], landmarks)\n", " log_weights += pm.logprob.logp(\n", " pm.Normal.dist(dist_to_land, sensor_noise),\n", @@ -109,9 +109,9 @@ "def estimate(particles, log_weights):\n", " \"\"\"returns mean and variance of the weighted particles\"\"\"\n", "\n", - " pos = particles[:, :2]\n", - " mean = pt.sum(pos * pt.exp(log_weights)[..., None], axis=-2) / pt.exp(log_weights).sum(axis=-1)\n", - " var = pt.sum((pos - mean)**2 * pt.exp(log_weights)[..., None], axis=-2) / pt.exp(log_weights).sum(axis=-1)\n", + " pos = particles[..., :2]\n", + " mean = pt.sum(pos * pt.exp(log_weights)[..., None], axis=-2) / pt.exp(log_weights[..., None]).sum(axis=-2)\n", + " var = pt.sum((pos - mean[..., None, :])**2 * pt.exp(log_weights)[..., None], axis=-2) / pt.exp(log_weights[..., None]).sum(axis=-2)\n", " return mean, pt.sqrt(var)\n", "\n", "\n", @@ -137,7 +137,7 @@ " indexes_update = pt.set_subtensor(indexes[ii], jj)\n", " i_update = i + increments[0]\n", " j_update = j + increments[1]\n", - " return [], {indexes: indexes_update, i: i_update, j: j_update}, until(ii >= n_particles)\n", + " return [], {indexes: indexes_update, i: i_update, j: j_update}, until(pt.ge(ii, n_particles - 1))\n", "\n", " _, updates = pytensor.scan(\n", " step,\n", @@ -171,7 +171,7 @@ " \n", "\n", " def step(heading_change, velocity, observed_distance, particles, log_weights):\n", - " particles = predict(\n", + " particles = temporal_evolution(\n", " particles=particles,\n", " heading_change=heading_change,\n", " velocity=velocity,\n", @@ -181,7 +181,7 @@ " )\n", " \n", " # incorporate measurements\n", - " log_weights = update(\n", + " log_weights = update_weights(\n", " particles=particles,\n", " log_weights=log_weights,\n", " observed=observed_distance,\n", @@ -231,8 +231,8 @@ "\n", "initial_position = np.array([0, 0, np.pi/4])\n", "n_time = 30\n", - "intended_headings = np.zeros(n_time)\n", - "max_speed = 12\n", + "intended_headings = np.deg2rad(6 * np.sin(np.linspace(0, 2 * np.pi, n_time)))\n", + "max_speed = 5\n", "intended_velocities = np.concatenate(\n", " [\n", " np.linspace(0, max_speed, n_time // 3),\n", @@ -250,7 +250,7 @@ "outputs": [], "source": [ "true_positions, _ = pytensor.scan(\n", - " predict,\n", + " temporal_evolution,\n", " outputs_info=[pt.as_tensor_variable([initial_position])],\n", " sequences=[\n", " pt.as_tensor_variable(intended_headings),\n", @@ -269,7 +269,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAisAAAGdCAYAAADT1TPdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABLjElEQVR4nO3dd3hUVf7H8ffMJJn0BBJIgRBCT6gBlCIIKsWIiIJSRVD0Z0GURdeGBd0VFAVRAXXVBQsqugjLWgGlqBQpoQhIDUVISGippM3c3x+RSEgogSRT8nk9zzyauefOfC83w3w499xzTIZhGIiIiIg4KbOjCxARERE5H4UVERERcWoKKyIiIuLUFFZERETEqSmsiIiIiFNTWBERERGnprAiIiIiTk1hRURERJyah6MLOJvdbufw4cMEBARgMpkcXY6IiIhcBMMwyMzMJDIyErO5YvtCnC6sHD58mKioKEeXISIiIpfg4MGD1K1bt0Jf0+nCSkBAAFB0sIGBgQ6uRkRERC5GRkYGUVFRxd/jFcnpwsrpSz+BgYEKKyIiIi6mMoZwaICtiIiIODWFFREREXFqCisiIiLi1JxuzMrFMAyDwsJCbDabo0sRJ+Xp6YnFYnF0GSIiUgFcLqzk5+eTnJxMTk6Oo0sRJ2Yymahbty7+/v6OLkVERC6TS4UVu91OUlISFouFyMhIvLy8NHGclGIYBmlpafzxxx80btxYPSwiIi7OpcJKfn4+drudqKgofH19HV2OOLFatWqxb98+CgoKFFZERFycSw6wrehpfMX9qMdNRMR96FtfREREnJrCilSoZcuWYTKZOHny5Hnb1a9fn2nTplVJTSIiAll5hazddxzDMBxdSrkprFQBk8l03sfIkSMdXWKF6dy5M8nJyQQFBQEwe/ZsgoODS7Vbu3Yt//d//1fF1YmIVF8PfrKB295eRdfJS5mxdDcp6bmOLumiudQAW1eVnJxc/P9z587l2WefZceOHcXP+fj4lGhfUFCAp6dnldVXkby8vAgPD79gu1q1alVBNSIi1VtWXiE/bD9Cr7hwavp6YTLBHydOMWXRDl5dtIOujUIZfGU9routjdXDeW9GUM9KFQgPDy9+BAUFYTKZin/Ozc0lODiYzz//nO7du+Pt7c3HH3/MhAkTaNOmTYnXmTZtGvXr1y/x3KxZs4iNjcXb25tmzZoxc+bM89bSvXt3HnzwQR588EGCg4MJCQnh6aefLtEteOLECe644w5q1KiBr68vCQkJ7Nq1q3j7/v376du3LzVq1MDPz4/mzZvzzTffACUvAy1btow777yT9PT04l6kCRMmAKUvAx04cIB+/frh7+9PYGAgAwcO5MiRI8XbT/95fPTRR9SvX5+goCAGDx5MZmZmOc6EiEj18uLX23j4s41c8eIS/jh5itO3HtgNMAz4ZfcxHpizge6vLHNkmRfk8mHFMAxy8gsd8qjI636PP/44Dz30ENu3b6d3794Xtc+7777L+PHjefHFF9m+fTsTJ07kmWee4YMPPjjvfh988AEeHh6sWbOGN954g9dee4333nuvePvIkSNZt24dCxcuZNWqVRiGwQ033EBBQQEAo0ePJi8vjxUrVrBlyxZefvnlMidf69y5M9OmTSMwMJDk5GSSk5N59NFHS7UzDIObb76Z48ePs3z5chYvXsyePXsYNGhQiXZ79uxhwYIFfPXVV3z11VcsX76cl1566aL+rEREqqNgXy/MpqIell+TjmM/62vLZhiYTFDD1wvb2RudiMtfBjpVYCPu2e8d8t7bXuiNr1fF/BGOHTuW/v37l2uff/zjH0yZMqV4v5iYGLZt28Y777zDiBEjzrlfVFQUr732GiaTiaZNm7JlyxZee+017rnnHnbt2sXChQv55Zdf6Ny5MwBz5swhKiqKBQsWcNttt3HgwAEGDBhAy5YtAWjQoEGZ7+Pl5VWiJ+lclixZwubNm0lKSiIqKgqAjz76iObNm7N27VquuOIKoGhSwNmzZxMQEADA8OHD+eGHH3jxxRfL9ecmIuJusvIKWb//BF0ahWIx/zV1Q1iAtVRAOVu/1pG8NKBVif2cjcuHFXfRvn37crVPS0vj4MGDjBo1invuuaf4+cLCwuLBrefSsWPHEvOQdOrUiSlTpmCz2di+fTseHh506NCheHtISAhNmzZl+/btADz00EPcf//9LFq0iB49ejBgwABatWpVrvrPtH37dqKiooqDCkBcXBzBwcFs3769OKzUr1+/OKgAREREkJqaesnvKyLiLh79YhPf/ZZCLX8rwzrWo398HX7Zc4zpS3efd78nEppx79UNnH5uKpcPKz6eFra9cHGXTSrjvSuKn59fiZ/NZnOpy0ynL8NAUS8DFF0KOjNYAJc1Y+u5Lm0ZhlH8y3z33XfTu3dvvv76axYtWsSkSZOYMmUKY8aMueT3LOuDcvbzZw86NplMxX8OIiLVWY0/L/ekZeXx+pJdTFuy67ztzSZ4bVAb+rWpU0UVXh6XDysmk6nCLsU4k1q1apGSklLiC3vjxo3F28PCwqhTpw579+5l2LBh5Xrt1atXl/r59Bo6cXFxFBYWsmbNmuLLQMeOHWPnzp3ExsYW7xMVFcV9993Hfffdx5NPPsm7775bZljx8vK64OrYcXFxHDhwgIMHDxb3rmzbto309PQS7ykiImWrV9OH0//WPNdVH7OpaGBteKA3n9zTgQa1XGehV/f7lncT3bt3Jy0tjcmTJ3Prrbfy3Xff8e233xIYGFjcZsKECTz00EMEBgaSkJBAXl4e69at48SJE4wbN+6cr33w4EHGjRvHvffey4YNG3jzzTeZMmUKAI0bN6Zfv37cc889vPPOOwQEBPDEE09Qp04d+vXrBxSNr0lISKBJkyacOHGCH3/88Zyhon79+mRlZfHDDz/QunVrfH19S63r1KNHD1q1asWwYcOYNm0ahYWFPPDAA3Tr1q3cl8dERNzR6QndujYKxcPy170xNrvB/zYd5t+/JJ0zpJwW6m9l5rC2tK9fs3KLrQQufzeQu4qNjWXmzJnMmDGD1q1b8+uvv5a6k+buu+/mvffeY/bs2bRs2ZJu3boxe/ZsYmJizvvad9xxB6dOneLKK69k9OjRjBkzpsQEbbNmzaJdu3bceOONdOrUCcMw+Oabb4ovw9hsNkaPHk1sbCzXX389TZs2Pect0507d+a+++5j0KBB1KpVi8mTJ5dqYzKZWLBgATVq1ODqq6+mR48eNGjQgLlz55b3j01ExC099p/N3DlrLR0n/cBri3dy+GQO3/2WQsLrKxg7dyNpmfll7te7eRh3XVWfG1pGsOhvV7tkUAEwGU42725GRgZBQUGkp6eX6EUAyM3NJSkpiZiYGLy9vR1UoWvr3r07bdq0cfup7vW7IiLu5OkFW/hkzQHsBphMcOY3d4DVwt1dGzBtyS4Mii73GMDj11ft4NnzfX9fLvWsiIiIOLn6IX7Fl3nO7mII8bfycI8m1AqwAuBv9eDjUR24r1tDp7/L52JpzIqIiIgT23jwJF9u+KNUSIGiXha7UTR2ZXjHaH7efZSpg9pQJ9indGMXprBSzSxbtszRJYiIyJ8ycwvYeSSLtvWCS/WCbE/OYMqinSzZfuQce0OP2DCmDmyNxWxizHWNGXNd48ou2SEUVkRERBxk9CeJrNiZRr2avgy6IooBbeuSlVfItCU7+Wpz0SK4ZhPc1LoOCzYeKv7ZEWNSHElhRURExEFq+HpiAg4cz2HKoh288v2OEttvbBXB2B5NaFTbn592pXEsO58Ab0/eGtaWzo1CHVO0A7hkWHGyG5jECel3RERcQePa/phNYDMotYZPiJ8X04e2Lf75jk7RrN57nKmDWhMR5F5jUi7EpcLK6Xk+cnJy8PGpXidKyic/v2jOgctZekBEpDJl5haw9XAGtnMMnI0I9sZmN4oXGHy4RxMeruIanYVLhRWLxUJwcHDx4nW+vr7V4lqdlI/dbictLQ1fX188PFzqV1xEqoH8Qjtz1uznzR93czy77Mnc+rWpw0v9Wzr1SshVyeX+Jg8PDwfQartyXmazmXr16inMiojTsNsN/rf5MK8u2sHB46cAiAn1Zf+xnOLJ3jDgqRtiubtrjP7+OoPLhRWTyURERAS1a9cusQqxyJm8vLwwmzXnoYhUnay8QjzMJrw9S19+/mX3UV769ne2HEoHoFaAlb/1aMLA9nXp+doKko5m4+NpYeawtnRvWruqS3d6LhdWTrNYLBqPICIiTsFuN7h5+s8cPHGKqxqF0iM2jGub1eZYdh4vffs7P+06ChTNLnvv1Q0Y1TUGX6+ir+BhHeqxYOMhXh8cT0MXWgm5KrnU2kAiIiLO6urJSzlwPAfLn3f3nMnDDLd3rM+YaxsR4m91TIGVTGsDiYiIOLmrGoXgYTaVeXePn9WT5/rGuW1QqWzlCiuTJk3iiiuuICAggNq1a3PzzTezY0fJCWwMw2DChAlERkbi4+ND9+7d2bp1a4UWLSIi4mx8vTwoPHuylD8N7VCviqtxL+UKK8uXL2f06NGsXr2axYsXU1hYSK9evcjOzi5uM3nyZKZOncr06dNZu3Yt4eHh9OzZk8zMzAovXkRExNGOZOTywJz1vP9zUpnb/967KY9f30x391yGyxqzkpaWRu3atVm+fDlXX301hmEQGRnJ2LFjefzxxwHIy8sjLCyMl19+mXvvvfeCr6kxKyIi4grsdoM5vx5g8re/k5lXiMVswuphJiffVtzm2RvjuKtLjAOrrDpOO2YlPb3oFqyaNWsCkJSUREpKCr169SpuY7Va6datGytXrizzNfLy8sjIyCjxEBERcWY7UjK57Z1VPLPgNzLzCmldN4iFD15F7+ZFc4GZgJcHtKw2QaWyXfKty4ZhMG7cOLp06UKLFi0ASElJASAsLKxE27CwMPbv31/m60yaNInnn3/+UssQERGpMrkFNt78cRfvLN9Lod3Az8vCo72bcken+ljMJhJahPPzrqM8fWMs/drUcXS5buOSw8qDDz7I5s2b+fnnn0ttO/u6nGEY57xW9+STTzJu3LjinzMyMoiKirrUskRERC7Lub6zftl9lPHzt7DvWA4APWLDeKFfcyKD/1qrrlfzcHr92bsiFeeSwsqYMWNYuHAhK1asoG7dusXPn54KPyUlhYiIiOLnU1NTS/W2nGa1WrFadSuXiIg4XlZeITfP+AWb3aBTwxCurF+TRrX9+fcvSXy54RAAYYFWnr+pOb2bh2vQbBUpV1gxDIMxY8Ywf/58li1bRkxMyWtxMTExhIeHs3jxYuLj44Gi1W+XL1/Oyy+/XHFVi4iIVAKLycT+Y9kU2AwOHs/hkzUHSmzv3rQWbwyJJ9Db00EVVk/lCiujR4/mk08+4b///S8BAQHFY1SCgoLw8fHBZDIxduxYJk6cSOPGjWncuDETJ07E19eXoUOHVsoBiIiIVBQfLwtdGoWyfGdamXOmbDucoaDiAOUKK2+99RYA3bt3L/H8rFmzGDlyJACPPfYYp06d4oEHHuDEiRN06NCBRYsWERAQUCEFi4iIVBbDMAjxt1LW3G4m4Lm+zau8JtHaQCIiIgCczMln/ILf+HpzcpnbJw9oxcArdAPIuVTm97fLrrosIiJSUX7ZfZRHPt9ESkYuFrOJGr6eHM3KL97+7I1xCioOpIUMRUSk2sotsPGPr7Yx7L01pGTkEhPqx7z7OzP0ynqcvs9nXM8mmtzNwdSzIiIi1dL25AzGfraRHUeK1q4b2qEeT/eJxdfLA0+LiY9W7+e29lGMubaRgysVhRUREalW7HaD939O4pXvd5BvsxPi58XLA1rRI+6v+cCaRwax4ZmeQOmJTqXqKayIiEi1cfjkKR75fBOr9h4D4LpmtXlpQCtqBZSenFQhxXkorIiISLWwcNNhnp6/hYzcQnw8LTxzYxxDroxSKHEBCisiIuI2MnMLuOP9X/Hz9qBVnSCaRwZRL8SXd1fsYeGmoluSW0cF89rA1jSo5e/gauViKayIiIjbOJ6dT+LBkwCs3nOs1Cy01zarzTvD2+Fp0c2wrkRnS0RE3EZ0iB/NIwMxQZnT5ScdzVZQcUE6YyIi4lZ6xoVxdkwxAV4WM68NauOAiuRyKayIiIjbWLn7KB+s3FfmtjeGxNMmKrhK65GKoTErIiLi8ux2g7eW72HKoh3YDfDxNJNbaOf06nfj+8RyfYtwxxYpl0xhRUREXNqJ7HzGfb6RpTvSALi1XV1aRAYy4X/bMAHDO0UzStPluzSFFRERcVkbD55k9JwNHDp5CquHmX/0a8HAK6I4kZ3P6z/sok1UMM/1ba65VFycwoqIiLgcwzD4ePV+XvhqGwU2g+gQX2YOa0vzyCAAavh5kfhsL+x2A7NZQcXVKayIiIhLyc4r5Mkvt7Bw02EAejcP45XbWhPo7VmqrYKKe1BYERERl7HrSCb3z9nA7tQsLGYTTyY0Y1SXGF3mcXMKKyIi4hL+u/EQT8zbwqkCG2GBVqYPbcsV9Ws6uiypAgorIiLi1PIKbfzjq218vPoAAFc1CuH1wfGE+pdeKVnck8KKiIg4hYzcAm5/bw0+nhbaRAXTsm4Qtfyt/PPrbWw5lAHAQ9c24uEeTbBoLEq1orAiIiJOITuvkM1/pAOwfv+JEmv7eJhN3NE5mnG9mjqqPHEgTbcvIiJOISLIhzZRwWUuQlhoN1iyLdUxhYnDKayIiIjTuKZprTIXIfQwm5gysLUjShInoLAiIiJOYdmOVGb9sq/MbW8MidedP9WYxqyIiIhDFdrsvLZkJzOW7gHAx9NCboGtuIfl6RvjuKFlhOMKFIdTWBEREYdJSc/loU8T+XXfcQBu71iP6BA/Jn69HYBRXWK0CKEorIiIiGMs35nG3+Zu5Hh2Pv5WDyb1b0nf1pEcychl5tLddGwQwvgbYh1dpjgBhRUREalSZ1/2iYsIZMawtsSE+gEQFujNhmd6Yhha20eKKKyIiEiVOZKRy5hPE/k16a/LPk/3icPb01KinclkQsv9yGkKKyIiUiVW/HnZ51h2Pn5eFiYNaMVNrSMdXZa4AIUVERGpVIU2O9OW7GLGst0YBsRGBDLzjMs+IheisCIiIpXm7Ms+wzrU45kbS1/2ETkfhRUREakUuuwjFUVhRUREKlShzc7rP+xi+tK/LvvMGBpPg1r+ji5NXJTCioiIXLLM3AJGzlpLgLcHLSKDiAz2Zu7ag2z6c/XkoR3q8awu+8hlUlgREZFLlpqZx/r9JwD4aedRbMZfyxBGh/jSPDJQQUUumxYyFBGRS9awlj/NwgMASgQVgP3Hcnj/5yRHlCVuRj0rIiJyyU5k51Ngs5d63gR4eZh5fVB81RclbkdhRURELsmmgyd5YM4GDp08Veb2N4fE07JuUBVXJe5IYUVERMrFMAw++fUAzy/cRr7NTnSIL/5WD7YnZ2D/80rQ+D6x9Goe7thCxW1ozIqIiFy0U/k2HvliE+Pn/0a+zU6P2DAWPtiF4R2jsRtFl39u71CPUV1iHF2quBGFFRERuShJR7O5ZeYvfLnhEGYTPH59M/41vB1BPp4ktIigpp8XXRqHMuGm5pi0CqFUIF0GEhGRC/p+awqPfr6JzLxCQv29eHNIWzo1DCneHuTryYZnemK3G5jNCipSsRRWRETknAptdl5ZtIN3lu8FoH10DWYMa0tYoHeZ7RVUpDIorIiISJlSM3N56NNEVu8tWoRwVJcYnkhohqdFIwikaimsiIhIKWv3HWf0nA2kZubh52Vh8q2t6dMqwtFlSTWlsCIiIsUMw+D9n5OY9O3v2OwGjWv789bt7WhUW4sQiuMorIiICABZeYU89p9NfLMlBYCbWkcyqX9L/Kz6qhDH0m+giIiw80gm9328nr1p2XhaTDzdJ447OkXrFmRxCgorIiLV3H83HuKJeVs4VWAjIsibGcPa0rZeDUeXJVJMYUVEpJrIzC1g+Pu/4me10KpuMM3CA1i2I5X5iYcB6NIolNcHtyHE3+rgSkVKUlgREakmTuYUsPHgSQBW7z2O7fRCPkBksDd9WkUoqIhT0s3yIiLVRFRNX1rWKVoF+cygAnD4ZC5vL9/jiLJELkg9KyIi1YTNbhDs61nqeRPgYTHx2qA2VV6TyMVQWBERqQbSMvMYOzeRX3YfK3P7m0PiNahWnJbCioiIm/s16TgPflI0G62vl4WwQG/2HcvG+PNK0Pg+sVzfQrPTivPSmBURETdltxu8vXwPQ95dTWpmHo1r+7Pwwau4q0sM/BlURnauz6guMY4tVOQC1LMiIuKGTubk88jnm/jh91QAbomvw4u3tMDXy4Mavl5MXbSDttE1eObGOE38Jk5PYUVExM1sPHiS0XM2cOjkKbw8zDx/U3MGXxFVHEpC/K0kPtsLu93AbFZQEeensCIi4iYMw+CDlft48ZvtFNgMokN8mTmsLc0jg8psr6AirkJhRUTEDWTmFvDEvC18vSUZgIQW4bx8aysCvUvfqiziahRWRERc3LbDGYz+ZANJR7PxMJt46oZY7ryqvsaiiNtQWBERcVGGYfD5uoM8+9+t5BXaiQzyZroWIRQ3pLAiIuKCTuXbeHrBb8zb8AcA3ZvW4rWBbajh5+XgykQqnsKKiIiL2Z2axeg5G9hxJBOzCR7p1ZT7uzXUgFlxWworIiIuZOGmwzw5bzPZ+TZC/a28OSSeTg1DHF2WSKVSWBERcUKZuQXc+9F6gn09aRoWSINavizedoSFm4ru9unYoCZvDImndoC3gysVqXzlnm5/xYoV9O3bl8jISEwmEwsWLCixfeTIkZhMphKPjh07VlS9IiLVwr6jOazcc4xvt6Twxg+7GPPpxuKgUtPPi15xYQoqUm2UO6xkZ2fTunVrpk+ffs42119/PcnJycWPb7755rKKFBGpblrUCSQm1A8DsJ1ecfBPx7Pz+WLdH44pTMQByn0ZKCEhgYSEhPO2sVqthIeHX3JRIiLVnWFAnWAfko5ml3jeBHh7Wnh9SLxjChNxgEpZdXnZsmXUrl2bJk2acM8995CamnrOtnl5eWRkZJR4iIhUZ5m5Bdz38Xp+3n20zO0zhsXTJCygiqsScZwKDysJCQnMmTOHH3/8kSlTprB27VquvfZa8vLyymw/adIkgoKCih9RUVEVXZKIiMvYk5bFzTN+YdG2I3hZzDSs5ceZdyQ/dUMs1zYLc1yBIg5gMoyzLoaWZ2eTifnz53PzzTefs01ycjLR0dF89tln9O/fv9T2vLy8EkEmIyODqKgo0tPTCQwMvNTSRERczpJtR/jb3I1k5hUSHujNW7e3Zf+xHMbO3YjJBAPa1uWVW1tpGn1xShkZGQQFBVXK93el37ocERFBdHQ0u3btKnO71WrFarVWdhkiIk7Lbjd448ddTFtS9PfkFfVrMGNYW2oHeNM0PIBaAVaiavjw4i0tFFSkWqr0sHLs2DEOHjxIREREZb+ViIjLycgtYNzcTSzZfgSAEZ2iGd8nDi+Poqv0vl4erB3fA5vdwKIZaqWaKndYycrKYvfu3cU/JyUlsXHjRmrWrEnNmjWZMGECAwYMICIign379vHUU08RGhrKLbfcUqGFi4i4ut2pWfzfR+vYm5aNl4eZF29uwW3tyx63p6Ai1Vm5w8q6deu45pprin8eN24cACNGjOCtt95iy5YtfPjhh5w8eZKIiAiuueYa5s6dS0CARq6LiJy2aGsK4z7fRFZeIRFB3rx9eztaRwU7uiwRp3RZA2wrQ2UO0BERcTS73WDaD7t444ei8SlXxtRk5rC2hPpr7J64NpceYCsiIkXSTxUwbu5Gfvi9aO6pkZ3rM75PLJ6WSpnySsRtKKyIiFSBXUcy+b+P1pN0NBurh5mJt7RkQLu6ji5LxCUorIiIVLLvfkvhkc83kp1vo06wD2/f3o6WdYMcXZaIy1BYERGpJDa7wbQlO3nzx6I7KDs2qMmMoW0J0fgUkXJRWBERqQTppwoY+1kiS3ekATCqSwxPJjTDQ+NTRMpNYUVE5DJl5hZwz4frCPT2JDYikABvD2b9ksShk7lYPcy8PKAVN8fXcXSZIi5LYUVE5DIdPH6K1XuPYwKWbD+C/YwJISKDvUk/VeCw2kTcgfojRUQuU2xEAA1r+WFAiaACkHQ0hzlr9jukLhF3oZ4VEZHLdCKnANvZKQUwAVZPM68Pjq/6okTciMKKiMhl2PJHOvd9vJ5DJ0+VuX36kLbERmg2bpHLobAiInKJ/rP+D56av4X8Qjv1Q3wJ8vFky6H04ktBT90QS4+4MMcWKeIGNGZFRKSc8gvtPLPgNx79YhP5hXaua1ab/z7YhTs61cduFF3+Gdi+Lnd3jXF0qSJuQWFFRKQcjmTkMvhfq/ho9X5MJvhbjya8e0d7gnw8ub5FOKH+XrSvX4N/3twSk8nk6HJF3IIuA4mIXKRfk44z+pMNpGXmEeDtweuD23Bts78u8/hZPVj3dE9sdgOLWUFFpKIorIiIXIBhGHywch///Ho7hXaDpmEBvDO8HfVD/cpsr6AiUrEUVkREzuNUvo3x87fwZeIhAPq2juTlAS3x9dJfnyJVRZ82EZFzOHg8h3s/Ws+25AwsZhNPJjRjVJcYjUURqWIKKyIiZVi+M42HPk0k/VQBIX5eTB/alk4NQxxdlki1pLAiInIGu93greV7eHXRDgwDWkcF8/btbYkI8nF0aSLVlsKKiMifMnMLeOTzTSzadgSAIVdGMeGm5lg9LA6uTKR6U1gREQF2p2byfx+tZ29aNl4WM8/3a86QK+s5uiwRQWFFRKqZzNwC7pq9liAfT+IiAmkWEUhaZi4vf/s7OQV2IoK8eev2drSJCnZ0qSLyJ4UVEalWktNzWbvvBADLdqRReMZqyX5eFu7oFK2gIuJkNN2+iFQrTcICaBLmjwlKBBWA7Hwb8zYcckxhInJOCisiUu10bhiKcdZzJsDqYeb1wW0cUJGInI/CiohUK5/+eoA5q/eXuW3G0LY0jwyq4opE5EI0ZkVEqoXcAhvP/vc3Pl/3BwA1fD1JP1XA6StB4/vE0iMu7DyvICKOorAiIm7v4PEc7p+znt8OZWA2waO9mxLi58Xj87ZgMsHgK6IY1SXG0WWKyDkorIiIW1u+M42HP0vkZE4BNf28eGNwPF0ah5KRW8Ar3++gce0AXujXQuv9iDgxhRURcUt2u8H0pbt5bcnOomnz6wYx8/Z21AkumjY/0NuTdU/3xG43MJsVVEScmcKKiLid9FMFjJu7kR9+TwVgyJX1eK5vHN6epafNV1ARcX4KKyLiVrYdzuD+OevZfywHLw8z/7y5BQPbRzm6LBG5DAorIuI25if+wZNfbiG3wE7dGj68fXs7WtTRrcgirk5hRURcXn6hnX9+vY0PVxXNn3J1k1q8PqgNNfy8HFyZiFQEhRURcWkp6bncP2c9iQdOAvDQdY15+LrGWDQWRcRtKKyIiMtatecYYz7dwNGsfAK9PXhtUBuui9XEbiLuRmFFRFyOYRi8+9NeXv5uBza7QWxEIG/f3pboED9HlyYilUBhRUScVmZuAXfOWkugjyfNIwOJjQikfogvb/ywi++2HgGgf3wdXrylJT5epW9LFhH3oLAiIk7rSEYu6/afAGDFzjQK7SXXSu7bKoIpA1tr9lkRN6dVl0XEaTWqHUDT8ABMUCqoAGxLzlBQEakGFFZExKnd3CaSs2OKCbB6mJk2KN4RJYlIFVNYERGnlZqRy/e/HSlz25tD4mlZVxO+iVQHGrMiIk7p16TjjP5kA2mZeZhNYADGn10s4/vE0qt5uEPrE5Gqo54VEXEqhmHw3k97GfLuatIy82gaFsC4nk0wjKLLP8M61GNUlxhHlykiVUg9KyLiNLLyCnnsP5v4ZksKAP3aRDKpf0sKbAazftlHs4gAnr+puQbVilQzCisi4hR2Hcnk3o/XszctG0+Liaf7xHFHp+jiYLL+mZ7Y7QZmTaMvUu0orIiIw/1v02Een7eZnHwb4YHezBjWlnbRNUq1U1ARqZ4UVkTEYQpsdiZ+s51Zv+wDoHPDEN4YEk+ov9WxhYmIU1FYERGHOJKRy+g5G4pnqL2/e0Me6dkED4vG/YtISQorIlLlzlwtOcDqwZSBrXUrsoick8KKiFQZwzD414q9TP6+aLXkZuEBvHV7O2JCtVqyiJybwoqIVInM3AL+/sVmvttadFuyVksWkYulsCIiFcowjFLzoOxIyeS+j9eTdLTotuRn+zbn9g71NF+KiFwUhRURqTBZeYXcPOMX7HaDTg1DuKJ+TU7k5DP5ux2cKrAREeTNzGFtia9X+rZkEZFzUVgRkQpjMZnYfyybApvBgeM5zFlzoHhbqL8X43o2UVARkXLTPYIiUmF8vCxc1SgUswkK7UaJbUez8pn8/Q4HVSYirkxhRUQqVFigN2flFKBoEcLnb2pe5fWIiOvTZSARqRDppwp47r+/sWDj4TK3v3xrK25oGVHFVYmIO1BYEZHLtnrvMR75fBOHTp7CbIIavl4cy84v3v5c3zgGto9yYIUi4sp0GUhELll+oZ2Xvv2dIe+u5tDJU9Sr6csX93VmWMdoTt+UPK5nE+68KsahdYqIa1PPiohckt2pmTz82Ua2Hs4AYFD7KJ7pG4e/1QMfTwsfrdrHre3qMubaRg6uVERcncKKiJSLYRh8tHo/L369nbxCO8G+nrzUvyXXt/hrPEpcZCAbnukJoInfROSyKayIyEVLzczl719sZvnONAC6Ng7l1dtaExboXaqtQoqIVBSFFRG5KIu2pvDEl1s4np2Pl4eZpxKacUen+pjNCiUiUrkUVkTkvLLzCvnHV9v4bO1BAGIjAnl9cBuahAU4uDIRqS4UVkTknBIPnOBvczey71gOJhP839UNGNezCVYPrZQsIlVHYUVESim02ZmxdA9v/LgLm90gMsibKQPb0KlhiKNLE5FqqNzzrKxYsYK+ffsSGRmJyWRiwYIFJbYbhsGECROIjIzEx8eH7t27s3Xr1oqqV0Qq2f5j2dz2zipeW7ITm92gb+tIvn34agUVEXGYcoeV7OxsWrduzfTp08vcPnnyZKZOncr06dNZu3Yt4eHh9OzZk8zMzMsuVkQqj2EYfL72IDe8/hOJB04SYPXg9cFteHNIPEG+no4uT0SqsXJfBkpISCAhIaHMbYZhMG3aNMaPH0///v0B+OCDDwgLC+OTTz7h3nvvvbxqReSyZeYWMPz9X/H1stCqbjAt6wRRt4YPM5fu5vttRwC4MqYmUwe2pm4NXwdXKyJSwWNWkpKSSElJoVevXsXPWa1WunXrxsqVKxVWRJzAyZwCNh48CcCvSccpPGOJZBNwfYtwpg9ti0W3JIuIk6jQtYFSUlIACAsLK/F8WFhY8baz5eXlkZGRUeIhIpUnqqYvreoEYYISQQXAALYlZyioiIhTqZSFDM+eudIwjHPOZjlp0iSCgoKKH1FRWplVpLJd06w2xlnPmQBPi4mpA9s4oCIRkXOr0LASHh4OUKoXJTU1tVRvy2lPPvkk6enpxY+DBw9WZEkicpZlO1KZ/UtSmdveGBxPu+gaVVyRiMj5VWhYiYmJITw8nMWLFxc/l5+fz/Lly+ncuXOZ+1itVgIDA0s8RKTiFdrsvPr9DkbOWkt6biG+XhbO7PAc3yeWhJYR534BEREHKfcA26ysLHbv3l38c1JSEhs3bqRmzZrUq1ePsWPHMnHiRBo3bkzjxo2ZOHEivr6+DB06tEILF5GLl5qRy0OfJbJ673EAhneMJibUj398tQ2AkZ3rM6pLjCNLFBE5p3KHlXXr1nHNNdcU/zxu3DgARowYwezZs3nsscc4deoUDzzwACdOnKBDhw4sWrSIgACtIyLiCCv3HOWhTzdyNCsPPy8Lkwa04qbWkRzNyuPNH3fRLromz9wYp1WSRcRpmQzDOHucnUNlZGQQFBREenq6LgmJXAa73WDmst1MXbwTuwFNwwKYeXtbGtbyL9VOKyeLyOWqzO9vrQ0k4oaOZ+czdu5GVuxMA+C2dnV5oV8LfLxKL0CooCIizk5hRcTNrN9/nAc/SSQ5PRdvTzMv9GvBwPaaEkBEXJfCioibMAyD935K4uXvfqfQbtCglh8zh7WlWbgup4qIa1NYEXED6TkFPPqfTSz+c22fvq0jmdS/Jf5WfcRFxPXpbzIRF7f5j5OM/mQDB4+fwsti5pm+cdzeoZ7u7hERt6GwIuKiDMPg49X7+cdX28m32Ymq6cPMoe1oWTfI0aWJiFQohRURF5SVV8gT8zbz1eZkAHrFhfHKba0J8vF0cGUiIhVPYUXEiWXmFnDrW6swm+HK+jVpG12DIB9Pnl+4laRjOXiYTTyR0IxRXWJ02UdE3JbCiogTsxuwKzWz6L9Hsvhg1f7ibVYPM6OvacTdXRs4sEIRkcpXoQsZikjFCvLxpGODEMwmKLSXnGw6r9DOJ2sOOKgyEZGqo7Ai4uRa1gnCXsaiGGYTTOzfouoLEhGpYroMJOKk7HaDd1bs5b2f9pa5fcrA1lzbLKyKqxIRqXoKKyJOKCU9l3Gfb2TlnmMABHp7kJFbWLz92RvjuCW+rqPKExGpUgorIk5m0dYUHp+3mRM5Bfh4Wnj+puakZuYyZdFODGDMtY24q0uMo8sUEakyCisiTiK3wMY/v97Gx6uLBs22qBPI64PjaVjLnz1pWbz/cxIJLcIZ17OJgysVEalaCisiTmB7cgYPfZrIrtQsAP7v6gY82qspXh5FY+Ab1vJnwzM9ATSfiohUOworIg5kGAYfrNzHxG9/J7/QTqi/lakDW3N1k1ql2iqkiEh1pbAi4iDHsvL4+3828+PvqQBc26w2k29tRai/1cGViYg4F4UVEQdYsTONR77YRFpmHl4eZp5KaMaIzvXVeyIiUgaFFZEqlF9o59VFO/jXiqK5UxrX9ueNIfHERgQ6uDIREeelsCJSRfakZfHwZ4n8digDgNs71uPpPnF4e1ocXJmIiHNTWBGpZIZh8MW6P3hu4VZOFdgI9vVk8oBW9Goe7ujSRERcgsKKSCVKzyngqflb+HpLMgCdG4YwdWAbwoO8HVyZiIjrUFgRqQBZeYU8v3ArNfy8qBPsQ51gH07k5DN18U6S03PxMJt4pFdT/u/qBljMGkQrIlIeCisiFWDZjlS+WP8HZhMYBpy5SLIJuLlNJPd3b+io8kREXJrZ0QWIuIMesWEEentgPyuoQNHP6WcsQigiIuWjsCJSAbw9LdwSX6fU82YThPp78VL/lg6oSkTEPSisiFSAnUcy+e63lDK3vXV7O0I0K62IyCXTmBWRy7R67zHu+XAdmbmF+HpZyCuwYzOKLgY92rspV9Sv6eAKRURcm3pWRC7D/zYd5o73fyUzt5B20TV4Y3A8NsPABHRtHMp9V2tQrYjI5VLPisglMAyD935K4sVvtgNwffNwpg1ug9XDTIs6gaSk5zJtUBvMuk1ZROSyKayIlJPNbvCPr7Yxe+U+AEZ2rs8zN8YVz5/y1ZiuFNrseFjUcSkiUhEUVkTKIbfAxtjPNvLd1qLBtONviOXurjGlVktWUBERqTgKKyIX6UR2Pnd/uI71+0/gZTHz6sDW3NQ60tFliYi4PYUVkYtw8HgOI2b9yt60bAK9PfjXHe3p2CDE0WWJiFQLCisiF7Dlj3TunL2Wo1l5RAZ5M/uuK2kSFuDoskREqg2FFZHzWLojldFzNpCTbyM2IpDZd15BWKBWTBYRqUoKKyLnMHftAZ6a/xs2u0GXRqG8dXtbArw9HV2WiEi1o7AichbDMJi2ZBev/7ALgP5t6/BS/1Z4eegOHxERR1BYETlDgc3OU19u4Yv1fwAw5tpGjOvZpNStySIiUnUUVqTaysorZMqiHdTw9aJ2gJUAH0/e+2kviQdOYgJevKUlQzvUc3SZIiLVnsKKVFtfbz7MrF/2YTaB3Si9fU9aVtUXJSIipegivFRb17eIwNvTXGZQMYCMUwVVXpOIiJSmsCLVVpCPJ9c3Dy/1vNkEkcHePHdTcwdUJSIiZ1NYkWpr7b7jLN5+pMxtM4a2xd+qq6QiIs5AYUWqpaW/pzL8/TVk59mo6etVvGIywN96NCG+Xg0HViciImdSWJFq578bD3HPh+vILbBzbbPavDuiPTa7gQloF12DB65p5OgSRUTkDOrnlmrlo1X7eHbhVgwD+rWJ5NXbWuNpMdOlUSiJB0/wxpD4Er0sIiLieAorUi0YhsH0H3czZfFOAEZ0iua5vs0x/xlMPr67A4U2Ox4WdTaKiDgbhRVxe3a7wT+/3s6/f0kC4KHrGvO3Ho1LzUqroCIi4pwUVsStFdrsPD5vC/M2FE2f/+yNcdzVJcbBVYmISHkorIjbyi2wMebTRBZvO4LFbGLygFYMaFfX0WWJiEg5KayIW8rMLeCeD9exeu9xvDzMzBjalp5xYY4uS0RELoHCiridY1l5jJy1li2H0vG3evDuHe3p1DDE0WWJiMglUlgRt3L45Cluf38Ne9OyqennxQd3XknLukGOLktERC6Dwoq4jT1pWQx/bw2H03OJDPLmw1EdaFTb39FliYjIZVJYEbfw26F07vj3rxzPzqdBLT8+GtWBOsE+ji5LREQqgMKKuJTM3ALumr2WIB9P4iICaRYRSF6hjafn/0Z2vo0WdQL54M4rCfG3OrpUERGpIAor4lKS03NZu+8EAMt2pFFoN4q3+XlZ6Nc6UkFFRMTNaMpOcSlNwgJoEuaPCUoEFYDsfBtz1/3hmMJERKTSKKyIy7k5vg7GWc+ZAKuHmdcHt3FARSIiUpkUVsSlJKef4qtNyWVumzG0Lc0jdZuyiIi70ZgVcRkrdx9lzKeJHMvOx2ICO2D82cUyvk8sPTRDrYiIW1LPijg9wzB4e/kebn9/Dcey84mLCOTvvZthGGAywZAroxilxQlFRNyWelbEqWXmFvD3Lzbz3dYUAAa0rcuLt7Qg32bn3Z/20iQsgBf6tcBkMjm4UhERqSwKK+K0dh3J5N6P17M3LRtPi4nn+jZnWId6mEwmvD0trH+mJ3a7gdmsoCIi4s4UVsQpfbX5MI/9ZzM5+TYigryZOawt8fVqlGqnoCIi4v4UVsSpFNrsvPTt77z3cxIAnRqE8ObQeEI10ZuISLVV4QNsJ0yYgMlkKvEIDw+v6LcRN5SWmcew99YUB5V7uzXgo1FXKqiIiFRzldKz0rx5c5YsWVL8s8ViqYy3ETeyfv9xHpizgSMZefhbPXjl1lYktIxwdFkiIuIEKiWseHh4qDdFLophGHy4aj//+GobhXaDRrX9efv2djSq7e/o0kRExElUSljZtWsXkZGRWK1WOnTowMSJE2nQoEGZbfPy8sjLyyv+OSMjozJKEid0Kt/GU/O3MD/xEAB9WkYw+dZW+Fk1lEpERP5S4WNWOnTowIcffsj333/Pu+++S0pKCp07d+bYsWNltp80aRJBQUHFj6ioqIouSZzQvqPZ3DLzF+YnHsJiNvF0n1imD41XUBERkVJMhmGcvSZchcrOzqZhw4Y89thjjBs3rtT2snpWoqKiSE9PJzAwsDJLkyqQW2DD02LGcsYtxku2HeFvn28kM7eQUH8vpg9tS8cGIQ6sUkRELldGRgZBQUGV8v1d6f+M9fPzo2XLluzatavM7VarFatVd3u4o7xCG33e+InUzDy6Na5Fl8ah7EjJZNbKfQC0rRfMzGHtCA/ydmyhIiLi1Co9rOTl5bF9+3a6du1a2W8lTsbLYuZETgGZuYV8+1sKX235a7Xk2IgAHunZVEFFREQuqMLHrDz66KMsX76cpKQk1qxZw6233kpGRgYjRoyo6LcSJ2cymbi6cShmE9jOutq4PTmTBz/dQCVfhRQRETdQ4T0rf/zxB0OGDOHo0aPUqlWLjh07snr1aqKjoyv6rcTJpWbmsjs1C/s58sgD3RtpAUIREbmgCg8rn332WUW/pLgYwzCYn3iI5/+3jfRTBWW2ebpPLHd3Lft2dhERkTPpPlGpUIdPnmL8/C0s3ZEGQPPIQI5m5XEk4687vp7rG8edV8U4qkQREXExFT5mRaonwzD4ZM0Ber22gqU70vCymPl776YsGH0VPWLDitu90K+5goqIiJSLelbksh04lsPj8zazam/RxH/x9YJ55dZWNKodAEBCiwi+/S2Fv/VswvCOGrskIiLlU+mTwpVXZU4qIxXLZjf4YOU+Xvl+B6cKbHh7mvl772aM7Fy/xCRwUNTzosG0IiLuy6UnhRP3tDs1i8fnbWb9/hMAdGxQk5cHtCI6xK/M9goqIiJyqRRWpFwKbXb+9dNepi3ZRX6hHX+rB0/e0IwhV9TDbFYgERGRiqewIhdte3IGj/1nM1sOpQPQrUktJvZvSZ1gHwdXJiIi7kxhRS4ov9DOjKW7mbF0N4V2g0BvD57t25wBbevo8o6IiFQ6hRUplplbwG1vr8JsMnFlTE3i6wXj42nh1e93sDM1C4DezcP4R78W1A7Umj4iIlI1FFakmN0OO49kYjeK/jv7z9WRATwtJoZ1iOa5vnHqTRERkSqlSeGkWJCvJx1iQjCZoPCsBX0KbAbfb01RUBERkSqnsCLF7HaDAG8Pypp5x2yCif1bVn1RIiJS7ekykACQmpHLI19s4qddR8vcPnVgG65pWruKqxIREVFYEeDH34/w6BebOZ6dj7enmZp+XiSfzOV0B8uzN8Zxc3wdh9YoIiLVly4DVWN5hTae/99W7pq9juPZ+cRGBPLVmC7cfsb6PaOvachdXbTwoIiIOI56Vqqp3amZjPl0I9uTMwC486r6PH59M7w9LZhNJt5dsZdezcN5tFdTB1cqIiLVncJKNWMYBp+tPcjz/9tKboGdmn5evHpbK65tFlbcpkEtfzY80xPQmj4iIuJ4CivVSHpOAU/O38w3W1IA6NIolKkDW5c5wZtCioiIOAuFlWpi7b7jjP1sI4dOnsLDbOLvvZtyT9cGWnxQREScnsKKmyu02Zm+dDdv/LALuwHRIb68MTie1lHBji5NRETkoiisuLFDJ08x9rNE1u47AUD/tnV4oV8L/K067SIi4jr0reUGMnMLuGv2WgK9PWkeGUiziEBSM3KZsmgHmXk2/K0e/PPmFporRUREXJLCihtISc8t7j1ZtjMN2xnr+vh4Wrina4yCioiIuCxNCucGGocF0CTMH6BEUAE4VWDjf5uTHVGWiIhIhVBYcRMt6gSVes4EWD3MTBvUpsrrERERqSi6DOTiCm12Xl20ky83HCpz+/ShbcsMMiIiIq5CYcWFHc3KY8wniazaewyA8EBvUjNzOX0laHyfWHrGhZ3nFURERJyfwoqL2nDgBA98vIGUjFx8vSxMvrUVOXk2Hpu3GRMw5MooRmkBQhERcQMKKy7GMAw+XnOAF/63lQKbQcNafrx9ezsahwWQkVvAy9/9TtPwAJ7v10JT5ouIiFtQWHEhp/JtjF+wpXh8yg0tw5l8a+viSd4CvT1Z/0xP7HZD0+iLiIjbUFhxEfuPZXPvR+v5PSUTi9nEE9c34+6uMWX2niioiIiIO1FYcQE/bD/C2LkbycwtJNTfizeHtKVTwxBHlyUiIlIlFFacRFZeIQ/O2UANPy8a1fanYS1/GoT68d+Nh5ixbA8AbesFM3NYO8KDvB1crYiISNVRWHESvydnsGxnGiYTmE2mUjPRto+uwSf3dMTLQ/P4iYhI9aJvPifRLroGdWv4YBilp8wHyLfZFVRERKRa0refkzCZTAy5sh5nD401AX5WC68PjndEWSIiIg6nsOIkbHaDlPRcSvepwMxh7YgJ9avymkRERJyBxqw4gczcAh7+bCM//p4KFPWmnA4tT97QjG5NajmsNhEREUdTz4qDJR3N5paZK/nx91SsHmbuvKo+BmAyQb82kdzTtYGjSxQREXEo9aw40IqdaTz4yQYycgsJD/TmX3e0o2l4AN/9lkINX09eHtBKU+aLiEi1p7DiAIZh8P7PSUz8Zjt2o2j+lLeHt6N2QNH8KauevA6b3cCimWhFREQUVqpaboGN8fN/Y96GPwAY2L4u/7i5BVYPS4l2CioiIiJFFFaq0JGMXO79aD0bD57EYjbxdJ9YRnaur0s9IiIi56GwUkmy8gqZsHArNXw9qVvDl7xCO28v383x7AKCfDyZMbQtXRqHOrpMERERp6ewUkmW70jjP+v/wGwCw6DE/Cn5hXZW7T2qsCIiInIRdOtyJbkutjaB3h7YzwoqAKcKbOxIyXRIXSIiIq5GYaWSWMwm6tTwKfW82QQh/l68NKCVA6oSERFxPQorlSA7r5C7P1jH9uTSvScGMHNoW0L9rVVfmIiIiAtSWKlgqRm5DPrXKpbvTMPb00x8veAStyE/2qspHRqEOLBCERER16IBthVod2omI/69lkMnTxHi58V7I9qTW2BnyLurMQFdG4dyf7eGji5TRETEpSisVJA1e49xz4fryMgtpH6ILx/cdSXRIX4YhkFcRCBpWXlMGxyPWZO9iYiIlIvCSjll5hYw9N01+HpZaBMVTMu6QaRl5jHx6+0U2A3i6wXz3h3tCflzTIrJZOKbh7tSaLPjYdFVNxERkfJSWCmnrLxCthxKB2D9/hMU2v+6Mbmmrye3tq1bHFTOpKAiIiJyafQNWk4RQT7ERwVjghJBBeB4TgFvL9/jmMJERETclMLKJejSOLTURG8mwMNsYsrANg6oSERExH0prJTTN1uS+ffPSWVue31wPFfG1KziikRERNybxqxcpLxCGxO/3s4Hq/YD4OdlISffVtzD8vSNcfRpFeG4AkVERNyUwspF2H8sm9GfbOC3QxkA3NutAbUDrPzzq+0AjOoSw6guMY4sUURExG0prJwhI7eAO97/FV8vC63qBtOiTiDHsvJ55bvfycq3UcPXk6kD23BNs9ocychl+o+76dgghPE3xDq6dBEREbelsHKG9JwCNh48CcCvScdL3O3jb/Xg3m4NuaZZbQDCAr3Z8ExPDANN9CYiIlKJNMD2DFE1fWlZJ6jM25Kz8gr59NcDJZ4zmUwKKiIiIpVMYeUszSICyrwt2dNiYqpuSxYREalyugz0pwKbnZe//Z0v1v1R5vY3BsfTLrpGFVclIiIi1TKsZOQWMPLfv+Jn9aBlnSAig334ZM1+tiVnAhAWYCU1Kw/jzy6W8X1iSWip25JFREQcoVqGleNZ+Ww4cBKAlbuPYTP+uvDToJYfLSKD+N+mwwCM7FxftyWLiIg4ULUIK3a7UWIgbP1QP+IiAtmWnFEiqADsTcum0GYQ7OtJu+iaPHNjHCaTBtGKiIg4ituHley8Qm6a/jN5hXa6NArlypiaNAkLICe/sFTbooG0Zt4YEk+bqOBSIUdERESqXqXdDTRz5kxiYmLw9vamXbt2/PTTT5X1VuflYTHxx4lT/HHiFP9Z/wfjPt/EjW/+zL5jOWW2Px1UQPOniIiIOINKCStz585l7NixjB8/nsTERLp27UpCQgIHDhy48M4VzOphoWvjUCym0nOnnG18n1iubxFeRZWJiIjIxaiUsDJ16lRGjRrF3XffTWxsLNOmTSMqKoq33nqrMt7ugq6LDcN2npxiAoZ3jNZAWhERESdU4WElPz+f9evX06tXrxLP9+rVi5UrV5Zqn5eXR0ZGRolHRevetFaZzz/dJ5Yavp50a1qL5/pqIK2IiIgzqvABtkePHsVmsxEWFlbi+bCwMFJSUkq1nzRpEs8//3xFl1FCRJAPjWv7sys1q/i5Z2+M464uMdzdtYEG0oqIiDixShtge3YvhWEYZfZcPPnkk6Snpxc/Dh48WCn19Goexul3/3vvptx1xiUfBRURERHnVeE9K6GhoVgsllK9KKmpqaV6WwCsVitWq7Wiyyild/NwPllzgGEdohl9TaNKfz8RERGpGBXes+Ll5UW7du1YvHhxiecXL15M586dK/rtLlqrusFseKYnj/Rq4rAaREREpPwqZVK4cePGMXz4cNq3b0+nTp3417/+xYEDB7jvvvsq4+0umgbQioiIuJ5KCSuDBg3i2LFjvPDCCyQnJ9OiRQu++eYboqOjK+PtRERExI2ZDMM4/0xpVSwjI4OgoCDS09MJDAx0dDkiIiJyESrz+7vS7gYSERERqQgKKyIiIuLUFFZERETEqSmsiIiIiFNTWBERERGnprAiIiIiTk1hRURERJxapUwKdzlOT/uSkZHh4EpERETkYp3+3q6M6ducLqxkZmYCEBUV5eBKREREpLwyMzMJCgqq0Nd0uhls7XY7hw8fJiAgoELW8snIyCAqKoqDBw+6/Yy41elYoXodr47VPelY3VN1PdaAgAAyMzOJjIzEbK7YUSZO17NiNpupW7duhb9uYGCg2//SnFadjhWq1/HqWN2TjtU9VcdjregeldM0wFZEREScmsKKiIiIODW3DytWq5XnnnsOq9Xq6FIqXXU6Vqhex6tjdU86VvekY614TjfAVkRERORMbt+zIiIiIq5NYUVEREScmsKKiIiIODWFFREREXFqbhFWZs6cSUxMDN7e3rRr146ffvrpvO2XL19Ou3bt8Pb2pkGDBrz99ttVVOmlmzRpEldccQUBAQHUrl2bm2++mR07dpx3n2XLlmEymUo9fv/99yqq+tJNmDChVN3h4eHn3ccVzytA/fr1yzxPo0ePLrO9K53XFStW0LdvXyIjIzGZTCxYsKDEdsMwmDBhApGRkfj4+NC9e3e2bt16wdedN28ecXFxWK1W4uLimD9/fiUdwcU737EWFBTw+OOP07JlS/z8/IiMjOSOO+7g8OHD533N2bNnl3muc3NzK/lozu9C53XkyJGlau7YseMFX9fVzitQ5vkxmUy88sor53xNZz2vF/M946jPrMuHlblz5zJ27FjGjx9PYmIiXbt2JSEhgQMHDpTZPikpiRtuuIGuXbuSmJjIU089xUMPPcS8efOquPLyWb58OaNHj2b16tUsXryYwsJCevXqRXZ29gX33bFjB8nJycWPxo0bV0HFl6958+Yl6t6yZcs527rqeQVYu3ZtieNcvHgxALfddtt593OF85qdnU3r1q2ZPn16mdsnT57M1KlTmT59OmvXriU8PJyePXsWrxFWllWrVjFo0CCGDx/Opk2bGD58OAMHDmTNmjWVdRgX5XzHmpOTw4YNG3jmmWfYsGEDX375JTt37uSmm2664OsGBgaWOM/Jycl4e3tXxiFctAudV4Drr7++RM3ffPPNeV/TFc8rUOrc/Pvf/8ZkMjFgwIDzvq4znteL+Z5x2GfWcHFXXnmlcd9995V4rlmzZsYTTzxRZvvHHnvMaNasWYnn7r33XqNjx46VVmNlSE1NNQBj+fLl52yzdOlSAzBOnDhRdYVVkOeee85o3br1Rbd3l/NqGIbx8MMPGw0bNjTsdnuZ2131vALG/Pnzi3+22+1GeHi48dJLLxU/l5ubawQFBRlvv/32OV9n4MCBxvXXX1/iud69exuDBw+u8Jov1dnHWpZff/3VAIz9+/efs82sWbOMoKCgii2ugpV1rCNGjDD69etXrtdxl/Par18/49prrz1vG1c4r4ZR+nvGkZ9Zl+5Zyc/PZ/369fTq1avE87169WLlypVl7rNq1apS7Xv37s26desoKCiotForWnp6OgA1a9a8YNv4+HgiIiK47rrrWLp0aWWXVmF27dpFZGQkMTExDB48mL17956zrbuc1/z8fD7++GPuuuuuCy7k6arn9bSkpCRSUlJKnDer1Uq3bt3O+fmFc5/r8+3jjNLT0zGZTAQHB5+3XVZWFtHR0dStW5cbb7yRxMTEqinwMi1btozatWvTpEkT7rnnHlJTU8/b3h3O65EjR/j6668ZNWrUBdu6wnk9+3vGkZ9Zlw4rR48exWazERYWVuL5sLAwUlJSytwnJSWlzPaFhYUcPXq00mqtSIZhMG7cOLp06UKLFi3O2S4iIoJ//etfzJs3jy+//JKmTZty3XXXsWLFiiqs9tJ06NCBDz/8kO+//553332XlJQUOnfuzLFjx8ps7w7nFWDBggWcPHmSkSNHnrONK5/XM53+jJbn83t6v/Lu42xyc3N54oknGDp06HkXumvWrBmzZ89m4cKFfPrpp3h7e3PVVVexa9euKqy2/BISEpgzZw4//vgjU6ZMYe3atVx77bXk5eWdcx93OK8ffPABAQEB9O/f/7ztXOG8lvU948jPrNOtunwpzv4XqGEY5/1XaVnty3reWT344INs3ryZn3/++bztmjZtStOmTYt/7tSpEwcPHuTVV1/l6quvruwyL0tCQkLx/7ds2ZJOnTrRsGFDPvjgA8aNG1fmPq5+XgHef/99EhISiIyMPGcbVz6vZSnv5/dS93EWBQUFDB48GLvdzsyZM8/btmPHjiUGpl511VW0bduWN998kzfeeKOyS71kgwYNKv7/Fi1a0L59e6Kjo/n666/P+0XuyucV4N///jfDhg274NgTVziv5/ueccRn1qV7VkJDQ7FYLKXSWWpqaqkUd1p4eHiZ7T08PAgJCam0WivKmDFjWLhwIUuXLqVu3brl3r9jx45Old4vlp+fHy1btjxn7a5+XgH279/PkiVLuPvuu8u9ryue19N3d5Xn83t6v/Lu4ywKCgoYOHAgSUlJLF68+Ly9KmUxm81cccUVLneuIyIiiI6OPm/drnxeAX766Sd27NhxSZ9fZzuv5/qeceRn1qXDipeXF+3atSu+e+K0xYsX07lz5zL36dSpU6n2ixYton379nh6elZarZfLMAwefPBBvvzyS3788UdiYmIu6XUSExOJiIio4OoqX15eHtu3bz9n7a56Xs80a9YsateuTZ8+fcq9ryue15iYGMLDw0uct/z8fJYvX37Ozy+c+1yfbx9ncDqo7Nq1iyVLllxSiDYMg40bN7rcuT527BgHDx48b92uel5Pe//992nXrh2tW7cu977Ocl4v9D3j0M/sRQ/FdVKfffaZ4enpabz//vvGtm3bjLFjxxp+fn7Gvn37DMMwjCeeeMIYPnx4cfu9e/cavr6+xt/+9jdj27Ztxvvvv294enoa//nPfxx1CBfl/vvvN4KCgoxly5YZycnJxY+cnJziNmcf62uvvWbMnz/f2Llzp/Hbb78ZTzzxhAEY8+bNc8QhlMsjjzxiLFu2zNi7d6+xevVq48YbbzQCAgLc7ryeZrPZjHr16hmPP/54qW2ufF4zMzONxMREIzEx0QCMqVOnGomJicV3wLz00ktGUFCQ8eWXXxpbtmwxhgwZYkRERBgZGRnFrzF8+PASd/f98ssvhsViMV566SVj+/btxksvvWR4eHgYq1evrvLjO9P5jrWgoMC46aabjLp16xobN24s8RnOy8srfo2zj3XChAnGd999Z+zZs8dITEw07rzzTsPDw8NYs2aNIw6x2PmONTMz03jkkUeMlStXGklJScbSpUuNTp06GXXq1HG783paenq64evra7z11ltlvoarnNeL+Z5x1GfW5cOKYRjGjBkzjOjoaMPLy8to27Ztidt5R4wYYXTr1q1E+2XLlhnx8fGGl5eXUb9+/XP+gjkToMzHrFmzitucfawvv/yy0bBhQ8Pb29uoUaOG0aVLF+Prr7+u+uIvwaBBg4yIiAjD09PTiIyMNPr3729s3bq1eLu7nNfTvv/+ewMwduzYUWqbK5/X07dZn/0YMWKEYRhFt0I+99xzRnh4uGG1Wo2rr77a2LJlS4nX6NatW3H707744gujadOmhqenp9GsWTOnCGrnO9akpKRzfoaXLl1a/BpnH+vYsWONevXqGV5eXkatWrWMXr16GStXrqz6gzvL+Y41JyfH6NWrl1GrVi3D09PTqFevnjFixAjjwIEDJV7DHc7rae+8847h4+NjnDx5sszXcJXzejHfM476zJr+LFBERETEKbn0mBURERFxfworIiIi4tQUVkRERMSpKayIiIiIU1NYEREREaemsCIiIiJOTWFFREREnJrCioiIiDg1hRURERFxagorIiIi4tQUVkRERMSpKayIiIiIU/t/a3/GGdMK6+IAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -326,98 +326,7 @@ "execution_count": 10, "id": "30fab4f8-1701-4a14-8fb6-27bc4f101520", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/tensor/rewriting/shape.py:156: UserWarning: Failed to infer_shape from Op Mul.\n", - "Input shapes: [(TensorConstant(TensorType(int64, shape=()), data=array(30)), TensorConstant(TensorType(int64, shape=()), data=array(2)), TensorConstant(TensorType(int64, shape=()), data=array(3))), (TensorConstant(TensorType(int64, shape=()), data=array(30)), TensorConstant(TensorType(int64, shape=()), data=array(1000)), TensorConstant(TensorType(int64, shape=()), data=array(1)))]\n", - "Exception encountered during infer_shape: \n", - "Exception message: Could not broadcast dimensions. Incompatible shapes were [(TensorConstant(TensorType(int64, shape=()), data=array(30)), TensorConstant(TensorType(int64, shape=()), data=array(2)), TensorConstant(TensorType(int64, shape=()), data=array(3))), (TensorConstant(TensorType(int64, shape=()), data=array(30)), TensorConstant(TensorType(int64, shape=()), data=array(1000)), ScalarConstant(ScalarType(int64), data=1))].\n", - "Traceback: Traceback (most recent call last):\n", - " File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/tensor/rewriting/shape.py\", line 132, in get_node_infer_shape\n", - " o_shapes = shape_infer(\n", - " ^^^^^^^^^^^^\n", - " File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/tensor/elemwise.py\", line 771, in infer_shape\n", - " out_shape = broadcast_shape(*i_shapes, arrays_are_shapes=True)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/tensor/extra_ops.py\", line 1451, in broadcast_shape\n", - " return broadcast_shape_iter(arrays, **kwargs)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/tensor/extra_ops.py\", line 1532, in broadcast_shape_iter\n", - " raise ValueError(\n", - "ValueError: Could not broadcast dimensions. Incompatible shapes were [(TensorConstant(TensorType(int64, shape=()), data=array(30)), TensorConstant(TensorType(int64, shape=()), data=array(2)), TensorConstant(TensorType(int64, shape=()), data=array(3))), (TensorConstant(TensorType(int64, shape=()), data=array(30)), TensorConstant(TensorType(int64, shape=()), data=array(1000)), ScalarConstant(ScalarType(int64), data=1))].\n", - "\n", - " warn(msg)\n", - "/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/tensor/rewriting/shape.py:156: UserWarning: Failed to infer_shape from Op Composite{(sqr((i0 - i1)) * i2)}.\n", - "Input shapes: [(TensorConstant(TensorType(int64, shape=()), data=array(30)), TensorConstant(TensorType(int64, shape=()), data=array(2)), TensorConstant(TensorType(int64, shape=()), data=array(3))), (TensorConstant(TensorType(int64, shape=()), data=array(1)), Shape_i{0}.0, Cast{int64}.0), (TensorConstant(TensorType(int64, shape=()), data=array(30)), TensorConstant(TensorType(int64, shape=()), data=array(1000)), TensorConstant(TensorType(int64, shape=()), data=array(1)))]\n", - "Exception encountered during infer_shape: \n", - "Exception message: Could not broadcast dimensions. Incompatible shapes were [(TensorConstant(TensorType(int64, shape=()), data=array(30)), TensorConstant(TensorType(int64, shape=()), data=array(2)), TensorConstant(TensorType(int64, shape=()), data=array(3))), (ScalarConstant(ScalarType(int64), data=1), Shape_i{0}.0, Cast{int64}.0), (TensorConstant(TensorType(int64, shape=()), data=array(30)), TensorConstant(TensorType(int64, shape=()), data=array(1000)), ScalarConstant(ScalarType(int64), data=1))].\n", - "Traceback: Traceback (most recent call last):\n", - " File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/tensor/rewriting/shape.py\", line 132, in get_node_infer_shape\n", - " o_shapes = shape_infer(\n", - " ^^^^^^^^^^^^\n", - " File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/tensor/elemwise.py\", line 771, in infer_shape\n", - " out_shape = broadcast_shape(*i_shapes, arrays_are_shapes=True)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/tensor/extra_ops.py\", line 1451, in broadcast_shape\n", - " return broadcast_shape_iter(arrays, **kwargs)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/tensor/extra_ops.py\", line 1532, in broadcast_shape_iter\n", - " raise ValueError(\n", - "ValueError: Could not broadcast dimensions. Incompatible shapes were [(TensorConstant(TensorType(int64, shape=()), data=array(30)), TensorConstant(TensorType(int64, shape=()), data=array(2)), TensorConstant(TensorType(int64, shape=()), data=array(3))), (ScalarConstant(ScalarType(int64), data=1), Shape_i{0}.0, Cast{int64}.0), (TensorConstant(TensorType(int64, shape=()), data=array(30)), TensorConstant(TensorType(int64, shape=()), data=array(1000)), ScalarConstant(ScalarType(int64), data=1))].\n", - "\n", - " warn(msg)\n" - ] - }, - { - "ename": "IndexError", - "evalue": "index out of bounds\nApply node that caused the error: Subtensor{i}(*3-, ScalarFromTensor.0)\nToposort index: 6\nInputs types: [TensorType(float64, shape=(None,)), ScalarType(int64)]\nInputs shapes: [(1000,), ()]\nInputs strides: [(8,), ()]\nInputs values: ['not shown', 1000]\nOutputs clients: [[ExpandDims{axis=0}(Subtensor{i}.0)]]\n\nBacktrace when the node is created (use PyTensor flag traceback__limit=N to make it longer):\n File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/IPython/core/interactiveshell.py\", line 3577, in run_code\n exec(code_obj, self.user_global_ns, self.user_ns)\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1489974652.py\", line 1, in \n particles, log_weights = particle_filter(\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 142, in particle_filter\n [particles, weights], _ = pytensor.scan(\n File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/basic.py\", line 854, in scan\n raw_inner_outputs = fn(*args)\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 133, in step\n systematic_resample(\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 80, in systematic_resample\n _, updates = pytensor.scan(\n File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/basic.py\", line 854, in scan\n raw_inner_outputs = fn(*args)\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 74, in step\n increments = pt.switch(positions[ii] < cumulative_sum[jj], [1, 0], [0, 1])\n\nHINT: Use the PyTensor flag `exception_verbosity=high` for a debug print-out and storage map footprint of this Apply node.\nApply node that caused the error: Scan{scan_fn, while_loop=True, inplace=none}(16960, Subtensor{:stop}.0, Subtensor{:stop}.0, Subtensor{:stop}.0, Composite{(0.001 * (i0 + i1))}.0, CumOp{None, add}.0)\nToposort index: 35\nInputs types: [TensorType(int16, shape=()), TensorType(int64, shape=(1, None)), TensorType(int64, shape=(2, None)), TensorType(int64, shape=(1, None)), TensorType(float64, shape=(1000,)), TensorType(float64, shape=(None,))]\nInputs shapes: [(), (1, 1), (2, 1000), (1, 1), (1000,), (1000,)]\nInputs strides: [(), (8, 8), (8000, 8), (8, 8), (8,), (8,)]\nInputs values: [array(16960, dtype=int16), array([[0]]), 'not shown', array([[0]]), 'not shown', 'not shown']\nOutputs clients: [[], [Subtensor{i}(Scan{scan_fn, while_loop=True, inplace=none}.1, -1)], []]\n\nHINT: Re-running with most PyTensor optimizations disabled could provide a back-trace showing when this node was created. This can be done by setting the PyTensor flag 'optimizer=fast_compile'. If that does not work, PyTensor optimizations can be disabled with 'optimizer=None'.\nHINT: Use the PyTensor flag `exception_verbosity=high` for a debug print-out and storage map footprint of this Apply node.\nApply node that caused the error: Scan{scan_fn, while_loop=False, inplace=all}(30, [[0. ... ]], [[[ 2.1862 ... 144801 ]]], SetSubtensor{:stop}.0, SetSubtensor{:stop}.0, RNG(), RNG(), RNG(), SetSubtensor{:stop}.0, SetSubtensor{:stop}.0, SetSubtensor{:stop}.0)\nToposort index: 26\nInputs types: [TensorType(int64, shape=()), TensorType(float64, shape=(30, 1)), TensorType(float64, shape=(30, 1, 4)), TensorType(float64, shape=(30, 1000, 3)), TensorType(float64, shape=(30, 1000)), RandomGeneratorType, RandomGeneratorType, RandomGeneratorType, TensorType(int64, shape=(16961, None)), TensorType(int64, shape=(16961, None)), TensorType(int64, shape=(16961, None))]\nInputs shapes: [(), (30, 1), (30, 1, 4), (30, 1000, 3), (30, 1000), 'No shapes', 'No shapes', 'No shapes', (16961, 1), (16961, 1000), (16961, 1)]\nInputs strides: [(), (8, 8), (32, 32, 8), (24000, 24, 8), (8000, 8), 'No strides', 'No strides', 'No strides', (8, 8), (8000, 8), (8, 8)]\nInputs values: [array(30), 'not shown', 'not shown', 'not shown', 'not shown', Generator(Philox) at 0x12A2D1620, Generator(Philox) at 0x12A287920, Generator(PCG64) at 0x12A2D2420, 'not shown', 'not shown', 'not shown']\nOutputs clients: [[Subtensor{:stop, :stop}(Scan{scan_fn, while_loop=False, inplace=all}.0, 30, 2), output[2](Scan{scan_fn, while_loop=False, inplace=all}.0)], [Exp(Scan{scan_fn, while_loop=False, inplace=all}.1), output[3](Scan{scan_fn, while_loop=False, inplace=all}.1)], [], []]\n\nHINT: Re-running with most PyTensor optimizations disabled could provide a back-trace showing when this node was created. This can be done by setting the PyTensor flag 'optimizer=fast_compile'. If that does not work, PyTensor optimizations can be disabled with 'optimizer=None'.\nHINT: Use the PyTensor flag `exception_verbosity=high` for a debug print-out and storage map footprint of this Apply node.", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1907\u001b[0m, in \u001b[0;36mScan.perform\u001b[0;34m(self, node, inputs, output_storage)\u001b[0m\n\u001b[1;32m 1906\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1907\u001b[0m \u001b[43mvm\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1908\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n", - "\u001b[0;31mIndexError\u001b[0m: index out of bounds", - "\nDuring handling of the above exception, another exception occurred:\n", - "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1907\u001b[0m, in \u001b[0;36mScan.perform\u001b[0;34m(self, node, inputs, output_storage)\u001b[0m\n\u001b[1;32m 1906\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1907\u001b[0m \u001b[43mvm\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1908\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1649\u001b[0m, in \u001b[0;36mScan.make_thunk..rval\u001b[0;34m(p, i, o, n, allow_gc)\u001b[0m\n\u001b[1;32m 1646\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrval\u001b[39m(\n\u001b[1;32m 1647\u001b[0m p\u001b[38;5;241m=\u001b[39mp, i\u001b[38;5;241m=\u001b[39mnode_input_storage, o\u001b[38;5;241m=\u001b[39mnode_output_storage, n\u001b[38;5;241m=\u001b[39mnode, allow_gc\u001b[38;5;241m=\u001b[39mallow_gc\n\u001b[1;32m 1648\u001b[0m ):\n\u001b[0;32m-> 1649\u001b[0m r \u001b[38;5;241m=\u001b[39m \u001b[43mp\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1650\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m o \u001b[38;5;129;01min\u001b[39;00m node\u001b[38;5;241m.\u001b[39moutputs:\n", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1915\u001b[0m, in \u001b[0;36mScan.perform\u001b[0;34m(self, node, inputs, output_storage)\u001b[0m\n\u001b[1;32m 1913\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(vm, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mthunks\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m 1914\u001b[0m \u001b[38;5;66;03m# For the CVM\u001b[39;00m\n\u001b[0;32m-> 1915\u001b[0m \u001b[43mlink_utils\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mraise_with_op\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1916\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmaker\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfgraph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1917\u001b[0m \u001b[43m \u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnodes\u001b[49m\u001b[43m[\u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mposition_of_error\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1918\u001b[0m \u001b[43m \u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mthunks\u001b[49m\u001b[43m[\u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mposition_of_error\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1919\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1920\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1921\u001b[0m \u001b[38;5;66;03m# For the c linker\u001b[39;00m\n\u001b[1;32m 1922\u001b[0m \u001b[38;5;66;03m# We don't have access from python to all the\u001b[39;00m\n\u001b[1;32m 1923\u001b[0m \u001b[38;5;66;03m# temps values So for now, we just don't print\u001b[39;00m\n\u001b[1;32m 1924\u001b[0m \u001b[38;5;66;03m# the extra shapes/strides info\u001b[39;00m\n", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/link/utils.py:524\u001b[0m, in \u001b[0;36mraise_with_op\u001b[0;34m(fgraph, node, thunk, exc_info, storage_map)\u001b[0m\n\u001b[1;32m 522\u001b[0m \u001b[38;5;66;03m# Some exception need extra parameter in inputs. So forget the\u001b[39;00m\n\u001b[1;32m 523\u001b[0m \u001b[38;5;66;03m# extra long error message in that case.\u001b[39;00m\n\u001b[0;32m--> 524\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exc_value\u001b[38;5;241m.\u001b[39mwith_traceback(exc_trace)\n", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1907\u001b[0m, in \u001b[0;36mScan.perform\u001b[0;34m(self, node, inputs, output_storage)\u001b[0m\n\u001b[1;32m 1906\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1907\u001b[0m \u001b[43mvm\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1908\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n", - "\u001b[0;31mIndexError\u001b[0m: index out of bounds\nApply node that caused the error: Subtensor{i}(*3-, ScalarFromTensor.0)\nToposort index: 6\nInputs types: [TensorType(float64, shape=(None,)), ScalarType(int64)]\nInputs shapes: [(1000,), ()]\nInputs strides: [(8,), ()]\nInputs values: ['not shown', 1000]\nOutputs clients: [[ExpandDims{axis=0}(Subtensor{i}.0)]]\n\nBacktrace when the node is created (use PyTensor flag traceback__limit=N to make it longer):\n File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/IPython/core/interactiveshell.py\", line 3577, in run_code\n exec(code_obj, self.user_global_ns, self.user_ns)\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1489974652.py\", line 1, in \n particles, log_weights = particle_filter(\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 142, in particle_filter\n [particles, weights], _ = pytensor.scan(\n File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/basic.py\", line 854, in scan\n raw_inner_outputs = fn(*args)\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 133, in step\n systematic_resample(\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 80, in systematic_resample\n _, updates = pytensor.scan(\n File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/basic.py\", line 854, in scan\n raw_inner_outputs = fn(*args)\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 74, in step\n increments = pt.switch(positions[ii] < cumulative_sum[jj], [1, 0], [0, 1])\n\nHINT: Use the PyTensor flag `exception_verbosity=high` for a debug print-out and storage map footprint of this Apply node.", - "\nDuring handling of the above exception, another exception occurred:\n", - "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/compile/function/types.py:960\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 958\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 959\u001b[0m outputs \u001b[38;5;241m=\u001b[39m (\n\u001b[0;32m--> 960\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvm\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 961\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m output_subset \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 962\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mvm(output_subset\u001b[38;5;241m=\u001b[39moutput_subset)\n\u001b[1;32m 963\u001b[0m )\n\u001b[1;32m 964\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1649\u001b[0m, in \u001b[0;36mScan.make_thunk..rval\u001b[0;34m(p, i, o, n, allow_gc)\u001b[0m\n\u001b[1;32m 1646\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrval\u001b[39m(\n\u001b[1;32m 1647\u001b[0m p\u001b[38;5;241m=\u001b[39mp, i\u001b[38;5;241m=\u001b[39mnode_input_storage, o\u001b[38;5;241m=\u001b[39mnode_output_storage, n\u001b[38;5;241m=\u001b[39mnode, allow_gc\u001b[38;5;241m=\u001b[39mallow_gc\n\u001b[1;32m 1648\u001b[0m ):\n\u001b[0;32m-> 1649\u001b[0m r \u001b[38;5;241m=\u001b[39m \u001b[43mp\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1650\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m o \u001b[38;5;129;01min\u001b[39;00m node\u001b[38;5;241m.\u001b[39moutputs:\n", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1915\u001b[0m, in \u001b[0;36mScan.perform\u001b[0;34m(self, node, inputs, output_storage)\u001b[0m\n\u001b[1;32m 1913\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(vm, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mthunks\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m 1914\u001b[0m \u001b[38;5;66;03m# For the CVM\u001b[39;00m\n\u001b[0;32m-> 1915\u001b[0m \u001b[43mlink_utils\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mraise_with_op\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1916\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmaker\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfgraph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1917\u001b[0m \u001b[43m \u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnodes\u001b[49m\u001b[43m[\u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mposition_of_error\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1918\u001b[0m \u001b[43m \u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mthunks\u001b[49m\u001b[43m[\u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mposition_of_error\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1919\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1920\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1921\u001b[0m \u001b[38;5;66;03m# For the c linker\u001b[39;00m\n\u001b[1;32m 1922\u001b[0m \u001b[38;5;66;03m# We don't have access from python to all the\u001b[39;00m\n\u001b[1;32m 1923\u001b[0m \u001b[38;5;66;03m# temps values So for now, we just don't print\u001b[39;00m\n\u001b[1;32m 1924\u001b[0m \u001b[38;5;66;03m# the extra shapes/strides info\u001b[39;00m\n", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/link/utils.py:524\u001b[0m, in \u001b[0;36mraise_with_op\u001b[0;34m(fgraph, node, thunk, exc_info, storage_map)\u001b[0m\n\u001b[1;32m 522\u001b[0m \u001b[38;5;66;03m# Some exception need extra parameter in inputs. So forget the\u001b[39;00m\n\u001b[1;32m 523\u001b[0m \u001b[38;5;66;03m# extra long error message in that case.\u001b[39;00m\n\u001b[0;32m--> 524\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exc_value\u001b[38;5;241m.\u001b[39mwith_traceback(exc_trace)\n", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1907\u001b[0m, in \u001b[0;36mScan.perform\u001b[0;34m(self, node, inputs, output_storage)\u001b[0m\n\u001b[1;32m 1906\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1907\u001b[0m \u001b[43mvm\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1908\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1649\u001b[0m, in \u001b[0;36mScan.make_thunk..rval\u001b[0;34m(p, i, o, n, allow_gc)\u001b[0m\n\u001b[1;32m 1646\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrval\u001b[39m(\n\u001b[1;32m 1647\u001b[0m p\u001b[38;5;241m=\u001b[39mp, i\u001b[38;5;241m=\u001b[39mnode_input_storage, o\u001b[38;5;241m=\u001b[39mnode_output_storage, n\u001b[38;5;241m=\u001b[39mnode, allow_gc\u001b[38;5;241m=\u001b[39mallow_gc\n\u001b[1;32m 1648\u001b[0m ):\n\u001b[0;32m-> 1649\u001b[0m r \u001b[38;5;241m=\u001b[39m \u001b[43mp\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1650\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m o \u001b[38;5;129;01min\u001b[39;00m node\u001b[38;5;241m.\u001b[39moutputs:\n", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1915\u001b[0m, in \u001b[0;36mScan.perform\u001b[0;34m(self, node, inputs, output_storage)\u001b[0m\n\u001b[1;32m 1913\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(vm, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mthunks\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m 1914\u001b[0m \u001b[38;5;66;03m# For the CVM\u001b[39;00m\n\u001b[0;32m-> 1915\u001b[0m \u001b[43mlink_utils\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mraise_with_op\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1916\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmaker\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfgraph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1917\u001b[0m \u001b[43m \u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnodes\u001b[49m\u001b[43m[\u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mposition_of_error\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1918\u001b[0m \u001b[43m \u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mthunks\u001b[49m\u001b[43m[\u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mposition_of_error\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1919\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1920\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1921\u001b[0m \u001b[38;5;66;03m# For the c linker\u001b[39;00m\n\u001b[1;32m 1922\u001b[0m \u001b[38;5;66;03m# We don't have access from python to all the\u001b[39;00m\n\u001b[1;32m 1923\u001b[0m \u001b[38;5;66;03m# temps values So for now, we just don't print\u001b[39;00m\n\u001b[1;32m 1924\u001b[0m \u001b[38;5;66;03m# the extra shapes/strides info\u001b[39;00m\n", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/link/utils.py:524\u001b[0m, in \u001b[0;36mraise_with_op\u001b[0;34m(fgraph, node, thunk, exc_info, storage_map)\u001b[0m\n\u001b[1;32m 522\u001b[0m \u001b[38;5;66;03m# Some exception need extra parameter in inputs. So forget the\u001b[39;00m\n\u001b[1;32m 523\u001b[0m \u001b[38;5;66;03m# extra long error message in that case.\u001b[39;00m\n\u001b[0;32m--> 524\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exc_value\u001b[38;5;241m.\u001b[39mwith_traceback(exc_trace)\n", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1907\u001b[0m, in \u001b[0;36mScan.perform\u001b[0;34m(self, node, inputs, output_storage)\u001b[0m\n\u001b[1;32m 1906\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1907\u001b[0m \u001b[43mvm\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1908\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n", - "\u001b[0;31mIndexError\u001b[0m: index out of bounds\nApply node that caused the error: Subtensor{i}(*3-, ScalarFromTensor.0)\nToposort index: 6\nInputs types: [TensorType(float64, shape=(None,)), ScalarType(int64)]\nInputs shapes: [(1000,), ()]\nInputs strides: [(8,), ()]\nInputs values: ['not shown', 1000]\nOutputs clients: [[ExpandDims{axis=0}(Subtensor{i}.0)]]\n\nBacktrace when the node is created (use PyTensor flag traceback__limit=N to make it longer):\n File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/IPython/core/interactiveshell.py\", line 3577, in run_code\n exec(code_obj, self.user_global_ns, self.user_ns)\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1489974652.py\", line 1, in \n particles, log_weights = particle_filter(\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 142, in particle_filter\n [particles, weights], _ = pytensor.scan(\n File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/basic.py\", line 854, in scan\n raw_inner_outputs = fn(*args)\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 133, in step\n systematic_resample(\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 80, in systematic_resample\n _, updates = pytensor.scan(\n File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/basic.py\", line 854, in scan\n raw_inner_outputs = fn(*args)\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 74, in step\n increments = pt.switch(positions[ii] < cumulative_sum[jj], [1, 0], [0, 1])\n\nHINT: Use the PyTensor flag `exception_verbosity=high` for a debug print-out and storage map footprint of this Apply node.\nApply node that caused the error: Scan{scan_fn, while_loop=True, inplace=none}(16960, Subtensor{:stop}.0, Subtensor{:stop}.0, Subtensor{:stop}.0, Composite{(0.001 * (i0 + i1))}.0, CumOp{None, add}.0)\nToposort index: 35\nInputs types: [TensorType(int16, shape=()), TensorType(int64, shape=(1, None)), TensorType(int64, shape=(2, None)), TensorType(int64, shape=(1, None)), TensorType(float64, shape=(1000,)), TensorType(float64, shape=(None,))]\nInputs shapes: [(), (1, 1), (2, 1000), (1, 1), (1000,), (1000,)]\nInputs strides: [(), (8, 8), (8000, 8), (8, 8), (8,), (8,)]\nInputs values: [array(16960, dtype=int16), array([[0]]), 'not shown', array([[0]]), 'not shown', 'not shown']\nOutputs clients: [[], [Subtensor{i}(Scan{scan_fn, while_loop=True, inplace=none}.1, -1)], []]\n\nHINT: Re-running with most PyTensor optimizations disabled could provide a back-trace showing when this node was created. This can be done by setting the PyTensor flag 'optimizer=fast_compile'. If that does not work, PyTensor optimizations can be disabled with 'optimizer=None'.\nHINT: Use the PyTensor flag `exception_verbosity=high` for a debug print-out and storage map footprint of this Apply node.", - "\nDuring handling of the above exception, another exception occurred:\n", - "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[10], line 4\u001b[0m\n\u001b[1;32m 1\u001b[0m estimate_mean, estimate_std \u001b[38;5;241m=\u001b[39m estimate(particles, log_weights)\n\u001b[1;32m 3\u001b[0m func \u001b[38;5;241m=\u001b[39m pytensor\u001b[38;5;241m.\u001b[39mfunction([], [estimate_mean, estimate_std, particles, log_weights])\n\u001b[0;32m----> 4\u001b[0m mean, std, parts, lws \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/compile/function/types.py:973\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 971\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mvm, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mthunks\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m 972\u001b[0m thunk \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mvm\u001b[38;5;241m.\u001b[39mthunks[\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mvm\u001b[38;5;241m.\u001b[39mposition_of_error]\n\u001b[0;32m--> 973\u001b[0m \u001b[43mraise_with_op\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 974\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmaker\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfgraph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 975\u001b[0m \u001b[43m \u001b[49m\u001b[43mnode\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnodes\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mposition_of_error\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 976\u001b[0m \u001b[43m \u001b[49m\u001b[43mthunk\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mthunk\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 977\u001b[0m \u001b[43m \u001b[49m\u001b[43mstorage_map\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mgetattr\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvm\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstorage_map\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 978\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 979\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 980\u001b[0m \u001b[38;5;66;03m# old-style linkers raise their own exceptions\u001b[39;00m\n\u001b[1;32m 981\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m\n", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/link/utils.py:524\u001b[0m, in \u001b[0;36mraise_with_op\u001b[0;34m(fgraph, node, thunk, exc_info, storage_map)\u001b[0m\n\u001b[1;32m 519\u001b[0m warnings\u001b[38;5;241m.\u001b[39mwarn(\n\u001b[1;32m 520\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mexc_type\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m error does not allow us to add an extra error message\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 521\u001b[0m )\n\u001b[1;32m 522\u001b[0m \u001b[38;5;66;03m# Some exception need extra parameter in inputs. So forget the\u001b[39;00m\n\u001b[1;32m 523\u001b[0m \u001b[38;5;66;03m# extra long error message in that case.\u001b[39;00m\n\u001b[0;32m--> 524\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exc_value\u001b[38;5;241m.\u001b[39mwith_traceback(exc_trace)\n", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/compile/function/types.py:960\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 957\u001b[0m t0_fn \u001b[38;5;241m=\u001b[39m time\u001b[38;5;241m.\u001b[39mperf_counter()\n\u001b[1;32m 958\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 959\u001b[0m outputs \u001b[38;5;241m=\u001b[39m (\n\u001b[0;32m--> 960\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvm\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 961\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m output_subset \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 962\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mvm(output_subset\u001b[38;5;241m=\u001b[39moutput_subset)\n\u001b[1;32m 963\u001b[0m )\n\u001b[1;32m 964\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n\u001b[1;32m 965\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_restore_defaults()\n", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1649\u001b[0m, in \u001b[0;36mScan.make_thunk..rval\u001b[0;34m(p, i, o, n, allow_gc)\u001b[0m\n\u001b[1;32m 1646\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrval\u001b[39m(\n\u001b[1;32m 1647\u001b[0m p\u001b[38;5;241m=\u001b[39mp, i\u001b[38;5;241m=\u001b[39mnode_input_storage, o\u001b[38;5;241m=\u001b[39mnode_output_storage, n\u001b[38;5;241m=\u001b[39mnode, allow_gc\u001b[38;5;241m=\u001b[39mallow_gc\n\u001b[1;32m 1648\u001b[0m ):\n\u001b[0;32m-> 1649\u001b[0m r \u001b[38;5;241m=\u001b[39m \u001b[43mp\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1650\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m o \u001b[38;5;129;01min\u001b[39;00m node\u001b[38;5;241m.\u001b[39moutputs:\n\u001b[1;32m 1651\u001b[0m compute_map[o][\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1915\u001b[0m, in \u001b[0;36mScan.perform\u001b[0;34m(self, node, inputs, output_storage)\u001b[0m\n\u001b[1;32m 1909\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(vm, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mposition_of_error\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m 1910\u001b[0m \u001b[38;5;66;03m# this is a new vm-provided function or c linker\u001b[39;00m\n\u001b[1;32m 1911\u001b[0m \u001b[38;5;66;03m# they need this because the exception manipulation\u001b[39;00m\n\u001b[1;32m 1912\u001b[0m \u001b[38;5;66;03m# done by raise_with_op is not implemented in C.\u001b[39;00m\n\u001b[1;32m 1913\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(vm, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mthunks\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m 1914\u001b[0m \u001b[38;5;66;03m# For the CVM\u001b[39;00m\n\u001b[0;32m-> 1915\u001b[0m \u001b[43mlink_utils\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mraise_with_op\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1916\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmaker\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfgraph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1917\u001b[0m \u001b[43m \u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnodes\u001b[49m\u001b[43m[\u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mposition_of_error\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1918\u001b[0m \u001b[43m \u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mthunks\u001b[49m\u001b[43m[\u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mposition_of_error\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1919\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1920\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1921\u001b[0m \u001b[38;5;66;03m# For the c linker\u001b[39;00m\n\u001b[1;32m 1922\u001b[0m \u001b[38;5;66;03m# We don't have access from python to all the\u001b[39;00m\n\u001b[1;32m 1923\u001b[0m \u001b[38;5;66;03m# temps values So for now, we just don't print\u001b[39;00m\n\u001b[1;32m 1924\u001b[0m \u001b[38;5;66;03m# the extra shapes/strides info\u001b[39;00m\n\u001b[1;32m 1925\u001b[0m link_utils\u001b[38;5;241m.\u001b[39mraise_with_op(\n\u001b[1;32m 1926\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfn\u001b[38;5;241m.\u001b[39mmaker\u001b[38;5;241m.\u001b[39mfgraph, vm\u001b[38;5;241m.\u001b[39mnodes[vm\u001b[38;5;241m.\u001b[39mposition_of_error]\n\u001b[1;32m 1927\u001b[0m )\n", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/link/utils.py:524\u001b[0m, in \u001b[0;36mraise_with_op\u001b[0;34m(fgraph, node, thunk, exc_info, storage_map)\u001b[0m\n\u001b[1;32m 519\u001b[0m warnings\u001b[38;5;241m.\u001b[39mwarn(\n\u001b[1;32m 520\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mexc_type\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m error does not allow us to add an extra error message\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 521\u001b[0m )\n\u001b[1;32m 522\u001b[0m \u001b[38;5;66;03m# Some exception need extra parameter in inputs. So forget the\u001b[39;00m\n\u001b[1;32m 523\u001b[0m \u001b[38;5;66;03m# extra long error message in that case.\u001b[39;00m\n\u001b[0;32m--> 524\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exc_value\u001b[38;5;241m.\u001b[39mwith_traceback(exc_trace)\n", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1907\u001b[0m, in \u001b[0;36mScan.perform\u001b[0;34m(self, node, inputs, output_storage)\u001b[0m\n\u001b[1;32m 1904\u001b[0m t0_fn \u001b[38;5;241m=\u001b[39m time\u001b[38;5;241m.\u001b[39mperf_counter()\n\u001b[1;32m 1906\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1907\u001b[0m \u001b[43mvm\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1908\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n\u001b[1;32m 1909\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(vm, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mposition_of_error\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m 1910\u001b[0m \u001b[38;5;66;03m# this is a new vm-provided function or c linker\u001b[39;00m\n\u001b[1;32m 1911\u001b[0m \u001b[38;5;66;03m# they need this because the exception manipulation\u001b[39;00m\n\u001b[1;32m 1912\u001b[0m \u001b[38;5;66;03m# done by raise_with_op is not implemented in C.\u001b[39;00m\n", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1649\u001b[0m, in \u001b[0;36mScan.make_thunk..rval\u001b[0;34m(p, i, o, n, allow_gc)\u001b[0m\n\u001b[1;32m 1646\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrval\u001b[39m(\n\u001b[1;32m 1647\u001b[0m p\u001b[38;5;241m=\u001b[39mp, i\u001b[38;5;241m=\u001b[39mnode_input_storage, o\u001b[38;5;241m=\u001b[39mnode_output_storage, n\u001b[38;5;241m=\u001b[39mnode, allow_gc\u001b[38;5;241m=\u001b[39mallow_gc\n\u001b[1;32m 1648\u001b[0m ):\n\u001b[0;32m-> 1649\u001b[0m r \u001b[38;5;241m=\u001b[39m \u001b[43mp\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mx\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1650\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m o \u001b[38;5;129;01min\u001b[39;00m node\u001b[38;5;241m.\u001b[39moutputs:\n\u001b[1;32m 1651\u001b[0m compute_map[o][\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1915\u001b[0m, in \u001b[0;36mScan.perform\u001b[0;34m(self, node, inputs, output_storage)\u001b[0m\n\u001b[1;32m 1909\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(vm, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mposition_of_error\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m 1910\u001b[0m \u001b[38;5;66;03m# this is a new vm-provided function or c linker\u001b[39;00m\n\u001b[1;32m 1911\u001b[0m \u001b[38;5;66;03m# they need this because the exception manipulation\u001b[39;00m\n\u001b[1;32m 1912\u001b[0m \u001b[38;5;66;03m# done by raise_with_op is not implemented in C.\u001b[39;00m\n\u001b[1;32m 1913\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(vm, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mthunks\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m 1914\u001b[0m \u001b[38;5;66;03m# For the CVM\u001b[39;00m\n\u001b[0;32m-> 1915\u001b[0m \u001b[43mlink_utils\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mraise_with_op\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1916\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmaker\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfgraph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1917\u001b[0m \u001b[43m \u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnodes\u001b[49m\u001b[43m[\u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mposition_of_error\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1918\u001b[0m \u001b[43m \u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mthunks\u001b[49m\u001b[43m[\u001b[49m\u001b[43mvm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mposition_of_error\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1919\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1920\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1921\u001b[0m \u001b[38;5;66;03m# For the c linker\u001b[39;00m\n\u001b[1;32m 1922\u001b[0m \u001b[38;5;66;03m# We don't have access from python to all the\u001b[39;00m\n\u001b[1;32m 1923\u001b[0m \u001b[38;5;66;03m# temps values So for now, we just don't print\u001b[39;00m\n\u001b[1;32m 1924\u001b[0m \u001b[38;5;66;03m# the extra shapes/strides info\u001b[39;00m\n\u001b[1;32m 1925\u001b[0m link_utils\u001b[38;5;241m.\u001b[39mraise_with_op(\n\u001b[1;32m 1926\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfn\u001b[38;5;241m.\u001b[39mmaker\u001b[38;5;241m.\u001b[39mfgraph, vm\u001b[38;5;241m.\u001b[39mnodes[vm\u001b[38;5;241m.\u001b[39mposition_of_error]\n\u001b[1;32m 1927\u001b[0m )\n", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/link/utils.py:524\u001b[0m, in \u001b[0;36mraise_with_op\u001b[0;34m(fgraph, node, thunk, exc_info, storage_map)\u001b[0m\n\u001b[1;32m 519\u001b[0m warnings\u001b[38;5;241m.\u001b[39mwarn(\n\u001b[1;32m 520\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mexc_type\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m error does not allow us to add an extra error message\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 521\u001b[0m )\n\u001b[1;32m 522\u001b[0m \u001b[38;5;66;03m# Some exception need extra parameter in inputs. So forget the\u001b[39;00m\n\u001b[1;32m 523\u001b[0m \u001b[38;5;66;03m# extra long error message in that case.\u001b[39;00m\n\u001b[0;32m--> 524\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exc_value\u001b[38;5;241m.\u001b[39mwith_traceback(exc_trace)\n", - "File \u001b[0;32m~/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/op.py:1907\u001b[0m, in \u001b[0;36mScan.perform\u001b[0;34m(self, node, inputs, output_storage)\u001b[0m\n\u001b[1;32m 1904\u001b[0m t0_fn \u001b[38;5;241m=\u001b[39m time\u001b[38;5;241m.\u001b[39mperf_counter()\n\u001b[1;32m 1906\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1907\u001b[0m \u001b[43mvm\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1908\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n\u001b[1;32m 1909\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(vm, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mposition_of_error\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m 1910\u001b[0m \u001b[38;5;66;03m# this is a new vm-provided function or c linker\u001b[39;00m\n\u001b[1;32m 1911\u001b[0m \u001b[38;5;66;03m# they need this because the exception manipulation\u001b[39;00m\n\u001b[1;32m 1912\u001b[0m \u001b[38;5;66;03m# done by raise_with_op is not implemented in C.\u001b[39;00m\n", - "\u001b[0;31mIndexError\u001b[0m: index out of bounds\nApply node that caused the error: Subtensor{i}(*3-, ScalarFromTensor.0)\nToposort index: 6\nInputs types: [TensorType(float64, shape=(None,)), ScalarType(int64)]\nInputs shapes: [(1000,), ()]\nInputs strides: [(8,), ()]\nInputs values: ['not shown', 1000]\nOutputs clients: [[ExpandDims{axis=0}(Subtensor{i}.0)]]\n\nBacktrace when the node is created (use PyTensor flag traceback__limit=N to make it longer):\n File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/IPython/core/interactiveshell.py\", line 3577, in run_code\n exec(code_obj, self.user_global_ns, self.user_ns)\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1489974652.py\", line 1, in \n particles, log_weights = particle_filter(\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 142, in particle_filter\n [particles, weights], _ = pytensor.scan(\n File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/basic.py\", line 854, in scan\n raw_inner_outputs = fn(*args)\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 133, in step\n systematic_resample(\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 80, in systematic_resample\n _, updates = pytensor.scan(\n File \"/Users/lucianopaz/miniforge3/envs/pymc/lib/python3.11/site-packages/pytensor/scan/basic.py\", line 854, in scan\n raw_inner_outputs = fn(*args)\n File \"/var/folders/p0/81r8yvt526ldqjrrf14b4bd00000gn/T/ipykernel_29222/1625854891.py\", line 74, in step\n increments = pt.switch(positions[ii] < cumulative_sum[jj], [1, 0], [0, 1])\n\nHINT: Use the PyTensor flag `exception_verbosity=high` for a debug print-out and storage map footprint of this Apply node.\nApply node that caused the error: Scan{scan_fn, while_loop=True, inplace=none}(16960, Subtensor{:stop}.0, Subtensor{:stop}.0, Subtensor{:stop}.0, Composite{(0.001 * (i0 + i1))}.0, CumOp{None, add}.0)\nToposort index: 35\nInputs types: [TensorType(int16, shape=()), TensorType(int64, shape=(1, None)), TensorType(int64, shape=(2, None)), TensorType(int64, shape=(1, None)), TensorType(float64, shape=(1000,)), TensorType(float64, shape=(None,))]\nInputs shapes: [(), (1, 1), (2, 1000), (1, 1), (1000,), (1000,)]\nInputs strides: [(), (8, 8), (8000, 8), (8, 8), (8,), (8,)]\nInputs values: [array(16960, dtype=int16), array([[0]]), 'not shown', array([[0]]), 'not shown', 'not shown']\nOutputs clients: [[], [Subtensor{i}(Scan{scan_fn, while_loop=True, inplace=none}.1, -1)], []]\n\nHINT: Re-running with most PyTensor optimizations disabled could provide a back-trace showing when this node was created. This can be done by setting the PyTensor flag 'optimizer=fast_compile'. If that does not work, PyTensor optimizations can be disabled with 'optimizer=None'.\nHINT: Use the PyTensor flag `exception_verbosity=high` for a debug print-out and storage map footprint of this Apply node.\nApply node that caused the error: Scan{scan_fn, while_loop=False, inplace=all}(30, [[0. ... ]], [[[ 2.1862 ... 144801 ]]], SetSubtensor{:stop}.0, SetSubtensor{:stop}.0, RNG(), RNG(), RNG(), SetSubtensor{:stop}.0, SetSubtensor{:stop}.0, SetSubtensor{:stop}.0)\nToposort index: 26\nInputs types: [TensorType(int64, shape=()), TensorType(float64, shape=(30, 1)), TensorType(float64, shape=(30, 1, 4)), TensorType(float64, shape=(30, 1000, 3)), TensorType(float64, shape=(30, 1000)), RandomGeneratorType, RandomGeneratorType, RandomGeneratorType, TensorType(int64, shape=(16961, None)), TensorType(int64, shape=(16961, None)), TensorType(int64, shape=(16961, None))]\nInputs shapes: [(), (30, 1), (30, 1, 4), (30, 1000, 3), (30, 1000), 'No shapes', 'No shapes', 'No shapes', (16961, 1), (16961, 1000), (16961, 1)]\nInputs strides: [(), (8, 8), (32, 32, 8), (24000, 24, 8), (8000, 8), 'No strides', 'No strides', 'No strides', (8, 8), (8000, 8), (8, 8)]\nInputs values: [array(30), 'not shown', 'not shown', 'not shown', 'not shown', Generator(Philox) at 0x12A2D1620, Generator(Philox) at 0x12A287920, Generator(PCG64) at 0x12A2D2420, 'not shown', 'not shown', 'not shown']\nOutputs clients: [[Subtensor{:stop, :stop}(Scan{scan_fn, while_loop=False, inplace=all}.0, 30, 2), output[2](Scan{scan_fn, while_loop=False, inplace=all}.0)], [Exp(Scan{scan_fn, while_loop=False, inplace=all}.1), output[3](Scan{scan_fn, while_loop=False, inplace=all}.1)], [], []]\n\nHINT: Re-running with most PyTensor optimizations disabled could provide a back-trace showing when this node was created. This can be done by setting the PyTensor flag 'optimizer=fast_compile'. If that does not work, PyTensor optimizations can be disabled with 'optimizer=None'.\nHINT: Use the PyTensor flag `exception_verbosity=high` for a debug print-out and storage map footprint of this Apply node." - ] - } - ], + "outputs": [], "source": [ "estimate_mean, estimate_std = estimate(particles, log_weights)\n", "\n", @@ -427,16 +336,35 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "c462f598-961e-42ff-9b27-20d87a8de753", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "plt.plot(true_positions[:, 0], true_positions[:, 1], color=\"k\", label=\"True position\")\n", + "plt.plot(true_positions[:, 0], true_positions[:, 1], ls=\"--\", lw=2, color=\"k\", label=\"True position\")\n", "plt.errorbar(mean[:, 0], mean[:, 1], std[:, 0], std[:, 1], color=\"C0\", label=\"Estimate position\")\n", - "plt.scatter(parts[:, 0], parts[:, 1], c=1, s=np.exp(lws) * 10, cmap=\"greens\")\n", + "plt.scatter(parts[..., 0], parts[..., 1], c=\"green\", s=np.exp(lws) * 100, alpha=0.05)\n", "plt.legend();" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cba00acd-afa1-41c0-96ca-ec681dd5def7", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 7f0ab8976e187583279c2981641a6f73505dcf00 Mon Sep 17 00:00:00 2001 From: Luciano Paz Date: Mon, 10 Feb 2025 10:17:32 +0100 Subject: [PATCH 3/4] Lint notebook --- notebooks/exercises/particle_filter.ipynb | 84 +++++++++++++---------- 1 file changed, 49 insertions(+), 35 deletions(-) diff --git a/notebooks/exercises/particle_filter.ipynb b/notebooks/exercises/particle_filter.ipynb index 14ba0d9..be4d02d 100644 --- a/notebooks/exercises/particle_filter.ipynb +++ b/notebooks/exercises/particle_filter.ipynb @@ -19,12 +19,12 @@ "outputs": [], "source": [ "import numpy as np\n", + "import pymc as pm\n", "import pytensor\n", + "from matplotlib import pyplot as plt\n", "from pytensor import tensor as pt\n", - "from pytensor.tensor import random as ptr\n", "from pytensor.scan import until\n", - "import pymc as pm\n", - "from matplotlib import pyplot as plt" + "from pytensor.tensor import random as ptr" ] }, { @@ -66,8 +66,11 @@ " particles = pt.set_subtensor(particles[:, 2], particles[:, 2] % (2 * np.pi))\n", " return particles\n", "\n", - "def temporal_evolution(heading_change, velocity, particles, heading_noise, velocity_noise, dt):\n", - " \"\"\" move according to control input (heading change, velocity)\n", + "\n", + "def temporal_evolution(\n", + " heading_change, velocity, particles, heading_noise, velocity_noise, dt\n", + "):\n", + " \"\"\"move according to control input (heading change, velocity)\n", " with noise (std heading change, std velocity)`\"\"\"\n", "\n", " N = particles.shape[0]\n", @@ -99,24 +102,29 @@ "def update_weights(log_weights, particles, observed, sensor_noise, landmarks):\n", " dist_to_land = distances(particles[..., :2], landmarks)\n", " log_weights += pm.logprob.logp(\n", - " pm.Normal.dist(dist_to_land, sensor_noise),\n", - " observed\n", + " pm.Normal.dist(dist_to_land, sensor_noise), observed\n", " ).sum(axis=-1)\n", "\n", " log_weights -= pt.logsumexp(log_weights)\n", " return log_weights\n", "\n", + "\n", "def estimate(particles, log_weights):\n", " \"\"\"returns mean and variance of the weighted particles\"\"\"\n", "\n", " pos = particles[..., :2]\n", - " mean = pt.sum(pos * pt.exp(log_weights)[..., None], axis=-2) / pt.exp(log_weights[..., None]).sum(axis=-2)\n", - " var = pt.sum((pos - mean[..., None, :])**2 * pt.exp(log_weights)[..., None], axis=-2) / pt.exp(log_weights[..., None]).sum(axis=-2)\n", + " mean = pt.sum(pos * pt.exp(log_weights)[..., None], axis=-2) / pt.exp(\n", + " log_weights[..., None]\n", + " ).sum(axis=-2)\n", + " var = pt.sum(\n", + " (pos - mean[..., None, :]) ** 2 * pt.exp(log_weights)[..., None], axis=-2\n", + " ) / pt.exp(log_weights[..., None]).sum(axis=-2)\n", " return mean, pt.sqrt(var)\n", "\n", "\n", "def neff(log_weights):\n", - " return 1 / pt.sum(pt.exp(log_weights)**2)\n", + " return 1 / pt.sum(pt.exp(log_weights) ** 2)\n", + "\n", "\n", "def systematic_resample(particles, log_weights, n_particles):\n", " # make n_particles subdivisions, and choose positions with a\n", @@ -126,10 +134,10 @@ "\n", " weights = pt.exp(log_weights)\n", " cumulative_sum = pt.cumsum(weights)\n", - " indexes = pytensor.shared(np.zeros(n_particles, dtype='int'))\n", + " indexes = pytensor.shared(np.zeros(n_particles, dtype=\"int\"))\n", " i = pytensor.shared(np.array([0]))\n", " j = pytensor.shared(np.array([0]))\n", - " \n", + "\n", " def step(indexes, i, j, positions, cumulative_sum):\n", " ii = i[0]\n", " jj = j[0]\n", @@ -137,15 +145,21 @@ " indexes_update = pt.set_subtensor(indexes[ii], jj)\n", " i_update = i + increments[0]\n", " j_update = j + increments[1]\n", - " return [], {indexes: indexes_update, i: i_update, j: j_update}, until(pt.ge(ii, n_particles - 1))\n", + " return (\n", + " [],\n", + " {indexes: indexes_update, i: i_update, j: j_update},\n", + " until(pt.ge(ii, n_particles - 1)),\n", + " )\n", "\n", " _, updates = pytensor.scan(\n", " step,\n", " non_sequences=[indexes, i, j, positions, cumulative_sum],\n", - " n_steps=n_particles ** 2,\n", + " n_steps=n_particles**2,\n", " )\n", " inds = updates[indexes]\n", - " return particles[inds], pt.full(n_particles, -np.log(n_particles), dtype=log_weights.dtype)\n", + " return particles[inds], pt.full(\n", + " n_particles, -np.log(n_particles), dtype=log_weights.dtype\n", + " )\n", "\n", "\n", "def no_resample(particles, log_weights):\n", @@ -160,7 +174,7 @@ " heading_noise,\n", " velocity_noise,\n", " sensor_noise,\n", - " dt=1.,\n", + " dt=1.0,\n", " n_particles=1000,\n", " initial_particles=None,\n", "):\n", @@ -168,7 +182,6 @@ " initial_particles = create_gaussian_particles(n_particles=n_particles)\n", "\n", " initial_weights = -pt.ones(n_particles) * np.log(n_particles)\n", - " \n", "\n", " def step(heading_change, velocity, observed_distance, particles, log_weights):\n", " particles = temporal_evolution(\n", @@ -179,7 +192,7 @@ " velocity_noise=velocity_noise,\n", " dt=dt,\n", " )\n", - " \n", + "\n", " # incorporate measurements\n", " log_weights = update_weights(\n", " particles=particles,\n", @@ -188,10 +201,10 @@ " sensor_noise=sensor_noise,\n", " landmarks=landmarks,\n", " )\n", - " \n", + "\n", " # resample if too few effective particles\n", " particles, log_weights = pytensor.ifelse(\n", - " neff(log_weights) < n_particles/2,\n", + " neff(log_weights) < n_particles / 2,\n", " systematic_resample(\n", " particles=particles,\n", " log_weights=log_weights,\n", @@ -223,13 +236,13 @@ "metadata": {}, "outputs": [], "source": [ - "landmarks = np.array([[-1, 2], [5, 10], [12,14], [18,21]])\n", + "landmarks = np.array([[-1, 2], [5, 10], [12, 14], [18, 21]])\n", "heading_noise = 0.05\n", "velocity_noise = 0.2\n", "sensor_noise = 0.1\n", "dt = 0.1\n", "\n", - "initial_position = np.array([0, 0, np.pi/4])\n", + "initial_position = np.array([0, 0, np.pi / 4])\n", "n_time = 30\n", "intended_headings = np.deg2rad(6 * np.sin(np.linspace(0, 2 * np.pi, n_time)))\n", "max_speed = 5\n", @@ -269,7 +282,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -336,13 +349,13 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "id": "c462f598-961e-42ff-9b27-20d87a8de753", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -352,19 +365,20 @@ } ], "source": [ - "plt.plot(true_positions[:, 0], true_positions[:, 1], ls=\"--\", lw=2, color=\"k\", label=\"True position\")\n", - "plt.errorbar(mean[:, 0], mean[:, 1], std[:, 0], std[:, 1], color=\"C0\", label=\"Estimate position\")\n", + "plt.plot(\n", + " true_positions[:, 0],\n", + " true_positions[:, 1],\n", + " ls=\"--\",\n", + " lw=2,\n", + " color=\"k\",\n", + " label=\"True position\",\n", + ")\n", + "plt.errorbar(\n", + " mean[:, 0], mean[:, 1], std[:, 0], std[:, 1], color=\"C0\", label=\"Estimate position\"\n", + ")\n", "plt.scatter(parts[..., 0], parts[..., 1], c=\"green\", s=np.exp(lws) * 100, alpha=0.05)\n", "plt.legend();" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cba00acd-afa1-41c0-96ca-ec681dd5def7", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 7214150427959b96271746ddb3a55b5827918348 Mon Sep 17 00:00:00 2001 From: Ricardo Vieira Date: Mon, 10 Feb 2025 11:37:58 +0100 Subject: [PATCH 4/4] Fix RNG stuff --- notebooks/exercises/particle_filter.ipynb | 293 ++++++++++++++++------ 1 file changed, 222 insertions(+), 71 deletions(-) diff --git a/notebooks/exercises/particle_filter.ipynb b/notebooks/exercises/particle_filter.ipynb index be4d02d..670d342 100644 --- a/notebooks/exercises/particle_filter.ipynb +++ b/notebooks/exercises/particle_filter.ipynb @@ -1,19 +1,33 @@ { "cells": [ { - "cell_type": "code", - "execution_count": 1, - "id": "7df44352-d887-45dd-b6ae-79fb80d40e03", + "cell_type": "markdown", + "id": "b924dff1-d2d4-4945-bc94-0ac5c68ece8e", + "metadata": {}, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "id": "a8d77251-0074-4025-82de-724ee8a86487", "metadata": {}, - "outputs": [], "source": [ - "%load_ext autoreload\n", - "%autoreload 2" + "**💡 To better engage gray mass we suggest you turn off Colab AI autocompletion in `Tools > Settings > AI Assistance`**" + ] + }, + { + "cell_type": "markdown", + "id": "39302d7d-734d-444f-aa53-5f154bea5e57", + "metadata": {}, + "source": [ + "ref: https://filterpy.readthedocs.io/en/latest/_modules/filterpy/monte_carlo/resampling.html#systematic_resample\n", + "https://github.com/rlabbe/Kalman-and-Bayesian-Filters-in-Python/blob/master/12-Particle-Filters.ipynb" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "9a763464-20c6-4f7f-8cd8-2c2a39be03cb", "metadata": {}, "outputs": [], @@ -29,7 +43,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "a5eb1196-2435-4990-984a-29def6d2df2b", "metadata": {}, "outputs": [ @@ -39,7 +53,7 @@ "array(-1.33507789)" ] }, - "execution_count": 3, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -55,20 +69,20 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "97a04566-f56c-4dc0-8c2e-60d49e2300fa", "metadata": {}, "outputs": [], "source": [ - "def create_gaussian_particles(n_particles, mean=0, std=1):\n", - " mean, std = pt.broadcast_arrays(mean, std)\n", + "def create_gaussian_particles(rng, n_particles, mean=0, std=1):\n", + " # Generate a new particle for the robot state: x, y, and orientation (radians)\n", " particles = rng.normal(loc=mean, scale=std, size=(n_particles, 3))\n", " particles = pt.set_subtensor(particles[:, 2], particles[:, 2] % (2 * np.pi))\n", " return particles\n", "\n", "\n", "def temporal_evolution(\n", - " heading_change, velocity, particles, heading_noise, velocity_noise, dt\n", + " rng, heading_change, velocity, particles, heading_noise, velocity_noise, dt\n", "):\n", " \"\"\"move according to control input (heading change, velocity)\n", " with noise (std heading change, std velocity)`\"\"\"\n", @@ -81,13 +95,13 @@ " particles = pt.set_subtensor(particles[:, 2], particles[:, 2] % (2 * np.pi))\n", "\n", " # move in the (noisy) commanded direction\n", - " dist = (velocity * dt) + (pm.HalfNormal.dist(size=N) * velocity_noise)\n", + " dist = (velocity * dt) + (rng.halfnormal(size=N) * velocity_noise)\n", " particles = pt.inc_subtensor(particles[:, 0], pt.cos(particles[:, 2]) * dist)\n", " particles = pt.inc_subtensor(particles[:, 1], pt.sin(particles[:, 2]) * dist)\n", " return particles\n", "\n", "\n", - "def distances2(positions, landmarks):\n", + "def distances_sq(positions, landmarks):\n", " # positions.shape (n_particles, dim)\n", " # landmarks.shape (n_landmarks, dim)\n", " # out.shape (n_particles, n_landmarks)\n", @@ -96,15 +110,17 @@ "\n", "\n", "def distances(positions, landmarks):\n", - " return pt.sqrt(distances2(positions, landmarks))\n", + " return pt.sqrt(distances_sq(positions, landmarks))\n", + "\n", + "def normal_logpdf(x, loc, scale):\n", + " return -0.5 * pt.log(2 * np.pi * scale ** 2) -((x - loc) ** 2 / (2 * scale ** 2))\n", "\n", "\n", "def update_weights(log_weights, particles, observed, sensor_noise, landmarks):\n", + " \"\"\"Update particle weights based on the distance to landmarks as measured by the noisy sensor.\"\"\"\n", " dist_to_land = distances(particles[..., :2], landmarks)\n", - " log_weights += pm.logprob.logp(\n", - " pm.Normal.dist(dist_to_land, sensor_noise), observed\n", - " ).sum(axis=-1)\n", - "\n", + " # Or use pm.logp(pm.Normal.dist(dist_to_last, sensor_noite), observed)\n", + " log_weights += normal_logpdf(observed, dist_to_land, sensor_noise).sum(axis=-1)\n", " log_weights -= pt.logsumexp(log_weights)\n", " return log_weights\n", "\n", @@ -126,47 +142,49 @@ " return 1 / pt.sum(pt.exp(log_weights) ** 2)\n", "\n", "\n", - "def systematic_resample(particles, log_weights, n_particles):\n", - " # make n_particles subdivisions, and choose positions with a\n", - " # consistent random offset\n", - " n_particles = n_particles.eval()\n", + "def systematic_resample(rng, particles, log_weights, n_particles):\n", + " \"\"\"Performs the systemic resampling algorithm used by particle filters.\n", + "\n", + " This algorithm separates the sample space into N divisions. A single random\n", + " offset is used to to choose where to sample from for all divisions. This\n", + " guarantees that every sample is exactly 1/N apart.\n", + " \"\"\"\n", " positions = (rng.uniform() + pt.arange(n_particles)) / n_particles\n", "\n", " weights = pt.exp(log_weights)\n", " cumulative_sum = pt.cumsum(weights)\n", " indexes = pytensor.shared(np.zeros(n_particles, dtype=\"int\"))\n", - " i = pytensor.shared(np.array([0]))\n", - " j = pytensor.shared(np.array([0]))\n", - "\n", - " def step(indexes, i, j, positions, cumulative_sum):\n", - " ii = i[0]\n", - " jj = j[0]\n", - " increments = pt.switch(positions[ii] < cumulative_sum[jj], [1, 0], [0, 1])\n", - " indexes_update = pt.set_subtensor(indexes[ii], jj)\n", - " i_update = i + increments[0]\n", - " j_update = j + increments[1]\n", + " i = pt.zeros((), dtype=int)\n", + " j = pt.zeros((), dtype=int)\n", + "\n", + " def choose_indices_step(indexes, i, j, positions, cumulative_sum, n_particles):\n", + " cond = positions[i] < cumulative_sum[j]\n", + " indexes_update = indexes[i].set(pt.switch(cond, j, indexes[i]))\n", + " i_update = pt.switch(cond, i + 1, i)\n", + " j_update = pt.switch(cond, j, j + 1)\n", + " \n", " return (\n", - " [],\n", - " {indexes: indexes_update, i: i_update, j: j_update},\n", - " until(pt.ge(ii, n_particles - 1)),\n", + " [indexes_update, i_update, j_update],\n", + " until(i_update >= n_particles),\n", " )\n", "\n", - " _, updates = pytensor.scan(\n", - " step,\n", - " non_sequences=[indexes, i, j, positions, cumulative_sum],\n", + " [indexes_scan, _, _], _ = pytensor.scan(\n", + " choose_indices_step,\n", + " outputs_info=[indexes, i, j],\n", + " non_sequences=[positions, cumulative_sum, n_particles],\n", " n_steps=n_particles**2,\n", " )\n", - " inds = updates[indexes]\n", - " return particles[inds], pt.full(\n", - " n_particles, -np.log(n_particles), dtype=log_weights.dtype\n", - " )\n", - "\n", + " indexes = indexes_scan[-1]\n", "\n", - "def no_resample(particles, log_weights):\n", - " return particles, log_weights\n", + " new_particles = particles[indexes]\n", + " # After resampling, all particles have the same weights: 1 / n\n", + " new_weights = pt.full_like(log_weights, -pt.log(n_particles), dtype=log_weights.dtype)\n", + " \n", + " return new_particles, new_weights\n", "\n", "\n", "def particle_filter(\n", + " rng,\n", " observed_distances,\n", " landmarks,\n", " heading_changes,\n", @@ -179,12 +197,13 @@ " initial_particles=None,\n", "):\n", " if initial_particles is None:\n", - " initial_particles = create_gaussian_particles(n_particles=n_particles)\n", + " initial_particles = create_gaussian_particles(rng=rng, n_particles=n_particles)\n", "\n", - " initial_weights = -pt.ones(n_particles) * np.log(n_particles)\n", + " initial_weights = -pt.ones(n_particles) * pt.log(n_particles)\n", "\n", " def step(heading_change, velocity, observed_distance, particles, log_weights):\n", - " particles = temporal_evolution(\n", + " particles = temporal_evolution(\n", + " rng=rng,\n", " particles=particles,\n", " heading_change=heading_change,\n", " velocity=velocity,\n", @@ -203,18 +222,20 @@ " )\n", "\n", " # resample if too few effective particles\n", + " neff_log_weights = neff(log_weights)\n", " particles, log_weights = pytensor.ifelse(\n", - " neff(log_weights) < n_particles / 2,\n", + " neff_log_weights < n_particles / 2,\n", " systematic_resample(\n", + " rng=rng,\n", " particles=particles,\n", " log_weights=log_weights,\n", - " n_particles=pt.as_tensor_variable(n_particles),\n", + " n_particles=n_particles,\n", " ),\n", - " no_resample(particles, log_weights),\n", + " (particles, log_weights),\n", " )\n", - " return particles, log_weights\n", + " return particles, log_weights, neff_log_weights\n", "\n", - " [particles, weights], _ = pytensor.scan(\n", + " [particles_scan, weights_scan, neff_scan], rng_updates = pytensor.scan(\n", " step,\n", " sequences=[\n", " pt.as_tensor_variable(heading_changes),\n", @@ -224,14 +245,15 @@ " outputs_info=[\n", " initial_particles,\n", " initial_weights,\n", + " None,\n", " ],\n", " )\n", - " return particles, weights" + " return particles_scan, weights_scan, neff_scan, rng_updates" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "74f09e9b-9daf-4f23-b151-9a4a55705da7", "metadata": {}, "outputs": [], @@ -257,21 +279,53 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "4ff6e6ba-5d44-4f97-bd8e-7bec510bf16a", "metadata": {}, "outputs": [], "source": [ - "true_positions, _ = pytensor.scan(\n", - " temporal_evolution,\n", - " outputs_info=[pt.as_tensor_variable([initial_position])],\n", + "true_positions_pt, rng_updates = pytensor.scan(\n", + " lambda *args: temporal_evolution(rng, *args),\n", " sequences=[\n", " pt.as_tensor_variable(intended_headings),\n", " pt.as_tensor_variable(intended_velocities),\n", " ],\n", + " outputs_info=[pt.as_tensor_variable([initial_position])],\n", " non_sequences=[heading_noise, velocity_noise, dt],\n", ")\n", - "true_positions = true_positions[:, 0].eval()" + "true_positions_pt = true_positions_pt.squeeze(1) # squeeze the only particle we have\n", + "assert rng_updates" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "7fa50851-4fbe-4394-8b9d-2f9145d63b2d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/ricardo/Documents/pytensor/pytensor/graph/basic.py:656: UserWarning: Keyword arguments could not be used to create a cache key for the underlying variable. A function will be recompiled on every call with such keyword arguments.\n", + "unhashable type: 'OrderedUpdates'\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/plain": [ + "(30, 3)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "true_positions = true_positions_pt.eval(updates=rng_updates) \n", + "true_positions.shape # (30 timesteps, 3-vector state)" ] }, { @@ -282,7 +336,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -320,14 +374,15 @@ "metadata": {}, "outputs": [], "source": [ - "particles, log_weights = particle_filter(\n", + "particles, log_weights, neffs, rng_updates = particle_filter(\n", + " rng=rng,\n", " observed_distances=observed_distances,\n", " landmarks=landmarks,\n", " heading_changes=intended_headings,\n", " velocities=intended_velocities,\n", " heading_noise=heading_noise,\n", " velocity_noise=velocity_noise,\n", - " sensor_noise=sensor_noise,\n", + " sensor_noise=sensor_noise * 2,\n", " dt=dt,\n", " n_particles=1000,\n", " initial_particles=None,\n", @@ -343,19 +398,66 @@ "source": [ "estimate_mean, estimate_std = estimate(particles, log_weights)\n", "\n", - "func = pytensor.function([], [estimate_mean, estimate_std, particles, log_weights])\n", - "mean, std, parts, lws = func()" + "func = pytensor.function([], [estimate_mean, estimate_std, particles, log_weights, neffs], updates=rng_updates)" ] }, { "cell_type": "code", "execution_count": 11, + "id": "9ab04193-62bd-4b22-9f1e-823d4974ac36", + "metadata": {}, + "outputs": [], + "source": [ + "mean, std, parts, lws, neffs = func()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "5e3e7edc-b638-4523-9aa0-33e19894158f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 45.06759826, 154.07591109, 506.84658165, 193.62834441,\n", + " 550.04902585, 255.25951101, 654.81421472, 379.19125097,\n", + " 686.5101707 , 419.29741896, 753.32719965, 443.27006312,\n", + " 732.37477667, 399.39162703, 270.98097829, 679.42941573,\n", + " 384.49971935, 681.73532008, 340.29482615, 626.62568288,\n", + " 355.18695443, 731.05710619, 283.02408421, 704.21433365,\n", + " 208.96256994, 706.75162769, 432.04024528, 729.63776185,\n", + " 460.4651018 , 701.08854833])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "neffs" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "1528f374-631a-4c8d-aaa2-f2f927d34dd9", + "metadata": {}, + "outputs": [], + "source": [ + "# func.dprint()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, "id": "c462f598-961e-42ff-9b27-20d87a8de753", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -379,13 +481,62 @@ "plt.scatter(parts[..., 0], parts[..., 1], c=\"green\", s=np.exp(lws) * 100, alpha=0.05)\n", "plt.legend();" ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "46056b31-35ea-4e48-887b-b18b15b59653", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(\n", + " true_positions[:, 0],\n", + " true_positions[:, 1],\n", + " ls=\"--\",\n", + " lw=2,\n", + " color=\"k\",\n", + " label=\"True position\",\n", + ")\n", + "plt.errorbar(\n", + " mean[:, 0], mean[:, 1], std[:, 0], std[:, 1], color=\"C0\", label=\"Estimate position\"\n", + ")\n", + "plt.scatter(parts[..., 0], parts[..., 1], c=\"green\", s=np.exp(lws) * 100, alpha=0.05)\n", + "plt.legend();" + ] + }, + { + "cell_type": "markdown", + "id": "98b94c95-d613-4387-b76a-f5af78e2b5bf", + "metadata": {}, + "source": [ + "https://filterpy.readthedocs.io/en/latest/_modules/filterpy/monte_carlo/resampling.html#systematic_resample" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "16823a38-8f95-4481-ab63-0593a5a283ee", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "pymc", + "display_name": "pymc-dev", "language": "python", - "name": "pymc" + "name": "pymc-dev" }, "language_info": { "codemirror_mode": { @@ -397,7 +548,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.10" + "version": "3.12.8" } }, "nbformat": 4,