diff --git a/.github/workflows/nestml-build.yml b/.github/workflows/nestml-build.yml index 95ecbebc8..d385983ac 100644 --- a/.github/workflows/nestml-build.yml +++ b/.github/workflows/nestml-build.yml @@ -279,6 +279,11 @@ jobs: run: | pytest -s -o log_cli=true -o log_cli_level="DEBUG" tests/nest_tests/nest_integration_test.py + # Install Python dependencies + - name: Python dependencies + run: | + python -m pip install --upgrade pygame + # Run IPython/Jupyter notebooks - name: Run Jupyter notebooks if: ${{ matrix.nest_branch == 'master' }} diff --git a/doc/tutorials/mountain_car_reinforcement_learning/iaf_psc_exp_neuron.nestml b/doc/tutorials/mountain_car_reinforcement_learning/iaf_psc_exp_neuron.nestml new file mode 100644 index 000000000..5c5511640 --- /dev/null +++ b/doc/tutorials/mountain_car_reinforcement_learning/iaf_psc_exp_neuron.nestml @@ -0,0 +1,58 @@ +# iaf_psc_exp - Leaky integrate-and-fire neuron model +# ################################################### +# +# Description +# +++++++++++ +# +# ... +# +# +# References +# ++++++++++ +# +# ... +# +# See also +# ++++++++ +# +model iaf_psc_exp_neuron: + + state: + V_m mV = E_l # Membrane potential + g_e real = 0. + + equations: + g_e' = -g_e / tau_g + V_m' = (g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m + + parameters: + tau_m ms = 10 ms # Membrane time constant + tau_g ms = 5 ms + E_e mV = 0 mV + E_l mV = -74 mV # Resting potential + V_th mV = -54 mV # Spike threshold potential + V_reset mV = -60 mV + + # constant external input current + I_e real = 0 + + #scaling factor for incoming spikes + s real = 1000 + + input: + spikes_in_port <- spike + I_stim real <- continuous + + output: + spike + + update: + integrate_odes() + + onReceive(spikes_in_port): + g_e += spikes_in_port * s + + onCondition(V_m >= V_th): + # threshold crossing + V_m = V_reset + emit_spike() diff --git a/doc/tutorials/mountain_car_reinforcement_learning/mountain_car_reinforcement_learning_nestml_tutorial.ipynb b/doc/tutorials/mountain_car_reinforcement_learning/mountain_car_reinforcement_learning_nestml_tutorial.ipynb new file mode 100644 index 000000000..92f472289 --- /dev/null +++ b/doc/tutorials/mountain_car_reinforcement_learning/mountain_car_reinforcement_learning_nestml_tutorial.ipynb @@ -0,0 +1,2326 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "27c21179", + "metadata": {}, + "source": [ + "# Solving the \"mountain car\" task using NESTML\n", + "\n", + "In this tutorial, we are going to build an agent that can successfully solve the \"mountain car\" task using a biologically plausible form of reinforcement learning (reward-modulated STDP).\n", + "\n", + "The \"mountain car\" task is a classic reinforcement learning control problem where an underpowered car must reach a goal position on top of a hill by exploiting momentum dynamics. The agent observes a continuous 2D state space (position and velocity of the car) and selects from discrete actions (accelerate left, no action, accelerate right) to maximize the reward. The car's engine is insufficient to directly climb the steep slope, requiring the agent to learn an oscillatory policy that builds momentum by driving backward up the opposite hill before gaining enough kinetic energy to reach the goal.\n", + "\n", + "Typically, the mountain car problem is formulated as a sparse reward problem: while the agent is exploring, no reward is given. Only at the very end of a successful trial (the car having reached the end goal), is a sudden large reward given. The sparsity of the reward problem makes the mountain-car task especially challenging for exploration strategies in reinforcement learning algorithms. For the spiking network controller, we make the task easier by using *reward shaping:* a reward is given at every timestep, proportional to the performance of the agent at that time. This tutorial encourages you to play around with different reward shaping algorithms, but they typically include terms involving speed and height achieved.\n", + "\n", + "As a reference point, We will start by using a standard temporal difference (Q-learning) approach and after that, use NESTML to perform the task using a spiking neural network.\n", + "\n", + "## Mountain car environment\n", + "\n", + "For the environment, we mostly need: \n", + "- A renderer to display the simulation;\n", + "- The physical system (differential equations)\n", + " \n", + "We will use the popular \"pygame\" package to do the rendering [3]." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "6ded29bc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pygame 2.5.0 (SDL 2.28.0, Python 3.11.4)\n", + "Hello from the pygame community. https://www.pygame.org/contribute.html\n", + "\n", + " -- N E S T --\n", + " Copyright (C) 2004 The NEST Initiative\n", + "\n", + " Version: 3.8.0-post0.dev0\n", + " Built: Jun 2 2025 16:24:58\n", + "\n", + " This program is provided AS IS and comes with\n", + " NO WARRANTY. See the file LICENSE for details.\n", + "\n", + " Problems or suggestions?\n", + " Visit https://www.nest-simulator.org\n", + "\n", + " Type 'nest.help()' to find out more about NEST.\n", + "\n" + ] + } + ], + "source": [ + "from typing import List, Tuple, Optional\n", + "\n", + "from collections import defaultdict\n", + "\n", + "import copy\n", + "import enum\n", + "import json\n", + "import matplotlib as mpl\n", + "import matplotlib.colors\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import os\n", + "import random\n", + "import sys\n", + "import time\n", + "\n", + "import pygame\n", + "\n", + "import nest\n", + "\n", + "nest.set_verbosity(\"M_ERROR\")\n", + "nest_local_num_threads = 1\n", + "\n", + "mpl.rcParams[\"axes.grid\"] = True\n", + "mpl.rcParams[\"grid.color\"] = \"k\"\n", + "mpl.rcParams[\"grid.linestyle\"] = \":\"\n", + "mpl.rcParams[\"grid.linewidth\"] = 0.5\n", + "mpl.rcParams['axes.formatter.useoffset'] = False # never use offsets on any axis\n", + "mpl.rcParams['axes.formatter.use_locale'] = False # optional: also suppress 1 000→1,000 locale formatting" + ] + }, + { + "cell_type": "markdown", + "id": "74907eaf", + "metadata": {}, + "source": [ + "### Physics of the mountain car task\n", + "\n", + "The ``MountainCarPhysics`` class simulates the physics of the mountain-car environment. The environment is modeled as a car on a one-dimensional track, shaped by a sinusoidal function.\n", + "\n", + "The state of the system is defined by the car's position, $x$, and velocity, $v$. The dynamics are influenced by a constant gravitational force and a control force, $F$, applied by the agent.\n", + "\n", + "The height of the track, $h$, at any given position $x$ is defined by:\n", + "$$ h(p) = 0.45 \\sin(3x) + 0.55 $$\n", + "\n", + "The car's movement is governed the following set of ordinary differential equations (ODEs):\n", + "\n", + "$$ \\frac{dv}{dt} = F - g \\cos(3x) $$\n", + "$$ \\frac{dx}{dt} = v $$\n", + "\n", + "Where:\n", + "- $v$ is the velocity of the car.\n", + "- $x$ is the position of the car.\n", + "- $F$ is the force applied by the agent (either positive, negative, or zero).\n", + "- $g$ is the gravitational constant.\n", + "\n", + "These equations are discretized using the Forward Euler method for the simulation update:\n", + "\n", + "$$ v_{t+1} = v_t + (F - g \\cos(3x_t)) $$\n", + "$$ x_{t+1} = x_t + v_{t+1} \\cdot \\Delta t $$\n", + "\n", + "Note that the velocity is updated first and then used to update the position. The velocity and position are subsequently clamped to their respective predefined minimum and maximum values.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6b5f4227", + "metadata": {}, + "outputs": [], + "source": [ + "class MountainCarPhysics:\n", + " def __init__(self,\n", + " dt: float = 10E-3,\n", + " POS_MIN = -1.5,\n", + " POS_MAX = 0.6,\n", + " VEL_MIN = -0.07,\n", + " VEL_MAX = 0.07,\n", + " GOAL_POS = 0.5,\n", + " GRAVITY = 0.0025,\n", + " FORCE_MAG = 0.0005) -> None:\n", + "\n", + " self.min_position = POS_MIN\n", + " self.max_position = POS_MAX\n", + " self.min_velocity = VEL_MIN\n", + " self.max_velocity = VEL_MAX\n", + " self.goal_position = GOAL_POS\n", + " self.force_mag = FORCE_MAG\n", + " self.gravity = GRAVITY\n", + " self.dt = dt / 10E-3 # normalize timestep\n", + " \n", + " self.state = self.reset()\n", + "\n", + " def _height(self, pos):\n", + " \"\"\"Calculate the height of the mountain at a given position.\n", + " \n", + " Shape is a scaled sine wave.\n", + " \"\"\"\n", + " return np.sin(3 * pos) * 0.45 + 0.55\n", + "\n", + " def reset(self):\n", + " r\"\"\"\n", + " Resets the environment to a starting state.\n", + " \n", + " Start near the bottom with zero velocity.\n", + " \"\"\"\n", + " start_pos = random.uniform(-0.6, -0.4)\n", + " start_vel = 0.0\n", + " self.state = (start_pos, start_vel)\n", + "\n", + " return self.state\n", + "\n", + " def step(self, action):\n", + " \"\"\"\n", + " Applies an action, updates the state, and returns new state.\n", + " \"\"\"\n", + " position, velocity = self.state\n", + " assert action in AgentAction, \"Invalid action\"\n", + "\n", + " # Physics update\n", + " force = 0.\n", + " if action == AgentAction.LEFT:\n", + " force = -self.force_mag\n", + " elif action == AgentAction.RIGHT:\n", + " force = self.force_mag\n", + "\n", + " velocity += force - self.gravity * np.cos(3 * position)\n", + " velocity = max(self.min_velocity, min(self.max_velocity, velocity)) # Clamp velocity\n", + "\n", + " position += velocity * self.dt\n", + " position = max(self.min_position, min(self.max_position, position)) # Clamp position\n", + "\n", + " # Check for goal\n", + " done = bool(position >= self.goal_position or position <= self.min_position)\n", + "\n", + " self.state = (position, velocity)\n", + " \n", + " return self.state, done\n", + "\n", + " def get_state(self):\n", + " return self.state" + ] + }, + { + "cell_type": "markdown", + "id": "433225be", + "metadata": {}, + "source": [ + "To render the environment for visual inspection, we make a class ``Renderer`` that uses pygame.\n", + "\n", + "To prevent from slowing down the learning process, the visualisation is not shown by default. With the pygame window highlighted, press the spacebar to toggle the visualisation on/off." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d1af3680-b849-48bb-a653-642b580a01aa", + "metadata": {}, + "outputs": [], + "source": [ + "class MountainCarRenderer:\n", + " \n", + " def __init__(self, env, agent):\n", + " self.env = env\n", + " self.agent = agent\n", + " self.CAR_WIDTH = 20\n", + " self.CAR_HEIGHT = 10\n", + " self.SCREEN_WIDTH = 600\n", + " self.SCREEN_HEIGHT = 400\n", + " \n", + " self.FLAG_X = int((self.env.goal_position - self.env.min_position) / (self.env.max_position - self.env.min_position) * self.SCREEN_WIDTH)\n", + " self.FLAG_Y_BASE = self.SCREEN_HEIGHT // 3\n", + " self.FLAG_HEIGHT = 30\n", + " \n", + " def _init_render(self):\n", + " \"\"\"Initializes Pygame for rendering.\"\"\"\n", + " pygame.init()\n", + " self.screen = pygame.display.set_mode((self.SCREEN_WIDTH, self.SCREEN_HEIGHT))\n", + " pygame.display.set_caption(\"Mountain Car Environment\")\n", + "\n", + " self.clock = pygame.time.Clock()\n", + " try:\n", + " self.font = pygame.font.Font(None, 24) # Default font\n", + " except IOError:\n", + " print(\"Pygame font not found, using fallback.\")\n", + " self.font = pygame.font.SysFont(pygame.font.get_default_font(), 24) # Fallback\n", + "\n", + " def render(self, episode=None, step=None, total_reward=None, action=None):\n", + " \"\"\"Renders the current state using Pygame.\"\"\"\n", + " if self.screen is None:\n", + " self._init_render()\n", + "\n", + " # Handle quit events\n", + " for event in pygame.event.get():\n", + " if event.type == pygame.QUIT:\n", + " self.close()\n", + " return False # Indicate rendering should stop\n", + "\n", + " self.screen.fill((255, 255, 255)) # White background\n", + "\n", + " # Draw the track\n", + " track_points = []\n", + " for i in range(self.SCREEN_WIDTH):\n", + " pos = env.min_position + (env.max_position - env.min_position) * (i / self.SCREEN_WIDTH)\n", + " height = env._height(pos)\n", + " screen_y = self.SCREEN_HEIGHT - int(height * self.SCREEN_HEIGHT * 0.8) # Scale height\n", + " track_points.append((i, screen_y))\n", + " pygame.draw.lines(self.screen, (0, 0, 0), False, track_points, 2)\n", + "\n", + " # Draw the goal flag\n", + " flag_world_y = env._height(env.goal_position)\n", + " flag_screen_y = self.SCREEN_HEIGHT - int(flag_world_y * self.SCREEN_HEIGHT * 0.8)\n", + " pygame.draw.line(self.screen, (200, 0, 0), (self.FLAG_X, flag_screen_y), (self.FLAG_X, flag_screen_y - self.FLAG_HEIGHT), 3)\n", + " pygame.draw.polygon(self.screen, (200, 0, 0), [(self.FLAG_X, flag_screen_y - self.FLAG_HEIGHT),\n", + " (self.FLAG_X + 15, flag_screen_y - self.FLAG_HEIGHT + 5),\n", + " (self.FLAG_X, flag_screen_y - self.FLAG_HEIGHT + 10)])\n", + "\n", + " # Draw the car\n", + " car_pos_norm = (self.env.state[0] - self.env.min_position) / (self.env.max_position - self.env.min_position)\n", + " car_x = int(car_pos_norm * self.SCREEN_WIDTH)\n", + " car_world_y = env._height(self.env.state[0])\n", + " car_y = self.SCREEN_HEIGHT - int(car_world_y * self.SCREEN_HEIGHT * 0.8) # Position car on track\n", + "\n", + " # Simple rectangle for the car\n", + " car_rect = pygame.Rect(car_x - self.CAR_WIDTH // 2, \n", + " car_y - self.CAR_HEIGHT, \n", + " self.CAR_WIDTH,\n", + " self.CAR_HEIGHT)\n", + " pygame.draw.rect(self.screen, (0, 0, 200), car_rect) # Blue car\n", + "\n", + " # Display stats if available\n", + " if episode is not None and self.font:\n", + " stats_text = f\"Episode: {episode} | Step: {step} | Reward: {total_reward:.2f}\"\n", + " if not action is None:\n", + " stats_text += \" | Action: \"\n", + " if action == AgentAction.LEFT:\n", + " stats_text += \"L\"\n", + " else:\n", + " stats_text += \"R\"\n", + " text_surface = self.font.render(stats_text, True, (0, 0, 0))\n", + " self.screen.blit(text_surface, (10, 10))\n", + "\n", + " pygame.display.flip()\n", + " self.clock.tick(30) # Limit frame rate\n", + " return True # Indicate rendering succeeded\n", + "\n", + " def close(self):\n", + " \"\"\"Closes the Pygame window.\"\"\"\n", + " if self.screen is not None:\n", + " print(\"Closing Pygame window.\")\n", + " pygame.quit()\n", + " self.screen = None # Mark as closed" + ] + }, + { + "cell_type": "markdown", + "id": "76793d12", + "metadata": {}, + "source": [ + "# The Agent\n", + "\n", + "In the base class ``Agent``, we define some base functions:\n", + "\n", + "- those for discretising the continous-valued environment state into discrete bins so that we can feed it into the neural network as a \"one-hot\" encoding.\n", + "- the reward function $\\Phi$ (note that this is not yet the reward-shaped version that will be used in the spiking agent below).\n", + "\n", + "The state is a set S of agent observable states. An action is a set of possible actions A in a state S. Usually, the actions that an agent can do are the same in all states." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5707ac4a", + "metadata": {}, + "outputs": [], + "source": [ + "class AgentAction(enum.Enum):\n", + " LEFT = 0\n", + " RIGHT = 1\n", + "\n", + "class Agent:\n", + " \"\"\"\n", + " Base class for an agent controlling the mountain car.\n", + " \"\"\"\n", + " \n", + " def __init__(self, env, NUM_POS_BINS: int = 10, NUM_VEL_BINS: int = 10) -> None:\n", + " self.env = env\n", + " self.pos_bins = self._create_bins(self.env.min_position, self.env.max_position, NUM_POS_BINS)\n", + " self.vel_bins = self._create_bins(self.env.min_velocity, self.env.max_velocity, NUM_VEL_BINS)\n", + "\n", + " LEARNING_RATE = 0.1 # Alpha\n", + " DISCOUNT_FACTOR = 0.99 # Gamma\n", + " P_EXPLORE_START = 1. # exploration ratio\n", + " P_EXPLORE_END = 0. # was: 0.01\n", + " P_EXPLORE_DECAY = .993 # Decay factor per episode\n", + " LEARNING_RATE_DECAY = .998 # learning rate usually decays less fast than exploration probability\n", + "\n", + " self.MIN_LEARNING_RATE = 0.01\n", + "\n", + " self.learning_rate = LEARNING_RATE\n", + " self.discount_factor = DISCOUNT_FACTOR\n", + " self.learning_rate_decay = LEARNING_RATE_DECAY\n", + " self.p_explore = P_EXPLORE_START\n", + " self.p_explore_decay = P_EXPLORE_DECAY\n", + " self.p_explore_end = P_EXPLORE_END\n", + " self.POTENTIAL_SCALE_POS = 10.0 \n", + " self.NUM_POS_BINS = NUM_POS_BINS\n", + " self.NUM_VEL_BINS = NUM_VEL_BINS\n", + " \n", + " self.rng = random.Random() # Local random number generator\n", + "\n", + " def _create_bins(self, min_val, max_val, num_bins):\n", + " r\"\"\"Creates discretization bins.\"\"\"\n", + " if num_bins <= 1:\n", + " return [] # No bins needed if only 1\n", + "\n", + " bin_size = (max_val - min_val) / num_bins\n", + "\n", + " # Create thresholds between bins\n", + " return [min_val + i * bin_size for i in range(1, num_bins)]\n", + "\n", + " def _get_discrete_state(self, state):\n", + " \"\"\"Converts continuous state (pos, vel) to discrete state (pos_bin, vel_bin).\"\"\"\n", + " position, velocity = state\n", + "\n", + " def _find_bin(value, bins):\n", + " for i, threshold in enumerate(bins):\n", + " if value < threshold:\n", + " return i\n", + " return len(bins) # Return the last bin index if value >= last threshold\n", + "\n", + " pos_bin = _find_bin(position, self.pos_bins)\n", + " vel_bin = _find_bin(velocity, self.vel_bins)\n", + "\n", + " return (pos_bin, vel_bin)\n", + " \n", + " def failure_reset(self, state: Tuple[float,float,float,float]):\n", + " box = self.get_box(state)\n", + " self.current_box = self.boxes[box[0], box[1], box[2], box[3], :]\n", + "\n", + " def decay_learning_rate(self):\n", + " \"\"\"Decays the learning rate.\"\"\"\n", + " self.learning_rate = self.learning_rate * self.learning_rate_decay\n", + " if self.learning_rate < self.MIN_LEARNING_RATE:\n", + " self.learning_rate = 0.\n", + "\n", + " def decay_p_explore(self):\n", + " \"\"\"Decays the exploration rate.\"\"\"\n", + " self.p_explore = max(self.p_explore_end, self.p_explore * self.p_explore_decay)\n", + " if self.p_explore < .01:\n", + " self.p_explore = 0.\n", + "\n", + " def _potential(self, state):\n", + " \"\"\"\n", + " Calculates the potential function Phi(s) for reward shaping.\n", + " Higher potential should correlate with being closer to the goal state.\n", + " \"\"\"\n", + " position, velocity = state\n", + " height = self.env._height(position) # Use the environment's height function\n", + " potential_val = self.POTENTIAL_SCALE_POS * height\n", + " \n", + " return potential_val" + ] + }, + { + "cell_type": "markdown", + "id": "d88b12fc", + "metadata": {}, + "source": [ + "\n", + "\n", + "Show discretisation:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "40679ee6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAGwCAYAAACHJU4LAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB+m0lEQVR4nO2deVxVRePGH5DFHXE3wz13S3FLc8ul1HKr3mxXs8UyrTffXqtfpSmES6S5Lym4gxYqbhiiiLgihKAooqDgAi4IiCwi9/z+8OXCZZF7LjNn5syd7+dzP8rlLM/znLnD3DlzZmwURVEgkUgkEolEwiG2rAVIJBKJRCKRlIVsqEgkEolEIuEW2VCRSCQSiUTCLbKhIpFIJBKJhFtkQ0UikUgkEgm3yIaKRCKRSCQSbpENFYlEIpFIJNxix1pARTAYDLhx4wZq1KgBGxsb1nIkEqtEURTcv38fTz31FGxt9fHdR9YdEglb1NQbum6o3LhxAy4uLqxlSCQSAElJSXj66adZyzALWXdIJHxgTr2h64ZKjRo1AACBgYHo0aMHYzX0OHfuHDp06MBaBhVE9gaI7a/AW0ZGBlxcXIyfRz1QoDUpKQk1a9bU7LwilwetkVmSRes81dQbum6oFHTZ3rp1S9PKRmtSUlLQq1cv1jKoILI3QGx/xb3p6RZKgdaaNWtqWneIXB60RmZJFlZ5mlNv6OOGcjk4ODiwlkAVkf2J7A0Q25/I3mghMyOHzJIsPOcpREOlXr16rCVQpUGDBqwlUENkb4DY/kT2RguZGTlklmThOU8hGiqRkZGsJVAlPDyctQRqiOwNENufyN5oITMjh8ySLDznaaMoisJahKVkZGTAyckJcXFxaNWqFWs51EhJSeG6tVsRRPYGiO2vwFvB5zA9PV03Y8VYaRa5PGiNzJIsWuep5jMoRI+Kt7c3awlUWb16NWsJ1BDZGyC2P5G90UJmRg6ZJVl4zlOIHhU9fZOTSERDj59DPWqWSETC6npU5s2bx1oCVdzc3FhLoIbI3gCx/YnsjRYyM3LILMnCc55C9KgkJycLfa8yOzsbVapUYS2DCiJ7A8T2V+BNj70TrDSLXB60RmZJFq3ztLoelT/++IO1BKosW7aMtQRqiOwNENufyN5oITMjh8ySLDznKURDZfjw4awlUGXkyJGsJVBDZG+A2P5E9kYLmRk5ZJZk4TlPIRoqos+jEhERwVoCNUT2BojtT2RvtJCZkUNmSRae8xSioVK3bl3WEqgi8sy7InsDxPYnsjdayMzIIbMkC8956npRwgIcHR1ZS6CKyP5E9gbox9+jfAOSM3JKvF+rqgOqO5ZeTejFG0/IzMghsySLOXlm5OQhIzuv3O1sbGzQuBa5gblCNFQSEhJYS6DK5cuX8cILL7CWQQWRvQH68ff6iuM4k5RW4n33MR3xbs+mpe6jF288ITMjh8ySLOXlefZ6Ol5bdgwP8w3lHqu6ox3O/vwyMW1CNFT69OnDWgJVBgwYwFoCNUT2BujHX0EjxcHOFkUXXa/0hCXY9eKNJ2Rm5JBZkqW8PGNuZuBhvgE2NoBDpSePGnG0IzuqRIgxKj4+PqwlUGXDhg2sJVBDZG+APvwVnUrp+LcDEes2zPh6q0eTMvfTgzfekJmRQ2ZJlnLz/F818WKb+iZ1RGmv8B+HENUmxIRv9+7dQ61atVjLoYbBYICtrRBtyhKI7A3Qhz+DQUGL7/cCACJ+HILa1RzM3O+xNznhm/nooTzoBZklWcrL0zcsEdP/isagtvWxZnz3Cp/P6iZ8+/XXX1lLoMovv/zCWgI1RPYG6MOfoch3Fduy7/SUQA/eeENmRg6ZJVnKy9Pwv2rC5gm3g2khe1R0gMjfHET2BujDX16+Ac/83z4AwJmfXoJTVXuz9pM9KurRQ3nQCzJLspSX5+aTifh+ezSGtG+A1R90q/D5rK5HxdPTk7UEqnh4eLCWQA2RvQH68Fe0R8VGRY2gB2+8ITMjh8ySLOXlWVBPqOl1JYUQDZW33nqLtQSqvP/++6wlUENkb4A+/BXtU1VTB+nBG2/IzMghsyRLeXkWVBM2qmoJMgjRUAkNDWUtgSrBwcGsJVBDZG+A/vypuf+sN288IDMjh8ySLOXm+b9vNAyGqIjRUGnevDlrCVRp2bIlawnUENkboA9/lg6m1YM33pCZkUNmSZby8iwYTGvLoKUiREMlNzeXtQSqiOxPZG+APvyZ3voxvxLSgzfekJmRQ2ZJlvLyND53I3tULOPOnTusJVDl9u3brCVQQ2RvgD78mQymVVEJ6cEbb8jMyCGzJEt5ecoelQrSuXNn1hKo4urqyloCNUT2BujDX9H5CdTUQXrwxhsyM3LILMlSXp6Fg2m1R4iGyt69e1lLoIq/vz9rCdQQ2RugD3+W3vrRgzfekJmRQ2ZJlvLyVBgOphViwrfk5GQ0aNCAtRxqZGdno0oVcktm84TI3gB9+EvLeojOswIBAJfch8GunAXHCijwJid8Mx89lAe9ILMkS3l5rg6Jh/ve8xjTpTEWjO1c4fNZ3YRvixcvZi2BKiJPaCeyN0Af/kx6VFR8XdKDN96QmZFDZkmW8vJU/nfzh8WtHyF6VPT0TU4i4Y27mbno6nYAAJDgMVz1Wh56/BzqUbNEwpIVhy9jzr4LeN31aXi++VyFj2d1PSrz5s1jLYEqbm5urCVQQ2RvgD78mQ6mNb+RogdvvCEzI4fMkizl5Wl8Olk+nmwZ48ePZy2BKh9//DFrCdQQ2RugD38GCztV9eCNN2Rm5JBZkqW8PAvqCfnUj4Xs2bOHtQSq7Ny5k7UEaojsDdCJP+P8COp204U3zpCZkUNmSRZz85TzqFiI6POodO3albUEaojsDdCHP+P8CCorID144w2ZGTlklmQpL0+WjycL0VARfYbClJQU1hKoIbI3QB/+LF2+XQ/eeENmRg6ZJVnKy9NgHKMie1Qs4uHDh6wlUEVkfyJ7A/Thr3AJD3UVkB688YbMjBwyS7KUl6ccTFtB5OrJ+kVkb4A+/BksXGxMD954Q2ZGDpklWcpfPVkOpq0QoaGhrCVQ5fDhw6wlUENkb4A+/CkWDqbVgzfekJmRQ2ZJlvLyLBjLJgfTWsjYsWNZS6DKe++9x1oCNUT2BujLn9pbP3ryxgsyM3LILMlSbp5yMG3FWLVqFWsJVFmyZAlrCdQQ2RugD3+WDqbVgzfekJmRQ2ZJlvLyNBh7XrVvqcgp9CUSK+fKnQcY8Gswqjva4ezPL6veX4+fQz1qlkhYMn//BSw9dBnjezfDzJEdKnw8OYW+YIg8VbTI3gB9+LN0kJwevPGGzIwcMkuylJenQT71UzE+/fRT1hKoMmXKFNYSqCGyN0Af/gonfFO3nx688YbMjBwyS7KUl6fC8NaPEA2VLVu2sJZAlfXr17OWQA2RvQH68KdYOJGTHrzxhsyMHDJLspSXpwL5eHKF6NevH2sJVHnxxRdZS6CGyN4AffhTLBxMqwdvvCEzI4fMkizl5WnsUVFbURBAiIbK5cuXWUugSlxcHGsJ1BDZG6APf5au9aMHb7whMyOHzJIs5eWpyAnfKkblypVZS6BKlSpVWEughsjeAH34s/TxZD144w2ZGTlklmQpL0+51k8FqV27NmsJVKlTpw5rCdQQ2RugD3+FExSoq4D04I03ZGbkkFmSpbw8rXatn/z8fPz4449o3rw5qlSpgpYtW2L27NlQO7VLdHQ0JYV8EBkZyVoCNUT2BujDn6UVECtvpOoNFuihPOgFmSVZysuT5WBaOwbnNDJ37lwsX74c69atQ4cOHXD69GlMmDABTk5OmDp1qtnHGTZsGEWV7BkxYgRrCdQQ2RugD3+W3vph5Y1UvcECPZQHvSCzJEt5ebJ8PJlpQ+XYsWMYNWoUXnnlFQBAs2bNsGXLFpw6darU7XNzc5Gbm2v8OSMjAwCwbt06oSf/+eOPP/DDDz+wlkEFkb0B5PwZDAqm/xWFi7cyCagyJfvhIwDq1/phde3U1htA2XWH1ohe3rVEZlmSmBsZcNsTgwcP81Xve+P6dTzVuHGZv79+LwuAFd766d27N4KCgnDx4kUAwJkzZxAaGlpmD4mHhwecnJyMLxcXFwDAG2+8gXnz5iE3N9fYYHFzc8ONGzewZs0ahIWFYf/+/fDz80NMTAwWLVqEjIwMk21TU1OxdOlSREVFwd/fH3v27EFERARWrlyJ27dvm2yblZUFT09PxMbGYuvWrQgKCsKxY8fg7e2NpKQkk23z8/Ph4eGBq1evYsOGDQgNDUVwcDB8fHwQFxeH+fPnIycnx2Sf5ORkrF69GmFhYQgICECHDh1w9uxZLF68GOnp6SbbpqWlYcmSJYiOjsaOHTuwd+9ehIeHY9WqVUhJSTHZNjs7G56enoiLi4Ovry8OHjyIo0ePYv369UhMTIS7uzsMBgPc3NxgMBjg7u6OxMRErF+/HkePHsXBgwfh6+uLuLg4eHp6Ijs72+T4KSkpWLVqFcLDw7F3717s2LED0dHRWLJkCdLS0ky2TU9Px+LFizF69Ghs374dAQEBCAsLw+rVq5GcnGyybU5ODubPn4+4uDj4+PggODgYoaGh2LBhA65evQoPDw/k5+eb7JOUlARvb28cO3YMQUFB2Lp1K2JjY+Hp6YmsrCyTbW/fvo2VK1ciIiICe/bsgb+/P6KiorB06VKkpqaabJuRkYFFixYhJiYGfn5+2L9/P8LCwrBmzRrcuHHDZNvc3Fw4ODjg8uXL2LJlC4KDg3HkyBFs3LgRV65cwZw5c/Do0SOTfa5duwYvLy+cOHECgYGB2LZtGy5cuICfPJdhW/g1nElKI/66mPK48dOoVmW4ubkhLy8Pc+fORXx8PDZt2oSQkBCEhIRg06ZNiI+Px9y5c5GXl2f8XGo9M7TaegMou+6Ij4/XtO74+uuvNa07tm/fLusOndYd8+bNU113zN4QgGOX71pUD9w2VHvi7+9kPgQA3LuegJMnT2Lt2rUldJtbd6jtWGC61o/BYMD333+PefPmoVKlSsjPz4e7uzu+++67Urcv7VuRi4sL/u///k/oHhU3NzdhvzmI7A0g5+/cjXS8sigUNSvbYcHYzhUXVgwbG6Brk9pwqmpv9j4F3rReN0dtvQGUXXdovdaP6OVdS2SWJfl51zl4Hb2CVzo1wmuuZfeOlIavry/Gjh37xG2qO9qhe7PaROZSUVVvKAzZsmWL8vTTTytbtmxRoqKilPXr1yu1a9dWvL29zdo/PT1dAaCkpKRQVsqW7Oxs1hKoIbI3RSHnL/pamtJ0+m6lh3sgkeORoMBbwecwPT1dk/NWtN5QFO01FyB6edcSmWVJZuw8qzSdvluZH3BB9b5a56nmM8j01s8333yDb7/9Fm+99RY6deqE999/H//+97/h4eGh6jgrV66kpJAPFi9ezFoCNUT2BpD3p3YcCU1YXTtS9QYLRC/vWiKzLBtLxpHwnCfThkpWVhZsbU0lVKpUCQaDQdVxXn31VZKyuGP06NGsJVBDZG8AOX+WPplDE1bXjlS9wQLRy7uWyCxLYlwJ3YKWCs95Mm2ojBgxAu7u7tizZw+uXLmC7du347fffsOYMWNUHeeff/6hpJAPwsPDWUughsjeAHL+LF04kCasrh2peoMFopd3LZFZlsRYT1iwL895Mn08efHixfjxxx/x+eef49atW3jqqafw6aef4qefflJ1nAYNGlBSyAcNGzZkLYEaInsDyPkr/KZE5HBEYHXtSNUbLBC9vGuJzLIkhT2v6isKnvNk2lCpUaMGFi5ciIULF1boOHZ2TG1QR2R/InsDyPkrXDiQyOGIwOrakao3WCB6edcSmWVJKlJP8JynEGv9XL16lbUEqiQkJLCWQA2RvQHk/BV26fLTUhH92tFAZkYOmWVJlAqscMxznkI0VHr37s1aAlX69evHWgI1RPYGkPOncDiYVvRrRwOZGTlkliUxTnNvQUXBc55CNFS2bdvGWgJVNm/ezFoCNUT2BpDzV9ily09LRfRrRwOZGTlkliWpyPStPOfJdGbailIws11qaiqcnZ1Zy6FGfn4+KlWqxFoGFUT2BpDzdzL+LsauOoEW9arh4LQBFRdGgAJvWs9MSwJWmkUv71oisyzJN9vOYFv4NUwf2hafDWipal+t81TzGRSiR8XT05O1BKroYSIrSxHZG0DOn7FHhcjRyCD6taOBzIwcMsuSVGQwLc95CtGjoqdvchKJJRy/fBdvrz6BVvWr48DX/VnLMUGPn0M9apZIyuPrrZHwi7iO74a1xaf91fWoaI3V9ahovXqr1oi+4KLIkPLH42Ba0a8dDWRm5JBZlkLBYFoLulR4zlOIhso777zDWgJVxo0bx1oCNUT2BpDzV3jrh5+WiujXjgYyM3LILEtSkYkhec5TiIbK4cOHWUugSlBQEGsJ1BDZG0DOH48z04p+7WggMyOHzLIkFXk6kOc8hWiotGrVirUEqrRu3Zq1BGqI7A0g54/HtX5Ev3Y0kJmRQ2ZZkoqs9cNznkI0VLKzs1lLoIrI/kT2BpDzx+NTP6JfOxrIzMghsyxJRXpeec5TiIZKamoqawlUuXv3LmsJ1BDZG0DOn3GxMY4+saJfOxrIzMghsyxJwRcaSwbT8pwnR9We5XTq1Im1BKo899xzrCVQQ2RvAEF/HK71I/q1o4HMjBwyy5IoFehR4TlPIRoqAQEBrCVQZffu3awlUENkbwA5fwYOH08W/drRQGZGDpllSSoylo3nPIVoqEycOJG1BKp89tlnrCVQQ2RvADl/SuFwfiLHI4Ho144GMjNyyCxLYqjA6sk85ylEQ2XJkiWsJVDlt99+Yy2BGiJ7A8j543EwrejXjgYyM3LILEtS2KOifl+e85RT6EskOmD/uWR8uiEcrk1qwe/zF1jLMUGPn0M9apZIyuOjdadx4HwKPF7rhLd7NGEt54nIKfQFg+epjSuKyN4AklPoP/6Xp3lURL92NJCZkUNmWRqW3/rhOU8hGioffvghawlU+fTTT1lLoIbI3gBy/nhc60f0a0cDmRk5ZJYlKfhCY8njyTznKURDxd/fn7UEqvj5+bGWQA2RvQHk/PG41o/o144GMjNyyCxLYqjA1LQ85ylEQ8XV1ZW1BKp0796dtQRqiOwNIOdP4XA0rejXjgYyM3LILEtSkWqC5zyFaKikpKSwlkCVmzdvspZADZG9AeT88TiPiujXjgYyM3LILEtiqMCtH57zFKKhkp+fz1oCVUT2J7I3gJw/Hm/9iH7taCAzI4fMsiQVmZmW5zyFaKg0acL3Y1gVpVmzZqwlUENkbwA5fwqHa/2Ifu1oIDMjh8yyJBUZTMtznhxVe5Zz7Ngx1hKocuTIEdYSqCGyN4CcP4XDtX5Ev3Y0kJmRQ2ZZEgWW96jwnKcQDZU33niDtQSqvP3226wlUENkbwA5fxVZvp0Wol87GsjMyCGzLElFpm/lOU8hGip//PEHawlUWbZsGWsJ1BDZG0DOH48Tvol+7WggMyOHzLIkhYPu1dcTPOcpp9CXSHTAn+HX8J9tZ9C/dT2s+7AHazkm6PFzqEfNEkl5jF15HCcTUrHknS549dmnWMt5Imo+g3YaaaLKvHnzuJ7+t6K4ubnhhx9+YC2DCiJ5y8jJg3/kDWQ9fGR878CBIAwePKjCxz5zLR0AX48ni3TttEJmRg69ZhlzIwOhl25TOfaN9GwAlvWo8JynED0qSUlJePrpp1nLoUZGRoaw3/pE8rbwwEUsPBBH9RzDOjbE8ve6Uj2HuRRcOz32TrDSLFJ5Z41es3xhzkFcT8umeo6147thYNsGqvbROk+r61HZvHkz/vvf/7KWQQ1vb29MnTqVtQwqiOQtLSsPANC2YQ20f+rxB+/C+Qto264tkeM7VLLF+72aEjkWCUS6dlohMyOHXrNMy3oIAHi5QwNUcyT/J7hBzcro3bKu6v14zlOIhsqAAQNYS6DK4MGDWUughkjeCjonh7RvgGkvtQEAxMQ4oH379ixlUUOka6cVMjNy6DXLglsY/ze8PZrUqcpUS1F4zlOIp34uXrzIWgJVLly4wFoCNUTyZijlyRyR/BVHZG+0kJmRQ69Z8jjVAMB3nkI0VKpW5adVSoNq1aqxlkANkbwZJ1sq8p5I/oojsjdayMzIodcsC6caYKujODznKURDxdnZmbUEqtSuXZu1BGqI5K20BcFE8lcckb3RQmZGDr1mWZFp7mnCc55CNFTOnTvHWgJVoqKiWEughkjeSvumJJK/4ojsjRYyM3LoNcuKTHNPE57zFKKhMmTIENYSqDJs2DDWEqghkjfjyqVF3hPJX3FE9kYLmRk59JqlgcN1uwC+8xSiobJhwwbWEqiydu1a1hKoIZI3Y5dukVnZRPJXHJG90UJmRg69ZmlcCZ2vdgrXeQox4ZueJpqSiMt//zyDraev4ZuX22Dyi61Yy9EMPX4O9ahZIgbNv9sDRQFO/d8g1K9RmbUcZqj5DArRozJv3jzWEqgi+vIAolDaYFqR/BVHZG+0kJmRQ69Z8jqYluc8hehRuXXrFurVq8daDjVyc3Ph6OjIWgYVRPI2besZ/BVxDd8Oa4tJ/VsCEMtfcQq86bF3gpVmkcuD1ugxS0VR0Py7vQCA8B8Go051fvRrnafV9agsX76ctQSq/P7776wlUEMkb6UNphXJX3FE9kYLmRk59JiloUi3gA1nPSo85ylEQ2XkyJGsJVDl9ddfZy2BGiJ5K6iDinbpiuSvOCJ7o4XMjBx6zLLoDQzeBtPynKcQDZXw8HDWEqhy6tQp1hKoIZI3pZSpsUXyVxyRvdFCZkYOPWZZdJwFb48n85ynEA2Vhg0bspZAlUaNGrGWQA2RvJW21o9I/oojsjdayMzIoccsDUV6VGw4++vLc56cRWUZlSpVYi2BKiL7E8lbQRVU9HuSSP6KI7I3WsjMyKHHLIs+usJXfwrfeQrRUElKSmItgSpXr15lLYEaInkzlDKRk0j+iiOyN1rIzMihxyyLNlR4ezyZ5zyFaKg8//zzrCVQpU+fPqwlUEMob6Xc+hHKXzFE9kYLmRk59JilUmSUCmftFK7zFKKh8tdff7GWQBUfHx/WEqghkrfSFhsTyV9xRPZGC5kZOfSYpemtH75aKjznKcSEb3fv3uV6ieqK8ujRI9jZ2bGWQQWRvE3aEI6Ac8mYPboj3n++KQCx/BWnwJuc8M18RC4PWqPHLO/n5KHTzL8BABdmD0Vle37GhWidp9VN+Pbbb7+xlkCVOXPmsJZADZG8GXtUirwnkr/iiOyNFjIzcugxS5PHk/nqUOE6TyF6VPT0TU4iLh+vP43AmBT8MqYT3unZhLUczdDj51CPmiX6Jz0rD8/NetyjEuc+DPaVhOgrsAir61GRixLqF5G8KcbBtIXvieSvOCJ7o4XMjBx6zNJkMC1DHaXBc55CNFTeffdd1hKoMn78eNYSqCGWt5K3fsTyZ4rI3mghMyOHHrNUOF7rh+c8hWioHDp0iLUEqgQGBrKWQA2RvBlKWb5dJH/FEdkbLWRm5NBjlgaO1/rhOU8hGipt2rRhLYEq7dq1Yy2BGiJ5Mw73KlIBieSvOCJ7o4XMjBx6zNJ0MC1fLRWe8xSioXL//n3WEqgisj+RvJXWoyKSv+KI7I0WMjNy6DFLQykLl/ICz3kK0VBJT09nLYEqaWlprCVQQyRvpa31I5K/4ojsjRYyM3LoMsuSna7cwHOeQjRUOnTowFoCVTp16sRaAjVE8qaU8m1JJH/FEdkbLWRm5NBjlsYvMxx2qfCcpxANFZ4HAZFg3759rCVQQyRvSim3fkTyVxyRvdFCZkYOPWZZ2sKlvMBznkI0VMaNG8daAlU+/vhj1hKoIZK30tb6EclfcUT2RguZGTn0mGXheHv+Wio85ylEQ2XZsmWsJVBl4cKFrCVQQyRvBsPjf4t264rkrzgie6OFzIwcesyS58G0POcpp9CXSAjx1qrjOBGfisVvd8GI555iLUcz9Pg51KNmif5JSs1C33mHUNneFhdmD2Mthym6mkL/+vXreO+991CnTh1UqVIFnTp1wunTp1UdQ06hr19E8ian0LecrKwsVduTqDdYIHJ50Bo9Z8njrR+e81TdUHnSLLArV65Udax79+7hhRdegL29Pfbt24eYmBh4enrC2dlZ1XEmTpyoanu9MWnSJNYSqCGSt9IG04rkrzhqvQ0aNAjXr18v8f6pU6fQuXNns49Dqt5ggcjlQWv0mCXPg2l5zlN1Q2Xo0KH45ptvkJeXZ3zvzp07GDFiBL799ltVx5o7dy5cXFzg5eWFHj16oHnz5njppZfQsmVLVcfZsWOHqu31xp9//slaAjVYeEtOz8G1e1nEX7mP8gGYzpEgr10hlStXxrPPPgtfX18AgMFgwMyZM9GnTx8MHz7c7OOQqjdYIHJ50BqaWebk5VOpI26m5wDg8/FknsumndodDh06hA8++ACBgYHYvHkzEhISMHHiRLRp0waRkZGqjuXv74+XX34Z//rXv3D48GE0btwYn3/+eZmjj3Nzc5Gbm2v8OSMjAwDQvXt3tTZ0xfPPP89aAjW09uax9zxWhsRTPUfROkheu0L27NmDpUuX4sMPP8TOnTtx5coVXL16Fbt378ZLL71k9nHU1htA2XWH1ohcHrSGVpY5efl48ddgY6OCBvw1U/gum6p7VHr37o3IyEh07NgRrq6uGDNmDP79738jODgYTZs2VXWs+Ph4LF++HM888wz279+Pzz77DFOnTsW6detK3d7DwwNOTk7Gl4uLCwAgIiIC8+bNQ25urvE+m5ubG27cuIE1a9YgLCwM+/fvh5+fH2JiYrBo0SJkZGSYbJuamoqlS5ciKioK/v7+2LNnDyIiIrBy5Urcvn3bZNusrCx4enoiNjYWW7duRVBQEI4dOwZvb28kJSWZbJufnw8PDw9cvXoVGzZsQGhoKIKDg+Hj44O4uDjMnz8fOTk5JvskJydj9erVCAsLQ0BAALZt24azZ89i8eLFSE9PN9k2LS0NS5YsQXR0NHbs2IG9e/ciPDwcq1atQkpKism22dnZ8PT0RFxcHHx9fXHw4EEcPXoU69evR2JiItzd3WEwGODm5gaDwQB3d3ckJiZi/fr1OHr0KA4ePAhfX1/ExcXB09MT2dnZJsdPSUnBqlWrEB4ejr1792LHjh2Ijo7GkiVLkJaWZrJteno6Fi9ejKNHj2L79u0ICAhAWFgYVq9ejeTkZJNtc3JyMH/+fMTFxcHHxwfBwcEIDQ3Fhg0bcPXqVXh4eCA/P99kn6SkJHh7e+PYsWMICgrC1q1bERsbi13HzwIAbGGAo50tKsEARzsb2NkocKgE2NsC9rYKHCrZwM7m8e8qmWz7+N/Hv1f+tz3+t78NatrkwLWJM9zc3JCbm4vff/8dly9fxpYtWxAcHIwjR45g48aNuHLlCubMmYNHjx6Z6L527Rq8vLxw4sQJBAYGYtu2bbhw4QIWLFiAzMxMk23v3LmDFStWIDIyErt378auXbsQGRmJ5cuX4+7duybb3r9/HwsXLkRMTAz++usv/P333zh58iTWrl2LGzdumGybl5eHuXPnIj4+Hps2bUJISAhCQkKwadMmxMfHY+7cucjLy4OnpycAdWPEJk+ejKlTp8LHxwenT5/Gtm3bVDVSAPX1BlB23REfH69p3XHp0iVN647t27fLukNl3XEmNsHYSCn62S6tHrC07ujklIv9+/cjLCwMa9asKfEZzM3Nxbx58zStO0JCQjSrO1SPh1EsIDw8XGnTpo3SsmVLpUqVKsqECROUzMxM1cext7dXevXqZfLelClTlOeff77U7XNycpT09HTjKykpSQGg+Pj4WGJDN/j7+7OWQA2tvf1r+TGl6fTdyp6oG5qczxquXXp6ugJASU9Pf+L2qampymuvvaY4OTkpq1atUt59912lWrVqytKlS1WdV229oShl1x3laSaNyOVBa2hleeVOptJ0+m6l/Y/7qByfV7Qum+bWG4qiKKp7VObMmYNevXphyJAhOHv2LE6dOoV//vkHzz77LI4fP67qWI0aNUL79u1N3mvXrh0SExNL3d7R0RE1a9Y0eQFA48aN1drQFQXf/kREa2/GSdk0Op+8doV07NgRKSkp+Oeff/Dxxx9j48aNWLNmDX788Ue88sorZh9Hbb0BlF13aI3I5UFraGVZ+PQejzdo6MFz2VTdUPn999+xY8cOLF68GJUrV0bHjh1x6tQpvPbaaxgwYICqY73wwguIjY01ee/ixYuqbyGdOnVK1fZ6Q20DUE9o7c2gcSUkr10hkyZNQkhICJo3b258b+zYsThz5gwePnxo9nFI1RssELk8aA2tLHmelI0mXJdNtd01t2/fLvN3wcHBqo516tQpxc7OTnF3d1fi4uKUTZs2KVWrVlU2btxo1v4FXUcJCQmqzqs37ty5w1oCNbT2NmZpqNJ0+m4l4OxNTc5nDddOTRduAdnZ2Raft6L1hqJYppkEIpcHraGV5aVb95Wm03crnWYEUDk+r2hdNqne+qlbty7S0tLwxx9/4LvvvkNqaiqAxwNaW7VqpepY3bt3x/bt27FlyxZ07NgRs2fPxsKFC/Huu++qOs4ff/yhanu9sXz5ctYSqKG1N0Mpc53QRF67QgwGA2bPno3GjRujevXqiI9//PTVjz/+iDVr1ph9HFL1BgtELg9aQytLpWCuEx4nO6EIz2VT9RT6UVFRGDx4MJycnHDlyhXExsaiRYsW+OGHH4yjvLVCToMtUcuopUdxJikNf3zQDYPbN2AtRwjM/RzOmjUL69atw6xZs/Dxxx/j7NmzaNGiBXx9fbFw4UJNu55l3SEpi7iU+xiyIATOVe3xz0/qnkiTmA/VKfT//e9/Y/z48YiLi0PlypWN7w8fPhwhISHq1RJATqGvXzT3pvH9Z3ntClm/fj1WrVqFd999F5UqVTK+/9xzz+HChQuk5XGJyOVBa2hlWfDN3doG0/JcNlVP+Hb69GmsWrWqxPuNGzdGcnIyEVFq+eyzz5icVyu+/PJL1hKoobU3rW/9yGtXyPXr10u9PWwwGExmuhYZkcuD1tDKkudp7mnCc9lU3aPi6OhY6qyOFy9eRL169YiIUsuGDRuYnFcr1Ny/1xtaeyt4PFmr55PltSukffv2OHLkSIn3//zzT3Tp0oWULK4RuTxoDa0sCwdDWFdLheeyqbpHZeTIkZg1axa2bt0K4HH3WGJiIqZPn47XX3+duEBzGDhwIJPzaoXamTv1hNbeDIbH/2rVoyKvXSE//fQTxo0bh+vXr8NgMMDPzw+xsbFYv349du/eTUklX4hcHrSGVpbW2qPCc9lU3aPi6emJzMxM1K9fH9nZ2ejfvz9atWqFGjVqwN3dnYbGcik+p4JonD9/nrUEamjtzXj/WaPzyWtXyKhRo7Br1y4cOHAA1apVw08//YTz589j165dGDJkCCWVfCFyedAaWlkWTvhG5fDcwnPZVN2j4uTkhMDAQISGhiIqKgqZmZlwdXXF4MGDaegzi+rVqzM7txbUqFGDtQRqaO1N0Xgwrbx2pvTt2xeBgYEU1OgDkcuD1tDO0sbKbv3wXDZVN1QK6NOnD/r06UNSi8U4OTmxlkAVkf1p7U3ReDCtvHaSosjMyEErS2u99cNz2TSrobJo0SKzDzh16lSLxVjK+fPnhR6ncu7cOfTs2ZO1DCpo7U3rtX6s/do5Ozub/ZhnweSRIiNyedAaWlla61o/PJdNsxoqCxYsMPn59u3byMrKQq1atQAAaWlpqFq1KurXr8+kocLytpMWDB06lLUEamjtTeu1fqz92i1cuND4/4Ll419++WX06tULwOP1Rfbv348ff/yRlkyuELk8aA2tLK11rR+ey6ZZg2kTEhKML3d3d3Tu3Bnnz59HamoqUlNTcf78ebi6umL27Nm09ZaK6I8nr127lrUEamjtTesxKtZ+7caNG2d8HT16FLNmzcKWLVswdepUTJ06FVu2bMGsWbNw+PBhDRSzR+TyoDW0siyc8I3K4bmF57Kpegr9li1bljrvQXh4ON544w0kJCQQFfgk5DTYErUM/DUY8XcewPeT59GzRR3WcoTA3M9h9erVERkZWWLSt0uXLqFz587IzMykLdWIrDskZRF+NRWvLz+OJrWrIuS/L7KWIyxUp9C/efMmHj16VOL9/Px8pKSkqD0cEeQU+vpFa28FrXKtFhyT166QOnXqYOfOnSXe37lzJ+rUsY5Go8jlQWuoTaFvHHBP5fDcwnPZVN2jMmLECFy/fh1//PEHXF1dATzuTfnkk0/QuHFj+Pv7UxFaGgUtsjt37ghd0eXl5cHe3p61DCpo7W3A/EO4cjcLf07qhW7NalM/nzVcO3O/GXl7e+Ojjz7CsGHDjIP2Tp48iYCAAKxevRrjx4/XSDm7HhWRy4PW0Moy7Eoq/rXiOJrXrYZD/xlA/Pi8onXZpNqjsnbtWjRs2BDdunWDo6MjHB0d0aNHDzRo0AB//PGHxaIrwpIlS5icVyt+++031hKoobU3rQfTymtXyPjx43H06FHUrFkTfn5+8PPzQ82aNREaGqppI4UlIpcHraGVpcFgnYNpeS6bqudRqVevHvbu3YuLFy8aVzxt27YtWrduTVycuYwePZrZubXgX//6F2sJ1NDam/HxZI0qIXntTOnZsyc2bdpEQY0+ELk8aA2tLLWevZoXeC6bFk/41rp1a6aNk6KcOnUKzz33HGsZ1Dh+/DhatGjBWgYVtPZWsNaPVpWQvHamGAwGXLp0Cbdu3YKh4GL8j379+pGUxyUilwetoZVl4ePJ1tVU4blsqm6o5Ofnw9vbG0FBQaVWNgcPHiQmzlyefvppzc+pJS4uLqwlUIOVN61mppXXrpATJ07gnXfewdWrV1F8aJyNjQ3y8/NJyuMSkcuD1lDL0koH0/JcNlU3VL788kt4e3vjlVdeQceOHa2u1SnRN1rPoyIpZNKkSejWrRv27NmDRo0aybpDwiWFt35k+eQF1Q0VHx8fbN26FcOHD6ehxyKuXbvGWgJVkpKSWEughtbeDBqv9SOvXSFxcXH4888/S8yjYk2IXB60hlaW1jozLc9lU/VTPw4ODtxVND169GAtgSoF042LiNbeFKh6Gr/CyGtXSM+ePXHp0iVKavSByOVBa2hlaa1r/fBcNlU3VKZNm4bff/+9xD1mluzYsYO1BKps27aNtQRqaO2t8PFkbc4nr10hU6ZMwbRp0+Dt7Y3w8HBERUWZvKwBkcuD1tDK0tijQuXo/MJz2VQ94duYMWNw6NAh1K5dGx06dCgxQYyfnx9RgU9CTvimf7T21s3tAO5k5mLfl33RrhH9ib6s4dqZO3GTrW3J70U2NjZQFEXzwbRywjf9QyvLQ7G3MMErDB0b18TuKX2JH59XhJrwrVatWhgzZgz69++PunXrwsnJyeTFguKrO4vG3LlzWUughvbetL3/LK9dIUUXNy14xcfHG/+1BkQuD1pDLcuCXlcr61PhuWyq7lHhCbmwmEQtrrMDkfrgIf7+dz+0blCDtRwh0OPnUI+aJdoQdD4FE9edxnNPO2HnF31YyxEWqj0qPCIXJdQvmi9KqPH9Z2u/dv7+/sjLyzP+/0kva0Dk8qA1tBcltLbHfngum2Y9nuzq6oqgoCA4OzujS5cuTxwNHRERQUycubz//vuan1NLPvzwQ9YSqKG1N63X+rH2azd69GgkJyejfv36T1zqwlomfBO5PGgNrSwLBtNa24RvPJdNs3pURo0aBUdHRwCPK55Ro0aV+WLBgQMHmJxXKwICAlhLoIbW3rSe8M3ar53BYED9+vWN/y/rZQ2NFEDs8qA1tLK01rV+eC6bZvWozJgxo9T/80K7du1YS6BKhw4dWEughtbetK6E5LWTFEVmRg5aWVrrPCo8l00hxqikp6ezlkAVkf1p7U3ReGZaee0kRZGZkYNWloqV3vrhuWxavHoyT2RmZrKWQJX79++zlkCN4t4URcEPO87i7I0MKufLevgIgHa3fqzp2knKR2ZGhku37mP+6RwsjTtK/NjpWQ8BWN/jyTyXTSEaKm3atGEtgSoi39oq7u3avWxsOplI9ZyOdrZwruZA9RwFWNO1k5SPzIwM/mduIi6jEpCRRu0cT9WqTO3YPMJz2RSioXLw4EGh1/v5+++/0b59e9YyqFDcW16+AQBQ2d4WS99xpXLOVvWro2ZlbWZgtKZrJykfmRkZHv2vnhjcrgHe7uFC/PiVbG3Qs7m4s52XBs9lU4iGiuiPJ0+cOJG1BGoU91Yw2NWhki0GtWugvSDCWNO1MweDwYBLly7h1q1bMBgMJr/r168fKWncInJ50JKCeqJpnapC1BM8wHPZVD2YNj8/H2vWrME777yDwYMHY+DAgSYvFixfvpzJebXi999/Zy2BGsW9iTbi3pquXXmcOHECrVq1Qrt27dCvXz8MGDDA+HrxxRcpqeQLkcuDlhjrCbYyhILnsql6Cv0vvvgC3t7eeOWVV9CoUaMSf1C0XHdHToMtHnEp9zFkQQicq9rjn59eYi1HYgbmfg47d+6M1q1b4+effy617tByrTBZd+gbj73nsTIkHp/0a4Hvh/M7tkJSNlSn0Pfx8cHWrVvh6+uLhQsXYsGCBSYvFsgp9PVLcW+Fs1eL8V3Jmq5decTFxeGXX35Bu3btUKtWLS4WNNUakcuDlljrpGw04blsqm6oODg4oFWrVjS0WMxHH33EWgJVPvvsM9YSqFHcm2jTV1vTtSuPnj174tKlS5TU6AORy4OWGAwFM0wLUlFwAM9lU3VDZdq0afj999/B06LLfn5+rCVQZevWrawlUKO4t8JiJUYFZE3XrjymTJmCadOmwdvbG+Hh4YiKijJ5WQMilwctsdJ1A6nCc9lU/dRPaGgoDh06hH379qFDhw6wtzd9zJNFo0HkR5MBoFevXqwlUKO4t8LBtAzEUMCarl15vP766wBMFz+zsbGBoihWsyihyOVBSwwar4JuDfBcNlU3VGrVqoUxY8bQ0GIx169fZy2BKklJSejcuTNrGVQo7k20Wz/WdO3KIyEhgZ4YnSByedASrZfCsAZ4LpuqGypeXl40dFQI0e9TiuyvLG+iTF9tjdeuLJo2bUpJiX4QuTywQMZJDp7LphATvj311FOsJVDl6aefZi2BGsW9idajYk3XrjT8/f0xbNgw2Nvbw9/f/4nbjhw5kpQ0bhG5PGiJ8dYPx39c9QbPZdOshoqrqyuCgoLg7OyMLl26PLFwREREEBNnLmFhYejTp4/m59WKEydOcNslV1GKexNtwjdrunalMXr0aCQnJ6N+/foYPXp0mdtZyxgVkcuDlsgJ38jDc9k0q6EyatQoODo6AsATKxtW8KiJJG+88QZrCdQo7o2fZ8nIYE3XrjSKTpNffMp8a0Tk8qAlhT0qjIUIBM9l06yGyowZM0r9Py+sWbOG68lqKsqKFSvwww8/sJZBheLejLd+VD84zyfWdO0k5SMzI0PBFxo5mJYcPJdN1VPoF3D69GmcP38eANC+fXt07dqVqDBzkNNgi0f41Xt4ffkxNKldFSH/tY71X/SOms9hUFAQFixYYKw72rVrh6+++gqDBw/WQqoRWXfom+/8orDlVBKmDWmNKYOeYS1HYgFUp9C/du0a+vbtix49euDLL7/El19+ie7du6NPnz64du2axaIrgpxCX7+UmEJfsMG01nTtymPZsmUYOnQoatSoYaw7atasieHDh2Pp0qWUVPKFyOVBS4yPJ4tSUXAAz2VTdY/K0KFDkZaWhnXr1qFNmzYAgNjYWEyYMAE1a9ZEQEAAFaGlUdAiu379utBP/mRmZqJ69eqsZVChuLewK6n414rjaF63Gg79ZwA7YYSwhmtn7jejp59+Gt9++y2++OILk/eXLl2KX375RdP5kFj1qIhcHrRk+p9R8D2dhG9eboPJL/K1pIte0bpsUu1ROXz4MJYvX25spABAmzZtsHjxYoSEhKhXS4B169YxOa9WrF69mrUEahT3Jtpofmu6duWRlpaGoUOHlnj/pZdeQnp6OilZXCNyedASOZiWPDyXTdUNFRcXF+Tl5ZV4Pz8/n1mvxpAhQ5icVyuGDRvGWgI1insTrQKypmtXHiNHjsT27dtLvL9z5068+uqrpGRxjcjlQUvkYFry8Fw2VU/4Nn/+fEyZMgVLly5Ft27dADweWPvll1/i119/JS7QHM6dO2fUIiLR0dFo27YtaxlUKO5NtHlUrOnalcaiRYuM/2/fvj3c3d0RHBxsXFfkxIkTOHr0KKZNm0ZVKy+IXB60RK71Qx6ey6ZZDRVnZ2eTPxwPHjxAz549YWf3ePdHjx7Bzs4OH374IZM5TZycnDQ/p5bUqlWLtQRqFPcm2mBaa7p2pbFgwQKTn52dnRETE4OYmBiT46xdu5bbRyNJInJ50BS51g9xeC6bZjVUFi5cSFlGxahRowZrCVQR2V9xb8bl2wX5rmRN16405EKEpohcHrREtFvEPMBz2TSroTJu3DjaOipEbGwsBg0axFoGNc6fP4/nn3+etQwqFPdWeOuHkSDCWNO1k5SPzIwMos1gzQM8l00h5v988UWxJwYTebBwcW+iLTZmTddOUj4yMzIY5K0f4vBcNoVoqGzatIm1BKp4e3uzlkCN4t4Kb/2IgTVdO0n5yMzIoMhbP8ThuWxaPIU+D8hpsMXjUOwtTPAKQ8fGNbF7Sl/WciRmoMfPoR41SwqZvDkCe6Ju4ueRHTCudzPWciQWQHXCNx6RU+jrlxLejBO+ifFVyaqunaRcZGZkkD0q5OG5bArRUPn6669ZS6DKt99+y1oCNYp7UyBWBWRN1648mjVrhlmzZiExMZGSIv4RuTxoiWgzWPMAz2VTdUPlwYMH+PHHH9G7d2+0atUKLVq0MHmxoOikUiLCaiI9LSjuzWB4/K8og2mt6dqVx1dffQU/Pz+0aNECQ4YMgY+PD3Jzcymp4xORy4OWiDbongd4LpuqZ6b96KOPcPjwYbz//vto1KgRFwXl9ddfZy2BKm+99RZrCdQo7k20wbTWdO3K46uvvsJXX32FiIgIeHt7Y8qUKfj888/xzjvv4MMPP4SrqyslpfwgcnnQEtGmMeABnsum6obKvn37sGfPHrzwwgs09FjEiRMn0KlTJ9YyqBEaGopmzZqxlkGF4t4Mgs1Ma03XzlxcXV3h6uoKT09PLFu2DNOnT8fy5cvRqVMnTJ06FRMmTODiCxANRC4PWiIfTyYPz2VTdUPF2dkZtWvXpqHFYlxcXFhLoErTpk1ZS6BGcW+irfVjTdfOXPLy8rB9+3Z4eXkhMDAQzz//PCZOnIhr167h+++/x4EDB7B582bCavlA5PKgLXKtH9LwXDZVN1Rmz56Nn376CevWrUPVqlVpaFJNfn4+awlUEdlfcW+KYIuNWdO1K4+IiAh4eXlhy5YtsLW1xQcffIAFCxaYLIQ2ZswYdO/enbRUbhC5PGiJvPVDHp7LpurBtJ6enti/fz8aNGiATp06GbtxC16WMmfOHNjY2OCrr75SvW9ycrLF59UDN2/eZC2BGsW9ibZ8uzVdu/Lo3r074uLisHz5cly/fh2//vpridVamzdvrvpeeUXqDq0RuTxoiRxMSx6ey6bqHhUaqyOHhYVh5cqVePbZZy3av2vXroQV8UWPHj1YS6BGcW+KYKNprenalUd8fHy53cvVqlWDl5eX2cesaN2hNSKXBy0RrJrgAp7LpuqGyowZM4gKyMzMxLvvvovVq1dbPOGMv78/OnfuTFQXT/z111/473//y1qGEYNBwa6oG0jJyKnwsQ4dCkbRpZpibmQAEGcwLW/XjiRqvb344osICwtDnTp1TN5PS0uDq6sr4uPjVZ2fRN2hNSKXh+JcTLmP4NhbVI6deDcLgDg9rzzAc9lU3VApIDw8HOfPnwcAdOjQAV26dLHoOJMnT8Yrr7yCwYMHl1vZ5Obmmsy7kJHx+I/aZ599ZtG59cKXX37JWoIJJxLu4kufSEJHa4jjey+UeLeyfSVCx2cLb9eOJGq9XblypdT74Lm5ubh+/brq85OoO7RG5PJQnM83ReDSrUyq5xClnuABnsum6jEqt27dwsCBA9G9e3dMnToVU6dORdeuXTFo0CDcvn1b1bF8fHwQEREBDw8Ps7b38PCAk5OT8VXwtM/MmTMxb9485ObmGissNzc33LhxA2vWrEFYWBj2798PPz8/xMTEYNGiRcjIyDDZNjU1FUuXLkVUVBT8/f2xZ88eREREYOXKlbh9+7bJtllZWfD09ERsbCy2bt2KoKAgHDt2DN7e3khKSjLZNj8/Hx4eHrh69So2bNiA0NBQBAcHw8fHB3FxcZg/fz5ycnJM9klOTsbq1asRFhaGgIAATJgwAWfPnsXixYuRnp5usm1aWhqWLFmC6Oho7NixA3v37kV4eDhWrVqFlJQUk22zs7Ph6emJuLg4+Pr64uDBgzh69CjWr1+PxMREuLu7w2AwwM3NDQaDAe7u7khMTMT69etx9OhRHDx4EL6+vjh/+fHMonWq2eMZu7t4zbUxnrG7i+Ht6qBT9SwMaFoZPesD3esaMLB5NbSveh+vdqxnsu2IjvXRvsp9PJ13Hd3q5uP5Bjbo36QyOlXPwogOdeCUGGrUnZOTg/nz5yMuLg4+Pj4IDg5GaGgoNmzYgKtXr8LDwwP5+fkmXpOSkuDt7Y1jx44hKCgIW7duRWxsLDw9PZGVlWWy7e3bt7Fy5UpERERgz5498Pf3R1RUFJYuXYrU1FSTbTMyMrBo0SLExMTAz88P+/fvR1hYGNasWYMbN26YbJubm4uRI0fi8uXL2LJlC4KDg3HkyBFs3LgRV65cwZw5c/Do0SOTfa5duwYvLy+cOHECgYGB2LZtGy5cuIAFCxYgMzPTZNs7d+5gxYoViIyMxO7du7Fr1y5ERkZi+fLluHv3rsm29+/fx8KFCxETE4O//voLf//9N06ePIm1a9eW0J2Xl4e5c+ciPj4emzZtQkhICEJCQrBp0ybEx8dj7ty5yMvLwyuvvAKg/CUs/P394e/vDwDYv3+/8Wd/f39s374ds2fPVv1YJKm6Iz4+XtO6w93dXdO6Y/v27czqjrv3H/e4ujawQ+9GleBaOw9DWtVEW8d0jHquYYXrjpYP43H/4gkEBAQgLCwMq1evRnJysoluPdcd8+bN07Tu+PrrrzWrO9T2gKpelHDs2LGIj4/H+vXr0a5dOwBATEwMxo0bh1atWmHLli1mHScpKQndunVDYGCg8f7ygAED0LlzZyxcuLDUfUr7VuTi4iIXFtOYPVE3MXlzBHo0r42tn/ZiLUfCmPIWF7O1ffx9yMbGBsWrG3t7ezRr1gyenp549dVXzTqfrDv0QdfZgbj74CH2f9UPbRrWYC1HwhlUFyUMCAjAsmXLjI0UAGjfvj2WLl2Kffv2mX2c8PBw3Lp1C66urrCzs4OdnR0OHz6MRYsWwc7OrtQuYkdHR9SsWdPkBchFCbWG5KRsvHkjjcj+zPVmMBhgMBjQpEkT3Lp1y/izwWBAbm4uYmNjzW6kAGTrDq0RuTwUh/bkjdaUpRbwnKfqMSoGgwH29vYl3re3t4ehYKEWMxg0aBCio6NN3pswYQLatm2L6dOno1Il8+89vv/++2Zvq0c+/PBD1hJMKBxxX/EaiDdvpBHZn1pvCQkJRM5Lsu7QGpHLQ3GM9QSlhoo1ZakFPOepuqEycOBAfPnll9iyZQueeuopAMD169fx73//G4MGDTL7ODVq1EDHjh1N3qtWrRrq1KlT4v3yCAwMRJs2bVTtoyf27duHiRMnspZhpKD73pbA2tu8eSONyP7M8bZo0SJ88sknqFy5crmLh06dOtWs85KsO7RG5PJQHIOB7lwn1pSlFvCcp+qGypIlSzBy5Eg0a9bMOCAtKSkJHTt2xMaNG4kLNIcOHTowOa9W8DZHROES6xWvgHjzRhqR/ZnjbcGCBXj33XdRuXJlLFiwoMztbGxszG6o6BmRy0NxaM91Yk1ZagHPeapuqLi4uCAiIgIHDhzAhQuPHytt164dBg8eXGExwcHBFu137969Cp+bZ1JTU1lLMKFwVsiKH4s3b6QR2Z853ore7iF166c0LK07tEbk8lAc2ut2WVOWWsBznhbNo2JjY4MhQ4ZgyJAhpPVYRFZWFmsJVHnw4AFrCSaQrIB480Yakf2J7I0W1pSZQnkwrTVlqQU852lWQ4XGfWaStG7dWvNzaknx9VBYQ7JLlzdvpBHZn1pvr7/+Onr06IHp06ebvD9v3jyEhYVh27ZtJOVxicjloTgkB92XhjVlqQU852lWQ4X3+8zBwcFcr1NQUQ4cOID27duzlmGE5GOHvHkjjcj+1HoLCQnBzJkzS7w/bNgweHp6ElTGLyKXh+KQvEVcGtaUpRbwnKdZDRWt7jNbyjvvvMNaAlXGjx/PWoIpBG/9cOeNMCL7U+stMzMTDg4OJd63t7dnNqW91ohcHopTeIuYzvGtKUst4DlP1Q+Yzpo1q9QxIdnZ2Zg1axYRUWpZsWIFk/NqRXm327TG+E2JwLF480Yakf2p9dapUyf4+vqWeN/Hx4fbb3KkEbk8FIf2YFprylILeM5T9RT6lSpVws2bN1G/fn2T9+/evYv69euXOiskLdRMwSshx5ZTifjOLxqD2zXAH+O6sZYjYYy5n8Ndu3bhtddewzvvvIOBAwcCAIKCgrBlyxZs27YNo0eP1kixrDu04Jn/24u8fAXHvxuIRk5VWMuRcAbVKfQVRSm1hXzmzBnUrl1b7eGIIKfQ1xaSXbq8eSONyP7UehsxYgR27NiBS5cu4fPPP8e0adNw7do1HDhwQNNGCktELg/FITnfUmlYU5ZawHOeZj+e7OzsDBsbG9jY2KB169YmjZX8/HxkZmZi0qRJVESWx0cffcTkvFrx+eefs5ZgAsnBtLx5I43I/izx9sorrxhXXbZGRC4PxaG91o81ZakFPOdpdo/KwoUL8dtvv0FRFPz8889YsGCB8bVixQqEhoZi6dKlNLWWyZ9//snkvFph7orUWkHysUPevJFGZH+WegsPD8fGjRuxceNG/PPPP4RV8Y3I5aE4xjEFlBoq1pSlFvCcp9k9KuPGjQMANG/eHL179y51YUJW9O7dm7UEqvTt25e1BBNIrvXDmzfSiOxPrbdbt27hrbfeQnBwMGrVqgUASEtLw4svvggfHx/Uq1ePgkq+ELk8FKfg1o8tpcG01pSlFvCcp1l/aoo+OtilSxdkZ2cjIyOj1BcLEhMTmZxXK65cucJaggkk7z3z5o00IvtT623KlCm4f/8+zp07h9TUVKSmpuLs2bPIyMiwinV+ALHLQ1GKPqNBa60fa8lSK3jO06weFWdnZ+OTPrVq1Sp1MG3BIFstn/opgOdl3UnAmz+lsKVSYXjzRhqR/an1FhAQgAMHDqBdu3bG99q3b4+lS5fipZdeIi2PS0QuD0Up+iwprceTrSVLreA5T7MaKgcPHjQ+0XPo0CGqgiyhQYMGrCVQpVGjRqwlmGAg2KXLmzfSiOxPrTeDwVDqLWN7e3sYDAZSsrhG5PJQFEORlgqtwbTWkqVW8JynWbd++vfvDzs7O+P/n/RiQUREBJPzakVYWBhrCSaQXOuHN2+kEdmfWm8DBw7El19+iRs3bhjfu379Ov79739j0KBBpOVxicjloShFJ+ei9XiytWSpFTznqXo4ZEBAAEJDQ40/L126FJ07d8Y777yDe/fuERVnLiNHjmRyXq147bXXWEswgeSqqLx5I43I/tR6W7JkCTIyMtCsWTO0bNkSLVu2RPPmzZGRkYHFixdTUskXIpeHohTtUbEhMOi+NKwlS63gOU/VReibb74xDpqNjo7G119/jeHDhyMhIQFff/01cYHmsHbtWibn1YqVK1eylmACyamxefNGGpH9qfXm4uKCiIgI7NmzB1999RW++uor7N27FxEREXj66acpqeQLkctDUUzGqFA6h7VkqRU856l6Cv3q1avj7NmzaNasGWbOnImzZ8/izz//REREBIYPH47k5GRaWksgp8Fmw6qQy/hl7wW81qUxfhvbmbUcCWP0+DnUo2Y9kZOXj7Y/BgAAzv78Mqo7mj0ThsRKoDqFvoODg3FRwgMHDhhH69euXZvZ48lyCn1tMRDsUeHNG2lE9meOt0WLFpn9sgZELg9F0WIwrbVkqRU856m6R2XkyJF4+PAhXnjhBcyePRsJCQlo3Lgx/v77b3zxxRe4ePEiLa0lKGiR3bx5Ew0bNtTsvFqTlZWFqlWrspZhZHnwZcwNuIA3uj6NX//1XIWOxZs30ojsr8Dbk74ZNW/e3Kxj2djYID4+nobMUmHVoyJyeSjKg9xH6DBjPwDg/KyhqOJA/tFXa8lSK7TOk2qPypIlS2BnZ4c///wTy5cvR+PGjQEA+/btw9ChQy1TXEHWrFnD5LxasXz5ctYSTCC5hgdv3kgjsj9zvCUkJJj10rKRwhKRy0NRTAbTUupRsZYstYLnPFXfOGzSpAl2795d4v0FCxYQEWQJrBpIWvHqq6+yllAqJB475NUbKUT2Z6m3hw8fIiEhAS1btjROe2AtiFweimLyeDKlhoq1ZKkVPOdp0YNj+fn5+Ouvv+Dm5gY3Nzds376dyYy0BURHRzM7txacOXOGtQQTCu4WkqiAePNGGpH9qfWWlZWFiRMnomrVqujQoYNx6YspU6Zgzpw5NCRyh8jloSimT/3QaalYS5ZawXOeqhsqly5dQrt27fDBBx/Az88Pfn5+eO+999ChQwdcvnyZhsZyKZg1V1Tq1KnDWoIJJAfT8uaNNCL7U+vtu+++w5kzZxAcHIzKlSsb3x88eDB8fX1Jy+MSkctDURQNBtNaS5ZawXOeqhsqU6dORcuWLZGUlISIiAhEREQgMTERzZs3Z7awWJUqVZicVyt481c4j0rFj8WbN9KI7E+ttx07dmDJkiXo06ePSSOX5ZccrRG5PBRFi7V+rCVLreA5T9UNlcOHD2PevHkmvRh16tTBnDlzcPjwYaLizOXSpUtMzqsVWj5JZQ4kB9Py5o00IvtT6+327duoX79+ifcfPHhA7Y8Zb4hcHoqixePJ1pKlVvCcp+qGiqOjI+7fv1/i/czMTDg4OBARpRZWawxpBW/roBSu9VPxGog3b6QR2Z9ab926dcOePXuMPxc0Tv744w/06tWLqDZeEbk8FMV0MC2dloq1ZKkVPOepuqHy6quv4pNPPsHJkyehKAoURcGJEycwadIkZmvubN68mcl5tWLdunWsJZhCcDAtd94II7I/td5++eUXfP/99/jss8/w6NEj/P7773jppZfg5eUFd3d3Sir5QuTyUBR1s3NZhrVkqRU856l6wre0tDSMGzcOu3btMi7Z/ujRI4wcORLe3t5wcnKiIrQ05DTYbPh1fyyWHLqE8b2bYebIDqzlSBhT3ufw7Nmz6NixIwDg8uXLmDNnDs6cOYPMzEy4urpi+vTp6NSpE1eaJRXjVkYOevwSBFsbIN7jFdZyJByi5jOoehKDWrVqYefOnbh06RLOnz8PAGjXrh1atWplmVoCzJs3j+vpfyuKm5sbfvjhB9X7pWTkIC/fQFxPRk4esWNZ6k0viOzPXG/PPvssunfvjo8++ghvvfUWVq9erYE6PuGtPDx8ZMCt+znEj3sn8yEAerd9AP6y1Ds852l2j4rBYMD8+fPh7++Phw8fYtCgQZgxYwbTkcIFLbLU1FQ4Ozsz00Gb/Px8VKqkbgrqBYEX8XtQHCVFj5nwQjPMGFGxHhVLvOkJkf0VeCvvm9GRI0fg5eWFP//8EwaDAW+88QYmTpyIvn37MlD9GFY9KjyVh7x8AwZ5HkZiaha1c9jZ2uDSL8OpHJunLEVA6zypTKHv7u6O77//HtWrV0fjxo3x+++/Y/LkyRUWS4KFCxeylkAVSxZdjExKA/C4onC0syX+ql3NAS+2KfkEhxbe9ITI/sz11rdvX6xduxY3b97E4sWLkZCQgP79+6N169aYO3eupiuus4an8nAv66GxkUKjjnC0s8Wozo2p6ecpSxHgOk/FTFq1aqWsWLHC+HNgYKDi4OCg5Ofnm3sI4qSnpysAlOjoaGYatODKlSuq93l/zUml6fTdyp+nkygoIocl3vSEyP4KvBV8DtPT083eNy4uTvn+++8VFxcXxd7eXhkxYgQtmaViiWYS8FQeUtKzlabTdyvNv93NWopF8JSlCGidp5rPoNk9KomJiRg+vLALb/DgwbCxscGNGzeIN57UcuzYMdYSqBISEqJ6H4Xgkzk0scSbnhDZX0W8tWrVCt9//z1++OEH1KhRw+SxZZHhqTwYpxngvZIoA56yFAGe8zR7MO2jR49Mpr0GAHt7e+TlkRtYaSlNmzZlLYEqzZs3V71PwcgjW84rIUu86QmR/VnqLSQkBGvXrsVff/0FW1tbvPnmm5g4cSJhdXzCU3kgOXEjC3jKUgR4ztPshoqiKBg/fjwcHR2N7+Xk5GDSpEmoVq2a8T0/Pz+yCs3g0aNHmp9TSyzxp0AfPSry2ukXNd5u3LgBb29veHt749KlS+jduzcWLVqEN99806T+EB2eyoNxKQxKiwbShqcsRYDnPM1uqIwbN67Ee++99x5RMZaSkpLCWgJVLBlsaPjfU8m8d+uKPpBSZH/mehs2bBgOHDiAunXr4oMPPsCHH36INm3aUFbHJzyVB4NObg+XBU9ZigDPeZrdUPHy8qKpo0J06dKFtQSqdO3aVfU+xh4V0mIIY4k3PSGyP3O92dvb488//8Srr75q9Y+T8lQeSC4uygKeshQBnvNUPYU+j+zevZu1BKrs2LFD9T56qYQs8aYnRPZnrjd/f3+MGjXK6hspAJ/lQa+3fnjMUs/wnKfqKfR5omDCmJSUlFJXZRWFnJycEgOZy+PNFcdx6koqlr3riuGdGlFSVnEs8aYnRPZX4E2P09Gz0sxTebh69wH6zw9GNYdKODdrKGs5quEpSxHQOk8qE77xzKJFi1hLoMqvv/6qeh+93PqxxJueENmfyN5owVNmhb2uvNcSpcNTliLAc55C9Kjo6ZucVry+/BjCr97Dive6YmjHhqzlSARGj59DPWomTfztTAz0PIwale0QPfNl1nIkVobV9ahwPfUvASxZcFEvE76JvJgkILY/kb3RgqfMjBO+MVVhOTxlKQI85ylEQ6W0R6dF4qOPPlK9j14qIUu86QmR/YnsjRY8Zab3Wz88ZSkCPOcpRENl3759rCVQZdeuXar3MehkZlpLvOkJkf2J7I0WPGWm6HxmWp6yFAGe8xSiodKpUyfWEqjSuXNn9Tvp5NaPRd50hMj+RPZGC54y0/taPzxlKQI85ylEQyU1NZW1BKrcvXtX9T566VGxxJueENmfyN5owVNmel/rh6csRYDnPIVoqOTk5LCWQJXs7GzV+xQ8nsz7IBVLvOkJkf2J7I0WPGVW+Lwn55VEGfCUpQjwnKcQDZWWLVuylkCVZ555RvU+xrV+CGshjSXe9ITI/kT2RgueMtP7Wj88ZSkCPOcpREMlJCSEtQSqHDp0SPU+BV+WeL/1Y4k3PSGyP5G90YKnzBTj7WG2OiyFpyxFgOc8hWiovP3226wlUOWDDz5QvY9e5lGxxJueENmfyN5owWNmel3rh8cs9QzPeQrRUFm5ciVrCVRZvHix6n0UnQymtcSbnhDZn8jeaMFTZnofTMtTliLAc55yCn1BeWnBYVxMycTmj3qid6u6rOVIBEaPn0M9aibNmaQ0jFp6FI1rVcHRbweyliOxMuQU+oJhydTGBp1MTcvztM0kENmfyN5owVNmBv1+RwXAV5YiwHOeQjRUPvnkE9YSqPLFF1+o3qdw1km+WyqWeNMTIvsT2RsteMrMOOBep38FeMpSBHjOU6dF1BRfX1/WEqiyceNG1fvopEPFIm96QmR/InujBU+ZGdf64b6WKB2eshQBnvMUoqHSp08f1hKo0r9/f9X7GAfTcj5SzhJvekJkfyJ7owVPmel9rR+eshQBnvMUoqGSkJDAWgJVLl++rHof4+PJpMUQxhJvekJkfyJ7owVPmel9rR+eshQBnvMUoqHi4ODAWgJVLPFXMJiW9zpIXjv9IrI3WvCUmcGgjy8zZcFTliLAc55CNFTq1avHWgJVGjRooHqfgrV+eP+2ZIk3PSGyP5G90YKnzAp7VJjKsBieshQBnvMUoqESGRnJWgJVwsPDVe9TOFCObyzxpidE9ieyN1rwlJmxjtBpS4WnLEWA5zyFaKi88sorrCVQZdSoUar30cvMtJZ40xMi+xPZGy14ykzvg2l5ylIEeM5TiIaKt7c3awlUWb16tep99LLWjyXe9ITI/kT2RgueMiucwoDzSqIMeMpSBHjOU06hLyjP/xKE5Iwc7J7SBx0bO7GWIxEYPX4O9aiZNEfibuP9NafQtmENBHzVj7UciZUhp9AXDEumNlagj/Ynz9M2k0BkfyJ7owVPmel9jApPWYoAz3kybah4eHige/fuqFGjBurXr4/Ro0cjNjZW9XGmTJlCQR0/TJs2TfU+ik4eT7bEm54Q2R8rb6TqDRbwVB70Mnt1WfCUpQjwnCfThsrhw4cxefJknDhxAoGBgcjLy8NLL72EBw8eqDrOH3/8QUkhHyxbtkz1PgadDKa1xJueENkfK2+k6g0W8FQeChYl1OtaPzxlKQI852nH8uQBAQEmP3t7e6N+/foIDw9Hv34l75nm5uYiNzfX+HNGRgYAYPjw4XSFUmLjiav4M/xauTdpctEZIUuPqjp2WtZDAPz3qIwcOZK1BKqI7I+VN7X1BlB23aE1ajO7evcBfthxFhk5j4hruZ+dB0C/g2lF/myxgOc8uWpLp6enAwBq165d6u89PDzg5ORkfLm4uAAA/v77b8ybNw+5ubnG+2xubm64ceMG1qxZg7CwMOzfvx9+fn6IiYnBokWLkJGRYbJtamoqli5diqioKPj7+2PPnj2IiIjAypUrcfv2bZNts7Ky4OnpidjYWGzduhVBQUE4duwYvL29kZSUZLJtfn4+PDw8cPXqVWzYsAGhoaEIDg6Gj48Pfg+8gMikNJwp53Xhdk652xR/PTIoqGRrgw2rlxm1ZGdnw9PTE3FxcfD19cXBgwdx9OhRrF+/HomJiXB3d4fBYICbmxsMBgPc3d2RmJiI9evX4+jRozh48CB8fX0RFxcHT09PZGdnm3hNSUnBqlWrEB4ejr1792LHjh2Ijo7GkiVLkJaWZrJteno6Fi9ejJ07d2L79u0ICAhAWFgYVq9ejeTkZJNtc3JyMH/+fMTFxcHHxwfBwcEIDQ3Fhg0bcPXqVXh4eCA/P99kn6SkJHh7e+PYsWMICgrC1q1bERsbC09PT2RlZZlse/v2baxcuRIRERHYs2cP/P39ERUVhaVLlyI1NdVk24yMDCxatAgxMTHw8/PD/v37ERYWhjVr1uDGjRsm2+bm5mLmzJm4fPkytmzZguDgYBw5cgQbN27ElStXMGfOHDx69Mhkn2vXrsHLy8vYW7Bt2zZcuHABCxYsQGZmpsm2d+7cwYoVKxAZGYndu3dj165diIyMxPLly3H37l2Tbe/fv4+FCxciJiYGf/31F/7++2+cPHkSa9euLaE7Ly8Pc+fORXx8PDZt2oSQkBCEhIRg06ZNiI+Px9y5c5GXl4cffvgBAPsxYuXVG0DZdUd8fLymdcfx48dV1R3/XbwFR+LuqP78m/OKv/O4B6q67UPs2LEDe/fuRXh4OFatWoWUlBQTLbLu0L7umDdvnqZ1h5+fn2Z1h9rxMNw89WMwGDBy5EikpaUhNDS01G1K+1bk4uICf39/jBgxQiupxOjufgC37+dixoj2aFK7apnbnYmKwnPPPqv6+M3rVkOLetUrIpE6Bw8exMCBA1nLoIbI/gq8sXyCxpx6Ayi77tBas9rysDgoDp6BF9GvdT2M69WUuB5bWxv0aFYb1RyZdq5bhMifLRZonaeaeoOb0jl58mScPXv2iZWNo6MjHB0dS31fjxQ0EZ9vUQftGpV9oSqnVsUL7fid3rgi6PXamYvI/njwZk69AZRdd2iNWg0F3yKfdq6CQYLWAZbCw/UUCZ7z5OLWzxdffIHdu3fj0KFDePrpp1Xvr9/Vk82blI3nVS0risjeALH9sfZW0XqDBWoz08tSGCxgXf5Eg+c8mfaoKIqCKVOmYPv27QgODkbz5s0tOk6fPn0IK9MGc5/MGTBgAH0xjBDZGyC2P1beSNUbLFCbmfHJHN5HxTNA5M8WC3jOk2mPyuTJk7Fx40Zs3rwZNWrUQHJyMpKTk5Gdna3qOD4+PpQU0sU4zX05223YsIG+GEaI7A0Q2x8rb6TqDRaozUzvKxzTROTPFgt4zpPpYNqyZkT08vLC+PHjy92/YDDOvXv3UKtWLbLiNOC5n/9GenYeDnzdH63qlz3o1WAwwFavkx2Ug8jeALH9FXjTejBtResNgN0U+mrLg+ffsVh88BLG926GmSM7UFSmP0T+bLFA6zx1M4W+oiilvsytbAr49ddf6QikjLkLB/7yyy8aqGGDyN4Asf2x8kaq3mCB2sz4eCaTT0T+bLGA5zy5eTzZEvTeo9Jp5n7cz3mEg9P6P/ExYpG/OYjsDRDbH6seFRLopUdlXsAFLAu+jAkvNMOMEbJHpSgif7ZYIHtUKOPp6clagkUoZg6m9fDw0EANG0T2BojtT2RvtFCbWcG3SDmYtiSy/JGF5zyFaKi89dZbrCVYhLm3ft5//30N1LBBZG+A2P5E9kYLtZnJx5PLRpY/svCcpxANlfIme+IVcx9PDg4Opi+GESJ7A8T2J7I3WqjNTDEuHCibKsWR5Y8sPOcpRENFT/MoFEUpdznCx7Rs2ZKyEnaI7A0Q25/I3mihNjPj48nkpegeWf7IwnOeQjRUiq7hoSeM3brl1EJ69WcOInsDxPYnsjdaqM3MYJD3fspClj+y8JynEA2VO3fusJZgEeYOpr19+7YGatggsjdAbH8ie6OF2szkYNqykeWPLDznKURDpXPnzqwlWIRi5lo/rq6uGqhhg8jeALH9ieyNFmozM5g5e7U1IssfWXjOU4iGyt69e1lLsAhzB9P6+/troIYNInsDxPYnsjdaqM3M3F5Xa0SWP7LwnKcQE74lJyejQQP9LYHe4rs9MCjAqe8HoX7NymVul52djSpVqmioTDtE9gaI7a/Am5zwzXzUloeZ/ufgfewKpgxshWkvtaGoTH+I/NligdZ5Wt2Eb4sXL2YtwSKMLcRyvizpdUI7cxDZGyC2P5G90UJtZvLWT9nI8kcWnvMUokdFT9/kitLs2z0AgNM/DEbd6o6M1UgklqHHz6FeNP+44yw2nLiKLwc9g38Pac1ajkRCDKvrUZk3bx5rCaop2j4s79uSm5sbXTEMEdkbILY/kb3RQm1mBjNnr7ZGZPkjC895CtFQ0cOqqcUxFOnHKm+g3Mcff0xZDTtE9gaI7U9kb7RQm5l8PLlsZPkjC895CtFQ2bNnD2sJqjHpUSmnDtq5cydlNewQ2Rsgtj+RvdFCbWaKHKNSJrL8kYXnPIVoqOhxHpWiA4NsyqmGunbtSlcMQ0T2BojtT2RvtFCbmbmzV1sjsvyRhec8hWio8DyjXlkYivaolHMVUlJSKKthh8jeALH9ieyNFmozKxyjIlsqxZHljyw85ylEQ+Xhw4esJaim6LNW5VVBevRnLiJ7A8T2J7I3WqjNTPaolI0sf2ThOU8hGip6XD1ZUTGYludVLSuKyN4Asf2J7I0Wlq6eLAfTlkSWP7LwnKcQDZXQ0FDWElSjwPzBtIcPH6ashh0iewPE9ieyN1qozUxO+FY2svyRhec8hWiojB07lrUE1Zje+nlyNfTee+9RVsMOkb0BYvsT2RstVGcmb/2UiSx/ZOE5TyEaKqtWrWItQTUGFY8nL1myhLIadojsDRDbn8jeaKE2s4J6Qt76KYksf2ThOU85hT4jMnLy8OzMvwEAsW5D4WhXibEiicQy9Pg51IvmL33+wc7IG/jhlXb4qG8L1nIkEmLIKfR1gGIo/H9535Z4ntq4oojsDRDbn8jeaKF+Cv3H/8oelZLI8kcWnvMUoqHy6aefspagGpPBtOVsO2XKFLpiGCKyN0BsfyJ7o4XazBS51k+ZyPJHFp7zFKKhsmXLFtYSVFN0rZ/yJnNav349ZTXsENkbILY/kb3RQm1mBdWEbKeURJY/svCcpxANlX79+rGWoJqiQ4Nsy6mFXnzxRcpq2CGyN0BsfyJ7o4XazArqCdvyKgkrRJY/svCcpxANlcuXL7OWoBqTtX7K6VGJi4ujK4YhInsDxPYnsjdaqM3MODMtBS16R5Y/svCcpx1rASSoXLkyleMqioI90TdxIy2b+LEzc/MBmHfvuUqVKsTPzwsiewPE9ieyNzXcyczF7jM38DDfUO62F2474naI+V+s4m8/ACDX+ikNWf7IwnOeQjRUateuTeW4kUlp+GLzP1SOXUBlMx5LrlOnDlUNLBHZGyC2P5G9qWFB4EVsOplo/g7xF1Sfo7K9nL6gOLL8kYXnPIVoqERHR1O5v5aWlQcAqFXVHgPb1id+fAB4sU35x42MjET37t2pnJ81InsDxPYnsjc1FNQTz7nUQst61Z64bdzFODzT+hlVx69TzQEvdWhgsT5RkeWPLDznKURDZdiwYVSOW/AIcZPaVfHbm52pnMMcRowYwezctBHZGyC2P5G9qaGgnnjDtTHe79XsidsmJzdEw4YNNVAlPrL8kYXnPIUYTLtu3ToqxzX875Yz6/vDf/zxB9Pz00Rkb4DY/kT2pgY19YTMjBwyS7LwnKecQv8JBMak4OP1p9HZpRZ2TH6B+PElEhHQy3T0RSGp+dMNp7H/XArcx3TEuz2bElIokYiNnEKfEIULglE5vNnwPLVxRRHZGyC2P5G9qUHNNPcyM3LILMnCc55C9KikpKSgfn3yg10DziZj0sZwdG3qjL8+6038+OaSk5ND7RFs1ojsDRDbX4E3a+9R+WjdaRw4n4I5r3XCWz2aPHFbkcuD1sgsyaJ1nlbXo7Jy5UoqxzWus0Hl6OazePFixgroIbI3QGx/IntTg5r1eGRm5JBZkoXnPIVoqLz66qtUjlvQ1cR65dLRo0czPT9NRPYGiO1PZG9qMK7HY0Y9ITMjh8ySLDznKURD5Z9/6EzKpnCyIlh4eDhbARQR2Rsgtj+RvalBTc+rzIwcMkuy8JynEA2VBg3oTIbEy2BakeddENkbILY/kb2pQc1gWpkZOWSWZOE5TyEaKnZ2dOatK+xQYdtSoeWPB0T2BojtT2Rvaii89VP+tjIzcsgsycJznkI0VK5evUrluGoGydEkISGBrQCKiOwNENufyN7UoKaekJmRQ2ZJFp7zFKKh0rs3nUeHFRVdujTp168f0/PTRGRvgNj+RPamBjX1hMyMHDJLsvCcpxANlW3btlE5bsEaHqx7VDZv3sxWAEVE9gaI7U9kb2pQYP5UVDIzcsgsycJznkJM+JaamgpnZ2fix/8r/BqmbTuDfq3rYf2HPYgf31zy8/NRqZKYy7yL7A0Q21+BN2uf8O3tVSdwPP4uFr/dBSOee+qJ24pcHrRGZkkWrfO0ugnfPD09qRyXk6eT4eHhwVgBPUT2BojtT2RvalDT8yozI4fMkiw85ylEjwqtb3JbTyfhv39G4cU29eA1gV2PikTCM9beo/LmyuM4lZCKZe+6YninRoQUSiRiY3U9KrQWJSzoUjFnxkma8LxYVEUR2Rsgtj+RvamioJ4wY1OZGTlklmThOU8hGirvvPMOleMau3SpHN18xo0bx1gBPUT2BojtT2RvalBz60dmRg6ZJVl4zlOIhsrhw4epHNfASY9KUFAQ0/PTRGRvgNj+RPamBjX1hMyMHDJLsvCcpxANlVatWlE5rmKsgKgc3mxat27NVgBFRPYGiO1PZG9qULPWj8yMHDJLsvCcpxANlezsbCrH5WWtH1r+eEBkb4DY/kT2pgY1a/3IzMghsyQLz3kK0VBJTU2lclxe1vq5e/cu0/PTRGRvgNj+RPamBjVr/cjMyCGzJAvPeQrRUOnUqROdA3Oy1s9zzz3HVgBFRPYGiO1PZG+qUFFPyMzIIbMkC895CtFQCQgIoHJcNV26NNm9ezfT89NEZG+A2P5E9qYGNYNpZWbkkFmShec8hWioTJw4kcpxjXPhMe5R+eyzz9gKoIjI3gCx/YnsTQ1qpjGQmZFDZkkWnvMUoqGyZMkSKsflpUflt99+Y3p+mojsDRDbn8je1GAwPP7XnHpCZkYOmSVZeM5TTqH/BNaEJmD27hiMfO4pLHq7C/HjSyQiYO1T6A/7/QjO38zAhok90PeZeoQUSiRiI6fQJ4TCyWBanqc2rigiewPE9ieyNzUUzqNSfkUhMyOHzJIsPOcpREPlww8/pHJchZNbP59++inT89NEZG+A2P5E9qaGwnqi/G1lZuSQWZKF5zyFaKj4+/tTOS4va/34+fkxVkAPkb0BYvsT2ZsaFBWrEsrMyCGzJAvPeQrRUHF1daVyXF7W+unevTvT89NEZG+A2P5E9qYGNYPuZWbkkFmShec8hWiopKSkUDkuL2v93Lx5k60AiojsDRDbn8je1KBmrR+ZGTlklmThOU8uGipLly5Fs2bNULlyZfTs2ROnTp1StX9+fj4VXbzc+qHljwdE9gaI7Y+1t4rWG6QonEK//JqCdWYiIbMkC895Mm+o+Pr64uuvv8aMGTMQERGB5557Di+//DJu3bpl9jGaNGlCRRsvg2mbNWvG9Pw0EdkbILY/lt5I1BukUDOYVuTyoDUyS7LwnCfzhspvv/2Gjz/+GBMmTED79u2xYsUKVK1aFWvXrjX7GMeOHXvi71MfPMS1e1mqX+nZeQDY3/o5cuQIWwEUEdkbILY/lt5I1BvlkW9QzKonHj56POObOfWEyOVBa2SWZOE5TzuWJ3/48CHCw8Px3XffGd+ztbXF4MGDcfz48RLb5+bmIjc31/hzRkYGAOCNN9544nlm7TqHHZE3LNbJuqHy9ttvsxVAEZG9AWL7Y+VNbb0BlF13PIm7D3LRZ+4hFcrKryhELg9aI7MkC895Mu1RuXPnDvLz89GgQQOT9xs0aIDk5OQS23t4eMDJycn4cnFxAQDMnz8f8+bNQ25urnHSGjc3N9y4cQNr1qxB2r1U2NsCdjYKHCrZoBIMcLSzLfavDexsDHCoZAN7WwX2toBDJaCybT66NqpsctysrCx4enoiNjYWW7duRVBQEI4dOwZvb28kJSWZbJufnw8PDw9cvXoVGzZsQGhoKIKDg+Hj44O4uDjMnz8fOTk5JvskJydj9erVCAsLQ0BAAL744gucPXsWixcvRnp6usm2aWlpWLJkCaKjo7Fjxw7s3bsX4eHhWLVqFVJSUky2zc7OhqenJ+Li4uDr64uDBw/i6NGjWL9+PRITE+Hu7g6DwQA3NzcYDAa4u7sjMTER69evx9GjR3Hw4EH4+voiLi4Onp6eyM7ONjl+SkoKVq1ahfDwcOzduxc7duxAdHQ0lixZgrS0NJNt09PTsXjxYsyYMQPbt29HQEAAwsLCsHr1aiQnJ5tsm5OTg/nz5yMuLg4+Pj4IDg5GaGgoNmzYgKtXr8LDwwP5+fkm+yQlJcHb2xvHjh1DUFAQtm7ditjYWHh6eiIrK8tk29u3b2PlypWIiIjAnj174O/vj6ioKCxduhSpqakm22ZkZGDRokWIiYmBn58f9u/fj7CwMKxZswY3btww2TY3Nxdvv/02Ll++jC1btiA4OBhHjhzBxo0bceXKFcyZMwePHj0y2efatWvw8vLCiRMnEBgYiG3btuHChQtYsGABMjMzTba9c+cOVqxYgcjISOzevRu7du1CZGQkli9fjrt375pse//+fSxcuBAxMTH466+/8Pfff+PkyZNYu3ZtCd15eXmYO3cu4uPjsWnTJoSEhCAkJASbNm1CfHw85s6di7y8PLz55psA6E24WBZq6w2g7LojPj6+zLpjy+YtsLeFWXVHXfuHyL97Ff7+/tizZw8iIiKwcuVK3L592+S4Cxcu1LTu2L59u6w7dFp3zJs3T9O648cff9Ss7lA7uRzTKfRv3LiBxo0b49ixY+jVq5fx/f/+9784fPgwTp48abJ9ad+KXFxcdDV1t0QiGlpPoa+23gBk3SGR8IZuptCvW7cuKlWqVOLx4pSUFDRs2LDE9o6OjqhZs6bJC9D+G53W8Dy1cUUR2Rsgtj9W3tTWG0DZdYfWiFwetEZmSRae82TaUHFwcEDXrl0RFBRkfM9gMCAoKMjkm1J5TJo0iYY8bpg6dSprCdQQ2Rsgtj9W3kjVGywQuTxojcySLDznyfypn6+//hqrV6/GunXrcP78eXz22Wd48OABJkyYYPYxNm/eTFEhe7y9vVlLoIbI3gCx/bH0RqLeYIHI5UFrZJZk4TlPpk/9AMDYsWNx+/Zt/PTTT0hOTkbnzp0REBBQYqDckxgwYAA9gRwwePBg1hKoIbI3QGx/LL2RqDdYIHJ50BqZJVl4zpN5jwoAfPHFF7h69Spyc3Nx8uRJ9OzZU9X+Fy9epKSMDy5cuMBaAjVE9gaI7Y+1t4rWGyxgnZlIyCzJwnOeXDRUKkrVqlVZS6BKtWrVWEughsjeALH9ieyNFjIzcsgsycJznkI0VJydnVlLoErt2rVZS6CGyN4Asf2J7I0WMjNyyCzJwnOeQjRUzp07x1oCVaKiolhLoIbI3gCx/YnsjRYyM3LILMnCc55CNFSGDBnCWgJVhg0bxloCNUT2BojtT2RvtJCZkUNmSRae8xSiobJhwwbWEqhCcqE13hDZGyC2P5G90UJmRg6ZJVl4zpPpFPoVReupuyUSSUn0+DnUo2aJRCR0M4U+KeQU+vpFZG+A2P5E9kYLmRk5ZJZk4TlPIXpUbt26hXr16rGWQ43c3Fw4OjqylkEFkb0BYvsr8KbH3glWmkUuD1ojsySL1nlaXY/K8uXLWUugyu+//85aAjVE9gaI7U9kb7SQmZFDZkkWnvNkPoV+RSjoDBo4cCAyMjIYq6HHSy+9JKw/kb0BYvsr8FbgT0+dswVatb42IpcHrZFZkkXrPNXUG7puqNy/fx8A0LdvX8ZKJBLJ/fv34eTkxFqGWRTUHS4uLoyVSCTWjTn1hq7HqBgMBsTGxqJ9+/ZISkrSzf1xNWRkZMDFxUVIfyJ7A8T2V9RbjRo1cP/+fTz11FOwtdXH3WSDwYAbN26gRo0asLGx0eScIpcHrZFZkoVFnoqimF1v6LpHxdbWFo0bNwYA1KxZU+gCK7I/kb0BYvsr8KaXnpQCbG1t8fTTTzM5t8jlQWtklmTROk9z6w19fP2RSCQSiURilciGikQikUgkEm7RfUPF0dERM2bMEPZ5epH9iewNENufyN5oITMjh8ySLLznqevBtBKJRCKRSMRG9z0qEolEIpFIxEU2VCQSiUQikXCLbKhIJBKJRCLhFtlQkUgkEolEwi26bKi4u7ujd+/eqFq1KmrVqmXWPuPHj4eNjY3Ja+jQoXSFWogl/hRFwU8//YRGjRqhSpUqGDx4MOLi4ugKtYDU1FS8++67qFmzJmrVqoWJEyciMzPzifsMGDCgxLWbNGmSRoqfzNKlS9GsWTNUrlwZPXv2xKlTp564/bZt29C2bVtUrlwZnTp1wt69ezVSqh413ry9vUtco8qVK2uolg8sKd85OTmYPHky6tSpg+rVq+P1119HSkqKyTbFs7WxsYGPjw9NK5pD+rOklzqRBqSzZP73U9EhP/30k/Lbb78pX3/9teLk5GTWPuPGjVOGDh2q3Lx50/hKTU2lK9RCLPE3Z84cxcnJSdmxY4dy5swZZeTIkUrz5s2V7OxsumJVMnToUOW5555TTpw4oRw5ckRp1aqV8vbbbz9xn/79+ysff/yxybVLT0/XSHHZ+Pj4KA4ODsratWuVc+fOKR9//LFSq1YtJSUlpdTtjx49qlSqVEmZN2+eEhMTo/zwww+Kvb29Eh0drbHy8lHrzcvLS6lZs6bJNUpOTtZYNXssKd+TJk1SXFxclKCgIOX06dPK888/r/Tu3dtkGwCKl5eXSb68fbYrAo3Pkl7qRNLQyJL1309dNlQK8PLyUtVQGTVqFFU9pDHXn8FgUBo2bKjMnz/f+F5aWpri6OiobNmyhaJCdcTExCgAlLCwMON7+/btU2xsbJTr16+XuV///v2VL7/8UgOF6ujRo4cyefJk48/5+fnKU089pXh4eJS6/Ztvvqm88sorJu/17NlT+fTTT6nqtAS13tR8FkXFkvKdlpam2NvbK9u2bTO+d/78eQWAcvz4ceN7AJTt27dT084a0p8lvdSJNKBRL7H++6nLWz+WEhwcjPr166NNmzb47LPPcPfuXdaSiJCQkIDk5GQMHjzY+J6TkxN69uyJ48ePM1RmyvHjx1GrVi1069bN+N7gwYNha2uLkydPPnHfTZs2oW7duujYsSO+++47ZGVl0Zb7RB4+fIjw8HCTzG1tbTF48OAyMz9+/LjJ9gDw8ssvc3WNAMu8AUBmZiaaNm0KFxcXjBo1CufOndNCLjdYUr7Dw8ORl5dnknXbtm3RpEmTEllPnjwZdevWRY8ePbB27VoogkyBReOzpJc6kTQ06yWWfz91vSihGoYOHYrXXnsNzZs3x+XLl/H9999j2LBhOH78OCpVqsRaXoVITk4GADRo0MDk/QYNGhh/xwPJycmoX7++yXt2dnaoXbv2E3W+8847aNq0KZ566ilERUVh+vTpiI2NhZ+fH23JZXLnzh3k5+eXmvmFCxdK3Sc5OZn7awRY5q1NmzZYu3Ytnn32WaSnp+PXX39F7969ce7cOWaL/2mNJeU7OTkZDg4OJcaiFS8Xs2bNwsCBA1G1alX8/fff+Pzzz5GZmYmpU6cS96E1ND5LeqkTSUOrXmL995Obhsq3336LuXPnPnGb8+fPo23bthYd/6233jL+v1OnTnj22WfRsmVLBAcHY9CgQRYdUw20/bHEXG+W8sknnxj/36lTJzRq1AiDBg3C5cuX0bJlS4uPKyFHr1690KtXL+PPvXv3Rrt27bBy5UrMnj2bobKKQ7t8m8OPP/5o/H+XLl3w4MEDzJ8/X4iGioR/WP/95KahMm3aNIwfP/6J27Ro0YLY+Vq0aIG6devi0qVLmgRN01/Dhg0BACkpKWjUqJHx/ZSUFHTu3NmiY6rBXG8NGzbErVu3TN5/9OgRUlNTjR7MoWfPngCAS5cuMWuo1K1bF5UqVSrxdEZKSkqZXho2bKhqe1ZY4q049vb26NKlCy5dukRDoqbQLN8NGzbEw4cPkZaWZtKrUl7WPXv2xOzZs5Gbm8vt+izmQuOzxLpOZIVW9ZLWfz+5GaNSr149tG3b9okvBwcHYue7du0a7t69a1KIaULTX/PmzdGwYUMEBQUZ38vIyMDJkydNvuXSwlxvvXr1QlpaGsLDw437Hjx4EAaDwdj4MIfIyEgA0OzalYaDgwO6du1qkrnBYEBQUFCZmffq1ctkewAIDAzU5BqpwRJvxcnPz0d0dDTTa0QKmuW7a9eusLe3N8k6NjYWiYmJT8w6MjISzs7Oum+kAHQ+S6zrRFZoVS9p/fdTl0/9XL16Vfnnn3+Un3/+Walevbryzz//KP/8849y//594zZt2rRR/Pz8FEVRlPv37yv/+c9/lOPHjysJCQnKgQMHFFdXV+WZZ55RcnJyWNkoE7X+FOXxo3i1atVSdu7cqURFRSmjRo3i8lG8oUOHKl26dFFOnjyphIaGKs8884zJ45vXrl1T2rRpo5w8eVJRFEW5dOmSMmvWLOX06dNKQkKCsnPnTqVFixZKv379WFkw4uPjozg6Oire3t5KTEyM8sknnyi1atUyPpb7/vvvK99++61x+6NHjyp2dnbKr7/+qpw/f16ZMWMG148nq/H2888/K/v371cuX76shIeHK2+99ZZSuXJl5dy5c6wsMEFt+VaUx48nN2nSRDl48KBy+vRppVevXkqvXr2Mv/f391dWr16tREdHK3FxccqyZcuUqlWrKj/99JOm3mhC47OklzqRNKSz5OHvpy4bKuPGjVMAlHgdOnTIuA3+N++AoihKVlaW8tJLLyn16tVT7O3tlaZNmyoff/wxt/M8qPWnKI8fx/vxxx+VBg0aKI6OjsqgQYOU2NhY7cWXw927d5W3335bqV69ulKzZk1lwoQJJg2whIQEE6+JiYlKv379lNq1ayuOjo5Kq1atlG+++YaLeVQURVEWL16sNGnSRHFwcFB69OihnDhxwvi7/v37K+PGjTPZfuvWrUrr1q0VBwcHpUOHDsqePXs0Vmw+arx99dVXxm0bNGigDB8+XImIiGCgmi1qy7eiKEp2drby+eefK87OzkrVqlWVMWPGKDdv3jT+ft++fUrnzp2V6tWrK9WqVVOee+45ZcWKFUp+fr6W1qhD+rOklzqRBiSz5OHvp42iCPKMm0QikUgkEuHgZoyKRCKRSCQSSXFkQ0UikUgkEgm3yIaKRCKRSCQSbpENFYlEIpFIJNwiGyoSiUQikUi4RTZUJBKJRCKRcItsqEgkEolEIuEW2VCRSCQSiUTCLbKhItGc4OBg2NjYIC0t7YnbNWvWDAsXLtREk0Qi4QPSn3tZj+gf2VCRlMn48eNhY2MDGxsbODg4oFWrVpg1axYePXpUoeP27t0bN2/ehJOTEwDA29vbZOXYAsLCwvDJJ59U6FwSiUQ7RowYgaFDh5b6uyNHjsDGxgZRUVGaaipej9jY2GDHjh2aapBUDNlQkTyRoUOH4ubNm4iLi8O0adMwc+ZMzJ8/v0LHdHBwQMOGDWFjY/PE7erVq4eqVatW6FwSiUQ7Jk6ciMDAQFy7dq3E77y8vNCtWzc8++yzmmqS9Yj+kQ0VyRNxdHREw4YN0bRpU3z22WcYPHgw/P39ce/ePXzwwQdwdnZG1apVMWzYMMTFxRn3u3r1KkaMGAFnZ2dUq1YNHTp0wN69ewGY3voJDg7GhAkTkJ6ebuy9mTlzJoCSXbaJiYkYNWoUqlevjpo1a+LNN99ESkqK8fczZ85E586dsWHDBjRr1gxOTk546623cP/+fU2ykkisnVdffRX16tWDt7e3yfuZmZnYtm0bJk6ciNDQUPTt2xdVqlSBi4sLpk6digcPHpR5zPI+9wCwa9cudO/eHZUrV0bdunUxZswY4++K1iPNmjUDAIwZMwY2NjZo1qwZrly5AltbW5w+fdrkmAsXLkTTpk1hMBgsD0RCBNlQkaiiSpUqePjwIcaPH4/Tp0/D398fx48fh6IoGD58OPLy8gAAkydPRm5uLkJCQhAdHY25c+eievXqJY7Xu3dvLFy4EDVr1sTNmzdx8+ZN/Oc//ymxncFgwKhRo5CamorDhw8jMDAQ8fHxGDt2rMl2ly9fxo4dO7B7927s3r0bhw8fxpw5c+iEIZFITLCzs8MHH3wAb29vFF3vdtu2bcjPz0evXr0wdOhQvP7664iKioKvry9CQ0PxxRdflHo8cz73e/bswZgxYzB8+HD8888/CAoKQo8ePUo9XlhYGIDHvTs3b95EWFgYmjVrhsGDB8PLy8tkWy8vL4wfPx62tvLPJHM0W6dZojvGjRunjBo1SlGUx0umBwYGKo6Ojsro0aMVAMrRo0eN2965c0epUqWKsnXrVkVRFKVTp07KzJkzSz3uoUOHFADKvXv3FEVRFC8vL8XJyanEdk2bNlUWLFigKIqi/P3330qlSpWUxMRE4+/PnTunAFBOnTqlKIqizJgxQ6lataqSkZFh3Oabb75RevbsaWkEEolEJefPn1cAKIcOHTK+17dvX+W9995TJk6cqHzyyScm2x85ckSxtbVVsrOzFUVR/7nv1auX8u6775app+jxFEVRACjbt2832cbX11dxdnZWcnJyFEVRlPDwcMXGxkZJSEhQ6V5CA9lUlDyR3bt3o3r16qhcuTKGDRuGsWPHYvz48bCzs0PPnj2N29WpUwdt2rTB+fPnAQBTp06Fm5sbXnjhBcyYMaPCA+jOnz8PFxcXuLi4GN9r3749atWqZTwn8Lhrt0aNGsafGzVqhFu3blXo3BKJxHzatm2L3r17Y+3atQCAS5cu4ciRI5g4cSLOnDkDb29vVK9e3fh6+eWXYTAYkJCQUOJY5nzuIyMjMWjQoAppHj16NCpVqoTt27cDeDzA/8UXXzTeKpKwRTZUJE/kxRdfRGRkJOLi4pCdnY1169aVOwgWAD766CPEx8fj/fffR3R0NLp164bFixdT12tvb2/ys42NjbzHLJFozMSJE/HXX3/h/v378PLyQsuWLdG/f39kZmbi008/RWRkpPF15swZxMXFoWXLlhadq0qVKhXW6+DggA8++ABeXl54+PAhNm/ejA8//LDCx5WQQTZUJE+kWrVqaNWqFZo0aQI7OzsAQLt27fDo0SOcPHnSuN3du3cRGxuL9u3bG99zcXHBpEmT4Ofnh2nTpmH16tWlnsPBwQH5+flP1NGuXTskJSUhKSnJ+F5MTAzS0tJMzimRSNjz5ptvwtbWFps3b8b69evx4YcfwsbGBq6uroiJiUGrVq1KvBwcHEocx5zP/bPPPougoCCztdnb25da33z00Uc4cOAAli1bhkePHuG1116zwLmEBrKhIlHNM888g1GjRuHjjz9GaGgozpw5g/feew+NGzfGqFGjAABfffUV9u/fj4SEBERERODQoUNo165dqcdr1qwZMjMzERQUhDt37iArK6vENoMHD0anTp3w7rvvIiIiAqdOncIHH3yA/v37o1u3blT9SiQSdVSvXh1jx47Fd999h5s3b2L8+PEAgOnTp+PYsWP44osvjD21O3fuLHMwrTmf+xkzZmDLli2YMWMGzp8/bxy8XxbNmjVDUFAQkpOTce/ePeP77dq1w/PPP4/p06fj7bffJtJTIyGDbKhILMLLywtdu3bFq6++il69ekFRFOzdu9d46yU/Px+TJ09Gu3btMHToULRu3RrLli0r9Vi9e/fGpEmTMHbsWNSrVw/z5s0rsY2NjQ127twJZ2dn9OvXD4MHD0aLFi3g6+tL1adEIrGMiRMn4t69e3j55Zfx1FNPAXjc+3H48GFcvHgRffv2RZcuXfDTTz8Zf18ccz73AwYMwLZt2+Dv74/OnTtj4MCBOHXqVJm6PD09ERgYCBcXF3Tp0qWE5ocPH8rbPpxhoyhFniGTSCQSicRKmT17NrZt26b57LmSJyN7VCQSiURi1WRmZuLs2bNYsmQJpkyZwlqOpBiyoSKRSCQSq+aLL75A165dMWDAAHnbh0PkrR+JRCKRSCTcIntUJBKJRCKRcItsqEgkEolEIuEW2VCRSCQSiUTCLbKhIpFIJBKJhFtkQ0UikUgkEgm3yIaKRCKRSCQSbpENFYlEIpFIJNwiGyoSiUQikUi45f8B0EngFolUSjgAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "env = MountainCarPhysics()\n", + "agent = Agent(env)\n", + "\n", + "pos_min = np.amin(agent.pos_bins)\n", + "pos_max = np.amax(agent.pos_bins)\n", + "pos_range = np.linspace(pos_min - .1 * np.abs(pos_min),\n", + " pos_max + .1 * np.abs(pos_max),\n", + " 1000)\n", + "\n", + "pos_idx = np.nan * np.ones_like(pos_range)\n", + "for i in range(len(pos_range)):\n", + " pos_idx[i] = agent._get_discrete_state((pos_range[i], 0.))[0]\n", + "\n", + "vel_min = np.amin(agent.vel_bins)\n", + "vel_max = np.amax(agent.vel_bins)\n", + "vel_range = np.linspace(vel_min - .1 * np.abs(vel_min),\n", + " vel_max + .1 * np.abs(vel_max),\n", + " 1000)\n", + "\n", + "vel_idx = np.nan * np.ones_like(vel_range)\n", + "for i in range(len(vel_range)):\n", + " vel_idx[i] = agent._get_discrete_state((0, vel_range[i]))[1]\n", + " \n", + "fig, ax = plt.subplots(ncols = 2)\n", + "\n", + "ax[0].plot(pos_range, pos_idx)\n", + "ax[0].set_xlabel(r\"Position\")\n", + "ax[0].set_ylabel(r\"Position bin index\")\n", + "\n", + "ax[1].plot(vel_range, vel_idx)\n", + "ax[1].set_xlabel(r\"Velocity\")\n", + "ax[1].set_ylabel(r\"Velocity bin index\")\n", + "\n", + "for _ax in ax:\n", + " _ax.grid(True)" + ] + }, + { + "cell_type": "markdown", + "id": "ba2e6cd3", + "metadata": {}, + "source": [ + "## Non-spiking Agent\n", + "\n", + "The traditional, Q-learning agent improves its decision-making by updating a \"Q-table\", which stores Q-values representing the expected rewards for taking particular actions in given states." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "eb4dab99", + "metadata": {}, + "outputs": [], + "source": [ + "class NonSpikingAgent(Agent):\n", + " def __init__(self, env):\n", + " super().__init__(env)\n", + "\n", + " # Use defaultdict for Q-table for easier handling of unseen states\n", + " # Q[discrete_state_tuple][action] = value\n", + " self.q_table = defaultdict(lambda: [0.0, 0.0]) # 2 actions: left and right move\n", + "\n", + " def choose_action(self, discrete_state):\n", + " \"\"\"Chooses an action using p_explore-greedy policy.\"\"\"\n", + " if self.rng.random() < self.p_explore:\n", + " return self.rng.choice([AgentAction.LEFT, AgentAction.RIGHT]) # Explore: random action\n", + "\n", + " # Exploit: choose action with highest Q-value.\n", + " # Handle ties randomly.\n", + " q_values = self.q_table[discrete_state]\n", + " max_q = max(q_values)\n", + " best_actions = [action for action, q in zip(AgentAction, q_values) if q == max_q]\n", + "\n", + " return self.rng.choice(best_actions)\n", + "\n", + " def update_q_table(self, current_state, action, next_state, done):\n", + " \"\"\"Updates the Q-table using the Q-learning formula and reward shaping.\"\"\"\n", + " current_discrete_state = self._get_discrete_state(current_state)\n", + " next_discrete_state = self._get_discrete_state(next_state)\n", + "\n", + " # Calculate shaping reward\n", + " current_potential = self._potential(current_state)\n", + " next_potential = self._potential(next_state)\n", + " base_reward = -1.\n", + " total_reward = base_reward + self.discount_factor * next_potential - current_potential\n", + " \n", + " # Q-Learning Update\n", + " old_q_value = self.q_table[current_discrete_state][action.value]\n", + "\n", + " # Best Q-value for the next state (max_a' Q(s', a'))\n", + " # If terminal state (done), the value of the next state is 0\n", + " next_max_q = max(self.q_table[next_discrete_state]) if not done else 0.0\n", + "\n", + " if done:\n", + " failure = env.state[0] <= env.min_position\n", + " if failure:\n", + " total_reward = -10.\n", + " \n", + " # Q-update formula\n", + " new_q_value = old_q_value + self.learning_rate * (\n", + " total_reward + self.discount_factor * next_max_q - old_q_value\n", + " )\n", + "\n", + " self.q_table[current_discrete_state][action.value] = new_q_value\n", + " \n", + " # Return the total (shaped) reward for tracking purposes if needed\n", + " return total_reward" + ] + }, + { + "cell_type": "markdown", + "id": "2cd7786b", + "metadata": {}, + "source": [ + "\n", + "\n", + "Plot renderer:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "3f9b07a1", + "metadata": {}, + "outputs": [], + "source": [ + "class NonSpikingPlotRenderer:\n", + " def __init__(self, env, agent) -> None:\n", + " self.env = env\n", + " self.agent = agent\n", + " self.lifetime_fig, self.lifetime_ax = plt.subplots(nrows=4)\n", + " self.lifetime_ax[0].set_yscale('log')\n", + "\n", + " self.lifetime_log_line, = self.lifetime_ax[0].plot([], [])\n", + " self.reward_log_line, = self.lifetime_ax[1].plot([], [])\n", + " self.p_explore_log_line, = self.lifetime_ax[2].plot([], [])\n", + " self.learning_rate_log_line, = self.lifetime_ax[3].plot([], [])\n", + " self.lifetime_ax[0].set_ylabel(\"Steps per episode\")\n", + " self.lifetime_ax[1].set_ylabel(\"Reward per episode\")\n", + " self.lifetime_ax[2].set_ylabel(\"Exploration ratio\")\n", + " self.lifetime_ax[3].set_ylabel(\"Learning rate\")\n", + " self.lifetime_ax[-1].set_xlabel(\"Episode\")\n", + "\n", + " def update(self, episode_idx, lifetime_log, reward_log, p_explore_log, learning_rate_log) -> None:\n", + " if lifetime_log:\n", + " max_lifetime = np.amax(lifetime_log)\n", + " self.lifetime_log_line.set_data(episode_idx, lifetime_log)\n", + " self.lifetime_ax[0].set_xlim(episode_idx[0], episode_idx[-1])\n", + " self.lifetime_ax[0].set_ylim(0, 1.1 * max_lifetime)\n", + "\n", + " if reward_log:\n", + " self.reward_log_line.set_data(episode_idx, reward_log)\n", + " self.lifetime_ax[1].set_xlim(episode_idx[0], episode_idx[-1])\n", + " self.lifetime_ax[1].set_ylim(np.amin(reward_log), np.amax(reward_log))\n", + "\n", + " if p_explore_log:\n", + " self.p_explore_log_line.set_data(episode_idx, p_explore_log)\n", + " self.lifetime_ax[2].set_xlim(episode_idx[0], episode_idx[-1])\n", + " self.lifetime_ax[2].set_ylim(np.amin(p_explore_log), np.amax(p_explore_log))\n", + "\n", + " if learning_rate_log:\n", + " self.learning_rate_log_line.set_data(episode_idx, learning_rate_log)\n", + " self.lifetime_ax[3].set_xlim(episode_idx[0], episode_idx[-1])\n", + " self.lifetime_ax[3].set_ylim(np.amin(learning_rate_log), np.amax(learning_rate_log))\n", + "\n", + " for _ax in self.lifetime_ax:\n", + " if not _ax == self.lifetime_ax[-1]:\n", + " _ax.set_xticklabels([])\n", + "\n", + " self.lifetime_fig.canvas.draw()\n", + " self.lifetime_fig.canvas.flush_events()\n", + " self.lifetime_fig.savefig(\"/tmp/mountain_car_lifetime_nonspiking.png\", dpi=300)\n", + "\n", + " \n", + " def update_q_table_heatmap(self):\n", + " r\"\"\"\n", + " Construct heatmap for two parameters\n", + " \"\"\"\n", + " left_q_table_matrix = np.empty((self.agent.NUM_POS_BINS, self.agent.NUM_VEL_BINS))\n", + " right_q_table_matrix = np.empty((self.agent.NUM_POS_BINS, self.agent.NUM_VEL_BINS))\n", + " for pos_bin in range(self.agent.NUM_POS_BINS):\n", + " for vel_bin in range(self.agent.NUM_VEL_BINS):\n", + " left_q_table_matrix[pos_bin, vel_bin] = self.agent.q_table[(pos_bin, vel_bin)][AgentAction.LEFT.value]\n", + " right_q_table_matrix[pos_bin, vel_bin] = self.agent.q_table[(pos_bin, vel_bin)][AgentAction.RIGHT.value]\n", + " \n", + " # Determine the overall min and max from all datasets.\n", + " global_min = min(left_q_table_matrix.min(), right_q_table_matrix.min())\n", + " global_max = max(left_q_table_matrix.max(), right_q_table_matrix.max())\n", + "\n", + " # Use symmetric limits so that zero is centered.\n", + " limit = max(abs(global_min), abs(global_max))\n", + "\n", + " # Create a normalization instance that forces 0 to be the center.\n", + " norm = mpl.colors.TwoSlopeNorm(vmin=-limit, vcenter=0, vmax=limit)\n", + " \n", + " fig, ax = plt.subplots(nrows=3, figsize=(12, 12))\n", + "\n", + " im1 = ax[0].imshow(left_q_table_matrix, cmap=plt.cm.coolwarm, norm=norm, interpolation='none')\n", + " ax[0].set_title(\"Q value L\")\n", + " im2 = ax[1].imshow(right_q_table_matrix, cmap=plt.cm.coolwarm, norm=norm, interpolation='none')\n", + " ax[1].set_title(\"Q value R\")\n", + " im2 = ax[2].imshow(10*(left_q_table_matrix - right_q_table_matrix), cmap=plt.cm.coolwarm, norm=norm, interpolation='none')\n", + " ax[2].set_title(\"Q value L - R (x10)\")\n", + "\n", + " for _ax in ax:\n", + " _ax.set_xlabel(r\"pos\")\n", + " _ax.set_ylabel(r\"vel\")\n", + "\n", + " fig.colorbar(im1, ax=ax.ravel().tolist())\n", + " fig.savefig(\"/tmp/mountain_car_q_table.png\", dpi=300)\n", + "\n", + " plt.close(fig)" + ] + }, + { + "cell_type": "markdown", + "id": "5bf590a3", + "metadata": {}, + "source": [ + "\n", + "\n", + "Executing Non-Spiking-Agent:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "717eda26-e385-494f-bdca-9847eefe01ca", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_22525/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode: 100/1500, Reward: -505.10, Avg Reward (Last 100): -506.48, p_explore: 0.4954\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_22525/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode: 200/1500, Reward: -506.81, Avg Reward (Last 100): -495.45, p_explore: 0.2454\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_22525/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode: 300/1500, Reward: -253.51, Avg Reward (Last 100): -442.25, p_explore: 0.1216\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_22525/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode: 400/1500, Reward: -394.97, Avg Reward (Last 100): -397.30, p_explore: 0.0602\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_22525/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode: 500/1500, Reward: -427.03, Avg Reward (Last 100): -384.39, p_explore: 0.0298\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_22525/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode: 600/1500, Reward: -241.11, Avg Reward (Last 100): -351.91, p_explore: 0.0148\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_22525/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode: 700/1500, Reward: -244.31, Avg Reward (Last 100): -314.58, p_explore: 0.0000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_22525/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode: 800/1500, Reward: -415.52, Avg Reward (Last 100): -308.01, p_explore: 0.0000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_22525/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode: 900/1500, Reward: -325.94, Avg Reward (Last 100): -300.50, p_explore: 0.0000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_22525/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode: 1000/1500, Reward: -259.44, Avg Reward (Last 100): -292.67, p_explore: 0.0000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_22525/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode: 1100/1500, Reward: -311.12, Avg Reward (Last 100): -293.76, p_explore: 0.0000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_22525/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode: 1200/1500, Reward: -282.93, Avg Reward (Last 100): -273.56, p_explore: 0.0000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_22525/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode: 1300/1500, Reward: -275.19, Avg Reward (Last 100): -269.94, p_explore: 0.0000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_22525/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode: 1400/1500, Reward: -275.96, Avg Reward (Last 100): -271.74, p_explore: 0.0000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_22525/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode: 1500/1500, Reward: -276.24, Avg Reward (Last 100): -269.29, p_explore: 0.0000\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "env = MountainCarPhysics()\n", + "agent = NonSpikingAgent(env)\n", + "r = MountainCarRenderer(env, agent)\n", + "r._init_render()\n", + "plot = NonSpikingPlotRenderer(env, agent)\n", + "\n", + "episode: int = 0\n", + "episode_idx: List[int] = [] # log of number of steps achieved for each episode\n", + "steps_per_episode: List[int] = [] # log of number of steps achieved for each episode\n", + "learning_rate_log: List[int] = []\n", + "p_explore_log: List[int] = []\n", + "rewards_per_episode: List[int] = [] # log of total reward achieved in each episode\n", + "\n", + "max_n_episodes: int = 1500\n", + "max_steps_per_episode: int = 500 # maximum allowed number of steps per episode\n", + "\n", + "plot_this_episode = True\n", + "plot_sim = False\n", + "failure = False\n", + "\n", + "render_active = True # Flag to control rendering loop\n", + "\n", + "for episode in range(max_n_episodes):\n", + " done = False\n", + "\n", + " current_state = env.reset()\n", + " episode_total_reward = 0\n", + "\n", + " render_this_episode = (episode + 1) % 200 == 0\n", + " plot_this_episode = (episode + 1) % 100 == 0\n", + "\n", + " for step in range(max_steps_per_episode):\n", + " # poll for events\n", + " for event in pygame.event.get():\n", + " if event.type == pygame.QUIT:\n", + " pygame.quit()\n", + " sys.exit()\n", + " elif event.type == pygame.KEYDOWN:\n", + " plot_sim ^= pygame.key.get_pressed()[pygame.K_SPACE]\n", + " \n", + " discrete_state = agent._get_discrete_state(current_state)\n", + " action = agent.choose_action(discrete_state)\n", + " next_state, done = env.step(action)\n", + "\n", + " # Update Q-table and get the total (shaped) reward for this step\n", + " step_reward = agent.update_q_table(current_state, action, next_state, done)\n", + " episode_total_reward += step_reward\n", + "\n", + " current_state = next_state\n", + "\n", + " # Render if requested and active\n", + " if render_this_episode and render_active:\n", + " r.render(episode, step + 1, episode_total_reward)\n", + "\n", + " if done:\n", + " break # End episode\n", + "\n", + " if plot_this_episode:\n", + " plot.update(episode_idx, steps_per_episode, rewards_per_episode, p_explore_log, learning_rate_log)\n", + " plot.update_q_table_heatmap()\n", + "\n", + " steps_per_episode.append(step)\n", + " episode_idx.append(episode)\n", + " p_explore_log.append(agent.p_explore)\n", + " learning_rate_log.append(agent.learning_rate)\n", + " rewards_per_episode.append(episode_total_reward)\n", + "\n", + " agent.decay_p_explore()\n", + " agent.decay_learning_rate()\n", + "\n", + " if (episode + 1) % 100 == 0:\n", + " avg_reward = sum(rewards_per_episode[-100:]) / 100\n", + " print(f\"Episode: {episode + 1}/{max_n_episodes}, \"\n", + " f\"Reward: {episode_total_reward:.2f}, \"\n", + " f\"Avg Reward (Last 100): {avg_reward:.2f}, \"\n", + " f\"p_explore: {agent.p_explore:.4f}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "7add07c7", + "metadata": {}, + "source": [ + "Task: Make a plot of how much the Q-values changed from before training to after training. Are there certain states that never get updated (that is, is the state space (configuration space) adequately explored)?" + ] + }, + { + "cell_type": "markdown", + "id": "43c70dff", + "metadata": {}, + "source": [ + "# Spiking version" + ] + }, + { + "cell_type": "markdown", + "id": "6df6e192", + "metadata": {}, + "source": [ + "The core principle of our SNN is to simulate the physics and neuron model in sequence, where the state at the end of a physics step is the input for the SNN and the resulting action at the end of a period of SNN simulation is the input to the next physics simulation. Both cycles are set to 25 ms (``SpikingAgent.cycle_period``), a value that is short compared to the typical dynamical timescales in the system, to provide the effect that SNN and physics run simultaneously. \n", + "\n", + "The SNN model's structure consists of two layers of neurons. For each discrete state of the system, the input layer contains a single neuron encoding it. This is also known as a \"one-hot\" encoding, because only one input neuron is ever active at any one time. (Note that the computational complexity of this is polynomial in the number of input dimensions—here, position and velocity—and is thus infeasible for more complex systems.) Neuromodulated synapses connect the input layer to the output layer, the latter consisting of two neuron groups which encode the actions \"move left\" and \"move right\".\n", + "\n", + "The main loop looks like this: for every iteration of the loop (for every \"cycle\" or \"step\"):\n", + "\n", + "- Simulate neural network: \n", + " - Set the rate of the input neurons to the current state of the environment: get the current state of the mountain car and find the corresponding neuron that only fires when that state is reached; set a nonzero spike rate for that neuron and zero for all the others;\n", + " - Run the SNN with this input state for a period of time (cycle time, here chosen as 25 ms)\n", + " - (The weight trace ``wtr`` is computed in each synapse;)\n", + "- An action is selected based on output neuron firing, by counting the number of spikes in the output populations over this cycle period;\n", + "- The environment is updated based on action; run the environment for the same cycle time (25 ms) to obtain next state;\n", + "- Reward is computed (neuromodulator signal is proportional to TD);\n", + "- Synapses that were active (between input and output neurons) have their weights updated (based on ``wtr * TD``)\n", + "- Weight trace (``wtr``) of all synapses is reset back to 0.\n", + "\n", + "The TD (temporal difference) signal can be interpreted as follows:\n", + "\n", + "- Positive TD signal: The outcome was better than expected → increase value estimate\n", + "- Negative TD signal: The outcome was worse than expected → decrease value estimate\n", + "- Zero TD signal: Perfect prediction → no learning needed\n", + "\n", + "In the neuromoduled STDP synapse model, the magnitude of the weight change is larger for pre- and postsynaptic spikes that occur closer together in time. However, in this particular STDP model, there is only a potentiation component and no depression component. This reduces the STDP synapse to a rate-based rule that potentiates more for higher firing rates. For a detailed analysis of the synapse, please see the section \"Mechanistic explanation\" below." + ] + }, + { + "cell_type": "markdown", + "id": "8dc47382", + "metadata": {}, + "source": [ + "\n", + "## NESTML models\n", + "\n", + "Neurons in the input layer will simply be spike generators (called ``ignore_and_fire``) that will fire spikes periodically with a given interval.\n", + "\n", + "The neuron model used for the output layer will be a leaky integrate-and-fire model with postsynaptic currents in the form of a decaying exponential (called ``iaf_psc_exp``).\n", + "\n", + "Input layer neurons are connected to the output layer neurons through the neuromodulated STDP synapse called ``neuromodulated_stdp_synapse``.\n", + "\n", + "The models are defined in ``.nestml`` files in the same directory as the tutorial notebook. We will now generate \"user extension module\" code for these models, so that they can be instantiated in NEST Simulator." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "8e16ea83", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " -- N E S T --\n", + " Copyright (C) 2004 The NEST Initiative\n", + "\n", + " Version: 3.8.0-post0.dev0\n", + " Built: Jun 2 2025 16:24:58\n", + "\n", + " This program is provided AS IS and comes with\n", + " NO WARRANTY. See the file LICENSE for details.\n", + "\n", + " Problems or suggestions?\n", + " Visit https://www.nest-simulator.org\n", + "\n", + " Type 'nest.help()' to find out more about NEST.\n", + "\n", + "[12,ignore_and_fire_neuron_nestml, WARNING, [54:34;54:58]]: Model contains a call to fixed-timestep functions (``resolution()`` and/or ``steps()``). This restricts the model to being compatible only with fixed-timestep simulators. Consider eliminating ``resolution()`` and ``steps()`` from the model, and using ``timestep()`` instead.\n", + "\n", + " -- N E S T --\n", + " Copyright (C) 2004 The NEST Initiative\n", + "\n", + " Version: 3.8.0-post0.dev0\n", + " Built: Jun 2 2025 16:24:58\n", + "\n", + " This program is provided AS IS and comes with\n", + " NO WARRANTY. See the file LICENSE for details.\n", + "\n", + " Problems or suggestions?\n", + " Visit https://www.nest-simulator.org\n", + "\n", + " Type 'nest.help()' to find out more about NEST.\n", + "\n", + "[18,iaf_psc_exp_neuron_nestml, WARNING, [40:8;40:17]]: Variable 's' has the same name as a physical unit!\n", + "[19,iaf_psc_exp_neuron_nestml, WARNING, [26:16;26:42]]: Implicit casting from (compatible) type 'mV' to 'real'.\n", + "[20,iaf_psc_exp_neuron_nestml, WARNING, [26:16;26:48]]: Implicit casting from (compatible) type 'mV' to 'real buffer'.\n", + "[21,neuromodulated_stdp_synapse_nestml, WARNING, [15:8;15:17]]: Variable 'd' has the same name as a physical unit!\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:Not preserving expression for variable \"g_e\" as it is solved by propagator solver\n", + "WARNING:Not preserving expression for variable \"g_e\" as it is solved by propagator solver\n", + "WARNING:Not preserving expression for variable \"post_trace__for_neuromodulated_stdp_synapse_nestml\" as it is solved by propagator solver\n", + "WARNING:Not preserving expression for variable \"pre_trace\" as it is solved by propagator solver\n", + "WARNING:Not preserving expression for variable \"wtr\" as it is solved by propagator solver\n" + ] + } + ], + "source": [ + "from pynestml.codegeneration.nest_code_generator_utils import NESTCodeGeneratorUtils\n", + "\n", + "input_layer_module_name, input_layer_neuron_model_name = \\\n", + " NESTCodeGeneratorUtils.generate_code_for(\"../../../models/neurons/ignore_and_fire_neuron.nestml\")\n", + "\n", + "output_layer_module_name, output_layer_neuron_model_name, output_layer_synapse_model_name = \\\n", + " NESTCodeGeneratorUtils.generate_code_for(\"iaf_psc_exp_neuron.nestml\",\n", + " \"neuromodulated_stdp_synapse.nestml\",\n", + " post_ports=[\"post_spikes\"],\n", + " logging_level=\"WARNING\",\n", + " codegen_opts={\"delay_variable\": {\"neuromodulated_stdp_synapse\": \"d\"},\n", + " \"weight_variable\": {\"neuromodulated_stdp_synapse\": \"w\"}})" + ] + }, + { + "cell_type": "markdown", + "id": "a0e71ff5", + "metadata": {}, + "source": [ + "## The spiking neural agent\n", + "\n", + "First, we define some helper functions for the visualisation of the network:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "83e05060", + "metadata": {}, + "outputs": [], + "source": [ + "def create_weight_matrix(connections):\n", + " \"\"\"\n", + " Create a weight matrix from NEST connections.\n", + " \n", + " Parameters:\n", + " -----------\n", + " connections : nest.NodeCollection\n", + " Connection object obtained from nest.GetConnections()\n", + " \n", + " Returns:\n", + " --------\n", + " weight_matrix : numpy.ndarray\n", + " Matrix of shape (n_pre, n_post) containing connection weights\n", + " \"\"\"\n", + " # Get connection properties\n", + " conn_info = connections.get([\"source\", \"target\", \"weight\"])\n", + " \n", + " # Extract source, target, and weight arrays\n", + " sources = np.array(conn_info[\"source\"])\n", + " targets = np.array(conn_info[\"target\"])\n", + " weights = np.array(conn_info[\"weight\"])\n", + " \n", + " # Get unique pre and post neuron IDs\n", + " pre_neurons = np.unique(sources)\n", + " post_neurons = np.unique(targets)\n", + " \n", + " # Create a mapping from neuron IDs to matrix indices\n", + " pre_map = {neuron: i for i, neuron in enumerate(pre_neurons)}\n", + " post_map = {neuron: i for i, neuron in enumerate(post_neurons)}\n", + " \n", + " # Initialize weight matrix with zeros\n", + " n_pre = len(pre_neurons)\n", + " n_post = len(post_neurons)\n", + " weight_matrix = np.zeros((n_pre, n_post))\n", + " \n", + " # Fill the weight matrix\n", + " for src, tgt, w in zip(sources, targets, weights):\n", + " pre_idx = pre_map[src]\n", + " post_idx = post_map[tgt]\n", + " weight_matrix[pre_idx, post_idx] = w\n", + " \n", + " return weight_matrix, pre_neurons, post_neurons" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "e9bdcc5a", + "metadata": {}, + "outputs": [], + "source": [ + "class SpikingPlotRenderer:\n", + " def __init__(self, env, agent) -> None:\n", + " self.env = env\n", + " self.agent = agent\n", + "\n", + " self.fig, self.ax = plt.subplots(nrows=7, figsize=(12, 10))\n", + " \n", + " # Construct lifetime plot\n", + " self.lifetime_fig, self.lifetime_ax = plt.subplots(nrows=2)\n", + " self.lifetime_line, = self.lifetime_ax[0].plot([0,1], [0,1])\n", + " self.total_reward_per_episode_line, = self.lifetime_ax[1].plot([0,1], [0,1])\n", + " self.lifetime_ax[0].set_ylabel(\"Steps per episode\")\n", + " self.lifetime_ax[1].set_ylabel(\"Reward per episode\")\n", + " self.lifetime_ax[-1].set_xlabel(\"Episode\")\n", + "\n", + " def update(self, data) -> None:\n", + " if data is None:\n", + " return\n", + " \n", + " self.ax[0].cla()\n", + " self.ax[1].cla()\n", + " self.ax[2].cla()\n", + " self.ax[3].cla()\n", + " self.ax[4].cla()\n", + " self.ax[5].cla()\n", + "\n", + " # Top plot for spikes\n", + " self.ax[0].set_ylabel(\"Input Neuron\")\n", + " self.ax[0].set_ylim(0, data[\"n_input_neurons\"])\n", + " self.ax[0].plot(data[\"input_spikes\"][\"times\"], data[\"input_spikes\"][\"senders\"], \".k\", markersize=5)\n", + " \n", + " for neuron_id in np.unique(data[\"multimeter_left_events\"][\"senders\"]):\n", + " idx = np.where(data[\"multimeter_left_events\"][\"senders\"] == neuron_id)[0]\n", + " neuron_times = data[\"multimeter_left_events\"][\"times\"][idx]\n", + " neuron_V_m = data[\"multimeter_left_events\"][\"V_m\"][idx]\n", + " self.ax[1].plot(neuron_times, neuron_V_m, c=\"b\")\n", + "\n", + " for neuron_id in np.unique(data[\"multimeter_right_events\"][\"senders\"]):\n", + " idx = np.where(data[\"multimeter_right_events\"][\"senders\"] == neuron_id)[0]\n", + " neuron_times = data[\"multimeter_right_events\"][\"times\"][idx]\n", + " neuron_V_m = data[\"multimeter_right_events\"][\"V_m\"][idx]\n", + " self.ax[1].plot(neuron_times, neuron_V_m, c=\"r\")\n", + " \n", + " self.ax[1].set_ylabel(\"V_m [mV]\")\n", + " \n", + " self.ax[2].plot(data[\"model_time_log\"], data[\"n_events_in_last_interval_left_log\"], label=\"left\")\n", + " self.ax[2].plot(data[\"model_time_log\"], data[\"n_events_in_last_interval_right_log\"], label=\"right\")\n", + " self.ax[2].legend()\n", + " self.ax[2].set_ylabel(\"Output Neuron\\nfiring rate\")\n", + " \n", + " self.ax[3].plot(data[\"model_time_log\"], [action.value for action in data[\"action_taken\"]], \"k\")\n", + " self.ax[3].set_ylabel(\"Action taken\")\n", + " self.ax[3].set_yticks([AgentAction.LEFT.value, AgentAction.RIGHT.value])\n", + " self.ax[3].set_yticklabels([\"LEFT\", \"RIGHT\"])\n", + " \n", + " self.ax[4].plot(data[\"model_time_log\"], data[\"p_explore_log\"], \"k\")\n", + " self.ax[4].set_ylabel(\"$p_\\mathrm{explore}$\")\n", + " self.ax[4].set_ylim(0, 1)\n", + " \n", + " self.ax[5].plot(data[\"model_time_log\"], data[\"learning_rate_log\"], \"k\")\n", + " self.ax[5].set_ylabel(\"Learning rate\")\n", + " self.ax[5].set_ylim(0, np.amax(data[\"learning_rate_log\"]))\n", + " \n", + " self.ax[6].plot(data[\"model_time_log\"], data[\"episode_number_detailed_log\"], \"k\")\n", + " self.ax[-1].set_ylabel(\"Episode\")\n", + " \n", + " for _ax in self.ax:\n", + " try:\n", + " _ax.set_xlim(np.min(data[\"multimeter_right_events\"][\"times\"]), np.max(data[\"multimeter_right_events\"][\"times\"]))\n", + " except:\n", + " pass\n", + " if not _ax == self.ax[-1]:\n", + " _ax.set_xticklabels([])\n", + " \n", + " self.ax[-1].set_xlabel(\"Time [ms]\")\n", + "\n", + " # ---------------\n", + "\n", + " max_lifetime = np.amax(np.array(data[\"steps_per_episode_log\"]) * data[\"episode_duration\"])\n", + " self.lifetime_line.set_data(data[\"episode_number_log\"], np.array(data[\"steps_per_episode_log\"]) * data[\"episode_duration\"])\n", + " self.total_reward_per_episode_line.set_data(data[\"episode_number_log\"], np.array(data[\"total_reward_per_episode\"]))\n", + " for _ax in self.lifetime_ax:\n", + " _ax.set_xlim(data[\"episode_number_log\"][0], data[\"episode_number_log\"][-1])\n", + "\n", + " if np.amax(data[\"total_reward_per_episode\"]) != np.amin(data[\"total_reward_per_episode\"]):\n", + " self.lifetime_ax[1].set_ylim(np.amin(data[\"total_reward_per_episode\"]), np.amax(data[\"total_reward_per_episode\"]))\n", + " self.lifetime_ax[0].set_ylim(-1E-9, 1.1*max_lifetime) # the 1E-9 trick is to prevent setting ylim equal to 0, 0 which causes an error\n", + " self.lifetime_ax[0].set_ylabel(\"Longevity [ms]\")\n", + " \n", + " self.ax[-1].set_xlabel(\"Time [ms]\")\n", + " \n", + " self.fig.savefig(\"/tmp/mountain_car_log.png\", dpi=300)\n", + " \n", + " self.lifetime_fig.savefig(\"/tmp/mountain_car_spiking_lifetime.png\", dpi=300)\n", + "\n", + " def update_weights_heatmap(self):\n", + " neuron_pop_base_gid = np.amin(agent.input_population.tolist()) # id of the first neuron in the NodeCollection\n", + " conn_info_left = self.agent.syn_left.get([\"source\", \"target\", \"weight\"])\n", + " conn_info_right = self.agent.syn_right.get([\"source\", \"target\", \"weight\"])\n", + "\n", + " left_q_table_matrix = np.empty((self.agent.NUM_POS_BINS, self.agent.NUM_VEL_BINS))\n", + " right_q_table_matrix = np.empty((self.agent.NUM_POS_BINS, self.agent.NUM_VEL_BINS))\n", + " for pos_bin in range(self.agent.NUM_POS_BINS):\n", + " for vel_bin in range(self.agent.NUM_VEL_BINS):\n", + " idx = pos_bin + self.agent.NUM_POS_BINS * vel_bin\n", + " input_neuron_gid = neuron_pop_base_gid + idx\n", + " \n", + " # for left\n", + "\n", + " sources = np.array(conn_info_left[\"source\"])\n", + " targets = np.array(conn_info_left[\"target\"])\n", + " weights = np.array(conn_info_left[\"weight\"])\n", + "\n", + " assert len(np.unique(targets)) == 1\n", + "\n", + " idx = np.where(sources == input_neuron_gid)[0]\n", + " \n", + " w = weights[idx]\n", + " \n", + " left_q_table_matrix[pos_bin, vel_bin] = w\n", + "\n", + " \n", + " # for right\n", + "\n", + " sources = np.array(conn_info_right[\"source\"])\n", + " targets = np.array(conn_info_right[\"target\"])\n", + " weights = np.array(conn_info_right[\"weight\"])\n", + "\n", + " assert len(np.unique(targets)) == 1\n", + "\n", + " idx = np.where(sources == input_neuron_gid)[0]\n", + " \n", + " w = weights[idx]\n", + " \n", + " right_q_table_matrix[pos_bin, vel_bin] = w\n", + "\n", + " \n", + " # Determine the overall min and max from all datasets\n", + " global_min = min(left_q_table_matrix.min(), right_q_table_matrix.min())\n", + " global_max = max(left_q_table_matrix.max(), right_q_table_matrix.max())\n", + "\n", + " # Use symmetric limits so that zero is centered\n", + " limit = max(abs(global_min), abs(global_max))\n", + "\n", + " # Create a normalization instance that forces 0 to be the center\n", + " norm = mpl.colors.TwoSlopeNorm(vmin=-limit, vcenter=0, vmax=limit)\n", + " \n", + " fig, ax = plt.subplots(nrows=3, figsize=(12, 12))\n", + "\n", + " im1 = ax[0].imshow(left_q_table_matrix, cmap=plt.cm.coolwarm, norm=norm, interpolation='none')\n", + " ax[0].set_title(\"Q value L\")\n", + " im2 = ax[1].imshow(right_q_table_matrix, cmap=plt.cm.coolwarm, norm=norm, interpolation='none')\n", + " ax[1].set_title(\"Q value R\")\n", + " im2 = ax[2].imshow(10*(left_q_table_matrix - right_q_table_matrix), cmap=plt.cm.coolwarm, norm=norm, interpolation='none')\n", + " ax[2].set_title(\"Q value L - R (x10)\")\n", + "\n", + " for _ax in ax:\n", + " _ax.set_xlabel(r\"pos\")\n", + " _ax.set_ylabel(r\"vel\")\n", + "\n", + " fig.colorbar(im1, ax=ax.ravel().tolist())\n", + " fig.savefig(\"/tmp/weights_matrix.png\", dpi=300)\n", + "\n", + " plt.close(fig)\n", + "\n", + " ###\n", + " \n", + " fig, ax = plt.subplots(nrows=1)\n", + " \n", + " ax.plot(np.array(conn_info_left[\"weight\"]), label=\"left\")\n", + " ax.plot(np.array(conn_info_right[\"weight\"]), label=\"right\")\n", + " ax.legend()\n", + " fig.savefig(\"/tmp/weights_spiking_1D.png\", dpi=300)\n", + "\n", + " plt.close(fig)" + ] + }, + { + "cell_type": "markdown", + "id": "125e6cf6", + "metadata": {}, + "source": [ + "Then, we define the spiking agent itself:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "99614c94", + "metadata": {}, + "outputs": [], + "source": [ + "class SpikingAgent(Agent):\n", + " cycle_period = 25. # alternate between physics and SNN simulation with this cycle length [ms]\n", + " \n", + " def __init__(self, env) -> None:\n", + " super().__init__(env)\n", + " \n", + " self.Q_left = 0.\n", + " self.Q_right = 0.\n", + " self.Q_left_prev = 0.\n", + " self.Q_right_prev = 0.\n", + " self.Q_old = 0.\n", + " self.Q_new = 0.\n", + " self.scale_n_output_spikes_to_Q_value = 0.1\n", + " self.last_action_chosen = AgentAction.LEFT # choose first action randomly\n", + "\n", + " self.POTENTIAL_SCALE_VEL = 10.\n", + " \n", + " self.Wmax = 3.\n", + " self.Wmin = 0.2\n", + "\n", + " self.n_action_neurons = 1 # number of neurons per action output population (this many for left, and another this many for right, etc.)\n", + "\n", + " self.INPUT_POPULATION_FIRING_RATE = 500. # [s⁻¹]\n", + " \n", + " self.construct_neural_network()\n", + " \n", + " def get_state_neuron(self, state) -> int:\n", + " discrete_state = self._get_discrete_state(state)\n", + " idx = discrete_state[0] + self.NUM_POS_BINS * discrete_state[1]\n", + " neuron_pop_base_gid = np.amin(self.input_population.tolist()) # id of the first neuron in the NodeCollection\n", + " \n", + " neuron_gid = neuron_pop_base_gid + idx\n", + " \n", + " if neuron_gid not in self.input_population:\n", + " return None\n", + "\n", + " return neuron_gid\n", + " \n", + " def construct_neural_network(self):\n", + " nest.ResetKernel()\n", + " nest.local_num_threads = nest_local_num_threads\n", + " nest.resolution = .1 # [ms]\n", + " nest.Install(input_layer_module_name) # makes the generated NESTML model available\n", + " nest.Install(output_layer_module_name) # makes the generated NESTML model available\n", + "\n", + " self.input_size = self.NUM_POS_BINS * self.NUM_VEL_BINS\n", + " self.input_population = nest.Create(input_layer_neuron_model_name, self.input_size)\n", + "\n", + " self.output_population_left = nest.Create(output_layer_neuron_model_name, self.n_action_neurons)\n", + " self.output_population_right = nest.Create(output_layer_neuron_model_name, self.n_action_neurons)\n", + " \n", + " self.spike_recorder_input = nest.Create(\"spike_recorder\")\n", + " nest.Connect(self.input_population, self.spike_recorder_input)\n", + "\n", + " self.multimeter_left = nest.Create('multimeter', 1, {'record_from': ['V_m']})\n", + " nest.Connect(self.multimeter_left, self.output_population_left)\n", + " self.multimeter_right = nest.Create('multimeter', 1, {'record_from': ['V_m']})\n", + " nest.Connect(self.multimeter_right, self.output_population_right)\n", + "\n", + " self.syn_opts = {\"synapse_model\": output_layer_synapse_model_name,\n", + " \"weight\": .5,\n", + " \"tau_tr_pre\": 20., # [ms]\n", + " \"tau_tr_post\": 20., # [ms]\n", + " \"wtr_max\": 0.1,\n", + " \"wtr_min\": 0.,\n", + " \"pre_trace_increment\": 0.0001,\n", + " \"post_trace_increment\": -1.05E-7}\n", + "\n", + " nest.Connect(self.input_population, self.output_population_left, syn_spec=self.syn_opts)\n", + " nest.Connect(self.input_population, self.output_population_right, syn_spec=self.syn_opts)\n", + "\n", + " syn = nest.GetConnections(source=self.input_population, target=self.output_population_right)\n", + " self.syn_right = nest.GetConnections(source=self.input_population, target=self.output_population_right)\n", + " self.syn_left = nest.GetConnections(source=self.input_population, target=self.output_population_left)\n", + "\n", + " self.output_population_spike_recorder_left = nest.Create(\"spike_recorder\")\n", + " nest.Connect(self.output_population_left, self.output_population_spike_recorder_left)\n", + "\n", + " self.output_population_spike_recorder_right = nest.Create(\"spike_recorder\")\n", + " nest.Connect(self.output_population_right, self.output_population_spike_recorder_right)\n", + " \n", + " def choose_action_based_on_q_values(self) -> AgentAction:\n", + " \"\"\"Chooses an action using p_explore-greedy policy.\"\"\"\n", + "\n", + " # Exploit: choose action with highest Q-value.\n", + " # Handle ties randomly.\n", + " Q_left, Q_right = self.compute_Q_values()\n", + " \n", + " if self.rng.random() < self.p_explore:\n", + " # Explore: random action\n", + " if self.rng.uniform(0, 1) < 0.5:\n", + " self.last_action_chosen = AgentAction.LEFT\n", + " return Q_left, AgentAction.LEFT\n", + "\n", + " self.last_action_chosen = AgentAction.RIGHT\n", + " return Q_right, AgentAction.RIGHT\n", + "\n", + " if Q_left > Q_right:\n", + " self.last_action_chosen = AgentAction.LEFT\n", + " return Q_left, AgentAction.LEFT\n", + " \n", + " self.last_action_chosen = AgentAction.RIGHT\n", + " return Q_right, AgentAction.RIGHT\n", + " \n", + " def plot_weight_updates(self, which_side, w, w_old):\n", + " q_table_matrix = np.empty((self.NUM_POS_BINS, self.NUM_VEL_BINS))\n", + " for pos_bin in range(self.NUM_POS_BINS):\n", + " for vel_bin in range(self.NUM_VEL_BINS):\n", + " idx = pos_bin + self.NUM_POS_BINS * vel_bin\n", + " q_table_matrix[pos_bin, vel_bin] = w[idx] - w_old[idx]\n", + " \n", + " # Determine the overall min and max from all datasets.\n", + " global_min = q_table_matrix.min()\n", + " global_max = q_table_matrix.max()\n", + "\n", + " # Use symmetric limits so that zero is centered.\n", + " limit = max(abs(global_min), abs(global_max))\n", + "\n", + " # Create a normalization instance that forces 0 to be the center.\n", + " norm = mpl.colors.TwoSlopeNorm(vmin=-limit, vcenter=0, vmax=limit)\n", + " \n", + " fig, ax = plt.subplots(figsize=(12, 12))\n", + " im1 = ax.imshow(q_table_matrix, cmap=plt.cm.coolwarm, norm=norm, interpolation='none')\n", + " ax.set_title(\"weight update (new - old)\")\n", + "\n", + " ax.set_xlabel(r\"pos\")\n", + " ax.set_ylabel(r\"vel\")\n", + "\n", + " fig.colorbar(im1, ax=ax)\n", + " fig.savefig(\"/tmp/weights_update_\" + which_side + \"_\" + str(time.time()) + \".png\", dpi=300)\n", + "\n", + " plt.close(fig)\n", + "\n", + " \n", + " # one-dimensional weight update plot\n", + " fig, ax = plt.subplots(ncols=2, figsize=(12,4))\n", + "\n", + " ax[0].plot(np.arange(len(w)), w_old, label=\"w_old\")\n", + " ax[0].plot(np.arange(len(w)), w, label=\"w_new\")\n", + " ax[0].legend()\n", + " ax[0].set_title(\"weights (\" + which_side + \")\")\n", + "\n", + " ax[1].set_title(\"w_new - w_old\")\n", + " ax[1].plot(np.arange(len(w)), w - w_old)\n", + " \n", + " print(\"Updating \" + str(len(np.where(np.abs(w - w_old) > 0)[0])) + \" weights\")\n", + "\n", + " fig.savefig(\"/tmp/w_updates_1D_\" + which_side + \"_\" + str(time.time()) + \".png\", dpi=300)\n", + " plt.close(fig)\n", + "\n", + " def compute_Q_values(self) -> None:\n", + " r\"\"\"The output of the SNN is interpreted as the (scaled) Q values.\"\"\"\n", + " self.n_events_in_last_interval_left = self.output_population_spike_recorder_left.n_events\n", + " self.n_events_in_last_interval_right = self.output_population_spike_recorder_right.n_events\n", + " self.Q_left = self.scale_n_output_spikes_to_Q_value * self.n_events_in_last_interval_left\n", + " self.Q_right = self.scale_n_output_spikes_to_Q_value * self.n_events_in_last_interval_right\n", + "\n", + " self.Q_new = np.amax([self.Q_left, self.Q_right])\n", + " \n", + " return self.Q_left, self.Q_right\n", + "\n", + " def update(self, next_state: Tuple[float, float]) -> Optional[AgentAction]:\n", + " # Reset output population spike recorders\n", + " self.output_population_spike_recorder_left.n_events = 0\n", + " self.output_population_spike_recorder_right.n_events = 0\n", + "\n", + " # make the correct input neuron fire\n", + " self.input_population.firing_rate = 0.\n", + " neuron_id = self.get_state_neuron(next_state)\n", + " \n", + " # if state was a failure\n", + " if neuron_id is None:\n", + " return None\n", + "\n", + " self.input_population[neuron_id].firing_rate = self.INPUT_POPULATION_FIRING_RATE\n", + "\n", + " # simulate for one cycle\n", + " nest.Simulate(SpikingAgent.cycle_period)\n", + "\n", + " def _potential(self, state, old_state):\n", + " \"\"\"\n", + " Calculates the potential function Phi(s) for reward shaping.\n", + " Higher potential should correlate with being closer to the goal state.\n", + " \"\"\"\n", + " position, velocity = state\n", + " old_position, old_velocity = old_state\n", + "\n", + " potential_val = 10 * self.env._height(position)\n", + " \n", + "# # reward increasing the velocity\n", + "# if np.abs(velocity) > np.abs(old_velocity):\n", + "# potential_val += 1 # (np.abs(velocity) - np.abs(old_velocity))\n", + "\n", + " # when going downhill, punish slowing down\n", + " if self.env._height(position) < self.env._height(old_position) and np.abs(velocity) < np.abs(old_velocity):\n", + " potential_val -= 10.\n", + " \n", + " return potential_val\n", + "\n", + " def update_synaptic_weights(self, Q_new, Q_old, action, reward, reset_traces_at_end_of_step=True):\n", + " if Q_old is None:\n", + " return\n", + "\n", + " TD = self.discount_factor * Q_new + 10 * reward - Q_old\n", + "\n", + " if action == AgentAction.RIGHT:\n", + " w = self.syn_right.get(\"w\")\n", + " # w_old = w.copy() # XXX only needed for debugging!\n", + " w += self.learning_rate * TD * np.array(self.syn_right.get(\"wtr\"))\n", + " w = np.minimum(w, self.Wmax)\n", + " w = np.maximum(w, self.Wmin)\n", + " self.syn_right.w = w\n", + " # self.plot_weight_updates(\"right\", w, w_old)\n", + " else:\n", + " assert action == AgentAction.LEFT\n", + " w = self.syn_left.get(\"w\")\n", + " # w_old = w.copy() # XXX only needed for debugging!\n", + " w += self.learning_rate * TD * np.array(self.syn_left.get(\"wtr\"))\n", + " w = np.minimum(w, self.Wmax)\n", + " w = np.maximum(w, self.Wmin)\n", + " self.syn_left.w = w\n", + " # self.plot_weight_updates(\"left\", w, w_old)\n", + " \n", + "\n", + " #\n", + " # reset synaptic state\n", + " #\n", + "\n", + " if reset_traces_at_end_of_step:\n", + " for _syn in [self.syn_left, self.syn_right]:\n", + " _syn.wtr = 0.\n", + " _syn.pre_trace = 0.\n", + " #_syn.post_trace = 0. # need to do this in postsyn. neuron partner instead! See the next two lines\n", + "\n", + " self.output_population_left.post_trace__for_neuromodulated_stdp_synapse_nestml = 0.\n", + " self.output_population_right.post_trace__for_neuromodulated_stdp_synapse_nestml = 0." + ] + }, + { + "cell_type": "markdown", + "id": "0a4563e2", + "metadata": {}, + "source": [ + "We can now run the simulation by putting together the mountain car physics with the SNN in the main loop:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "e4bda6d4", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode 0 took: 2.072 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -6.571768537791498\n", + "Episode 1 took: 2.124 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -5.19039522413152\n", + "Episode 2 took: 2.367 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -13.872030450958711\n", + "Episode 3 took: 2.100 s\n", + "\tNumber of steps in episode = 449\n", + "\tTotal reward = 2.2696698077239224\n", + "Episode 4 took: 2.470 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -4.810795083585302\n", + "Episode 5 took: 1.741 s\n", + "\tNumber of steps in episode = 341\n", + "\tTotal reward = 8.276293294583889\n", + "Episode 6 took: 2.548 s\n", + "\tNumber of steps in episode = 491\n", + "\tTotal reward = -0.22341812730234079\n", + "Episode 7 took: 1.839 s\n", + "\tNumber of steps in episode = 351\n", + "\tTotal reward = 7.15596660228648\n", + "Episode 8 took: 2.131 s\n", + "\tNumber of steps in episode = 423\n", + "\tTotal reward = 4.115677345994694\n", + "Episode 9 took: 2.547 s\n", + "\tNumber of steps in episode = 485\n", + "\tTotal reward = 2.4359103775790394\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_22525/516419963.py:120: DeprecationWarning:Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", + "/tmp/ipykernel_22525/516419963.py:135: DeprecationWarning:Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode 10 took: 2.903 s\n", + "\tNumber of steps in episode = 498\n", + "\tTotal reward = 1.427414090888584\n", + "Episode 11 took: 2.747 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -0.8675605990046993\n", + "Episode 12 took: 2.815 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -2.614152588149077\n", + "Episode 13 took: 2.813 s\n", + "\tNumber of steps in episode = 471\n", + "\tTotal reward = 4.57502823374634\n", + "Episode 14 took: 2.913 s\n", + "\tNumber of steps in episode = 476\n", + "\tTotal reward = 4.0343901898932675\n", + "Episode 15 took: 2.795 s\n", + "\tNumber of steps in episode = 442\n", + "\tTotal reward = 3.500417295266188\n", + "Episode 16 took: 2.690 s\n", + "\tNumber of steps in episode = 383\n", + "\tTotal reward = 7.561476895082343\n", + "Episode 17 took: 3.262 s\n", + "\tNumber of steps in episode = 473\n", + "\tTotal reward = 3.5659861246914084\n", + "Episode 18 took: 3.015 s\n", + "\tNumber of steps in episode = 454\n", + "\tTotal reward = 2.39207412096165\n", + "Episode 19 took: 12.232 s\n", + "\tNumber of steps in episode = 442\n", + "\tTotal reward = 3.180317693753257\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_22525/516419963.py:120: DeprecationWarning:Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", + "/tmp/ipykernel_22525/516419963.py:135: DeprecationWarning:Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode 20 took: 3.398 s\n", + "\tNumber of steps in episode = 470\n", + "\tTotal reward = 3.6261927930092166\n", + "Episode 21 took: 3.401 s\n", + "\tNumber of steps in episode = 475\n", + "\tTotal reward = 3.2414708376777224\n", + "Episode 22 took: 3.667 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = 0.2641690601681379\n", + "Episode 23 took: 3.578 s\n", + "\tNumber of steps in episode = 489\n", + "\tTotal reward = 2.033950892654474\n", + "Episode 24 took: 3.567 s\n", + "\tNumber of steps in episode = 470\n", + "\tTotal reward = 4.02203641546302\n", + "Episode 25 took: 4.339 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = 0.2538028721419012\n", + "Episode 26 took: 3.720 s\n", + "\tNumber of steps in episode = 420\n", + "\tTotal reward = 4.8656779515640345\n", + "Episode 27 took: 4.268 s\n", + "\tNumber of steps in episode = 492\n", + "\tTotal reward = 1.463498464463361\n", + "Episode 28 took: 2.976 s\n", + "\tNumber of steps in episode = 351\n", + "\tTotal reward = 6.559925476344539\n", + "Episode 29 took: 3.141 s\n", + "\tNumber of steps in episode = 376\n", + "\tTotal reward = 8.06510862261401\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_22525/516419963.py:120: DeprecationWarning:Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", + "/tmp/ipykernel_22525/516419963.py:135: DeprecationWarning:Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode 30 took: 4.012 s\n", + "\tNumber of steps in episode = 447\n", + "\tTotal reward = 5.736444971973054\n", + "Episode 31 took: 3.759 s\n", + "\tNumber of steps in episode = 414\n", + "\tTotal reward = 4.033955350325707\n", + "Episode 32 took: 4.753 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = 0.6403141816248414\n", + "Episode 33 took: 4.852 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -1.4082959714880707\n", + "Episode 34 took: 4.986 s\n", + "\tNumber of steps in episode = 474\n", + "\tTotal reward = 4.135084847299336\n", + "Episode 35 took: 5.040 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -6.351861565861838\n", + "Episode 36 took: 5.134 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -8.032888960153212\n", + "Episode 37 took: 5.237 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -2.84738271039367\n", + "Episode 38 took: 5.522 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -6.077593949329013\n", + "Episode 39 took: 5.158 s\n", + "\tNumber of steps in episode = 472\n", + "\tTotal reward = 2.8466066761981885\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_22525/516419963.py:120: DeprecationWarning:Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", + "/tmp/ipykernel_22525/516419963.py:135: DeprecationWarning:Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode 40 took: 5.416 s\n", + "\tNumber of steps in episode = 480\n", + "\tTotal reward = 1.7855389496985774\n", + "Episode 41 took: 4.780 s\n", + "\tNumber of steps in episode = 433\n", + "\tTotal reward = 3.228520915671402\n", + "Episode 42 took: 5.559 s\n", + "\tNumber of steps in episode = 496\n", + "\tTotal reward = -2.3871516078153805\n", + "Episode 43 took: 5.423 s\n", + "\tNumber of steps in episode = 464\n", + "\tTotal reward = 3.6281908642250578\n", + "Episode 44 took: 5.567 s\n", + "\tNumber of steps in episode = 481\n", + "\tTotal reward = 1.559397872573852\n", + "Episode 45 took: 5.522 s\n", + "\tNumber of steps in episode = 473\n", + "\tTotal reward = 2.9103789490908967\n", + "Episode 46 took: 5.453 s\n", + "\tNumber of steps in episode = 457\n", + "\tTotal reward = 4.026032199679252\n", + "Episode 47 took: 5.338 s\n", + "\tNumber of steps in episode = 444\n", + "\tTotal reward = 3.0325767959556384\n", + "Episode 48 took: 6.114 s\n", + "\tNumber of steps in episode = 495\n", + "\tTotal reward = 0.618114235047786\n", + "Episode 49 took: 6.478 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -4.731807474432128\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_22525/516419963.py:120: DeprecationWarning:Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", + "/tmp/ipykernel_22525/516419963.py:135: DeprecationWarning:Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "env = MountainCarPhysics()\n", + "agent = SpikingAgent(env)\n", + "\n", + "agent.p_explore = 0. # XXX: no exploration! not necessary\n", + "agent.learning_rate = 0.001\n", + "agent.learning_rate_decay = .99\n", + "agent.MIN_LEARNING_RATE = agent.learning_rate / 100.\n", + "\n", + "r = MountainCarRenderer(env, agent)\n", + "r._init_render()\n", + "plot = SpikingPlotRenderer(env, agent)\n", + "\n", + "episode_number_log = []\n", + "episode_number_detailed_log = []\n", + "steps_per_episode_log = []\n", + "episode_number_times = []\n", + "episode_number_at_time = []\n", + "n_events_in_last_interval_left_log = []\n", + "n_events_in_last_interval_right_log = []\n", + "\n", + "model_time_log = []\n", + "action_taken = []\n", + "p_explore_log = []\n", + "rewards_per_episode: List[int] = [] # log of total reward achieved in each episode\n", + "learning_rate_log = []\n", + "\n", + "syn_to_left = nest.GetConnections(source=agent.input_population, target=agent.output_population_left)\n", + "syn_to_right = nest.GetConnections(source=agent.input_population, target=agent.output_population_right)\n", + "\n", + "max_n_episodes: int = 50\n", + "max_steps_per_episode: int = 500 # maximum allowed number of steps per episode\n", + "\n", + "plot_this_episode = True\n", + "plot_sim = False\n", + "failure = False\n", + "\n", + "# agent chooses action, simulation is updated and reward is calculated\n", + "\n", + "render_active = True # Flag to control rendering loop\n", + "\n", + "Q_old = None\n", + "env.reset()\n", + "old_state = copy.copy(env.state)\n", + "\n", + "for episode in range(max_n_episodes):\n", + " render_this_episode = False\n", + " plot_this_episode = (episode + 1) % 10 == 0\n", + "\n", + " env.reset()\n", + " \n", + " episode_total_reward = 0\n", + "\n", + " start_time_episode = time.time()\n", + " \n", + " for step in range(max_steps_per_episode):\n", + "\n", + " #\n", + " # agent chooses action\n", + " #\n", + "\n", + " agent.update(env.state)\n", + " Q_max, action = agent.choose_action_based_on_q_values()\n", + "\n", + " if action is None:\n", + " # failure\n", + " break\n", + " \n", + " #\n", + " # step environment using action\n", + " #\n", + " \n", + " old_old_state = copy.copy(old_state)\n", + " old_state = copy.copy(env.state)\n", + " _, env_done = env.step(action)\n", + "\n", + " if env_done:\n", + " # success!\n", + " agent.update_synaptic_weights(Q_new=Q_max,\n", + " Q_old=Q_old,\n", + " action=action,\n", + " reward=1.)\n", + " break\n", + "\n", + " #\n", + " # change synaptic weights based on environment reward\n", + " #\n", + "\n", + " step_reward = agent.discount_factor * agent._potential(env.state, old_state) - agent._potential(old_state, old_old_state) # compute reward in the new state\n", + " agent.update_synaptic_weights(Q_new=Q_max,\n", + " Q_old=Q_old,\n", + " action=action,\n", + " reward=step_reward)\n", + "\n", + " Q_old = Q_max\n", + " \n", + "\n", + " #\n", + " # Render if requested and active\n", + " #\n", + " \n", + " for event in pygame.event.get():\n", + " if event.type == pygame.QUIT:\n", + " pygame.quit()\n", + " sys.exit()\n", + " quit()\n", + " elif event.type == pygame.KEYDOWN:\n", + " render_this_episode ^= pygame.key.get_pressed()[pygame.K_SPACE]\n", + " \n", + " if render_this_episode and render_active:\n", + " r.render(episode, step + 1, step_reward, action)\n", + "\n", + " \n", + " #\n", + " # logging\n", + " #\n", + "\n", + " episode_total_reward += step_reward\n", + "\n", + " p_explore_log.append(agent.p_explore)\n", + " learning_rate_log.append(agent.learning_rate)\n", + " model_time_log.append(nest.biological_time)\n", + " action_taken.append(action)\n", + " episode_number_detailed_log.append(episode)\n", + " n_events_in_last_interval_left_log.append(agent.n_events_in_last_interval_left)\n", + " n_events_in_last_interval_right_log.append(agent.n_events_in_last_interval_right)\n", + " \n", + " #\n", + " # print performance stats\n", + " #\n", + "\n", + " end_time_episode = time.time()\n", + " time_episode = end_time_episode - start_time_episode\n", + " print(f\"Episode \" + str(episode) + f\" took: {time_episode:.3f} s\")\n", + " print(\"\\tNumber of steps in episode = \" + str(step))\n", + " print(\"\\tTotal reward = \" + str(episode_total_reward))\n", + "\n", + " episode_number_log.append(episode)\n", + " steps_per_episode_log.append(step)\n", + " rewards_per_episode.append(episode_total_reward)\n", + " \n", + " if plot_this_episode:\n", + " plot_data = {\n", + " \"input_spikes\": nest.GetStatus(agent.spike_recorder_input, keys=\"events\")[0],\n", + " \"output_spikes_left\": nest.GetStatus(agent.output_population_spike_recorder_left, keys=\"events\")[0],\n", + " \"output_spikes_right\": nest.GetStatus(agent.output_population_spike_recorder_right, keys=\"events\")[0],\n", + " \"multimeter_right_events\": agent.multimeter_right.get(\"events\"),\n", + " \"multimeter_left_events\": agent.multimeter_left.get(\"events\"),\n", + " \"n_input_neurons\": agent.input_size,\n", + " \"total_reward_per_episode\": rewards_per_episode\n", + " }\n", + "\n", + " plot_data[\"model_time_log\"] = model_time_log\n", + " plot_data[\"action_taken\"] = action_taken\n", + " plot_data[\"p_explore_log\"] = p_explore_log\n", + " plot_data[\"learning_rate_log\"] = learning_rate_log\n", + " plot_data[\"episode_number_log\"] = episode_number_log\n", + " plot_data[\"episode_number_detailed_log\"] = episode_number_detailed_log\n", + " plot_data[\"episode_duration\"] = agent.cycle_period\n", + " plot_data[\"steps_per_episode_log\"] = steps_per_episode_log\n", + " plot_data[\"Wmin\"] = agent.Wmin\n", + " plot_data[\"Wmax\"] = agent.Wmax\n", + " plot_data[\"n_events_in_last_interval_left_log\"] = n_events_in_last_interval_left_log\n", + " plot_data[\"n_events_in_last_interval_right_log\"] = n_events_in_last_interval_right_log\n", + "\n", + " plot.update(plot_data)\n", + " plot.update_weights_heatmap()\n", + " \n", + " agent.decay_p_explore()\n", + " agent.decay_learning_rate()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "b999c031", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "# run this cell to do benchmarking! \n", + "# %%prun -s cumulative\n", + "# main_simulation_loop()" + ] + }, + { + "cell_type": "markdown", + "id": "b6113b6c", + "metadata": {}, + "source": [ + "## Mechanistic explanation: why does this learning principle work?\n", + "\n", + "The neuromoduled STDP synapse used in the SNN only as a potentiation component, and no depression. This reduces the model to a Hebbian firing-rate rule: if the pre- and postsynaptic neuron fire at higher rates, their connection tends to become strenghtened.\n", + "\n", + "This can be shown by plotting the change in weight as a function of pre- and postsynaptic firing rate for a single synapse. Observe that more potentiation happens as the firing rates become higher." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "6a68403e", + "metadata": {}, + "outputs": [], + "source": [ + "def run_stdp_firing_rate_experiment(alpha=0., debug=False):\n", + " #\n", + " # Simulation parameters\n", + " #\n", + "\n", + " duration = 1000. # Duration of each individual simulation [ms]\n", + " dt = 0.1 # Simulation time step [ms]\n", + "\n", + " #\n", + " # STDP synapse parameters\n", + " #\n", + "\n", + " # This script uses NEST's standard 'stdp_synapse' model.\n", + " learning_rate = 0.001 # LTP/LTD amplitude change (NEST's 'lambda')\n", + " alpha = alpha # ratio between LTP and LTD amplitude change (NEST's 'alpha')\n", + " w_max = 1. # Maximum synaptic weight\n", + " initial_weight = 0.5 # Starting weight for the synapse\n", + "\n", + " #\n", + " # Firing rate parameters\n", + " #\n", + "\n", + " # Range of firing rates to test (in s⁻¹)\n", + " pre_rates = np.linspace(5, 100, 10)\n", + " post_rates = np.linspace(5, 100, 10)\n", + "\n", + " #\n", + " # Main loop\n", + " #\n", + "\n", + " # Iterate over every combination of presynaptic and postsynaptic firing rates\n", + " weight_changes = np.zeros((len(pre_rates), len(post_rates))) # Initialize a matrix to store the final weight change for each rate pair\n", + " for i, pre_rate in enumerate(pre_rates):\n", + " for j, post_rate in enumerate(post_rates):\n", + " if debug:\n", + " print(f\"Simulating: Pre-rate={pre_rate:.1f} s⁻¹, Post-rate={post_rate:.1f} s⁻¹\")\n", + "\n", + " # Reset NEST Kernel: Ensures that each simulation run is independent and starts from a clean state\n", + " nest.ResetKernel()\n", + " nest.resolution = dt\n", + " nest.print_time = False # Suppress NEST's progress output for a cleaner console\n", + " nest.local_num_threads = 1 # Ensures reproducibility for this script\n", + "\n", + " # Create network nodes\n", + " # The presynaptic neuron is a simple Poisson spike generator\n", + " pre_generator = nest.Create(\"poisson_generator\", params={\"rate\": pre_rate})\n", + " pre_parrot = nest.Create(\"parrot_neuron\")\n", + " nest.Connect(pre_generator, pre_parrot)\n", + "\n", + " sr_pre = nest.Create(\"spike_recorder\")\n", + " sr_post = nest.Create(\"spike_recorder\")\n", + "\n", + " # The postsynaptic neuron must be a spiking model for STDP to work\n", + " # We use a standard leaky integrate-and-fire neuron model\n", + " post_neuron = nest.Create(\"iaf_psc_alpha\")\n", + "\n", + " nest.Connect(pre_parrot, sr_pre)\n", + " nest.Connect(post_neuron, sr_post)\n", + "\n", + " # To control the postsynaptic firing rate, we drive it with another generator\n", + " # This driver provides strong input to make the post_neuron fire at the target rate\n", + " post_driver = nest.Create(\"poisson_generator\", params={\"rate\": post_rate})\n", + "\n", + " # --- Configure Synapse Model ---\n", + " # Define the parameters for NEST's built-in STDP synapse model\n", + " stdp_params = {\n", + " \"lambda\": learning_rate, # Potentiation step\n", + " \"alpha\": alpha, # Depression step (as a positive factor)\n", + " \"Wmax\": w_max, # Upper bound for the weight\n", + " \"weight\": initial_weight,\n", + " \"mu_plus\": 0.,\n", + " \"mu_minus\": 0.,\n", + " \"delay\": dt, # Minimum delay\n", + " }\n", + " # Create a custom synapse name based on the standard model\n", + " nest.CopyModel(\"stdp_synapse\", \"custom_stdp_synapse\", params=stdp_params)\n", + "\n", + " nest.Connect(pre_parrot, post_neuron, syn_spec={\"synapse_model\": \"custom_stdp_synapse\"})\n", + " nest.Connect(post_driver, post_neuron, syn_spec={\"weight\": 2000.})\n", + "\n", + " #\n", + " # Run simulation\n", + " #\n", + "\n", + " # We need the initial state to calculate the change later\n", + " connection = nest.GetConnections(pre_parrot, post_neuron)\n", + " initial_w = nest.GetStatus(connection, \"weight\")[0]\n", + "\n", + " nest.Simulate(duration)\n", + "\n", + " assert len(sr_pre.events[\"times\"]) > 0\n", + " if debug:\n", + " print(\"\\t-> Actual pre rate: \" + str(len(sr_pre.events[\"times\"]) / (duration / 1000)) + \" s⁻¹\")\n", + " assert len(sr_post.events[\"times\"]) > 0\n", + " if debug:\n", + " print(\"\\t-> Actual post rate: \" + str(len(sr_post.events[\"times\"]) / (duration / 1000)) + \" s⁻¹\")\n", + "\n", + " # Retrieve the weight after the simulation has finished\n", + " final_w = nest.GetStatus(connection, \"weight\")[0]\n", + " weight_changes[i, j] = final_w - initial_w\n", + "\n", + "\n", + " #\n", + " # Plotting\n", + " #\n", + "\n", + " # Create a custom colormap: blue -> white -> red\n", + " colors = [(0, 0, 1), (1, 1, 1), (1, 0, 0)] # Blue, White, Red\n", + " cmap = mpl.colors.LinearSegmentedColormap.from_list('stdp_cmap', colors, N=256)\n", + "\n", + " # Automatically determine the color limits to be symmetric around zero\n", + " v_limit = np.max(np.abs(weight_changes))\n", + "\n", + " # Create the figure and axes\n", + " plt.figure(figsize=(8, 6))\n", + " im = plt.imshow(\n", + " weight_changes, \n", + " cmap=cmap,\n", + " extent=[post_rates[0], post_rates[-1], pre_rates[0], pre_rates[-1]],\n", + " origin='lower', \n", + " aspect='auto', \n", + " vmin=-v_limit, \n", + " vmax=v_limit\n", + " )\n", + "\n", + " plt.colorbar(im, label='Change in Synaptic Weight')\n", + " plt.xlabel('Postsynaptic Firing Rate [s⁻¹]')\n", + " plt.ylabel('Presynaptic Firing Rate [s⁻¹]')\n", + " plt.title(f'STDP Weight Change vs. Firing Rates ({int(duration)} ms) - NEST Simulator')\n", + " plt.grid(False)\n", + " plt.tight_layout()\n", + "\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f95e4500", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "run_stdp_firing_rate_experiment()" + ] + }, + { + "cell_type": "markdown", + "id": "636aaba1", + "metadata": {}, + "source": [ + "By comparison, if we use the normal STDP rule, that has a depression component equal in magnitude to the facilitation component, no clear patterns of firing rate dependence emerges:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "d2ea5d0f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "run_stdp_firing_rate_experiment(alpha=1.)" + ] + }, + { + "cell_type": "markdown", + "id": "629465a0", + "metadata": {}, + "source": [ + "Because of the activity of the neuromodulator in the mountain-car network (in addition to the basic STDP mechanism), only the connections between the input neuron that are active, and the output layer neuron for the action that was chosen, will be updated, proportional to the reward obtained. Thus, the weight increase is proportional to the reward, ensuring that successful input state/output action mappings get strengthened." + ] + }, + { + "cell_type": "markdown", + "id": "f6d4d920", + "metadata": {}, + "source": [ + "# Citations\n", + "\n", + "[1] Liu Y, Pan W. Spiking Neural-Networks-Based Data-Driven Control. Electronics. 2023; 12(2):310. https://doi.org/10.3390/electronics12020310 \n", + "\n", + "[2] Kaiser, Jacques & v. Tieck, J. Camilo & Hubschneider, Christian & Wolf, Peter & Weber, Michael & Hoff, Michael & Friedrich, Alexander & Wojtasik, Konrad & Roennau, Arne & Kohlhaas, Ralf & Dillmann, Rüdiger & Zöllner, J.. (2016). Towards a framework for end-to-end control of a simulated vehicle with spiking neural networks. 10.1109/SIMPAR.2016.7862386.\n", + "\n", + "[3] Pygame community (2025). Pygame (computer software). Retrieved from https://www.pygame.org/\n", + "\n", + "\n", + "\n", + "## Acknowledgements\n", + "\n", + "The authors would like to thank Prof. Wei Pan and Dr. Yuxiang Liu for kindly providing the source code for their original publication. \n", + "\n", + "This software was developed in part or in whole in the Human Brain Project, funded from the European Union’s Horizon 2020 Framework Programme for Research and Innovation under Specific Grant Agreements No. 720270 and No. 785907 (Human Brain Project SGA1 and SGA2).\n", + "\n", + "## Copyright\n", + "\n", + "This file is part of NEST.\n", + "\n", + "Copyright (C) 2004 The NEST Initiative\n", + "\n", + "NEST is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.\n", + "\n", + "NEST is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.\n", + "\n", + "You should have received a copy of the GNU General Public License along with NEST. If not, see http://www.gnu.org/licenses/." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/doc/tutorials/mountain_car_reinforcement_learning/neuromodulated_stdp_synapse.nestml b/doc/tutorials/mountain_car_reinforcement_learning/neuromodulated_stdp_synapse.nestml new file mode 100644 index 000000000..1e67e6b34 --- /dev/null +++ b/doc/tutorials/mountain_car_reinforcement_learning/neuromodulated_stdp_synapse.nestml @@ -0,0 +1,55 @@ +# stdp - Synapse model for spike-timing dependent plasticity +# ########################################################## +# +# [1] Liu Y, Pan W. Spiking Neural-Networks-Based Data-Driven Control. Electronics. 2023; 12(2):310. https://doi.org/10.3390/electronics12020310 +# +model neuromodulated_stdp_synapse: + state: + w real = 1 # Synaptic weight + wtr real = 0 + pre_trace real = 0. + post_trace real = 0. + + parameters: + n real = 0. # Neuromodulator concentration between 0 and 1 + d ms = 1 ms # Synaptic transmission delay + beta real = 0.01 # Learning rate + tau_tr_pre ms = 10 ms + tau_tr_post ms = 10 ms + pre_trace_increment real = 1. + post_trace_increment real = 1. + wtr_max real = 0.1 + wtr_min real = 0 + tau_wtr ms = 100 ms # Substantially longer than one cycle time (25 ms) + + equations: + pre_trace' = -pre_trace / tau_tr_pre + post_trace' = -post_trace / tau_tr_post + wtr' = -wtr / tau_wtr + + input: + pre_spikes <- spike + post_spikes <- spike + + output: + spike(weight real, delay ms) + + onReceive(post_spikes): + post_trace += 1 # XXX FIXME!!!! should be ``+= post_trace_increment`` + + wtr += pre_trace + wtr = max(wtr_min, wtr) + wtr = min(wtr_max, wtr) + + onReceive(pre_spikes): + pre_trace += pre_trace_increment + + wtr += post_trace + wtr = max(wtr_min, wtr) + wtr = min(wtr_max, wtr) + + # deliver spike to postsynaptic partner + emit_spike(w, d) + + update: + integrate_odes()