From 6712be16c524a6595c3344442ba15e4964c0432c Mon Sep 17 00:00:00 2001 From: "C.A.P. Linssen" Date: Mon, 16 Jun 2025 12:25:45 +0200 Subject: [PATCH 1/8] add mountain car reinforcement learning tutorial --- .../iaf_psc_exp_neuron.nestml | 58 + ...inforcement_learning_nestml_tutorial.ipynb | 3490 +++++++++++++++++ .../neuromodulated_stdp_synapse.nestml | 55 + 3 files changed, 3603 insertions(+) create mode 100644 doc/tutorials/mountain_car_reinforcement_learning/iaf_psc_exp_neuron.nestml create mode 100644 doc/tutorials/mountain_car_reinforcement_learning/mountain_car_reinforcement_learning_nestml_tutorial.ipynb create mode 100644 doc/tutorials/mountain_car_reinforcement_learning/neuromodulated_stdp_synapse.nestml 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..e766b437d --- /dev/null +++ b/doc/tutorials/mountain_car_reinforcement_learning/mountain_car_reinforcement_learning_nestml_tutorial.ipynb @@ -0,0 +1,3490 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "f763ff4e", + "metadata": {}, + "source": [ + "# Solving the \"mountain car\" task using NESTML\n" + ] + }, + { + "cell_type": "markdown", + "id": "27c21179", + "metadata": {}, + "source": [ + "\n", + "\n", + "In this tutorial, we are going to build an agent that can successfully solve the \"mountain car\" task using reinforcement learning. [describe the task..]\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." + ] + }, + { + "cell_type": "markdown", + "id": "0885d90c", + "metadata": {}, + "source": [ + "## Mountain car environment" + ] + }, + { + "cell_type": "markdown", + "id": "3e9c0bfe", + "metadata": {}, + "source": [ + "For the environment, we mostly need: \n", + " - A renderer to display the simulation \n", + " - The physics system\n", + " \n", + "We will use the popular \"pygame\" package to do the rendering. [add citation]" + ] + }, + { + "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", + "import copy\n", + "import enum\n", + "import json\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import os\n", + "import random\n", + "from collections import defaultdict\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 = 8 # XXX should be 1 by default\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", + "...\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6b5f4227", + "metadata": {}, + "outputs": [], + "source": [ + "class MountainCarPhysics:\n", + " \"\"\"\n", + " A custom implementation of the Mountain Car environment.\n", + " Uses Forward Euler integration for physics.\n", + " \"\"\"\n", + "\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 (Forward Euler) ---\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": [ + "\n", + "\n", + "To render the environment for visual inspection, we make a class ``Renderer`` that uses pygame:\n" + ] + }, + { + "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``...\n", + "\n", + "The state is a set S of agent observable states. \"boxes\" (discretizing the state space)...\n", + "\n", + "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. Therefore, one set of A is represented.\n", + "\n", + "\"Over time, it improves its decision-making by updating a Q-table, which stores Q-values representing the expected rewards for taking particular actions in given states.\"\n" + ] + }, + { + "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": "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\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", + "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_135852/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: -508.43, Avg Reward (Last 100): -506.43, p_explore: 0.4954\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_135852/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.08, Avg Reward (Last 100): -494.29, p_explore: 0.2454\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_135852/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: -373.31, Avg Reward (Last 100): -467.66, p_explore: 0.1216\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_135852/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: -411.05, Avg Reward (Last 100): -380.99, p_explore: 0.0602\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_135852/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: -269.34, Avg Reward (Last 100): -337.76, p_explore: 0.0298\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_135852/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: -265.11, Avg Reward (Last 100): -333.28, p_explore: 0.0148\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_135852/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: -255.63, Avg Reward (Last 100): -319.24, p_explore: 0.0000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_135852/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: -225.64, Avg Reward (Last 100): -306.97, p_explore: 0.0000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_135852/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: -311.51, Avg Reward (Last 100): -300.41, p_explore: 0.0000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_135852/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: -237.05, Avg Reward (Last 100): -302.85, p_explore: 0.0000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_135852/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: -269.26, Avg Reward (Last 100): -281.02, p_explore: 0.0000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_135852/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: -287.27, Avg Reward (Last 100): -293.43, p_explore: 0.0000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_135852/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: -252.75, Avg Reward (Last 100): -312.30, p_explore: 0.0000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_135852/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: -300.46, Avg Reward (Last 100): -316.93, p_explore: 0.0000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_135852/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: -252.87, Avg Reward (Last 100): -312.45, 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 = False\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": [ + "\n", + "\n", + "TODO: Make plot of how much q values changed from before training to after training. Are there certain boxes that never get updated? i.e. is the state space (configuration space) adequately explored?\n" + ] + }, + { + "cell_type": "markdown", + "id": "43c70dff", + "metadata": {}, + "source": [ + "# Spiking version" + ] + }, + { + "cell_type": "markdown", + "id": "d4705cf6", + "metadata": {}, + "source": [ + "## Idea" + ] + }, + { + "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 40ms to provide the effect that they run simultaneously.\n", + "The model's structure consists of two layers of neurons. For each discrete state of the system, the input layer contains a single neuron corresponding to it. Neuromodulated synapses connect these to the output layer, which itself consists of two neuron groups interpreted as actions \"move left\" and \"move right\" respectively.\n", + "\n", + "One simulation step of the SNN works as follows:\n", + "1. Get the current state of the cart pole and find the designated neuron that only fires when that state is reached.\n", + "2. Set a continuous firing rate for the simulation period on that neuron.\n", + "3. Determine which of the neuron groups in the output layer has fired more spikes at the end of the step." + ] + }, + { + "cell_type": "markdown", + "id": "5831c9d7", + "metadata": {}, + "source": [ + "# SNN Visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "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\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "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", + "# self.ax[1].plot(data[\"multimeter_right_events\"][\"times\"], data[\"multimeter_right_events\"][\"V_m\"], 'r')\n", + "# self.ax[1].plot(data[\"multimeter_left_events\"][\"times\"], data[\"multimeter_left_events\"][\"V_m\"], 'b')\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[\"output_spikes_left\"][\"times\"], data[\"output_spikes_left\"][\"senders\"], \".b\", markersize=5)\n", + "# self.ax[2].plot(data[\"output_spikes_right\"][\"times\"], data[\"output_spikes_right\"][\"senders\"], \".r\", markersize=5)\n", + "# self.ax[2].set_ylabel(\"Output Neuron\")\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.canvas.draw()\n", + " self.fig.savefig(\"/tmp/mountain_car_log.png\", dpi=300)\n", + "# self.fig.canvas.flush_events()\n", + " \n", + "# self.lifetime_fig.canvas.draw()\n", + " self.lifetime_fig.savefig(\"/tmp/mountain_car_spiking_lifetime.png\", dpi=300)\n", + "# self.lifetime_fig.canvas.flush_events()\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", + " \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)\n", + "\n", + " " + ] + }, + { + "cell_type": "markdown", + "id": "8dc47382", + "metadata": {}, + "source": [ + "\n", + "## NESTML models\n", + "\n", + "Neurons in the input layer will simply be spike generators (ignore_and_fire) that will fire spikes periodically with a given interval.\n", + "\n", + "Neuron model used for the output layer will be iaf_psc_exp.\n", + "\n", + "Input layer neurons are connected through output layer neurons through ``neuromodulated_stdp_synapse``.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "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, [35:34;35: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", + "[1,GLOBAL, INFO]: List of files that will be processed:\n", + "[2,GLOBAL, INFO]: /home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/iaf_psc_exp_neuron.nestml\n", + "[3,GLOBAL, INFO]: /home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/neuromodulated_stdp_synapse.nestml\n", + "[4,GLOBAL, INFO]: Target platform code will be generated in directory: '/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target'\n", + "[5,GLOBAL, INFO]: Target platform code will be installed in directory: '/tmp/nestml_target_bluoj7hw'\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", + "[6,GLOBAL, INFO]: The NEST Simulator version was automatically detected as: master\n", + "[7,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n", + "[8,GLOBAL, INFO]: The NEST Simulator installation path was automatically detected as: /home/charl/julich/nest-simulator-install\n", + "[9,GLOBAL, INFO]: Start processing '/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/iaf_psc_exp_neuron.nestml'!\n", + "[10,iaf_psc_exp_neuron_nestml, INFO, [37:19;37:19]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[11,iaf_psc_exp_neuron_nestml, INFO, [40:17;40:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[12,iaf_psc_exp_neuron_nestml, INFO, [53:15;53:32]]: Implicit casting from (compatible) type '1 / s buffer' to 'real'.\n", + "[13,GLOBAL, INFO]: Start processing '/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/neuromodulated_stdp_synapse.nestml'!\n", + "[14,neuromodulated_stdp_synapse_nestml, INFO, [8:17;8:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[15,neuromodulated_stdp_synapse_nestml, INFO, [9:19;9:19]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[16,neuromodulated_stdp_synapse_nestml, INFO, [22:23;22:23]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", + "[17,neuromodulated_stdp_synapse_nestml, INFO, [38:22;38:22]]: Implicit casting from (compatible) type 'integer' to 'real'.\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": [ + "INFO:Analysing input:\n", + "INFO:{\n", + " \"dynamics\": [\n", + " {\n", + " \"expression\": \"g_e' = (-g_e) / tau_g\",\n", + " \"initial_values\": {\n", + " \"g_e\": \"0.0\"\n", + " }\n", + " },\n", + " {\n", + " \"expression\": \"V_m' = (g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\",\n", + " \"initial_values\": {\n", + " \"V_m\": \"E_l\"\n", + " }\n", + " }\n", + " ],\n", + " \"options\": {\n", + " \"output_timestep_symbol\": \"__h\"\n", + " },\n", + " \"parameters\": {\n", + " \"E_e\": \"0\",\n", + " \"E_l\": \"(-74)\",\n", + " \"I_e\": \"0\",\n", + " \"V_reset\": \"(-60)\",\n", + " \"V_th\": \"(-54)\",\n", + " \"s\": \"1000\",\n", + " \"tau_g\": \"5\",\n", + " \"tau_m\": \"10\"\n", + " }\n", + "}\n", + "INFO:Processing global options...\n", + "INFO:Processing input shapes...\n", + "INFO:\n", + "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", + "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_g]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "DEBUG:Created Shape with symbol g_e, derivative_factors = [-1/tau_g], inhom_term = 0.0, nonlin_term = 0.0\n", + "INFO:\tReturning shape: Shape \"g_e\" of order 1\n", + "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", + "INFO:\n", + "Processing differential-equation form shape V_m with defining expression = \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\"\n", + "DEBUG:Splitting expression (E_l + I_e + I_stim - V_m + g_e*(E_e - V_m))/tau_m (symbols [V_m])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_m]])\n", + "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m\n", + "DEBUG:\tnonlinear term: E_e*g_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m\n", + "DEBUG:Created Shape with symbol V_m, derivative_factors = [-1/tau_m], inhom_term = E_l/tau_m + I_e/tau_m, nonlin_term = E_e*g_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m\n", + "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", + "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", + "INFO:All known variables: [g_e, V_m], all parameters used in ODEs: {tau_g, I_stim, E_e, E_l, tau_m, I_e}\n", + "INFO:No numerical value specified for parameter \"I_stim\"\n", + "INFO:\n", + "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", + "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m, g_e])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0], [0]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "DEBUG:Created Shape with symbol g_e, derivative_factors = [-1/tau_g], inhom_term = 0.0, nonlin_term = 0\n", + "INFO:\tReturning shape: Shape \"g_e\" of order 1\n", + "INFO:\n", + "Processing differential-equation form shape V_m with defining expression = \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\"\n", + "DEBUG:Splitting expression (E_l + I_e + I_stim - V_m + g_e*(E_e - V_m))/tau_m (symbols [g_e, V_m, g_e, V_m])\n", + "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m], [0], [0]])\n", + "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", + "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", + "DEBUG:Created Shape with symbol V_m, derivative_factors = [-1/tau_m], inhom_term = E_l/tau_m + I_e/tau_m + I_stim/tau_m, nonlin_term = E_e*g_e/tau_m - V_m*g_e/tau_m\n", + "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", + "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", + "DEBUG:Splitting expression -g_e/tau_g (symbols Matrix([[g_e], [V_m]]))\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", + "DEBUG:Splitting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m (symbols Matrix([[g_e], [V_m]]))\n", + "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m]])\n", + "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", + "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", + "DEBUG:Initializing system of shapes with x = Matrix([[g_e], [V_m]]), A = Matrix([[-1/tau_g, 0], [E_e/tau_m, -1/tau_m]]), b = Matrix([[0], [E_l/tau_m + I_e/tau_m + I_stim/tau_m]]), c = Matrix([[0], [-V_m*g_e/tau_m]])\n", + "INFO:Finding analytically solvable equations...\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", + "DEBUG:os.makedirs('/tmp')\n", + "DEBUG:write lines to '/tmp/ode_dependency_graph.dot'\n", + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n", + "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", + "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", + "DEBUG:Splitting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m (symbols [g_e, V_m])\n", + "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m]])\n", + "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", + "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot\n", + "DEBUG:os.makedirs('/tmp')\n", + "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot'\n", + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable_before_propagated.dot']\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[22,GLOBAL, INFO]: State variables that will be moved from synapse to neuron: ['post_trace']\n", + "[23,GLOBAL, INFO]: Parameters that will be copied from synapse to neuron: ['tau_tr_post']\n", + "[24,GLOBAL, INFO]: Synaptic state variables moved to neuron that will need buffering: []\n", + "[25,GLOBAL, INFO]: Moving state var defining equation(s) post_trace\n", + "[26,GLOBAL, INFO]: Moving state variables for equation(s) post_trace\n", + "[27,GLOBAL, INFO]: Moving definition of post_trace from synapse to neuron\n", + "[28,GLOBAL, INFO]: \tMoving statement post_trace += 1 # XXX FIXME!!!! should be ``+= post_trace_increment``\n", + "[29,GLOBAL, INFO]: In synapse: replacing ``continuous`` type input ports that are connected to postsynaptic neuron with external variable references\n", + "[30,GLOBAL, INFO]: Copying parameters from synapse to neuron...\n", + "[31,GLOBAL, INFO]: Copying definition of tau_tr_post from synapse to neuron\n", + "[32,GLOBAL, INFO]: Adding suffix to variables in spike updates\n", + "[33,GLOBAL, INFO]: In synapse: replacing variables with suffixed external variable references\n", + "[34,GLOBAL, INFO]: \t• Replacing variable post_trace\n", + "[35,GLOBAL, INFO]: Successfully constructed neuron-synapse pair iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml, neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml\n", + "[36,GLOBAL, INFO]: Analysing/transforming model 'iaf_psc_exp_neuron_nestml'\n", + "[37,iaf_psc_exp_neuron_nestml, INFO, [18:0;58:0]]: Starts processing of the model 'iaf_psc_exp_neuron_nestml'\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable.dot\n", + "DEBUG:os.makedirs('/tmp')\n", + "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable.dot'\n", + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable.dot']\n", + "INFO:Generating propagators for the following symbols: g_e\n", + "DEBUG:Initializing system of shapes with x = Matrix([[g_e]]), A = Matrix([[-1/tau_g]]), b = Matrix([[0]]), c = Matrix([[0]])\n", + "DEBUG:System of equations:\n", + "DEBUG:x = Matrix([[g_e]])\n", + "DEBUG:A = Matrix([[-1/tau_g]])\n", + "DEBUG:b = Matrix([[0]])\n", + "DEBUG:c = Matrix([[0]])\n", + "INFO:update_expr[g_e] = __P__g_e__g_e*g_e\n", + "INFO:Generating numerical solver for the following symbols: V_m\n", + "DEBUG:Initializing system of shapes with x = Matrix([[V_m]]), A = Matrix([[-1/tau_m]]), b = Matrix([[E_l/tau_m + I_e/tau_m + I_stim/tau_m]]), c = Matrix([[E_e*g_e/tau_m - V_m*g_e/tau_m]])\n", + "WARNING:Not preserving expression for variable \"g_e\" as it is solved by propagator solver\n", + "INFO:Preserving expression for variable \"V_m\"\n", + "INFO:In ode-toolbox: returning outdict = \n", + "INFO:[\n", + " {\n", + " \"initial_values\": {\n", + " \"g_e\": \"0.0\"\n", + " },\n", + " \"parameters\": {\n", + " \"tau_g\": \"5.00000000000000\"\n", + " },\n", + " \"propagators\": {\n", + " \"__P__g_e__g_e\": \"exp(-__h/tau_g)\"\n", + " },\n", + " \"solver\": \"analytical\",\n", + " \"state_variables\": [\n", + " \"g_e\"\n", + " ],\n", + " \"update_expressions\": {\n", + " \"g_e\": \"__P__g_e__g_e*g_e\"\n", + " }\n", + " },\n", + " {\n", + " \"initial_values\": {\n", + " \"V_m\": \"E_l\"\n", + " },\n", + " \"parameters\": {\n", + " \"E_e\": \"0\",\n", + " \"E_l\": \"-74.0000000000000\",\n", + " \"I_e\": \"0\",\n", + " \"tau_m\": \"10.0000000000000\"\n", + " },\n", + " \"solver\": \"numeric\",\n", + " \"state_variables\": [\n", + " \"V_m\"\n", + " ],\n", + " \"update_expressions\": {\n", + " \"V_m\": \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\"\n", + " }\n", + " }\n", + "]\n", + "INFO:Analysing input:\n", + "INFO:{\n", + " \"dynamics\": [\n", + " {\n", + " \"expression\": \"g_e' = (-g_e) / tau_g\",\n", + " \"initial_values\": {\n", + " \"g_e\": \"0.0\"\n", + " }\n", + " },\n", + " {\n", + " \"expression\": \"V_m' = (g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\",\n", + " \"initial_values\": {\n", + " \"V_m\": \"E_l\"\n", + " }\n", + " }\n", + " ],\n", + " \"options\": {\n", + " \"output_timestep_symbol\": \"__h\"\n", + " },\n", + " \"parameters\": {\n", + " \"E_e\": \"0\",\n", + " \"E_l\": \"(-74)\",\n", + " \"I_e\": \"0\",\n", + " \"V_reset\": \"(-60)\",\n", + " \"V_th\": \"(-54)\",\n", + " \"s\": \"1000\",\n", + " \"tau_g\": \"5\",\n", + " \"tau_m\": \"10\"\n", + " }\n", + "}\n", + "INFO:Processing global options...\n", + "INFO:Processing input shapes...\n", + "INFO:\n", + "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", + "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_g]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "DEBUG:Created Shape with symbol g_e, derivative_factors = [-1/tau_g], inhom_term = 0.0, nonlin_term = 0.0\n", + "INFO:\tReturning shape: Shape \"g_e\" of order 1\n", + "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", + "INFO:\n", + "Processing differential-equation form shape V_m with defining expression = \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\"\n", + "DEBUG:Splitting expression (E_l + I_e + I_stim - V_m + g_e*(E_e - V_m))/tau_m (symbols [V_m])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_m]])\n", + "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m\n", + "DEBUG:\tnonlinear term: E_e*g_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m\n", + "DEBUG:Created Shape with symbol V_m, derivative_factors = [-1/tau_m], inhom_term = E_l/tau_m + I_e/tau_m, nonlin_term = E_e*g_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m\n", + "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", + "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", + "INFO:All known variables: [g_e, V_m], all parameters used in ODEs: {tau_g, I_stim, E_e, E_l, tau_m, I_e}\n", + "INFO:No numerical value specified for parameter \"I_stim\"\n", + "INFO:\n", + "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", + "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m, g_e])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0], [0]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "DEBUG:Created Shape with symbol g_e, derivative_factors = [-1/tau_g], inhom_term = 0.0, nonlin_term = 0\n", + "INFO:\tReturning shape: Shape \"g_e\" of order 1\n", + "INFO:\n", + "Processing differential-equation form shape V_m with defining expression = \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\"\n", + "DEBUG:Splitting expression (E_l + I_e + I_stim - V_m + g_e*(E_e - V_m))/tau_m (symbols [g_e, V_m, g_e, V_m])\n", + "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m], [0], [0]])\n", + "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", + "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", + "DEBUG:Created Shape with symbol V_m, derivative_factors = [-1/tau_m], inhom_term = E_l/tau_m + I_e/tau_m + I_stim/tau_m, nonlin_term = E_e*g_e/tau_m - V_m*g_e/tau_m\n", + "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", + "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", + "DEBUG:Splitting expression -g_e/tau_g (symbols Matrix([[g_e], [V_m]]))\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", + "DEBUG:Splitting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m (symbols Matrix([[g_e], [V_m]]))\n", + "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m]])\n", + "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", + "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", + "DEBUG:Initializing system of shapes with x = Matrix([[g_e], [V_m]]), A = Matrix([[-1/tau_g, 0], [E_e/tau_m, -1/tau_m]]), b = Matrix([[0], [E_l/tau_m + I_e/tau_m + I_stim/tau_m]]), c = Matrix([[0], [-V_m*g_e/tau_m]])\n", + "INFO:Finding analytically solvable equations...\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", + "DEBUG:os.makedirs('/tmp')\n", + "DEBUG:write lines to '/tmp/ode_dependency_graph.dot'\n", + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n", + "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", + "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", + "DEBUG:Splitting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m (symbols [g_e, V_m])\n", + "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m]])\n", + "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", + "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot\n", + "DEBUG:os.makedirs('/tmp')\n", + "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot'\n", + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable_before_propagated.dot']\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable.dot\n", + "DEBUG:os.makedirs('/tmp')\n", + "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable.dot'\n", + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable.dot']\n", + "INFO:Generating numerical solver for the following symbols: g_e, V_m\n", + "DEBUG:Initializing system of shapes with x = Matrix([[g_e], [V_m]]), A = Matrix([[-1/tau_g, 0], [E_e/tau_m, -1/tau_m]]), b = Matrix([[0], [E_l/tau_m + I_e/tau_m + I_stim/tau_m]]), c = Matrix([[0], [-V_m*g_e/tau_m]])\n", + "INFO:Preserving expression for variable \"g_e\"\n", + "INFO:Preserving expression for variable \"V_m\"\n", + "INFO:In ode-toolbox: returning outdict = \n", + "INFO:[\n", + " {\n", + " \"initial_values\": {\n", + " \"V_m\": \"E_l\",\n", + " \"g_e\": \"0.0\"\n", + " },\n", + " \"parameters\": {\n", + " \"E_e\": \"0\",\n", + " \"E_l\": \"-74.0000000000000\",\n", + " \"I_e\": \"0\",\n", + " \"tau_g\": \"5.00000000000000\",\n", + " \"tau_m\": \"10.0000000000000\"\n", + " },\n", + " \"solver\": \"numeric\",\n", + " \"state_variables\": [\n", + " \"g_e\",\n", + " \"V_m\"\n", + " ],\n", + " \"update_expressions\": {\n", + " \"V_m\": \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\",\n", + " \"g_e\": \"(-g_e) / tau_g\"\n", + " }\n", + " }\n", + "]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:Analysing input:\n", + "INFO:{\n", + " \"dynamics\": [\n", + " {\n", + " \"expression\": \"g_e' = (-g_e) / tau_g\",\n", + " \"initial_values\": {\n", + " \"g_e\": \"0.0\"\n", + " }\n", + " },\n", + " {\n", + " \"expression\": \"V_m' = (g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\",\n", + " \"initial_values\": {\n", + " \"V_m\": \"E_l\"\n", + " }\n", + " },\n", + " {\n", + " \"expression\": \"post_trace__for_neuromodulated_stdp_synapse_nestml' = (-post_trace__for_neuromodulated_stdp_synapse_nestml) / tau_tr_post__for_neuromodulated_stdp_synapse_nestml\",\n", + " \"initial_values\": {\n", + " \"post_trace__for_neuromodulated_stdp_synapse_nestml\": \"0.0\"\n", + " }\n", + " }\n", + " ],\n", + " \"options\": {\n", + " \"output_timestep_symbol\": \"__h\"\n", + " },\n", + " \"parameters\": {\n", + " \"E_e\": \"0\",\n", + " \"E_l\": \"(-74)\",\n", + " \"I_e\": \"0\",\n", + " \"V_reset\": \"(-60)\",\n", + " \"V_th\": \"(-54)\",\n", + " \"s\": \"1000\",\n", + " \"tau_g\": \"5\",\n", + " \"tau_m\": \"10\",\n", + " \"tau_tr_post__for_neuromodulated_stdp_synapse_nestml\": \"10\"\n", + " }\n", + "}\n", + "INFO:Processing global options...\n", + "INFO:Processing input shapes...\n", + "INFO:\n", + "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", + "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_g]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "DEBUG:Created Shape with symbol g_e, derivative_factors = [-1/tau_g], inhom_term = 0.0, nonlin_term = 0.0\n", + "INFO:\tReturning shape: Shape \"g_e\" of order 1\n", + "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", + "INFO:\n", + "Processing differential-equation form shape V_m with defining expression = \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\"\n", + "DEBUG:Splitting expression (E_l + I_e + I_stim - V_m + g_e*(E_e - V_m))/tau_m (symbols [V_m])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_m]])\n", + "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m\n", + "DEBUG:\tnonlinear term: E_e*g_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m\n", + "DEBUG:Created Shape with symbol V_m, derivative_factors = [-1/tau_m], inhom_term = E_l/tau_m + I_e/tau_m, nonlin_term = E_e*g_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m\n", + "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", + "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", + "INFO:\n", + "Processing differential-equation form shape post_trace__for_neuromodulated_stdp_synapse_nestml with defining expression = \"(-post_trace__for_neuromodulated_stdp_synapse_nestml) / tau_tr_post__for_neuromodulated_stdp_synapse_nestml\"\n", + "DEBUG:Splitting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml (symbols [post_trace__for_neuromodulated_stdp_synapse_nestml])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "DEBUG:Created Shape with symbol post_trace__for_neuromodulated_stdp_synapse_nestml, derivative_factors = [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml], inhom_term = 0.0, nonlin_term = 0.0\n", + "INFO:\tReturning shape: Shape \"post_trace__for_neuromodulated_stdp_synapse_nestml\" of order 1\n", + "INFO:Shape post_trace__for_neuromodulated_stdp_synapse_nestml: reconstituting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml\n", + "INFO:All known variables: [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml], all parameters used in ODEs: {tau_g, I_stim, tau_tr_post__for_neuromodulated_stdp_synapse_nestml, E_e, E_l, tau_m, I_e}\n", + "INFO:No numerical value specified for parameter \"I_stim\"\n", + "INFO:\n", + "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", + "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml, g_e])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0], [0], [0]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "DEBUG:Created Shape with symbol g_e, derivative_factors = [-1/tau_g], inhom_term = 0.0, nonlin_term = 0\n", + "INFO:\tReturning shape: Shape \"g_e\" of order 1\n", + "INFO:\n", + "Processing differential-equation form shape V_m with defining expression = \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\"\n", + "DEBUG:Splitting expression (E_l + I_e + I_stim - V_m + g_e*(E_e - V_m))/tau_m (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml, g_e, V_m])\n", + "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m], [0], [0], [0]])\n", + "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", + "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", + "DEBUG:Created Shape with symbol V_m, derivative_factors = [-1/tau_m], inhom_term = E_l/tau_m + I_e/tau_m + I_stim/tau_m, nonlin_term = E_e*g_e/tau_m - V_m*g_e/tau_m\n", + "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", + "INFO:\n", + "Processing differential-equation form shape post_trace__for_neuromodulated_stdp_synapse_nestml with defining expression = \"(-post_trace__for_neuromodulated_stdp_synapse_nestml) / tau_tr_post__for_neuromodulated_stdp_synapse_nestml\"\n", + "DEBUG:Splitting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml, g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml])\n", + "DEBUG:\tlinear factors: Matrix([[0], [0], [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml], [0], [0], [0]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "DEBUG:Created Shape with symbol post_trace__for_neuromodulated_stdp_synapse_nestml, derivative_factors = [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml], inhom_term = 0.0, nonlin_term = 0\n", + "INFO:\tReturning shape: Shape \"post_trace__for_neuromodulated_stdp_synapse_nestml\" of order 1\n", + "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", + "DEBUG:Splitting expression -g_e/tau_g (symbols Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]))\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0], [0]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", + "DEBUG:Splitting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m (symbols Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]))\n", + "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m], [0]])\n", + "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", + "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", + "INFO:Shape post_trace__for_neuromodulated_stdp_synapse_nestml: reconstituting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml\n", + "DEBUG:Splitting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml (symbols Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]))\n", + "DEBUG:\tlinear factors: Matrix([[0], [0], [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "DEBUG:Initializing system of shapes with x = Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]), A = Matrix([[-1/tau_g, 0, 0], [E_e/tau_m, -1/tau_m, 0], [0, 0, -1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]]), b = Matrix([[0], [E_l/tau_m + I_e/tau_m + I_stim/tau_m], [0]]), c = Matrix([[0], [-V_m*g_e/tau_m], [0]])\n", + "INFO:Finding analytically solvable equations...\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", + "DEBUG:os.makedirs('/tmp')\n", + "DEBUG:write lines to '/tmp/ode_dependency_graph.dot'\n", + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n", + "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", + "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0], [0]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", + "DEBUG:Splitting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m], [0]])\n", + "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", + "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", + "INFO:Shape post_trace__for_neuromodulated_stdp_synapse_nestml: reconstituting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml\n", + "DEBUG:Splitting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml])\n", + "DEBUG:\tlinear factors: Matrix([[0], [0], [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot\n", + "DEBUG:os.makedirs('/tmp')\n", + "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot'\n", + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable_before_propagated.dot']\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable.dot\n", + "DEBUG:os.makedirs('/tmp')\n", + "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable.dot'\n", + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable.dot']\n", + "INFO:Generating propagators for the following symbols: g_e, post_trace__for_neuromodulated_stdp_synapse_nestml\n", + "DEBUG:Initializing system of shapes with x = Matrix([[g_e], [post_trace__for_neuromodulated_stdp_synapse_nestml]]), A = Matrix([[-1/tau_g, 0], [0, -1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]]), b = Matrix([[0], [0]]), c = Matrix([[0], [0]])\n", + "DEBUG:System of equations:\n", + "DEBUG:x = Matrix([[g_e], [post_trace__for_neuromodulated_stdp_synapse_nestml]])\n", + "DEBUG:A = Matrix([\n", + "[-1/tau_g, 0],\n", + "[ 0, -1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]])\n", + "DEBUG:b = Matrix([[0], [0]])\n", + "DEBUG:c = Matrix([[0], [0]])\n", + "INFO:update_expr[g_e] = __P__g_e__g_e*g_e\n", + "INFO:update_expr[post_trace__for_neuromodulated_stdp_synapse_nestml] = __P__post_trace__for_neuromodulated_stdp_synapse_nestml__post_trace__for_neuromodulated_stdp_synapse_nestml*post_trace__for_neuromodulated_stdp_synapse_nestml\n", + "INFO:Generating numerical solver for the following symbols: V_m\n", + "DEBUG:Initializing system of shapes with x = Matrix([[V_m]]), A = Matrix([[-1/tau_m]]), b = Matrix([[E_l/tau_m + I_e/tau_m + I_stim/tau_m]]), c = Matrix([[E_e*g_e/tau_m - V_m*g_e/tau_m]])\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", + "INFO:Preserving expression for variable \"V_m\"\n", + "INFO:In ode-toolbox: returning outdict = \n", + "INFO:[\n", + " {\n", + " \"initial_values\": {\n", + " \"g_e\": \"0.0\",\n", + " \"post_trace__for_neuromodulated_stdp_synapse_nestml\": \"0.0\"\n", + " },\n", + " \"parameters\": {\n", + " \"tau_g\": \"5.00000000000000\",\n", + " \"tau_tr_post__for_neuromodulated_stdp_synapse_nestml\": \"10.0000000000000\"\n", + " },\n", + " \"propagators\": {\n", + " \"__P__g_e__g_e\": \"exp(-__h/tau_g)\",\n", + " \"__P__post_trace__for_neuromodulated_stdp_synapse_nestml__post_trace__for_neuromodulated_stdp_synapse_nestml\": \"exp(-__h/tau_tr_post__for_neuromodulated_stdp_synapse_nestml)\"\n", + " },\n", + " \"solver\": \"analytical\",\n", + " \"state_variables\": [\n", + " \"g_e\",\n", + " \"post_trace__for_neuromodulated_stdp_synapse_nestml\"\n", + " ],\n", + " \"update_expressions\": {\n", + " \"g_e\": \"__P__g_e__g_e*g_e\",\n", + " \"post_trace__for_neuromodulated_stdp_synapse_nestml\": \"__P__post_trace__for_neuromodulated_stdp_synapse_nestml__post_trace__for_neuromodulated_stdp_synapse_nestml*post_trace__for_neuromodulated_stdp_synapse_nestml\"\n", + " }\n", + " },\n", + " {\n", + " \"initial_values\": {\n", + " \"V_m\": \"E_l\"\n", + " },\n", + " \"parameters\": {\n", + " \"E_e\": \"0\",\n", + " \"E_l\": \"-74.0000000000000\",\n", + " \"I_e\": \"0\",\n", + " \"tau_m\": \"10.0000000000000\"\n", + " },\n", + " \"solver\": \"numeric\",\n", + " \"state_variables\": [\n", + " \"V_m\"\n", + " ],\n", + " \"update_expressions\": {\n", + " \"V_m\": \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\"\n", + " }\n", + " }\n", + "]\n", + "INFO:Analysing input:\n", + "INFO:{\n", + " \"dynamics\": [\n", + " {\n", + " \"expression\": \"g_e' = (-g_e) / tau_g\",\n", + " \"initial_values\": {\n", + " \"g_e\": \"0.0\"\n", + " }\n", + " },\n", + " {\n", + " \"expression\": \"V_m' = (g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\",\n", + " \"initial_values\": {\n", + " \"V_m\": \"E_l\"\n", + " }\n", + " },\n", + " {\n", + " \"expression\": \"post_trace__for_neuromodulated_stdp_synapse_nestml' = (-post_trace__for_neuromodulated_stdp_synapse_nestml) / tau_tr_post__for_neuromodulated_stdp_synapse_nestml\",\n", + " \"initial_values\": {\n", + " \"post_trace__for_neuromodulated_stdp_synapse_nestml\": \"0.0\"\n", + " }\n", + " }\n", + " ],\n", + " \"options\": {\n", + " \"output_timestep_symbol\": \"__h\"\n", + " },\n", + " \"parameters\": {\n", + " \"E_e\": \"0\",\n", + " \"E_l\": \"(-74)\",\n", + " \"I_e\": \"0\",\n", + " \"V_reset\": \"(-60)\",\n", + " \"V_th\": \"(-54)\",\n", + " \"s\": \"1000\",\n", + " \"tau_g\": \"5\",\n", + " \"tau_m\": \"10\",\n", + " \"tau_tr_post__for_neuromodulated_stdp_synapse_nestml\": \"10\"\n", + " }\n", + "}\n", + "INFO:Processing global options...\n", + "INFO:Processing input shapes...\n", + "INFO:\n", + "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", + "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_g]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "DEBUG:Created Shape with symbol g_e, derivative_factors = [-1/tau_g], inhom_term = 0.0, nonlin_term = 0.0\n", + "INFO:\tReturning shape: Shape \"g_e\" of order 1\n", + "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", + "INFO:\n", + "Processing differential-equation form shape V_m with defining expression = \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\"\n", + "DEBUG:Splitting expression (E_l + I_e + I_stim - V_m + g_e*(E_e - V_m))/tau_m (symbols [V_m])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_m]])\n", + "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m\n", + "DEBUG:\tnonlinear term: E_e*g_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m\n", + "DEBUG:Created Shape with symbol V_m, derivative_factors = [-1/tau_m], inhom_term = E_l/tau_m + I_e/tau_m, nonlin_term = E_e*g_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m\n", + "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", + "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", + "INFO:\n", + "Processing differential-equation form shape post_trace__for_neuromodulated_stdp_synapse_nestml with defining expression = \"(-post_trace__for_neuromodulated_stdp_synapse_nestml) / tau_tr_post__for_neuromodulated_stdp_synapse_nestml\"\n", + "DEBUG:Splitting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml (symbols [post_trace__for_neuromodulated_stdp_synapse_nestml])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "DEBUG:Created Shape with symbol post_trace__for_neuromodulated_stdp_synapse_nestml, derivative_factors = [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml], inhom_term = 0.0, nonlin_term = 0.0\n", + "INFO:\tReturning shape: Shape \"post_trace__for_neuromodulated_stdp_synapse_nestml\" of order 1\n", + "INFO:Shape post_trace__for_neuromodulated_stdp_synapse_nestml: reconstituting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml\n", + "INFO:All known variables: [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml], all parameters used in ODEs: {tau_g, I_stim, tau_tr_post__for_neuromodulated_stdp_synapse_nestml, E_e, E_l, tau_m, I_e}\n", + "INFO:No numerical value specified for parameter \"I_stim\"\n", + "INFO:\n", + "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", + "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml, g_e])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0], [0], [0]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "DEBUG:Created Shape with symbol g_e, derivative_factors = [-1/tau_g], inhom_term = 0.0, nonlin_term = 0\n", + "INFO:\tReturning shape: Shape \"g_e\" of order 1\n", + "INFO:\n", + "Processing differential-equation form shape V_m with defining expression = \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\"\n", + "DEBUG:Splitting expression (E_l + I_e + I_stim - V_m + g_e*(E_e - V_m))/tau_m (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml, g_e, V_m])\n", + "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m], [0], [0], [0]])\n", + "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", + "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", + "DEBUG:Created Shape with symbol V_m, derivative_factors = [-1/tau_m], inhom_term = E_l/tau_m + I_e/tau_m + I_stim/tau_m, nonlin_term = E_e*g_e/tau_m - V_m*g_e/tau_m\n", + "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", + "INFO:\n", + "Processing differential-equation form shape post_trace__for_neuromodulated_stdp_synapse_nestml with defining expression = \"(-post_trace__for_neuromodulated_stdp_synapse_nestml) / tau_tr_post__for_neuromodulated_stdp_synapse_nestml\"\n", + "DEBUG:Splitting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml, g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml])\n", + "DEBUG:\tlinear factors: Matrix([[0], [0], [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml], [0], [0], [0]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "DEBUG:Created Shape with symbol post_trace__for_neuromodulated_stdp_synapse_nestml, derivative_factors = [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml], inhom_term = 0.0, nonlin_term = 0\n", + "INFO:\tReturning shape: Shape \"post_trace__for_neuromodulated_stdp_synapse_nestml\" of order 1\n", + "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", + "DEBUG:Splitting expression -g_e/tau_g (symbols Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]))\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0], [0]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", + "DEBUG:Splitting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m (symbols Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]))\n", + "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m], [0]])\n", + "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", + "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", + "INFO:Shape post_trace__for_neuromodulated_stdp_synapse_nestml: reconstituting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml\n", + "DEBUG:Splitting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml (symbols Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]))\n", + "DEBUG:\tlinear factors: Matrix([[0], [0], [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "DEBUG:Initializing system of shapes with x = Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]), A = Matrix([[-1/tau_g, 0, 0], [E_e/tau_m, -1/tau_m, 0], [0, 0, -1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]]), b = Matrix([[0], [E_l/tau_m + I_e/tau_m + I_stim/tau_m], [0]]), c = Matrix([[0], [-V_m*g_e/tau_m], [0]])\n", + "INFO:Finding analytically solvable equations...\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", + "DEBUG:os.makedirs('/tmp')\n", + "DEBUG:write lines to '/tmp/ode_dependency_graph.dot'\n", + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n", + "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", + "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0], [0]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", + "DEBUG:Splitting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml])\n", + "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m], [0]])\n", + "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", + "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", + "INFO:Shape post_trace__for_neuromodulated_stdp_synapse_nestml: reconstituting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml\n", + "DEBUG:Splitting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml])\n", + "DEBUG:\tlinear factors: Matrix([[0], [0], [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[38,GLOBAL, INFO]: Analysing/transforming model 'iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml'\n", + "[39,iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml, INFO, [18:0;58:0]]: Starts processing of the model 'iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml'\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEBUG:\tnonlinear term: 0.0\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot\n", + "DEBUG:os.makedirs('/tmp')\n", + "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot'\n", + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable_before_propagated.dot']\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable.dot\n", + "DEBUG:os.makedirs('/tmp')\n", + "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable.dot'\n", + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable.dot']\n", + "INFO:Generating numerical solver for the following symbols: g_e, post_trace__for_neuromodulated_stdp_synapse_nestml, V_m\n", + "DEBUG:Initializing system of shapes with x = Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]), A = Matrix([[-1/tau_g, 0, 0], [E_e/tau_m, -1/tau_m, 0], [0, 0, -1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]]), b = Matrix([[0], [E_l/tau_m + I_e/tau_m + I_stim/tau_m], [0]]), c = Matrix([[0], [-V_m*g_e/tau_m], [0]])\n", + "INFO:Preserving expression for variable \"g_e\"\n", + "INFO:Preserving expression for variable \"V_m\"\n", + "INFO:Preserving expression for variable \"post_trace__for_neuromodulated_stdp_synapse_nestml\"\n", + "INFO:In ode-toolbox: returning outdict = \n", + "INFO:[\n", + " {\n", + " \"initial_values\": {\n", + " \"V_m\": \"E_l\",\n", + " \"g_e\": \"0.0\",\n", + " \"post_trace__for_neuromodulated_stdp_synapse_nestml\": \"0.0\"\n", + " },\n", + " \"parameters\": {\n", + " \"E_e\": \"0\",\n", + " \"E_l\": \"-74.0000000000000\",\n", + " \"I_e\": \"0\",\n", + " \"tau_g\": \"5.00000000000000\",\n", + " \"tau_m\": \"10.0000000000000\",\n", + " \"tau_tr_post__for_neuromodulated_stdp_synapse_nestml\": \"10.0000000000000\"\n", + " },\n", + " \"solver\": \"numeric\",\n", + " \"state_variables\": [\n", + " \"g_e\",\n", + " \"V_m\",\n", + " \"post_trace__for_neuromodulated_stdp_synapse_nestml\"\n", + " ],\n", + " \"update_expressions\": {\n", + " \"V_m\": \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\",\n", + " \"g_e\": \"(-g_e) / tau_g\",\n", + " \"post_trace__for_neuromodulated_stdp_synapse_nestml\": \"(-post_trace__for_neuromodulated_stdp_synapse_nestml) / tau_tr_post__for_neuromodulated_stdp_synapse_nestml\"\n", + " }\n", + " }\n", + "]\n", + "INFO:Analysing input:\n", + "INFO:{\n", + " \"dynamics\": [\n", + " {\n", + " \"expression\": \"pre_trace' = (-pre_trace) / tau_tr_pre\",\n", + " \"initial_values\": {\n", + " \"pre_trace\": \"0.0\"\n", + " }\n", + " },\n", + " {\n", + " \"expression\": \"wtr' = (-wtr) / tau_wtr\",\n", + " \"initial_values\": {\n", + " \"wtr\": \"0\"\n", + " }\n", + " }\n", + " ],\n", + " \"options\": {\n", + " \"output_timestep_symbol\": \"__h\"\n", + " },\n", + " \"parameters\": {\n", + " \"beta\": \"0.01\",\n", + " \"d\": \"1\",\n", + " \"n\": \"0.0\",\n", + " \"post_trace_increment\": \"1.0\",\n", + " \"pre_trace_increment\": \"1.0\",\n", + " \"tau_tr_post\": \"10\",\n", + " \"tau_tr_pre\": \"10\",\n", + " \"tau_wtr\": \"100\",\n", + " \"wtr_max\": \"0.1\",\n", + " \"wtr_min\": \"0\"\n", + " }\n", + "}\n", + "INFO:Processing global options...\n", + "INFO:Processing input shapes...\n", + "INFO:\n", + "Processing differential-equation form shape pre_trace with defining expression = \"(-pre_trace) / tau_tr_pre\"\n", + "DEBUG:Splitting expression -pre_trace/tau_tr_pre (symbols [pre_trace])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_tr_pre]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "DEBUG:Created Shape with symbol pre_trace, derivative_factors = [-1/tau_tr_pre], inhom_term = 0.0, nonlin_term = 0.0\n", + "INFO:\tReturning shape: Shape \"pre_trace\" of order 1\n", + "INFO:Shape pre_trace: reconstituting expression -pre_trace/tau_tr_pre\n", + "INFO:\n", + "Processing differential-equation form shape wtr with defining expression = \"(-wtr) / tau_wtr\"\n", + "DEBUG:Splitting expression -wtr/tau_wtr (symbols [wtr])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_wtr]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "DEBUG:Created Shape with symbol wtr, derivative_factors = [-1/tau_wtr], inhom_term = 0.0, nonlin_term = 0.0\n", + "INFO:\tReturning shape: Shape \"wtr\" of order 1\n", + "INFO:Shape wtr: reconstituting expression -wtr/tau_wtr\n", + "INFO:All known variables: [pre_trace, wtr], all parameters used in ODEs: {tau_tr_pre, tau_wtr}\n", + "INFO:\n", + "Processing differential-equation form shape pre_trace with defining expression = \"(-pre_trace) / tau_tr_pre\"\n", + "DEBUG:Splitting expression -pre_trace/tau_tr_pre (symbols [pre_trace, wtr, pre_trace])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_tr_pre], [0], [0]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "DEBUG:Created Shape with symbol pre_trace, derivative_factors = [-1/tau_tr_pre], inhom_term = 0.0, nonlin_term = 0\n", + "INFO:\tReturning shape: Shape \"pre_trace\" of order 1\n", + "INFO:\n", + "Processing differential-equation form shape wtr with defining expression = \"(-wtr) / tau_wtr\"\n", + "DEBUG:Splitting expression -wtr/tau_wtr (symbols [pre_trace, wtr, pre_trace, wtr])\n", + "DEBUG:\tlinear factors: Matrix([[0], [-1/tau_wtr], [0], [0]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "DEBUG:Created Shape with symbol wtr, derivative_factors = [-1/tau_wtr], inhom_term = 0.0, nonlin_term = 0\n", + "INFO:\tReturning shape: Shape \"wtr\" of order 1\n", + "INFO:Shape pre_trace: reconstituting expression -pre_trace/tau_tr_pre\n", + "DEBUG:Splitting expression -pre_trace/tau_tr_pre (symbols Matrix([[pre_trace], [wtr]]))\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_tr_pre], [0]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "INFO:Shape wtr: reconstituting expression -wtr/tau_wtr\n", + "DEBUG:Splitting expression -wtr/tau_wtr (symbols Matrix([[pre_trace], [wtr]]))\n", + "DEBUG:\tlinear factors: Matrix([[0], [-1/tau_wtr]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "DEBUG:Initializing system of shapes with x = Matrix([[pre_trace], [wtr]]), A = Matrix([[-1/tau_tr_pre, 0], [0, -1/tau_wtr]]), b = Matrix([[0], [0]]), c = Matrix([[0], [0]])\n", + "INFO:Finding analytically solvable equations...\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", + "DEBUG:os.makedirs('/tmp')\n", + "DEBUG:write lines to '/tmp/ode_dependency_graph.dot'\n", + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n", + "INFO:Shape pre_trace: reconstituting expression -pre_trace/tau_tr_pre\n", + "DEBUG:Splitting expression -pre_trace/tau_tr_pre (symbols [pre_trace, wtr])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_tr_pre], [0]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "INFO:Shape wtr: reconstituting expression -wtr/tau_wtr\n", + "DEBUG:Splitting expression -wtr/tau_wtr (symbols [pre_trace, wtr])\n", + "DEBUG:\tlinear factors: Matrix([[0], [-1/tau_wtr]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot\n", + "DEBUG:os.makedirs('/tmp')\n", + "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot'\n", + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable_before_propagated.dot']\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable.dot\n", + "DEBUG:os.makedirs('/tmp')\n", + "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable.dot'\n", + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable.dot']\n", + "INFO:Generating propagators for the following symbols: pre_trace, wtr\n", + "DEBUG:Initializing system of shapes with x = Matrix([[pre_trace], [wtr]]), A = Matrix([[-1/tau_tr_pre, 0], [0, -1/tau_wtr]]), b = Matrix([[0], [0]]), c = Matrix([[0], [0]])\n", + "DEBUG:System of equations:\n", + "DEBUG:x = Matrix([[pre_trace], [wtr]])\n", + "DEBUG:A = Matrix([\n", + "[-1/tau_tr_pre, 0],\n", + "[ 0, -1/tau_wtr]])\n", + "DEBUG:b = Matrix([[0], [0]])\n", + "DEBUG:c = Matrix([[0], [0]])\n", + "INFO:update_expr[pre_trace] = __P__pre_trace__pre_trace*pre_trace\n", + "INFO:update_expr[wtr] = __P__wtr__wtr*wtr\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", + "INFO:In ode-toolbox: returning outdict = \n", + "INFO:[\n", + " {\n", + " \"initial_values\": {\n", + " \"pre_trace\": \"0.0\",\n", + " \"wtr\": \"0\"\n", + " },\n", + " \"parameters\": {\n", + " \"tau_tr_pre\": \"10.0000000000000\",\n", + " \"tau_wtr\": \"100.000000000000\"\n", + " },\n", + " \"propagators\": {\n", + " \"__P__pre_trace__pre_trace\": \"exp(-__h/tau_tr_pre)\",\n", + " \"__P__wtr__wtr\": \"exp(-__h/tau_wtr)\"\n", + " },\n", + " \"solver\": \"analytical\",\n", + " \"state_variables\": [\n", + " \"pre_trace\",\n", + " \"wtr\"\n", + " ],\n", + " \"update_expressions\": {\n", + " \"pre_trace\": \"__P__pre_trace__pre_trace*pre_trace\",\n", + " \"wtr\": \"__P__wtr__wtr*wtr\"\n", + " }\n", + " }\n", + "]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[40,GLOBAL, INFO]: Analysing/transforming synapse neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.\n", + "[41,neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml, INFO, [6:0;55:0]]: Starts processing of the model 'neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml'\n", + "[42,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp\n", + "[43,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.h\n", + "[44,iaf_psc_exp_neuron_nestml, INFO, [18:0;58:0]]: Successfully generated code for the model: 'iaf_psc_exp_neuron_nestml' in: '/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target' !\n", + "[45,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp\n", + "[46,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.h\n", + "[47,iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml, INFO, [18:0;58:0]]: Successfully generated code for the model: 'iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml' in: '/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target' !\n", + "[48,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h\n", + "[49,neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml, INFO, [6:0;55:0]]: Successfully generated code for the model: 'neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml' in: '/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target' !\n", + "[50,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/nestml_5db106a63cc54757ab6af013c5525511_module.cpp\n", + "[51,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/nestml_5db106a63cc54757ab6af013c5525511_module.h\n", + "[52,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/CMakeLists.txt\n", + "[53,GLOBAL, INFO]: Successfully generated NEST module code in '/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target' !\n", + "CMake Warning (dev) at CMakeLists.txt:95 (project):\n", + " cmake_minimum_required() should be called prior to this top-level project()\n", + " call. Please see the cmake-commands(7) manual for usage documentation of\n", + " both commands.\n", + "This warning is for project developers. Use -Wno-dev to suppress it.\n", + "\n", + "-- The CXX compiler identification is GNU 12.3.0\n", + "-- Detecting CXX compiler ABI info\n", + "-- Detecting CXX compiler ABI info - done\n", + "-- Check for working CXX compiler: /usr/bin/c++ - skipped\n", + "-- Detecting CXX compile features\n", + "-- Detecting CXX compile features - done\n", + "\n", + "-------------------------------------------------------\n", + "nestml_5db106a63cc54757ab6af013c5525511_module Configuration Summary\n", + "-------------------------------------------------------\n", + "\n", + "C++ compiler : /usr/bin/c++\n", + "Build static libs : OFF\n", + "C++ compiler flags : \n", + "NEST compiler flags : -std=c++17 -Wall -fopenmp -O2 -fdiagnostics-color=auto\n", + "NEST include dirs : -I/home/charl/julich/nest-simulator-install/include/nest -I/usr/include -I/usr/local/include -I/usr/include\n", + "NEST libraries flags : -L/home/charl/julich/nest-simulator-install/lib/nest -lnest -lsli /usr/lib/x86_64-linux-gnu/libltdl.so /usr/local/lib/libgsl.so /usr/local/lib/libgslcblas.so /usr/lib/gcc/x86_64-linux-gnu/12/libgomp.so /usr/lib/x86_64-linux-gnu/libpthread.a\n", + "\n", + "-------------------------------------------------------\n", + "\n", + "You can now build and install 'nestml_5db106a63cc54757ab6af013c5525511_module' using\n", + " make\n", + " make install\n", + "\n", + "The library file libnestml_5db106a63cc54757ab6af013c5525511_module.so will be installed to\n", + " /tmp/nestml_target_bluoj7hw\n", + "The module can be loaded into NEST using\n", + " (nestml_5db106a63cc54757ab6af013c5525511_module) Install (in SLI)\n", + " nest.Install(nestml_5db106a63cc54757ab6af013c5525511_module) (in PyNEST)\n", + "\n", + "CMake Warning (dev) in CMakeLists.txt:\n", + " No cmake_minimum_required command is present. A line of code such as\n", + "\n", + " cmake_minimum_required(VERSION 3.26)\n", + "\n", + " should be added at the top of the file. The version specified may be lower\n", + " if you wish to support older CMake versions for this project. For more\n", + " information run \"cmake --help-policy CMP0000\".\n", + "This warning is for project developers. Use -Wno-dev to suppress it.\n", + "\n", + "-- Configuring done (0.1s)\n", + "-- Generating done (0.0s)\n", + "-- Build files have been written to: /home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target\n", + "[ 25%] Building CXX object CMakeFiles/nestml_5db106a63cc54757ab6af013c5525511_module_module.dir/nestml_5db106a63cc54757ab6af013c5525511_module.o\n", + "[ 50%] Building CXX object CMakeFiles/nestml_5db106a63cc54757ab6af013c5525511_module_module.dir/iaf_psc_exp_neuron_nestml.o\n", + "[ 75%] Building CXX object CMakeFiles/nestml_5db106a63cc54757ab6af013c5525511_module_module.dir/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.o\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml::init_state_internal_()’:\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:201:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 201 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml::recompute_internal_variables(bool)’:\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:290:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 290 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp: In function ‘int iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml_dynamics_post_trace__for_neuromodulated_stdp_synapse_nestml(double, const double*, double*, void*)’:\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:347:77: warning: unused variable ‘node’ [-Wunused-variable]\n", + " 347 | const iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml& node = *( reinterpret_cast< iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml* >( pnode ) );\n", + " | ^~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp: In member function ‘virtual void iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml::update(const nest::Time&, long int, long int)’:\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:375:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", + " 375 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", + " | ~~^~~~~~~~~~~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:366:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 366 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:360:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 360 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml::on_receive_block_spikes_in_port()’:\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:537:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 537 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml::init_state_internal_()’:\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:191:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 191 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml::recompute_internal_variables(bool)’:\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:271:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 271 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘virtual void iaf_psc_exp_neuron_nestml::update(const nest::Time&, long int, long int)’:\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:337:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", + " 337 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", + " | ~~^~~~~~~~~~~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:328:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 328 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:322:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 322 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml::on_receive_block_spikes_in_port()’:\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:496:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 496 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n", + "In file included from /home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/nestml_5db106a63cc54757ab6af013c5525511_module.cpp:36:\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:62:5: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:613:104: required from here\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:746:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 746 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘void nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::recompute_internal_variables() [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:760:3: required from ‘nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierPtrRport]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:62:5: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:613:104: required from here\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:733:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 733 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:103:34: required from ‘void nest::ModelManager::register_specific_connection_model_(const std::string&) [with CompleteConnecionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:67:80: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:613:104: required from here\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:746:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 746 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘void nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::recompute_internal_variables() [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:760:3: required from ‘nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierIndex]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:103:34: required from ‘void nest::ModelManager::register_specific_connection_model_(const std::string&) [with CompleteConnecionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:67:80: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:613:104: required from here\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:733:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 733 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘bool nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::send(nest::Event&, size_t, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport; size_t = long unsigned int]’:\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; size_t = long unsigned int]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:517:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 517 | auto get_t = [t_hist_entry_ms](){ return t_hist_entry_ms; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:546:12: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 546 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:587:12: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 587 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:442:18: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 442 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:444:10: warning: variable ‘get_thread’ set but not used [-Wunused-but-set-variable]\n", + " 444 | auto get_thread = [tid]()\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘bool nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::send(nest::Event&, size_t, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex; size_t = long unsigned int]’:\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; size_t = long unsigned int]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:517:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 517 | auto get_t = [t_hist_entry_ms](){ return t_hist_entry_ms; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:546:12: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 546 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:587:12: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 587 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:442:18: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 442 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:444:10: warning: variable ‘get_thread’ set but not used [-Wunused-but-set-variable]\n", + " 444 | auto get_thread = [tid]()\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘void nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::update_internal_state_(double, double, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:512:9: required from ‘bool nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::send(nest::Event&, size_t, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport; size_t = long unsigned int]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; size_t = long unsigned int]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:812:18: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 812 | const double __timestep = timestep; // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:813:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 813 | auto get_t = [t_start](){ return t_start; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘void nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::update_internal_state_(double, double, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:512:9: required from ‘bool nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::send(nest::Event&, size_t, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex; size_t = long unsigned int]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; size_t = long unsigned int]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:812:18: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 812 | const double __timestep = timestep; // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:813:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 813 | auto get_t = [t_start](){ return t_start; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", + " | ^~~~~\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[100%] Linking CXX shared module nestml_5db106a63cc54757ab6af013c5525511_module.so\n", + "[100%] Built target nestml_5db106a63cc54757ab6af013c5525511_module_module\n", + "[100%] Built target nestml_5db106a63cc54757ab6af013c5525511_module_module\n", + "Install the project...\n", + "-- Install configuration: \"\"\n", + "-- Installing: /tmp/nestml_target_bluoj7hw/nestml_5db106a63cc54757ab6af013c5525511_module.so\n" + ] + } + ], + "source": [ + "# ... generate NESTML model code...\n", + "\n", + "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=\"DEBUG\",\n", + " codegen_opts={\"delay_variable\": {\"neuromodulated_stdp_synapse\": \"d\"},\n", + " \"weight_variable\": {\"neuromodulated_stdp_synapse\": \"w\"}})" + ] + }, + { + "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.constant_reward = -1.\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 = .01 # [ms]\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,# + nest.random.uniform(min=0.0, max=1.0) * 0.2, # XXX: \"R_STDP\" script has ``0.05+rand()*0.001`` instead of ``0.1+rand()*0.02``\n", + " #\"delay\": nest.resolution, # XXX: this slows the simulation down drastically!\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", + "# print(\"after network init:\")\n", + "# print(\"\\tbefore w = \" + str(syn.w))\n", + "# print(\"\\tbefore wtr = \" + str(syn.wtr))\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", + " \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", + "# ax[0].set_ylim(0.005, 0.3)\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", + "# print(\"n_events_in_last_interval_left = \" + str(n_events_in_last_interval_left))\n", + "# print(\"n_events_in_last_interval_right = \" + str(n_events_in_last_interval_right))\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", + " Options:\n", + " 1) 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\n", + "\n", + " 2) potential_val = 10 * self.env._height(position)\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", + " 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 #0 * (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", + "# print(\"Updating synaptic weights\")\n", + "\n", + " if Q_old is None:\n", + " return\n", + "\n", + "# print(\"reward = \" + str(reward))\n", + "# print(\"Q_new = \" + str(Q_new))\n", + "# print(\"Q_old = \" + str(Q_old))\n", + " TD = self.discount_factor * Q_new + 10 * reward - Q_old\n", + "\n", + " if action == AgentAction.RIGHT:\n", + "# print(\"\\tLast chosen action = RIGHT\")\n", + "# print(\"\\tbefore w = \" + str(self.syn_right.w))\n", + "# print(\"\\tbefore wtr = \" + str(self.syn_right.wtr))\n", + "\n", + " # w = np.array(self.syn_right.w)\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", + "# print(\"Chosen action = LEFT\")\n", + "# print(\"\\tbefore w = \" + str(self.syn_left.w))\n", + "# print(\"\\tbefore wtr = \" + str(self.syn_left.wtr))\n", + "\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": "566fa9c9", + "metadata": {}, + "source": [ + "# Executing spiking version\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\n", + " - run the SNN with this input state for a period of time (cycle time, e.g. 10-50 ms)\n", + " - (wtr is computed in each synapse)\n", + "- action is selected based on output neuron firing, by counting the number of spikes in the output population over this cycle period\n", + "- environment is updated based on action; run the environment for the same cycle time (40 ms) to obtain next state\n", + "- reward is computed (neuromodulator signal is proportional to reward)\n", + "- synapses that were active (between input and output neurons) have their weights updated (based on wtr * reward)\n", + "- wtr of all synapses is reset back to 0" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "e4bda6d4", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode 0 took: 2.396 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -14.429986275364584\n", + "Episode 1 took: 3.628 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -2.3097269263348172\n", + "Episode 2 took: 2.961 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -5.745195530886559\n", + "Episode 3 took: 3.045 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -5.162839260667261\n", + "Episode 4 took: 3.265 s\n", + "\tNumber of steps in episode = 494\n", + "\tTotal reward = -2.0093830106173436\n", + "Episode 5 took: 3.367 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -3.484248105324001\n", + "Episode 6 took: 3.025 s\n", + "\tNumber of steps in episode = 442\n", + "\tTotal reward = -0.862316426913704\n", + "Episode 7 took: 3.484 s\n", + "\tNumber of steps in episode = 492\n", + "\tTotal reward = -2.4798809287375443\n", + "Episode 8 took: 3.590 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -3.6967923126483626\n", + "Episode 9 took: 3.649 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -8.838109664200717\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_135852/3878736473.py:131: 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_135852/3878736473.py:146: 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", + "DEBUG:locator: \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode 10 took: 3.902 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -8.474306970260933\n", + "Episode 11 took: 14.914 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -4.171496431406933\n", + "Episode 12 took: 4.832 s\n", + "\tNumber of steps in episode = 488\n", + "\tTotal reward = -1.5529026859427615\n", + "Episode 13 took: 9.974 s\n", + "\tNumber of steps in episode = 488\n", + "\tTotal reward = -2.1662564152294133\n", + "Episode 14 took: 3.491 s\n", + "\tNumber of steps in episode = 457\n", + "\tTotal reward = -2.332099267964661\n", + "Episode 15 took: 3.936 s\n", + "\tNumber of steps in episode = 468\n", + "\tTotal reward = -3.974842668742503\n", + "Episode 16 took: 4.558 s\n", + "\tNumber of steps in episode = 498\n", + "\tTotal reward = -4.235195462609564\n", + "Episode 17 took: 4.816 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -4.266898108741331\n", + "Episode 18 took: 4.706 s\n", + "\tNumber of steps in episode = 493\n", + "\tTotal reward = -2.2962522883292382\n", + "Episode 19 took: 4.718 s\n", + "\tNumber of steps in episode = 488\n", + "\tTotal reward = -1.738135771043018\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_135852/3878736473.py:131: 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_135852/3878736473.py:146: 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", + "DEBUG:locator: \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode 20 took: 4.254 s\n", + "\tNumber of steps in episode = 460\n", + "\tTotal reward = -0.5980166104265345\n", + "Episode 21 took: 4.664 s\n", + "\tNumber of steps in episode = 492\n", + "\tTotal reward = -3.2709305203253445\n", + "Episode 22 took: 4.711 s\n", + "\tNumber of steps in episode = 483\n", + "\tTotal reward = -2.3639374756658995\n", + "Episode 23 took: 4.770 s\n", + "\tNumber of steps in episode = 483\n", + "\tTotal reward = -2.2573473423086354\n", + "Episode 24 took: 4.600 s\n", + "\tNumber of steps in episode = 457\n", + "\tTotal reward = -1.7980199520269358\n", + "Episode 25 took: 4.615 s\n", + "\tNumber of steps in episode = 451\n", + "\tTotal reward = -1.8367791521574466\n", + "Episode 26 took: 5.135 s\n", + "\tNumber of steps in episode = 487\n", + "\tTotal reward = -1.0770105658971882\n", + "Episode 27 took: 5.256 s\n", + "\tNumber of steps in episode = 495\n", + "\tTotal reward = -2.0753492849253092\n", + "Episode 28 took: 4.865 s\n", + "\tNumber of steps in episode = 444\n", + "\tTotal reward = 0.3497993620438027\n", + "Episode 29 took: 5.040 s\n", + "\tNumber of steps in episode = 448\n", + "\tTotal reward = -0.8937316034708713\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_135852/3878736473.py:131: 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_135852/3878736473.py:146: 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", + "DEBUG:locator: \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode 30 took: 5.858 s\n", + "\tNumber of steps in episode = 495\n", + "\tTotal reward = -2.5366703341895085\n", + "Episode 31 took: 6.025 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -9.732158962214742\n", + "Episode 32 took: 6.119 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -4.084983674777322\n", + "Episode 33 took: 6.191 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -10.332046367056178\n", + "Episode 34 took: 6.290 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -4.625961740618313\n", + "Episode 35 took: 5.713 s\n", + "\tNumber of steps in episode = 448\n", + "\tTotal reward = -0.7424877650462732\n", + "Episode 36 took: 6.509 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -10.412757866309805\n", + "Episode 37 took: 6.542 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -6.646176399187974\n", + "Episode 38 took: 6.379 s\n", + "\tNumber of steps in episode = 480\n", + "\tTotal reward = -2.5253841298115454\n", + "Episode 39 took: 6.627 s\n", + "\tNumber of steps in episode = 492\n", + "\tTotal reward = -2.867692170935876\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_135852/3878736473.py:131: 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_135852/3878736473.py:146: 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", + "DEBUG:locator: \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode 40 took: 6.514 s\n", + "\tNumber of steps in episode = 491\n", + "\tTotal reward = -2.506865882547583\n", + "Episode 41 took: 6.743 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -3.625091740399541\n", + "Episode 42 took: 6.853 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -10.180668926668451\n", + "Episode 43 took: 6.958 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -8.193412170871625\n", + "Episode 44 took: 6.738 s\n", + "\tNumber of steps in episode = 470\n", + "\tTotal reward = -0.5849281891564296\n", + "Episode 45 took: 7.018 s\n", + "\tNumber of steps in episode = 481\n", + "\tTotal reward = -1.518052722351252\n", + "Episode 46 took: 7.240 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -7.974870087397576\n", + "Episode 47 took: 7.327 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -5.526891330796331\n", + "Episode 48 took: 7.398 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -3.609195444307881\n", + "Episode 49 took: 7.381 s\n", + "\tNumber of steps in episode = 488\n", + "\tTotal reward = -4.725225310960246\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_135852/3878736473.py:131: 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_135852/3878736473.py:146: 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", + "DEBUG:locator: \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 # was: 0.01\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", + " step_reward += -.01\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", + "For high firing rates, STDP basically becomes a purely rate-based rule: weights are predominantely potentiated (rather than depressed) for higher pre- and higher post-synaptic firing rates.\n", + "\n", + "\"Gating\" the weight updates: only the connections between the input neuron that are active, and the 10 output layer neurons for the action that was chosen, will be updated.\n", + "\n", + "The neuromodulator determines the sign and magnitude of the update, based on TD signal" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "d624cd2e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Simulating pre_rate=5.0 Hz, post_rate=5.0 Hz\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/lib/python3/dist-packages/pythran/tables.py:4530: FutureWarning:In the future `np.bool` will be defined as the corresponding NumPy scalar.\n", + "/usr/lib/python3/dist-packages/pythran/tables.py:4563: FutureWarning:In the future `np.bytes` will be defined as the corresponding NumPy scalar.\n", + "WARNING 'dt' is an internal variable of group 'poissongroup_1', but also exists in the run namespace with the value 100. * usecond. The internal variable will be used. [brian2.groups.group.Group.resolve.resolution_conflict]\n", + "WARNING 'dt' is an internal variable of group 'poissongroup', but also exists in the run namespace with the value 100. * usecond. The internal variable will be used. [brian2.groups.group.Group.resolve.resolution_conflict]\n", + "WARNING 'dt' is an internal variable of group 'poissongroup_2', but also exists in the run namespace with the value 100. * usecond. The internal variable will be used. [brian2.groups.group.Group.resolve.resolution_conflict]\n", + "WARNING 'dt' is an internal variable of group 'poissongroup_3', but also exists in the run namespace with the value 100. * usecond. The internal variable will be used. [brian2.groups.group.Group.resolve.resolution_conflict]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Simulating pre_rate=5.0 Hz, post_rate=15.555555555555555 Hz\n", + "Simulating pre_rate=5.0 Hz, post_rate=26.11111111111111 Hz\n", + "Simulating pre_rate=5.0 Hz, post_rate=36.666666666666664 Hz\n", + "Simulating pre_rate=5.0 Hz, post_rate=47.22222222222222 Hz\n", + "Simulating pre_rate=5.0 Hz, post_rate=57.77777777777778 Hz\n", + "Simulating pre_rate=5.0 Hz, post_rate=68.33333333333333 Hz\n", + "Simulating pre_rate=5.0 Hz, post_rate=78.88888888888889 Hz\n", + "Simulating pre_rate=5.0 Hz, post_rate=89.44444444444444 Hz\n", + "Simulating pre_rate=5.0 Hz, post_rate=100.0 Hz\n", + "Simulating pre_rate=15.555555555555555 Hz, post_rate=5.0 Hz\n", + "Simulating pre_rate=15.555555555555555 Hz, post_rate=15.555555555555555 Hz\n", + "Simulating pre_rate=15.555555555555555 Hz, post_rate=26.11111111111111 Hz\n", + "Simulating pre_rate=15.555555555555555 Hz, post_rate=36.666666666666664 Hz\n", + "Simulating pre_rate=15.555555555555555 Hz, post_rate=47.22222222222222 Hz\n", + "Simulating pre_rate=15.555555555555555 Hz, post_rate=57.77777777777778 Hz\n", + "Simulating pre_rate=15.555555555555555 Hz, post_rate=68.33333333333333 Hz\n", + "Simulating pre_rate=15.555555555555555 Hz, post_rate=78.88888888888889 Hz\n", + "Simulating pre_rate=15.555555555555555 Hz, post_rate=89.44444444444444 Hz\n", + "Simulating pre_rate=15.555555555555555 Hz, post_rate=100.0 Hz\n", + "Simulating pre_rate=26.11111111111111 Hz, post_rate=5.0 Hz\n", + "Simulating pre_rate=26.11111111111111 Hz, post_rate=15.555555555555555 Hz\n", + "Simulating pre_rate=26.11111111111111 Hz, post_rate=26.11111111111111 Hz\n", + "Simulating pre_rate=26.11111111111111 Hz, post_rate=36.666666666666664 Hz\n", + "Simulating pre_rate=26.11111111111111 Hz, post_rate=47.22222222222222 Hz\n", + "Simulating pre_rate=26.11111111111111 Hz, post_rate=57.77777777777778 Hz\n", + "Simulating pre_rate=26.11111111111111 Hz, post_rate=68.33333333333333 Hz\n", + "Simulating pre_rate=26.11111111111111 Hz, post_rate=78.88888888888889 Hz\n", + "Simulating pre_rate=26.11111111111111 Hz, post_rate=89.44444444444444 Hz\n", + "Simulating pre_rate=26.11111111111111 Hz, post_rate=100.0 Hz\n", + "Simulating pre_rate=36.666666666666664 Hz, post_rate=5.0 Hz\n", + "Simulating pre_rate=36.666666666666664 Hz, post_rate=15.555555555555555 Hz\n", + "Simulating pre_rate=36.666666666666664 Hz, post_rate=26.11111111111111 Hz\n", + "Simulating pre_rate=36.666666666666664 Hz, post_rate=36.666666666666664 Hz\n", + "Simulating pre_rate=36.666666666666664 Hz, post_rate=47.22222222222222 Hz\n", + "Simulating pre_rate=36.666666666666664 Hz, post_rate=57.77777777777778 Hz\n", + "Simulating pre_rate=36.666666666666664 Hz, post_rate=68.33333333333333 Hz\n", + "Simulating pre_rate=36.666666666666664 Hz, post_rate=78.88888888888889 Hz\n", + "Simulating pre_rate=36.666666666666664 Hz, post_rate=89.44444444444444 Hz\n", + "Simulating pre_rate=36.666666666666664 Hz, post_rate=100.0 Hz\n", + "Simulating pre_rate=47.22222222222222 Hz, post_rate=5.0 Hz\n", + "Simulating pre_rate=47.22222222222222 Hz, post_rate=15.555555555555555 Hz\n", + "Simulating pre_rate=47.22222222222222 Hz, post_rate=26.11111111111111 Hz\n", + "Simulating pre_rate=47.22222222222222 Hz, post_rate=36.666666666666664 Hz\n", + "Simulating pre_rate=47.22222222222222 Hz, post_rate=47.22222222222222 Hz\n", + "Simulating pre_rate=47.22222222222222 Hz, post_rate=57.77777777777778 Hz\n", + "Simulating pre_rate=47.22222222222222 Hz, post_rate=68.33333333333333 Hz\n", + "Simulating pre_rate=47.22222222222222 Hz, post_rate=78.88888888888889 Hz\n", + "Simulating pre_rate=47.22222222222222 Hz, post_rate=89.44444444444444 Hz\n", + "Simulating pre_rate=47.22222222222222 Hz, post_rate=100.0 Hz\n", + "Simulating pre_rate=57.77777777777778 Hz, post_rate=5.0 Hz\n", + "Simulating pre_rate=57.77777777777778 Hz, post_rate=15.555555555555555 Hz\n", + "Simulating pre_rate=57.77777777777778 Hz, post_rate=26.11111111111111 Hz\n", + "Simulating pre_rate=57.77777777777778 Hz, post_rate=36.666666666666664 Hz\n", + "Simulating pre_rate=57.77777777777778 Hz, post_rate=47.22222222222222 Hz\n", + "Simulating pre_rate=57.77777777777778 Hz, post_rate=57.77777777777778 Hz\n", + "Simulating pre_rate=57.77777777777778 Hz, post_rate=68.33333333333333 Hz\n", + "Simulating pre_rate=57.77777777777778 Hz, post_rate=78.88888888888889 Hz\n", + "Simulating pre_rate=57.77777777777778 Hz, post_rate=89.44444444444444 Hz\n", + "Simulating pre_rate=57.77777777777778 Hz, post_rate=100.0 Hz\n", + "Simulating pre_rate=68.33333333333333 Hz, post_rate=5.0 Hz\n", + "Simulating pre_rate=68.33333333333333 Hz, post_rate=15.555555555555555 Hz\n", + "Simulating pre_rate=68.33333333333333 Hz, post_rate=26.11111111111111 Hz\n", + "Simulating pre_rate=68.33333333333333 Hz, post_rate=36.666666666666664 Hz\n", + "Simulating pre_rate=68.33333333333333 Hz, post_rate=47.22222222222222 Hz\n", + "Simulating pre_rate=68.33333333333333 Hz, post_rate=57.77777777777778 Hz\n", + "Simulating pre_rate=68.33333333333333 Hz, post_rate=68.33333333333333 Hz\n", + "Simulating pre_rate=68.33333333333333 Hz, post_rate=78.88888888888889 Hz\n", + "Simulating pre_rate=68.33333333333333 Hz, post_rate=89.44444444444444 Hz\n", + "Simulating pre_rate=68.33333333333333 Hz, post_rate=100.0 Hz\n", + "Simulating pre_rate=78.88888888888889 Hz, post_rate=5.0 Hz\n", + "Simulating pre_rate=78.88888888888889 Hz, post_rate=15.555555555555555 Hz\n", + "Simulating pre_rate=78.88888888888889 Hz, post_rate=26.11111111111111 Hz\n", + "Simulating pre_rate=78.88888888888889 Hz, post_rate=36.666666666666664 Hz\n", + "Simulating pre_rate=78.88888888888889 Hz, post_rate=47.22222222222222 Hz\n", + "Simulating pre_rate=78.88888888888889 Hz, post_rate=57.77777777777778 Hz\n", + "Simulating pre_rate=78.88888888888889 Hz, post_rate=68.33333333333333 Hz\n", + "Simulating pre_rate=78.88888888888889 Hz, post_rate=78.88888888888889 Hz\n", + "Simulating pre_rate=78.88888888888889 Hz, post_rate=89.44444444444444 Hz\n", + "Simulating pre_rate=78.88888888888889 Hz, post_rate=100.0 Hz\n", + "Simulating pre_rate=89.44444444444444 Hz, post_rate=5.0 Hz\n", + "Simulating pre_rate=89.44444444444444 Hz, post_rate=15.555555555555555 Hz\n", + "Simulating pre_rate=89.44444444444444 Hz, post_rate=26.11111111111111 Hz\n", + "Simulating pre_rate=89.44444444444444 Hz, post_rate=36.666666666666664 Hz\n", + "Simulating pre_rate=89.44444444444444 Hz, post_rate=47.22222222222222 Hz\n", + "Simulating pre_rate=89.44444444444444 Hz, post_rate=57.77777777777778 Hz\n", + "Simulating pre_rate=89.44444444444444 Hz, post_rate=68.33333333333333 Hz\n", + "Simulating pre_rate=89.44444444444444 Hz, post_rate=78.88888888888889 Hz\n", + "Simulating pre_rate=89.44444444444444 Hz, post_rate=89.44444444444444 Hz\n", + "Simulating pre_rate=89.44444444444444 Hz, post_rate=100.0 Hz\n", + "Simulating pre_rate=100.0 Hz, post_rate=5.0 Hz\n", + "Simulating pre_rate=100.0 Hz, post_rate=15.555555555555555 Hz\n", + "Simulating pre_rate=100.0 Hz, post_rate=26.11111111111111 Hz\n", + "Simulating pre_rate=100.0 Hz, post_rate=36.666666666666664 Hz\n", + "Simulating pre_rate=100.0 Hz, post_rate=47.22222222222222 Hz\n", + "Simulating pre_rate=100.0 Hz, post_rate=57.77777777777778 Hz\n", + "Simulating pre_rate=100.0 Hz, post_rate=68.33333333333333 Hz\n", + "Simulating pre_rate=100.0 Hz, post_rate=78.88888888888889 Hz\n", + "Simulating pre_rate=100.0 Hz, post_rate=89.44444444444444 Hz\n", + "Simulating pre_rate=100.0 Hz, post_rate=100.0 Hz\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEBUG:locator: \n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.colors import LinearSegmentedColormap\n", + "from brian2 import *\n", + "\n", + "# Simulation parameters\n", + "duration = 1000 * ms # Simulation duration\n", + "dt = 0.1 * ms # Simulation time step\n", + "\n", + "# STDP parameters\n", + "tau_pre = 20 * ms\n", + "tau_post = 20 * ms\n", + "A_pre = 0.001 # LTD amplitude\n", + "A_post = 0.001 # LTP amplitude\n", + "w_max = 1.0 # Maximum weight\n", + "\n", + "# Range of firing rates to test (Hz)\n", + "pre_rates = np.linspace(5, 100, 10)\n", + "post_rates = np.linspace(5, 100, 10)\n", + "\n", + "# Initialize result matrix to store final weights\n", + "weight_changes = np.zeros((len(pre_rates), len(post_rates)))\n", + "\n", + "# Function to simulate STDP for a given pre and post rate\n", + "def simulate_stdp(pre_rate, post_rate):\n", + " # Set up the network\n", + " pre = PoissonGroup(1, rates=pre_rate * Hz)\n", + " post = PoissonGroup(1, rates=post_rate * Hz)\n", + " \n", + " # STDP synapse\n", + " S = Synapses(pre, post,\n", + " '''\n", + " w : 1\n", + " dapre/dt = -apre/tau_pre : 1 (event-driven)\n", + " dapost/dt = -apost/tau_post : 1 (event-driven)\n", + " ''',\n", + " on_pre='''\n", + " apre += A_pre\n", + " w = clip(w + apost, 0, w_max)\n", + " ''',\n", + " on_post='''\n", + " apost += A_post\n", + " w = clip(w + apre, 0, w_max)\n", + " ''')\n", + " \n", + " S.connect()\n", + " S.w = 0.5 # Initial weight\n", + " \n", + " # Record weight changes\n", + " weight_mon = StateMonitor(S, 'w', record=0)\n", + " \n", + " # Run simulation\n", + " run(duration)\n", + " \n", + " # Return the weight change (final - initial)\n", + " return weight_mon.w[0][-1] - 0.5\n", + "\n", + "# Run simulations for all combinations of pre and post rates\n", + "for i, pre_rate in enumerate(pre_rates):\n", + " for j, post_rate in enumerate(post_rates):\n", + " print(f\"Simulating pre_rate={pre_rate} Hz, post_rate={post_rate} Hz\")\n", + " weight_changes[i, j] = simulate_stdp(pre_rate, post_rate)\n", + "\n", + "# Create a custom colormap: blue for depression, white for no change, red for potentiation\n", + "colors = [(0, 0, 1), (1, 1, 1), (1, 0, 0)] # Blue -> White -> Red\n", + "cmap = LinearSegmentedColormap.from_list('stdp_cmap', colors, N=100)\n", + "\n", + "# Plot the results\n", + "plt.figure(figsize=(10, 8))\n", + "im = plt.imshow(weight_changes, cmap=cmap, \n", + " extent=[post_rates[0], post_rates[-1], pre_rates[0], pre_rates[-1]],\n", + " origin='lower', aspect='auto', vmin=-0.5, vmax=0.5)\n", + "\n", + "plt.colorbar(im, label='Weight Change')\n", + "plt.xlabel('Postsynaptic Firing Rate (Hz)')\n", + "plt.ylabel('Presynaptic Firing Rate (Hz)')\n", + "plt.title('STDP Weight Change for Different Firing Rates (1000 ms)')\n", + "\n", + "# Add grid lines\n", + "plt.grid(False)\n", + "plt.tight_layout()\n", + "plt.savefig('stdp_weight_change_heatmap.png', dpi=300)\n", + "plt.show()" + ] + }, + { + "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", + "## Acknowledgements\n", + "\n", + "The authors would like to thank Prof. Wei Pan and Dr. Yuxiang Liu for kindly providing ..." + ] + } + ], + "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() From 6110d9e75c3d75c3f454e922482d15dfeb310f21 Mon Sep 17 00:00:00 2001 From: "C.A.P. Linssen" Date: Mon, 16 Jun 2025 14:03:13 +0200 Subject: [PATCH 2/8] add mountain car reinforcement learning tutorial --- ...inforcement_learning_nestml_tutorial.ipynb | 1350 ++++++++++------- 1 file changed, 792 insertions(+), 558 deletions(-) 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 index e766b437d..462aef077 100644 --- 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 @@ -678,215 +678,215 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_135852/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_422139/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: -508.43, Avg Reward (Last 100): -506.43, p_explore: 0.4954\n" + "Episode: 100/1500, Reward: -505.17, Avg Reward (Last 100): -505.92, p_explore: 0.4954\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_135852/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_422139/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.08, Avg Reward (Last 100): -494.29, p_explore: 0.2454\n" + "Episode: 200/1500, Reward: -505.21, Avg Reward (Last 100): -503.95, p_explore: 0.2454\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_135852/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_422139/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: -373.31, Avg Reward (Last 100): -467.66, p_explore: 0.1216\n" + "Episode: 300/1500, Reward: -518.23, Avg Reward (Last 100): -458.50, p_explore: 0.1216\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_135852/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_422139/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: -411.05, Avg Reward (Last 100): -380.99, p_explore: 0.0602\n" + "Episode: 400/1500, Reward: -284.43, Avg Reward (Last 100): -371.70, p_explore: 0.0602\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_135852/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_422139/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: -269.34, Avg Reward (Last 100): -337.76, p_explore: 0.0298\n" + "Episode: 500/1500, Reward: -400.98, Avg Reward (Last 100): -357.51, p_explore: 0.0298\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_135852/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_422139/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: -265.11, Avg Reward (Last 100): -333.28, p_explore: 0.0148\n" + "Episode: 600/1500, Reward: -276.57, Avg Reward (Last 100): -344.15, p_explore: 0.0148\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_135852/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_422139/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: -255.63, Avg Reward (Last 100): -319.24, p_explore: 0.0000\n" + "Episode: 700/1500, Reward: -272.36, Avg Reward (Last 100): -319.99, p_explore: 0.0000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_135852/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_422139/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: -225.64, Avg Reward (Last 100): -306.97, p_explore: 0.0000\n" + "Episode: 800/1500, Reward: -361.60, Avg Reward (Last 100): -301.87, p_explore: 0.0000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_135852/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_422139/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: -311.51, Avg Reward (Last 100): -300.41, p_explore: 0.0000\n" + "Episode: 900/1500, Reward: -277.43, Avg Reward (Last 100): -305.19, p_explore: 0.0000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_135852/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_422139/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: -237.05, Avg Reward (Last 100): -302.85, p_explore: 0.0000\n" + "Episode: 1000/1500, Reward: -283.36, Avg Reward (Last 100): -297.28, p_explore: 0.0000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_135852/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_422139/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: -269.26, Avg Reward (Last 100): -281.02, p_explore: 0.0000\n" + "Episode: 1100/1500, Reward: -260.01, Avg Reward (Last 100): -280.45, p_explore: 0.0000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_135852/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_422139/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: -287.27, Avg Reward (Last 100): -293.43, p_explore: 0.0000\n" + "Episode: 1200/1500, Reward: -286.47, Avg Reward (Last 100): -289.09, p_explore: 0.0000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_135852/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_422139/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: -252.75, Avg Reward (Last 100): -312.30, p_explore: 0.0000\n" + "Episode: 1300/1500, Reward: -257.20, Avg Reward (Last 100): -264.03, p_explore: 0.0000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_135852/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_422139/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: -300.46, Avg Reward (Last 100): -316.93, p_explore: 0.0000\n" + "Episode: 1400/1500, Reward: -240.43, Avg Reward (Last 100): -264.71, p_explore: 0.0000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_135852/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_422139/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: -252.87, Avg Reward (Last 100): -312.45, p_explore: 0.0000\n" + "Episode: 1500/1500, Reward: -258.35, Avg Reward (Last 100): -262.64, p_explore: 0.0000\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1310,12 +1310,12 @@ "\n", " Type 'nest.help()' to find out more about NEST.\n", "\n", - "[12,ignore_and_fire_neuron_nestml, WARNING, [35:34;35: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", + "[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", "[1,GLOBAL, INFO]: List of files that will be processed:\n", - "[2,GLOBAL, INFO]: /home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/iaf_psc_exp_neuron.nestml\n", - "[3,GLOBAL, INFO]: /home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/neuromodulated_stdp_synapse.nestml\n", - "[4,GLOBAL, INFO]: Target platform code will be generated in directory: '/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target'\n", - "[5,GLOBAL, INFO]: Target platform code will be installed in directory: '/tmp/nestml_target_bluoj7hw'\n", + "[2,GLOBAL, INFO]: /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/iaf_psc_exp_neuron.nestml\n", + "[3,GLOBAL, INFO]: /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/neuromodulated_stdp_synapse.nestml\n", + "[4,GLOBAL, INFO]: Target platform code will be generated in directory: '/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target'\n", + "[5,GLOBAL, INFO]: Target platform code will be installed in directory: '/tmp/nestml_target_j3n51fhv'\n", "\n", " -- N E S T --\n", " Copyright (C) 2004 The NEST Initiative\n", @@ -1332,13 +1332,13 @@ " Type 'nest.help()' to find out more about NEST.\n", "\n", "[6,GLOBAL, INFO]: The NEST Simulator version was automatically detected as: master\n", - "[7,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n", + "[7,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-fork-mountain-car/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n", "[8,GLOBAL, INFO]: The NEST Simulator installation path was automatically detected as: /home/charl/julich/nest-simulator-install\n", - "[9,GLOBAL, INFO]: Start processing '/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/iaf_psc_exp_neuron.nestml'!\n", + "[9,GLOBAL, INFO]: Start processing '/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/iaf_psc_exp_neuron.nestml'!\n", "[10,iaf_psc_exp_neuron_nestml, INFO, [37:19;37:19]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", "[11,iaf_psc_exp_neuron_nestml, INFO, [40:17;40:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", "[12,iaf_psc_exp_neuron_nestml, INFO, [53:15;53:32]]: Implicit casting from (compatible) type '1 / s buffer' to 'real'.\n", - "[13,GLOBAL, INFO]: Start processing '/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/neuromodulated_stdp_synapse.nestml'!\n", + "[13,GLOBAL, INFO]: Start processing '/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/neuromodulated_stdp_synapse.nestml'!\n", "[14,neuromodulated_stdp_synapse_nestml, INFO, [8:17;8:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", "[15,neuromodulated_stdp_synapse_nestml, INFO, [9:19;9:19]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", "[16,neuromodulated_stdp_synapse_nestml, INFO, [22:23;22:23]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", @@ -1370,7 +1370,8 @@ " }\n", " ],\n", " \"options\": {\n", - " \"output_timestep_symbol\": \"__h\"\n", + " \"output_timestep_symbol\": \"__h\",\n", + " \"simplify_expression\": \"sympy.logcombine(sympy.powsimp(sympy.expand(expr)))\"\n", " },\n", " \"parameters\": {\n", " \"E_e\": \"0\",\n", @@ -1403,7 +1404,7 @@ "DEBUG:Created Shape with symbol V_m, derivative_factors = [-1/tau_m], inhom_term = E_l/tau_m + I_e/tau_m, nonlin_term = E_e*g_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m\n", "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", - "INFO:All known variables: [g_e, V_m], all parameters used in ODEs: {tau_g, I_stim, E_e, E_l, tau_m, I_e}\n", + "INFO:All known variables: [g_e, V_m], all parameters used in ODEs: {tau_g, I_stim, E_l, tau_m, I_e, E_e}\n", "INFO:No numerical value specified for parameter \"I_stim\"\n", "INFO:\n", "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", @@ -1436,21 +1437,7 @@ "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", "DEBUG:os.makedirs('/tmp')\n", "DEBUG:write lines to '/tmp/ode_dependency_graph.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n", - "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", - "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", - "DEBUG:Splitting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m (symbols [g_e, V_m])\n", - "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m]])\n", - "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", - "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot\n", - "DEBUG:os.makedirs('/tmp')\n", - "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable_before_propagated.dot']\n" + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n" ] }, { @@ -1479,6 +1466,20 @@ "name": "stderr", "output_type": "stream", "text": [ + "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", + "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", + "DEBUG:Splitting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m (symbols [g_e, V_m])\n", + "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m]])\n", + "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", + "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot\n", + "DEBUG:os.makedirs('/tmp')\n", + "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot'\n", + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable_before_propagated.dot']\n", "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable.dot\n", "DEBUG:os.makedirs('/tmp')\n", "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable.dot'\n", @@ -1551,7 +1552,8 @@ " }\n", " ],\n", " \"options\": {\n", - " \"output_timestep_symbol\": \"__h\"\n", + " \"output_timestep_symbol\": \"__h\",\n", + " \"simplify_expression\": \"sympy.logcombine(sympy.powsimp(sympy.expand(expr)))\"\n", " },\n", " \"parameters\": {\n", " \"E_e\": \"0\",\n", @@ -1584,7 +1586,7 @@ "DEBUG:Created Shape with symbol V_m, derivative_factors = [-1/tau_m], inhom_term = E_l/tau_m + I_e/tau_m, nonlin_term = E_e*g_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m\n", "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", - "INFO:All known variables: [g_e, V_m], all parameters used in ODEs: {tau_g, I_stim, E_e, E_l, tau_m, I_e}\n", + "INFO:All known variables: [g_e, V_m], all parameters used in ODEs: {tau_g, I_stim, E_l, tau_m, I_e, E_e}\n", "INFO:No numerical value specified for parameter \"I_stim\"\n", "INFO:\n", "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", @@ -1631,7 +1633,13 @@ "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot\n", "DEBUG:os.makedirs('/tmp')\n", "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable_before_propagated.dot']\n", + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable_before_propagated.dot']\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable.dot\n", "DEBUG:os.makedirs('/tmp')\n", "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable.dot'\n", @@ -1664,13 +1672,7 @@ " \"g_e\": \"(-g_e) / tau_g\"\n", " }\n", " }\n", - "]\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ + "]\n", "INFO:Analysing input:\n", "INFO:{\n", " \"dynamics\": [\n", @@ -1694,7 +1696,8 @@ " }\n", " ],\n", " \"options\": {\n", - " \"output_timestep_symbol\": \"__h\"\n", + " \"output_timestep_symbol\": \"__h\",\n", + " \"simplify_expression\": \"sympy.logcombine(sympy.powsimp(sympy.expand(expr)))\"\n", " },\n", " \"parameters\": {\n", " \"E_e\": \"0\",\n", @@ -1737,7 +1740,7 @@ "DEBUG:Created Shape with symbol post_trace__for_neuromodulated_stdp_synapse_nestml, derivative_factors = [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml], inhom_term = 0.0, nonlin_term = 0.0\n", "INFO:\tReturning shape: Shape \"post_trace__for_neuromodulated_stdp_synapse_nestml\" of order 1\n", "INFO:Shape post_trace__for_neuromodulated_stdp_synapse_nestml: reconstituting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml\n", - "INFO:All known variables: [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml], all parameters used in ODEs: {tau_g, I_stim, tau_tr_post__for_neuromodulated_stdp_synapse_nestml, E_e, E_l, tau_m, I_e}\n", + "INFO:All known variables: [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml], all parameters used in ODEs: {tau_g, I_stim, E_l, tau_m, tau_tr_post__for_neuromodulated_stdp_synapse_nestml, I_e, E_e}\n", "INFO:No numerical value specified for parameter \"I_stim\"\n", "INFO:\n", "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", @@ -1774,7 +1777,13 @@ "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", "INFO:Shape post_trace__for_neuromodulated_stdp_synapse_nestml: reconstituting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml\n", - "DEBUG:Splitting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml (symbols Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]))\n", + "DEBUG:Splitting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml (symbols Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]))\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ "DEBUG:\tlinear factors: Matrix([[0], [0], [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]])\n", "DEBUG:\tinhomogeneous term: 0.0\n", "DEBUG:\tnonlinear term: 0.0\n", @@ -1790,13 +1799,7 @@ "DEBUG:\tinhomogeneous term: 0.0\n", "DEBUG:\tnonlinear term: 0.0\n", "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", - "DEBUG:Splitting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml])\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ + "DEBUG:Splitting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml])\n", "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m], [0]])\n", "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", @@ -1896,7 +1899,8 @@ " }\n", " ],\n", " \"options\": {\n", - " \"output_timestep_symbol\": \"__h\"\n", + " \"output_timestep_symbol\": \"__h\",\n", + " \"simplify_expression\": \"sympy.logcombine(sympy.powsimp(sympy.expand(expr)))\"\n", " },\n", " \"parameters\": {\n", " \"E_e\": \"0\",\n", @@ -1931,7 +1935,13 @@ "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", "INFO:\n", - "Processing differential-equation form shape post_trace__for_neuromodulated_stdp_synapse_nestml with defining expression = \"(-post_trace__for_neuromodulated_stdp_synapse_nestml) / tau_tr_post__for_neuromodulated_stdp_synapse_nestml\"\n", + "Processing differential-equation form shape post_trace__for_neuromodulated_stdp_synapse_nestml with defining expression = \"(-post_trace__for_neuromodulated_stdp_synapse_nestml) / tau_tr_post__for_neuromodulated_stdp_synapse_nestml\"\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ "DEBUG:Splitting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml (symbols [post_trace__for_neuromodulated_stdp_synapse_nestml])\n", "DEBUG:\tlinear factors: Matrix([[-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]])\n", "DEBUG:\tinhomogeneous term: 0.0\n", @@ -1939,17 +1949,11 @@ "DEBUG:Created Shape with symbol post_trace__for_neuromodulated_stdp_synapse_nestml, derivative_factors = [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml], inhom_term = 0.0, nonlin_term = 0.0\n", "INFO:\tReturning shape: Shape \"post_trace__for_neuromodulated_stdp_synapse_nestml\" of order 1\n", "INFO:Shape post_trace__for_neuromodulated_stdp_synapse_nestml: reconstituting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml\n", - "INFO:All known variables: [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml], all parameters used in ODEs: {tau_g, I_stim, tau_tr_post__for_neuromodulated_stdp_synapse_nestml, E_e, E_l, tau_m, I_e}\n", + "INFO:All known variables: [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml], all parameters used in ODEs: {tau_g, I_stim, E_l, tau_m, tau_tr_post__for_neuromodulated_stdp_synapse_nestml, I_e, E_e}\n", "INFO:No numerical value specified for parameter \"I_stim\"\n", "INFO:\n", "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", - "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml, g_e])\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ + "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml, g_e])\n", "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0], [0], [0]])\n", "DEBUG:\tinhomogeneous term: 0.0\n", "DEBUG:\tnonlinear term: 0.0\n", @@ -1959,7 +1963,21 @@ "Processing differential-equation form shape V_m with defining expression = \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\"\n", "DEBUG:Splitting expression (E_l + I_e + I_stim - V_m + g_e*(E_e - V_m))/tau_m (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml, g_e, V_m])\n", "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m], [0], [0], [0]])\n", - "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", + "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[38,GLOBAL, INFO]: Analysing/transforming model 'iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml'\n", + "[39,iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml, INFO, [18:0;58:0]]: Starts processing of the model 'iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml'\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", "DEBUG:Created Shape with symbol V_m, derivative_factors = [-1/tau_m], inhom_term = E_l/tau_m + I_e/tau_m + I_stim/tau_m, nonlin_term = E_e*g_e/tau_m - V_m*g_e/tau_m\n", "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", @@ -2005,21 +2023,7 @@ "INFO:Shape post_trace__for_neuromodulated_stdp_synapse_nestml: reconstituting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml\n", "DEBUG:Splitting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml])\n", "DEBUG:\tlinear factors: Matrix([[0], [0], [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[38,GLOBAL, INFO]: Analysing/transforming model 'iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml'\n", - "[39,iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml, INFO, [18:0;58:0]]: Starts processing of the model 'iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml'\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ + "DEBUG:\tinhomogeneous term: 0.0\n", "DEBUG:\tnonlinear term: 0.0\n", "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot\n", "DEBUG:os.makedirs('/tmp')\n", @@ -2029,7 +2033,7 @@ "DEBUG:os.makedirs('/tmp')\n", "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable.dot'\n", "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable.dot']\n", - "INFO:Generating numerical solver for the following symbols: g_e, post_trace__for_neuromodulated_stdp_synapse_nestml, V_m\n", + "INFO:Generating numerical solver for the following symbols: V_m, g_e, post_trace__for_neuromodulated_stdp_synapse_nestml\n", "DEBUG:Initializing system of shapes with x = Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]), A = Matrix([[-1/tau_g, 0, 0], [E_e/tau_m, -1/tau_m, 0], [0, 0, -1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]]), b = Matrix([[0], [E_l/tau_m + I_e/tau_m + I_stim/tau_m], [0]]), c = Matrix([[0], [-V_m*g_e/tau_m], [0]])\n", "INFO:Preserving expression for variable \"g_e\"\n", "INFO:Preserving expression for variable \"V_m\"\n", @@ -2080,7 +2084,8 @@ " }\n", " ],\n", " \"options\": {\n", - " \"output_timestep_symbol\": \"__h\"\n", + " \"output_timestep_symbol\": \"__h\",\n", + " \"simplify_expression\": \"sympy.logcombine(sympy.powsimp(sympy.expand(expr)))\"\n", " },\n", " \"parameters\": {\n", " \"beta\": \"0.01\",\n", @@ -2105,7 +2110,13 @@ "DEBUG:\tnonlinear term: 0.0\n", "DEBUG:Created Shape with symbol pre_trace, derivative_factors = [-1/tau_tr_pre], inhom_term = 0.0, nonlin_term = 0.0\n", "INFO:\tReturning shape: Shape \"pre_trace\" of order 1\n", - "INFO:Shape pre_trace: reconstituting expression -pre_trace/tau_tr_pre\n", + "INFO:Shape pre_trace: reconstituting expression -pre_trace/tau_tr_pre\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ "INFO:\n", "Processing differential-equation form shape wtr with defining expression = \"(-wtr) / tau_wtr\"\n", "DEBUG:Splitting expression -wtr/tau_wtr (symbols [wtr])\n", @@ -2115,7 +2126,7 @@ "DEBUG:Created Shape with symbol wtr, derivative_factors = [-1/tau_wtr], inhom_term = 0.0, nonlin_term = 0.0\n", "INFO:\tReturning shape: Shape \"wtr\" of order 1\n", "INFO:Shape wtr: reconstituting expression -wtr/tau_wtr\n", - "INFO:All known variables: [pre_trace, wtr], all parameters used in ODEs: {tau_tr_pre, tau_wtr}\n", + "INFO:All known variables: [pre_trace, wtr], all parameters used in ODEs: {tau_wtr, tau_tr_pre}\n", "INFO:\n", "Processing differential-equation form shape pre_trace with defining expression = \"(-pre_trace) / tau_tr_pre\"\n", "DEBUG:Splitting expression -pre_trace/tau_tr_pre (symbols [pre_trace, wtr, pre_trace])\n", @@ -2213,24 +2224,18 @@ "text": [ "[40,GLOBAL, INFO]: Analysing/transforming synapse neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.\n", "[41,neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml, INFO, [6:0;55:0]]: Starts processing of the model 'neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml'\n", - "[42,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp\n", - "[43,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.h\n", - "[44,iaf_psc_exp_neuron_nestml, INFO, [18:0;58:0]]: Successfully generated code for the model: 'iaf_psc_exp_neuron_nestml' in: '/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target' !\n", - "[45,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp\n", - "[46,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.h\n", - "[47,iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml, INFO, [18:0;58:0]]: Successfully generated code for the model: 'iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml' in: '/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target' !\n", - "[48,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h\n", - "[49,neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml, INFO, [6:0;55:0]]: Successfully generated code for the model: 'neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml' in: '/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target' !\n", - "[50,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/nestml_5db106a63cc54757ab6af013c5525511_module.cpp\n", - "[51,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/nestml_5db106a63cc54757ab6af013c5525511_module.h\n", - "[52,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/CMakeLists.txt\n", - "[53,GLOBAL, INFO]: Successfully generated NEST module code in '/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target' !\n", - "CMake Warning (dev) at CMakeLists.txt:95 (project):\n", - " cmake_minimum_required() should be called prior to this top-level project()\n", - " call. Please see the cmake-commands(7) manual for usage documentation of\n", - " both commands.\n", - "This warning is for project developers. Use -Wno-dev to suppress it.\n", - "\n", + "[42,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp\n", + "[43,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.h\n", + "[44,iaf_psc_exp_neuron_nestml, INFO, [18:0;58:0]]: Successfully generated code for the model: 'iaf_psc_exp_neuron_nestml' in: '/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target' !\n", + "[45,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp\n", + "[46,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.h\n", + "[47,iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml, INFO, [18:0;58:0]]: Successfully generated code for the model: 'iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml' in: '/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target' !\n", + "[48,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h\n", + "[49,neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml, INFO, [6:0;55:0]]: Successfully generated code for the model: 'neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml' in: '/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target' !\n", + "[50,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/nestml_7e96446dfb6046169507a433a49d24d6_module.cpp\n", + "[51,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/nestml_7e96446dfb6046169507a433a49d24d6_module.h\n", + "[52,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/CMakeLists.txt\n", + "[53,GLOBAL, INFO]: Successfully generated NEST module code in '/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target' !\n", "-- The CXX compiler identification is GNU 12.3.0\n", "-- Detecting CXX compiler ABI info\n", "-- Detecting CXX compiler ABI info - done\n", @@ -2239,7 +2244,7 @@ "-- Detecting CXX compile features - done\n", "\n", "-------------------------------------------------------\n", - "nestml_5db106a63cc54757ab6af013c5525511_module Configuration Summary\n", + "nestml_7e96446dfb6046169507a433a49d24d6_module Configuration Summary\n", "-------------------------------------------------------\n", "\n", "C++ compiler : /usr/bin/c++\n", @@ -2251,97 +2256,84 @@ "\n", "-------------------------------------------------------\n", "\n", - "You can now build and install 'nestml_5db106a63cc54757ab6af013c5525511_module' using\n", + "You can now build and install 'nestml_7e96446dfb6046169507a433a49d24d6_module' using\n", " make\n", " make install\n", "\n", - "The library file libnestml_5db106a63cc54757ab6af013c5525511_module.so will be installed to\n", - " /tmp/nestml_target_bluoj7hw\n", + "The library file libnestml_7e96446dfb6046169507a433a49d24d6_module.so will be installed to\n", + " /tmp/nestml_target_j3n51fhv\n", "The module can be loaded into NEST using\n", - " (nestml_5db106a63cc54757ab6af013c5525511_module) Install (in SLI)\n", - " nest.Install(nestml_5db106a63cc54757ab6af013c5525511_module) (in PyNEST)\n", - "\n", - "CMake Warning (dev) in CMakeLists.txt:\n", - " No cmake_minimum_required command is present. A line of code such as\n", - "\n", - " cmake_minimum_required(VERSION 3.26)\n", - "\n", - " should be added at the top of the file. The version specified may be lower\n", - " if you wish to support older CMake versions for this project. For more\n", - " information run \"cmake --help-policy CMP0000\".\n", - "This warning is for project developers. Use -Wno-dev to suppress it.\n", + " (nestml_7e96446dfb6046169507a433a49d24d6_module) Install (in SLI)\n", + " nest.Install(nestml_7e96446dfb6046169507a433a49d24d6_module) (in PyNEST)\n", "\n", "-- Configuring done (0.1s)\n", "-- Generating done (0.0s)\n", - "-- Build files have been written to: /home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target\n", - "[ 25%] Building CXX object CMakeFiles/nestml_5db106a63cc54757ab6af013c5525511_module_module.dir/nestml_5db106a63cc54757ab6af013c5525511_module.o\n", - "[ 50%] Building CXX object CMakeFiles/nestml_5db106a63cc54757ab6af013c5525511_module_module.dir/iaf_psc_exp_neuron_nestml.o\n", - "[ 75%] Building CXX object CMakeFiles/nestml_5db106a63cc54757ab6af013c5525511_module_module.dir/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.o\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml::init_state_internal_()’:\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:201:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + "-- Build files have been written to: /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target\n", + "[ 25%] Building CXX object CMakeFiles/nestml_7e96446dfb6046169507a433a49d24d6_module_module.dir/nestml_7e96446dfb6046169507a433a49d24d6_module.cpp.o\n", + "[ 50%] Building CXX object CMakeFiles/nestml_7e96446dfb6046169507a433a49d24d6_module_module.dir/iaf_psc_exp_neuron_nestml.cpp.o\n", + "[ 75%] Building CXX object CMakeFiles/nestml_7e96446dfb6046169507a433a49d24d6_module_module.dir/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp.o\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml::init_state_internal_()’:\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:191:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 191 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml::recompute_internal_variables(bool)’:\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:271:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 271 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘virtual void iaf_psc_exp_neuron_nestml::update(const nest::Time&, long int, long int)’:\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:337:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", + " 337 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", + " | ~~^~~~~~~~~~~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:328:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 328 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:322:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 322 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml::on_receive_block_spikes_in_port(const nest::Time&, long int)’:\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:500:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 500 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:501:8: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 501 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml::init_state_internal_()’:\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:201:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", " 201 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml::recompute_internal_variables(bool)’:\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:290:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml::recompute_internal_variables(bool)’:\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:290:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", " 290 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp: In function ‘int iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml_dynamics_post_trace__for_neuromodulated_stdp_synapse_nestml(double, const double*, double*, void*)’:\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:347:77: warning: unused variable ‘node’ [-Wunused-variable]\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp: In function ‘int iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml_dynamics_post_trace__for_neuromodulated_stdp_synapse_nestml(double, const double*, double*, void*)’:\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:347:77: warning: unused variable ‘node’ [-Wunused-variable]\n", " 347 | const iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml& node = *( reinterpret_cast< iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml* >( pnode ) );\n", " | ^~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp: In member function ‘virtual void iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml::update(const nest::Time&, long int, long int)’:\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:375:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp: In member function ‘virtual void iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml::update(const nest::Time&, long int, long int)’:\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:375:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", " 375 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", " | ~~^~~~~~~~~~~~~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:366:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:366:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", " 366 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", " | ^~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:360:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:360:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", " 360 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml::on_receive_block_spikes_in_port()’:\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:537:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 537 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml::on_receive_block_spikes_in_port(const nest::Time&, long int)’:\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:541:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 541 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml::init_state_internal_()’:\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:191:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 191 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml::recompute_internal_variables(bool)’:\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:271:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 271 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘virtual void iaf_psc_exp_neuron_nestml::update(const nest::Time&, long int, long int)’:\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:337:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", - " 337 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", - " | ~~^~~~~~~~~~~~~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:328:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 328 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", - " | ^~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:322:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 322 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml::on_receive_block_spikes_in_port()’:\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:496:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 496 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", - "In file included from /home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/nestml_5db106a63cc54757ab6af013c5525511_module.cpp:36:\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:542:8: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 542 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", + " | ^~~~~\n", + "In file included from /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/nestml_7e96446dfb6046169507a433a49d24d6_module.cpp:36:\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:62:5: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:613:104: required from here\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:746:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:613:104: required from here\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:746:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", " 746 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘void nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::recompute_internal_variables() [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:760:3: required from ‘nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierPtrRport]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:62:5: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:613:104: required from here\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:733:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 733 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", " | ^~~~~~~~~~\n" ] }, @@ -2349,79 +2341,88 @@ "name": "stdout", "output_type": "stream", "text": [ - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘void nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::recompute_internal_variables() [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:760:3: required from ‘nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierPtrRport]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:62:5: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:613:104: required from here\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:733:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 733 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:103:34: required from ‘void nest::ModelManager::register_specific_connection_model_(const std::string&) [with CompleteConnecionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:67:80: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:613:104: required from here\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:746:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:613:104: required from here\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:746:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", " 746 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘void nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::recompute_internal_variables() [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:760:3: required from ‘nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierIndex]’\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘void nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::recompute_internal_variables() [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:760:3: required from ‘nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierIndex]’\n", "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:103:34: required from ‘void nest::ModelManager::register_specific_connection_model_(const std::string&) [with CompleteConnecionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:67:80: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:613:104: required from here\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:733:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:613:104: required from here\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:733:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", " 733 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘bool nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::send(nest::Event&, size_t, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport; size_t = long unsigned int]’:\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘bool nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::send(nest::Event&, size_t, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport; size_t = long unsigned int]’:\n", "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; size_t = long unsigned int]’\n", "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:517:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:517:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", " 517 | auto get_t = [t_hist_entry_ms](){ return t_hist_entry_ms; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", " | ^~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:546:12: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:546:12: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", " 546 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", " | ^~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:587:12: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:587:12: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", " 587 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", " | ^~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:442:18: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:442:18: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", " 442 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:444:10: warning: variable ‘get_thread’ set but not used [-Wunused-but-set-variable]\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:444:10: warning: variable ‘get_thread’ set but not used [-Wunused-but-set-variable]\n", " 444 | auto get_thread = [tid]()\n", " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘bool nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::send(nest::Event&, size_t, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex; size_t = long unsigned int]’:\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘bool nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::send(nest::Event&, size_t, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex; size_t = long unsigned int]’:\n", "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; size_t = long unsigned int]’\n", "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:517:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:517:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", " 517 | auto get_t = [t_hist_entry_ms](){ return t_hist_entry_ms; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", " | ^~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:546:12: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:546:12: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", " 546 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", " | ^~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:587:12: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:587:12: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", " 587 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", " | ^~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:442:18: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:442:18: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", " 442 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:444:10: warning: variable ‘get_thread’ set but not used [-Wunused-but-set-variable]\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:444:10: warning: variable ‘get_thread’ set but not used [-Wunused-but-set-variable]\n", " 444 | auto get_thread = [tid]()\n", " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘void nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::update_internal_state_(double, double, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:512:9: required from ‘bool nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::send(nest::Event&, size_t, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport; size_t = long unsigned int]’\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘void nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::update_internal_state_(double, double, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:512:9: required from ‘bool nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::send(nest::Event&, size_t, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport; size_t = long unsigned int]’\n", "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; size_t = long unsigned int]’\n", "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:812:18: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:812:18: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", " 812 | const double __timestep = timestep; // do not remove, this is necessary for the timestep() function\n", " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:813:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:813:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", " 813 | auto get_t = [t_start](){ return t_start; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", " | ^~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘void nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::update_internal_state_(double, double, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:512:9: required from ‘bool nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::send(nest::Event&, size_t, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex; size_t = long unsigned int]’\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘void nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::update_internal_state_(double, double, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:512:9: required from ‘bool nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::send(nest::Event&, size_t, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex; size_t = long unsigned int]’\n", "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; size_t = long unsigned int]’\n", "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:812:18: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:812:18: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", " 812 | const double __timestep = timestep; // do not remove, this is necessary for the timestep() function\n", " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-AlexisWis-cart_pole_tutorial-stash-restore/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:813:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:813:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", " 813 | auto get_t = [t_start](){ return t_start; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", " | ^~~~~\n" ] @@ -2430,12 +2431,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "[100%] Linking CXX shared module nestml_5db106a63cc54757ab6af013c5525511_module.so\n", - "[100%] Built target nestml_5db106a63cc54757ab6af013c5525511_module_module\n", - "[100%] Built target nestml_5db106a63cc54757ab6af013c5525511_module_module\n", + "[100%] Linking CXX shared module nestml_7e96446dfb6046169507a433a49d24d6_module.so\n", + "[100%] Built target nestml_7e96446dfb6046169507a433a49d24d6_module_module\n", + "[100%] Built target nestml_7e96446dfb6046169507a433a49d24d6_module_module\n", "Install the project...\n", "-- Install configuration: \"\"\n", - "-- Installing: /tmp/nestml_target_bluoj7hw/nestml_5db106a63cc54757ab6af013c5525511_module.so\n" + "-- Installing: /tmp/nestml_target_j3n51fhv/nestml_7e96446dfb6046169507a433a49d24d6_module.so\n" ] } ], @@ -2772,230 +2773,230 @@ "name": "stdout", "output_type": "stream", "text": [ - "Episode 0 took: 2.396 s\n", + "Episode 0 took: 2.344 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -14.429986275364584\n", - "Episode 1 took: 3.628 s\n", + "\tTotal reward = -13.89745665968862\n", + "Episode 1 took: 2.467 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -2.3097269263348172\n", - "Episode 2 took: 2.961 s\n", + "\tTotal reward = -11.442271180514668\n", + "Episode 2 took: 2.934 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -5.745195530886559\n", - "Episode 3 took: 3.045 s\n", + "\tTotal reward = -7.8635394467340385\n", + "Episode 3 took: 3.070 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -5.162839260667261\n", - "Episode 4 took: 3.265 s\n", - "\tNumber of steps in episode = 494\n", - "\tTotal reward = -2.0093830106173436\n", - "Episode 5 took: 3.367 s\n", + "\tTotal reward = -6.19216835818245\n", + "Episode 4 took: 4.093 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -3.484248105324001\n", - "Episode 6 took: 3.025 s\n", - "\tNumber of steps in episode = 442\n", - "\tTotal reward = -0.862316426913704\n", - "Episode 7 took: 3.484 s\n", - "\tNumber of steps in episode = 492\n", - "\tTotal reward = -2.4798809287375443\n", - "Episode 8 took: 3.590 s\n", + "\tTotal reward = -8.466157008234736\n", + "Episode 5 took: 3.796 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -11.082273989936038\n", + "Episode 6 took: 4.928 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -9.421463092319835\n", + "Episode 7 took: 3.645 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -4.356526027823034\n", + "Episode 8 took: 3.490 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -3.6967923126483626\n", - "Episode 9 took: 3.649 s\n", + "\tTotal reward = -9.659186902639018\n", + "Episode 9 took: 14.558 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -8.838109664200717\n" + "\tTotal reward = -7.635423324172356\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_135852/3878736473.py:131: 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_135852/3878736473.py:146: 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", - "DEBUG:locator: \n" + "/tmp/ipykernel_422139/3878736473.py:131: 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_422139/3878736473.py:146: 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", + "DEBUG:locator: \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Episode 10 took: 3.902 s\n", + "Episode 10 took: 7.743 s\n", + "\tNumber of steps in episode = 479\n", + "\tTotal reward = -0.4885892464491851\n", + "Episode 11 took: 3.615 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -8.474306970260933\n", - "Episode 11 took: 14.914 s\n", + "\tTotal reward = -6.9620801843858295\n", + "Episode 12 took: 4.018 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -4.171496431406933\n", - "Episode 12 took: 4.832 s\n", - "\tNumber of steps in episode = 488\n", - "\tTotal reward = -1.5529026859427615\n", - "Episode 13 took: 9.974 s\n", - "\tNumber of steps in episode = 488\n", - "\tTotal reward = -2.1662564152294133\n", - "Episode 14 took: 3.491 s\n", - "\tNumber of steps in episode = 457\n", - "\tTotal reward = -2.332099267964661\n", - "Episode 15 took: 3.936 s\n", - "\tNumber of steps in episode = 468\n", - "\tTotal reward = -3.974842668742503\n", - "Episode 16 took: 4.558 s\n", - "\tNumber of steps in episode = 498\n", - "\tTotal reward = -4.235195462609564\n", - "Episode 17 took: 4.816 s\n", + "\tTotal reward = -9.300473736603209\n", + "Episode 13 took: 3.490 s\n", + "\tNumber of steps in episode = 453\n", + "\tTotal reward = -1.392652469476832\n", + "Episode 14 took: 2.944 s\n", + "\tNumber of steps in episode = 386\n", + "\tTotal reward = 2.885767962045132\n", + "Episode 15 took: 3.774 s\n", + "\tNumber of steps in episode = 477\n", + "\tTotal reward = -1.8624652303670965\n", + "Episode 16 took: 4.778 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -4.266898108741331\n", - "Episode 18 took: 4.706 s\n", - "\tNumber of steps in episode = 493\n", - "\tTotal reward = -2.2962522883292382\n", - "Episode 19 took: 4.718 s\n", - "\tNumber of steps in episode = 488\n", - "\tTotal reward = -1.738135771043018\n" + "\tTotal reward = -9.218878430148171\n", + "Episode 17 took: 5.400 s\n", + "\tNumber of steps in episode = 476\n", + "\tTotal reward = -1.9805538063803714\n", + "Episode 18 took: 5.237 s\n", + "\tNumber of steps in episode = 480\n", + "\tTotal reward = -0.9794208365042383\n", + "Episode 19 took: 5.832 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -6.563055951722551\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_135852/3878736473.py:131: 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_135852/3878736473.py:146: 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", - "DEBUG:locator: \n" + "/tmp/ipykernel_422139/3878736473.py:131: 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_422139/3878736473.py:146: 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", + "DEBUG:locator: \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Episode 20 took: 4.254 s\n", - "\tNumber of steps in episode = 460\n", - "\tTotal reward = -0.5980166104265345\n", - "Episode 21 took: 4.664 s\n", - "\tNumber of steps in episode = 492\n", - "\tTotal reward = -3.2709305203253445\n", - "Episode 22 took: 4.711 s\n", - "\tNumber of steps in episode = 483\n", - "\tTotal reward = -2.3639374756658995\n", - "Episode 23 took: 4.770 s\n", - "\tNumber of steps in episode = 483\n", - "\tTotal reward = -2.2573473423086354\n", - "Episode 24 took: 4.600 s\n", - "\tNumber of steps in episode = 457\n", - "\tTotal reward = -1.7980199520269358\n", - "Episode 25 took: 4.615 s\n", - "\tNumber of steps in episode = 451\n", - "\tTotal reward = -1.8367791521574466\n", - "Episode 26 took: 5.135 s\n", + "Episode 20 took: 5.205 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -13.165721711732578\n", + "Episode 21 took: 6.762 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -10.239928874624217\n", + "Episode 22 took: 6.033 s\n", + "\tNumber of steps in episode = 474\n", + "\tTotal reward = -0.9907165448633724\n", + "Episode 23 took: 6.347 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -7.4022506305974085\n", + "Episode 24 took: 6.333 s\n", + "\tNumber of steps in episode = 489\n", + "\tTotal reward = -2.8665191573290967\n", + "Episode 25 took: 6.771 s\n", + "\tNumber of steps in episode = 472\n", + "\tTotal reward = -0.6466374718461726\n", + "Episode 26 took: 7.958 s\n", "\tNumber of steps in episode = 487\n", - "\tTotal reward = -1.0770105658971882\n", - "Episode 27 took: 5.256 s\n", - "\tNumber of steps in episode = 495\n", - "\tTotal reward = -2.0753492849253092\n", - "Episode 28 took: 4.865 s\n", - "\tNumber of steps in episode = 444\n", - "\tTotal reward = 0.3497993620438027\n", - "Episode 29 took: 5.040 s\n", - "\tNumber of steps in episode = 448\n", - "\tTotal reward = -0.8937316034708713\n" + "\tTotal reward = -2.4798575567892795\n", + "Episode 27 took: 8.987 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -7.628327176179652\n", + "Episode 28 took: 7.048 s\n", + "\tNumber of steps in episode = 479\n", + "\tTotal reward = -1.6239026800755658\n", + "Episode 29 took: 7.290 s\n", + "\tNumber of steps in episode = 476\n", + "\tTotal reward = -1.2992894723211477\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_135852/3878736473.py:131: 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_135852/3878736473.py:146: 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", - "DEBUG:locator: \n" + "/tmp/ipykernel_422139/3878736473.py:131: 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_422139/3878736473.py:146: 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", + "DEBUG:locator: \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Episode 30 took: 5.858 s\n", - "\tNumber of steps in episode = 495\n", - "\tTotal reward = -2.5366703341895085\n", - "Episode 31 took: 6.025 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -9.732158962214742\n", - "Episode 32 took: 6.119 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -4.084983674777322\n", - "Episode 33 took: 6.191 s\n", + "Episode 30 took: 8.402 s\n", + "\tNumber of steps in episode = 477\n", + "\tTotal reward = -1.621931569406017\n", + "Episode 31 took: 9.206 s\n", + "\tNumber of steps in episode = 492\n", + "\tTotal reward = -3.0492795427312145\n", + "Episode 32 took: 9.118 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -10.332046367056178\n", - "Episode 34 took: 6.290 s\n", + "\tTotal reward = -10.145864008713575\n", + "Episode 33 took: 9.475 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -4.625961740618313\n", - "Episode 35 took: 5.713 s\n", - "\tNumber of steps in episode = 448\n", - "\tTotal reward = -0.7424877650462732\n", - "Episode 36 took: 6.509 s\n", + "\tTotal reward = -3.698123034555376\n", + "Episode 34 took: 9.436 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -10.412757866309805\n", - "Episode 37 took: 6.542 s\n", + "\tTotal reward = -4.500674730655058\n", + "Episode 35 took: 8.835 s\n", + "\tNumber of steps in episode = 486\n", + "\tTotal reward = -2.4276867620122182\n", + "Episode 36 took: 9.213 s\n", + "\tNumber of steps in episode = 477\n", + "\tTotal reward = -1.7457801937345705\n", + "Episode 37 took: 10.053 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -6.646176399187974\n", - "Episode 38 took: 6.379 s\n", - "\tNumber of steps in episode = 480\n", - "\tTotal reward = -2.5253841298115454\n", - "Episode 39 took: 6.627 s\n", - "\tNumber of steps in episode = 492\n", - "\tTotal reward = -2.867692170935876\n" + "\tTotal reward = -5.294304910806366\n", + "Episode 38 took: 7.630 s\n", + "\tNumber of steps in episode = 471\n", + "\tTotal reward = -0.560492635470805\n", + "Episode 39 took: 7.403 s\n", + "\tNumber of steps in episode = 432\n", + "\tTotal reward = 0.8241573628332903\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_135852/3878736473.py:131: 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_135852/3878736473.py:146: 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", - "DEBUG:locator: \n" + "/tmp/ipykernel_422139/3878736473.py:131: 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_422139/3878736473.py:146: 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", + "DEBUG:locator: \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Episode 40 took: 6.514 s\n", - "\tNumber of steps in episode = 491\n", - "\tTotal reward = -2.506865882547583\n", - "Episode 41 took: 6.743 s\n", + "Episode 40 took: 7.616 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -11.08313563601852\n", + "Episode 41 took: 9.039 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -3.625091740399541\n", - "Episode 42 took: 6.853 s\n", + "\tTotal reward = -3.5331820861561907\n", + "Episode 42 took: 10.973 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -10.180668926668451\n", - "Episode 43 took: 6.958 s\n", + "\tTotal reward = -10.652568550823352\n", + "Episode 43 took: 8.706 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -8.193412170871625\n", - "Episode 44 took: 6.738 s\n", - "\tNumber of steps in episode = 470\n", - "\tTotal reward = -0.5849281891564296\n", - "Episode 45 took: 7.018 s\n", - "\tNumber of steps in episode = 481\n", - "\tTotal reward = -1.518052722351252\n", - "Episode 46 took: 7.240 s\n", + "\tTotal reward = -4.196979159821003\n", + "Episode 44 took: 8.583 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -7.974870087397576\n", - "Episode 47 took: 7.327 s\n", + "\tTotal reward = -3.0645991757691977\n", + "Episode 45 took: 8.422 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -5.526891330796331\n", - "Episode 48 took: 7.398 s\n", + "\tTotal reward = -3.928509879186927\n", + "Episode 46 took: 8.530 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -3.609195444307881\n", - "Episode 49 took: 7.381 s\n", - "\tNumber of steps in episode = 488\n", - "\tTotal reward = -4.725225310960246\n" + "\tTotal reward = -5.502845410718123\n", + "Episode 47 took: 8.241 s\n", + "\tNumber of steps in episode = 476\n", + "\tTotal reward = -1.0917405163381833\n", + "Episode 48 took: 7.799 s\n", + "\tNumber of steps in episode = 447\n", + "\tTotal reward = -1.1848611410375645\n", + "Episode 49 took: 8.326 s\n", + "\tNumber of steps in episode = 476\n", + "\tTotal reward = -1.7557132022891608\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_135852/3878736473.py:131: 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_135852/3878736473.py:146: 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", - "DEBUG:locator: \n" + "/tmp/ipykernel_422139/3878736473.py:131: 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_422139/3878736473.py:146: 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", + "DEBUG:locator: \n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3005,7 +3006,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3217,144 +3218,326 @@ }, { "cell_type": "code", - "execution_count": 15, - "id": "d624cd2e", + "execution_count": 41, + "id": "6a68403e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Simulating pre_rate=5.0 Hz, post_rate=5.0 Hz\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/lib/python3/dist-packages/pythran/tables.py:4530: FutureWarning:In the future `np.bool` will be defined as the corresponding NumPy scalar.\n", - "/usr/lib/python3/dist-packages/pythran/tables.py:4563: FutureWarning:In the future `np.bytes` will be defined as the corresponding NumPy scalar.\n", - "WARNING 'dt' is an internal variable of group 'poissongroup_1', but also exists in the run namespace with the value 100. * usecond. The internal variable will be used. [brian2.groups.group.Group.resolve.resolution_conflict]\n", - "WARNING 'dt' is an internal variable of group 'poissongroup', but also exists in the run namespace with the value 100. * usecond. The internal variable will be used. [brian2.groups.group.Group.resolve.resolution_conflict]\n", - "WARNING 'dt' is an internal variable of group 'poissongroup_2', but also exists in the run namespace with the value 100. * usecond. The internal variable will be used. [brian2.groups.group.Group.resolve.resolution_conflict]\n", - "WARNING 'dt' is an internal variable of group 'poissongroup_3', but also exists in the run namespace with the value 100. * usecond. The internal variable will be used. [brian2.groups.group.Group.resolve.resolution_conflict]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Simulating pre_rate=5.0 Hz, post_rate=15.555555555555555 Hz\n", - "Simulating pre_rate=5.0 Hz, post_rate=26.11111111111111 Hz\n", - "Simulating pre_rate=5.0 Hz, post_rate=36.666666666666664 Hz\n", - "Simulating pre_rate=5.0 Hz, post_rate=47.22222222222222 Hz\n", - "Simulating pre_rate=5.0 Hz, post_rate=57.77777777777778 Hz\n", - "Simulating pre_rate=5.0 Hz, post_rate=68.33333333333333 Hz\n", - "Simulating pre_rate=5.0 Hz, post_rate=78.88888888888889 Hz\n", - "Simulating pre_rate=5.0 Hz, post_rate=89.44444444444444 Hz\n", - "Simulating pre_rate=5.0 Hz, post_rate=100.0 Hz\n", - "Simulating pre_rate=15.555555555555555 Hz, post_rate=5.0 Hz\n", - "Simulating pre_rate=15.555555555555555 Hz, post_rate=15.555555555555555 Hz\n", - "Simulating pre_rate=15.555555555555555 Hz, post_rate=26.11111111111111 Hz\n", - "Simulating pre_rate=15.555555555555555 Hz, post_rate=36.666666666666664 Hz\n", - "Simulating pre_rate=15.555555555555555 Hz, post_rate=47.22222222222222 Hz\n", - "Simulating pre_rate=15.555555555555555 Hz, post_rate=57.77777777777778 Hz\n", - "Simulating pre_rate=15.555555555555555 Hz, post_rate=68.33333333333333 Hz\n", - "Simulating pre_rate=15.555555555555555 Hz, post_rate=78.88888888888889 Hz\n", - "Simulating pre_rate=15.555555555555555 Hz, post_rate=89.44444444444444 Hz\n", - "Simulating pre_rate=15.555555555555555 Hz, post_rate=100.0 Hz\n", - "Simulating pre_rate=26.11111111111111 Hz, post_rate=5.0 Hz\n", - "Simulating pre_rate=26.11111111111111 Hz, post_rate=15.555555555555555 Hz\n", - "Simulating pre_rate=26.11111111111111 Hz, post_rate=26.11111111111111 Hz\n", - "Simulating pre_rate=26.11111111111111 Hz, post_rate=36.666666666666664 Hz\n", - "Simulating pre_rate=26.11111111111111 Hz, post_rate=47.22222222222222 Hz\n", - "Simulating pre_rate=26.11111111111111 Hz, post_rate=57.77777777777778 Hz\n", - "Simulating pre_rate=26.11111111111111 Hz, post_rate=68.33333333333333 Hz\n", - "Simulating pre_rate=26.11111111111111 Hz, post_rate=78.88888888888889 Hz\n", - "Simulating pre_rate=26.11111111111111 Hz, post_rate=89.44444444444444 Hz\n", - "Simulating pre_rate=26.11111111111111 Hz, post_rate=100.0 Hz\n", - "Simulating pre_rate=36.666666666666664 Hz, post_rate=5.0 Hz\n", - "Simulating pre_rate=36.666666666666664 Hz, post_rate=15.555555555555555 Hz\n", - "Simulating pre_rate=36.666666666666664 Hz, post_rate=26.11111111111111 Hz\n", - "Simulating pre_rate=36.666666666666664 Hz, post_rate=36.666666666666664 Hz\n", - "Simulating pre_rate=36.666666666666664 Hz, post_rate=47.22222222222222 Hz\n", - "Simulating pre_rate=36.666666666666664 Hz, post_rate=57.77777777777778 Hz\n", - "Simulating pre_rate=36.666666666666664 Hz, post_rate=68.33333333333333 Hz\n", - "Simulating pre_rate=36.666666666666664 Hz, post_rate=78.88888888888889 Hz\n", - "Simulating pre_rate=36.666666666666664 Hz, post_rate=89.44444444444444 Hz\n", - "Simulating pre_rate=36.666666666666664 Hz, post_rate=100.0 Hz\n", - "Simulating pre_rate=47.22222222222222 Hz, post_rate=5.0 Hz\n", - "Simulating pre_rate=47.22222222222222 Hz, post_rate=15.555555555555555 Hz\n", - "Simulating pre_rate=47.22222222222222 Hz, post_rate=26.11111111111111 Hz\n", - "Simulating pre_rate=47.22222222222222 Hz, post_rate=36.666666666666664 Hz\n", - "Simulating pre_rate=47.22222222222222 Hz, post_rate=47.22222222222222 Hz\n", - "Simulating pre_rate=47.22222222222222 Hz, post_rate=57.77777777777778 Hz\n", - "Simulating pre_rate=47.22222222222222 Hz, post_rate=68.33333333333333 Hz\n", - "Simulating pre_rate=47.22222222222222 Hz, post_rate=78.88888888888889 Hz\n", - "Simulating pre_rate=47.22222222222222 Hz, post_rate=89.44444444444444 Hz\n", - "Simulating pre_rate=47.22222222222222 Hz, post_rate=100.0 Hz\n", - "Simulating pre_rate=57.77777777777778 Hz, post_rate=5.0 Hz\n", - "Simulating pre_rate=57.77777777777778 Hz, post_rate=15.555555555555555 Hz\n", - "Simulating pre_rate=57.77777777777778 Hz, post_rate=26.11111111111111 Hz\n", - "Simulating pre_rate=57.77777777777778 Hz, post_rate=36.666666666666664 Hz\n", - "Simulating pre_rate=57.77777777777778 Hz, post_rate=47.22222222222222 Hz\n", - "Simulating pre_rate=57.77777777777778 Hz, post_rate=57.77777777777778 Hz\n", - "Simulating pre_rate=57.77777777777778 Hz, post_rate=68.33333333333333 Hz\n", - "Simulating pre_rate=57.77777777777778 Hz, post_rate=78.88888888888889 Hz\n", - "Simulating pre_rate=57.77777777777778 Hz, post_rate=89.44444444444444 Hz\n", - "Simulating pre_rate=57.77777777777778 Hz, post_rate=100.0 Hz\n", - "Simulating pre_rate=68.33333333333333 Hz, post_rate=5.0 Hz\n", - "Simulating pre_rate=68.33333333333333 Hz, post_rate=15.555555555555555 Hz\n", - "Simulating pre_rate=68.33333333333333 Hz, post_rate=26.11111111111111 Hz\n", - "Simulating pre_rate=68.33333333333333 Hz, post_rate=36.666666666666664 Hz\n", - "Simulating pre_rate=68.33333333333333 Hz, post_rate=47.22222222222222 Hz\n", - "Simulating pre_rate=68.33333333333333 Hz, post_rate=57.77777777777778 Hz\n", - "Simulating pre_rate=68.33333333333333 Hz, post_rate=68.33333333333333 Hz\n", - "Simulating pre_rate=68.33333333333333 Hz, post_rate=78.88888888888889 Hz\n", - "Simulating pre_rate=68.33333333333333 Hz, post_rate=89.44444444444444 Hz\n", - "Simulating pre_rate=68.33333333333333 Hz, post_rate=100.0 Hz\n", - "Simulating pre_rate=78.88888888888889 Hz, post_rate=5.0 Hz\n", - "Simulating pre_rate=78.88888888888889 Hz, post_rate=15.555555555555555 Hz\n", - "Simulating pre_rate=78.88888888888889 Hz, post_rate=26.11111111111111 Hz\n", - "Simulating pre_rate=78.88888888888889 Hz, post_rate=36.666666666666664 Hz\n", - "Simulating pre_rate=78.88888888888889 Hz, post_rate=47.22222222222222 Hz\n", - "Simulating pre_rate=78.88888888888889 Hz, post_rate=57.77777777777778 Hz\n", - "Simulating pre_rate=78.88888888888889 Hz, post_rate=68.33333333333333 Hz\n", - "Simulating pre_rate=78.88888888888889 Hz, post_rate=78.88888888888889 Hz\n", - "Simulating pre_rate=78.88888888888889 Hz, post_rate=89.44444444444444 Hz\n", - "Simulating pre_rate=78.88888888888889 Hz, post_rate=100.0 Hz\n", - "Simulating pre_rate=89.44444444444444 Hz, post_rate=5.0 Hz\n", - "Simulating pre_rate=89.44444444444444 Hz, post_rate=15.555555555555555 Hz\n", - "Simulating pre_rate=89.44444444444444 Hz, post_rate=26.11111111111111 Hz\n", - "Simulating pre_rate=89.44444444444444 Hz, post_rate=36.666666666666664 Hz\n", - "Simulating pre_rate=89.44444444444444 Hz, post_rate=47.22222222222222 Hz\n", - "Simulating pre_rate=89.44444444444444 Hz, post_rate=57.77777777777778 Hz\n", - "Simulating pre_rate=89.44444444444444 Hz, post_rate=68.33333333333333 Hz\n", - "Simulating pre_rate=89.44444444444444 Hz, post_rate=78.88888888888889 Hz\n", - "Simulating pre_rate=89.44444444444444 Hz, post_rate=89.44444444444444 Hz\n", - "Simulating pre_rate=89.44444444444444 Hz, post_rate=100.0 Hz\n", - "Simulating pre_rate=100.0 Hz, post_rate=5.0 Hz\n", - "Simulating pre_rate=100.0 Hz, post_rate=15.555555555555555 Hz\n", - "Simulating pre_rate=100.0 Hz, post_rate=26.11111111111111 Hz\n", - "Simulating pre_rate=100.0 Hz, post_rate=36.666666666666664 Hz\n", - "Simulating pre_rate=100.0 Hz, post_rate=47.22222222222222 Hz\n", - "Simulating pre_rate=100.0 Hz, post_rate=57.77777777777778 Hz\n", - "Simulating pre_rate=100.0 Hz, post_rate=68.33333333333333 Hz\n", - "Simulating pre_rate=100.0 Hz, post_rate=78.88888888888889 Hz\n", - "Simulating pre_rate=100.0 Hz, post_rate=89.44444444444444 Hz\n", - "Simulating pre_rate=100.0 Hz, post_rate=100.0 Hz\n" + "Simulating: Pre-rate=5.0 Hz, Post-rate=5.0 Hz\n", + "Actual pre rate: 6.0\n", + "Actual post rate: 2.0\n", + "Simulating: Pre-rate=5.0 Hz, Post-rate=15.6 Hz\n", + "Actual pre rate: 2.0\n", + "Actual post rate: 20.0\n", + "Simulating: Pre-rate=5.0 Hz, Post-rate=26.1 Hz\n", + "Actual pre rate: 2.0\n", + "Actual post rate: 28.0\n", + "Simulating: Pre-rate=5.0 Hz, Post-rate=36.7 Hz\n", + "Actual pre rate: 2.0\n", + "Actual post rate: 37.0\n", + "Simulating: Pre-rate=5.0 Hz, Post-rate=47.2 Hz\n", + "Actual pre rate: 5.0\n", + "Actual post rate: 47.0\n", + "Simulating: Pre-rate=5.0 Hz, Post-rate=57.8 Hz\n", + "Actual pre rate: 4.0\n", + "Actual post rate: 61.0\n", + "Simulating: Pre-rate=5.0 Hz, Post-rate=68.3 Hz\n", + "Actual pre rate: 5.0\n", + "Actual post rate: 71.0\n", + "Simulating: Pre-rate=5.0 Hz, Post-rate=78.9 Hz\n", + "Actual pre rate: 3.0\n", + "Actual post rate: 87.0\n", + "Simulating: Pre-rate=5.0 Hz, Post-rate=89.4 Hz\n", + "Actual pre rate: 4.0\n", + "Actual post rate: 104.0\n", + "Simulating: Pre-rate=5.0 Hz, Post-rate=100.0 Hz\n", + "Actual pre rate: 5.0\n", + "Actual post rate: 114.0\n", + "Simulating: Pre-rate=15.6 Hz, Post-rate=5.0 Hz\n", + "Actual pre rate: 14.0\n", + "Actual post rate: 4.0\n", + "Simulating: Pre-rate=15.6 Hz, Post-rate=15.6 Hz\n", + "Actual pre rate: 12.0\n", + "Actual post rate: 18.0\n", + "Simulating: Pre-rate=15.6 Hz, Post-rate=26.1 Hz\n", + "Actual pre rate: 13.0\n", + "Actual post rate: 26.0\n", + "Simulating: Pre-rate=15.6 Hz, Post-rate=36.7 Hz\n", + "Actual pre rate: 17.0\n", + "Actual post rate: 37.0\n", + "Simulating: Pre-rate=15.6 Hz, Post-rate=47.2 Hz\n", + "Actual pre rate: 17.0\n", + "Actual post rate: 51.0\n", + "Simulating: Pre-rate=15.6 Hz, Post-rate=57.8 Hz\n", + "Actual pre rate: 18.0\n", + "Actual post rate: 63.0\n", + "Simulating: Pre-rate=15.6 Hz, Post-rate=68.3 Hz\n", + "Actual pre rate: 13.0\n", + "Actual post rate: 73.0\n", + "Simulating: Pre-rate=15.6 Hz, Post-rate=78.9 Hz\n", + "Actual pre rate: 17.0\n", + "Actual post rate: 87.0\n", + "Simulating: Pre-rate=15.6 Hz, Post-rate=89.4 Hz\n", + "Actual pre rate: 16.0\n", + "Actual post rate: 99.0\n", + "Simulating: Pre-rate=15.6 Hz, Post-rate=100.0 Hz\n", + "Actual pre rate: 18.0\n", + "Actual post rate: 103.0\n", + "Simulating: Pre-rate=26.1 Hz, Post-rate=5.0 Hz\n", + "Actual pre rate: 25.0\n", + "Actual post rate: 6.0\n", + "Simulating: Pre-rate=26.1 Hz, Post-rate=15.6 Hz\n", + "Actual pre rate: 28.0\n", + "Actual post rate: 14.0\n", + "Simulating: Pre-rate=26.1 Hz, Post-rate=26.1 Hz\n", + "Actual pre rate: 27.0\n", + "Actual post rate: 29.0\n", + "Simulating: Pre-rate=26.1 Hz, Post-rate=36.7 Hz\n", + "Actual pre rate: 35.0\n", + "Actual post rate: 37.0\n", + "Simulating: Pre-rate=26.1 Hz, Post-rate=47.2 Hz\n", + "Actual pre rate: 28.0\n", + "Actual post rate: 52.0\n", + "Simulating: Pre-rate=26.1 Hz, Post-rate=57.8 Hz\n", + "Actual pre rate: 23.0\n", + "Actual post rate: 62.0\n", + "Simulating: Pre-rate=26.1 Hz, Post-rate=68.3 Hz\n", + "Actual pre rate: 25.0\n", + "Actual post rate: 81.0\n", + "Simulating: Pre-rate=26.1 Hz, Post-rate=78.9 Hz\n", + "Actual pre rate: 31.0\n", + "Actual post rate: 88.0\n", + "Simulating: Pre-rate=26.1 Hz, Post-rate=89.4 Hz\n", + "Actual pre rate: 32.0\n", + "Actual post rate: 99.0\n", + "Simulating: Pre-rate=26.1 Hz, Post-rate=100.0 Hz\n", + "Actual pre rate: 33.0\n", + "Actual post rate: 115.0\n", + "Simulating: Pre-rate=36.7 Hz, Post-rate=5.0 Hz\n", + "Actual pre rate: 33.0\n", + "Actual post rate: 6.0\n", + "Simulating: Pre-rate=36.7 Hz, Post-rate=15.6 Hz\n", + "Actual pre rate: 32.0\n", + "Actual post rate: 15.0\n", + "Simulating: Pre-rate=36.7 Hz, Post-rate=26.1 Hz\n", + "Actual pre rate: 35.0\n", + "Actual post rate: 26.0\n", + "Simulating: Pre-rate=36.7 Hz, Post-rate=36.7 Hz\n", + "Actual pre rate: 34.0\n", + "Actual post rate: 50.0\n", + "Simulating: Pre-rate=36.7 Hz, Post-rate=47.2 Hz\n", + "Actual pre rate: 34.0\n", + "Actual post rate: 55.0\n", + "Simulating: Pre-rate=36.7 Hz, Post-rate=57.8 Hz\n", + "Actual pre rate: 35.0\n", + "Actual post rate: 61.0\n", + "Simulating: Pre-rate=36.7 Hz, Post-rate=68.3 Hz\n", + "Actual pre rate: 39.0\n", + "Actual post rate: 72.0\n", + "Simulating: Pre-rate=36.7 Hz, Post-rate=78.9 Hz\n", + "Actual pre rate: 44.0\n", + "Actual post rate: 91.0\n", + "Simulating: Pre-rate=36.7 Hz, Post-rate=89.4 Hz\n", + "Actual pre rate: 41.0\n", + "Actual post rate: 103.0\n", + "Simulating: Pre-rate=36.7 Hz, Post-rate=100.0 Hz\n", + "Actual pre rate: 38.0\n", + "Actual post rate: 116.0\n", + "Simulating: Pre-rate=47.2 Hz, Post-rate=5.0 Hz\n", + "Actual pre rate: 45.0\n", + "Actual post rate: 3.0\n", + "Simulating: Pre-rate=47.2 Hz, Post-rate=15.6 Hz\n", + "Actual pre rate: 43.0\n", + "Actual post rate: 16.0\n", + "Simulating: Pre-rate=47.2 Hz, Post-rate=26.1 Hz\n", + "Actual pre rate: 46.0\n", + "Actual post rate: 24.0\n", + "Simulating: Pre-rate=47.2 Hz, Post-rate=36.7 Hz\n", + "Actual pre rate: 52.0\n", + "Actual post rate: 41.0\n", + "Simulating: Pre-rate=47.2 Hz, Post-rate=47.2 Hz\n", + "Actual pre rate: 51.0\n", + "Actual post rate: 48.0\n", + "Simulating: Pre-rate=47.2 Hz, Post-rate=57.8 Hz\n", + "Actual pre rate: 43.0\n", + "Actual post rate: 63.0\n", + "Simulating: Pre-rate=47.2 Hz, Post-rate=68.3 Hz\n", + "Actual pre rate: 48.0\n", + "Actual post rate: 77.0\n", + "Simulating: Pre-rate=47.2 Hz, Post-rate=78.9 Hz\n", + "Actual pre rate: 49.0\n", + "Actual post rate: 93.0\n", + "Simulating: Pre-rate=47.2 Hz, Post-rate=89.4 Hz\n", + "Actual pre rate: 49.0\n", + "Actual post rate: 112.0\n", + "Simulating: Pre-rate=47.2 Hz, Post-rate=100.0 Hz\n", + "Actual pre rate: 48.0\n", + "Actual post rate: 118.0\n", + "Simulating: Pre-rate=57.8 Hz, Post-rate=5.0 Hz\n", + "Actual pre rate: 56.0\n", + "Actual post rate: 4.0\n", + "Simulating: Pre-rate=57.8 Hz, Post-rate=15.6 Hz\n", + "Actual pre rate: 56.0\n", + "Actual post rate: 11.0\n", + "Simulating: Pre-rate=57.8 Hz, Post-rate=26.1 Hz\n", + "Actual pre rate: 61.0\n", + "Actual post rate: 28.0\n", + "Simulating: Pre-rate=57.8 Hz, Post-rate=36.7 Hz\n", + "Actual pre rate: 56.0\n", + "Actual post rate: 40.0\n", + "Simulating: Pre-rate=57.8 Hz, Post-rate=47.2 Hz\n", + "Actual pre rate: 56.0\n", + "Actual post rate: 54.0\n", + "Simulating: Pre-rate=57.8 Hz, Post-rate=57.8 Hz\n", + "Actual pre rate: 58.0\n", + "Actual post rate: 60.0\n", + "Simulating: Pre-rate=57.8 Hz, Post-rate=68.3 Hz\n", + "Actual pre rate: 61.0\n", + "Actual post rate: 72.0\n", + "Simulating: Pre-rate=57.8 Hz, Post-rate=78.9 Hz\n", + "Actual pre rate: 53.0\n", + "Actual post rate: 89.0\n", + "Simulating: Pre-rate=57.8 Hz, Post-rate=89.4 Hz\n", + "Actual pre rate: 57.0\n", + "Actual post rate: 106.0\n", + "Simulating: Pre-rate=57.8 Hz, Post-rate=100.0 Hz\n", + "Actual pre rate: 54.0\n", + "Actual post rate: 111.0\n", + "Simulating: Pre-rate=68.3 Hz, Post-rate=5.0 Hz\n", + "Actual pre rate: 63.0\n", + "Actual post rate: 4.0\n", + "Simulating: Pre-rate=68.3 Hz, Post-rate=15.6 Hz\n", + "Actual pre rate: 67.0\n", + "Actual post rate: 20.0\n", + "Simulating: Pre-rate=68.3 Hz, Post-rate=26.1 Hz\n", + "Actual pre rate: 67.0\n", + "Actual post rate: 26.0\n", + "Simulating: Pre-rate=68.3 Hz, Post-rate=36.7 Hz\n", + "Actual pre rate: 72.0\n", + "Actual post rate: 37.0\n", + "Simulating: Pre-rate=68.3 Hz, Post-rate=47.2 Hz\n", + "Actual pre rate: 68.0\n", + "Actual post rate: 49.0\n", + "Simulating: Pre-rate=68.3 Hz, Post-rate=57.8 Hz\n", + "Actual pre rate: 66.0\n", + "Actual post rate: 60.0\n", + "Simulating: Pre-rate=68.3 Hz, Post-rate=68.3 Hz\n", + "Actual pre rate: 62.0\n", + "Actual post rate: 85.0\n", + "Simulating: Pre-rate=68.3 Hz, Post-rate=78.9 Hz\n", + "Actual pre rate: 66.0\n", + "Actual post rate: 93.0\n", + "Simulating: Pre-rate=68.3 Hz, Post-rate=89.4 Hz\n", + "Actual pre rate: 60.0\n", + "Actual post rate: 107.0\n", + "Simulating: Pre-rate=68.3 Hz, Post-rate=100.0 Hz\n", + "Actual pre rate: 66.0\n", + "Actual post rate: 110.0\n", + "Simulating: Pre-rate=78.9 Hz, Post-rate=5.0 Hz\n", + "Actual pre rate: 84.0\n", + "Actual post rate: 3.0\n", + "Simulating: Pre-rate=78.9 Hz, Post-rate=15.6 Hz\n", + "Actual pre rate: 76.0\n", + "Actual post rate: 14.0\n", + "Simulating: Pre-rate=78.9 Hz, Post-rate=26.1 Hz\n", + "Actual pre rate: 84.0\n", + "Actual post rate: 28.0\n", + "Simulating: Pre-rate=78.9 Hz, Post-rate=36.7 Hz\n", + "Actual pre rate: 75.0\n", + "Actual post rate: 47.0\n", + "Simulating: Pre-rate=78.9 Hz, Post-rate=47.2 Hz\n", + "Actual pre rate: 76.0\n", + "Actual post rate: 52.0\n", + "Simulating: Pre-rate=78.9 Hz, Post-rate=57.8 Hz\n", + "Actual pre rate: 75.0\n", + "Actual post rate: 72.0\n", + "Simulating: Pre-rate=78.9 Hz, Post-rate=68.3 Hz\n", + "Actual pre rate: 84.0\n", + "Actual post rate: 71.0\n", + "Simulating: Pre-rate=78.9 Hz, Post-rate=78.9 Hz\n", + "Actual pre rate: 76.0\n", + "Actual post rate: 95.0\n", + "Simulating: Pre-rate=78.9 Hz, Post-rate=89.4 Hz\n", + "Actual pre rate: 87.0\n", + "Actual post rate: 95.0\n", + "Simulating: Pre-rate=78.9 Hz, Post-rate=100.0 Hz\n", + "Actual pre rate: 75.0\n", + "Actual post rate: 121.0\n", + "Simulating: Pre-rate=89.4 Hz, Post-rate=5.0 Hz\n", + "Actual pre rate: 90.0\n", + "Actual post rate: 3.0\n", + "Simulating: Pre-rate=89.4 Hz, Post-rate=15.6 Hz\n", + "Actual pre rate: 100.0\n", + "Actual post rate: 12.0\n", + "Simulating: Pre-rate=89.4 Hz, Post-rate=26.1 Hz\n", + "Actual pre rate: 93.0\n", + "Actual post rate: 32.0\n", + "Simulating: Pre-rate=89.4 Hz, Post-rate=36.7 Hz\n", + "Actual pre rate: 93.0\n", + "Actual post rate: 36.0\n", + "Simulating: Pre-rate=89.4 Hz, Post-rate=47.2 Hz\n", + "Actual pre rate: 92.0\n", + "Actual post rate: 54.0\n", + "Simulating: Pre-rate=89.4 Hz, Post-rate=57.8 Hz\n", + "Actual pre rate: 97.0\n", + "Actual post rate: 60.0\n", + "Simulating: Pre-rate=89.4 Hz, Post-rate=68.3 Hz\n", + "Actual pre rate: 93.0\n", + "Actual post rate: 76.0\n", + "Simulating: Pre-rate=89.4 Hz, Post-rate=78.9 Hz\n", + "Actual pre rate: 99.0\n", + "Actual post rate: 84.0\n", + "Simulating: Pre-rate=89.4 Hz, Post-rate=89.4 Hz\n", + "Actual pre rate: 81.0\n", + "Actual post rate: 114.0\n", + "Simulating: Pre-rate=89.4 Hz, Post-rate=100.0 Hz\n", + "Actual pre rate: 94.0\n", + "Actual post rate: 113.0\n", + "Simulating: Pre-rate=100.0 Hz, Post-rate=5.0 Hz\n", + "Actual pre rate: 109.0\n", + "Actual post rate: 4.0\n", + "Simulating: Pre-rate=100.0 Hz, Post-rate=15.6 Hz\n", + "Actual pre rate: 107.0\n", + "Actual post rate: 16.0\n", + "Simulating: Pre-rate=100.0 Hz, Post-rate=26.1 Hz\n", + "Actual pre rate: 111.0\n", + "Actual post rate: 22.0\n", + "Simulating: Pre-rate=100.0 Hz, Post-rate=36.7 Hz\n", + "Actual pre rate: 97.0\n", + "Actual post rate: 47.0\n", + "Simulating: Pre-rate=100.0 Hz, Post-rate=47.2 Hz\n", + "Actual pre rate: 105.0\n", + "Actual post rate: 62.0\n", + "Simulating: Pre-rate=100.0 Hz, Post-rate=57.8 Hz\n", + "Actual pre rate: 104.0\n", + "Actual post rate: 67.0\n", + "Simulating: Pre-rate=100.0 Hz, Post-rate=68.3 Hz\n", + "Actual pre rate: 107.0\n", + "Actual post rate: 69.0\n", + "Simulating: Pre-rate=100.0 Hz, Post-rate=78.9 Hz\n", + "Actual pre rate: 107.0\n", + "Actual post rate: 97.0\n", + "Simulating: Pre-rate=100.0 Hz, Post-rate=89.4 Hz\n", + "Actual pre rate: 110.0\n", + "Actual post rate: 94.0\n", + "Simulating: Pre-rate=100.0 Hz, Post-rate=100.0 Hz\n", + "Actual pre rate: 106.0\n", + "Actual post rate: 108.0\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "DEBUG:locator: \n" + "DEBUG:locator: \n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3364,88 +3547,139 @@ } ], "source": [ + "import nest\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from matplotlib.colors import LinearSegmentedColormap\n", - "from brian2 import *\n", "\n", - "# Simulation parameters\n", - "duration = 1000 * ms # Simulation duration\n", - "dt = 0.1 * ms # Simulation time step\n", + "# --- Simulation Parameters ---\n", + "# Duration of each individual simulation\n", + "duration = 1000. # ms\n", + "# Simulation time step\n", + "dt = 0.1 # ms\n", + "\n", + "# --- STDP Synapse Parameters ---\n", + "# This script uses NEST's standard 'stdp_synapse' model.\n", + "# Note: In the standard asymmetric model, tau_plus is for LTP and tau_minus is for LTD.\n", + "tau_plus = 20.0 # LTP time window (τ+), corresponds to tau_post in the original script\n", + "tau_minus = 20.0 # LTD time window (τ-), corresponds to tau_pre in the original script\n", + "A_plus = 0.001 # LTP amplitude change (NEST's 'lambda'), from A_post\n", + "A_minus = 0.001 # LTD amplitude change (NEST's 'alpha'), from A_pre\n", + "w_max = 1.0 # Maximum synaptic weight\n", + "initial_weight = 0.5 # Starting weight for the synapse\n", + "\n", + "# --- Firing Rate Parameters ---\n", + "# Range of firing rates to test (in Hz)\n", + "pre_rates = np.linspace(5.0, 100.0, 10)\n", + "post_rates = np.linspace(5.0, 100.0, 10)\n", + "\n", + "# --- Result Matrix ---\n", + "# Initialize a matrix to store the final weight change for each rate pair\n", + "weight_changes = np.zeros((len(pre_rates), len(post_rates)))\n", "\n", - "# STDP parameters\n", - "tau_pre = 20 * ms\n", - "tau_post = 20 * ms\n", - "A_pre = 0.001 # LTD amplitude\n", - "A_post = 0.001 # LTP amplitude\n", - "w_max = 1.0 # Maximum weight\n", + "# --- NEST Simulation Loop ---\n", + "# Iterate over every combination of presynaptic and postsynaptic firing rates\n", + "for i, pre_rate in enumerate(pre_rates):\n", + " for j, post_rate in enumerate(post_rates):\n", + " print(f\"Simulating: Pre-rate={pre_rate:.1f} Hz, Post-rate={post_rate:.1f} Hz\")\n", "\n", - "# Range of firing rates to test (Hz)\n", - "pre_rates = np.linspace(5, 100, 10)\n", - "post_rates = np.linspace(5, 100, 10)\n", + " # --- 1. Reset NEST Kernel ---\n", + " # Ensures that each simulation run is independent and starts from a clean state\n", + " nest.ResetKernel()\n", + " nest.resolution = dt\n", + " # Suppress NEST's progress output for a cleaner console\n", + " nest.print_time = False\n", + " nest.local_num_threads = 1 # Ensures reproducibility for this script\n", + "\n", + " # --- 2. 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", + " # --- 3. Configure Synapse Model ---\n", + " # Define the parameters for NEST's built-in STDP synapse model\n", + " stdp_params = {\n", + " \"lambda\": A_plus, # Potentiation step\n", + " \"alpha\": A_minus, # Depression step (as a positive factor)\n", + " \"Wmax\": w_max, # Upper bound for the weight\n", + " \"weight\": initial_weight,\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", - "# Initialize result matrix to store final weights\n", - "weight_changes = np.zeros((len(pre_rates), len(post_rates)))\n", + " nest.Connect(pre_parrot, post_neuron, syn_spec={\"synapse_model\": \"stdp_synapse\"})\n", + " nest.Connect(post_driver, post_neuron, syn_spec={\"weight\": 2000.})\n", "\n", - "# Function to simulate STDP for a given pre and post rate\n", - "def simulate_stdp(pre_rate, post_rate):\n", - " # Set up the network\n", - " pre = PoissonGroup(1, rates=pre_rate * Hz)\n", - " post = PoissonGroup(1, rates=post_rate * Hz)\n", - " \n", - " # STDP synapse\n", - " S = Synapses(pre, post,\n", - " '''\n", - " w : 1\n", - " dapre/dt = -apre/tau_pre : 1 (event-driven)\n", - " dapost/dt = -apost/tau_post : 1 (event-driven)\n", - " ''',\n", - " on_pre='''\n", - " apre += A_pre\n", - " w = clip(w + apost, 0, w_max)\n", - " ''',\n", - " on_post='''\n", - " apost += A_post\n", - " w = clip(w + apre, 0, w_max)\n", - " ''')\n", - " \n", - " S.connect()\n", - " S.w = 0.5 # Initial weight\n", - " \n", - " # Record weight changes\n", - " weight_mon = StateMonitor(S, 'w', record=0)\n", - " \n", - " # Run simulation\n", - " run(duration)\n", - " \n", - " # Return the weight change (final - initial)\n", - " return weight_mon.w[0][-1] - 0.5\n", + " # --- 5. Get Initial Weight ---\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", - "# Run simulations for all combinations of pre and post rates\n", - "for i, pre_rate in enumerate(pre_rates):\n", - " for j, post_rate in enumerate(post_rates):\n", - " print(f\"Simulating pre_rate={pre_rate} Hz, post_rate={post_rate} Hz\")\n", - " weight_changes[i, j] = simulate_stdp(pre_rate, post_rate)\n", + " # --- 6. Run Simulation ---\n", + " nest.Simulate(duration)\n", + " \n", + " assert len(sr_pre.events[\"times\"]) > 0\n", + " print(\"Actual pre rate: \" + str(len(sr_pre.events[\"times\"]) / (duration / 1000)))\n", + " assert len(sr_post.events[\"times\"]) > 0\n", + " print(\"Actual post rate: \" + str(len(sr_post.events[\"times\"]) / (duration / 1000)))\n", "\n", - "# Create a custom colormap: blue for depression, white for no change, red for potentiation\n", - "colors = [(0, 0, 1), (1, 1, 1), (1, 0, 0)] # Blue -> White -> Red\n", - "cmap = LinearSegmentedColormap.from_list('stdp_cmap', colors, N=100)\n", + " # --- 7. Get Final Weight ---\n", + " # Retrieve the weight after the simulation has finished\n", + " final_w = nest.GetStatus(connection, \"weight\")[0]\n", "\n", - "# Plot the results\n", - "plt.figure(figsize=(10, 8))\n", - "im = plt.imshow(weight_changes, cmap=cmap, \n", - " extent=[post_rates[0], post_rates[-1], pre_rates[0], pre_rates[-1]],\n", - " origin='lower', aspect='auto', vmin=-0.5, vmax=0.5)\n", + " # --- 8. Store Result ---\n", + " weight_changes[i, j] = final_w - initial_w\n", + "\n", + "# --- Plotting Results ---\n", + "# The plotting code is largely the same as in the original script.\n", "\n", - "plt.colorbar(im, label='Weight Change')\n", + "# Create a custom colormap: blue -> white -> red\n", + "colors = [(0, 0, 1), (1, 1, 1), (1, 0, 0)] # Blue, White, Red\n", + "cmap = 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=(10, 8))\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", + "# Add labels, title, and a color bar\n", + "plt.colorbar(im, label='Change in Synaptic Weight')\n", "plt.xlabel('Postsynaptic Firing Rate (Hz)')\n", "plt.ylabel('Presynaptic Firing Rate (Hz)')\n", - "plt.title('STDP Weight Change for Different Firing Rates (1000 ms)')\n", - "\n", - "# Add grid lines\n", + "plt.title(f'STDP Weight Change vs. Firing Rates ({int(duration)} ms) - NEST Simulator')\n", "plt.grid(False)\n", "plt.tight_layout()\n", - "plt.savefig('stdp_weight_change_heatmap.png', dpi=300)\n", + "\n", + "# Save the figure (optional)\n", + "# plt.savefig('stdp_nest_heatmap.png', dpi=300)\n", + "\n", + "# Display the plot\n", "plt.show()" ] }, @@ -3462,7 +3696,7 @@ "\n", "## Acknowledgements\n", "\n", - "The authors would like to thank Prof. Wei Pan and Dr. Yuxiang Liu for kindly providing ..." + "The authors would like to thank Prof. Wei Pan and Dr. Yuxiang Liu for kindly providing the source code for their original publication. " ] } ], From 3fd292d30663ab86a857d21734409032078abadc Mon Sep 17 00:00:00 2001 From: "C.A.P. Linssen" Date: Tue, 17 Jun 2025 15:01:03 +0200 Subject: [PATCH 3/8] add mountain car reinforcement learning tutorial --- ...inforcement_learning_nestml_tutorial.ipynb | 1403 +++++++++-------- 1 file changed, 707 insertions(+), 696 deletions(-) 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 index 462aef077..8af9b9537 100644 --- 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 @@ -13,9 +13,11 @@ "id": "27c21179", "metadata": {}, "source": [ + "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", - "In this tutorial, we are going to build an agent that can successfully solve the \"mountain car\" task using reinforcement learning. [describe the task..]\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." ] @@ -37,7 +39,7 @@ " - A renderer to display the simulation \n", " - The physics system\n", " \n", - "We will use the popular \"pygame\" package to do the rendering. [add citation]" + "We will use the popular \"pygame\" package to do the rendering [3]." ] }, { @@ -73,15 +75,17 @@ "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", - "from collections import defaultdict\n", "import sys\n", "import time\n", "\n", @@ -90,7 +94,7 @@ "import nest\n", "\n", "nest.set_verbosity(\"M_ERROR\")\n", - "nest_local_num_threads = 8 # XXX should be 1 by default\n", + "nest_local_num_threads = 1\n", "\n", "mpl.rcParams[\"axes.grid\"] = True\n", "mpl.rcParams[\"grid.color\"] = \"k\"\n", @@ -107,7 +111,30 @@ "source": [ "### Physics of the mountain car task\n", "\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" ] }, { @@ -118,11 +145,6 @@ "outputs": [], "source": [ "class MountainCarPhysics:\n", - " \"\"\"\n", - " A custom implementation of the Mountain Car environment.\n", - " Uses Forward Euler integration for physics.\n", - " \"\"\"\n", - "\n", " def __init__(self,\n", " dt: float = 10E-3,\n", " POS_MIN = -1.5,\n", @@ -312,7 +334,9 @@ "source": [ "# The Agent\n", "\n", - "In the base class ``Agent``...\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", "\n", "The state is a set S of agent observable states. \"boxes\" (discretizing the state space)...\n", "\n", @@ -678,215 +702,215 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_422139/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_466717/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.17, Avg Reward (Last 100): -505.92, p_explore: 0.4954\n" + "Episode: 100/1500, Reward: -505.25, Avg Reward (Last 100): -505.82, p_explore: 0.4954\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_422139/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_466717/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: -505.21, Avg Reward (Last 100): -503.95, p_explore: 0.2454\n" + "Episode: 200/1500, Reward: -511.00, Avg Reward (Last 100): -502.18, p_explore: 0.2454\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_422139/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_466717/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: -518.23, Avg Reward (Last 100): -458.50, p_explore: 0.1216\n" + "Episode: 300/1500, Reward: -341.47, Avg Reward (Last 100): -421.71, p_explore: 0.1216\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_422139/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_466717/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: -284.43, Avg Reward (Last 100): -371.70, p_explore: 0.0602\n" + "Episode: 400/1500, Reward: -358.99, Avg Reward (Last 100): -397.72, p_explore: 0.0602\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_422139/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_466717/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: -400.98, Avg Reward (Last 100): -357.51, p_explore: 0.0298\n" + "Episode: 500/1500, Reward: -514.72, Avg Reward (Last 100): -379.10, p_explore: 0.0298\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_422139/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_466717/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: -276.57, Avg Reward (Last 100): -344.15, p_explore: 0.0148\n" + "Episode: 600/1500, Reward: -378.92, Avg Reward (Last 100): -348.36, p_explore: 0.0148\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_422139/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_466717/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: -272.36, Avg Reward (Last 100): -319.99, p_explore: 0.0000\n" + "Episode: 700/1500, Reward: -270.65, Avg Reward (Last 100): -365.93, p_explore: 0.0000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_422139/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_466717/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: -361.60, Avg Reward (Last 100): -301.87, p_explore: 0.0000\n" + "Episode: 800/1500, Reward: -269.72, Avg Reward (Last 100): -324.57, p_explore: 0.0000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_422139/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_466717/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: -277.43, Avg Reward (Last 100): -305.19, p_explore: 0.0000\n" + "Episode: 900/1500, Reward: -308.57, Avg Reward (Last 100): -320.11, p_explore: 0.0000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_422139/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_466717/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: -283.36, Avg Reward (Last 100): -297.28, p_explore: 0.0000\n" + "Episode: 1000/1500, Reward: -337.12, Avg Reward (Last 100): -297.41, p_explore: 0.0000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_422139/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_466717/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: -260.01, Avg Reward (Last 100): -280.45, p_explore: 0.0000\n" + "Episode: 1100/1500, Reward: -211.31, Avg Reward (Last 100): -292.63, p_explore: 0.0000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_422139/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_466717/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: -286.47, Avg Reward (Last 100): -289.09, p_explore: 0.0000\n" + "Episode: 1200/1500, Reward: -262.84, Avg Reward (Last 100): -270.42, p_explore: 0.0000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_422139/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_466717/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: -257.20, Avg Reward (Last 100): -264.03, p_explore: 0.0000\n" + "Episode: 1300/1500, Reward: -313.19, Avg Reward (Last 100): -268.92, p_explore: 0.0000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_422139/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_466717/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: -240.43, Avg Reward (Last 100): -264.71, p_explore: 0.0000\n" + "Episode: 1400/1500, Reward: -275.84, Avg Reward (Last 100): -259.86, p_explore: 0.0000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_422139/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_466717/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: -258.35, Avg Reward (Last 100): -262.64, p_explore: 0.0000\n" + "Episode: 1500/1500, Reward: -262.36, Avg Reward (Last 100): -261.79, p_explore: 0.0000\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1019,7 +1043,7 @@ "id": "5831c9d7", "metadata": {}, "source": [ - "# SNN Visualization" + "## SNN Visualization" ] }, { @@ -1070,7 +1094,7 @@ " post_idx = post_map[tgt]\n", " weight_matrix[pre_idx, post_idx] = w\n", " \n", - " return weight_matrix, pre_neurons, post_neurons\n" + " return weight_matrix, pre_neurons, post_neurons" ] }, { @@ -1111,9 +1135,6 @@ " 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", - "# self.ax[1].plot(data[\"multimeter_right_events\"][\"times\"], data[\"multimeter_right_events\"][\"V_m\"], 'r')\n", - "# self.ax[1].plot(data[\"multimeter_left_events\"][\"times\"], data[\"multimeter_left_events\"][\"V_m\"], 'b')\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", @@ -1128,9 +1149,6 @@ " \n", " self.ax[1].set_ylabel(\"V_m [mV]\")\n", " \n", - "# self.ax[2].plot(data[\"output_spikes_left\"][\"times\"], data[\"output_spikes_left\"][\"senders\"], \".b\", markersize=5)\n", - "# self.ax[2].plot(data[\"output_spikes_right\"][\"times\"], data[\"output_spikes_right\"][\"senders\"], \".r\", markersize=5)\n", - "# self.ax[2].set_ylabel(\"Output Neuron\")\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", @@ -1177,13 +1195,9 @@ " \n", " self.ax[-1].set_xlabel(\"Time [ms]\")\n", " \n", - "# self.fig.canvas.draw()\n", " self.fig.savefig(\"/tmp/mountain_car_log.png\", dpi=300)\n", - "# self.fig.canvas.flush_events()\n", " \n", - "# self.lifetime_fig.canvas.draw()\n", " self.lifetime_fig.savefig(\"/tmp/mountain_car_spiking_lifetime.png\", dpi=300)\n", - "# self.lifetime_fig.canvas.flush_events()\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", @@ -1196,7 +1210,6 @@ " 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", " \n", " # for left\n", "\n", @@ -1228,14 +1241,14 @@ " right_q_table_matrix[pos_bin, vel_bin] = w\n", "\n", " \n", - " # Determine the overall min and max from all datasets.\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", + " # 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", + " # 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", @@ -1265,9 +1278,7 @@ " ax.legend()\n", " fig.savefig(\"/tmp/weights_spiking_1D.png\", dpi=300)\n", "\n", - " plt.close(fig)\n", - "\n", - " " + " plt.close(fig)" ] }, { @@ -1278,11 +1289,13 @@ "\n", "## NESTML models\n", "\n", - "Neurons in the input layer will simply be spike generators (ignore_and_fire) that will fire spikes periodically with a given interval.\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", - "Neuron model used for the output layer will be iaf_psc_exp.\n", + "Input layer neurons are connected to the output layer neurons through the neuromodulated STDP synapse called ``neuromodulated_stdp_synapse``.\n", "\n", - "Input layer neurons are connected through output layer neurons through ``neuromodulated_stdp_synapse``.\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." ] }, { @@ -1315,7 +1328,7 @@ "[2,GLOBAL, INFO]: /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/iaf_psc_exp_neuron.nestml\n", "[3,GLOBAL, INFO]: /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/neuromodulated_stdp_synapse.nestml\n", "[4,GLOBAL, INFO]: Target platform code will be generated in directory: '/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target'\n", - "[5,GLOBAL, INFO]: Target platform code will be installed in directory: '/tmp/nestml_target_j3n51fhv'\n", + "[5,GLOBAL, INFO]: Target platform code will be installed in directory: '/tmp/nestml_target_404rbl0t'\n", "\n", " -- N E S T --\n", " Copyright (C) 2004 The NEST Initiative\n", @@ -1346,7 +1359,20 @@ "[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" + "[21,neuromodulated_stdp_synapse_nestml, WARNING, [15:8;15:17]]: Variable 'd' has the same name as a physical unit!\n", + "[22,GLOBAL, INFO]: State variables that will be moved from synapse to neuron: ['post_trace']\n", + "[23,GLOBAL, INFO]: Parameters that will be copied from synapse to neuron: ['tau_tr_post']\n", + "[24,GLOBAL, INFO]: Synaptic state variables moved to neuron that will need buffering: []\n", + "[25,GLOBAL, INFO]: Moving state var defining equation(s) post_trace\n", + "[26,GLOBAL, INFO]: Moving state variables for equation(s) post_trace\n", + "[27,GLOBAL, INFO]: Moving definition of post_trace from synapse to neuron\n", + "[28,GLOBAL, INFO]: \tMoving statement post_trace += 1 # XXX FIXME!!!! should be ``+= post_trace_increment``\n", + "[29,GLOBAL, INFO]: In synapse: replacing ``continuous`` type input ports that are connected to postsynaptic neuron with external variable references\n", + "[30,GLOBAL, INFO]: Copying parameters from synapse to neuron...\n", + "[31,GLOBAL, INFO]: Copying definition of tau_tr_post from synapse to neuron\n", + "[32,GLOBAL, INFO]: Adding suffix to variables in spike updates\n", + "[33,GLOBAL, INFO]: In synapse: replacing variables with suffixed external variable references\n", + "[34,GLOBAL, INFO]: \t• Replacing variable post_trace\n" ] }, { @@ -1404,7 +1430,7 @@ "DEBUG:Created Shape with symbol V_m, derivative_factors = [-1/tau_m], inhom_term = E_l/tau_m + I_e/tau_m, nonlin_term = E_e*g_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m\n", "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", - "INFO:All known variables: [g_e, V_m], all parameters used in ODEs: {tau_g, I_stim, E_l, tau_m, I_e, E_e}\n", + "INFO:All known variables: [g_e, V_m], all parameters used in ODEs: {tau_m, E_l, I_stim, E_e, tau_g, I_e}\n", "INFO:No numerical value specified for parameter \"I_stim\"\n", "INFO:\n", "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", @@ -1427,36 +1453,13 @@ "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0]])\n", "DEBUG:\tinhomogeneous term: 0.0\n", "DEBUG:\tnonlinear term: 0.0\n", - "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", - "DEBUG:Splitting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m (symbols Matrix([[g_e], [V_m]]))\n", - "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m]])\n", - "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", - "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", - "DEBUG:Initializing system of shapes with x = Matrix([[g_e], [V_m]]), A = Matrix([[-1/tau_g, 0], [E_e/tau_m, -1/tau_m]]), b = Matrix([[0], [E_l/tau_m + I_e/tau_m + I_stim/tau_m]]), c = Matrix([[0], [-V_m*g_e/tau_m]])\n", - "INFO:Finding analytically solvable equations...\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", - "DEBUG:os.makedirs('/tmp')\n", - "DEBUG:write lines to '/tmp/ode_dependency_graph.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n" + "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "[22,GLOBAL, INFO]: State variables that will be moved from synapse to neuron: ['post_trace']\n", - "[23,GLOBAL, INFO]: Parameters that will be copied from synapse to neuron: ['tau_tr_post']\n", - "[24,GLOBAL, INFO]: Synaptic state variables moved to neuron that will need buffering: []\n", - "[25,GLOBAL, INFO]: Moving state var defining equation(s) post_trace\n", - "[26,GLOBAL, INFO]: Moving state variables for equation(s) post_trace\n", - "[27,GLOBAL, INFO]: Moving definition of post_trace from synapse to neuron\n", - "[28,GLOBAL, INFO]: \tMoving statement post_trace += 1 # XXX FIXME!!!! should be ``+= post_trace_increment``\n", - "[29,GLOBAL, INFO]: In synapse: replacing ``continuous`` type input ports that are connected to postsynaptic neuron with external variable references\n", - "[30,GLOBAL, INFO]: Copying parameters from synapse to neuron...\n", - "[31,GLOBAL, INFO]: Copying definition of tau_tr_post from synapse to neuron\n", - "[32,GLOBAL, INFO]: Adding suffix to variables in spike updates\n", - "[33,GLOBAL, INFO]: In synapse: replacing variables with suffixed external variable references\n", - "[34,GLOBAL, INFO]: \t• Replacing variable post_trace\n", "[35,GLOBAL, INFO]: Successfully constructed neuron-synapse pair iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml, neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml\n", "[36,GLOBAL, INFO]: Analysing/transforming model 'iaf_psc_exp_neuron_nestml'\n", "[37,iaf_psc_exp_neuron_nestml, INFO, [18:0;58:0]]: Starts processing of the model 'iaf_psc_exp_neuron_nestml'\n" @@ -1466,6 +1469,16 @@ "name": "stderr", "output_type": "stream", "text": [ + "DEBUG:Splitting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m (symbols Matrix([[g_e], [V_m]]))\n", + "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m]])\n", + "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", + "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", + "DEBUG:Initializing system of shapes with x = Matrix([[g_e], [V_m]]), A = Matrix([[-1/tau_g, 0], [E_e/tau_m, -1/tau_m]]), b = Matrix([[0], [E_l/tau_m + I_e/tau_m + I_stim/tau_m]]), c = Matrix([[0], [-V_m*g_e/tau_m]])\n", + "INFO:Finding analytically solvable equations...\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", + "DEBUG:os.makedirs('/tmp')\n", + "DEBUG:write lines to '/tmp/ode_dependency_graph.dot'\n", + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n", "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m])\n", "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0]])\n", @@ -1586,7 +1599,7 @@ "DEBUG:Created Shape with symbol V_m, derivative_factors = [-1/tau_m], inhom_term = E_l/tau_m + I_e/tau_m, nonlin_term = E_e*g_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m\n", "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", - "INFO:All known variables: [g_e, V_m], all parameters used in ODEs: {tau_g, I_stim, E_l, tau_m, I_e, E_e}\n", + "INFO:All known variables: [g_e, V_m], all parameters used in ODEs: {tau_m, E_l, I_stim, E_e, tau_g, I_e}\n", "INFO:No numerical value specified for parameter \"I_stim\"\n", "INFO:\n", "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", @@ -1622,7 +1635,13 @@ "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n", "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0]])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0]])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ "DEBUG:\tinhomogeneous term: 0.0\n", "DEBUG:\tnonlinear term: 0.0\n", "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", @@ -1633,18 +1652,12 @@ "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot\n", "DEBUG:os.makedirs('/tmp')\n", "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable_before_propagated.dot']\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable_before_propagated.dot']\n", "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable.dot\n", "DEBUG:os.makedirs('/tmp')\n", "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable.dot'\n", "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable.dot']\n", - "INFO:Generating numerical solver for the following symbols: g_e, V_m\n", + "INFO:Generating numerical solver for the following symbols: V_m, g_e\n", "DEBUG:Initializing system of shapes with x = Matrix([[g_e], [V_m]]), A = Matrix([[-1/tau_g, 0], [E_e/tau_m, -1/tau_m]]), b = Matrix([[0], [E_l/tau_m + I_e/tau_m + I_stim/tau_m]]), c = Matrix([[0], [-V_m*g_e/tau_m]])\n", "INFO:Preserving expression for variable \"g_e\"\n", "INFO:Preserving expression for variable \"V_m\"\n", @@ -1740,7 +1753,7 @@ "DEBUG:Created Shape with symbol post_trace__for_neuromodulated_stdp_synapse_nestml, derivative_factors = [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml], inhom_term = 0.0, nonlin_term = 0.0\n", "INFO:\tReturning shape: Shape \"post_trace__for_neuromodulated_stdp_synapse_nestml\" of order 1\n", "INFO:Shape post_trace__for_neuromodulated_stdp_synapse_nestml: reconstituting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml\n", - "INFO:All known variables: [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml], all parameters used in ODEs: {tau_g, I_stim, E_l, tau_m, tau_tr_post__for_neuromodulated_stdp_synapse_nestml, I_e, E_e}\n", + "INFO:All known variables: [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml], all parameters used in ODEs: {tau_m, E_l, tau_tr_post__for_neuromodulated_stdp_synapse_nestml, I_stim, E_e, tau_g, I_e}\n", "INFO:No numerical value specified for parameter \"I_stim\"\n", "INFO:\n", "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", @@ -1768,7 +1781,13 @@ "INFO:\tReturning shape: Shape \"post_trace__for_neuromodulated_stdp_synapse_nestml\" of order 1\n", "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", "DEBUG:Splitting expression -g_e/tau_g (symbols Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]))\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0], [0]])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0], [0]])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ "DEBUG:\tinhomogeneous term: 0.0\n", "DEBUG:\tnonlinear term: 0.0\n", "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", @@ -1780,6 +1799,14 @@ "DEBUG:Splitting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml (symbols Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]))\n" ] }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[38,GLOBAL, INFO]: Analysing/transforming model 'iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml'\n", + "[39,iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml, INFO, [18:0;58:0]]: Starts processing of the model 'iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml'\n" + ] + }, { "name": "stderr", "output_type": "stream", @@ -1949,7 +1976,7 @@ "DEBUG:Created Shape with symbol post_trace__for_neuromodulated_stdp_synapse_nestml, derivative_factors = [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml], inhom_term = 0.0, nonlin_term = 0.0\n", "INFO:\tReturning shape: Shape \"post_trace__for_neuromodulated_stdp_synapse_nestml\" of order 1\n", "INFO:Shape post_trace__for_neuromodulated_stdp_synapse_nestml: reconstituting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml\n", - "INFO:All known variables: [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml], all parameters used in ODEs: {tau_g, I_stim, E_l, tau_m, tau_tr_post__for_neuromodulated_stdp_synapse_nestml, I_e, E_e}\n", + "INFO:All known variables: [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml], all parameters used in ODEs: {tau_m, E_l, tau_tr_post__for_neuromodulated_stdp_synapse_nestml, I_stim, E_e, tau_g, I_e}\n", "INFO:No numerical value specified for parameter \"I_stim\"\n", "INFO:\n", "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", @@ -1963,21 +1990,7 @@ "Processing differential-equation form shape V_m with defining expression = \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\"\n", "DEBUG:Splitting expression (E_l + I_e + I_stim - V_m + g_e*(E_e - V_m))/tau_m (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml, g_e, V_m])\n", "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m], [0], [0], [0]])\n", - "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[38,GLOBAL, INFO]: Analysing/transforming model 'iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml'\n", - "[39,iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml, INFO, [18:0;58:0]]: Starts processing of the model 'iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml'\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ + "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", "DEBUG:Created Shape with symbol V_m, derivative_factors = [-1/tau_m], inhom_term = E_l/tau_m + I_e/tau_m + I_stim/tau_m, nonlin_term = E_e*g_e/tau_m - V_m*g_e/tau_m\n", "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", @@ -2033,7 +2046,7 @@ "DEBUG:os.makedirs('/tmp')\n", "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable.dot'\n", "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable.dot']\n", - "INFO:Generating numerical solver for the following symbols: V_m, g_e, post_trace__for_neuromodulated_stdp_synapse_nestml\n", + "INFO:Generating numerical solver for the following symbols: post_trace__for_neuromodulated_stdp_synapse_nestml, V_m, g_e\n", "DEBUG:Initializing system of shapes with x = Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]), A = Matrix([[-1/tau_g, 0, 0], [E_e/tau_m, -1/tau_m, 0], [0, 0, -1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]]), b = Matrix([[0], [E_l/tau_m + I_e/tau_m + I_stim/tau_m], [0]]), c = Matrix([[0], [-V_m*g_e/tau_m], [0]])\n", "INFO:Preserving expression for variable \"g_e\"\n", "INFO:Preserving expression for variable \"V_m\"\n", @@ -2066,7 +2079,13 @@ " \"post_trace__for_neuromodulated_stdp_synapse_nestml\": \"(-post_trace__for_neuromodulated_stdp_synapse_nestml) / tau_tr_post__for_neuromodulated_stdp_synapse_nestml\"\n", " }\n", " }\n", - "]\n", + "]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ "INFO:Analysing input:\n", "INFO:{\n", " \"dynamics\": [\n", @@ -2110,13 +2129,7 @@ "DEBUG:\tnonlinear term: 0.0\n", "DEBUG:Created Shape with symbol pre_trace, derivative_factors = [-1/tau_tr_pre], inhom_term = 0.0, nonlin_term = 0.0\n", "INFO:\tReturning shape: Shape \"pre_trace\" of order 1\n", - "INFO:Shape pre_trace: reconstituting expression -pre_trace/tau_tr_pre\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ + "INFO:Shape pre_trace: reconstituting expression -pre_trace/tau_tr_pre\n", "INFO:\n", "Processing differential-equation form shape wtr with defining expression = \"(-wtr) / tau_wtr\"\n", "DEBUG:Splitting expression -wtr/tau_wtr (symbols [wtr])\n", @@ -2126,7 +2139,7 @@ "DEBUG:Created Shape with symbol wtr, derivative_factors = [-1/tau_wtr], inhom_term = 0.0, nonlin_term = 0.0\n", "INFO:\tReturning shape: Shape \"wtr\" of order 1\n", "INFO:Shape wtr: reconstituting expression -wtr/tau_wtr\n", - "INFO:All known variables: [pre_trace, wtr], all parameters used in ODEs: {tau_wtr, tau_tr_pre}\n", + "INFO:All known variables: [pre_trace, wtr], all parameters used in ODEs: {tau_tr_pre, tau_wtr}\n", "INFO:\n", "Processing differential-equation form shape pre_trace with defining expression = \"(-pre_trace) / tau_tr_pre\"\n", "DEBUG:Splitting expression -pre_trace/tau_tr_pre (symbols [pre_trace, wtr, pre_trace])\n", @@ -2158,7 +2171,21 @@ "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", "DEBUG:os.makedirs('/tmp')\n", "DEBUG:write lines to '/tmp/ode_dependency_graph.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n", + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[40,GLOBAL, INFO]: Analysing/transforming synapse neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.\n", + "[41,neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml, INFO, [6:0;55:0]]: Starts processing of the model 'neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml'\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ "INFO:Shape pre_trace: reconstituting expression -pre_trace/tau_tr_pre\n", "DEBUG:Splitting expression -pre_trace/tau_tr_pre (symbols [pre_trace, wtr])\n", "DEBUG:\tlinear factors: Matrix([[-1/tau_tr_pre], [0]])\n", @@ -2222,8 +2249,6 @@ "name": "stdout", "output_type": "stream", "text": [ - "[40,GLOBAL, INFO]: Analysing/transforming synapse neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.\n", - "[41,neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml, INFO, [6:0;55:0]]: Starts processing of the model 'neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml'\n", "[42,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp\n", "[43,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.h\n", "[44,iaf_psc_exp_neuron_nestml, INFO, [18:0;58:0]]: Successfully generated code for the model: 'iaf_psc_exp_neuron_nestml' in: '/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target' !\n", @@ -2232,8 +2257,8 @@ "[47,iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml, INFO, [18:0;58:0]]: Successfully generated code for the model: 'iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml' in: '/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target' !\n", "[48,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h\n", "[49,neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml, INFO, [6:0;55:0]]: Successfully generated code for the model: 'neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml' in: '/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target' !\n", - "[50,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/nestml_7e96446dfb6046169507a433a49d24d6_module.cpp\n", - "[51,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/nestml_7e96446dfb6046169507a433a49d24d6_module.h\n", + "[50,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/nestml_d7b75d7ce2614d2f84133484b2d1378f_module.cpp\n", + "[51,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/nestml_d7b75d7ce2614d2f84133484b2d1378f_module.h\n", "[52,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/CMakeLists.txt\n", "[53,GLOBAL, INFO]: Successfully generated NEST module code in '/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target' !\n", "-- The CXX compiler identification is GNU 12.3.0\n", @@ -2244,7 +2269,7 @@ "-- Detecting CXX compile features - done\n", "\n", "-------------------------------------------------------\n", - "nestml_7e96446dfb6046169507a433a49d24d6_module Configuration Summary\n", + "nestml_d7b75d7ce2614d2f84133484b2d1378f_module Configuration Summary\n", "-------------------------------------------------------\n", "\n", "C++ compiler : /usr/bin/c++\n", @@ -2256,22 +2281,22 @@ "\n", "-------------------------------------------------------\n", "\n", - "You can now build and install 'nestml_7e96446dfb6046169507a433a49d24d6_module' using\n", + "You can now build and install 'nestml_d7b75d7ce2614d2f84133484b2d1378f_module' using\n", " make\n", " make install\n", "\n", - "The library file libnestml_7e96446dfb6046169507a433a49d24d6_module.so will be installed to\n", - " /tmp/nestml_target_j3n51fhv\n", + "The library file libnestml_d7b75d7ce2614d2f84133484b2d1378f_module.so will be installed to\n", + " /tmp/nestml_target_404rbl0t\n", "The module can be loaded into NEST using\n", - " (nestml_7e96446dfb6046169507a433a49d24d6_module) Install (in SLI)\n", - " nest.Install(nestml_7e96446dfb6046169507a433a49d24d6_module) (in PyNEST)\n", + " (nestml_d7b75d7ce2614d2f84133484b2d1378f_module) Install (in SLI)\n", + " nest.Install(nestml_d7b75d7ce2614d2f84133484b2d1378f_module) (in PyNEST)\n", "\n", - "-- Configuring done (0.1s)\n", + "-- Configuring done (0.5s)\n", "-- Generating done (0.0s)\n", "-- Build files have been written to: /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target\n", - "[ 25%] Building CXX object CMakeFiles/nestml_7e96446dfb6046169507a433a49d24d6_module_module.dir/nestml_7e96446dfb6046169507a433a49d24d6_module.cpp.o\n", - "[ 50%] Building CXX object CMakeFiles/nestml_7e96446dfb6046169507a433a49d24d6_module_module.dir/iaf_psc_exp_neuron_nestml.cpp.o\n", - "[ 75%] Building CXX object CMakeFiles/nestml_7e96446dfb6046169507a433a49d24d6_module_module.dir/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp.o\n", + "[ 25%] Building CXX object CMakeFiles/nestml_d7b75d7ce2614d2f84133484b2d1378f_module_module.dir/nestml_d7b75d7ce2614d2f84133484b2d1378f_module.cpp.o\n", + "[ 50%] Building CXX object CMakeFiles/nestml_d7b75d7ce2614d2f84133484b2d1378f_module_module.dir/iaf_psc_exp_neuron_nestml.cpp.o\n", + "[ 75%] Building CXX object CMakeFiles/nestml_d7b75d7ce2614d2f84133484b2d1378f_module_module.dir/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp.o\n", "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml::init_state_internal_()’:\n", "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:191:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", " 191 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", @@ -2325,8 +2350,14 @@ " | ^~~~~~~~~~\n", "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:542:8: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", " 542 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", - " | ^~~~~\n", - "In file included from /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/nestml_7e96446dfb6046169507a433a49d24d6_module.cpp:36:\n", + " | ^~~~~\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "In file included from /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/nestml_d7b75d7ce2614d2f84133484b2d1378f_module.cpp:36:\n", "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:62:5: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", @@ -2334,13 +2365,7 @@ "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:613:104: required from here\n", "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:746:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", " 746 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + " | ^~~~~~~~~~\n", "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘void nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::recompute_internal_variables() [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:760:3: required from ‘nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierPtrRport]’\n", "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", @@ -2368,7 +2393,13 @@ "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:613:104: required from here\n", "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:733:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", " 733 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", + " | ^~~~~~~~~~\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘bool nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::send(nest::Event&, size_t, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport; size_t = long unsigned int]’:\n", "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; size_t = long unsigned int]’\n", "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", @@ -2431,18 +2462,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "[100%] Linking CXX shared module nestml_7e96446dfb6046169507a433a49d24d6_module.so\n", - "[100%] Built target nestml_7e96446dfb6046169507a433a49d24d6_module_module\n", - "[100%] Built target nestml_7e96446dfb6046169507a433a49d24d6_module_module\n", + "[100%] Linking CXX shared module nestml_d7b75d7ce2614d2f84133484b2d1378f_module.so\n", + "[100%] Built target nestml_d7b75d7ce2614d2f84133484b2d1378f_module_module\n", + "[100%] Built target nestml_d7b75d7ce2614d2f84133484b2d1378f_module_module\n", "Install the project...\n", "-- Install configuration: \"\"\n", - "-- Installing: /tmp/nestml_target_j3n51fhv/nestml_7e96446dfb6046169507a433a49d24d6_module.so\n" + "-- Installing: /tmp/nestml_target_404rbl0t/nestml_d7b75d7ce2614d2f84133484b2d1378f_module.so\n" ] } ], "source": [ - "# ... generate NESTML model code...\n", - "\n", "from pynestml.codegeneration.nest_code_generator_utils import NESTCodeGeneratorUtils\n", "\n", "input_layer_module_name, input_layer_neuron_model_name = \\\n", @@ -2507,7 +2536,6 @@ " def construct_neural_network(self):\n", " nest.ResetKernel()\n", " nest.local_num_threads = nest_local_num_threads\n", - "# nest.resolution = .01 # [ms]\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", @@ -2527,14 +2555,13 @@ " nest.Connect(self.multimeter_right, self.output_population_right)\n", "\n", " self.syn_opts = {\"synapse_model\": output_layer_synapse_model_name,\n", - " \"weight\": .5,# + nest.random.uniform(min=0.0, max=1.0) * 0.2, # XXX: \"R_STDP\" script has ``0.05+rand()*0.001`` instead of ``0.1+rand()*0.02``\n", - " #\"delay\": nest.resolution, # XXX: this slows the simulation down drastically!\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", + " \"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", @@ -2543,10 +2570,6 @@ " 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", - "# print(\"after network init:\")\n", - "# print(\"\\tbefore w = \" + str(syn.w))\n", - "# print(\"\\tbefore wtr = \" + str(syn.wtr))\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", @@ -2606,7 +2629,6 @@ " plt.close(fig)\n", "\n", " \n", - " \n", " # one-dimensional weight update plot\n", " fig, ax = plt.subplots(ncols=2, figsize=(12,4))\n", "\n", @@ -2614,7 +2636,6 @@ " ax[0].plot(np.arange(len(w)), w, label=\"w_new\")\n", " ax[0].legend()\n", " ax[0].set_title(\"weights (\" + which_side + \")\")\n", - "# ax[0].set_ylim(0.005, 0.3)\n", "\n", " ax[1].set_title(\"w_new - w_old\")\n", " ax[1].plot(np.arange(len(w)), w - w_old)\n", @@ -2628,8 +2649,6 @@ " 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", - "# print(\"n_events_in_last_interval_left = \" + str(n_events_in_last_interval_left))\n", - "# print(\"n_events_in_last_interval_right = \" + str(n_events_in_last_interval_right))\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", @@ -2659,19 +2678,6 @@ " \"\"\"\n", " Calculates the potential function Phi(s) for reward shaping.\n", " Higher potential should correlate with being closer to the goal state.\n", - " \n", - " Options:\n", - " 1) 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\n", - "\n", - " 2) potential_val = 10 * self.env._height(position)\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", " position, velocity = state\n", " old_position, old_velocity = old_state\n", @@ -2689,42 +2695,28 @@ " return potential_val\n", "\n", " def update_synaptic_weights(self, Q_new, Q_old, action, reward, reset_traces_at_end_of_step=True):\n", - "# print(\"Updating synaptic weights\")\n", - "\n", " if Q_old is None:\n", " return\n", "\n", - "# print(\"reward = \" + str(reward))\n", - "# print(\"Q_new = \" + str(Q_new))\n", - "# print(\"Q_old = \" + str(Q_old))\n", " TD = self.discount_factor * Q_new + 10 * reward - Q_old\n", "\n", " if action == AgentAction.RIGHT:\n", - "# print(\"\\tLast chosen action = RIGHT\")\n", - "# print(\"\\tbefore w = \" + str(self.syn_right.w))\n", - "# print(\"\\tbefore wtr = \" + str(self.syn_right.wtr))\n", - "\n", - " # w = np.array(self.syn_right.w)\n", " w = self.syn_right.get(\"w\")\n", - " w_old = w.copy() # XXX only needed for debugging!\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", + " # self.plot_weight_updates(\"right\", w, w_old)\n", " else:\n", " assert action == AgentAction.LEFT\n", - "# print(\"Chosen action = LEFT\")\n", - "# print(\"\\tbefore w = \" + str(self.syn_left.w))\n", - "# print(\"\\tbefore wtr = \" + str(self.syn_left.wtr))\n", - "\n", " w = self.syn_left.get(\"w\")\n", - " w_old = w.copy() # XXX only needed for debugging!\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", + " # self.plot_weight_updates(\"left\", w, w_old)\n", " \n", "\n", " #\n", @@ -2750,20 +2742,20 @@ "\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\n", - " - run the SNN with this input state for a period of time (cycle time, e.g. 10-50 ms)\n", + "- Simulate neural network: \n", + " - Set the rate of the input neurons to the current state of the environment\n", + " - Run the SNN with this input state for a period of time (cycle time, e.g. 10-50 ms)\n", " - (wtr is computed in each synapse)\n", - "- action is selected based on output neuron firing, by counting the number of spikes in the output population over this cycle period\n", - "- environment is updated based on action; run the environment for the same cycle time (40 ms) to obtain next state\n", - "- reward is computed (neuromodulator signal is proportional to reward)\n", - "- synapses that were active (between input and output neurons) have their weights updated (based on wtr * reward)\n", + "- Action is selected based on output neuron firing, by counting the number of spikes in the output population over this cycle period\n", + "- Environment is updated based on action; run the environment for the same cycle time (40 ms) to obtain next state\n", + "- Reward is computed (neuromodulator signal is proportional to reward)\n", + "- Synapses that were active (between input and output neurons) have their weights updated (based on wtr * reward)\n", "- wtr of all synapses is reset back to 0" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 16, "id": "e4bda6d4", "metadata": { "scrolled": true @@ -2773,230 +2765,230 @@ "name": "stdout", "output_type": "stream", "text": [ - "Episode 0 took: 2.344 s\n", + "Episode 0 took: 15.407 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -13.89745665968862\n", - "Episode 1 took: 2.467 s\n", + "\tTotal reward = -12.351658852336673\n", + "Episode 1 took: 12.304 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -11.442271180514668\n", - "Episode 2 took: 2.934 s\n", + "\tTotal reward = -0.9684528937981807\n", + "Episode 2 took: 13.071 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -7.8635394467340385\n", - "Episode 3 took: 3.070 s\n", + "\tTotal reward = -5.58159301896193\n", + "Episode 3 took: 13.731 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -6.19216835818245\n", - "Episode 4 took: 4.093 s\n", + "\tTotal reward = -5.932404965977481\n", + "Episode 4 took: 16.133 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -8.466157008234736\n", - "Episode 5 took: 3.796 s\n", + "\tTotal reward = -7.9822054960841875\n", + "Episode 5 took: 16.678 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -11.082273989936038\n", - "Episode 6 took: 4.928 s\n", + "\tTotal reward = -6.76394759868483\n", + "Episode 6 took: 15.628 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -9.421463092319835\n", - "Episode 7 took: 3.645 s\n", + "\tTotal reward = -4.67723116917611\n", + "Episode 7 took: 16.470 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -4.356526027823034\n", - "Episode 8 took: 3.490 s\n", + "\tTotal reward = -4.107778950184352\n", + "Episode 8 took: 16.912 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -9.659186902639018\n", - "Episode 9 took: 14.558 s\n", + "\tTotal reward = -8.935828944056933\n", + "Episode 9 took: 18.802 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -7.635423324172356\n" + "\tTotal reward = -8.86354982654994\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_422139/3878736473.py:131: 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_422139/3878736473.py:146: 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", - "DEBUG:locator: \n" + "/tmp/ipykernel_466717/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_466717/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", + "DEBUG:locator: \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Episode 10 took: 7.743 s\n", - "\tNumber of steps in episode = 479\n", - "\tTotal reward = -0.4885892464491851\n", - "Episode 11 took: 3.615 s\n", + "Episode 10 took: 17.959 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -6.9620801843858295\n", - "Episode 12 took: 4.018 s\n", + "\tTotal reward = -4.4788246108889975\n", + "Episode 11 took: 18.878 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -9.300473736603209\n", - "Episode 13 took: 3.490 s\n", - "\tNumber of steps in episode = 453\n", - "\tTotal reward = -1.392652469476832\n", - "Episode 14 took: 2.944 s\n", - "\tNumber of steps in episode = 386\n", - "\tTotal reward = 2.885767962045132\n", - "Episode 15 took: 3.774 s\n", - "\tNumber of steps in episode = 477\n", - "\tTotal reward = -1.8624652303670965\n", - "Episode 16 took: 4.778 s\n", + "\tTotal reward = -9.291752250754872\n", + "Episode 12 took: 20.706 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -9.218878430148171\n", - "Episode 17 took: 5.400 s\n", - "\tNumber of steps in episode = 476\n", - "\tTotal reward = -1.9805538063803714\n", - "Episode 18 took: 5.237 s\n", - "\tNumber of steps in episode = 480\n", - "\tTotal reward = -0.9794208365042383\n", - "Episode 19 took: 5.832 s\n", + "\tTotal reward = -2.3123560165874424\n", + "Episode 13 took: 19.795 s\n", + "\tNumber of steps in episode = 489\n", + "\tTotal reward = -3.2660639947028134\n", + "Episode 14 took: 19.379 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -5.281728056258335\n", + "Episode 15 took: 21.669 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -7.451217772876397\n", + "Episode 16 took: 21.719 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -15.816558112548382\n", + "Episode 17 took: 20.802 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -6.563055951722551\n" + "\tTotal reward = -5.594274672288915\n", + "Episode 18 took: 21.144 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -8.196928489595395\n", + "Episode 19 took: 21.599 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -3.435630197778771\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_422139/3878736473.py:131: 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_422139/3878736473.py:146: 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", - "DEBUG:locator: \n" + "/tmp/ipykernel_466717/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_466717/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", + "DEBUG:locator: \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Episode 20 took: 5.205 s\n", + "Episode 20 took: 21.901 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -13.165721711732578\n", - "Episode 21 took: 6.762 s\n", + "\tTotal reward = -9.59459783032514\n", + "Episode 21 took: 20.405 s\n", + "\tNumber of steps in episode = 457\n", + "\tTotal reward = -12.069258944600652\n", + "Episode 22 took: 22.738 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -10.239928874624217\n", - "Episode 22 took: 6.033 s\n", - "\tNumber of steps in episode = 474\n", - "\tTotal reward = -0.9907165448633724\n", - "Episode 23 took: 6.347 s\n", + "\tTotal reward = -2.983211203391944\n", + "Episode 23 took: 23.244 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -7.4022506305974085\n", - "Episode 24 took: 6.333 s\n", - "\tNumber of steps in episode = 489\n", - "\tTotal reward = -2.8665191573290967\n", - "Episode 25 took: 6.771 s\n", - "\tNumber of steps in episode = 472\n", - "\tTotal reward = -0.6466374718461726\n", - "Episode 26 took: 7.958 s\n", - "\tNumber of steps in episode = 487\n", - "\tTotal reward = -2.4798575567892795\n", - "Episode 27 took: 8.987 s\n", + "\tTotal reward = -7.803500254992504\n", + "Episode 24 took: 23.738 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -7.7393838278464715\n", + "Episode 25 took: 24.110 s\n", + "\tNumber of steps in episode = 498\n", + "\tTotal reward = -2.6646766558777424\n", + "Episode 26 took: 24.521 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -2.9948900342711395\n", + "Episode 27 took: 25.041 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -7.3875393416858675\n", + "Episode 28 took: 25.476 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -7.628327176179652\n", - "Episode 28 took: 7.048 s\n", - "\tNumber of steps in episode = 479\n", - "\tTotal reward = -1.6239026800755658\n", - "Episode 29 took: 7.290 s\n", - "\tNumber of steps in episode = 476\n", - "\tTotal reward = -1.2992894723211477\n" + "\tTotal reward = -10.941111404711826\n", + "Episode 29 took: 26.055 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -9.056446903616594\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_422139/3878736473.py:131: 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_422139/3878736473.py:146: 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", - "DEBUG:locator: \n" + "/tmp/ipykernel_466717/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_466717/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", + "DEBUG:locator: \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Episode 30 took: 8.402 s\n", - "\tNumber of steps in episode = 477\n", - "\tTotal reward = -1.621931569406017\n", - "Episode 31 took: 9.206 s\n", - "\tNumber of steps in episode = 492\n", - "\tTotal reward = -3.0492795427312145\n", - "Episode 32 took: 9.118 s\n", + "Episode 30 took: 25.601 s\n", + "\tNumber of steps in episode = 480\n", + "\tTotal reward = -2.0707537229392057\n", + "Episode 31 took: 27.051 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -5.797468082776563\n", + "Episode 32 took: 26.863 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -10.145864008713575\n", - "Episode 33 took: 9.475 s\n", + "\tTotal reward = -10.512519489314643\n", + "Episode 33 took: 27.274 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -3.698123034555376\n", - "Episode 34 took: 9.436 s\n", + "\tTotal reward = -5.742458908871843\n", + "Episode 34 took: 26.226 s\n", + "\tNumber of steps in episode = 460\n", + "\tTotal reward = -2.3096488520975944\n", + "Episode 35 took: 28.926 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -4.500674730655058\n", - "Episode 35 took: 8.835 s\n", - "\tNumber of steps in episode = 486\n", - "\tTotal reward = -2.4276867620122182\n", - "Episode 36 took: 9.213 s\n", - "\tNumber of steps in episode = 477\n", - "\tTotal reward = -1.7457801937345705\n", - "Episode 37 took: 10.053 s\n", + "\tTotal reward = -5.053005044676333\n", + "Episode 36 took: 28.562 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -5.294304910806366\n", - "Episode 38 took: 7.630 s\n", - "\tNumber of steps in episode = 471\n", - "\tTotal reward = -0.560492635470805\n", - "Episode 39 took: 7.403 s\n", - "\tNumber of steps in episode = 432\n", - "\tTotal reward = 0.8241573628332903\n" + "\tTotal reward = -3.7688145165822498\n", + "Episode 37 took: 29.804 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -6.767199467062796\n", + "Episode 38 took: 29.125 s\n", + "\tNumber of steps in episode = 491\n", + "\tTotal reward = -2.539055721169114\n", + "Episode 39 took: 29.308 s\n", + "\tNumber of steps in episode = 491\n", + "\tTotal reward = -1.634220915900104\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_422139/3878736473.py:131: 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_422139/3878736473.py:146: 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", - "DEBUG:locator: \n" + "/tmp/ipykernel_466717/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_466717/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", + "DEBUG:locator: \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Episode 40 took: 7.616 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -11.08313563601852\n", - "Episode 41 took: 9.039 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -3.5331820861561907\n", - "Episode 42 took: 10.973 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -10.652568550823352\n", - "Episode 43 took: 8.706 s\n", + "Episode 40 took: 30.316 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -4.196979159821003\n", - "Episode 44 took: 8.583 s\n", + "\tTotal reward = -10.829884359490437\n", + "Episode 41 took: 30.823 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -3.0645991757691977\n", - "Episode 45 took: 8.422 s\n", + "\tTotal reward = -5.933377528602501\n", + "Episode 42 took: 30.965 s\n", + "\tNumber of steps in episode = 483\n", + "\tTotal reward = -1.2283859896948104\n", + "Episode 43 took: 29.655 s\n", + "\tNumber of steps in episode = 454\n", + "\tTotal reward = -0.9775696618329375\n", + "Episode 44 took: 32.379 s\n", + "\tNumber of steps in episode = 491\n", + "\tTotal reward = -2.1502698667775784\n", + "Episode 45 took: 31.509 s\n", + "\tNumber of steps in episode = 484\n", + "\tTotal reward = -2.102920542307939\n", + "Episode 46 took: 32.146 s\n", + "\tNumber of steps in episode = 472\n", + "\tTotal reward = -0.9045579995110267\n", + "Episode 47 took: 32.240 s\n", + "\tNumber of steps in episode = 482\n", + "\tTotal reward = -1.3819170721571714\n", + "Episode 48 took: 33.800 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -3.928509879186927\n", - "Episode 46 took: 8.530 s\n", + "\tTotal reward = -11.184655639188577\n", + "Episode 49 took: 35.395 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -5.502845410718123\n", - "Episode 47 took: 8.241 s\n", - "\tNumber of steps in episode = 476\n", - "\tTotal reward = -1.0917405163381833\n", - "Episode 48 took: 7.799 s\n", - "\tNumber of steps in episode = 447\n", - "\tTotal reward = -1.1848611410375645\n", - "Episode 49 took: 8.326 s\n", - "\tNumber of steps in episode = 476\n", - "\tTotal reward = -1.7557132022891608\n" + "\tTotal reward = -8.443552516839317\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_422139/3878736473.py:131: 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_422139/3878736473.py:146: 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", - "DEBUG:locator: \n" + "/tmp/ipykernel_466717/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_466717/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", + "DEBUG:locator: \n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3006,7 +2998,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3020,7 +3012,7 @@ "agent = SpikingAgent(env)\n", "\n", "agent.p_explore = 0. # XXX: no exploration! not necessary\n", - "agent.learning_rate = 0.001 # was: 0.01\n", + "agent.learning_rate = 0.001\n", "agent.learning_rate_decay = .99\n", "agent.MIN_LEARNING_RATE = agent.learning_rate / 100.\n", "\n", @@ -3197,9 +3189,9 @@ }, "outputs": [], "source": [ - "# run this cell to do benchmarking -- \n", - "#%%prun -s cumulative\n", - "#main_simulation_loop()" + "# run this cell to do benchmarking! \n", + "# %%prun -s cumulative\n", + "# main_simulation_loop()" ] }, { @@ -3209,16 +3201,14 @@ "source": [ "## Mechanistic explanation: why does this learning principle work?\n", "\n", - "For high firing rates, STDP basically becomes a purely rate-based rule: weights are predominantely potentiated (rather than depressed) for higher pre- and higher post-synaptic firing rates.\n", - "\n", - "\"Gating\" the weight updates: only the connections between the input neuron that are active, and the 10 output layer neurons for the action that was chosen, will be updated.\n", + "For high firing rates, STDP basically becomes a purely rate-based rule: weights are predominantely potentiated (rather than depressed) for higher pre- and higher post-synaptic firing rates. The rule thus becomes a purely Hebbian learning rule.\n", "\n", - "The neuromodulator determines the sign and magnitude of the update, based on TD signal" + "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": 41, + "execution_count": 15, "id": "6a68403e", "metadata": {}, "outputs": [ @@ -3226,318 +3216,324 @@ "name": "stdout", "output_type": "stream", "text": [ - "Simulating: Pre-rate=5.0 Hz, Post-rate=5.0 Hz\n", - "Actual pre rate: 6.0\n", - "Actual post rate: 2.0\n", - "Simulating: Pre-rate=5.0 Hz, Post-rate=15.6 Hz\n", - "Actual pre rate: 2.0\n", - "Actual post rate: 20.0\n", - "Simulating: Pre-rate=5.0 Hz, Post-rate=26.1 Hz\n", - "Actual pre rate: 2.0\n", - "Actual post rate: 28.0\n", - "Simulating: Pre-rate=5.0 Hz, Post-rate=36.7 Hz\n", - "Actual pre rate: 2.0\n", - "Actual post rate: 37.0\n", - "Simulating: Pre-rate=5.0 Hz, Post-rate=47.2 Hz\n", - "Actual pre rate: 5.0\n", - "Actual post rate: 47.0\n", - "Simulating: Pre-rate=5.0 Hz, Post-rate=57.8 Hz\n", - "Actual pre rate: 4.0\n", - "Actual post rate: 61.0\n", - "Simulating: Pre-rate=5.0 Hz, Post-rate=68.3 Hz\n", - "Actual pre rate: 5.0\n", - "Actual post rate: 71.0\n", - "Simulating: Pre-rate=5.0 Hz, Post-rate=78.9 Hz\n", - "Actual pre rate: 3.0\n", - "Actual post rate: 87.0\n", - "Simulating: Pre-rate=5.0 Hz, Post-rate=89.4 Hz\n", - "Actual pre rate: 4.0\n", - "Actual post rate: 104.0\n", - "Simulating: Pre-rate=5.0 Hz, Post-rate=100.0 Hz\n", - "Actual pre rate: 5.0\n", - "Actual post rate: 114.0\n", - "Simulating: Pre-rate=15.6 Hz, Post-rate=5.0 Hz\n", - "Actual pre rate: 14.0\n", - "Actual post rate: 4.0\n", - "Simulating: Pre-rate=15.6 Hz, Post-rate=15.6 Hz\n", - "Actual pre rate: 12.0\n", - "Actual post rate: 18.0\n", - "Simulating: Pre-rate=15.6 Hz, Post-rate=26.1 Hz\n", - "Actual pre rate: 13.0\n", - "Actual post rate: 26.0\n", - "Simulating: Pre-rate=15.6 Hz, Post-rate=36.7 Hz\n", - "Actual pre rate: 17.0\n", - "Actual post rate: 37.0\n", - "Simulating: Pre-rate=15.6 Hz, Post-rate=47.2 Hz\n", - "Actual pre rate: 17.0\n", - "Actual post rate: 51.0\n", - "Simulating: Pre-rate=15.6 Hz, Post-rate=57.8 Hz\n", - "Actual pre rate: 18.0\n", - "Actual post rate: 63.0\n", - "Simulating: Pre-rate=15.6 Hz, Post-rate=68.3 Hz\n", - "Actual pre rate: 13.0\n", - "Actual post rate: 73.0\n", - "Simulating: Pre-rate=15.6 Hz, Post-rate=78.9 Hz\n", - "Actual pre rate: 17.0\n", - "Actual post rate: 87.0\n", - "Simulating: Pre-rate=15.6 Hz, Post-rate=89.4 Hz\n", - "Actual pre rate: 16.0\n", - "Actual post rate: 99.0\n", - "Simulating: Pre-rate=15.6 Hz, Post-rate=100.0 Hz\n", - "Actual pre rate: 18.0\n", - "Actual post rate: 103.0\n", - "Simulating: Pre-rate=26.1 Hz, Post-rate=5.0 Hz\n", - "Actual pre rate: 25.0\n", - "Actual post rate: 6.0\n", - "Simulating: Pre-rate=26.1 Hz, Post-rate=15.6 Hz\n", - "Actual pre rate: 28.0\n", - "Actual post rate: 14.0\n", - "Simulating: Pre-rate=26.1 Hz, Post-rate=26.1 Hz\n", - "Actual pre rate: 27.0\n", - "Actual post rate: 29.0\n", - "Simulating: Pre-rate=26.1 Hz, Post-rate=36.7 Hz\n", - "Actual pre rate: 35.0\n", - "Actual post rate: 37.0\n", - "Simulating: Pre-rate=26.1 Hz, Post-rate=47.2 Hz\n", - "Actual pre rate: 28.0\n", - "Actual post rate: 52.0\n", - "Simulating: Pre-rate=26.1 Hz, Post-rate=57.8 Hz\n", - "Actual pre rate: 23.0\n", - "Actual post rate: 62.0\n", - "Simulating: Pre-rate=26.1 Hz, Post-rate=68.3 Hz\n", - "Actual pre rate: 25.0\n", - "Actual post rate: 81.0\n", - "Simulating: Pre-rate=26.1 Hz, Post-rate=78.9 Hz\n", - "Actual pre rate: 31.0\n", - "Actual post rate: 88.0\n", - "Simulating: Pre-rate=26.1 Hz, Post-rate=89.4 Hz\n", - "Actual pre rate: 32.0\n", - "Actual post rate: 99.0\n", - "Simulating: Pre-rate=26.1 Hz, Post-rate=100.0 Hz\n", - "Actual pre rate: 33.0\n", - "Actual post rate: 115.0\n", - "Simulating: Pre-rate=36.7 Hz, Post-rate=5.0 Hz\n", - "Actual pre rate: 33.0\n", - "Actual post rate: 6.0\n", - "Simulating: Pre-rate=36.7 Hz, Post-rate=15.6 Hz\n", - "Actual pre rate: 32.0\n", - "Actual post rate: 15.0\n", - "Simulating: Pre-rate=36.7 Hz, Post-rate=26.1 Hz\n", - "Actual pre rate: 35.0\n", - "Actual post rate: 26.0\n", - "Simulating: Pre-rate=36.7 Hz, Post-rate=36.7 Hz\n", - "Actual pre rate: 34.0\n", - "Actual post rate: 50.0\n", - "Simulating: Pre-rate=36.7 Hz, Post-rate=47.2 Hz\n", - "Actual pre rate: 34.0\n", - "Actual post rate: 55.0\n", - "Simulating: Pre-rate=36.7 Hz, Post-rate=57.8 Hz\n", - "Actual pre rate: 35.0\n", - "Actual post rate: 61.0\n", - "Simulating: Pre-rate=36.7 Hz, Post-rate=68.3 Hz\n", - "Actual pre rate: 39.0\n", - "Actual post rate: 72.0\n", - "Simulating: Pre-rate=36.7 Hz, Post-rate=78.9 Hz\n", - "Actual pre rate: 44.0\n", - "Actual post rate: 91.0\n", - "Simulating: Pre-rate=36.7 Hz, Post-rate=89.4 Hz\n", - "Actual pre rate: 41.0\n", - "Actual post rate: 103.0\n", - "Simulating: Pre-rate=36.7 Hz, Post-rate=100.0 Hz\n", - "Actual pre rate: 38.0\n", - "Actual post rate: 116.0\n", - "Simulating: Pre-rate=47.2 Hz, Post-rate=5.0 Hz\n", - "Actual pre rate: 45.0\n", - "Actual post rate: 3.0\n", - "Simulating: Pre-rate=47.2 Hz, Post-rate=15.6 Hz\n", - "Actual pre rate: 43.0\n", - "Actual post rate: 16.0\n", - "Simulating: Pre-rate=47.2 Hz, Post-rate=26.1 Hz\n", - "Actual pre rate: 46.0\n", - "Actual post rate: 24.0\n", - "Simulating: Pre-rate=47.2 Hz, Post-rate=36.7 Hz\n", - "Actual pre rate: 52.0\n", - "Actual post rate: 41.0\n", - "Simulating: Pre-rate=47.2 Hz, Post-rate=47.2 Hz\n", - "Actual pre rate: 51.0\n", - "Actual post rate: 48.0\n", - "Simulating: Pre-rate=47.2 Hz, Post-rate=57.8 Hz\n", - "Actual pre rate: 43.0\n", - "Actual post rate: 63.0\n", - "Simulating: Pre-rate=47.2 Hz, Post-rate=68.3 Hz\n", - "Actual pre rate: 48.0\n", - "Actual post rate: 77.0\n", - "Simulating: Pre-rate=47.2 Hz, Post-rate=78.9 Hz\n", - "Actual pre rate: 49.0\n", - "Actual post rate: 93.0\n", - "Simulating: Pre-rate=47.2 Hz, Post-rate=89.4 Hz\n", - "Actual pre rate: 49.0\n", - "Actual post rate: 112.0\n", - "Simulating: Pre-rate=47.2 Hz, Post-rate=100.0 Hz\n", - "Actual pre rate: 48.0\n", - "Actual post rate: 118.0\n", - "Simulating: Pre-rate=57.8 Hz, Post-rate=5.0 Hz\n", - "Actual pre rate: 56.0\n", - "Actual post rate: 4.0\n", - "Simulating: Pre-rate=57.8 Hz, Post-rate=15.6 Hz\n", - "Actual pre rate: 56.0\n", - "Actual post rate: 11.0\n", - "Simulating: Pre-rate=57.8 Hz, Post-rate=26.1 Hz\n", - "Actual pre rate: 61.0\n", - "Actual post rate: 28.0\n", - "Simulating: Pre-rate=57.8 Hz, Post-rate=36.7 Hz\n", - "Actual pre rate: 56.0\n", - "Actual post rate: 40.0\n", - "Simulating: Pre-rate=57.8 Hz, Post-rate=47.2 Hz\n", - "Actual pre rate: 56.0\n", - "Actual post rate: 54.0\n", - "Simulating: Pre-rate=57.8 Hz, Post-rate=57.8 Hz\n", - "Actual pre rate: 58.0\n", - "Actual post rate: 60.0\n", - "Simulating: Pre-rate=57.8 Hz, Post-rate=68.3 Hz\n", - "Actual pre rate: 61.0\n", - "Actual post rate: 72.0\n", - "Simulating: Pre-rate=57.8 Hz, Post-rate=78.9 Hz\n", - "Actual pre rate: 53.0\n", - "Actual post rate: 89.0\n", - "Simulating: Pre-rate=57.8 Hz, Post-rate=89.4 Hz\n", - "Actual pre rate: 57.0\n", - "Actual post rate: 106.0\n", - "Simulating: Pre-rate=57.8 Hz, Post-rate=100.0 Hz\n", - "Actual pre rate: 54.0\n", - "Actual post rate: 111.0\n", - "Simulating: Pre-rate=68.3 Hz, Post-rate=5.0 Hz\n", - "Actual pre rate: 63.0\n", - "Actual post rate: 4.0\n", - "Simulating: Pre-rate=68.3 Hz, Post-rate=15.6 Hz\n", - "Actual pre rate: 67.0\n", - "Actual post rate: 20.0\n", - "Simulating: Pre-rate=68.3 Hz, Post-rate=26.1 Hz\n", - "Actual pre rate: 67.0\n", - "Actual post rate: 26.0\n", - "Simulating: Pre-rate=68.3 Hz, Post-rate=36.7 Hz\n", - "Actual pre rate: 72.0\n", - "Actual post rate: 37.0\n", - "Simulating: Pre-rate=68.3 Hz, Post-rate=47.2 Hz\n", - "Actual pre rate: 68.0\n", - "Actual post rate: 49.0\n", - "Simulating: Pre-rate=68.3 Hz, Post-rate=57.8 Hz\n", - "Actual pre rate: 66.0\n", - "Actual post rate: 60.0\n", - "Simulating: Pre-rate=68.3 Hz, Post-rate=68.3 Hz\n", - "Actual pre rate: 62.0\n", - "Actual post rate: 85.0\n", - "Simulating: Pre-rate=68.3 Hz, Post-rate=78.9 Hz\n", - "Actual pre rate: 66.0\n", - "Actual post rate: 93.0\n", - "Simulating: Pre-rate=68.3 Hz, Post-rate=89.4 Hz\n", - "Actual pre rate: 60.0\n", - "Actual post rate: 107.0\n", - "Simulating: Pre-rate=68.3 Hz, Post-rate=100.0 Hz\n", - "Actual pre rate: 66.0\n", - "Actual post rate: 110.0\n", - "Simulating: Pre-rate=78.9 Hz, Post-rate=5.0 Hz\n", - "Actual pre rate: 84.0\n", - "Actual post rate: 3.0\n", - "Simulating: Pre-rate=78.9 Hz, Post-rate=15.6 Hz\n", - "Actual pre rate: 76.0\n", - "Actual post rate: 14.0\n", - "Simulating: Pre-rate=78.9 Hz, Post-rate=26.1 Hz\n", - "Actual pre rate: 84.0\n", - "Actual post rate: 28.0\n", - "Simulating: Pre-rate=78.9 Hz, Post-rate=36.7 Hz\n", - "Actual pre rate: 75.0\n", - "Actual post rate: 47.0\n", - "Simulating: Pre-rate=78.9 Hz, Post-rate=47.2 Hz\n", - "Actual pre rate: 76.0\n", - "Actual post rate: 52.0\n", - "Simulating: Pre-rate=78.9 Hz, Post-rate=57.8 Hz\n", - "Actual pre rate: 75.0\n", - "Actual post rate: 72.0\n", - "Simulating: Pre-rate=78.9 Hz, Post-rate=68.3 Hz\n", - "Actual pre rate: 84.0\n", - "Actual post rate: 71.0\n", - "Simulating: Pre-rate=78.9 Hz, Post-rate=78.9 Hz\n", - "Actual pre rate: 76.0\n", - "Actual post rate: 95.0\n", - "Simulating: Pre-rate=78.9 Hz, Post-rate=89.4 Hz\n", - "Actual pre rate: 87.0\n", - "Actual post rate: 95.0\n", - "Simulating: Pre-rate=78.9 Hz, Post-rate=100.0 Hz\n", - "Actual pre rate: 75.0\n", - "Actual post rate: 121.0\n", - "Simulating: Pre-rate=89.4 Hz, Post-rate=5.0 Hz\n", - "Actual pre rate: 90.0\n", - "Actual post rate: 3.0\n", - "Simulating: Pre-rate=89.4 Hz, Post-rate=15.6 Hz\n", - "Actual pre rate: 100.0\n", - "Actual post rate: 12.0\n", - "Simulating: Pre-rate=89.4 Hz, Post-rate=26.1 Hz\n", - "Actual pre rate: 93.0\n", - "Actual post rate: 32.0\n", - "Simulating: Pre-rate=89.4 Hz, Post-rate=36.7 Hz\n", - "Actual pre rate: 93.0\n", - "Actual post rate: 36.0\n", - "Simulating: Pre-rate=89.4 Hz, Post-rate=47.2 Hz\n", - "Actual pre rate: 92.0\n", - "Actual post rate: 54.0\n", - "Simulating: Pre-rate=89.4 Hz, Post-rate=57.8 Hz\n", - "Actual pre rate: 97.0\n", - "Actual post rate: 60.0\n", - "Simulating: Pre-rate=89.4 Hz, Post-rate=68.3 Hz\n", - "Actual pre rate: 93.0\n", - "Actual post rate: 76.0\n", - "Simulating: Pre-rate=89.4 Hz, Post-rate=78.9 Hz\n", - "Actual pre rate: 99.0\n", - "Actual post rate: 84.0\n", - "Simulating: Pre-rate=89.4 Hz, Post-rate=89.4 Hz\n", - "Actual pre rate: 81.0\n", - "Actual post rate: 114.0\n", - "Simulating: Pre-rate=89.4 Hz, Post-rate=100.0 Hz\n", - "Actual pre rate: 94.0\n", - "Actual post rate: 113.0\n", - "Simulating: Pre-rate=100.0 Hz, Post-rate=5.0 Hz\n", - "Actual pre rate: 109.0\n", - "Actual post rate: 4.0\n", - "Simulating: Pre-rate=100.0 Hz, Post-rate=15.6 Hz\n", - "Actual pre rate: 107.0\n", - "Actual post rate: 16.0\n", - "Simulating: Pre-rate=100.0 Hz, Post-rate=26.1 Hz\n", - "Actual pre rate: 111.0\n", - "Actual post rate: 22.0\n", - "Simulating: Pre-rate=100.0 Hz, Post-rate=36.7 Hz\n", - "Actual pre rate: 97.0\n", - "Actual post rate: 47.0\n", - "Simulating: Pre-rate=100.0 Hz, Post-rate=47.2 Hz\n", - "Actual pre rate: 105.0\n", - "Actual post rate: 62.0\n", - "Simulating: Pre-rate=100.0 Hz, Post-rate=57.8 Hz\n", - "Actual pre rate: 104.0\n", - "Actual post rate: 67.0\n", - "Simulating: Pre-rate=100.0 Hz, Post-rate=68.3 Hz\n", - "Actual pre rate: 107.0\n", - "Actual post rate: 69.0\n", - "Simulating: Pre-rate=100.0 Hz, Post-rate=78.9 Hz\n", - "Actual pre rate: 107.0\n", - "Actual post rate: 97.0\n", - "Simulating: Pre-rate=100.0 Hz, Post-rate=89.4 Hz\n", - "Actual pre rate: 110.0\n", - "Actual post rate: 94.0\n", - "Simulating: Pre-rate=100.0 Hz, Post-rate=100.0 Hz\n", - "Actual pre rate: 106.0\n", - "Actual post rate: 108.0\n" + "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=5.0 s⁻¹\n", + "\t-> Actual pre rate: 6.0 s⁻¹\n", + "\t-> Actual post rate: 2.0 s⁻¹\n", + "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=15.6 s⁻¹\n", + "\t-> Actual pre rate: 2.0 s⁻¹\n", + "\t-> Actual post rate: 20.0 s⁻¹\n", + "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=26.1 s⁻¹\n", + "\t-> Actual pre rate: 2.0 s⁻¹\n", + "\t-> Actual post rate: 28.0 s⁻¹\n", + "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=36.7 s⁻¹\n", + "\t-> Actual pre rate: 2.0 s⁻¹\n", + "\t-> Actual post rate: 37.0 s⁻¹\n", + "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=47.2 s⁻¹\n", + "\t-> Actual pre rate: 5.0 s⁻¹\n", + "\t-> Actual post rate: 47.0 s⁻¹\n", + "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=57.8 s⁻¹\n", + "\t-> Actual pre rate: 4.0 s⁻¹\n", + "\t-> Actual post rate: 61.0 s⁻¹\n", + "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=68.3 s⁻¹\n", + "\t-> Actual pre rate: 5.0 s⁻¹\n", + "\t-> Actual post rate: 71.0 s⁻¹\n", + "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=78.9 s⁻¹\n", + "\t-> Actual pre rate: 3.0 s⁻¹\n", + "\t-> Actual post rate: 87.0 s⁻¹\n", + "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=89.4 s⁻¹\n", + "\t-> Actual pre rate: 4.0 s⁻¹\n", + "\t-> Actual post rate: 104.0 s⁻¹\n", + "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=100.0 s⁻¹\n", + "\t-> Actual pre rate: 5.0 s⁻¹\n", + "\t-> Actual post rate: 114.0 s⁻¹\n", + "Simulating: Pre-rate=15.6 s⁻¹, Post-rate=5.0 s⁻¹\n", + "\t-> Actual pre rate: 14.0 s⁻¹\n", + "\t-> Actual post rate: 4.0 s⁻¹\n", + "Simulating: Pre-rate=15.6 s⁻¹, Post-rate=15.6 s⁻¹\n", + "\t-> Actual pre rate: 12.0 s⁻¹\n", + "\t-> Actual post rate: 18.0 s⁻¹\n", + "Simulating: Pre-rate=15.6 s⁻¹, Post-rate=26.1 s⁻¹\n", + "\t-> Actual pre rate: 13.0 s⁻¹\n", + "\t-> Actual post rate: 26.0 s⁻¹\n", + "Simulating: Pre-rate=15.6 s⁻¹, Post-rate=36.7 s⁻¹\n", + "\t-> Actual pre rate: 17.0 s⁻¹\n", + "\t-> Actual post rate: 37.0 s⁻¹\n", + "Simulating: Pre-rate=15.6 s⁻¹, Post-rate=47.2 s⁻¹\n", + "\t-> Actual pre rate: 17.0 s⁻¹\n", + "\t-> Actual post rate: 51.0 s⁻¹\n", + "Simulating: Pre-rate=15.6 s⁻¹, Post-rate=57.8 s⁻¹\n", + "\t-> Actual pre rate: 18.0 s⁻¹\n", + "\t-> Actual post rate: 63.0 s⁻¹\n", + "Simulating: Pre-rate=15.6 s⁻¹, Post-rate=68.3 s⁻¹\n", + "\t-> Actual pre rate: 13.0 s⁻¹\n", + "\t-> Actual post rate: 73.0 s⁻¹\n", + "Simulating: Pre-rate=15.6 s⁻¹, Post-rate=78.9 s⁻¹\n", + "\t-> Actual pre rate: 17.0 s⁻¹\n", + "\t-> Actual post rate: 87.0 s⁻¹\n", + "Simulating: Pre-rate=15.6 s⁻¹, Post-rate=89.4 s⁻¹\n", + "\t-> Actual pre rate: 16.0 s⁻¹\n", + "\t-> Actual post rate: 99.0 s⁻¹\n", + "Simulating: Pre-rate=15.6 s⁻¹, Post-rate=100.0 s⁻¹\n", + "\t-> Actual pre rate: 18.0 s⁻¹\n", + "\t-> Actual post rate: 103.0 s⁻¹\n", + "Simulating: Pre-rate=26.1 s⁻¹, Post-rate=5.0 s⁻¹\n", + "\t-> Actual pre rate: 25.0 s⁻¹\n", + "\t-> Actual post rate: 6.0 s⁻¹\n", + "Simulating: Pre-rate=26.1 s⁻¹, Post-rate=15.6 s⁻¹\n", + "\t-> Actual pre rate: 28.0 s⁻¹\n", + "\t-> Actual post rate: 14.0 s⁻¹\n", + "Simulating: Pre-rate=26.1 s⁻¹, Post-rate=26.1 s⁻¹\n", + "\t-> Actual pre rate: 27.0 s⁻¹\n", + "\t-> Actual post rate: 29.0 s⁻¹\n", + "Simulating: Pre-rate=26.1 s⁻¹, Post-rate=36.7 s⁻¹\n", + "\t-> Actual pre rate: 35.0 s⁻¹\n", + "\t-> Actual post rate: 37.0 s⁻¹\n", + "Simulating: Pre-rate=26.1 s⁻¹, Post-rate=47.2 s⁻¹\n", + "\t-> Actual pre rate: 28.0 s⁻¹\n", + "\t-> Actual post rate: 52.0 s⁻¹\n", + "Simulating: Pre-rate=26.1 s⁻¹, Post-rate=57.8 s⁻¹\n", + "\t-> Actual pre rate: 23.0 s⁻¹\n", + "\t-> Actual post rate: 62.0 s⁻¹\n", + "Simulating: Pre-rate=26.1 s⁻¹, Post-rate=68.3 s⁻¹\n", + "\t-> Actual pre rate: 25.0 s⁻¹\n", + "\t-> Actual post rate: 81.0 s⁻¹\n", + "Simulating: Pre-rate=26.1 s⁻¹, Post-rate=78.9 s⁻¹\n", + "\t-> Actual pre rate: 31.0 s⁻¹\n", + "\t-> Actual post rate: 88.0 s⁻¹\n", + "Simulating: Pre-rate=26.1 s⁻¹, Post-rate=89.4 s⁻¹\n", + "\t-> Actual pre rate: 32.0 s⁻¹\n", + "\t-> Actual post rate: 99.0 s⁻¹\n", + "Simulating: Pre-rate=26.1 s⁻¹, Post-rate=100.0 s⁻¹\n", + "\t-> Actual pre rate: 33.0 s⁻¹\n", + "\t-> Actual post rate: 115.0 s⁻¹\n", + "Simulating: Pre-rate=36.7 s⁻¹, Post-rate=5.0 s⁻¹\n", + "\t-> Actual pre rate: 33.0 s⁻¹\n", + "\t-> Actual post rate: 6.0 s⁻¹\n", + "Simulating: Pre-rate=36.7 s⁻¹, Post-rate=15.6 s⁻¹\n", + "\t-> Actual pre rate: 32.0 s⁻¹\n", + "\t-> Actual post rate: 15.0 s⁻¹\n", + "Simulating: Pre-rate=36.7 s⁻¹, Post-rate=26.1 s⁻¹\n", + "\t-> Actual pre rate: 35.0 s⁻¹\n", + "\t-> Actual post rate: 26.0 s⁻¹\n", + "Simulating: Pre-rate=36.7 s⁻¹, Post-rate=36.7 s⁻¹\n", + "\t-> Actual pre rate: 34.0 s⁻¹\n", + "\t-> Actual post rate: 50.0 s⁻¹\n", + "Simulating: Pre-rate=36.7 s⁻¹, Post-rate=47.2 s⁻¹\n", + "\t-> Actual pre rate: 34.0 s⁻¹\n", + "\t-> Actual post rate: 55.0 s⁻¹\n", + "Simulating: Pre-rate=36.7 s⁻¹, Post-rate=57.8 s⁻¹\n", + "\t-> Actual pre rate: 35.0 s⁻¹\n", + "\t-> Actual post rate: 61.0 s⁻¹\n", + "Simulating: Pre-rate=36.7 s⁻¹, Post-rate=68.3 s⁻¹\n", + "\t-> Actual pre rate: 39.0 s⁻¹\n", + "\t-> Actual post rate: 72.0 s⁻¹\n", + "Simulating: Pre-rate=36.7 s⁻¹, Post-rate=78.9 s⁻¹\n", + "\t-> Actual pre rate: 44.0 s⁻¹\n", + "\t-> Actual post rate: 91.0 s⁻¹\n", + "Simulating: Pre-rate=36.7 s⁻¹, Post-rate=89.4 s⁻¹\n", + "\t-> Actual pre rate: 41.0 s⁻¹\n", + "\t-> Actual post rate: 103.0 s⁻¹\n", + "Simulating: Pre-rate=36.7 s⁻¹, Post-rate=100.0 s⁻¹\n", + "\t-> Actual pre rate: 38.0 s⁻¹\n", + "\t-> Actual post rate: 116.0 s⁻¹\n", + "Simulating: Pre-rate=47.2 s⁻¹, Post-rate=5.0 s⁻¹\n", + "\t-> Actual pre rate: 45.0 s⁻¹\n", + "\t-> Actual post rate: 3.0 s⁻¹\n", + "Simulating: Pre-rate=47.2 s⁻¹, Post-rate=15.6 s⁻¹\n", + "\t-> Actual pre rate: 43.0 s⁻¹\n", + "\t-> Actual post rate: 16.0 s⁻¹\n", + "Simulating: Pre-rate=47.2 s⁻¹, Post-rate=26.1 s⁻¹\n", + "\t-> Actual pre rate: 46.0 s⁻¹\n", + "\t-> Actual post rate: 24.0 s⁻¹\n", + "Simulating: Pre-rate=47.2 s⁻¹, Post-rate=36.7 s⁻¹\n", + "\t-> Actual pre rate: 52.0 s⁻¹\n", + "\t-> Actual post rate: 41.0 s⁻¹\n", + "Simulating: Pre-rate=47.2 s⁻¹, Post-rate=47.2 s⁻¹\n", + "\t-> Actual pre rate: 51.0 s⁻¹\n", + "\t-> Actual post rate: 48.0 s⁻¹\n", + "Simulating: Pre-rate=47.2 s⁻¹, Post-rate=57.8 s⁻¹\n", + "\t-> Actual pre rate: 43.0 s⁻¹\n", + "\t-> Actual post rate: 63.0 s⁻¹\n", + "Simulating: Pre-rate=47.2 s⁻¹, Post-rate=68.3 s⁻¹\n", + "\t-> Actual pre rate: 48.0 s⁻¹\n", + "\t-> Actual post rate: 77.0 s⁻¹\n", + "Simulating: Pre-rate=47.2 s⁻¹, Post-rate=78.9 s⁻¹\n", + "\t-> Actual pre rate: 49.0 s⁻¹\n", + "\t-> Actual post rate: 93.0 s⁻¹\n", + "Simulating: Pre-rate=47.2 s⁻¹, Post-rate=89.4 s⁻¹\n", + "\t-> Actual pre rate: 49.0 s⁻¹\n", + "\t-> Actual post rate: 112.0 s⁻¹\n", + "Simulating: Pre-rate=47.2 s⁻¹, Post-rate=100.0 s⁻¹\n", + "\t-> Actual pre rate: 48.0 s⁻¹\n", + "\t-> Actual post rate: 118.0 s⁻¹\n", + "Simulating: Pre-rate=57.8 s⁻¹, Post-rate=5.0 s⁻¹\n", + "\t-> Actual pre rate: 56.0 s⁻¹\n", + "\t-> Actual post rate: 4.0 s⁻¹\n", + "Simulating: Pre-rate=57.8 s⁻¹, Post-rate=15.6 s⁻¹\n", + "\t-> Actual pre rate: 56.0 s⁻¹\n", + "\t-> Actual post rate: 11.0 s⁻¹\n", + "Simulating: Pre-rate=57.8 s⁻¹, Post-rate=26.1 s⁻¹\n", + "\t-> Actual pre rate: 61.0 s⁻¹\n", + "\t-> Actual post rate: 28.0 s⁻¹\n", + "Simulating: Pre-rate=57.8 s⁻¹, Post-rate=36.7 s⁻¹\n", + "\t-> Actual pre rate: 56.0 s⁻¹\n", + "\t-> Actual post rate: 40.0 s⁻¹\n", + "Simulating: Pre-rate=57.8 s⁻¹, Post-rate=47.2 s⁻¹\n", + "\t-> Actual pre rate: 56.0 s⁻¹\n", + "\t-> Actual post rate: 54.0 s⁻¹\n", + "Simulating: Pre-rate=57.8 s⁻¹, Post-rate=57.8 s⁻¹\n", + "\t-> Actual pre rate: 58.0 s⁻¹\n", + "\t-> Actual post rate: 60.0 s⁻¹\n", + "Simulating: Pre-rate=57.8 s⁻¹, Post-rate=68.3 s⁻¹\n", + "\t-> Actual pre rate: 61.0 s⁻¹\n", + "\t-> Actual post rate: 72.0 s⁻¹\n", + "Simulating: Pre-rate=57.8 s⁻¹, Post-rate=78.9 s⁻¹\n", + "\t-> Actual pre rate: 53.0 s⁻¹\n", + "\t-> Actual post rate: 89.0 s⁻¹\n", + "Simulating: Pre-rate=57.8 s⁻¹, Post-rate=89.4 s⁻¹\n", + "\t-> Actual pre rate: 57.0 s⁻¹\n", + "\t-> Actual post rate: 106.0 s⁻¹\n", + "Simulating: Pre-rate=57.8 s⁻¹, Post-rate=100.0 s⁻¹\n", + "\t-> Actual pre rate: 54.0 s⁻¹\n", + "\t-> Actual post rate: 111.0 s⁻¹\n", + "Simulating: Pre-rate=68.3 s⁻¹, Post-rate=5.0 s⁻¹\n", + "\t-> Actual pre rate: 63.0 s⁻¹\n", + "\t-> Actual post rate: 4.0 s⁻¹\n", + "Simulating: Pre-rate=68.3 s⁻¹, Post-rate=15.6 s⁻¹\n", + "\t-> Actual pre rate: 67.0 s⁻¹\n", + "\t-> Actual post rate: 20.0 s⁻¹\n", + "Simulating: Pre-rate=68.3 s⁻¹, Post-rate=26.1 s⁻¹\n", + "\t-> Actual pre rate: 67.0 s⁻¹\n", + "\t-> Actual post rate: 26.0 s⁻¹\n", + "Simulating: Pre-rate=68.3 s⁻¹, Post-rate=36.7 s⁻¹\n", + "\t-> Actual pre rate: 72.0 s⁻¹\n", + "\t-> Actual post rate: 37.0 s⁻¹\n", + "Simulating: Pre-rate=68.3 s⁻¹, Post-rate=47.2 s⁻¹\n", + "\t-> Actual pre rate: 68.0 s⁻¹\n", + "\t-> Actual post rate: 49.0 s⁻¹\n", + "Simulating: Pre-rate=68.3 s⁻¹, Post-rate=57.8 s⁻¹\n", + "\t-> Actual pre rate: 66.0 s⁻¹\n", + "\t-> Actual post rate: 60.0 s⁻¹\n", + "Simulating: Pre-rate=68.3 s⁻¹, Post-rate=68.3 s⁻¹\n", + "\t-> Actual pre rate: 62.0 s⁻¹\n", + "\t-> Actual post rate: 85.0 s⁻¹\n", + "Simulating: Pre-rate=68.3 s⁻¹, Post-rate=78.9 s⁻¹\n", + "\t-> Actual pre rate: 66.0 s⁻¹\n", + "\t-> Actual post rate: 93.0 s⁻¹\n", + "Simulating: Pre-rate=68.3 s⁻¹, Post-rate=89.4 s⁻¹\n", + "\t-> Actual pre rate: 60.0 s⁻¹\n", + "\t-> Actual post rate: 107.0 s⁻¹\n", + "Simulating: Pre-rate=68.3 s⁻¹, Post-rate=100.0 s⁻¹\n", + "\t-> Actual pre rate: 66.0 s⁻¹\n", + "\t-> Actual post rate: 110.0 s⁻¹\n", + "Simulating: Pre-rate=78.9 s⁻¹, Post-rate=5.0 s⁻¹\n", + "\t-> Actual pre rate: 84.0 s⁻¹\n", + "\t-> Actual post rate: 3.0 s⁻¹\n", + "Simulating: Pre-rate=78.9 s⁻¹, Post-rate=15.6 s⁻¹\n", + "\t-> Actual pre rate: 76.0 s⁻¹\n", + "\t-> Actual post rate: 14.0 s⁻¹\n", + "Simulating: Pre-rate=78.9 s⁻¹, Post-rate=26.1 s⁻¹\n", + "\t-> Actual pre rate: 84.0 s⁻¹\n", + "\t-> Actual post rate: 28.0 s⁻¹\n", + "Simulating: Pre-rate=78.9 s⁻¹, Post-rate=36.7 s⁻¹\n", + "\t-> Actual pre rate: 75.0 s⁻¹\n", + "\t-> Actual post rate: 47.0 s⁻¹\n", + "Simulating: Pre-rate=78.9 s⁻¹, Post-rate=47.2 s⁻¹\n", + "\t-> Actual pre rate: 76.0 s⁻¹\n", + "\t-> Actual post rate: 52.0 s⁻¹\n", + "Simulating: Pre-rate=78.9 s⁻¹, Post-rate=57.8 s⁻¹\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t-> Actual pre rate: 75.0 s⁻¹\n", + "\t-> Actual post rate: 72.0 s⁻¹\n", + "Simulating: Pre-rate=78.9 s⁻¹, Post-rate=68.3 s⁻¹\n", + "\t-> Actual pre rate: 84.0 s⁻¹\n", + "\t-> Actual post rate: 71.0 s⁻¹\n", + "Simulating: Pre-rate=78.9 s⁻¹, Post-rate=78.9 s⁻¹\n", + "\t-> Actual pre rate: 76.0 s⁻¹\n", + "\t-> Actual post rate: 95.0 s⁻¹\n", + "Simulating: Pre-rate=78.9 s⁻¹, Post-rate=89.4 s⁻¹\n", + "\t-> Actual pre rate: 87.0 s⁻¹\n", + "\t-> Actual post rate: 95.0 s⁻¹\n", + "Simulating: Pre-rate=78.9 s⁻¹, Post-rate=100.0 s⁻¹\n", + "\t-> Actual pre rate: 75.0 s⁻¹\n", + "\t-> Actual post rate: 121.0 s⁻¹\n", + "Simulating: Pre-rate=89.4 s⁻¹, Post-rate=5.0 s⁻¹\n", + "\t-> Actual pre rate: 90.0 s⁻¹\n", + "\t-> Actual post rate: 3.0 s⁻¹\n", + "Simulating: Pre-rate=89.4 s⁻¹, Post-rate=15.6 s⁻¹\n", + "\t-> Actual pre rate: 100.0 s⁻¹\n", + "\t-> Actual post rate: 12.0 s⁻¹\n", + "Simulating: Pre-rate=89.4 s⁻¹, Post-rate=26.1 s⁻¹\n", + "\t-> Actual pre rate: 93.0 s⁻¹\n", + "\t-> Actual post rate: 32.0 s⁻¹\n", + "Simulating: Pre-rate=89.4 s⁻¹, Post-rate=36.7 s⁻¹\n", + "\t-> Actual pre rate: 93.0 s⁻¹\n", + "\t-> Actual post rate: 36.0 s⁻¹\n", + "Simulating: Pre-rate=89.4 s⁻¹, Post-rate=47.2 s⁻¹\n", + "\t-> Actual pre rate: 92.0 s⁻¹\n", + "\t-> Actual post rate: 54.0 s⁻¹\n", + "Simulating: Pre-rate=89.4 s⁻¹, Post-rate=57.8 s⁻¹\n", + "\t-> Actual pre rate: 97.0 s⁻¹\n", + "\t-> Actual post rate: 60.0 s⁻¹\n", + "Simulating: Pre-rate=89.4 s⁻¹, Post-rate=68.3 s⁻¹\n", + "\t-> Actual pre rate: 93.0 s⁻¹\n", + "\t-> Actual post rate: 76.0 s⁻¹\n", + "Simulating: Pre-rate=89.4 s⁻¹, Post-rate=78.9 s⁻¹\n", + "\t-> Actual pre rate: 99.0 s⁻¹\n", + "\t-> Actual post rate: 84.0 s⁻¹\n", + "Simulating: Pre-rate=89.4 s⁻¹, Post-rate=89.4 s⁻¹\n", + "\t-> Actual pre rate: 81.0 s⁻¹\n", + "\t-> Actual post rate: 114.0 s⁻¹\n", + "Simulating: Pre-rate=89.4 s⁻¹, Post-rate=100.0 s⁻¹\n", + "\t-> Actual pre rate: 94.0 s⁻¹\n", + "\t-> Actual post rate: 113.0 s⁻¹\n", + "Simulating: Pre-rate=100.0 s⁻¹, Post-rate=5.0 s⁻¹\n", + "\t-> Actual pre rate: 109.0 s⁻¹\n", + "\t-> Actual post rate: 4.0 s⁻¹\n", + "Simulating: Pre-rate=100.0 s⁻¹, Post-rate=15.6 s⁻¹\n", + "\t-> Actual pre rate: 107.0 s⁻¹\n", + "\t-> Actual post rate: 16.0 s⁻¹\n", + "Simulating: Pre-rate=100.0 s⁻¹, Post-rate=26.1 s⁻¹\n", + "\t-> Actual pre rate: 111.0 s⁻¹\n", + "\t-> Actual post rate: 22.0 s⁻¹\n", + "Simulating: Pre-rate=100.0 s⁻¹, Post-rate=36.7 s⁻¹\n", + "\t-> Actual pre rate: 97.0 s⁻¹\n", + "\t-> Actual post rate: 47.0 s⁻¹\n", + "Simulating: Pre-rate=100.0 s⁻¹, Post-rate=47.2 s⁻¹\n", + "\t-> Actual pre rate: 105.0 s⁻¹\n", + "\t-> Actual post rate: 62.0 s⁻¹\n", + "Simulating: Pre-rate=100.0 s⁻¹, Post-rate=57.8 s⁻¹\n", + "\t-> Actual pre rate: 104.0 s⁻¹\n", + "\t-> Actual post rate: 67.0 s⁻¹\n", + "Simulating: Pre-rate=100.0 s⁻¹, Post-rate=68.3 s⁻¹\n", + "\t-> Actual pre rate: 107.0 s⁻¹\n", + "\t-> Actual post rate: 69.0 s⁻¹\n", + "Simulating: Pre-rate=100.0 s⁻¹, Post-rate=78.9 s⁻¹\n", + "\t-> Actual pre rate: 107.0 s⁻¹\n", + "\t-> Actual post rate: 97.0 s⁻¹\n", + "Simulating: Pre-rate=100.0 s⁻¹, Post-rate=89.4 s⁻¹\n", + "\t-> Actual pre rate: 110.0 s⁻¹\n", + "\t-> Actual post rate: 94.0 s⁻¹\n", + "Simulating: Pre-rate=100.0 s⁻¹, Post-rate=100.0 s⁻¹\n", + "\t-> Actual pre rate: 106.0 s⁻¹\n", + "\t-> Actual post rate: 108.0 s⁻¹\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "DEBUG:locator: \n" + "DEBUG:locator: \n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3547,11 +3543,6 @@ } ], "source": [ - "import nest\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from matplotlib.colors import LinearSegmentedColormap\n", - "\n", "# --- Simulation Parameters ---\n", "# Duration of each individual simulation\n", "duration = 1000. # ms\n", @@ -3569,7 +3560,7 @@ "initial_weight = 0.5 # Starting weight for the synapse\n", "\n", "# --- Firing Rate Parameters ---\n", - "# Range of firing rates to test (in Hz)\n", + "# Range of firing rates to test (in s⁻¹)\n", "pre_rates = np.linspace(5.0, 100.0, 10)\n", "post_rates = np.linspace(5.0, 100.0, 10)\n", "\n", @@ -3581,9 +3572,9 @@ "# Iterate over every combination of presynaptic and postsynaptic firing rates\n", "for i, pre_rate in enumerate(pre_rates):\n", " for j, post_rate in enumerate(post_rates):\n", - " print(f\"Simulating: Pre-rate={pre_rate:.1f} Hz, Post-rate={post_rate:.1f} Hz\")\n", + " print(f\"Simulating: Pre-rate={pre_rate:.1f} s⁻¹, Post-rate={post_rate:.1f} s⁻¹\")\n", "\n", - " # --- 1. Reset NEST Kernel ---\n", + " # --- Reset NEST Kernel ---\n", " # Ensures that each simulation run is independent and starts from a clean state\n", " nest.ResetKernel()\n", " nest.resolution = dt\n", @@ -3591,7 +3582,7 @@ " nest.print_time = False\n", " nest.local_num_threads = 1 # Ensures reproducibility for this script\n", "\n", - " # --- 2. Create Network Nodes ---\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", @@ -3611,7 +3602,7 @@ " # 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", - " # --- 3. Configure Synapse Model ---\n", + " # --- Configure Synapse Model ---\n", " # Define the parameters for NEST's built-in STDP synapse model\n", " stdp_params = {\n", " \"lambda\": A_plus, # Potentiation step\n", @@ -3626,32 +3617,31 @@ " nest.Connect(pre_parrot, post_neuron, syn_spec={\"synapse_model\": \"stdp_synapse\"})\n", " nest.Connect(post_driver, post_neuron, syn_spec={\"weight\": 2000.})\n", "\n", - " # --- 5. Get Initial Weight ---\n", + " # --- Get Initial Weight ---\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", - " # --- 6. Run Simulation ---\n", + " # --- Run Simulation ---\n", " nest.Simulate(duration)\n", " \n", " assert len(sr_pre.events[\"times\"]) > 0\n", - " print(\"Actual pre rate: \" + str(len(sr_pre.events[\"times\"]) / (duration / 1000)))\n", + " print(\"\\t-> Actual pre rate: \" + str(len(sr_pre.events[\"times\"]) / (duration / 1000)) + \" s⁻¹\")\n", " assert len(sr_post.events[\"times\"]) > 0\n", - " print(\"Actual post rate: \" + str(len(sr_post.events[\"times\"]) / (duration / 1000)))\n", + " print(\"\\t-> Actual post rate: \" + str(len(sr_post.events[\"times\"]) / (duration / 1000)) + \" s⁻¹\")\n", "\n", - " # --- 7. Get Final Weight ---\n", + " # --- Get Final Weight ---\n", " # Retrieve the weight after the simulation has finished\n", " final_w = nest.GetStatus(connection, \"weight\")[0]\n", "\n", - " # --- 8. Store Result ---\n", + " # --- Store Result ---\n", " weight_changes[i, j] = final_w - initial_w\n", "\n", - "# --- Plotting Results ---\n", - "# The plotting code is largely the same as in the original script.\n", "\n", + "# --- Plotting Results ---\n", "# Create a custom colormap: blue -> white -> red\n", "colors = [(0, 0, 1), (1, 1, 1), (1, 0, 0)] # Blue, White, Red\n", - "cmap = LinearSegmentedColormap.from_list('stdp_cmap', colors, N=256)\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", @@ -3668,21 +3658,24 @@ " vmax=v_limit\n", ")\n", "\n", - "# Add labels, title, and a color bar\n", "plt.colorbar(im, label='Change in Synaptic Weight')\n", - "plt.xlabel('Postsynaptic Firing Rate (Hz)')\n", - "plt.ylabel('Presynaptic Firing Rate (Hz)')\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", - "# Save the figure (optional)\n", - "# plt.savefig('stdp_nest_heatmap.png', dpi=300)\n", - "\n", - "# Display the plot\n", "plt.show()" ] }, + { + "cell_type": "markdown", + "id": "2c9ea2c1", + "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", @@ -3692,11 +3685,29 @@ "\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", + "[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. " + "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/." ] } ], From c092b77acf8bef833c6361b7e14f7f51cf7a07e5 Mon Sep 17 00:00:00 2001 From: "C.A.P. Linssen" Date: Tue, 17 Jun 2025 16:18:50 +0200 Subject: [PATCH 4/8] add mountain car reinforcement learning tutorial --- ...r_reinforcement_learning_nestml_tutorial.ipynb | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) 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 index 8af9b9537..ad5de23a2 100644 --- 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 @@ -221,9 +221,9 @@ "id": "433225be", "metadata": {}, "source": [ + "To render the environment for visual inspection, we make a class ``Renderer`` that uses pygame.\n", "\n", - "\n", - "To render the environment for visual inspection, we make a class ``Renderer`` that uses pygame:\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." ] }, { @@ -337,12 +337,9 @@ "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. \"boxes\" (discretizing the state space)...\n", - "\n", - "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. Therefore, one set of A is represented.\n", - "\n", - "\"Over time, it improves its decision-making by updating a Q-table, which stores Q-values representing the expected rewards for taking particular actions in given states.\"\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." ] }, { @@ -512,7 +509,7 @@ "source": [ "## Non-spiking Agent\n", "\n", - "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." + "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." ] }, { @@ -3670,7 +3667,7 @@ }, { "cell_type": "markdown", - "id": "2c9ea2c1", + "id": "b52fae58", "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." From 7ea4f99e13340868995ff13c10961422b641c0ea Mon Sep 17 00:00:00 2001 From: "C.A.P. Linssen" Date: Thu, 19 Jun 2025 15:53:14 +0200 Subject: [PATCH 5/8] add mountain car reinforcement learning tutorial --- ...inforcement_learning_nestml_tutorial.ipynb | 639 +++++++++--------- 1 file changed, 321 insertions(+), 318 deletions(-) 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 index ad5de23a2..7010debaa 100644 --- 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 @@ -514,7 +514,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 10, "id": "eb4dab99", "metadata": {}, "outputs": [], @@ -586,7 +586,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 11, "id": "3f9b07a1", "metadata": {}, "outputs": [], @@ -691,7 +691,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 12, "id": "717eda26-e385-494f-bdca-9847eefe01ca", "metadata": {}, "outputs": [ @@ -699,215 +699,215 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_466717/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_495062/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.25, Avg Reward (Last 100): -505.82, p_explore: 0.4954\n" + "Episode: 100/1500, Reward: -505.50, Avg Reward (Last 100): -506.07, p_explore: 0.4954\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_466717/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_495062/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: -511.00, Avg Reward (Last 100): -502.18, p_explore: 0.2454\n" + "Episode: 200/1500, Reward: -505.14, Avg Reward (Last 100): -491.17, p_explore: 0.2454\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_466717/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_495062/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: -341.47, Avg Reward (Last 100): -421.71, p_explore: 0.1216\n" + "Episode: 300/1500, Reward: -481.72, Avg Reward (Last 100): -458.79, p_explore: 0.1216\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_466717/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_495062/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: -358.99, Avg Reward (Last 100): -397.72, p_explore: 0.0602\n" + "Episode: 400/1500, Reward: -355.78, Avg Reward (Last 100): -382.86, p_explore: 0.0602\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_466717/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_495062/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: -514.72, Avg Reward (Last 100): -379.10, p_explore: 0.0298\n" + "Episode: 500/1500, Reward: -347.04, Avg Reward (Last 100): -435.51, p_explore: 0.0298\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_466717/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_495062/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: -378.92, Avg Reward (Last 100): -348.36, p_explore: 0.0148\n" + "Episode: 600/1500, Reward: -362.93, Avg Reward (Last 100): -328.22, p_explore: 0.0148\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_466717/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_495062/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: -270.65, Avg Reward (Last 100): -365.93, p_explore: 0.0000\n" + "Episode: 700/1500, Reward: -212.66, Avg Reward (Last 100): -296.76, p_explore: 0.0000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_466717/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_495062/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: -269.72, Avg Reward (Last 100): -324.57, p_explore: 0.0000\n" + "Episode: 800/1500, Reward: -297.14, Avg Reward (Last 100): -295.55, p_explore: 0.0000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_466717/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_495062/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: -308.57, Avg Reward (Last 100): -320.11, p_explore: 0.0000\n" + "Episode: 900/1500, Reward: -247.92, Avg Reward (Last 100): -279.87, p_explore: 0.0000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_466717/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_495062/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: -337.12, Avg Reward (Last 100): -297.41, p_explore: 0.0000\n" + "Episode: 1000/1500, Reward: -296.33, Avg Reward (Last 100): -271.56, p_explore: 0.0000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_466717/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_495062/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: -211.31, Avg Reward (Last 100): -292.63, p_explore: 0.0000\n" + "Episode: 1100/1500, Reward: -261.17, Avg Reward (Last 100): -269.62, p_explore: 0.0000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_466717/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_495062/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: -262.84, Avg Reward (Last 100): -270.42, p_explore: 0.0000\n" + "Episode: 1200/1500, Reward: -243.95, Avg Reward (Last 100): -244.42, p_explore: 0.0000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_466717/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_495062/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: -313.19, Avg Reward (Last 100): -268.92, p_explore: 0.0000\n" + "Episode: 1300/1500, Reward: -242.92, Avg Reward (Last 100): -233.84, p_explore: 0.0000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_466717/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_495062/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.84, Avg Reward (Last 100): -259.86, p_explore: 0.0000\n" + "Episode: 1400/1500, Reward: -244.06, Avg Reward (Last 100): -231.38, p_explore: 0.0000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_466717/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/tmp/ipykernel_495062/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: -262.36, Avg Reward (Last 100): -261.79, p_explore: 0.0000\n" + "Episode: 1500/1500, Reward: -242.84, Avg Reward (Last 100): -231.57, p_explore: 0.0000\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -945,7 +945,7 @@ " current_state = env.reset()\n", " episode_total_reward = 0\n", "\n", - " render_this_episode = False\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", @@ -1032,7 +1032,13 @@ "One simulation step of the SNN works as follows:\n", "1. Get the current state of the cart pole and find the designated neuron that only fires when that state is reached.\n", "2. Set a continuous firing rate for the simulation period on that neuron.\n", - "3. Determine which of the neuron groups in the output layer has fired more spikes at the end of the step." + "3. Determine which of the neuron groups in the output layer has fired more spikes at the end of the step.\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" ] }, { @@ -1045,7 +1051,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "id": "83e05060", "metadata": {}, "outputs": [], @@ -1096,7 +1102,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 7, "id": "e9bdcc5a", "metadata": {}, "outputs": [], @@ -1297,7 +1303,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 8, "id": "8e16ea83", "metadata": {}, "outputs": [ @@ -1325,7 +1331,7 @@ "[2,GLOBAL, INFO]: /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/iaf_psc_exp_neuron.nestml\n", "[3,GLOBAL, INFO]: /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/neuromodulated_stdp_synapse.nestml\n", "[4,GLOBAL, INFO]: Target platform code will be generated in directory: '/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target'\n", - "[5,GLOBAL, INFO]: Target platform code will be installed in directory: '/tmp/nestml_target_404rbl0t'\n", + "[5,GLOBAL, INFO]: Target platform code will be installed in directory: '/tmp/nestml_target_25yka07n'\n", "\n", " -- N E S T --\n", " Copyright (C) 2004 The NEST Initiative\n", @@ -1427,7 +1433,7 @@ "DEBUG:Created Shape with symbol V_m, derivative_factors = [-1/tau_m], inhom_term = E_l/tau_m + I_e/tau_m, nonlin_term = E_e*g_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m\n", "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", - "INFO:All known variables: [g_e, V_m], all parameters used in ODEs: {tau_m, E_l, I_stim, E_e, tau_g, I_e}\n", + "INFO:All known variables: [g_e, V_m], all parameters used in ODEs: {tau_m, E_e, tau_g, E_l, I_stim, I_e}\n", "INFO:No numerical value specified for parameter \"I_stim\"\n", "INFO:\n", "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", @@ -1450,7 +1456,17 @@ "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0]])\n", "DEBUG:\tinhomogeneous term: 0.0\n", "DEBUG:\tnonlinear term: 0.0\n", - "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n" + "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", + "DEBUG:Splitting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m (symbols Matrix([[g_e], [V_m]]))\n", + "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m]])\n", + "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", + "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", + "DEBUG:Initializing system of shapes with x = Matrix([[g_e], [V_m]]), A = Matrix([[-1/tau_g, 0], [E_e/tau_m, -1/tau_m]]), b = Matrix([[0], [E_l/tau_m + I_e/tau_m + I_stim/tau_m]]), c = Matrix([[0], [-V_m*g_e/tau_m]])\n", + "INFO:Finding analytically solvable equations...\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", + "DEBUG:os.makedirs('/tmp')\n", + "DEBUG:write lines to '/tmp/ode_dependency_graph.dot'\n", + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n" ] }, { @@ -1466,16 +1482,6 @@ "name": "stderr", "output_type": "stream", "text": [ - "DEBUG:Splitting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m (symbols Matrix([[g_e], [V_m]]))\n", - "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m]])\n", - "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", - "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", - "DEBUG:Initializing system of shapes with x = Matrix([[g_e], [V_m]]), A = Matrix([[-1/tau_g, 0], [E_e/tau_m, -1/tau_m]]), b = Matrix([[0], [E_l/tau_m + I_e/tau_m + I_stim/tau_m]]), c = Matrix([[0], [-V_m*g_e/tau_m]])\n", - "INFO:Finding analytically solvable equations...\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", - "DEBUG:os.makedirs('/tmp')\n", - "DEBUG:write lines to '/tmp/ode_dependency_graph.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n", "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m])\n", "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0]])\n", @@ -1596,7 +1602,7 @@ "DEBUG:Created Shape with symbol V_m, derivative_factors = [-1/tau_m], inhom_term = E_l/tau_m + I_e/tau_m, nonlin_term = E_e*g_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m\n", "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", - "INFO:All known variables: [g_e, V_m], all parameters used in ODEs: {tau_m, E_l, I_stim, E_e, tau_g, I_e}\n", + "INFO:All known variables: [g_e, V_m], all parameters used in ODEs: {tau_m, E_e, tau_g, E_l, I_stim, I_e}\n", "INFO:No numerical value specified for parameter \"I_stim\"\n", "INFO:\n", "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", @@ -1632,13 +1638,7 @@ "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n", "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0]])\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ + "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0]])\n", "DEBUG:\tinhomogeneous term: 0.0\n", "DEBUG:\tnonlinear term: 0.0\n", "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", @@ -1649,12 +1649,18 @@ "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot\n", "DEBUG:os.makedirs('/tmp')\n", "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable_before_propagated.dot']\n", + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable_before_propagated.dot']\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable.dot\n", "DEBUG:os.makedirs('/tmp')\n", "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable.dot'\n", "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable.dot']\n", - "INFO:Generating numerical solver for the following symbols: V_m, g_e\n", + "INFO:Generating numerical solver for the following symbols: g_e, V_m\n", "DEBUG:Initializing system of shapes with x = Matrix([[g_e], [V_m]]), A = Matrix([[-1/tau_g, 0], [E_e/tau_m, -1/tau_m]]), b = Matrix([[0], [E_l/tau_m + I_e/tau_m + I_stim/tau_m]]), c = Matrix([[0], [-V_m*g_e/tau_m]])\n", "INFO:Preserving expression for variable \"g_e\"\n", "INFO:Preserving expression for variable \"V_m\"\n", @@ -1750,7 +1756,7 @@ "DEBUG:Created Shape with symbol post_trace__for_neuromodulated_stdp_synapse_nestml, derivative_factors = [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml], inhom_term = 0.0, nonlin_term = 0.0\n", "INFO:\tReturning shape: Shape \"post_trace__for_neuromodulated_stdp_synapse_nestml\" of order 1\n", "INFO:Shape post_trace__for_neuromodulated_stdp_synapse_nestml: reconstituting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml\n", - "INFO:All known variables: [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml], all parameters used in ODEs: {tau_m, E_l, tau_tr_post__for_neuromodulated_stdp_synapse_nestml, I_stim, E_e, tau_g, I_e}\n", + "INFO:All known variables: [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml], all parameters used in ODEs: {tau_m, E_e, tau_tr_post__for_neuromodulated_stdp_synapse_nestml, tau_g, E_l, I_stim, I_e}\n", "INFO:No numerical value specified for parameter \"I_stim\"\n", "INFO:\n", "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", @@ -1778,13 +1784,7 @@ "INFO:\tReturning shape: Shape \"post_trace__for_neuromodulated_stdp_synapse_nestml\" of order 1\n", "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", "DEBUG:Splitting expression -g_e/tau_g (symbols Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]))\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0], [0]])\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ + "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0], [0]])\n", "DEBUG:\tinhomogeneous term: 0.0\n", "DEBUG:\tnonlinear term: 0.0\n", "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", @@ -1796,14 +1796,6 @@ "DEBUG:Splitting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml (symbols Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]))\n" ] }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[38,GLOBAL, INFO]: Analysing/transforming model 'iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml'\n", - "[39,iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml, INFO, [18:0;58:0]]: Starts processing of the model 'iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml'\n" - ] - }, { "name": "stderr", "output_type": "stream", @@ -1816,7 +1808,21 @@ "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", "DEBUG:os.makedirs('/tmp')\n", "DEBUG:write lines to '/tmp/ode_dependency_graph.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n", + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[38,GLOBAL, INFO]: Analysing/transforming model 'iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml'\n", + "[39,iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml, INFO, [18:0;58:0]]: Starts processing of the model 'iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml'\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml])\n", "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0], [0]])\n", @@ -1959,21 +1965,21 @@ "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", "INFO:\n", - "Processing differential-equation form shape post_trace__for_neuromodulated_stdp_synapse_nestml with defining expression = \"(-post_trace__for_neuromodulated_stdp_synapse_nestml) / tau_tr_post__for_neuromodulated_stdp_synapse_nestml\"\n" + "Processing differential-equation form shape post_trace__for_neuromodulated_stdp_synapse_nestml with defining expression = \"(-post_trace__for_neuromodulated_stdp_synapse_nestml) / tau_tr_post__for_neuromodulated_stdp_synapse_nestml\"\n", + "DEBUG:Splitting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml (symbols [post_trace__for_neuromodulated_stdp_synapse_nestml])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "DEBUG:Created Shape with symbol post_trace__for_neuromodulated_stdp_synapse_nestml, derivative_factors = [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml], inhom_term = 0.0, nonlin_term = 0.0\n", + "INFO:\tReturning shape: Shape \"post_trace__for_neuromodulated_stdp_synapse_nestml\" of order 1\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "DEBUG:Splitting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml (symbols [post_trace__for_neuromodulated_stdp_synapse_nestml])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "DEBUG:Created Shape with symbol post_trace__for_neuromodulated_stdp_synapse_nestml, derivative_factors = [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml], inhom_term = 0.0, nonlin_term = 0.0\n", - "INFO:\tReturning shape: Shape \"post_trace__for_neuromodulated_stdp_synapse_nestml\" of order 1\n", "INFO:Shape post_trace__for_neuromodulated_stdp_synapse_nestml: reconstituting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml\n", - "INFO:All known variables: [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml], all parameters used in ODEs: {tau_m, E_l, tau_tr_post__for_neuromodulated_stdp_synapse_nestml, I_stim, E_e, tau_g, I_e}\n", + "INFO:All known variables: [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml], all parameters used in ODEs: {tau_m, E_e, tau_tr_post__for_neuromodulated_stdp_synapse_nestml, tau_g, E_l, I_stim, I_e}\n", "INFO:No numerical value specified for parameter \"I_stim\"\n", "INFO:\n", "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", @@ -2043,7 +2049,7 @@ "DEBUG:os.makedirs('/tmp')\n", "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable.dot'\n", "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable.dot']\n", - "INFO:Generating numerical solver for the following symbols: post_trace__for_neuromodulated_stdp_synapse_nestml, V_m, g_e\n", + "INFO:Generating numerical solver for the following symbols: g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml\n", "DEBUG:Initializing system of shapes with x = Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]), A = Matrix([[-1/tau_g, 0, 0], [E_e/tau_m, -1/tau_m, 0], [0, 0, -1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]]), b = Matrix([[0], [E_l/tau_m + I_e/tau_m + I_stim/tau_m], [0]]), c = Matrix([[0], [-V_m*g_e/tau_m], [0]])\n", "INFO:Preserving expression for variable \"g_e\"\n", "INFO:Preserving expression for variable \"V_m\"\n", @@ -2076,14 +2082,14 @@ " \"post_trace__for_neuromodulated_stdp_synapse_nestml\": \"(-post_trace__for_neuromodulated_stdp_synapse_nestml) / tau_tr_post__for_neuromodulated_stdp_synapse_nestml\"\n", " }\n", " }\n", - "]\n" + "]\n", + "INFO:Analysing input:\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "INFO:Analysing input:\n", "INFO:{\n", " \"dynamics\": [\n", " {\n", @@ -2136,7 +2142,7 @@ "DEBUG:Created Shape with symbol wtr, derivative_factors = [-1/tau_wtr], inhom_term = 0.0, nonlin_term = 0.0\n", "INFO:\tReturning shape: Shape \"wtr\" of order 1\n", "INFO:Shape wtr: reconstituting expression -wtr/tau_wtr\n", - "INFO:All known variables: [pre_trace, wtr], all parameters used in ODEs: {tau_tr_pre, tau_wtr}\n", + "INFO:All known variables: [pre_trace, wtr], all parameters used in ODEs: {tau_wtr, tau_tr_pre}\n", "INFO:\n", "Processing differential-equation form shape pre_trace with defining expression = \"(-pre_trace) / tau_tr_pre\"\n", "DEBUG:Splitting expression -pre_trace/tau_tr_pre (symbols [pre_trace, wtr, pre_trace])\n", @@ -2168,7 +2174,21 @@ "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", "DEBUG:os.makedirs('/tmp')\n", "DEBUG:write lines to '/tmp/ode_dependency_graph.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n" + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n", + "INFO:Shape pre_trace: reconstituting expression -pre_trace/tau_tr_pre\n", + "DEBUG:Splitting expression -pre_trace/tau_tr_pre (symbols [pre_trace, wtr])\n", + "DEBUG:\tlinear factors: Matrix([[-1/tau_tr_pre], [0]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "INFO:Shape wtr: reconstituting expression -wtr/tau_wtr\n", + "DEBUG:Splitting expression -wtr/tau_wtr (symbols [pre_trace, wtr])\n", + "DEBUG:\tlinear factors: Matrix([[0], [-1/tau_wtr]])\n", + "DEBUG:\tinhomogeneous term: 0.0\n", + "DEBUG:\tnonlinear term: 0.0\n", + "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot\n", + "DEBUG:os.makedirs('/tmp')\n", + "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot'\n", + "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable_before_propagated.dot']\n" ] }, { @@ -2183,20 +2203,6 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO:Shape pre_trace: reconstituting expression -pre_trace/tau_tr_pre\n", - "DEBUG:Splitting expression -pre_trace/tau_tr_pre (symbols [pre_trace, wtr])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_tr_pre], [0]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "INFO:Shape wtr: reconstituting expression -wtr/tau_wtr\n", - "DEBUG:Splitting expression -wtr/tau_wtr (symbols [pre_trace, wtr])\n", - "DEBUG:\tlinear factors: Matrix([[0], [-1/tau_wtr]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot\n", - "DEBUG:os.makedirs('/tmp')\n", - "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable_before_propagated.dot']\n", "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable.dot\n", "DEBUG:os.makedirs('/tmp')\n", "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable.dot'\n", @@ -2254,8 +2260,8 @@ "[47,iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml, INFO, [18:0;58:0]]: Successfully generated code for the model: 'iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml' in: '/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target' !\n", "[48,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h\n", "[49,neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml, INFO, [6:0;55:0]]: Successfully generated code for the model: 'neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml' in: '/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target' !\n", - "[50,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/nestml_d7b75d7ce2614d2f84133484b2d1378f_module.cpp\n", - "[51,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/nestml_d7b75d7ce2614d2f84133484b2d1378f_module.h\n", + "[50,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/nestml_be24d67e1342417f93e13b73cd626d8c_module.cpp\n", + "[51,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/nestml_be24d67e1342417f93e13b73cd626d8c_module.h\n", "[52,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/CMakeLists.txt\n", "[53,GLOBAL, INFO]: Successfully generated NEST module code in '/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target' !\n", "-- The CXX compiler identification is GNU 12.3.0\n", @@ -2266,7 +2272,7 @@ "-- Detecting CXX compile features - done\n", "\n", "-------------------------------------------------------\n", - "nestml_d7b75d7ce2614d2f84133484b2d1378f_module Configuration Summary\n", + "nestml_be24d67e1342417f93e13b73cd626d8c_module Configuration Summary\n", "-------------------------------------------------------\n", "\n", "C++ compiler : /usr/bin/c++\n", @@ -2278,47 +2284,22 @@ "\n", "-------------------------------------------------------\n", "\n", - "You can now build and install 'nestml_d7b75d7ce2614d2f84133484b2d1378f_module' using\n", + "You can now build and install 'nestml_be24d67e1342417f93e13b73cd626d8c_module' using\n", " make\n", " make install\n", "\n", - "The library file libnestml_d7b75d7ce2614d2f84133484b2d1378f_module.so will be installed to\n", - " /tmp/nestml_target_404rbl0t\n", + "The library file libnestml_be24d67e1342417f93e13b73cd626d8c_module.so will be installed to\n", + " /tmp/nestml_target_25yka07n\n", "The module can be loaded into NEST using\n", - " (nestml_d7b75d7ce2614d2f84133484b2d1378f_module) Install (in SLI)\n", - " nest.Install(nestml_d7b75d7ce2614d2f84133484b2d1378f_module) (in PyNEST)\n", + " (nestml_be24d67e1342417f93e13b73cd626d8c_module) Install (in SLI)\n", + " nest.Install(nestml_be24d67e1342417f93e13b73cd626d8c_module) (in PyNEST)\n", "\n", - "-- Configuring done (0.5s)\n", + "-- Configuring done (0.4s)\n", "-- Generating done (0.0s)\n", "-- Build files have been written to: /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target\n", - "[ 25%] Building CXX object CMakeFiles/nestml_d7b75d7ce2614d2f84133484b2d1378f_module_module.dir/nestml_d7b75d7ce2614d2f84133484b2d1378f_module.cpp.o\n", - "[ 50%] Building CXX object CMakeFiles/nestml_d7b75d7ce2614d2f84133484b2d1378f_module_module.dir/iaf_psc_exp_neuron_nestml.cpp.o\n", - "[ 75%] Building CXX object CMakeFiles/nestml_d7b75d7ce2614d2f84133484b2d1378f_module_module.dir/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp.o\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml::init_state_internal_()’:\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:191:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 191 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml::recompute_internal_variables(bool)’:\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:271:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 271 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘virtual void iaf_psc_exp_neuron_nestml::update(const nest::Time&, long int, long int)’:\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:337:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", - " 337 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", - " | ~~^~~~~~~~~~~~~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:328:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 328 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", - " | ^~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:322:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 322 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml::on_receive_block_spikes_in_port(const nest::Time&, long int)’:\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:500:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 500 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:501:8: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 501 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", - " | ^~~~~\n", + "[ 25%] Building CXX object CMakeFiles/nestml_be24d67e1342417f93e13b73cd626d8c_module_module.dir/nestml_be24d67e1342417f93e13b73cd626d8c_module.cpp.o\n", + "[ 50%] Building CXX object CMakeFiles/nestml_be24d67e1342417f93e13b73cd626d8c_module_module.dir/iaf_psc_exp_neuron_nestml.cpp.o\n", + "[ 75%] Building CXX object CMakeFiles/nestml_be24d67e1342417f93e13b73cd626d8c_module_module.dir/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp.o\n", "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml::init_state_internal_()’:\n", "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:201:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", " 201 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", @@ -2347,6 +2328,31 @@ " | ^~~~~~~~~~\n", "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:542:8: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", " 542 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml::init_state_internal_()’:\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:191:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 191 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml::recompute_internal_variables(bool)’:\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:271:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 271 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘virtual void iaf_psc_exp_neuron_nestml::update(const nest::Time&, long int, long int)’:\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:337:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", + " 337 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", + " | ~~^~~~~~~~~~~~~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:328:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 328 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", + " | ^~~~~\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:322:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 322 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml::on_receive_block_spikes_in_port(const nest::Time&, long int)’:\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:500:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", + " 500 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", + " | ^~~~~~~~~~\n", + "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:501:8: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", + " 501 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", " | ^~~~~\n" ] }, @@ -2354,7 +2360,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "In file included from /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/nestml_d7b75d7ce2614d2f84133484b2d1378f_module.cpp:36:\n", + "In file included from /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/nestml_be24d67e1342417f93e13b73cd626d8c_module.cpp:36:\n", "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:62:5: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", @@ -2459,12 +2465,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "[100%] Linking CXX shared module nestml_d7b75d7ce2614d2f84133484b2d1378f_module.so\n", - "[100%] Built target nestml_d7b75d7ce2614d2f84133484b2d1378f_module_module\n", - "[100%] Built target nestml_d7b75d7ce2614d2f84133484b2d1378f_module_module\n", + "[100%] Linking CXX shared module nestml_be24d67e1342417f93e13b73cd626d8c_module.so\n", + "[100%] Built target nestml_be24d67e1342417f93e13b73cd626d8c_module_module\n", + "[100%] Built target nestml_be24d67e1342417f93e13b73cd626d8c_module_module\n", "Install the project...\n", "-- Install configuration: \"\"\n", - "-- Installing: /tmp/nestml_target_404rbl0t/nestml_d7b75d7ce2614d2f84133484b2d1378f_module.so\n" + "-- Installing: /tmp/nestml_target_25yka07n/nestml_be24d67e1342417f93e13b73cd626d8c_module.so\n" ] } ], @@ -2485,7 +2491,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 9, "id": "99614c94", "metadata": {}, "outputs": [], @@ -2496,8 +2502,6 @@ " def __init__(self, env) -> None:\n", " super().__init__(env)\n", " \n", - " self.constant_reward = -1.\n", - " \n", " self.Q_left = 0.\n", " self.Q_right = 0.\n", " self.Q_left_prev = 0.\n", @@ -2752,7 +2756,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 10, "id": "e4bda6d4", "metadata": { "scrolled": true @@ -2762,230 +2766,230 @@ "name": "stdout", "output_type": "stream", "text": [ - "Episode 0 took: 15.407 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -12.351658852336673\n", - "Episode 1 took: 12.304 s\n", + "Episode 0 took: 4.902 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -0.9684528937981807\n", - "Episode 2 took: 13.071 s\n", + "\tTotal reward = -7.372242346828137\n", + "Episode 1 took: 4.326 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -5.58159301896193\n", - "Episode 3 took: 13.731 s\n", + "\tTotal reward = 2.7640682743350213\n", + "Episode 2 took: 16.325 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -5.932404965977481\n", - "Episode 4 took: 16.133 s\n", + "\tTotal reward = -2.7498576649449835\n", + "Episode 3 took: 9.898 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -7.9822054960841875\n", - "Episode 5 took: 16.678 s\n", + "\tTotal reward = -4.837556579077697\n", + "Episode 4 took: 13.589 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -6.76394759868483\n", - "Episode 6 took: 15.628 s\n", + "\tTotal reward = 1.670897495745249\n", + "Episode 5 took: 5.945 s\n", + "\tNumber of steps in episode = 432\n", + "\tTotal reward = 3.989864219702854\n", + "Episode 6 took: 5.603 s\n", + "\tNumber of steps in episode = 461\n", + "\tTotal reward = 4.126203512291253\n", + "Episode 7 took: 5.870 s\n", + "\tNumber of steps in episode = 478\n", + "\tTotal reward = 3.265240199780956\n", + "Episode 8 took: 6.708 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -4.67723116917611\n", - "Episode 7 took: 16.470 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -4.107778950184352\n", - "Episode 8 took: 16.912 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -8.935828944056933\n", - "Episode 9 took: 18.802 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -8.86354982654994\n" + "\tTotal reward = 0.18832725094545388\n", + "Episode 9 took: 5.675 s\n", + "\tNumber of steps in episode = 421\n", + "\tTotal reward = 5.106904076414163\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_466717/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_466717/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", - "DEBUG:locator: \n" + "/tmp/ipykernel_94521/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_94521/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", + "DEBUG:locator: \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Episode 10 took: 17.959 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -4.4788246108889975\n", - "Episode 11 took: 18.878 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -9.291752250754872\n", - "Episode 12 took: 20.706 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -2.3123560165874424\n", - "Episode 13 took: 19.795 s\n", - "\tNumber of steps in episode = 489\n", - "\tTotal reward = -3.2660639947028134\n", - "Episode 14 took: 19.379 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -5.281728056258335\n", - "Episode 15 took: 21.669 s\n", + "Episode 10 took: 9.965 s\n", + "\tNumber of steps in episode = 387\n", + "\tTotal reward = 6.798445782414001\n", + "Episode 11 took: 11.372 s\n", + "\tNumber of steps in episode = 449\n", + "\tTotal reward = 2.7922593359881955\n", + "Episode 12 took: 13.048 s\n", + "\tNumber of steps in episode = 472\n", + "\tTotal reward = 3.4417362526944237\n", + "Episode 13 took: 11.977 s\n", + "\tNumber of steps in episode = 459\n", + "\tTotal reward = 4.084680653365472\n", + "Episode 14 took: 13.248 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -7.451217772876397\n", - "Episode 16 took: 21.719 s\n", + "\tTotal reward = -0.8305929598994641\n", + "Episode 15 took: 14.977 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -15.816558112548382\n", - "Episode 17 took: 20.802 s\n", + "\tTotal reward = -5.377416253306809\n", + "Episode 16 took: 15.148 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -5.594274672288915\n", - "Episode 18 took: 21.144 s\n", + "\tTotal reward = -4.323984646280818\n", + "Episode 17 took: 13.083 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -8.196928489595395\n", - "Episode 19 took: 21.599 s\n", + "\tTotal reward = 0.8199416134117596\n", + "Episode 18 took: 8.791 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -3.435630197778771\n" + "\tTotal reward = -4.8012069808303295\n", + "Episode 19 took: 8.250 s\n", + "\tNumber of steps in episode = 481\n", + "\tTotal reward = 2.918082621247154\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_466717/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_466717/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", - "DEBUG:locator: \n" + "/tmp/ipykernel_94521/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_94521/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", + "DEBUG:locator: \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Episode 20 took: 21.901 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -9.59459783032514\n", - "Episode 21 took: 20.405 s\n", - "\tNumber of steps in episode = 457\n", - "\tTotal reward = -12.069258944600652\n", - "Episode 22 took: 22.738 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -2.983211203391944\n", - "Episode 23 took: 23.244 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -7.803500254992504\n", - "Episode 24 took: 23.738 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -7.7393838278464715\n", - "Episode 25 took: 24.110 s\n", - "\tNumber of steps in episode = 498\n", - "\tTotal reward = -2.6646766558777424\n", - "Episode 26 took: 24.521 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -2.9948900342711395\n", - "Episode 27 took: 25.041 s\n", + "Episode 20 took: 15.266 s\n", + "\tNumber of steps in episode = 423\n", + "\tTotal reward = 4.648173414790665\n", + "Episode 21 took: 13.491 s\n", + "\tNumber of steps in episode = 485\n", + "\tTotal reward = 3.3109517152601144\n", + "Episode 22 took: 9.645 s\n", + "\tNumber of steps in episode = 467\n", + "\tTotal reward = 4.316775721449431\n", + "Episode 23 took: 11.492 s\n", + "\tNumber of steps in episode = 469\n", + "\tTotal reward = 3.585056711349568\n", + "Episode 24 took: 9.037 s\n", + "\tNumber of steps in episode = 434\n", + "\tTotal reward = 3.6589571947102533\n", + "Episode 25 took: 14.447 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -7.3875393416858675\n", - "Episode 28 took: 25.476 s\n", + "\tTotal reward = -3.5138648522466207\n", + "Episode 26 took: 11.478 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -10.941111404711826\n", - "Episode 29 took: 26.055 s\n", + "\tTotal reward = -6.489495125106023\n", + "Episode 27 took: 11.056 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -9.056446903616594\n" + "\tTotal reward = -8.528480605481178\n", + "Episode 28 took: 10.880 s\n", + "\tNumber of steps in episode = 473\n", + "\tTotal reward = 2.5657937347404847\n", + "Episode 29 took: 11.481 s\n", + "\tNumber of steps in episode = 479\n", + "\tTotal reward = 2.6279668513699606\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_466717/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_466717/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", - "DEBUG:locator: \n" + "/tmp/ipykernel_94521/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_94521/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", + "DEBUG:locator: \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Episode 30 took: 25.601 s\n", - "\tNumber of steps in episode = 480\n", - "\tTotal reward = -2.0707537229392057\n", - "Episode 31 took: 27.051 s\n", + "Episode 30 took: 11.399 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -5.797468082776563\n", - "Episode 32 took: 26.863 s\n", + "\tTotal reward = -3.384320220067796\n", + "Episode 31 took: 13.640 s\n", + "\tNumber of steps in episode = 481\n", + "\tTotal reward = 3.616085028768447\n", + "Episode 32 took: 14.110 s\n", + "\tNumber of steps in episode = 490\n", + "\tTotal reward = 2.1357700712903664\n", + "Episode 33 took: 12.025 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -10.512519489314643\n", - "Episode 33 took: 27.274 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -5.742458908871843\n", - "Episode 34 took: 26.226 s\n", - "\tNumber of steps in episode = 460\n", - "\tTotal reward = -2.3096488520975944\n", - "Episode 35 took: 28.926 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -5.053005044676333\n", - "Episode 36 took: 28.562 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -3.7688145165822498\n", - "Episode 37 took: 29.804 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -6.767199467062796\n", - "Episode 38 took: 29.125 s\n", - "\tNumber of steps in episode = 491\n", - "\tTotal reward = -2.539055721169114\n", - "Episode 39 took: 29.308 s\n", - "\tNumber of steps in episode = 491\n", - "\tTotal reward = -1.634220915900104\n" + "\tTotal reward = -6.411110310144679\n", + "Episode 34 took: 17.872 s\n", + "\tNumber of steps in episode = 478\n", + "\tTotal reward = -6.533725626458156\n", + "Episode 35 took: 18.508 s\n", + "\tNumber of steps in episode = 459\n", + "\tTotal reward = 1.9349308218181434\n", + "Episode 36 took: 14.583 s\n", + "\tNumber of steps in episode = 492\n", + "\tTotal reward = 0.5230181736049531\n", + "Episode 37 took: 16.994 s\n", + "\tNumber of steps in episode = 497\n", + "\tTotal reward = 0.6642959097188439\n", + "Episode 38 took: 11.881 s\n", + "\tNumber of steps in episode = 405\n", + "\tTotal reward = 4.9408723019823055\n", + "Episode 39 took: 14.187 s\n", + "\tNumber of steps in episode = 495\n", + "\tTotal reward = 1.6476732815863748\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_466717/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_466717/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", - "DEBUG:locator: \n" + "/tmp/ipykernel_94521/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_94521/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", + "DEBUG:locator: \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Episode 40 took: 30.316 s\n", + "Episode 40 took: 14.596 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -10.829884359490437\n", - "Episode 41 took: 30.823 s\n", + "\tTotal reward = 0.38633393082653766\n", + "Episode 41 took: 14.086 s\n", + "\tNumber of steps in episode = 457\n", + "\tTotal reward = 2.4158343715341517\n", + "Episode 42 took: 15.169 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -5.933377528602501\n", - "Episode 42 took: 30.965 s\n", - "\tNumber of steps in episode = 483\n", - "\tTotal reward = -1.2283859896948104\n", - "Episode 43 took: 29.655 s\n", - "\tNumber of steps in episode = 454\n", - "\tTotal reward = -0.9775696618329375\n", - "Episode 44 took: 32.379 s\n", - "\tNumber of steps in episode = 491\n", - "\tTotal reward = -2.1502698667775784\n", - "Episode 45 took: 31.509 s\n", - "\tNumber of steps in episode = 484\n", - "\tTotal reward = -2.102920542307939\n", - "Episode 46 took: 32.146 s\n", - "\tNumber of steps in episode = 472\n", - "\tTotal reward = -0.9045579995110267\n", - "Episode 47 took: 32.240 s\n", - "\tNumber of steps in episode = 482\n", - "\tTotal reward = -1.3819170721571714\n", - "Episode 48 took: 33.800 s\n", + "\tTotal reward = -1.502273505512294\n", + "Episode 43 took: 14.705 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -1.6081728820230135\n", + "Episode 44 took: 14.568 s\n", + "\tNumber of steps in episode = 474\n", + "\tTotal reward = 4.012642709907481\n", + "Episode 45 took: 15.049 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -11.184655639188577\n", - "Episode 49 took: 35.395 s\n", + "\tTotal reward = -1.6299141470083702\n", + "Episode 46 took: 19.880 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -8.443552516839317\n" + "\tTotal reward = -5.417938044004686\n", + "Episode 47 took: 15.396 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -5.623624887836356\n", + "Episode 48 took: 15.449 s\n", + "\tNumber of steps in episode = 486\n", + "\tTotal reward = 3.199464312955735\n", + "Episode 49 took: 15.649 s\n", + "\tNumber of steps in episode = 499\n", + "\tTotal reward = -1.7155625577912286\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_466717/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_466717/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", - "DEBUG:locator: \n" + "/tmp/ipykernel_94521/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_94521/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", + "DEBUG:locator: \n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2995,7 +2999,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3093,7 +3097,6 @@ " #\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", - " step_reward += -.01\n", " agent.update_synaptic_weights(Q_new=Q_max,\n", " Q_old=Q_old,\n", " action=action,\n", @@ -3179,7 +3182,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 11, "id": "b999c031", "metadata": { "scrolled": false @@ -3205,7 +3208,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 12, "id": "6a68403e", "metadata": {}, "outputs": [ @@ -3438,13 +3441,7 @@ "Simulating: Pre-rate=78.9 s⁻¹, Post-rate=47.2 s⁻¹\n", "\t-> Actual pre rate: 76.0 s⁻¹\n", "\t-> Actual post rate: 52.0 s⁻¹\n", - "Simulating: Pre-rate=78.9 s⁻¹, Post-rate=57.8 s⁻¹\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Simulating: Pre-rate=78.9 s⁻¹, Post-rate=57.8 s⁻¹\n", "\t-> Actual pre rate: 75.0 s⁻¹\n", "\t-> Actual post rate: 72.0 s⁻¹\n", "Simulating: Pre-rate=78.9 s⁻¹, Post-rate=68.3 s⁻¹\n", @@ -3510,7 +3507,20 @@ "Simulating: Pre-rate=100.0 s⁻¹, Post-rate=68.3 s⁻¹\n", "\t-> Actual pre rate: 107.0 s⁻¹\n", "\t-> Actual post rate: 69.0 s⁻¹\n", - "Simulating: Pre-rate=100.0 s⁻¹, Post-rate=78.9 s⁻¹\n", + "Simulating: Pre-rate=100.0 s⁻¹, Post-rate=78.9 s⁻¹\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DEBUG:locator: \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "\t-> Actual pre rate: 107.0 s⁻¹\n", "\t-> Actual post rate: 97.0 s⁻¹\n", "Simulating: Pre-rate=100.0 s⁻¹, Post-rate=89.4 s⁻¹\n", @@ -3521,13 +3531,6 @@ "\t-> Actual post rate: 108.0 s⁻¹\n" ] }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:locator: \n" - ] - }, { "data": { "image/png": "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\n", @@ -3667,7 +3670,7 @@ }, { "cell_type": "markdown", - "id": "b52fae58", + "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." From 3a2f826db201d304065c8d6400ab5347e7d71323 Mon Sep 17 00:00:00 2001 From: "C.A.P. Linssen" Date: Thu, 19 Jun 2025 15:54:39 +0200 Subject: [PATCH 6/8] add mountain car reinforcement learning tutorial --- .github/workflows/nestml-build.yml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/.github/workflows/nestml-build.yml b/.github/workflows/nestml-build.yml index 8974d2d17..6beaa933b 100644 --- a/.github/workflows/nestml-build.yml +++ b/.github/workflows/nestml-build.yml @@ -278,6 +278,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' }} From 4dfea09e4ce0c7bce6bb3c84535f2270f5c3f6f9 Mon Sep 17 00:00:00 2001 From: "C.A.P. Linssen" Date: Fri, 25 Jul 2025 14:12:13 +0200 Subject: [PATCH 7/8] add mountain car reinforcement learning tutorial --- ...inforcement_learning_nestml_tutorial.ipynb | 671 +++++++++--------- 1 file changed, 337 insertions(+), 334 deletions(-) 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 index 7010debaa..2b44529e9 100644 --- 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 @@ -1038,7 +1038,9 @@ "\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" + "- Zero TD signal: Perfect prediction → no learning needed\n", + "\n", + "XXX: TODO: point out that there is no depression in the STDP synapse" ] }, { @@ -3201,6 +3203,8 @@ "source": [ "## Mechanistic explanation: why does this learning principle work?\n", "\n", + "XXX: point out difference between having depression and not having depression\n", + "\n", "For high firing rates, STDP basically becomes a purely rate-based rule: weights are predominantely potentiated (rather than depressed) for higher pre- and higher post-synaptic firing rates. The rule thus becomes a purely Hebbian learning rule.\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." @@ -3208,7 +3212,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "id": "6a68403e", "metadata": {}, "outputs": [ @@ -3217,323 +3221,316 @@ "output_type": "stream", "text": [ "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=5.0 s⁻¹\n", - "\t-> Actual pre rate: 6.0 s⁻¹\n", - "\t-> Actual post rate: 2.0 s⁻¹\n", - "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=15.6 s⁻¹\n", - "\t-> Actual pre rate: 2.0 s⁻¹\n", - "\t-> Actual post rate: 20.0 s⁻¹\n", - "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=26.1 s⁻¹\n", "\t-> Actual pre rate: 2.0 s⁻¹\n", - "\t-> Actual post rate: 28.0 s⁻¹\n", - "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=36.7 s⁻¹\n", - "\t-> Actual pre rate: 2.0 s⁻¹\n", - "\t-> Actual post rate: 37.0 s⁻¹\n", - "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=47.2 s⁻¹\n", - "\t-> Actual pre rate: 5.0 s⁻¹\n", - "\t-> Actual post rate: 47.0 s⁻¹\n", - "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=57.8 s⁻¹\n", + "\t-> Actual post rate: 6.0 s⁻¹\n", + "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=115.6 s⁻¹\n", "\t-> Actual pre rate: 4.0 s⁻¹\n", - "\t-> Actual post rate: 61.0 s⁻¹\n", - "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=68.3 s⁻¹\n", + "\t-> Actual post rate: 126.0 s⁻¹\n", + "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=226.1 s⁻¹\n", + "\t-> Actual pre rate: 6.0 s⁻¹\n", + "\t-> Actual post rate: 232.0 s⁻¹\n", + "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=336.7 s⁻¹\n", + "\t-> Actual pre rate: 6.0 s⁻¹\n", + "\t-> Actual post rate: 288.0 s⁻¹\n", + "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=447.2 s⁻¹\n", + "\t-> Actual pre rate: 6.0 s⁻¹\n", + "\t-> Actual post rate: 325.0 s⁻¹\n", + "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=557.8 s⁻¹\n", + "\t-> Actual pre rate: 5.0 s⁻¹\n", + "\t-> Actual post rate: 350.0 s⁻¹\n", + "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=668.3 s⁻¹\n", "\t-> Actual pre rate: 5.0 s⁻¹\n", - "\t-> Actual post rate: 71.0 s⁻¹\n", - "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=78.9 s⁻¹\n", + "\t-> Actual post rate: 369.0 s⁻¹\n", + "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=778.9 s⁻¹\n", "\t-> Actual pre rate: 3.0 s⁻¹\n", - "\t-> Actual post rate: 87.0 s⁻¹\n", - "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=89.4 s⁻¹\n", + "\t-> Actual post rate: 387.0 s⁻¹\n", + "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=889.4 s⁻¹\n", "\t-> Actual pre rate: 4.0 s⁻¹\n", - "\t-> Actual post rate: 104.0 s⁻¹\n", - "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=100.0 s⁻¹\n", + "\t-> Actual post rate: 396.0 s⁻¹\n", + "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=1000.0 s⁻¹\n", "\t-> Actual pre rate: 5.0 s⁻¹\n", - "\t-> Actual post rate: 114.0 s⁻¹\n", - "Simulating: Pre-rate=15.6 s⁻¹, Post-rate=5.0 s⁻¹\n", - "\t-> Actual pre rate: 14.0 s⁻¹\n", + "\t-> Actual post rate: 408.0 s⁻¹\n", + "Simulating: Pre-rate=115.6 s⁻¹, Post-rate=5.0 s⁻¹\n", + "\t-> Actual pre rate: 116.0 s⁻¹\n", "\t-> Actual post rate: 4.0 s⁻¹\n", - "Simulating: Pre-rate=15.6 s⁻¹, Post-rate=15.6 s⁻¹\n", - "\t-> Actual pre rate: 12.0 s⁻¹\n", - "\t-> Actual post rate: 18.0 s⁻¹\n", - "Simulating: Pre-rate=15.6 s⁻¹, Post-rate=26.1 s⁻¹\n", - "\t-> Actual pre rate: 13.0 s⁻¹\n", - "\t-> Actual post rate: 26.0 s⁻¹\n", - "Simulating: Pre-rate=15.6 s⁻¹, Post-rate=36.7 s⁻¹\n", - "\t-> Actual pre rate: 17.0 s⁻¹\n", - "\t-> Actual post rate: 37.0 s⁻¹\n", - "Simulating: Pre-rate=15.6 s⁻¹, Post-rate=47.2 s⁻¹\n", - "\t-> Actual pre rate: 17.0 s⁻¹\n", - "\t-> Actual post rate: 51.0 s⁻¹\n", - "Simulating: Pre-rate=15.6 s⁻¹, Post-rate=57.8 s⁻¹\n", - "\t-> Actual pre rate: 18.0 s⁻¹\n", - "\t-> Actual post rate: 63.0 s⁻¹\n", - "Simulating: Pre-rate=15.6 s⁻¹, Post-rate=68.3 s⁻¹\n", - "\t-> Actual pre rate: 13.0 s⁻¹\n", - "\t-> Actual post rate: 73.0 s⁻¹\n", - "Simulating: Pre-rate=15.6 s⁻¹, Post-rate=78.9 s⁻¹\n", - "\t-> Actual pre rate: 17.0 s⁻¹\n", - "\t-> Actual post rate: 87.0 s⁻¹\n", - "Simulating: Pre-rate=15.6 s⁻¹, Post-rate=89.4 s⁻¹\n", - "\t-> Actual pre rate: 16.0 s⁻¹\n", - "\t-> Actual post rate: 99.0 s⁻¹\n", - "Simulating: Pre-rate=15.6 s⁻¹, Post-rate=100.0 s⁻¹\n", - "\t-> Actual pre rate: 18.0 s⁻¹\n", - "\t-> Actual post rate: 103.0 s⁻¹\n", - "Simulating: Pre-rate=26.1 s⁻¹, Post-rate=5.0 s⁻¹\n", - "\t-> Actual pre rate: 25.0 s⁻¹\n", + "Simulating: Pre-rate=115.6 s⁻¹, Post-rate=115.6 s⁻¹\n", + "\t-> Actual pre rate: 134.0 s⁻¹\n", + "\t-> Actual post rate: 114.0 s⁻¹\n", + "Simulating: Pre-rate=115.6 s⁻¹, Post-rate=226.1 s⁻¹\n", + "\t-> Actual pre rate: 131.0 s⁻¹\n", + "\t-> Actual post rate: 232.0 s⁻¹\n", + "Simulating: Pre-rate=115.6 s⁻¹, Post-rate=336.7 s⁻¹\n", + "\t-> Actual pre rate: 127.0 s⁻¹\n", + "\t-> Actual post rate: 284.0 s⁻¹\n", + "Simulating: Pre-rate=115.6 s⁻¹, Post-rate=447.2 s⁻¹\n", + "\t-> Actual pre rate: 113.0 s⁻¹\n", + "\t-> Actual post rate: 326.0 s⁻¹\n", + "Simulating: Pre-rate=115.6 s⁻¹, Post-rate=557.8 s⁻¹\n", + "\t-> Actual pre rate: 116.0 s⁻¹\n", + "\t-> Actual post rate: 350.0 s⁻¹\n", + "Simulating: Pre-rate=115.6 s⁻¹, Post-rate=668.3 s⁻¹\n", + "\t-> Actual pre rate: 116.0 s⁻¹\n", + "\t-> Actual post rate: 370.0 s⁻¹\n", + "Simulating: Pre-rate=115.6 s⁻¹, Post-rate=778.9 s⁻¹\n", + "\t-> Actual pre rate: 118.0 s⁻¹\n", + "\t-> Actual post rate: 386.0 s⁻¹\n", + "Simulating: Pre-rate=115.6 s⁻¹, Post-rate=889.4 s⁻¹\n", + "\t-> Actual pre rate: 124.0 s⁻¹\n", + "\t-> Actual post rate: 396.0 s⁻¹\n", + "Simulating: Pre-rate=115.6 s⁻¹, Post-rate=1000.0 s⁻¹\n", + "\t-> Actual pre rate: 130.0 s⁻¹\n", + "\t-> Actual post rate: 407.0 s⁻¹\n", + "Simulating: Pre-rate=226.1 s⁻¹, Post-rate=5.0 s⁻¹\n", + "\t-> Actual pre rate: 243.0 s⁻¹\n", + "\t-> Actual post rate: 5.0 s⁻¹\n", + "Simulating: Pre-rate=226.1 s⁻¹, Post-rate=115.6 s⁻¹\n", + "\t-> Actual pre rate: 241.0 s⁻¹\n", + "\t-> Actual post rate: 142.0 s⁻¹\n", + "Simulating: Pre-rate=226.1 s⁻¹, Post-rate=226.1 s⁻¹\n", + "\t-> Actual pre rate: 263.0 s⁻¹\n", + "\t-> Actual post rate: 219.0 s⁻¹\n", + "Simulating: Pre-rate=226.1 s⁻¹, Post-rate=336.7 s⁻¹\n", + "\t-> Actual pre rate: 222.0 s⁻¹\n", + "\t-> Actual post rate: 289.0 s⁻¹\n", + "Simulating: Pre-rate=226.1 s⁻¹, Post-rate=447.2 s⁻¹\n", + "\t-> Actual pre rate: 230.0 s⁻¹\n", + "\t-> Actual post rate: 325.0 s⁻¹\n", + "Simulating: Pre-rate=226.1 s⁻¹, Post-rate=557.8 s⁻¹\n", + "\t-> Actual pre rate: 233.0 s⁻¹\n", + "\t-> Actual post rate: 351.0 s⁻¹\n", + "Simulating: Pre-rate=226.1 s⁻¹, Post-rate=668.3 s⁻¹\n", + "\t-> Actual pre rate: 236.0 s⁻¹\n", + "\t-> Actual post rate: 370.0 s⁻¹\n", + "Simulating: Pre-rate=226.1 s⁻¹, Post-rate=778.9 s⁻¹\n", + "\t-> Actual pre rate: 232.0 s⁻¹\n", + "\t-> Actual post rate: 387.0 s⁻¹\n", + "Simulating: Pre-rate=226.1 s⁻¹, Post-rate=889.4 s⁻¹\n", + "\t-> Actual pre rate: 236.0 s⁻¹\n", + "\t-> Actual post rate: 396.0 s⁻¹\n", + "Simulating: Pre-rate=226.1 s⁻¹, Post-rate=1000.0 s⁻¹\n", + "\t-> Actual pre rate: 236.0 s⁻¹\n", + "\t-> Actual post rate: 407.0 s⁻¹\n", + "Simulating: Pre-rate=336.7 s⁻¹, Post-rate=5.0 s⁻¹\n", + "\t-> Actual pre rate: 357.0 s⁻¹\n", "\t-> Actual post rate: 6.0 s⁻¹\n", - "Simulating: Pre-rate=26.1 s⁻¹, Post-rate=15.6 s⁻¹\n", - "\t-> Actual pre rate: 28.0 s⁻¹\n", - "\t-> Actual post rate: 14.0 s⁻¹\n", - "Simulating: Pre-rate=26.1 s⁻¹, Post-rate=26.1 s⁻¹\n", - "\t-> Actual pre rate: 27.0 s⁻¹\n", - "\t-> Actual post rate: 29.0 s⁻¹\n", - "Simulating: Pre-rate=26.1 s⁻¹, Post-rate=36.7 s⁻¹\n", - "\t-> Actual pre rate: 35.0 s⁻¹\n", - "\t-> Actual post rate: 37.0 s⁻¹\n", - "Simulating: Pre-rate=26.1 s⁻¹, Post-rate=47.2 s⁻¹\n", - "\t-> Actual pre rate: 28.0 s⁻¹\n", - "\t-> Actual post rate: 52.0 s⁻¹\n", - "Simulating: Pre-rate=26.1 s⁻¹, Post-rate=57.8 s⁻¹\n", - "\t-> Actual pre rate: 23.0 s⁻¹\n", - "\t-> Actual post rate: 62.0 s⁻¹\n", - "Simulating: Pre-rate=26.1 s⁻¹, Post-rate=68.3 s⁻¹\n", - "\t-> Actual pre rate: 25.0 s⁻¹\n", - "\t-> Actual post rate: 81.0 s⁻¹\n", - "Simulating: Pre-rate=26.1 s⁻¹, Post-rate=78.9 s⁻¹\n", - "\t-> Actual pre rate: 31.0 s⁻¹\n", - "\t-> Actual post rate: 88.0 s⁻¹\n", - "Simulating: Pre-rate=26.1 s⁻¹, Post-rate=89.4 s⁻¹\n", - "\t-> Actual pre rate: 32.0 s⁻¹\n", - "\t-> Actual post rate: 99.0 s⁻¹\n", - "Simulating: Pre-rate=26.1 s⁻¹, Post-rate=100.0 s⁻¹\n", - "\t-> Actual pre rate: 33.0 s⁻¹\n", - "\t-> Actual post rate: 115.0 s⁻¹\n", - "Simulating: Pre-rate=36.7 s⁻¹, Post-rate=5.0 s⁻¹\n", - "\t-> Actual pre rate: 33.0 s⁻¹\n", + "Simulating: Pre-rate=336.7 s⁻¹, Post-rate=115.6 s⁻¹\n", + "\t-> Actual pre rate: 349.0 s⁻¹\n", + "\t-> Actual post rate: 136.0 s⁻¹\n", + "Simulating: Pre-rate=336.7 s⁻¹, Post-rate=226.1 s⁻¹\n", + "\t-> Actual pre rate: 364.0 s⁻¹\n", + "\t-> Actual post rate: 219.0 s⁻¹\n", + "Simulating: Pre-rate=336.7 s⁻¹, Post-rate=336.7 s⁻¹\n", + "\t-> Actual pre rate: 351.0 s⁻¹\n", + "\t-> Actual post rate: 287.0 s⁻¹\n", + "Simulating: Pre-rate=336.7 s⁻¹, Post-rate=447.2 s⁻¹\n", + "\t-> Actual pre rate: 356.0 s⁻¹\n", + "\t-> Actual post rate: 319.0 s⁻¹\n", + "Simulating: Pre-rate=336.7 s⁻¹, Post-rate=557.8 s⁻¹\n", + "\t-> Actual pre rate: 333.0 s⁻¹\n", + "\t-> Actual post rate: 350.0 s⁻¹\n", + "Simulating: Pre-rate=336.7 s⁻¹, Post-rate=668.3 s⁻¹\n", + "\t-> Actual pre rate: 344.0 s⁻¹\n", + "\t-> Actual post rate: 372.0 s⁻¹\n", + "Simulating: Pre-rate=336.7 s⁻¹, Post-rate=778.9 s⁻¹\n", + "\t-> Actual pre rate: 343.0 s⁻¹\n", + "\t-> Actual post rate: 389.0 s⁻¹\n", + "Simulating: Pre-rate=336.7 s⁻¹, Post-rate=889.4 s⁻¹\n", + "\t-> Actual pre rate: 352.0 s⁻¹\n", + "\t-> Actual post rate: 397.0 s⁻¹\n", + "Simulating: Pre-rate=336.7 s⁻¹, Post-rate=1000.0 s⁻¹\n", + "\t-> Actual pre rate: 349.0 s⁻¹\n", + "\t-> Actual post rate: 408.0 s⁻¹\n", + "Simulating: Pre-rate=447.2 s⁻¹, Post-rate=5.0 s⁻¹\n", + "\t-> Actual pre rate: 454.0 s⁻¹\n", "\t-> Actual post rate: 6.0 s⁻¹\n", - "Simulating: Pre-rate=36.7 s⁻¹, Post-rate=15.6 s⁻¹\n", - "\t-> Actual pre rate: 32.0 s⁻¹\n", - "\t-> Actual post rate: 15.0 s⁻¹\n", - "Simulating: Pre-rate=36.7 s⁻¹, Post-rate=26.1 s⁻¹\n", - "\t-> Actual pre rate: 35.0 s⁻¹\n", - "\t-> Actual post rate: 26.0 s⁻¹\n", - "Simulating: Pre-rate=36.7 s⁻¹, Post-rate=36.7 s⁻¹\n", - "\t-> Actual pre rate: 34.0 s⁻¹\n", - "\t-> Actual post rate: 50.0 s⁻¹\n", - "Simulating: Pre-rate=36.7 s⁻¹, Post-rate=47.2 s⁻¹\n", - "\t-> Actual pre rate: 34.0 s⁻¹\n", - "\t-> Actual post rate: 55.0 s⁻¹\n", - "Simulating: Pre-rate=36.7 s⁻¹, Post-rate=57.8 s⁻¹\n", - "\t-> Actual pre rate: 35.0 s⁻¹\n", - "\t-> Actual post rate: 61.0 s⁻¹\n", - "Simulating: Pre-rate=36.7 s⁻¹, Post-rate=68.3 s⁻¹\n", - "\t-> Actual pre rate: 39.0 s⁻¹\n", - "\t-> Actual post rate: 72.0 s⁻¹\n", - "Simulating: Pre-rate=36.7 s⁻¹, Post-rate=78.9 s⁻¹\n", - "\t-> Actual pre rate: 44.0 s⁻¹\n", - "\t-> Actual post rate: 91.0 s⁻¹\n", - "Simulating: Pre-rate=36.7 s⁻¹, Post-rate=89.4 s⁻¹\n", - "\t-> Actual pre rate: 41.0 s⁻¹\n", - "\t-> Actual post rate: 103.0 s⁻¹\n", - "Simulating: Pre-rate=36.7 s⁻¹, Post-rate=100.0 s⁻¹\n", - "\t-> Actual pre rate: 38.0 s⁻¹\n", - "\t-> Actual post rate: 116.0 s⁻¹\n", - "Simulating: Pre-rate=47.2 s⁻¹, Post-rate=5.0 s⁻¹\n", - "\t-> Actual pre rate: 45.0 s⁻¹\n", - "\t-> Actual post rate: 3.0 s⁻¹\n", - "Simulating: Pre-rate=47.2 s⁻¹, Post-rate=15.6 s⁻¹\n", - "\t-> Actual pre rate: 43.0 s⁻¹\n", - "\t-> Actual post rate: 16.0 s⁻¹\n", - "Simulating: Pre-rate=47.2 s⁻¹, Post-rate=26.1 s⁻¹\n", - "\t-> Actual pre rate: 46.0 s⁻¹\n", - "\t-> Actual post rate: 24.0 s⁻¹\n", - "Simulating: Pre-rate=47.2 s⁻¹, Post-rate=36.7 s⁻¹\n", - "\t-> Actual pre rate: 52.0 s⁻¹\n", - "\t-> Actual post rate: 41.0 s⁻¹\n", - "Simulating: Pre-rate=47.2 s⁻¹, Post-rate=47.2 s⁻¹\n", - "\t-> Actual pre rate: 51.0 s⁻¹\n", - "\t-> Actual post rate: 48.0 s⁻¹\n", - "Simulating: Pre-rate=47.2 s⁻¹, Post-rate=57.8 s⁻¹\n", - "\t-> Actual pre rate: 43.0 s⁻¹\n", - "\t-> Actual post rate: 63.0 s⁻¹\n", - "Simulating: Pre-rate=47.2 s⁻¹, Post-rate=68.3 s⁻¹\n", - "\t-> Actual pre rate: 48.0 s⁻¹\n", - "\t-> Actual post rate: 77.0 s⁻¹\n", - "Simulating: Pre-rate=47.2 s⁻¹, Post-rate=78.9 s⁻¹\n", - "\t-> Actual pre rate: 49.0 s⁻¹\n", - "\t-> Actual post rate: 93.0 s⁻¹\n", - "Simulating: Pre-rate=47.2 s⁻¹, Post-rate=89.4 s⁻¹\n", - "\t-> Actual pre rate: 49.0 s⁻¹\n", - "\t-> Actual post rate: 112.0 s⁻¹\n", - "Simulating: Pre-rate=47.2 s⁻¹, Post-rate=100.0 s⁻¹\n", - "\t-> Actual pre rate: 48.0 s⁻¹\n", - "\t-> Actual post rate: 118.0 s⁻¹\n", - "Simulating: Pre-rate=57.8 s⁻¹, Post-rate=5.0 s⁻¹\n", - "\t-> Actual pre rate: 56.0 s⁻¹\n", - "\t-> Actual post rate: 4.0 s⁻¹\n", - "Simulating: Pre-rate=57.8 s⁻¹, Post-rate=15.6 s⁻¹\n", - "\t-> Actual pre rate: 56.0 s⁻¹\n", - "\t-> Actual post rate: 11.0 s⁻¹\n", - "Simulating: Pre-rate=57.8 s⁻¹, Post-rate=26.1 s⁻¹\n", - "\t-> Actual pre rate: 61.0 s⁻¹\n", - "\t-> Actual post rate: 28.0 s⁻¹\n", - "Simulating: Pre-rate=57.8 s⁻¹, Post-rate=36.7 s⁻¹\n", - "\t-> Actual pre rate: 56.0 s⁻¹\n", - "\t-> Actual post rate: 40.0 s⁻¹\n", - "Simulating: Pre-rate=57.8 s⁻¹, Post-rate=47.2 s⁻¹\n", - "\t-> Actual pre rate: 56.0 s⁻¹\n", - "\t-> Actual post rate: 54.0 s⁻¹\n", - "Simulating: Pre-rate=57.8 s⁻¹, Post-rate=57.8 s⁻¹\n", - "\t-> Actual pre rate: 58.0 s⁻¹\n", - "\t-> Actual post rate: 60.0 s⁻¹\n", - "Simulating: Pre-rate=57.8 s⁻¹, Post-rate=68.3 s⁻¹\n", - "\t-> Actual pre rate: 61.0 s⁻¹\n", - "\t-> Actual post rate: 72.0 s⁻¹\n", - "Simulating: Pre-rate=57.8 s⁻¹, Post-rate=78.9 s⁻¹\n", - "\t-> Actual pre rate: 53.0 s⁻¹\n", - "\t-> Actual post rate: 89.0 s⁻¹\n", - "Simulating: Pre-rate=57.8 s⁻¹, Post-rate=89.4 s⁻¹\n", - "\t-> Actual pre rate: 57.0 s⁻¹\n", - "\t-> Actual post rate: 106.0 s⁻¹\n", - "Simulating: Pre-rate=57.8 s⁻¹, Post-rate=100.0 s⁻¹\n", - "\t-> Actual pre rate: 54.0 s⁻¹\n", - "\t-> Actual post rate: 111.0 s⁻¹\n", - "Simulating: Pre-rate=68.3 s⁻¹, Post-rate=5.0 s⁻¹\n", - "\t-> Actual pre rate: 63.0 s⁻¹\n", - "\t-> Actual post rate: 4.0 s⁻¹\n", - "Simulating: Pre-rate=68.3 s⁻¹, Post-rate=15.6 s⁻¹\n", - "\t-> Actual pre rate: 67.0 s⁻¹\n", - "\t-> Actual post rate: 20.0 s⁻¹\n", - "Simulating: Pre-rate=68.3 s⁻¹, Post-rate=26.1 s⁻¹\n", - "\t-> Actual pre rate: 67.0 s⁻¹\n", - "\t-> Actual post rate: 26.0 s⁻¹\n", - "Simulating: Pre-rate=68.3 s⁻¹, Post-rate=36.7 s⁻¹\n", - "\t-> Actual pre rate: 72.0 s⁻¹\n", - "\t-> Actual post rate: 37.0 s⁻¹\n", - "Simulating: Pre-rate=68.3 s⁻¹, Post-rate=47.2 s⁻¹\n", - "\t-> Actual pre rate: 68.0 s⁻¹\n", - "\t-> Actual post rate: 49.0 s⁻¹\n", - "Simulating: Pre-rate=68.3 s⁻¹, Post-rate=57.8 s⁻¹\n", - "\t-> Actual pre rate: 66.0 s⁻¹\n", - "\t-> Actual post rate: 60.0 s⁻¹\n", - "Simulating: Pre-rate=68.3 s⁻¹, Post-rate=68.3 s⁻¹\n", - "\t-> Actual pre rate: 62.0 s⁻¹\n", - "\t-> Actual post rate: 85.0 s⁻¹\n", - "Simulating: Pre-rate=68.3 s⁻¹, Post-rate=78.9 s⁻¹\n", - "\t-> Actual pre rate: 66.0 s⁻¹\n", - "\t-> Actual post rate: 93.0 s⁻¹\n", - "Simulating: Pre-rate=68.3 s⁻¹, Post-rate=89.4 s⁻¹\n", - "\t-> Actual pre rate: 60.0 s⁻¹\n", - "\t-> Actual post rate: 107.0 s⁻¹\n", - "Simulating: Pre-rate=68.3 s⁻¹, Post-rate=100.0 s⁻¹\n", - "\t-> Actual pre rate: 66.0 s⁻¹\n", - "\t-> Actual post rate: 110.0 s⁻¹\n", - "Simulating: Pre-rate=78.9 s⁻¹, Post-rate=5.0 s⁻¹\n", - "\t-> Actual pre rate: 84.0 s⁻¹\n", - "\t-> Actual post rate: 3.0 s⁻¹\n", - "Simulating: Pre-rate=78.9 s⁻¹, Post-rate=15.6 s⁻¹\n", - "\t-> Actual pre rate: 76.0 s⁻¹\n", - "\t-> Actual post rate: 14.0 s⁻¹\n", - "Simulating: Pre-rate=78.9 s⁻¹, Post-rate=26.1 s⁻¹\n", - "\t-> Actual pre rate: 84.0 s⁻¹\n", - "\t-> Actual post rate: 28.0 s⁻¹\n", - "Simulating: Pre-rate=78.9 s⁻¹, Post-rate=36.7 s⁻¹\n", - "\t-> Actual pre rate: 75.0 s⁻¹\n", - "\t-> Actual post rate: 47.0 s⁻¹\n", - "Simulating: Pre-rate=78.9 s⁻¹, Post-rate=47.2 s⁻¹\n", - "\t-> Actual pre rate: 76.0 s⁻¹\n", - "\t-> Actual post rate: 52.0 s⁻¹\n", - "Simulating: Pre-rate=78.9 s⁻¹, Post-rate=57.8 s⁻¹\n", - "\t-> Actual pre rate: 75.0 s⁻¹\n", - "\t-> Actual post rate: 72.0 s⁻¹\n", - "Simulating: Pre-rate=78.9 s⁻¹, Post-rate=68.3 s⁻¹\n", - "\t-> Actual pre rate: 84.0 s⁻¹\n", - "\t-> Actual post rate: 71.0 s⁻¹\n", - "Simulating: Pre-rate=78.9 s⁻¹, Post-rate=78.9 s⁻¹\n", - "\t-> Actual pre rate: 76.0 s⁻¹\n", - "\t-> Actual post rate: 95.0 s⁻¹\n", - "Simulating: Pre-rate=78.9 s⁻¹, Post-rate=89.4 s⁻¹\n", - "\t-> Actual pre rate: 87.0 s⁻¹\n", - "\t-> Actual post rate: 95.0 s⁻¹\n", - "Simulating: Pre-rate=78.9 s⁻¹, Post-rate=100.0 s⁻¹\n", - "\t-> Actual pre rate: 75.0 s⁻¹\n", - "\t-> Actual post rate: 121.0 s⁻¹\n", - "Simulating: Pre-rate=89.4 s⁻¹, Post-rate=5.0 s⁻¹\n", - "\t-> Actual pre rate: 90.0 s⁻¹\n", + "Simulating: Pre-rate=447.2 s⁻¹, Post-rate=115.6 s⁻¹\n", + "\t-> Actual pre rate: 462.0 s⁻¹\n", + "\t-> Actual post rate: 122.0 s⁻¹\n", + "Simulating: Pre-rate=447.2 s⁻¹, Post-rate=226.1 s⁻¹\n", + "\t-> Actual pre rate: 450.0 s⁻¹\n", + "\t-> Actual post rate: 224.0 s⁻¹\n", + "Simulating: Pre-rate=447.2 s⁻¹, Post-rate=336.7 s⁻¹\n", + "\t-> Actual pre rate: 440.0 s⁻¹\n", + "\t-> Actual post rate: 290.0 s⁻¹\n", + "Simulating: Pre-rate=447.2 s⁻¹, Post-rate=447.2 s⁻¹\n", + "\t-> Actual pre rate: 439.0 s⁻¹\n", + "\t-> Actual post rate: 329.0 s⁻¹\n", + "Simulating: Pre-rate=447.2 s⁻¹, Post-rate=557.8 s⁻¹\n", + "\t-> Actual pre rate: 437.0 s⁻¹\n", + "\t-> Actual post rate: 354.0 s⁻¹\n", + "Simulating: Pre-rate=447.2 s⁻¹, Post-rate=668.3 s⁻¹\n", + "\t-> Actual pre rate: 449.0 s⁻¹\n", + "\t-> Actual post rate: 371.0 s⁻¹\n", + "Simulating: Pre-rate=447.2 s⁻¹, Post-rate=778.9 s⁻¹\n", + "\t-> Actual pre rate: 434.0 s⁻¹\n", + "\t-> Actual post rate: 389.0 s⁻¹\n", + "Simulating: Pre-rate=447.2 s⁻¹, Post-rate=889.4 s⁻¹\n", + "\t-> Actual pre rate: 431.0 s⁻¹\n", + "\t-> Actual post rate: 399.0 s⁻¹\n", + "Simulating: Pre-rate=447.2 s⁻¹, Post-rate=1000.0 s⁻¹\n", + "\t-> Actual pre rate: 424.0 s⁻¹\n", + "\t-> Actual post rate: 410.0 s⁻¹\n", + "Simulating: Pre-rate=557.8 s⁻¹, Post-rate=5.0 s⁻¹\n", + "\t-> Actual pre rate: 559.0 s⁻¹\n", + "\t-> Actual post rate: 5.0 s⁻¹\n", + "Simulating: Pre-rate=557.8 s⁻¹, Post-rate=115.6 s⁻¹\n", + "\t-> Actual pre rate: 560.0 s⁻¹\n", + "\t-> Actual post rate: 122.0 s⁻¹\n", + "Simulating: Pre-rate=557.8 s⁻¹, Post-rate=226.1 s⁻¹\n", + "\t-> Actual pre rate: 561.0 s⁻¹\n", + "\t-> Actual post rate: 230.0 s⁻¹\n", + "Simulating: Pre-rate=557.8 s⁻¹, Post-rate=336.7 s⁻¹\n", + "\t-> Actual pre rate: 564.0 s⁻¹\n", + "\t-> Actual post rate: 281.0 s⁻¹\n", + "Simulating: Pre-rate=557.8 s⁻¹, Post-rate=447.2 s⁻¹\n", + "\t-> Actual pre rate: 571.0 s⁻¹\n", + "\t-> Actual post rate: 316.0 s⁻¹\n", + "Simulating: Pre-rate=557.8 s⁻¹, Post-rate=557.8 s⁻¹\n", + "\t-> Actual pre rate: 544.0 s⁻¹\n", + "\t-> Actual post rate: 358.0 s⁻¹\n", + "Simulating: Pre-rate=557.8 s⁻¹, Post-rate=668.3 s⁻¹\n", + "\t-> Actual pre rate: 550.0 s⁻¹\n", + "\t-> Actual post rate: 373.0 s⁻¹\n", + "Simulating: Pre-rate=557.8 s⁻¹, Post-rate=778.9 s⁻¹\n", + "\t-> Actual pre rate: 546.0 s⁻¹\n", + "\t-> Actual post rate: 390.0 s⁻¹\n", + "Simulating: Pre-rate=557.8 s⁻¹, Post-rate=889.4 s⁻¹\n", + "\t-> Actual pre rate: 555.0 s⁻¹\n", + "\t-> Actual post rate: 398.0 s⁻¹\n", + "Simulating: Pre-rate=557.8 s⁻¹, Post-rate=1000.0 s⁻¹\n", + "\t-> Actual pre rate: 549.0 s⁻¹\n", + "\t-> Actual post rate: 410.0 s⁻¹\n", + "Simulating: Pre-rate=668.3 s⁻¹, Post-rate=5.0 s⁻¹\n", + "\t-> Actual pre rate: 671.0 s⁻¹\n", + "\t-> Actual post rate: 5.0 s⁻¹\n", + "Simulating: Pre-rate=668.3 s⁻¹, Post-rate=115.6 s⁻¹\n", + "\t-> Actual pre rate: 672.0 s⁻¹\n", + "\t-> Actual post rate: 124.0 s⁻¹\n", + "Simulating: Pre-rate=668.3 s⁻¹, Post-rate=226.1 s⁻¹\n", + "\t-> Actual pre rate: 662.0 s⁻¹\n", + "\t-> Actual post rate: 229.0 s⁻¹\n", + "Simulating: Pre-rate=668.3 s⁻¹, Post-rate=336.7 s⁻¹\n", + "\t-> Actual pre rate: 671.0 s⁻¹\n", + "\t-> Actual post rate: 287.0 s⁻¹\n", + "Simulating: Pre-rate=668.3 s⁻¹, Post-rate=447.2 s⁻¹\n", + "\t-> Actual pre rate: 678.0 s⁻¹\n", + "\t-> Actual post rate: 325.0 s⁻¹\n", + "Simulating: Pre-rate=668.3 s⁻¹, Post-rate=557.8 s⁻¹\n", + "\t-> Actual pre rate: 684.0 s⁻¹\n", + "\t-> Actual post rate: 351.0 s⁻¹\n", + "Simulating: Pre-rate=668.3 s⁻¹, Post-rate=668.3 s⁻¹\n", + "\t-> Actual pre rate: 681.0 s⁻¹\n", + "\t-> Actual post rate: 375.0 s⁻¹\n", + "Simulating: Pre-rate=668.3 s⁻¹, Post-rate=778.9 s⁻¹\n", + "\t-> Actual pre rate: 709.0 s⁻¹\n", + "\t-> Actual post rate: 383.0 s⁻¹\n", + "Simulating: Pre-rate=668.3 s⁻¹, Post-rate=889.4 s⁻¹\n", + "\t-> Actual pre rate: 684.0 s⁻¹\n", + "\t-> Actual post rate: 396.0 s⁻¹\n", + "Simulating: Pre-rate=668.3 s⁻¹, Post-rate=1000.0 s⁻¹\n", + "\t-> Actual pre rate: 666.0 s⁻¹\n", + "\t-> Actual post rate: 407.0 s⁻¹\n", + "Simulating: Pre-rate=778.9 s⁻¹, Post-rate=5.0 s⁻¹\n", + "\t-> Actual pre rate: 800.0 s⁻¹\n", "\t-> Actual post rate: 3.0 s⁻¹\n", - "Simulating: Pre-rate=89.4 s⁻¹, Post-rate=15.6 s⁻¹\n", - "\t-> Actual pre rate: 100.0 s⁻¹\n", - "\t-> Actual post rate: 12.0 s⁻¹\n", - "Simulating: Pre-rate=89.4 s⁻¹, Post-rate=26.1 s⁻¹\n", - "\t-> Actual pre rate: 93.0 s⁻¹\n", - "\t-> Actual post rate: 32.0 s⁻¹\n", - "Simulating: Pre-rate=89.4 s⁻¹, Post-rate=36.7 s⁻¹\n", - "\t-> Actual pre rate: 93.0 s⁻¹\n", - "\t-> Actual post rate: 36.0 s⁻¹\n", - "Simulating: Pre-rate=89.4 s⁻¹, Post-rate=47.2 s⁻¹\n", - "\t-> Actual pre rate: 92.0 s⁻¹\n", - "\t-> Actual post rate: 54.0 s⁻¹\n", - "Simulating: Pre-rate=89.4 s⁻¹, Post-rate=57.8 s⁻¹\n", - "\t-> Actual pre rate: 97.0 s⁻¹\n", - "\t-> Actual post rate: 60.0 s⁻¹\n", - "Simulating: Pre-rate=89.4 s⁻¹, Post-rate=68.3 s⁻¹\n", - "\t-> Actual pre rate: 93.0 s⁻¹\n", - "\t-> Actual post rate: 76.0 s⁻¹\n", - "Simulating: Pre-rate=89.4 s⁻¹, Post-rate=78.9 s⁻¹\n", - "\t-> Actual pre rate: 99.0 s⁻¹\n", - "\t-> Actual post rate: 84.0 s⁻¹\n", - "Simulating: Pre-rate=89.4 s⁻¹, Post-rate=89.4 s⁻¹\n", - "\t-> Actual pre rate: 81.0 s⁻¹\n", - "\t-> Actual post rate: 114.0 s⁻¹\n", - "Simulating: Pre-rate=89.4 s⁻¹, Post-rate=100.0 s⁻¹\n", - "\t-> Actual pre rate: 94.0 s⁻¹\n", - "\t-> Actual post rate: 113.0 s⁻¹\n", - "Simulating: Pre-rate=100.0 s⁻¹, Post-rate=5.0 s⁻¹\n", - "\t-> Actual pre rate: 109.0 s⁻¹\n", - "\t-> Actual post rate: 4.0 s⁻¹\n", - "Simulating: Pre-rate=100.0 s⁻¹, Post-rate=15.6 s⁻¹\n", - "\t-> Actual pre rate: 107.0 s⁻¹\n", - "\t-> Actual post rate: 16.0 s⁻¹\n", - "Simulating: Pre-rate=100.0 s⁻¹, Post-rate=26.1 s⁻¹\n", - "\t-> Actual pre rate: 111.0 s⁻¹\n", - "\t-> Actual post rate: 22.0 s⁻¹\n", - "Simulating: Pre-rate=100.0 s⁻¹, Post-rate=36.7 s⁻¹\n", - "\t-> Actual pre rate: 97.0 s⁻¹\n", - "\t-> Actual post rate: 47.0 s⁻¹\n", - "Simulating: Pre-rate=100.0 s⁻¹, Post-rate=47.2 s⁻¹\n", - "\t-> Actual pre rate: 105.0 s⁻¹\n", - "\t-> Actual post rate: 62.0 s⁻¹\n", - "Simulating: Pre-rate=100.0 s⁻¹, Post-rate=57.8 s⁻¹\n", - "\t-> Actual pre rate: 104.0 s⁻¹\n", - "\t-> Actual post rate: 67.0 s⁻¹\n", - "Simulating: Pre-rate=100.0 s⁻¹, Post-rate=68.3 s⁻¹\n", - "\t-> Actual pre rate: 107.0 s⁻¹\n", - "\t-> Actual post rate: 69.0 s⁻¹\n", - "Simulating: Pre-rate=100.0 s⁻¹, Post-rate=78.9 s⁻¹\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:locator: \n" + "Simulating: Pre-rate=778.9 s⁻¹, Post-rate=115.6 s⁻¹\n", + "\t-> Actual pre rate: 789.0 s⁻¹\n", + "\t-> Actual post rate: 123.0 s⁻¹\n", + "Simulating: Pre-rate=778.9 s⁻¹, Post-rate=226.1 s⁻¹\n", + "\t-> Actual pre rate: 794.0 s⁻¹\n", + "\t-> Actual post rate: 228.0 s⁻¹\n", + "Simulating: Pre-rate=778.9 s⁻¹, Post-rate=336.7 s⁻¹\n", + "\t-> Actual pre rate: 795.0 s⁻¹\n", + "\t-> Actual post rate: 290.0 s⁻¹\n", + "Simulating: Pre-rate=778.9 s⁻¹, Post-rate=447.2 s⁻¹\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\t-> Actual pre rate: 107.0 s⁻¹\n", - "\t-> Actual post rate: 97.0 s⁻¹\n", - "Simulating: Pre-rate=100.0 s⁻¹, Post-rate=89.4 s⁻¹\n", - "\t-> Actual pre rate: 110.0 s⁻¹\n", - "\t-> Actual post rate: 94.0 s⁻¹\n", - "Simulating: Pre-rate=100.0 s⁻¹, Post-rate=100.0 s⁻¹\n", - "\t-> Actual pre rate: 106.0 s⁻¹\n", - "\t-> Actual post rate: 108.0 s⁻¹\n" + "\t-> Actual pre rate: 804.0 s⁻¹\n", + "\t-> Actual post rate: 322.0 s⁻¹\n", + "Simulating: Pre-rate=778.9 s⁻¹, Post-rate=557.8 s⁻¹\n", + "\t-> Actual pre rate: 805.0 s⁻¹\n", + "\t-> Actual post rate: 348.0 s⁻¹\n", + "Simulating: Pre-rate=778.9 s⁻¹, Post-rate=668.3 s⁻¹\n", + "\t-> Actual pre rate: 754.0 s⁻¹\n", + "\t-> Actual post rate: 375.0 s⁻¹\n", + "Simulating: Pre-rate=778.9 s⁻¹, Post-rate=778.9 s⁻¹\n", + "\t-> Actual pre rate: 767.0 s⁻¹\n", + "\t-> Actual post rate: 389.0 s⁻¹\n", + "Simulating: Pre-rate=778.9 s⁻¹, Post-rate=889.4 s⁻¹\n", + "\t-> Actual pre rate: 758.0 s⁻¹\n", + "\t-> Actual post rate: 400.0 s⁻¹\n", + "Simulating: Pre-rate=778.9 s⁻¹, Post-rate=1000.0 s⁻¹\n", + "\t-> Actual pre rate: 758.0 s⁻¹\n", + "\t-> Actual post rate: 409.0 s⁻¹\n", + "Simulating: Pre-rate=889.4 s⁻¹, Post-rate=5.0 s⁻¹\n", + "\t-> Actual pre rate: 877.0 s⁻¹\n", + "\t-> Actual post rate: 3.0 s⁻¹\n", + "Simulating: Pre-rate=889.4 s⁻¹, Post-rate=115.6 s⁻¹\n", + "\t-> Actual pre rate: 882.0 s⁻¹\n", + "\t-> Actual post rate: 133.0 s⁻¹\n", + "Simulating: Pre-rate=889.4 s⁻¹, Post-rate=226.1 s⁻¹\n", + "\t-> Actual pre rate: 888.0 s⁻¹\n", + "\t-> Actual post rate: 232.0 s⁻¹\n", + "Simulating: Pre-rate=889.4 s⁻¹, Post-rate=336.7 s⁻¹\n", + "\t-> Actual pre rate: 894.0 s⁻¹\n", + "\t-> Actual post rate: 294.0 s⁻¹\n", + "Simulating: Pre-rate=889.4 s⁻¹, Post-rate=447.2 s⁻¹\n", + "\t-> Actual pre rate: 911.0 s⁻¹\n", + "\t-> Actual post rate: 322.0 s⁻¹\n", + "Simulating: Pre-rate=889.4 s⁻¹, Post-rate=557.8 s⁻¹\n", + "\t-> Actual pre rate: 895.0 s⁻¹\n", + "\t-> Actual post rate: 351.0 s⁻¹\n", + "Simulating: Pre-rate=889.4 s⁻¹, Post-rate=668.3 s⁻¹\n", + "\t-> Actual pre rate: 885.0 s⁻¹\n", + "\t-> Actual post rate: 374.0 s⁻¹\n", + "Simulating: Pre-rate=889.4 s⁻¹, Post-rate=778.9 s⁻¹\n", + "\t-> Actual pre rate: 927.0 s⁻¹\n", + "\t-> Actual post rate: 383.0 s⁻¹\n", + "Simulating: Pre-rate=889.4 s⁻¹, Post-rate=889.4 s⁻¹\n", + "\t-> Actual pre rate: 901.0 s⁻¹\n", + "\t-> Actual post rate: 396.0 s⁻¹\n", + "Simulating: Pre-rate=889.4 s⁻¹, Post-rate=1000.0 s⁻¹\n", + "\t-> Actual pre rate: 870.0 s⁻¹\n", + "\t-> Actual post rate: 408.0 s⁻¹\n", + "Simulating: Pre-rate=1000.0 s⁻¹, Post-rate=5.0 s⁻¹\n", + "\t-> Actual pre rate: 1022.0 s⁻¹\n", + "\t-> Actual post rate: 5.0 s⁻¹\n", + "Simulating: Pre-rate=1000.0 s⁻¹, Post-rate=115.6 s⁻¹\n", + "\t-> Actual pre rate: 1017.0 s⁻¹\n", + "\t-> Actual post rate: 138.0 s⁻¹\n", + "Simulating: Pre-rate=1000.0 s⁻¹, Post-rate=226.1 s⁻¹\n", + "\t-> Actual pre rate: 1017.0 s⁻¹\n", + "\t-> Actual post rate: 231.0 s⁻¹\n", + "Simulating: Pre-rate=1000.0 s⁻¹, Post-rate=336.7 s⁻¹\n", + "\t-> Actual pre rate: 1016.0 s⁻¹\n", + "\t-> Actual post rate: 290.0 s⁻¹\n", + "Simulating: Pre-rate=1000.0 s⁻¹, Post-rate=447.2 s⁻¹\n", + "\t-> Actual pre rate: 1045.0 s⁻¹\n", + "\t-> Actual post rate: 320.0 s⁻¹\n", + "Simulating: Pre-rate=1000.0 s⁻¹, Post-rate=557.8 s⁻¹\n", + "\t-> Actual pre rate: 1033.0 s⁻¹\n", + "\t-> Actual post rate: 351.0 s⁻¹\n", + "Simulating: Pre-rate=1000.0 s⁻¹, Post-rate=668.3 s⁻¹\n", + "\t-> Actual pre rate: 1023.0 s⁻¹\n", + "\t-> Actual post rate: 370.0 s⁻¹\n", + "Simulating: Pre-rate=1000.0 s⁻¹, Post-rate=778.9 s⁻¹\n", + "\t-> Actual pre rate: 1052.0 s⁻¹\n", + "\t-> Actual post rate: 384.0 s⁻¹\n", + "Simulating: Pre-rate=1000.0 s⁻¹, Post-rate=889.4 s⁻¹\n", + "\t-> Actual pre rate: 1026.0 s⁻¹\n", + "\t-> Actual post rate: 393.0 s⁻¹\n", + "Simulating: Pre-rate=1000.0 s⁻¹, Post-rate=1000.0 s⁻¹\n", + "\t-> Actual pre rate: 1039.0 s⁻¹\n", + "\t-> Actual post rate: 406.0 s⁻¹\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3543,46 +3540,48 @@ } ], "source": [ - "# --- Simulation Parameters ---\n", - "# Duration of each individual simulation\n", - "duration = 1000. # ms\n", - "# Simulation time step\n", - "dt = 0.1 # ms\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", - "# --- STDP Synapse Parameters ---\n", "# This script uses NEST's standard 'stdp_synapse' model.\n", - "# Note: In the standard asymmetric model, tau_plus is for LTP and tau_minus is for LTD.\n", - "tau_plus = 20.0 # LTP time window (τ+), corresponds to tau_post in the original script\n", - "tau_minus = 20.0 # LTD time window (τ-), corresponds to tau_pre in the original script\n", - "A_plus = 0.001 # LTP amplitude change (NEST's 'lambda'), from A_post\n", - "A_minus = 0.001 # LTD amplitude change (NEST's 'alpha'), from A_pre\n", - "w_max = 1.0 # Maximum synaptic weight\n", + "learning_rate = 0.001 # LTP/LTD amplitude change (NEST's 'lambda')\n", + "alpha = 1. # ratio between LTP and LTD amplitude change (NEST's 'lambda')\n", + "w_max = 1. # Maximum synaptic weight\n", "initial_weight = 0.5 # Starting weight for the synapse\n", "\n", - "# --- Firing Rate Parameters ---\n", + "#\n", + "# Firing rate parameters\n", + "#\n", + "\n", "# Range of firing rates to test (in s⁻¹)\n", - "pre_rates = np.linspace(5.0, 100.0, 10)\n", - "post_rates = np.linspace(5.0, 100.0, 10)\n", + "pre_rates = np.linspace(5, 100, 10)\n", + "post_rates = np.linspace(5, 100, 10)\n", "\n", - "# --- Result Matrix ---\n", - "# Initialize a matrix to store the final weight change for each rate pair\n", - "weight_changes = np.zeros((len(pre_rates), len(post_rates)))\n", + "#\n", + "# Main loop\n", + "#\n", "\n", - "# --- NEST Simulation Loop ---\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", " print(f\"Simulating: Pre-rate={pre_rate:.1f} s⁻¹, Post-rate={post_rate:.1f} s⁻¹\")\n", "\n", - " # --- Reset NEST Kernel ---\n", - " # Ensures that each simulation run is independent and starts from a clean state\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", - " # Suppress NEST's progress output for a cleaner console\n", - " nest.print_time = False\n", - " nest.local_num_threads = 1 # Ensures reproducibility for this script\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", + " # 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", @@ -3605,24 +3604,28 @@ " # --- Configure Synapse Model ---\n", " # Define the parameters for NEST's built-in STDP synapse model\n", " stdp_params = {\n", - " \"lambda\": A_plus, # Potentiation step\n", - " \"alpha\": A_minus, # Depression step (as a positive factor)\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", + " nest.CopyModel(\"stdp_synapse\", \"custom_stdp_synapse\", params=stdp_params)\n", "\n", - " nest.Connect(pre_parrot, post_neuron, syn_spec={\"synapse_model\": \"stdp_synapse\"})\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", - " # --- Get Initial Weight ---\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", - " # --- Run Simulation ---\n", " nest.Simulate(duration)\n", " \n", " assert len(sr_pre.events[\"times\"]) > 0\n", @@ -3630,15 +3633,15 @@ " assert len(sr_post.events[\"times\"]) > 0\n", " print(\"\\t-> Actual post rate: \" + str(len(sr_post.events[\"times\"]) / (duration / 1000)) + \" s⁻¹\")\n", "\n", - " # --- Get Final Weight ---\n", " # Retrieve the weight after the simulation has finished\n", " final_w = nest.GetStatus(connection, \"weight\")[0]\n", - "\n", - " # --- Store Result ---\n", " weight_changes[i, j] = final_w - initial_w\n", "\n", "\n", - "# --- Plotting Results ---\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", From 13743b66e2892a03e33d2824d9ca06a86410865b Mon Sep 17 00:00:00 2001 From: "C.A.P. Linssen" Date: Sat, 26 Jul 2025 13:24:21 +0200 Subject: [PATCH 8/8] add mountain car reinforcement learning tutorial --- ...inforcement_learning_nestml_tutorial.ipynb | 2394 ++++------------- 1 file changed, 491 insertions(+), 1903 deletions(-) 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 index 2b44529e9..92f472289 100644 --- 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 @@ -1,43 +1,25 @@ { "cells": [ - { - "cell_type": "markdown", - "id": "f763ff4e", - "metadata": {}, - "source": [ - "# Solving the \"mountain car\" task using NESTML\n" - ] - }, { "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." - ] - }, - { - "cell_type": "markdown", - "id": "0885d90c", - "metadata": {}, - "source": [ - "## Mountain car environment" - ] - }, - { - "cell_type": "markdown", - "id": "3e9c0bfe", - "metadata": {}, - "source": [ + "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 physics system\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]." ] @@ -192,7 +174,7 @@ " position, velocity = self.state\n", " assert action in AgentAction, \"Invalid action\"\n", "\n", - " # --- Physics Update (Forward Euler) ---\n", + " # Physics update\n", " force = 0.\n", " if action == AgentAction.LEFT:\n", " force = -self.force_mag\n", @@ -205,7 +187,7 @@ " position += velocity * self.dt\n", " position = max(self.min_position, min(self.max_position, position)) # Clamp position\n", "\n", - " # --- Check for Goal ---\n", + " # Check for goal\n", " done = bool(position >= self.goal_position or position <= self.min_position)\n", "\n", " self.state = (position, velocity)\n", @@ -514,7 +496,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 6, "id": "eb4dab99", "metadata": {}, "outputs": [], @@ -545,13 +527,13 @@ " 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", + " # 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", + " # 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", @@ -586,7 +568,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 7, "id": "3f9b07a1", "metadata": {}, "outputs": [], @@ -691,7 +673,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 8, "id": "717eda26-e385-494f-bdca-9847eefe01ca", "metadata": {}, "outputs": [ @@ -699,215 +681,215 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_495062/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/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.50, Avg Reward (Last 100): -506.07, p_explore: 0.4954\n" + "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_495062/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/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: -505.14, Avg Reward (Last 100): -491.17, p_explore: 0.2454\n" + "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_495062/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/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: -481.72, Avg Reward (Last 100): -458.79, p_explore: 0.1216\n" + "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_495062/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/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: -355.78, Avg Reward (Last 100): -382.86, p_explore: 0.0602\n" + "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_495062/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/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: -347.04, Avg Reward (Last 100): -435.51, p_explore: 0.0298\n" + "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_495062/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/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: -362.93, Avg Reward (Last 100): -328.22, p_explore: 0.0148\n" + "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_495062/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/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: -212.66, Avg Reward (Last 100): -296.76, p_explore: 0.0000\n" + "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_495062/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/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: -297.14, Avg Reward (Last 100): -295.55, p_explore: 0.0000\n" + "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_495062/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/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: -247.92, Avg Reward (Last 100): -279.87, p_explore: 0.0000\n" + "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_495062/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/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: -296.33, Avg Reward (Last 100): -271.56, p_explore: 0.0000\n" + "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_495062/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/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: -261.17, Avg Reward (Last 100): -269.62, p_explore: 0.0000\n" + "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_495062/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/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: -243.95, Avg Reward (Last 100): -244.42, p_explore: 0.0000\n" + "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_495062/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/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: -242.92, Avg Reward (Last 100): -233.84, p_explore: 0.0000\n" + "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_495062/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/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: -244.06, Avg Reward (Last 100): -231.38, p_explore: 0.0000\n" + "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_495062/3251491258.py:23: UserWarning:Attempt to set non-positive ylim on a log-scaled axis will be ignored.\n" + "/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: -242.84, Avg Reward (Last 100): -231.57, p_explore: 0.0000\n" + "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1000,9 +982,7 @@ "id": "7add07c7", "metadata": {}, "source": [ - "\n", - "\n", - "TODO: Make plot of how much q values changed from before training to after training. Are there certain boxes that never get updated? i.e. is the state space (configuration space) adequately explored?\n" + "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)?" ] }, { @@ -1015,45 +995,138 @@ }, { "cell_type": "markdown", - "id": "d4705cf6", + "id": "6df6e192", "metadata": {}, "source": [ - "## Idea" + "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": "6df6e192", + "id": "8dc47382", "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 40ms to provide the effect that they run simultaneously.\n", - "The model's structure consists of two layers of neurons. For each discrete state of the system, the input layer contains a single neuron corresponding to it. Neuromodulated synapses connect these to the output layer, which itself consists of two neuron groups interpreted as actions \"move left\" and \"move right\" respectively.\n", "\n", - "One simulation step of the SNN works as follows:\n", - "1. Get the current state of the cart pole and find the designated neuron that only fires when that state is reached.\n", - "2. Set a continuous firing rate for the simulation period on that neuron.\n", - "3. Determine which of the neuron groups in the output layer has fired more spikes at the end of the step.\n", + "## NESTML models\n", "\n", - "The TD (temporal difference) signal can be interpreted as follows:\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", - "- 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", + "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", - "XXX: TODO: point out that there is no depression in the STDP synapse" + "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": "5831c9d7", + "id": "a0e71ff5", "metadata": {}, "source": [ - "## SNN Visualization" + "## The spiking neural agent\n", + "\n", + "First, we define some helper functions for the visualisation of the network:" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 10, "id": "83e05060", "metadata": {}, "outputs": [], @@ -1104,7 +1177,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 11, "id": "e9bdcc5a", "metadata": {}, "outputs": [], @@ -1288,1212 +1361,15 @@ }, { "cell_type": "markdown", - "id": "8dc47382", + "id": "125e6cf6", "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." + "Then, we define the spiking agent itself:" ] }, { "cell_type": "code", - "execution_count": 8, - "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", - "[1,GLOBAL, INFO]: List of files that will be processed:\n", - "[2,GLOBAL, INFO]: /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/iaf_psc_exp_neuron.nestml\n", - "[3,GLOBAL, INFO]: /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/neuromodulated_stdp_synapse.nestml\n", - "[4,GLOBAL, INFO]: Target platform code will be generated in directory: '/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target'\n", - "[5,GLOBAL, INFO]: Target platform code will be installed in directory: '/tmp/nestml_target_25yka07n'\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", - "[6,GLOBAL, INFO]: The NEST Simulator version was automatically detected as: master\n", - "[7,GLOBAL, INFO]: Given template root path is not an absolute path. Creating the absolute path with default templates directory '/home/charl/julich/nestml-fork-mountain-car/nestml/pynestml/codegeneration/resources_nest/point_neuron'\n", - "[8,GLOBAL, INFO]: The NEST Simulator installation path was automatically detected as: /home/charl/julich/nest-simulator-install\n", - "[9,GLOBAL, INFO]: Start processing '/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/iaf_psc_exp_neuron.nestml'!\n", - "[10,iaf_psc_exp_neuron_nestml, INFO, [37:19;37:19]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[11,iaf_psc_exp_neuron_nestml, INFO, [40:17;40:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[12,iaf_psc_exp_neuron_nestml, INFO, [53:15;53:32]]: Implicit casting from (compatible) type '1 / s buffer' to 'real'.\n", - "[13,GLOBAL, INFO]: Start processing '/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/neuromodulated_stdp_synapse.nestml'!\n", - "[14,neuromodulated_stdp_synapse_nestml, INFO, [8:17;8:17]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[15,neuromodulated_stdp_synapse_nestml, INFO, [9:19;9:19]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[16,neuromodulated_stdp_synapse_nestml, INFO, [22:23;22:23]]: Implicit casting from (compatible) type 'integer' to 'real'.\n", - "[17,neuromodulated_stdp_synapse_nestml, INFO, [38:22;38:22]]: Implicit casting from (compatible) type 'integer' to 'real'.\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", - "[22,GLOBAL, INFO]: State variables that will be moved from synapse to neuron: ['post_trace']\n", - "[23,GLOBAL, INFO]: Parameters that will be copied from synapse to neuron: ['tau_tr_post']\n", - "[24,GLOBAL, INFO]: Synaptic state variables moved to neuron that will need buffering: []\n", - "[25,GLOBAL, INFO]: Moving state var defining equation(s) post_trace\n", - "[26,GLOBAL, INFO]: Moving state variables for equation(s) post_trace\n", - "[27,GLOBAL, INFO]: Moving definition of post_trace from synapse to neuron\n", - "[28,GLOBAL, INFO]: \tMoving statement post_trace += 1 # XXX FIXME!!!! should be ``+= post_trace_increment``\n", - "[29,GLOBAL, INFO]: In synapse: replacing ``continuous`` type input ports that are connected to postsynaptic neuron with external variable references\n", - "[30,GLOBAL, INFO]: Copying parameters from synapse to neuron...\n", - "[31,GLOBAL, INFO]: Copying definition of tau_tr_post from synapse to neuron\n", - "[32,GLOBAL, INFO]: Adding suffix to variables in spike updates\n", - "[33,GLOBAL, INFO]: In synapse: replacing variables with suffixed external variable references\n", - "[34,GLOBAL, INFO]: \t• Replacing variable post_trace\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Analysing input:\n", - "INFO:{\n", - " \"dynamics\": [\n", - " {\n", - " \"expression\": \"g_e' = (-g_e) / tau_g\",\n", - " \"initial_values\": {\n", - " \"g_e\": \"0.0\"\n", - " }\n", - " },\n", - " {\n", - " \"expression\": \"V_m' = (g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\",\n", - " \"initial_values\": {\n", - " \"V_m\": \"E_l\"\n", - " }\n", - " }\n", - " ],\n", - " \"options\": {\n", - " \"output_timestep_symbol\": \"__h\",\n", - " \"simplify_expression\": \"sympy.logcombine(sympy.powsimp(sympy.expand(expr)))\"\n", - " },\n", - " \"parameters\": {\n", - " \"E_e\": \"0\",\n", - " \"E_l\": \"(-74)\",\n", - " \"I_e\": \"0\",\n", - " \"V_reset\": \"(-60)\",\n", - " \"V_th\": \"(-54)\",\n", - " \"s\": \"1000\",\n", - " \"tau_g\": \"5\",\n", - " \"tau_m\": \"10\"\n", - " }\n", - "}\n", - "INFO:Processing global options...\n", - "INFO:Processing input shapes...\n", - "INFO:\n", - "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", - "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_g]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "DEBUG:Created Shape with symbol g_e, derivative_factors = [-1/tau_g], inhom_term = 0.0, nonlin_term = 0.0\n", - "INFO:\tReturning shape: Shape \"g_e\" of order 1\n", - "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", - "INFO:\n", - "Processing differential-equation form shape V_m with defining expression = \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\"\n", - "DEBUG:Splitting expression (E_l + I_e + I_stim - V_m + g_e*(E_e - V_m))/tau_m (symbols [V_m])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_m]])\n", - "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m\n", - "DEBUG:\tnonlinear term: E_e*g_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m\n", - "DEBUG:Created Shape with symbol V_m, derivative_factors = [-1/tau_m], inhom_term = E_l/tau_m + I_e/tau_m, nonlin_term = E_e*g_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m\n", - "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", - "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", - "INFO:All known variables: [g_e, V_m], all parameters used in ODEs: {tau_m, E_e, tau_g, E_l, I_stim, I_e}\n", - "INFO:No numerical value specified for parameter \"I_stim\"\n", - "INFO:\n", - "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", - "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m, g_e])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0], [0]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "DEBUG:Created Shape with symbol g_e, derivative_factors = [-1/tau_g], inhom_term = 0.0, nonlin_term = 0\n", - "INFO:\tReturning shape: Shape \"g_e\" of order 1\n", - "INFO:\n", - "Processing differential-equation form shape V_m with defining expression = \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\"\n", - "DEBUG:Splitting expression (E_l + I_e + I_stim - V_m + g_e*(E_e - V_m))/tau_m (symbols [g_e, V_m, g_e, V_m])\n", - "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m], [0], [0]])\n", - "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", - "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", - "DEBUG:Created Shape with symbol V_m, derivative_factors = [-1/tau_m], inhom_term = E_l/tau_m + I_e/tau_m + I_stim/tau_m, nonlin_term = E_e*g_e/tau_m - V_m*g_e/tau_m\n", - "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", - "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", - "DEBUG:Splitting expression -g_e/tau_g (symbols Matrix([[g_e], [V_m]]))\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", - "DEBUG:Splitting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m (symbols Matrix([[g_e], [V_m]]))\n", - "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m]])\n", - "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", - "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", - "DEBUG:Initializing system of shapes with x = Matrix([[g_e], [V_m]]), A = Matrix([[-1/tau_g, 0], [E_e/tau_m, -1/tau_m]]), b = Matrix([[0], [E_l/tau_m + I_e/tau_m + I_stim/tau_m]]), c = Matrix([[0], [-V_m*g_e/tau_m]])\n", - "INFO:Finding analytically solvable equations...\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", - "DEBUG:os.makedirs('/tmp')\n", - "DEBUG:write lines to '/tmp/ode_dependency_graph.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[35,GLOBAL, INFO]: Successfully constructed neuron-synapse pair iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml, neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml\n", - "[36,GLOBAL, INFO]: Analysing/transforming model 'iaf_psc_exp_neuron_nestml'\n", - "[37,iaf_psc_exp_neuron_nestml, INFO, [18:0;58:0]]: Starts processing of the model 'iaf_psc_exp_neuron_nestml'\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", - "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", - "DEBUG:Splitting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m (symbols [g_e, V_m])\n", - "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m]])\n", - "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", - "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot\n", - "DEBUG:os.makedirs('/tmp')\n", - "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable_before_propagated.dot']\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable.dot\n", - "DEBUG:os.makedirs('/tmp')\n", - "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable.dot']\n", - "INFO:Generating propagators for the following symbols: g_e\n", - "DEBUG:Initializing system of shapes with x = Matrix([[g_e]]), A = Matrix([[-1/tau_g]]), b = Matrix([[0]]), c = Matrix([[0]])\n", - "DEBUG:System of equations:\n", - "DEBUG:x = Matrix([[g_e]])\n", - "DEBUG:A = Matrix([[-1/tau_g]])\n", - "DEBUG:b = Matrix([[0]])\n", - "DEBUG:c = Matrix([[0]])\n", - "INFO:update_expr[g_e] = __P__g_e__g_e*g_e\n", - "INFO:Generating numerical solver for the following symbols: V_m\n", - "DEBUG:Initializing system of shapes with x = Matrix([[V_m]]), A = Matrix([[-1/tau_m]]), b = Matrix([[E_l/tau_m + I_e/tau_m + I_stim/tau_m]]), c = Matrix([[E_e*g_e/tau_m - V_m*g_e/tau_m]])\n", - "WARNING:Not preserving expression for variable \"g_e\" as it is solved by propagator solver\n", - "INFO:Preserving expression for variable \"V_m\"\n", - "INFO:In ode-toolbox: returning outdict = \n", - "INFO:[\n", - " {\n", - " \"initial_values\": {\n", - " \"g_e\": \"0.0\"\n", - " },\n", - " \"parameters\": {\n", - " \"tau_g\": \"5.00000000000000\"\n", - " },\n", - " \"propagators\": {\n", - " \"__P__g_e__g_e\": \"exp(-__h/tau_g)\"\n", - " },\n", - " \"solver\": \"analytical\",\n", - " \"state_variables\": [\n", - " \"g_e\"\n", - " ],\n", - " \"update_expressions\": {\n", - " \"g_e\": \"__P__g_e__g_e*g_e\"\n", - " }\n", - " },\n", - " {\n", - " \"initial_values\": {\n", - " \"V_m\": \"E_l\"\n", - " },\n", - " \"parameters\": {\n", - " \"E_e\": \"0\",\n", - " \"E_l\": \"-74.0000000000000\",\n", - " \"I_e\": \"0\",\n", - " \"tau_m\": \"10.0000000000000\"\n", - " },\n", - " \"solver\": \"numeric\",\n", - " \"state_variables\": [\n", - " \"V_m\"\n", - " ],\n", - " \"update_expressions\": {\n", - " \"V_m\": \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\"\n", - " }\n", - " }\n", - "]\n", - "INFO:Analysing input:\n", - "INFO:{\n", - " \"dynamics\": [\n", - " {\n", - " \"expression\": \"g_e' = (-g_e) / tau_g\",\n", - " \"initial_values\": {\n", - " \"g_e\": \"0.0\"\n", - " }\n", - " },\n", - " {\n", - " \"expression\": \"V_m' = (g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\",\n", - " \"initial_values\": {\n", - " \"V_m\": \"E_l\"\n", - " }\n", - " }\n", - " ],\n", - " \"options\": {\n", - " \"output_timestep_symbol\": \"__h\",\n", - " \"simplify_expression\": \"sympy.logcombine(sympy.powsimp(sympy.expand(expr)))\"\n", - " },\n", - " \"parameters\": {\n", - " \"E_e\": \"0\",\n", - " \"E_l\": \"(-74)\",\n", - " \"I_e\": \"0\",\n", - " \"V_reset\": \"(-60)\",\n", - " \"V_th\": \"(-54)\",\n", - " \"s\": \"1000\",\n", - " \"tau_g\": \"5\",\n", - " \"tau_m\": \"10\"\n", - " }\n", - "}\n", - "INFO:Processing global options...\n", - "INFO:Processing input shapes...\n", - "INFO:\n", - "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", - "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_g]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "DEBUG:Created Shape with symbol g_e, derivative_factors = [-1/tau_g], inhom_term = 0.0, nonlin_term = 0.0\n", - "INFO:\tReturning shape: Shape \"g_e\" of order 1\n", - "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", - "INFO:\n", - "Processing differential-equation form shape V_m with defining expression = \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\"\n", - "DEBUG:Splitting expression (E_l + I_e + I_stim - V_m + g_e*(E_e - V_m))/tau_m (symbols [V_m])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_m]])\n", - "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m\n", - "DEBUG:\tnonlinear term: E_e*g_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m\n", - "DEBUG:Created Shape with symbol V_m, derivative_factors = [-1/tau_m], inhom_term = E_l/tau_m + I_e/tau_m, nonlin_term = E_e*g_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m\n", - "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", - "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", - "INFO:All known variables: [g_e, V_m], all parameters used in ODEs: {tau_m, E_e, tau_g, E_l, I_stim, I_e}\n", - "INFO:No numerical value specified for parameter \"I_stim\"\n", - "INFO:\n", - "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", - "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m, g_e])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0], [0]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "DEBUG:Created Shape with symbol g_e, derivative_factors = [-1/tau_g], inhom_term = 0.0, nonlin_term = 0\n", - "INFO:\tReturning shape: Shape \"g_e\" of order 1\n", - "INFO:\n", - "Processing differential-equation form shape V_m with defining expression = \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\"\n", - "DEBUG:Splitting expression (E_l + I_e + I_stim - V_m + g_e*(E_e - V_m))/tau_m (symbols [g_e, V_m, g_e, V_m])\n", - "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m], [0], [0]])\n", - "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", - "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", - "DEBUG:Created Shape with symbol V_m, derivative_factors = [-1/tau_m], inhom_term = E_l/tau_m + I_e/tau_m + I_stim/tau_m, nonlin_term = E_e*g_e/tau_m - V_m*g_e/tau_m\n", - "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", - "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", - "DEBUG:Splitting expression -g_e/tau_g (symbols Matrix([[g_e], [V_m]]))\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", - "DEBUG:Splitting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m (symbols Matrix([[g_e], [V_m]]))\n", - "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m]])\n", - "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", - "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", - "DEBUG:Initializing system of shapes with x = Matrix([[g_e], [V_m]]), A = Matrix([[-1/tau_g, 0], [E_e/tau_m, -1/tau_m]]), b = Matrix([[0], [E_l/tau_m + I_e/tau_m + I_stim/tau_m]]), c = Matrix([[0], [-V_m*g_e/tau_m]])\n", - "INFO:Finding analytically solvable equations...\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", - "DEBUG:os.makedirs('/tmp')\n", - "DEBUG:write lines to '/tmp/ode_dependency_graph.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n", - "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", - "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", - "DEBUG:Splitting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m (symbols [g_e, V_m])\n", - "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m]])\n", - "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", - "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot\n", - "DEBUG:os.makedirs('/tmp')\n", - "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable_before_propagated.dot']\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable.dot\n", - "DEBUG:os.makedirs('/tmp')\n", - "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable.dot']\n", - "INFO:Generating numerical solver for the following symbols: g_e, V_m\n", - "DEBUG:Initializing system of shapes with x = Matrix([[g_e], [V_m]]), A = Matrix([[-1/tau_g, 0], [E_e/tau_m, -1/tau_m]]), b = Matrix([[0], [E_l/tau_m + I_e/tau_m + I_stim/tau_m]]), c = Matrix([[0], [-V_m*g_e/tau_m]])\n", - "INFO:Preserving expression for variable \"g_e\"\n", - "INFO:Preserving expression for variable \"V_m\"\n", - "INFO:In ode-toolbox: returning outdict = \n", - "INFO:[\n", - " {\n", - " \"initial_values\": {\n", - " \"V_m\": \"E_l\",\n", - " \"g_e\": \"0.0\"\n", - " },\n", - " \"parameters\": {\n", - " \"E_e\": \"0\",\n", - " \"E_l\": \"-74.0000000000000\",\n", - " \"I_e\": \"0\",\n", - " \"tau_g\": \"5.00000000000000\",\n", - " \"tau_m\": \"10.0000000000000\"\n", - " },\n", - " \"solver\": \"numeric\",\n", - " \"state_variables\": [\n", - " \"g_e\",\n", - " \"V_m\"\n", - " ],\n", - " \"update_expressions\": {\n", - " \"V_m\": \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\",\n", - " \"g_e\": \"(-g_e) / tau_g\"\n", - " }\n", - " }\n", - "]\n", - "INFO:Analysing input:\n", - "INFO:{\n", - " \"dynamics\": [\n", - " {\n", - " \"expression\": \"g_e' = (-g_e) / tau_g\",\n", - " \"initial_values\": {\n", - " \"g_e\": \"0.0\"\n", - " }\n", - " },\n", - " {\n", - " \"expression\": \"V_m' = (g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\",\n", - " \"initial_values\": {\n", - " \"V_m\": \"E_l\"\n", - " }\n", - " },\n", - " {\n", - " \"expression\": \"post_trace__for_neuromodulated_stdp_synapse_nestml' = (-post_trace__for_neuromodulated_stdp_synapse_nestml) / tau_tr_post__for_neuromodulated_stdp_synapse_nestml\",\n", - " \"initial_values\": {\n", - " \"post_trace__for_neuromodulated_stdp_synapse_nestml\": \"0.0\"\n", - " }\n", - " }\n", - " ],\n", - " \"options\": {\n", - " \"output_timestep_symbol\": \"__h\",\n", - " \"simplify_expression\": \"sympy.logcombine(sympy.powsimp(sympy.expand(expr)))\"\n", - " },\n", - " \"parameters\": {\n", - " \"E_e\": \"0\",\n", - " \"E_l\": \"(-74)\",\n", - " \"I_e\": \"0\",\n", - " \"V_reset\": \"(-60)\",\n", - " \"V_th\": \"(-54)\",\n", - " \"s\": \"1000\",\n", - " \"tau_g\": \"5\",\n", - " \"tau_m\": \"10\",\n", - " \"tau_tr_post__for_neuromodulated_stdp_synapse_nestml\": \"10\"\n", - " }\n", - "}\n", - "INFO:Processing global options...\n", - "INFO:Processing input shapes...\n", - "INFO:\n", - "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", - "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_g]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "DEBUG:Created Shape with symbol g_e, derivative_factors = [-1/tau_g], inhom_term = 0.0, nonlin_term = 0.0\n", - "INFO:\tReturning shape: Shape \"g_e\" of order 1\n", - "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", - "INFO:\n", - "Processing differential-equation form shape V_m with defining expression = \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\"\n", - "DEBUG:Splitting expression (E_l + I_e + I_stim - V_m + g_e*(E_e - V_m))/tau_m (symbols [V_m])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_m]])\n", - "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m\n", - "DEBUG:\tnonlinear term: E_e*g_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m\n", - "DEBUG:Created Shape with symbol V_m, derivative_factors = [-1/tau_m], inhom_term = E_l/tau_m + I_e/tau_m, nonlin_term = E_e*g_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m\n", - "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", - "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", - "INFO:\n", - "Processing differential-equation form shape post_trace__for_neuromodulated_stdp_synapse_nestml with defining expression = \"(-post_trace__for_neuromodulated_stdp_synapse_nestml) / tau_tr_post__for_neuromodulated_stdp_synapse_nestml\"\n", - "DEBUG:Splitting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml (symbols [post_trace__for_neuromodulated_stdp_synapse_nestml])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "DEBUG:Created Shape with symbol post_trace__for_neuromodulated_stdp_synapse_nestml, derivative_factors = [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml], inhom_term = 0.0, nonlin_term = 0.0\n", - "INFO:\tReturning shape: Shape \"post_trace__for_neuromodulated_stdp_synapse_nestml\" of order 1\n", - "INFO:Shape post_trace__for_neuromodulated_stdp_synapse_nestml: reconstituting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml\n", - "INFO:All known variables: [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml], all parameters used in ODEs: {tau_m, E_e, tau_tr_post__for_neuromodulated_stdp_synapse_nestml, tau_g, E_l, I_stim, I_e}\n", - "INFO:No numerical value specified for parameter \"I_stim\"\n", - "INFO:\n", - "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", - "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml, g_e])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0], [0], [0]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "DEBUG:Created Shape with symbol g_e, derivative_factors = [-1/tau_g], inhom_term = 0.0, nonlin_term = 0\n", - "INFO:\tReturning shape: Shape \"g_e\" of order 1\n", - "INFO:\n", - "Processing differential-equation form shape V_m with defining expression = \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\"\n", - "DEBUG:Splitting expression (E_l + I_e + I_stim - V_m + g_e*(E_e - V_m))/tau_m (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml, g_e, V_m])\n", - "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m], [0], [0], [0]])\n", - "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", - "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", - "DEBUG:Created Shape with symbol V_m, derivative_factors = [-1/tau_m], inhom_term = E_l/tau_m + I_e/tau_m + I_stim/tau_m, nonlin_term = E_e*g_e/tau_m - V_m*g_e/tau_m\n", - "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", - "INFO:\n", - "Processing differential-equation form shape post_trace__for_neuromodulated_stdp_synapse_nestml with defining expression = \"(-post_trace__for_neuromodulated_stdp_synapse_nestml) / tau_tr_post__for_neuromodulated_stdp_synapse_nestml\"\n", - "DEBUG:Splitting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml, g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml])\n", - "DEBUG:\tlinear factors: Matrix([[0], [0], [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml], [0], [0], [0]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "DEBUG:Created Shape with symbol post_trace__for_neuromodulated_stdp_synapse_nestml, derivative_factors = [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml], inhom_term = 0.0, nonlin_term = 0\n", - "INFO:\tReturning shape: Shape \"post_trace__for_neuromodulated_stdp_synapse_nestml\" of order 1\n", - "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", - "DEBUG:Splitting expression -g_e/tau_g (symbols Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]))\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0], [0]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", - "DEBUG:Splitting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m (symbols Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]))\n", - "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m], [0]])\n", - "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", - "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", - "INFO:Shape post_trace__for_neuromodulated_stdp_synapse_nestml: reconstituting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml\n", - "DEBUG:Splitting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml (symbols Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]))\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "DEBUG:\tlinear factors: Matrix([[0], [0], [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "DEBUG:Initializing system of shapes with x = Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]), A = Matrix([[-1/tau_g, 0, 0], [E_e/tau_m, -1/tau_m, 0], [0, 0, -1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]]), b = Matrix([[0], [E_l/tau_m + I_e/tau_m + I_stim/tau_m], [0]]), c = Matrix([[0], [-V_m*g_e/tau_m], [0]])\n", - "INFO:Finding analytically solvable equations...\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", - "DEBUG:os.makedirs('/tmp')\n", - "DEBUG:write lines to '/tmp/ode_dependency_graph.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[38,GLOBAL, INFO]: Analysing/transforming model 'iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml'\n", - "[39,iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml, INFO, [18:0;58:0]]: Starts processing of the model 'iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml'\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", - "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0], [0]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", - "DEBUG:Splitting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml])\n", - "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m], [0]])\n", - "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", - "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", - "INFO:Shape post_trace__for_neuromodulated_stdp_synapse_nestml: reconstituting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml\n", - "DEBUG:Splitting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml])\n", - "DEBUG:\tlinear factors: Matrix([[0], [0], [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot\n", - "DEBUG:os.makedirs('/tmp')\n", - "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable_before_propagated.dot']\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable.dot\n", - "DEBUG:os.makedirs('/tmp')\n", - "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable.dot']\n", - "INFO:Generating propagators for the following symbols: g_e, post_trace__for_neuromodulated_stdp_synapse_nestml\n", - "DEBUG:Initializing system of shapes with x = Matrix([[g_e], [post_trace__for_neuromodulated_stdp_synapse_nestml]]), A = Matrix([[-1/tau_g, 0], [0, -1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]]), b = Matrix([[0], [0]]), c = Matrix([[0], [0]])\n", - "DEBUG:System of equations:\n", - "DEBUG:x = Matrix([[g_e], [post_trace__for_neuromodulated_stdp_synapse_nestml]])\n", - "DEBUG:A = Matrix([\n", - "[-1/tau_g, 0],\n", - "[ 0, -1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]])\n", - "DEBUG:b = Matrix([[0], [0]])\n", - "DEBUG:c = Matrix([[0], [0]])\n", - "INFO:update_expr[g_e] = __P__g_e__g_e*g_e\n", - "INFO:update_expr[post_trace__for_neuromodulated_stdp_synapse_nestml] = __P__post_trace__for_neuromodulated_stdp_synapse_nestml__post_trace__for_neuromodulated_stdp_synapse_nestml*post_trace__for_neuromodulated_stdp_synapse_nestml\n", - "INFO:Generating numerical solver for the following symbols: V_m\n", - "DEBUG:Initializing system of shapes with x = Matrix([[V_m]]), A = Matrix([[-1/tau_m]]), b = Matrix([[E_l/tau_m + I_e/tau_m + I_stim/tau_m]]), c = Matrix([[E_e*g_e/tau_m - V_m*g_e/tau_m]])\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", - "INFO:Preserving expression for variable \"V_m\"\n", - "INFO:In ode-toolbox: returning outdict = \n", - "INFO:[\n", - " {\n", - " \"initial_values\": {\n", - " \"g_e\": \"0.0\",\n", - " \"post_trace__for_neuromodulated_stdp_synapse_nestml\": \"0.0\"\n", - " },\n", - " \"parameters\": {\n", - " \"tau_g\": \"5.00000000000000\",\n", - " \"tau_tr_post__for_neuromodulated_stdp_synapse_nestml\": \"10.0000000000000\"\n", - " },\n", - " \"propagators\": {\n", - " \"__P__g_e__g_e\": \"exp(-__h/tau_g)\",\n", - " \"__P__post_trace__for_neuromodulated_stdp_synapse_nestml__post_trace__for_neuromodulated_stdp_synapse_nestml\": \"exp(-__h/tau_tr_post__for_neuromodulated_stdp_synapse_nestml)\"\n", - " },\n", - " \"solver\": \"analytical\",\n", - " \"state_variables\": [\n", - " \"g_e\",\n", - " \"post_trace__for_neuromodulated_stdp_synapse_nestml\"\n", - " ],\n", - " \"update_expressions\": {\n", - " \"g_e\": \"__P__g_e__g_e*g_e\",\n", - " \"post_trace__for_neuromodulated_stdp_synapse_nestml\": \"__P__post_trace__for_neuromodulated_stdp_synapse_nestml__post_trace__for_neuromodulated_stdp_synapse_nestml*post_trace__for_neuromodulated_stdp_synapse_nestml\"\n", - " }\n", - " },\n", - " {\n", - " \"initial_values\": {\n", - " \"V_m\": \"E_l\"\n", - " },\n", - " \"parameters\": {\n", - " \"E_e\": \"0\",\n", - " \"E_l\": \"-74.0000000000000\",\n", - " \"I_e\": \"0\",\n", - " \"tau_m\": \"10.0000000000000\"\n", - " },\n", - " \"solver\": \"numeric\",\n", - " \"state_variables\": [\n", - " \"V_m\"\n", - " ],\n", - " \"update_expressions\": {\n", - " \"V_m\": \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\"\n", - " }\n", - " }\n", - "]\n", - "INFO:Analysing input:\n", - "INFO:{\n", - " \"dynamics\": [\n", - " {\n", - " \"expression\": \"g_e' = (-g_e) / tau_g\",\n", - " \"initial_values\": {\n", - " \"g_e\": \"0.0\"\n", - " }\n", - " },\n", - " {\n", - " \"expression\": \"V_m' = (g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\",\n", - " \"initial_values\": {\n", - " \"V_m\": \"E_l\"\n", - " }\n", - " },\n", - " {\n", - " \"expression\": \"post_trace__for_neuromodulated_stdp_synapse_nestml' = (-post_trace__for_neuromodulated_stdp_synapse_nestml) / tau_tr_post__for_neuromodulated_stdp_synapse_nestml\",\n", - " \"initial_values\": {\n", - " \"post_trace__for_neuromodulated_stdp_synapse_nestml\": \"0.0\"\n", - " }\n", - " }\n", - " ],\n", - " \"options\": {\n", - " \"output_timestep_symbol\": \"__h\",\n", - " \"simplify_expression\": \"sympy.logcombine(sympy.powsimp(sympy.expand(expr)))\"\n", - " },\n", - " \"parameters\": {\n", - " \"E_e\": \"0\",\n", - " \"E_l\": \"(-74)\",\n", - " \"I_e\": \"0\",\n", - " \"V_reset\": \"(-60)\",\n", - " \"V_th\": \"(-54)\",\n", - " \"s\": \"1000\",\n", - " \"tau_g\": \"5\",\n", - " \"tau_m\": \"10\",\n", - " \"tau_tr_post__for_neuromodulated_stdp_synapse_nestml\": \"10\"\n", - " }\n", - "}\n", - "INFO:Processing global options...\n", - "INFO:Processing input shapes...\n", - "INFO:\n", - "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", - "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_g]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "DEBUG:Created Shape with symbol g_e, derivative_factors = [-1/tau_g], inhom_term = 0.0, nonlin_term = 0.0\n", - "INFO:\tReturning shape: Shape \"g_e\" of order 1\n", - "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", - "INFO:\n", - "Processing differential-equation form shape V_m with defining expression = \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\"\n", - "DEBUG:Splitting expression (E_l + I_e + I_stim - V_m + g_e*(E_e - V_m))/tau_m (symbols [V_m])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_m]])\n", - "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m\n", - "DEBUG:\tnonlinear term: E_e*g_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m\n", - "DEBUG:Created Shape with symbol V_m, derivative_factors = [-1/tau_m], inhom_term = E_l/tau_m + I_e/tau_m, nonlin_term = E_e*g_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m\n", - "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", - "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", - "INFO:\n", - "Processing differential-equation form shape post_trace__for_neuromodulated_stdp_synapse_nestml with defining expression = \"(-post_trace__for_neuromodulated_stdp_synapse_nestml) / tau_tr_post__for_neuromodulated_stdp_synapse_nestml\"\n", - "DEBUG:Splitting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml (symbols [post_trace__for_neuromodulated_stdp_synapse_nestml])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "DEBUG:Created Shape with symbol post_trace__for_neuromodulated_stdp_synapse_nestml, derivative_factors = [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml], inhom_term = 0.0, nonlin_term = 0.0\n", - "INFO:\tReturning shape: Shape \"post_trace__for_neuromodulated_stdp_synapse_nestml\" of order 1\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Shape post_trace__for_neuromodulated_stdp_synapse_nestml: reconstituting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml\n", - "INFO:All known variables: [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml], all parameters used in ODEs: {tau_m, E_e, tau_tr_post__for_neuromodulated_stdp_synapse_nestml, tau_g, E_l, I_stim, I_e}\n", - "INFO:No numerical value specified for parameter \"I_stim\"\n", - "INFO:\n", - "Processing differential-equation form shape g_e with defining expression = \"(-g_e) / tau_g\"\n", - "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml, g_e])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0], [0], [0]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "DEBUG:Created Shape with symbol g_e, derivative_factors = [-1/tau_g], inhom_term = 0.0, nonlin_term = 0\n", - "INFO:\tReturning shape: Shape \"g_e\" of order 1\n", - "INFO:\n", - "Processing differential-equation form shape V_m with defining expression = \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\"\n", - "DEBUG:Splitting expression (E_l + I_e + I_stim - V_m + g_e*(E_e - V_m))/tau_m (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml, g_e, V_m])\n", - "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m], [0], [0], [0]])\n", - "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", - "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", - "DEBUG:Created Shape with symbol V_m, derivative_factors = [-1/tau_m], inhom_term = E_l/tau_m + I_e/tau_m + I_stim/tau_m, nonlin_term = E_e*g_e/tau_m - V_m*g_e/tau_m\n", - "INFO:\tReturning shape: Shape \"V_m\" of order 1\n", - "INFO:\n", - "Processing differential-equation form shape post_trace__for_neuromodulated_stdp_synapse_nestml with defining expression = \"(-post_trace__for_neuromodulated_stdp_synapse_nestml) / tau_tr_post__for_neuromodulated_stdp_synapse_nestml\"\n", - "DEBUG:Splitting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml, g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml])\n", - "DEBUG:\tlinear factors: Matrix([[0], [0], [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml], [0], [0], [0]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "DEBUG:Created Shape with symbol post_trace__for_neuromodulated_stdp_synapse_nestml, derivative_factors = [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml], inhom_term = 0.0, nonlin_term = 0\n", - "INFO:\tReturning shape: Shape \"post_trace__for_neuromodulated_stdp_synapse_nestml\" of order 1\n", - "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", - "DEBUG:Splitting expression -g_e/tau_g (symbols Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]))\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0], [0]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", - "DEBUG:Splitting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m (symbols Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]))\n", - "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m], [0]])\n", - "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", - "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", - "INFO:Shape post_trace__for_neuromodulated_stdp_synapse_nestml: reconstituting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml\n", - "DEBUG:Splitting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml (symbols Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]))\n", - "DEBUG:\tlinear factors: Matrix([[0], [0], [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "DEBUG:Initializing system of shapes with x = Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]), A = Matrix([[-1/tau_g, 0, 0], [E_e/tau_m, -1/tau_m, 0], [0, 0, -1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]]), b = Matrix([[0], [E_l/tau_m + I_e/tau_m + I_stim/tau_m], [0]]), c = Matrix([[0], [-V_m*g_e/tau_m], [0]])\n", - "INFO:Finding analytically solvable equations...\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", - "DEBUG:os.makedirs('/tmp')\n", - "DEBUG:write lines to '/tmp/ode_dependency_graph.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n", - "INFO:Shape g_e: reconstituting expression -g_e/tau_g\n", - "DEBUG:Splitting expression -g_e/tau_g (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_g], [0], [0]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "INFO:Shape V_m: reconstituting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m\n", - "DEBUG:Splitting expression E_e*g_e/tau_m + E_l/tau_m + I_e/tau_m + I_stim/tau_m - V_m*g_e/tau_m - V_m/tau_m (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml])\n", - "DEBUG:\tlinear factors: Matrix([[E_e/tau_m], [-1/tau_m], [0]])\n", - "DEBUG:\tinhomogeneous term: E_l/tau_m + I_e/tau_m + I_stim/tau_m\n", - "DEBUG:\tnonlinear term: -V_m*g_e/tau_m\n", - "INFO:Shape post_trace__for_neuromodulated_stdp_synapse_nestml: reconstituting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml\n", - "DEBUG:Splitting expression -post_trace__for_neuromodulated_stdp_synapse_nestml/tau_tr_post__for_neuromodulated_stdp_synapse_nestml (symbols [g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml])\n", - "DEBUG:\tlinear factors: Matrix([[0], [0], [-1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot\n", - "DEBUG:os.makedirs('/tmp')\n", - "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable_before_propagated.dot']\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable.dot\n", - "DEBUG:os.makedirs('/tmp')\n", - "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable.dot']\n", - "INFO:Generating numerical solver for the following symbols: g_e, V_m, post_trace__for_neuromodulated_stdp_synapse_nestml\n", - "DEBUG:Initializing system of shapes with x = Matrix([[g_e], [V_m], [post_trace__for_neuromodulated_stdp_synapse_nestml]]), A = Matrix([[-1/tau_g, 0, 0], [E_e/tau_m, -1/tau_m, 0], [0, 0, -1/tau_tr_post__for_neuromodulated_stdp_synapse_nestml]]), b = Matrix([[0], [E_l/tau_m + I_e/tau_m + I_stim/tau_m], [0]]), c = Matrix([[0], [-V_m*g_e/tau_m], [0]])\n", - "INFO:Preserving expression for variable \"g_e\"\n", - "INFO:Preserving expression for variable \"V_m\"\n", - "INFO:Preserving expression for variable \"post_trace__for_neuromodulated_stdp_synapse_nestml\"\n", - "INFO:In ode-toolbox: returning outdict = \n", - "INFO:[\n", - " {\n", - " \"initial_values\": {\n", - " \"V_m\": \"E_l\",\n", - " \"g_e\": \"0.0\",\n", - " \"post_trace__for_neuromodulated_stdp_synapse_nestml\": \"0.0\"\n", - " },\n", - " \"parameters\": {\n", - " \"E_e\": \"0\",\n", - " \"E_l\": \"-74.0000000000000\",\n", - " \"I_e\": \"0\",\n", - " \"tau_g\": \"5.00000000000000\",\n", - " \"tau_m\": \"10.0000000000000\",\n", - " \"tau_tr_post__for_neuromodulated_stdp_synapse_nestml\": \"10.0000000000000\"\n", - " },\n", - " \"solver\": \"numeric\",\n", - " \"state_variables\": [\n", - " \"g_e\",\n", - " \"V_m\",\n", - " \"post_trace__for_neuromodulated_stdp_synapse_nestml\"\n", - " ],\n", - " \"update_expressions\": {\n", - " \"V_m\": \"(g_e * (E_e - V_m) + E_l - V_m + I_e + I_stim) / tau_m\",\n", - " \"g_e\": \"(-g_e) / tau_g\",\n", - " \"post_trace__for_neuromodulated_stdp_synapse_nestml\": \"(-post_trace__for_neuromodulated_stdp_synapse_nestml) / tau_tr_post__for_neuromodulated_stdp_synapse_nestml\"\n", - " }\n", - " }\n", - "]\n", - "INFO:Analysing input:\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:{\n", - " \"dynamics\": [\n", - " {\n", - " \"expression\": \"pre_trace' = (-pre_trace) / tau_tr_pre\",\n", - " \"initial_values\": {\n", - " \"pre_trace\": \"0.0\"\n", - " }\n", - " },\n", - " {\n", - " \"expression\": \"wtr' = (-wtr) / tau_wtr\",\n", - " \"initial_values\": {\n", - " \"wtr\": \"0\"\n", - " }\n", - " }\n", - " ],\n", - " \"options\": {\n", - " \"output_timestep_symbol\": \"__h\",\n", - " \"simplify_expression\": \"sympy.logcombine(sympy.powsimp(sympy.expand(expr)))\"\n", - " },\n", - " \"parameters\": {\n", - " \"beta\": \"0.01\",\n", - " \"d\": \"1\",\n", - " \"n\": \"0.0\",\n", - " \"post_trace_increment\": \"1.0\",\n", - " \"pre_trace_increment\": \"1.0\",\n", - " \"tau_tr_post\": \"10\",\n", - " \"tau_tr_pre\": \"10\",\n", - " \"tau_wtr\": \"100\",\n", - " \"wtr_max\": \"0.1\",\n", - " \"wtr_min\": \"0\"\n", - " }\n", - "}\n", - "INFO:Processing global options...\n", - "INFO:Processing input shapes...\n", - "INFO:\n", - "Processing differential-equation form shape pre_trace with defining expression = \"(-pre_trace) / tau_tr_pre\"\n", - "DEBUG:Splitting expression -pre_trace/tau_tr_pre (symbols [pre_trace])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_tr_pre]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "DEBUG:Created Shape with symbol pre_trace, derivative_factors = [-1/tau_tr_pre], inhom_term = 0.0, nonlin_term = 0.0\n", - "INFO:\tReturning shape: Shape \"pre_trace\" of order 1\n", - "INFO:Shape pre_trace: reconstituting expression -pre_trace/tau_tr_pre\n", - "INFO:\n", - "Processing differential-equation form shape wtr with defining expression = \"(-wtr) / tau_wtr\"\n", - "DEBUG:Splitting expression -wtr/tau_wtr (symbols [wtr])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_wtr]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "DEBUG:Created Shape with symbol wtr, derivative_factors = [-1/tau_wtr], inhom_term = 0.0, nonlin_term = 0.0\n", - "INFO:\tReturning shape: Shape \"wtr\" of order 1\n", - "INFO:Shape wtr: reconstituting expression -wtr/tau_wtr\n", - "INFO:All known variables: [pre_trace, wtr], all parameters used in ODEs: {tau_wtr, tau_tr_pre}\n", - "INFO:\n", - "Processing differential-equation form shape pre_trace with defining expression = \"(-pre_trace) / tau_tr_pre\"\n", - "DEBUG:Splitting expression -pre_trace/tau_tr_pre (symbols [pre_trace, wtr, pre_trace])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_tr_pre], [0], [0]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "DEBUG:Created Shape with symbol pre_trace, derivative_factors = [-1/tau_tr_pre], inhom_term = 0.0, nonlin_term = 0\n", - "INFO:\tReturning shape: Shape \"pre_trace\" of order 1\n", - "INFO:\n", - "Processing differential-equation form shape wtr with defining expression = \"(-wtr) / tau_wtr\"\n", - "DEBUG:Splitting expression -wtr/tau_wtr (symbols [pre_trace, wtr, pre_trace, wtr])\n", - "DEBUG:\tlinear factors: Matrix([[0], [-1/tau_wtr], [0], [0]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "DEBUG:Created Shape with symbol wtr, derivative_factors = [-1/tau_wtr], inhom_term = 0.0, nonlin_term = 0\n", - "INFO:\tReturning shape: Shape \"wtr\" of order 1\n", - "INFO:Shape pre_trace: reconstituting expression -pre_trace/tau_tr_pre\n", - "DEBUG:Splitting expression -pre_trace/tau_tr_pre (symbols Matrix([[pre_trace], [wtr]]))\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_tr_pre], [0]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "INFO:Shape wtr: reconstituting expression -wtr/tau_wtr\n", - "DEBUG:Splitting expression -wtr/tau_wtr (symbols Matrix([[pre_trace], [wtr]]))\n", - "DEBUG:\tlinear factors: Matrix([[0], [-1/tau_wtr]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "DEBUG:Initializing system of shapes with x = Matrix([[pre_trace], [wtr]]), A = Matrix([[-1/tau_tr_pre, 0], [0, -1/tau_wtr]]), b = Matrix([[0], [0]]), c = Matrix([[0], [0]])\n", - "INFO:Finding analytically solvable equations...\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph.dot\n", - "DEBUG:os.makedirs('/tmp')\n", - "DEBUG:write lines to '/tmp/ode_dependency_graph.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph.dot']\n", - "INFO:Shape pre_trace: reconstituting expression -pre_trace/tau_tr_pre\n", - "DEBUG:Splitting expression -pre_trace/tau_tr_pre (symbols [pre_trace, wtr])\n", - "DEBUG:\tlinear factors: Matrix([[-1/tau_tr_pre], [0]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "INFO:Shape wtr: reconstituting expression -wtr/tau_wtr\n", - "DEBUG:Splitting expression -wtr/tau_wtr (symbols [pre_trace, wtr])\n", - "DEBUG:\tlinear factors: Matrix([[0], [-1/tau_wtr]])\n", - "DEBUG:\tinhomogeneous term: 0.0\n", - "DEBUG:\tnonlinear term: 0.0\n", - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot\n", - "DEBUG:os.makedirs('/tmp')\n", - "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable_before_propagated.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable_before_propagated.dot']\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[40,GLOBAL, INFO]: Analysing/transforming synapse neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.\n", - "[41,neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml, INFO, [6:0;55:0]]: Starts processing of the model 'neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml'\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Saving dependency graph plot to /tmp/ode_dependency_graph_analytically_solvable.dot\n", - "DEBUG:os.makedirs('/tmp')\n", - "DEBUG:write lines to '/tmp/ode_dependency_graph_analytically_solvable.dot'\n", - "DEBUG:run [PosixPath('dot'), '-Kdot', '-Tpdf', '-O', 'ode_dependency_graph_analytically_solvable.dot']\n", - "INFO:Generating propagators for the following symbols: pre_trace, wtr\n", - "DEBUG:Initializing system of shapes with x = Matrix([[pre_trace], [wtr]]), A = Matrix([[-1/tau_tr_pre, 0], [0, -1/tau_wtr]]), b = Matrix([[0], [0]]), c = Matrix([[0], [0]])\n", - "DEBUG:System of equations:\n", - "DEBUG:x = Matrix([[pre_trace], [wtr]])\n", - "DEBUG:A = Matrix([\n", - "[-1/tau_tr_pre, 0],\n", - "[ 0, -1/tau_wtr]])\n", - "DEBUG:b = Matrix([[0], [0]])\n", - "DEBUG:c = Matrix([[0], [0]])\n", - "INFO:update_expr[pre_trace] = __P__pre_trace__pre_trace*pre_trace\n", - "INFO:update_expr[wtr] = __P__wtr__wtr*wtr\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", - "INFO:In ode-toolbox: returning outdict = \n", - "INFO:[\n", - " {\n", - " \"initial_values\": {\n", - " \"pre_trace\": \"0.0\",\n", - " \"wtr\": \"0\"\n", - " },\n", - " \"parameters\": {\n", - " \"tau_tr_pre\": \"10.0000000000000\",\n", - " \"tau_wtr\": \"100.000000000000\"\n", - " },\n", - " \"propagators\": {\n", - " \"__P__pre_trace__pre_trace\": \"exp(-__h/tau_tr_pre)\",\n", - " \"__P__wtr__wtr\": \"exp(-__h/tau_wtr)\"\n", - " },\n", - " \"solver\": \"analytical\",\n", - " \"state_variables\": [\n", - " \"pre_trace\",\n", - " \"wtr\"\n", - " ],\n", - " \"update_expressions\": {\n", - " \"pre_trace\": \"__P__pre_trace__pre_trace*pre_trace\",\n", - " \"wtr\": \"__P__wtr__wtr*wtr\"\n", - " }\n", - " }\n", - "]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[42,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp\n", - "[43,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.h\n", - "[44,iaf_psc_exp_neuron_nestml, INFO, [18:0;58:0]]: Successfully generated code for the model: 'iaf_psc_exp_neuron_nestml' in: '/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target' !\n", - "[45,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp\n", - "[46,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.h\n", - "[47,iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml, INFO, [18:0;58:0]]: Successfully generated code for the model: 'iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml' in: '/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target' !\n", - "[48,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h\n", - "[49,neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml, INFO, [6:0;55:0]]: Successfully generated code for the model: 'neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml' in: '/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target' !\n", - "[50,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/nestml_be24d67e1342417f93e13b73cd626d8c_module.cpp\n", - "[51,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/nestml_be24d67e1342417f93e13b73cd626d8c_module.h\n", - "[52,GLOBAL, INFO]: Rendering template /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/CMakeLists.txt\n", - "[53,GLOBAL, INFO]: Successfully generated NEST module code in '/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target' !\n", - "-- The CXX compiler identification is GNU 12.3.0\n", - "-- Detecting CXX compiler ABI info\n", - "-- Detecting CXX compiler ABI info - done\n", - "-- Check for working CXX compiler: /usr/bin/c++ - skipped\n", - "-- Detecting CXX compile features\n", - "-- Detecting CXX compile features - done\n", - "\n", - "-------------------------------------------------------\n", - "nestml_be24d67e1342417f93e13b73cd626d8c_module Configuration Summary\n", - "-------------------------------------------------------\n", - "\n", - "C++ compiler : /usr/bin/c++\n", - "Build static libs : OFF\n", - "C++ compiler flags : \n", - "NEST compiler flags : -std=c++17 -Wall -fopenmp -O2 -fdiagnostics-color=auto\n", - "NEST include dirs : -I/home/charl/julich/nest-simulator-install/include/nest -I/usr/include -I/usr/local/include -I/usr/include\n", - "NEST libraries flags : -L/home/charl/julich/nest-simulator-install/lib/nest -lnest -lsli /usr/lib/x86_64-linux-gnu/libltdl.so /usr/local/lib/libgsl.so /usr/local/lib/libgslcblas.so /usr/lib/gcc/x86_64-linux-gnu/12/libgomp.so /usr/lib/x86_64-linux-gnu/libpthread.a\n", - "\n", - "-------------------------------------------------------\n", - "\n", - "You can now build and install 'nestml_be24d67e1342417f93e13b73cd626d8c_module' using\n", - " make\n", - " make install\n", - "\n", - "The library file libnestml_be24d67e1342417f93e13b73cd626d8c_module.so will be installed to\n", - " /tmp/nestml_target_25yka07n\n", - "The module can be loaded into NEST using\n", - " (nestml_be24d67e1342417f93e13b73cd626d8c_module) Install (in SLI)\n", - " nest.Install(nestml_be24d67e1342417f93e13b73cd626d8c_module) (in PyNEST)\n", - "\n", - "-- Configuring done (0.4s)\n", - "-- Generating done (0.0s)\n", - "-- Build files have been written to: /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target\n", - "[ 25%] Building CXX object CMakeFiles/nestml_be24d67e1342417f93e13b73cd626d8c_module_module.dir/nestml_be24d67e1342417f93e13b73cd626d8c_module.cpp.o\n", - "[ 50%] Building CXX object CMakeFiles/nestml_be24d67e1342417f93e13b73cd626d8c_module_module.dir/iaf_psc_exp_neuron_nestml.cpp.o\n", - "[ 75%] Building CXX object CMakeFiles/nestml_be24d67e1342417f93e13b73cd626d8c_module_module.dir/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp.o\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml::init_state_internal_()’:\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:201:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 201 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml::recompute_internal_variables(bool)’:\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:290:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 290 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp: In function ‘int iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml_dynamics_post_trace__for_neuromodulated_stdp_synapse_nestml(double, const double*, double*, void*)’:\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:347:77: warning: unused variable ‘node’ [-Wunused-variable]\n", - " 347 | const iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml& node = *( reinterpret_cast< iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml* >( pnode ) );\n", - " | ^~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp: In member function ‘virtual void iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml::update(const nest::Time&, long int, long int)’:\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:375:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", - " 375 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", - " | ~~^~~~~~~~~~~~~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:366:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 366 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", - " | ^~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:360:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 360 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml::on_receive_block_spikes_in_port(const nest::Time&, long int)’:\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:541:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 541 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml__with_neuromodulated_stdp_synapse_nestml.cpp:542:8: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 542 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", - " | ^~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml::init_state_internal_()’:\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:191:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 191 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml::recompute_internal_variables(bool)’:\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:271:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 271 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘virtual void iaf_psc_exp_neuron_nestml::update(const nest::Time&, long int, long int)’:\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:337:24: warning: comparison of integer expressions of different signedness: ‘long int’ and ‘const size_t’ {aka ‘const long unsigned int’} [-Wsign-compare]\n", - " 337 | for (long i = 0; i < NUM_SPIKE_RECEPTORS; ++i)\n", - " | ~~^~~~~~~~~~~~~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:328:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 328 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", - " | ^~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:322:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 322 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp: In member function ‘void iaf_psc_exp_neuron_nestml::on_receive_block_spikes_in_port(const nest::Time&, long int)’:\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:500:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 500 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/iaf_psc_exp_neuron_nestml.cpp:501:8: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 501 | auto get_t = [origin, lag](){ return nest::Time( nest::Time::step( origin.get_steps() + lag + 1) ).get_ms(); };\n", - " | ^~~~~\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "In file included from /home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/nestml_be24d67e1342417f93e13b73cd626d8c_module.cpp:36:\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:62:5: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:613:104: required from here\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:746:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 746 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘void nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::recompute_internal_variables() [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:760:3: required from ‘nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierPtrRport]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:62:5: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:613:104: required from here\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:733:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 733 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:103:34: required from ‘void nest::ModelManager::register_specific_connection_model_(const std::string&) [with CompleteConnecionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:67:80: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:613:104: required from here\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:746:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 746 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘void nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::recompute_internal_variables() [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:760:3: required from ‘nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml() [with targetidentifierT = nest::TargetIdentifierIndex]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_model.h:164:25: required from ‘nest::GenericConnectorModel::GenericConnectorModel(std::string) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:103:34: required from ‘void nest::ModelManager::register_specific_connection_model_(const std::string&) [with CompleteConnecionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/model_manager_impl.h:67:80: required from ‘void nest::ModelManager::register_connection_model(const std::string&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/nest_impl.h:37:70: required from ‘void nest::register_connection_model(const std::string&) [with ConnectorModelT = neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; std::string = std::__cxx11::basic_string]’\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:613:104: required from here\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:733:16: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 733 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘bool nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::send(nest::Event&, size_t, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport; size_t = long unsigned int]’:\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; size_t = long unsigned int]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:517:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 517 | auto get_t = [t_hist_entry_ms](){ return t_hist_entry_ms; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", - " | ^~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:546:12: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 546 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", - " | ^~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:587:12: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 587 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", - " | ^~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:442:18: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 442 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:444:10: warning: variable ‘get_thread’ set but not used [-Wunused-but-set-variable]\n", - " 444 | auto get_thread = [tid]()\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘bool nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::send(nest::Event&, size_t, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex; size_t = long unsigned int]’:\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; size_t = long unsigned int]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:517:14: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 517 | auto get_t = [t_hist_entry_ms](){ return t_hist_entry_ms; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", - " | ^~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:546:12: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 546 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", - " | ^~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:587:12: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 587 | auto get_t = [__t_spike](){ return __t_spike; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", - " | ^~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:442:18: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 442 | const double __timestep = nest::Time::get_resolution().get_ms(); // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:444:10: warning: variable ‘get_thread’ set but not used [-Wunused-but-set-variable]\n", - " 444 | auto get_thread = [tid]()\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘void nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::update_internal_state_(double, double, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport]’:\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:512:9: required from ‘bool nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::send(nest::Event&, size_t, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierPtrRport; size_t = long unsigned int]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; size_t = long unsigned int]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:812:18: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 812 | const double __timestep = timestep; // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:813:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 813 | auto get_t = [t_start](){ return t_start; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", - " | ^~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h: In instantiation of ‘void nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::update_internal_state_(double, double, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex]’:\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:512:9: required from ‘bool nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml::send(nest::Event&, size_t, const nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestmlCommonSynapseProperties&) [with targetidentifierT = nest::TargetIdentifierIndex; size_t = long unsigned int]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:391:22: required from ‘void nest::Connector::send_to_all(size_t, const std::vector&, nest::Event&) [with ConnectionT = nest::neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml; size_t = long unsigned int]’\n", - "/home/charl/julich/nest-simulator-install/include/nest/connector_base.h:383:3: required from here\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:812:18: warning: unused variable ‘__timestep’ [-Wunused-variable]\n", - " 812 | const double __timestep = timestep; // do not remove, this is necessary for the timestep() function\n", - " | ^~~~~~~~~~\n", - "/home/charl/julich/nestml-fork-mountain-car/nestml/doc/tutorials/mountain_car_reinforcement_learning/target/neuromodulated_stdp_synapse_nestml__with_iaf_psc_exp_neuron_nestml.h:813:10: warning: variable ‘get_t’ set but not used [-Wunused-but-set-variable]\n", - " 813 | auto get_t = [t_start](){ return t_start; }; // do not remove, this is in case the predefined time variable ``t`` is used in the NESTML model\n", - " | ^~~~~\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[100%] Linking CXX shared module nestml_be24d67e1342417f93e13b73cd626d8c_module.so\n", - "[100%] Built target nestml_be24d67e1342417f93e13b73cd626d8c_module_module\n", - "[100%] Built target nestml_be24d67e1342417f93e13b73cd626d8c_module_module\n", - "Install the project...\n", - "-- Install configuration: \"\"\n", - "-- Installing: /tmp/nestml_target_25yka07n/nestml_be24d67e1342417f93e13b73cd626d8c_module.so\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=\"DEBUG\",\n", - " codegen_opts={\"delay_variable\": {\"neuromodulated_stdp_synapse\": \"d\"},\n", - " \"weight_variable\": {\"neuromodulated_stdp_synapse\": \"w\"}})" - ] - }, - { - "cell_type": "code", - "execution_count": 9, + "execution_count": 12, "id": "99614c94", "metadata": {}, "outputs": [], @@ -2689,7 +1565,7 @@ " \n", "# # reward increasing the velocity\n", "# if np.abs(velocity) > np.abs(old_velocity):\n", - "# potential_val += 1 #0 * (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", @@ -2738,27 +1614,15 @@ }, { "cell_type": "markdown", - "id": "566fa9c9", + "id": "0a4563e2", "metadata": {}, "source": [ - "# Executing spiking version\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\n", - " - Run the SNN with this input state for a period of time (cycle time, e.g. 10-50 ms)\n", - " - (wtr is computed in each synapse)\n", - "- Action is selected based on output neuron firing, by counting the number of spikes in the output population over this cycle period\n", - "- Environment is updated based on action; run the environment for the same cycle time (40 ms) to obtain next state\n", - "- Reward is computed (neuromodulator signal is proportional to reward)\n", - "- Synapses that were active (between input and output neurons) have their weights updated (based on wtr * reward)\n", - "- wtr of all synapses is reset back to 0" + "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": 10, + "execution_count": 13, "id": "e4bda6d4", "metadata": { "scrolled": true @@ -2768,230 +1632,225 @@ "name": "stdout", "output_type": "stream", "text": [ - "Episode 0 took: 4.902 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -7.372242346828137\n", - "Episode 1 took: 4.326 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = 2.7640682743350213\n", - "Episode 2 took: 16.325 s\n", + "Episode 0 took: 2.072 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -2.7498576649449835\n", - "Episode 3 took: 9.898 s\n", + "\tTotal reward = -6.571768537791498\n", + "Episode 1 took: 2.124 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -4.837556579077697\n", - "Episode 4 took: 13.589 s\n", + "\tTotal reward = -5.19039522413152\n", + "Episode 2 took: 2.367 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = 1.670897495745249\n", - "Episode 5 took: 5.945 s\n", - "\tNumber of steps in episode = 432\n", - "\tTotal reward = 3.989864219702854\n", - "Episode 6 took: 5.603 s\n", - "\tNumber of steps in episode = 461\n", - "\tTotal reward = 4.126203512291253\n", - "Episode 7 took: 5.870 s\n", - "\tNumber of steps in episode = 478\n", - "\tTotal reward = 3.265240199780956\n", - "Episode 8 took: 6.708 s\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 = 0.18832725094545388\n", - "Episode 9 took: 5.675 s\n", - "\tNumber of steps in episode = 421\n", - "\tTotal reward = 5.106904076414163\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_94521/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_94521/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", - "DEBUG:locator: \n" + "/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: 9.965 s\n", - "\tNumber of steps in episode = 387\n", - "\tTotal reward = 6.798445782414001\n", - "Episode 11 took: 11.372 s\n", - "\tNumber of steps in episode = 449\n", - "\tTotal reward = 2.7922593359881955\n", - "Episode 12 took: 13.048 s\n", - "\tNumber of steps in episode = 472\n", - "\tTotal reward = 3.4417362526944237\n", - "Episode 13 took: 11.977 s\n", - "\tNumber of steps in episode = 459\n", - "\tTotal reward = 4.084680653365472\n", - "Episode 14 took: 13.248 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -0.8305929598994641\n", - "Episode 15 took: 14.977 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -5.377416253306809\n", - "Episode 16 took: 15.148 s\n", + "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 = -4.323984646280818\n", - "Episode 17 took: 13.083 s\n", + "\tTotal reward = -0.8675605990046993\n", + "Episode 12 took: 2.815 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = 0.8199416134117596\n", - "Episode 18 took: 8.791 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -4.8012069808303295\n", - "Episode 19 took: 8.250 s\n", - "\tNumber of steps in episode = 481\n", - "\tTotal reward = 2.918082621247154\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_94521/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_94521/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", - "DEBUG:locator: \n" + "/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: 15.266 s\n", - "\tNumber of steps in episode = 423\n", - "\tTotal reward = 4.648173414790665\n", - "Episode 21 took: 13.491 s\n", - "\tNumber of steps in episode = 485\n", - "\tTotal reward = 3.3109517152601144\n", - "Episode 22 took: 9.645 s\n", - "\tNumber of steps in episode = 467\n", - "\tTotal reward = 4.316775721449431\n", - "Episode 23 took: 11.492 s\n", - "\tNumber of steps in episode = 469\n", - "\tTotal reward = 3.585056711349568\n", - "Episode 24 took: 9.037 s\n", - "\tNumber of steps in episode = 434\n", - "\tTotal reward = 3.6589571947102533\n", - "Episode 25 took: 14.447 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -3.5138648522466207\n", - "Episode 26 took: 11.478 s\n", + "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 = -6.489495125106023\n", - "Episode 27 took: 11.056 s\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 = -8.528480605481178\n", - "Episode 28 took: 10.880 s\n", - "\tNumber of steps in episode = 473\n", - "\tTotal reward = 2.5657937347404847\n", - "Episode 29 took: 11.481 s\n", - "\tNumber of steps in episode = 479\n", - "\tTotal reward = 2.6279668513699606\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_94521/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_94521/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", - "DEBUG:locator: \n" + "/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: 11.399 s\n", + "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 = -3.384320220067796\n", - "Episode 31 took: 13.640 s\n", - "\tNumber of steps in episode = 481\n", - "\tTotal reward = 3.616085028768447\n", - "Episode 32 took: 14.110 s\n", - "\tNumber of steps in episode = 490\n", - "\tTotal reward = 2.1357700712903664\n", - "Episode 33 took: 12.025 s\n", + "\tTotal reward = 0.6403141816248414\n", + "Episode 33 took: 4.852 s\n", "\tNumber of steps in episode = 499\n", - "\tTotal reward = -6.411110310144679\n", - "Episode 34 took: 17.872 s\n", - "\tNumber of steps in episode = 478\n", - "\tTotal reward = -6.533725626458156\n", - "Episode 35 took: 18.508 s\n", - "\tNumber of steps in episode = 459\n", - "\tTotal reward = 1.9349308218181434\n", - "Episode 36 took: 14.583 s\n", - "\tNumber of steps in episode = 492\n", - "\tTotal reward = 0.5230181736049531\n", - "Episode 37 took: 16.994 s\n", - "\tNumber of steps in episode = 497\n", - "\tTotal reward = 0.6642959097188439\n", - "Episode 38 took: 11.881 s\n", - "\tNumber of steps in episode = 405\n", - "\tTotal reward = 4.9408723019823055\n", - "Episode 39 took: 14.187 s\n", - "\tNumber of steps in episode = 495\n", - "\tTotal reward = 1.6476732815863748\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_94521/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_94521/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", - "DEBUG:locator: \n" + "/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: 14.596 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = 0.38633393082653766\n", - "Episode 41 took: 14.086 s\n", + "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 = 2.4158343715341517\n", - "Episode 42 took: 15.169 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -1.502273505512294\n", - "Episode 43 took: 14.705 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -1.6081728820230135\n", - "Episode 44 took: 14.568 s\n", - "\tNumber of steps in episode = 474\n", - "\tTotal reward = 4.012642709907481\n", - "Episode 45 took: 15.049 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -1.6299141470083702\n", - "Episode 46 took: 19.880 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -5.417938044004686\n", - "Episode 47 took: 15.396 s\n", - "\tNumber of steps in episode = 499\n", - "\tTotal reward = -5.623624887836356\n", - "Episode 48 took: 15.449 s\n", - "\tNumber of steps in episode = 486\n", - "\tTotal reward = 3.199464312955735\n", - "Episode 49 took: 15.649 s\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 = -1.7155625577912286\n" + "\tTotal reward = -4.731807474432128\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_94521/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_94521/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", - "DEBUG:locator: \n" + "/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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3001,7 +1860,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3184,7 +2043,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 14, "id": "b999c031", "metadata": { "scrolled": false @@ -3203,336 +2062,193 @@ "source": [ "## Mechanistic explanation: why does this learning principle work?\n", "\n", - "XXX: point out difference between having depression and not having depression\n", - "\n", - "For high firing rates, STDP basically becomes a purely rate-based rule: weights are predominantely potentiated (rather than depressed) for higher pre- and higher post-synaptic firing rates. The rule thus becomes a purely Hebbian learning rule.\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": 13, + "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": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=5.0 s⁻¹\n", - "\t-> Actual pre rate: 2.0 s⁻¹\n", - "\t-> Actual post rate: 6.0 s⁻¹\n", - "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=115.6 s⁻¹\n", - "\t-> Actual pre rate: 4.0 s⁻¹\n", - "\t-> Actual post rate: 126.0 s⁻¹\n", - "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=226.1 s⁻¹\n", - "\t-> Actual pre rate: 6.0 s⁻¹\n", - "\t-> Actual post rate: 232.0 s⁻¹\n", - "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=336.7 s⁻¹\n", - "\t-> Actual pre rate: 6.0 s⁻¹\n", - "\t-> Actual post rate: 288.0 s⁻¹\n", - "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=447.2 s⁻¹\n", - "\t-> Actual pre rate: 6.0 s⁻¹\n", - "\t-> Actual post rate: 325.0 s⁻¹\n", - "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=557.8 s⁻¹\n", - "\t-> Actual pre rate: 5.0 s⁻¹\n", - "\t-> Actual post rate: 350.0 s⁻¹\n", - "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=668.3 s⁻¹\n", - "\t-> Actual pre rate: 5.0 s⁻¹\n", - "\t-> Actual post rate: 369.0 s⁻¹\n", - "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=778.9 s⁻¹\n", - "\t-> Actual pre rate: 3.0 s⁻¹\n", - "\t-> Actual post rate: 387.0 s⁻¹\n", - "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=889.4 s⁻¹\n", - "\t-> Actual pre rate: 4.0 s⁻¹\n", - "\t-> Actual post rate: 396.0 s⁻¹\n", - "Simulating: Pre-rate=5.0 s⁻¹, Post-rate=1000.0 s⁻¹\n", - "\t-> Actual pre rate: 5.0 s⁻¹\n", - "\t-> Actual post rate: 408.0 s⁻¹\n", - "Simulating: Pre-rate=115.6 s⁻¹, Post-rate=5.0 s⁻¹\n", - "\t-> Actual pre rate: 116.0 s⁻¹\n", - "\t-> Actual post rate: 4.0 s⁻¹\n", - "Simulating: Pre-rate=115.6 s⁻¹, Post-rate=115.6 s⁻¹\n", - "\t-> Actual pre rate: 134.0 s⁻¹\n", - "\t-> Actual post rate: 114.0 s⁻¹\n", - "Simulating: Pre-rate=115.6 s⁻¹, Post-rate=226.1 s⁻¹\n", - "\t-> Actual pre rate: 131.0 s⁻¹\n", - "\t-> Actual post rate: 232.0 s⁻¹\n", - "Simulating: Pre-rate=115.6 s⁻¹, Post-rate=336.7 s⁻¹\n", - "\t-> Actual pre rate: 127.0 s⁻¹\n", - "\t-> Actual post rate: 284.0 s⁻¹\n", - "Simulating: Pre-rate=115.6 s⁻¹, Post-rate=447.2 s⁻¹\n", - "\t-> Actual pre rate: 113.0 s⁻¹\n", - "\t-> Actual post rate: 326.0 s⁻¹\n", - "Simulating: Pre-rate=115.6 s⁻¹, Post-rate=557.8 s⁻¹\n", - "\t-> Actual pre rate: 116.0 s⁻¹\n", - "\t-> Actual post rate: 350.0 s⁻¹\n", - "Simulating: Pre-rate=115.6 s⁻¹, Post-rate=668.3 s⁻¹\n", - "\t-> Actual pre rate: 116.0 s⁻¹\n", - "\t-> Actual post rate: 370.0 s⁻¹\n", - "Simulating: Pre-rate=115.6 s⁻¹, Post-rate=778.9 s⁻¹\n", - "\t-> Actual pre rate: 118.0 s⁻¹\n", - "\t-> Actual post rate: 386.0 s⁻¹\n", - "Simulating: Pre-rate=115.6 s⁻¹, Post-rate=889.4 s⁻¹\n", - "\t-> Actual pre rate: 124.0 s⁻¹\n", - "\t-> Actual post rate: 396.0 s⁻¹\n", - "Simulating: Pre-rate=115.6 s⁻¹, Post-rate=1000.0 s⁻¹\n", - "\t-> Actual pre rate: 130.0 s⁻¹\n", - "\t-> Actual post rate: 407.0 s⁻¹\n", - "Simulating: Pre-rate=226.1 s⁻¹, Post-rate=5.0 s⁻¹\n", - "\t-> Actual pre rate: 243.0 s⁻¹\n", - "\t-> Actual post rate: 5.0 s⁻¹\n", - "Simulating: Pre-rate=226.1 s⁻¹, Post-rate=115.6 s⁻¹\n", - "\t-> Actual pre rate: 241.0 s⁻¹\n", - "\t-> Actual post rate: 142.0 s⁻¹\n", - "Simulating: Pre-rate=226.1 s⁻¹, Post-rate=226.1 s⁻¹\n", - "\t-> Actual pre rate: 263.0 s⁻¹\n", - "\t-> Actual post rate: 219.0 s⁻¹\n", - "Simulating: Pre-rate=226.1 s⁻¹, Post-rate=336.7 s⁻¹\n", - "\t-> Actual pre rate: 222.0 s⁻¹\n", - "\t-> Actual post rate: 289.0 s⁻¹\n", - "Simulating: Pre-rate=226.1 s⁻¹, Post-rate=447.2 s⁻¹\n", - "\t-> Actual pre rate: 230.0 s⁻¹\n", - "\t-> Actual post rate: 325.0 s⁻¹\n", - "Simulating: Pre-rate=226.1 s⁻¹, Post-rate=557.8 s⁻¹\n", - "\t-> Actual pre rate: 233.0 s⁻¹\n", - "\t-> Actual post rate: 351.0 s⁻¹\n", - "Simulating: Pre-rate=226.1 s⁻¹, Post-rate=668.3 s⁻¹\n", - "\t-> Actual pre rate: 236.0 s⁻¹\n", - "\t-> Actual post rate: 370.0 s⁻¹\n", - "Simulating: Pre-rate=226.1 s⁻¹, Post-rate=778.9 s⁻¹\n", - "\t-> Actual pre rate: 232.0 s⁻¹\n", - "\t-> Actual post rate: 387.0 s⁻¹\n", - "Simulating: Pre-rate=226.1 s⁻¹, Post-rate=889.4 s⁻¹\n", - "\t-> Actual pre rate: 236.0 s⁻¹\n", - "\t-> Actual post rate: 396.0 s⁻¹\n", - "Simulating: Pre-rate=226.1 s⁻¹, Post-rate=1000.0 s⁻¹\n", - "\t-> Actual pre rate: 236.0 s⁻¹\n", - "\t-> Actual post rate: 407.0 s⁻¹\n", - "Simulating: Pre-rate=336.7 s⁻¹, Post-rate=5.0 s⁻¹\n", - "\t-> Actual pre rate: 357.0 s⁻¹\n", - "\t-> Actual post rate: 6.0 s⁻¹\n", - "Simulating: Pre-rate=336.7 s⁻¹, Post-rate=115.6 s⁻¹\n", - "\t-> Actual pre rate: 349.0 s⁻¹\n", - "\t-> Actual post rate: 136.0 s⁻¹\n", - "Simulating: Pre-rate=336.7 s⁻¹, Post-rate=226.1 s⁻¹\n", - "\t-> Actual pre rate: 364.0 s⁻¹\n", - "\t-> Actual post rate: 219.0 s⁻¹\n", - "Simulating: Pre-rate=336.7 s⁻¹, Post-rate=336.7 s⁻¹\n", - "\t-> Actual pre rate: 351.0 s⁻¹\n", - "\t-> Actual post rate: 287.0 s⁻¹\n", - "Simulating: Pre-rate=336.7 s⁻¹, Post-rate=447.2 s⁻¹\n", - "\t-> Actual pre rate: 356.0 s⁻¹\n", - "\t-> Actual post rate: 319.0 s⁻¹\n", - "Simulating: Pre-rate=336.7 s⁻¹, Post-rate=557.8 s⁻¹\n", - "\t-> Actual pre rate: 333.0 s⁻¹\n", - "\t-> Actual post rate: 350.0 s⁻¹\n", - "Simulating: Pre-rate=336.7 s⁻¹, Post-rate=668.3 s⁻¹\n", - "\t-> Actual pre rate: 344.0 s⁻¹\n", - "\t-> Actual post rate: 372.0 s⁻¹\n", - "Simulating: Pre-rate=336.7 s⁻¹, Post-rate=778.9 s⁻¹\n", - "\t-> Actual pre rate: 343.0 s⁻¹\n", - "\t-> Actual post rate: 389.0 s⁻¹\n", - "Simulating: Pre-rate=336.7 s⁻¹, Post-rate=889.4 s⁻¹\n", - "\t-> Actual pre rate: 352.0 s⁻¹\n", - "\t-> Actual post rate: 397.0 s⁻¹\n", - "Simulating: Pre-rate=336.7 s⁻¹, Post-rate=1000.0 s⁻¹\n", - "\t-> Actual pre rate: 349.0 s⁻¹\n", - "\t-> Actual post rate: 408.0 s⁻¹\n", - "Simulating: Pre-rate=447.2 s⁻¹, Post-rate=5.0 s⁻¹\n", - "\t-> Actual pre rate: 454.0 s⁻¹\n", - "\t-> Actual post rate: 6.0 s⁻¹\n", - "Simulating: Pre-rate=447.2 s⁻¹, Post-rate=115.6 s⁻¹\n", - "\t-> Actual pre rate: 462.0 s⁻¹\n", - "\t-> Actual post rate: 122.0 s⁻¹\n", - "Simulating: Pre-rate=447.2 s⁻¹, Post-rate=226.1 s⁻¹\n", - "\t-> Actual pre rate: 450.0 s⁻¹\n", - "\t-> Actual post rate: 224.0 s⁻¹\n", - "Simulating: Pre-rate=447.2 s⁻¹, Post-rate=336.7 s⁻¹\n", - "\t-> Actual pre rate: 440.0 s⁻¹\n", - "\t-> Actual post rate: 290.0 s⁻¹\n", - "Simulating: Pre-rate=447.2 s⁻¹, Post-rate=447.2 s⁻¹\n", - "\t-> Actual pre rate: 439.0 s⁻¹\n", - "\t-> Actual post rate: 329.0 s⁻¹\n", - "Simulating: Pre-rate=447.2 s⁻¹, Post-rate=557.8 s⁻¹\n", - "\t-> Actual pre rate: 437.0 s⁻¹\n", - "\t-> Actual post rate: 354.0 s⁻¹\n", - "Simulating: Pre-rate=447.2 s⁻¹, Post-rate=668.3 s⁻¹\n", - "\t-> Actual pre rate: 449.0 s⁻¹\n", - "\t-> Actual post rate: 371.0 s⁻¹\n", - "Simulating: Pre-rate=447.2 s⁻¹, Post-rate=778.9 s⁻¹\n", - "\t-> Actual pre rate: 434.0 s⁻¹\n", - "\t-> Actual post rate: 389.0 s⁻¹\n", - "Simulating: Pre-rate=447.2 s⁻¹, Post-rate=889.4 s⁻¹\n", - "\t-> Actual pre rate: 431.0 s⁻¹\n", - "\t-> Actual post rate: 399.0 s⁻¹\n", - "Simulating: Pre-rate=447.2 s⁻¹, Post-rate=1000.0 s⁻¹\n", - "\t-> Actual pre rate: 424.0 s⁻¹\n", - "\t-> Actual post rate: 410.0 s⁻¹\n", - "Simulating: Pre-rate=557.8 s⁻¹, Post-rate=5.0 s⁻¹\n", - "\t-> Actual pre rate: 559.0 s⁻¹\n", - "\t-> Actual post rate: 5.0 s⁻¹\n", - "Simulating: Pre-rate=557.8 s⁻¹, Post-rate=115.6 s⁻¹\n", - "\t-> Actual pre rate: 560.0 s⁻¹\n", - "\t-> Actual post rate: 122.0 s⁻¹\n", - "Simulating: Pre-rate=557.8 s⁻¹, Post-rate=226.1 s⁻¹\n", - "\t-> Actual pre rate: 561.0 s⁻¹\n", - "\t-> Actual post rate: 230.0 s⁻¹\n", - "Simulating: Pre-rate=557.8 s⁻¹, Post-rate=336.7 s⁻¹\n", - "\t-> Actual pre rate: 564.0 s⁻¹\n", - "\t-> Actual post rate: 281.0 s⁻¹\n", - "Simulating: Pre-rate=557.8 s⁻¹, Post-rate=447.2 s⁻¹\n", - "\t-> Actual pre rate: 571.0 s⁻¹\n", - "\t-> Actual post rate: 316.0 s⁻¹\n", - "Simulating: Pre-rate=557.8 s⁻¹, Post-rate=557.8 s⁻¹\n", - "\t-> Actual pre rate: 544.0 s⁻¹\n", - "\t-> Actual post rate: 358.0 s⁻¹\n", - "Simulating: Pre-rate=557.8 s⁻¹, Post-rate=668.3 s⁻¹\n", - "\t-> Actual pre rate: 550.0 s⁻¹\n", - "\t-> Actual post rate: 373.0 s⁻¹\n", - "Simulating: Pre-rate=557.8 s⁻¹, Post-rate=778.9 s⁻¹\n", - "\t-> Actual pre rate: 546.0 s⁻¹\n", - "\t-> Actual post rate: 390.0 s⁻¹\n", - "Simulating: Pre-rate=557.8 s⁻¹, Post-rate=889.4 s⁻¹\n", - "\t-> Actual pre rate: 555.0 s⁻¹\n", - "\t-> Actual post rate: 398.0 s⁻¹\n", - "Simulating: Pre-rate=557.8 s⁻¹, Post-rate=1000.0 s⁻¹\n", - "\t-> Actual pre rate: 549.0 s⁻¹\n", - "\t-> Actual post rate: 410.0 s⁻¹\n", - "Simulating: Pre-rate=668.3 s⁻¹, Post-rate=5.0 s⁻¹\n", - "\t-> Actual pre rate: 671.0 s⁻¹\n", - "\t-> Actual post rate: 5.0 s⁻¹\n", - "Simulating: Pre-rate=668.3 s⁻¹, Post-rate=115.6 s⁻¹\n", - "\t-> Actual pre rate: 672.0 s⁻¹\n", - "\t-> Actual post rate: 124.0 s⁻¹\n", - "Simulating: Pre-rate=668.3 s⁻¹, Post-rate=226.1 s⁻¹\n", - "\t-> Actual pre rate: 662.0 s⁻¹\n", - "\t-> Actual post rate: 229.0 s⁻¹\n", - "Simulating: Pre-rate=668.3 s⁻¹, Post-rate=336.7 s⁻¹\n", - "\t-> Actual pre rate: 671.0 s⁻¹\n", - "\t-> Actual post rate: 287.0 s⁻¹\n", - "Simulating: Pre-rate=668.3 s⁻¹, Post-rate=447.2 s⁻¹\n", - "\t-> Actual pre rate: 678.0 s⁻¹\n", - "\t-> Actual post rate: 325.0 s⁻¹\n", - "Simulating: Pre-rate=668.3 s⁻¹, Post-rate=557.8 s⁻¹\n", - "\t-> Actual pre rate: 684.0 s⁻¹\n", - "\t-> Actual post rate: 351.0 s⁻¹\n", - "Simulating: Pre-rate=668.3 s⁻¹, Post-rate=668.3 s⁻¹\n", - "\t-> Actual pre rate: 681.0 s⁻¹\n", - "\t-> Actual post rate: 375.0 s⁻¹\n", - "Simulating: Pre-rate=668.3 s⁻¹, Post-rate=778.9 s⁻¹\n", - "\t-> Actual pre rate: 709.0 s⁻¹\n", - "\t-> Actual post rate: 383.0 s⁻¹\n", - "Simulating: Pre-rate=668.3 s⁻¹, Post-rate=889.4 s⁻¹\n", - "\t-> Actual pre rate: 684.0 s⁻¹\n", - "\t-> Actual post rate: 396.0 s⁻¹\n", - "Simulating: Pre-rate=668.3 s⁻¹, Post-rate=1000.0 s⁻¹\n", - "\t-> Actual pre rate: 666.0 s⁻¹\n", - "\t-> Actual post rate: 407.0 s⁻¹\n", - "Simulating: Pre-rate=778.9 s⁻¹, Post-rate=5.0 s⁻¹\n", - "\t-> Actual pre rate: 800.0 s⁻¹\n", - "\t-> Actual post rate: 3.0 s⁻¹\n", - "Simulating: Pre-rate=778.9 s⁻¹, Post-rate=115.6 s⁻¹\n", - "\t-> Actual pre rate: 789.0 s⁻¹\n", - "\t-> Actual post rate: 123.0 s⁻¹\n", - "Simulating: Pre-rate=778.9 s⁻¹, Post-rate=226.1 s⁻¹\n", - "\t-> Actual pre rate: 794.0 s⁻¹\n", - "\t-> Actual post rate: 228.0 s⁻¹\n", - "Simulating: Pre-rate=778.9 s⁻¹, Post-rate=336.7 s⁻¹\n", - "\t-> Actual pre rate: 795.0 s⁻¹\n", - "\t-> Actual post rate: 290.0 s⁻¹\n", - "Simulating: Pre-rate=778.9 s⁻¹, Post-rate=447.2 s⁻¹\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t-> Actual pre rate: 804.0 s⁻¹\n", - "\t-> Actual post rate: 322.0 s⁻¹\n", - "Simulating: Pre-rate=778.9 s⁻¹, Post-rate=557.8 s⁻¹\n", - "\t-> Actual pre rate: 805.0 s⁻¹\n", - "\t-> Actual post rate: 348.0 s⁻¹\n", - "Simulating: Pre-rate=778.9 s⁻¹, Post-rate=668.3 s⁻¹\n", - "\t-> Actual pre rate: 754.0 s⁻¹\n", - "\t-> Actual post rate: 375.0 s⁻¹\n", - "Simulating: Pre-rate=778.9 s⁻¹, Post-rate=778.9 s⁻¹\n", - "\t-> Actual pre rate: 767.0 s⁻¹\n", - "\t-> Actual post rate: 389.0 s⁻¹\n", - "Simulating: Pre-rate=778.9 s⁻¹, Post-rate=889.4 s⁻¹\n", - "\t-> Actual pre rate: 758.0 s⁻¹\n", - "\t-> Actual post rate: 400.0 s⁻¹\n", - "Simulating: Pre-rate=778.9 s⁻¹, Post-rate=1000.0 s⁻¹\n", - "\t-> Actual pre rate: 758.0 s⁻¹\n", - "\t-> Actual post rate: 409.0 s⁻¹\n", - "Simulating: Pre-rate=889.4 s⁻¹, Post-rate=5.0 s⁻¹\n", - "\t-> Actual pre rate: 877.0 s⁻¹\n", - "\t-> Actual post rate: 3.0 s⁻¹\n", - "Simulating: Pre-rate=889.4 s⁻¹, Post-rate=115.6 s⁻¹\n", - "\t-> Actual pre rate: 882.0 s⁻¹\n", - "\t-> Actual post rate: 133.0 s⁻¹\n", - "Simulating: Pre-rate=889.4 s⁻¹, Post-rate=226.1 s⁻¹\n", - "\t-> Actual pre rate: 888.0 s⁻¹\n", - "\t-> Actual post rate: 232.0 s⁻¹\n", - "Simulating: Pre-rate=889.4 s⁻¹, Post-rate=336.7 s⁻¹\n", - "\t-> Actual pre rate: 894.0 s⁻¹\n", - "\t-> Actual post rate: 294.0 s⁻¹\n", - "Simulating: Pre-rate=889.4 s⁻¹, Post-rate=447.2 s⁻¹\n", - "\t-> Actual pre rate: 911.0 s⁻¹\n", - "\t-> Actual post rate: 322.0 s⁻¹\n", - "Simulating: Pre-rate=889.4 s⁻¹, Post-rate=557.8 s⁻¹\n", - "\t-> Actual pre rate: 895.0 s⁻¹\n", - "\t-> Actual post rate: 351.0 s⁻¹\n", - "Simulating: Pre-rate=889.4 s⁻¹, Post-rate=668.3 s⁻¹\n", - "\t-> Actual pre rate: 885.0 s⁻¹\n", - "\t-> Actual post rate: 374.0 s⁻¹\n", - "Simulating: Pre-rate=889.4 s⁻¹, Post-rate=778.9 s⁻¹\n", - "\t-> Actual pre rate: 927.0 s⁻¹\n", - "\t-> Actual post rate: 383.0 s⁻¹\n", - "Simulating: Pre-rate=889.4 s⁻¹, Post-rate=889.4 s⁻¹\n", - "\t-> Actual pre rate: 901.0 s⁻¹\n", - "\t-> Actual post rate: 396.0 s⁻¹\n", - "Simulating: Pre-rate=889.4 s⁻¹, Post-rate=1000.0 s⁻¹\n", - "\t-> Actual pre rate: 870.0 s⁻¹\n", - "\t-> Actual post rate: 408.0 s⁻¹\n", - "Simulating: Pre-rate=1000.0 s⁻¹, Post-rate=5.0 s⁻¹\n", - "\t-> Actual pre rate: 1022.0 s⁻¹\n", - "\t-> Actual post rate: 5.0 s⁻¹\n", - "Simulating: Pre-rate=1000.0 s⁻¹, Post-rate=115.6 s⁻¹\n", - "\t-> Actual pre rate: 1017.0 s⁻¹\n", - "\t-> Actual post rate: 138.0 s⁻¹\n", - "Simulating: Pre-rate=1000.0 s⁻¹, Post-rate=226.1 s⁻¹\n", - "\t-> Actual pre rate: 1017.0 s⁻¹\n", - "\t-> Actual post rate: 231.0 s⁻¹\n", - "Simulating: Pre-rate=1000.0 s⁻¹, Post-rate=336.7 s⁻¹\n", - "\t-> Actual pre rate: 1016.0 s⁻¹\n", - "\t-> Actual post rate: 290.0 s⁻¹\n", - "Simulating: Pre-rate=1000.0 s⁻¹, Post-rate=447.2 s⁻¹\n", - "\t-> Actual pre rate: 1045.0 s⁻¹\n", - "\t-> Actual post rate: 320.0 s⁻¹\n", - "Simulating: Pre-rate=1000.0 s⁻¹, Post-rate=557.8 s⁻¹\n", - "\t-> Actual pre rate: 1033.0 s⁻¹\n", - "\t-> Actual post rate: 351.0 s⁻¹\n", - "Simulating: Pre-rate=1000.0 s⁻¹, Post-rate=668.3 s⁻¹\n", - "\t-> Actual pre rate: 1023.0 s⁻¹\n", - "\t-> Actual post rate: 370.0 s⁻¹\n", - "Simulating: Pre-rate=1000.0 s⁻¹, Post-rate=778.9 s⁻¹\n", - "\t-> Actual pre rate: 1052.0 s⁻¹\n", - "\t-> Actual post rate: 384.0 s⁻¹\n", - "Simulating: Pre-rate=1000.0 s⁻¹, Post-rate=889.4 s⁻¹\n", - "\t-> Actual pre rate: 1026.0 s⁻¹\n", - "\t-> Actual post rate: 393.0 s⁻¹\n", - "Simulating: Pre-rate=1000.0 s⁻¹, Post-rate=1000.0 s⁻¹\n", - "\t-> Actual pre rate: 1039.0 s⁻¹\n", - "\t-> Actual post rate: 406.0 s⁻¹\n" - ] - }, + "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", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -3540,135 +2256,7 @@ } ], "source": [ - "#\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 = 1. # ratio between LTP and LTD amplitude change (NEST's 'lambda')\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", - " 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", - " print(\"\\t-> Actual pre rate: \" + str(len(sr_pre.events[\"times\"]) / (duration / 1000)) + \" s⁻¹\")\n", - " assert len(sr_post.events[\"times\"]) > 0\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=(10, 8))\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()" + "run_stdp_firing_rate_experiment(alpha=1.)" ] }, {