From 806ccfb940b62e1d8e7c0e460cd3fe51bd231c97 Mon Sep 17 00:00:00 2001 From: Carlos Gutierrez Date: Mon, 10 Aug 2026 01:54:29 +0900 Subject: [PATCH 1/8] Add parameter optimization engine and supporting schema fields --- .../codes/neuroworkflow/core/schema.py | 81 +++- .../codes/nodes/analysis/NW_Analysis.py | 83 +++- src/neuroworkflow/core/schema.py | 81 +++- .../nodes/analysis/NW_Analysis.py | 83 +++- src/neuroworkflow/optimization/__init__.py | 45 +++ src/neuroworkflow/optimization/addressing.py | 132 +++++++ src/neuroworkflow/optimization/engine.py | 357 +++++++++++++++++ src/neuroworkflow/optimization/ledger.py | 100 +++++ src/neuroworkflow/optimization/optimizers.py | 208 ++++++++++ src/neuroworkflow/optimization/spec.py | 358 ++++++++++++++++++ 10 files changed, 1516 insertions(+), 12 deletions(-) create mode 100644 src/neuroworkflow/optimization/__init__.py create mode 100644 src/neuroworkflow/optimization/addressing.py create mode 100644 src/neuroworkflow/optimization/engine.py create mode 100644 src/neuroworkflow/optimization/ledger.py create mode 100644 src/neuroworkflow/optimization/optimizers.py create mode 100644 src/neuroworkflow/optimization/spec.py diff --git a/gui/workflow_backend/django-project/codes/neuroworkflow/core/schema.py b/gui/workflow_backend/django-project/codes/neuroworkflow/core/schema.py index fb69af58..0b824bcb 100644 --- a/gui/workflow_backend/django-project/codes/neuroworkflow/core/schema.py +++ b/gui/workflow_backend/django-project/codes/neuroworkflow/core/schema.py @@ -5,6 +5,7 @@ node definitions, ports, parameters, and methods in the workflow system. """ +import warnings from dataclasses import dataclass, field from enum import Enum, auto from typing import Dict, List, Union, Any, Type, Optional, Tuple @@ -83,6 +84,23 @@ def is_memory_port(self) -> bool: return not self.is_io_port() +def _range_problem(value: Any) -> Optional[str]: + """Describe what is wrong with a [min, max] pair, or None if it is usable. + + Non-numeric bounds are left alone: a range may legitimately be expressed in + terms this module does not interpret. + """ + if not isinstance(value, (list, tuple)) or len(value) != 2: + return f"must be [min, max], got {value}" + low, high = value + if not all(isinstance(v, (int, float)) and not isinstance(v, bool) + for v in (low, high)): + return None + if low > high: + return f"min {low} is above max {high}" + return None + + @dataclass class ParameterDefinition: """Definition of a parameter in a node. @@ -92,21 +110,80 @@ class ParameterDefinition: description: Human-readable description constraints: Validation constraints (min, max, allowed_values, etc.) optimizable: Whether this parameter can be tuned during optimization - optimization_range: [min, max] range for parameter tuning + optimization_range: [min, max] range for parameter tuning. For a + dict-valued parameter, a range per key instead: + {"V_th": [-60.0, -45.0], "C_m": [200.0, 300.0]} is_objective: Whether this parameter serves as an optimization objective/target objective_range: [min, max] acceptable range for the objective value suggested_values: List of suggested values for the parameter + unit: Physical unit of the value (e.g. "Hz", "pF", "ms") + measures: For an objective, the address of the output value it is compared + against, as "NodeName.output_port[.key...]" (e.g. + "Analysis.firing_rate_hz.exc"). Resolved against a baseline run before + an optimization starts. """ default_value: Any = None description: str = "" constraints: Dict[str, Any] = field(default_factory=dict) optimizable: bool = False - optimization_range: Optional[List[Any]] = None + optimization_range: Optional[Union[List[Any], Dict[str, Any]]] = None is_objective: bool = False objective_range: Optional[List[Any]] = None metadata_sources: List[str] = field(default_factory=list) species_specific: bool = False suggested_values: List[Dict[str, Any]] = field(default_factory=list) + unit: str = "" + measures: Optional[str] = None + + def __post_init__(self) -> None: + """Warn when the search window does not lie inside the constraints. + + ``constraints`` are hard bounds: ``configure()`` rejects values outside + them. ``optimization_range`` only says where a search should look, so a + range reaching past the constraints describes points that could never be + evaluated. + + A dict-valued parameter declares one range per key + (``{"V_th": [-60.0, -45.0]}``). Only the shape of each pair is checked + there: ``constraints`` belongs to the parameter as a whole and cannot + bound an individual key. + + This only warns. A partly-specified optimization declaration must never + stop a node from being imported or uploaded. + """ + if not self.optimization_range: # None or {} or [] all mean "unspecified" + return + + def warn(problem: str) -> None: + hint = self.description[:60] or f"default_value={self.default_value!r}" + warnings.warn( + f"optimization_range {problem} ({hint})", + UserWarning, + stacklevel=3, + ) + + if isinstance(self.optimization_range, dict): + for key, pair in self.optimization_range.items(): + problem = _range_problem(pair) + if problem: + warn(f"for key {key!r} {problem}") + return + + problem = _range_problem(self.optimization_range) + if problem: + warn(problem) + return + + low, high = self.optimization_range + if not all(isinstance(v, (int, float)) for v in (low, high)): + return # non-numeric ranges are not checked against constraints + + c_min = self.constraints.get('min') + c_max = self.constraints.get('max') + if isinstance(c_min, (int, float)) and low < c_min: + warn(f"min {low} is below the constraint min {c_min}") + if isinstance(c_max, (int, float)) and high > c_max: + warn(f"max {high} is above the constraint max {c_max}") @dataclass diff --git a/gui/workflow_backend/django-project/codes/nodes/analysis/NW_Analysis.py b/gui/workflow_backend/django-project/codes/nodes/analysis/NW_Analysis.py index 5817d912..d3bffb15 100644 --- a/gui/workflow_backend/django-project/codes/nodes/analysis/NW_Analysis.py +++ b/gui/workflow_backend/django-project/codes/nodes/analysis/NW_Analysis.py @@ -92,15 +92,25 @@ class NW_Analysis(Node): "the path to the saved PNG file (or None if disabled)." ), ), + "firing_rate_hz": PortDefinition( + type=PortType.DICT, + description=( + "Mean firing rate per population in Hz, keyed by population name: " + "total spikes / (population size x simulation duration). A population " + "of size 1 reports that single neuron's rate. Populations that " + "produced no spikes appear with a rate of 0.0 rather than being " + "omitted. Empty dict if the spikes file cannot be read." + ), + ), }, methods={ "analyze": MethodDefinition( description=( - "Load simulation results and produce spike raster and/or " - "membrane potential trace plots." + "Load simulation results, measure per-population firing rates, and " + "produce spike raster and/or membrane potential trace plots." ), inputs=["results"], - outputs=["figures"], + outputs=["figures", "firing_rate_hz"], ), }, ) @@ -132,6 +142,68 @@ def _detect_populations(self, output_dir: str, report_name: str) -> list: return [] + def _measure_firing_rates(self, config_file: str, output_dir: str) -> Dict[str, float]: + """Mean firing rate per population, in Hz, read from the SONATA output. + + The denominator is the population size from the network files, not the + number of neurons that happened to spike: counting only spiking neurons + would make a mostly-silent network report a healthy rate. + + The network directory comes from the context's ``results_path`` — the same + value NW_SimConfig used to build it — and the spikes file from the + ``output_dir`` that node reports. The config is read only for the run + duration, since its paths are still unexpanded $VAR manifest entries. + """ + try: + import glob + import json + import os + + import h5py + + with open(config_file) as fh: + run = json.load(fh).get("run", {}) + duration_s = (float(run["tstop"]) - float(run.get("tstart", 0.0))) / 1000.0 + if duration_s <= 0: + print(f"[NW_Analysis] firing rate skipped: run duration is {duration_s}s") + return {} + + # Same run root NW_SimConfig used to build the network, and the value + # a re-run updates when it points the workflow at a new results dir. + base_dir = self._context.get("results_path", "results") + network_dir = os.path.join(base_dir, "network") + sizes: Dict[str, int] = {} + for nodes_file in sorted(glob.glob(os.path.join(network_dir, "*_nodes.h5"))): + with h5py.File(nodes_file, "r") as f: + for pop, group in f.get("nodes", {}).items(): + if "node_id" in group: + sizes[pop] = len(group["node_id"]) + + spikes_path = os.path.join(output_dir, "spikes.h5") + if not sizes: + print(f"[NW_Analysis] firing rate skipped: no node files in {network_dir}") + return {} + if not os.path.exists(spikes_path): + print(f"[NW_Analysis] firing rate skipped: no spikes file at {spikes_path}") + return {} + + counts: Dict[str, int] = {} + with h5py.File(spikes_path, "r") as f: + for pop, group in f.get("spikes", {}).items(): + if "timestamps" in group: + counts[pop] = len(group["timestamps"]) + + # A silent population stays in the dict at 0.0: a missing key would turn + # a meaningful result into an unresolvable measurement. + return { + pop: counts.get(pop, 0) / (n * duration_s) + for pop, n in sizes.items() if n > 0 + } + + except Exception as e: + print(f"[NW_Analysis] firing rate measurement skipped: {e}") + return {} + def analyze(self, results: Dict) -> Dict[str, Any]: import os import matplotlib.pyplot as plt @@ -140,6 +212,9 @@ def analyze(self, results: Dict) -> Dict[str, Any]: output_dir = results["output_dir"] p = self._parameters + # Measured before plotting, so it does not depend on the plotting flags. + firing_rate_hz = self._measure_firing_rates(config_file, output_dir) + populations = list(p["populations"]) or self._detect_populations(output_dir, str(p["report_name"])) node_ids = list(p["trace_node_ids"]) or None figures: Dict[str, Any] = {"raster": None, "traces": None} @@ -187,4 +262,4 @@ def analyze(self, results: Dict) -> Dict[str, Any]: except Exception as e: print(f"[NW_Analysis] plot_traces skipped: {e}") - return {"figures": figures} + return {"figures": figures, "firing_rate_hz": firing_rate_hz} diff --git a/src/neuroworkflow/core/schema.py b/src/neuroworkflow/core/schema.py index fb69af58..0b824bcb 100644 --- a/src/neuroworkflow/core/schema.py +++ b/src/neuroworkflow/core/schema.py @@ -5,6 +5,7 @@ node definitions, ports, parameters, and methods in the workflow system. """ +import warnings from dataclasses import dataclass, field from enum import Enum, auto from typing import Dict, List, Union, Any, Type, Optional, Tuple @@ -83,6 +84,23 @@ def is_memory_port(self) -> bool: return not self.is_io_port() +def _range_problem(value: Any) -> Optional[str]: + """Describe what is wrong with a [min, max] pair, or None if it is usable. + + Non-numeric bounds are left alone: a range may legitimately be expressed in + terms this module does not interpret. + """ + if not isinstance(value, (list, tuple)) or len(value) != 2: + return f"must be [min, max], got {value}" + low, high = value + if not all(isinstance(v, (int, float)) and not isinstance(v, bool) + for v in (low, high)): + return None + if low > high: + return f"min {low} is above max {high}" + return None + + @dataclass class ParameterDefinition: """Definition of a parameter in a node. @@ -92,21 +110,80 @@ class ParameterDefinition: description: Human-readable description constraints: Validation constraints (min, max, allowed_values, etc.) optimizable: Whether this parameter can be tuned during optimization - optimization_range: [min, max] range for parameter tuning + optimization_range: [min, max] range for parameter tuning. For a + dict-valued parameter, a range per key instead: + {"V_th": [-60.0, -45.0], "C_m": [200.0, 300.0]} is_objective: Whether this parameter serves as an optimization objective/target objective_range: [min, max] acceptable range for the objective value suggested_values: List of suggested values for the parameter + unit: Physical unit of the value (e.g. "Hz", "pF", "ms") + measures: For an objective, the address of the output value it is compared + against, as "NodeName.output_port[.key...]" (e.g. + "Analysis.firing_rate_hz.exc"). Resolved against a baseline run before + an optimization starts. """ default_value: Any = None description: str = "" constraints: Dict[str, Any] = field(default_factory=dict) optimizable: bool = False - optimization_range: Optional[List[Any]] = None + optimization_range: Optional[Union[List[Any], Dict[str, Any]]] = None is_objective: bool = False objective_range: Optional[List[Any]] = None metadata_sources: List[str] = field(default_factory=list) species_specific: bool = False suggested_values: List[Dict[str, Any]] = field(default_factory=list) + unit: str = "" + measures: Optional[str] = None + + def __post_init__(self) -> None: + """Warn when the search window does not lie inside the constraints. + + ``constraints`` are hard bounds: ``configure()`` rejects values outside + them. ``optimization_range`` only says where a search should look, so a + range reaching past the constraints describes points that could never be + evaluated. + + A dict-valued parameter declares one range per key + (``{"V_th": [-60.0, -45.0]}``). Only the shape of each pair is checked + there: ``constraints`` belongs to the parameter as a whole and cannot + bound an individual key. + + This only warns. A partly-specified optimization declaration must never + stop a node from being imported or uploaded. + """ + if not self.optimization_range: # None or {} or [] all mean "unspecified" + return + + def warn(problem: str) -> None: + hint = self.description[:60] or f"default_value={self.default_value!r}" + warnings.warn( + f"optimization_range {problem} ({hint})", + UserWarning, + stacklevel=3, + ) + + if isinstance(self.optimization_range, dict): + for key, pair in self.optimization_range.items(): + problem = _range_problem(pair) + if problem: + warn(f"for key {key!r} {problem}") + return + + problem = _range_problem(self.optimization_range) + if problem: + warn(problem) + return + + low, high = self.optimization_range + if not all(isinstance(v, (int, float)) for v in (low, high)): + return # non-numeric ranges are not checked against constraints + + c_min = self.constraints.get('min') + c_max = self.constraints.get('max') + if isinstance(c_min, (int, float)) and low < c_min: + warn(f"min {low} is below the constraint min {c_min}") + if isinstance(c_max, (int, float)) and high > c_max: + warn(f"max {high} is above the constraint max {c_max}") @dataclass diff --git a/src/neuroworkflow/nodes/analysis/NW_Analysis.py b/src/neuroworkflow/nodes/analysis/NW_Analysis.py index 5817d912..d3bffb15 100644 --- a/src/neuroworkflow/nodes/analysis/NW_Analysis.py +++ b/src/neuroworkflow/nodes/analysis/NW_Analysis.py @@ -92,15 +92,25 @@ class NW_Analysis(Node): "the path to the saved PNG file (or None if disabled)." ), ), + "firing_rate_hz": PortDefinition( + type=PortType.DICT, + description=( + "Mean firing rate per population in Hz, keyed by population name: " + "total spikes / (population size x simulation duration). A population " + "of size 1 reports that single neuron's rate. Populations that " + "produced no spikes appear with a rate of 0.0 rather than being " + "omitted. Empty dict if the spikes file cannot be read." + ), + ), }, methods={ "analyze": MethodDefinition( description=( - "Load simulation results and produce spike raster and/or " - "membrane potential trace plots." + "Load simulation results, measure per-population firing rates, and " + "produce spike raster and/or membrane potential trace plots." ), inputs=["results"], - outputs=["figures"], + outputs=["figures", "firing_rate_hz"], ), }, ) @@ -132,6 +142,68 @@ def _detect_populations(self, output_dir: str, report_name: str) -> list: return [] + def _measure_firing_rates(self, config_file: str, output_dir: str) -> Dict[str, float]: + """Mean firing rate per population, in Hz, read from the SONATA output. + + The denominator is the population size from the network files, not the + number of neurons that happened to spike: counting only spiking neurons + would make a mostly-silent network report a healthy rate. + + The network directory comes from the context's ``results_path`` — the same + value NW_SimConfig used to build it — and the spikes file from the + ``output_dir`` that node reports. The config is read only for the run + duration, since its paths are still unexpanded $VAR manifest entries. + """ + try: + import glob + import json + import os + + import h5py + + with open(config_file) as fh: + run = json.load(fh).get("run", {}) + duration_s = (float(run["tstop"]) - float(run.get("tstart", 0.0))) / 1000.0 + if duration_s <= 0: + print(f"[NW_Analysis] firing rate skipped: run duration is {duration_s}s") + return {} + + # Same run root NW_SimConfig used to build the network, and the value + # a re-run updates when it points the workflow at a new results dir. + base_dir = self._context.get("results_path", "results") + network_dir = os.path.join(base_dir, "network") + sizes: Dict[str, int] = {} + for nodes_file in sorted(glob.glob(os.path.join(network_dir, "*_nodes.h5"))): + with h5py.File(nodes_file, "r") as f: + for pop, group in f.get("nodes", {}).items(): + if "node_id" in group: + sizes[pop] = len(group["node_id"]) + + spikes_path = os.path.join(output_dir, "spikes.h5") + if not sizes: + print(f"[NW_Analysis] firing rate skipped: no node files in {network_dir}") + return {} + if not os.path.exists(spikes_path): + print(f"[NW_Analysis] firing rate skipped: no spikes file at {spikes_path}") + return {} + + counts: Dict[str, int] = {} + with h5py.File(spikes_path, "r") as f: + for pop, group in f.get("spikes", {}).items(): + if "timestamps" in group: + counts[pop] = len(group["timestamps"]) + + # A silent population stays in the dict at 0.0: a missing key would turn + # a meaningful result into an unresolvable measurement. + return { + pop: counts.get(pop, 0) / (n * duration_s) + for pop, n in sizes.items() if n > 0 + } + + except Exception as e: + print(f"[NW_Analysis] firing rate measurement skipped: {e}") + return {} + def analyze(self, results: Dict) -> Dict[str, Any]: import os import matplotlib.pyplot as plt @@ -140,6 +212,9 @@ def analyze(self, results: Dict) -> Dict[str, Any]: output_dir = results["output_dir"] p = self._parameters + # Measured before plotting, so it does not depend on the plotting flags. + firing_rate_hz = self._measure_firing_rates(config_file, output_dir) + populations = list(p["populations"]) or self._detect_populations(output_dir, str(p["report_name"])) node_ids = list(p["trace_node_ids"]) or None figures: Dict[str, Any] = {"raster": None, "traces": None} @@ -187,4 +262,4 @@ def analyze(self, results: Dict) -> Dict[str, Any]: except Exception as e: print(f"[NW_Analysis] plot_traces skipped: {e}") - return {"figures": figures} + return {"figures": figures, "firing_rate_hz": firing_rate_hz} diff --git a/src/neuroworkflow/optimization/__init__.py b/src/neuroworkflow/optimization/__init__.py new file mode 100644 index 00000000..9d1453fb --- /dev/null +++ b/src/neuroworkflow/optimization/__init__.py @@ -0,0 +1,45 @@ +"""Parameter optimization for NeuroWorkflow workflows. + +The workflow is the objective function; the optimizer wraps it. Typical use:: + + from neuroworkflow.optimization import build_spec, optimize, AlgorithmConfig + + spec = build_spec(workflow, AlgorithmConfig(name="cmaes", pop_size=12)) + print(spec.summary()) # review, edit, or hand to an agent + result = optimize(workflow, spec=spec) + print(result.configure_snippet()) +""" + +from .addressing import discover_measurables, read_output, set_parameter +from .engine import OptimizationResult, objective_fitness, optimize +from .ledger import Ledger +from .optimizers import Optimizer, available, register_optimizer +from .spec import ( + AlgorithmConfig, + Dimension, + Objective, + OptimizationSpec, + build_spec, + collect_dimensions, + collect_objectives, +) + +__all__ = [ + "AlgorithmConfig", + "Dimension", + "Ledger", + "Objective", + "OptimizationResult", + "OptimizationSpec", + "Optimizer", + "available", + "build_spec", + "collect_dimensions", + "collect_objectives", + "discover_measurables", + "objective_fitness", + "optimize", + "read_output", + "register_optimizer", + "set_parameter", +] diff --git a/src/neuroworkflow/optimization/addressing.py b/src/neuroworkflow/optimization/addressing.py new file mode 100644 index 00000000..d53f1f97 --- /dev/null +++ b/src/neuroworkflow/optimization/addressing.py @@ -0,0 +1,132 @@ +"""Dotted addresses into a workflow. + +Two kinds of address are used by the optimizer, both rooted at a node name: + +* a **parameter** address names something to set — ``"Model.nest_params.C_m"`` +* a **measurement** address names something to read — ``"Analysis.firing_rate_hz.exc"`` + +The first segment is always the node name. The second is the parameter or output +port name. Any further segments index into a nested dict. +""" + +from copy import deepcopy +from typing import Any, Dict, List, Tuple + +# Deeper than this and an "objective" is almost certainly a data structure +# rather than a measured quantity. +MAX_LEAF_DEPTH = 4 + + +def split_address(address: str) -> Tuple[str, str, List[str]]: + """Split ``"Node.port.k1.k2"`` into ``("Node", "port", ["k1", "k2"])``.""" + parts = address.split(".") + if len(parts) < 2: + raise ValueError( + f"Address {address!r} must be at least 'Node.name' " + f"(e.g. 'Analysis.firing_rate_hz.exc')" + ) + return parts[0], parts[1], parts[2:] + + +def _get_node(workflow, node_name: str): + if node_name not in workflow.nodes: + raise KeyError( + f"No node named {node_name!r} in the workflow " + f"(have: {', '.join(sorted(workflow.nodes))})" + ) + return workflow.nodes[node_name] + + +def set_parameter(workflow, address: str, value: Any) -> None: + """Set a parameter by dotted address, going through ``Node.configure()``. + + ``configure()`` only accepts whole parameters, so a nested key is applied by + copying the current dict, updating the key, and configuring the result. The + copy matters: mutating the live dict in place would edit the node's state + even if ``configure()`` then rejected the value. + """ + node_name, param, keys = split_address(address) + node = _get_node(workflow, node_name) + + if param not in node._parameters: + raise KeyError( + f"Node {node_name!r} has no parameter {param!r} " + f"(have: {', '.join(sorted(node._parameters))})" + ) + + if not keys: + node.configure(**{param: value}) + return + + current = deepcopy(node._parameters[param]) + if not isinstance(current, dict): + raise TypeError( + f"Address {address!r} indexes into {param!r}, but it holds " + f"{type(current).__name__}, not a dict" + ) + + target = current + for k in keys[:-1]: + if not isinstance(target.get(k), dict): + raise KeyError(f"Address {address!r}: {k!r} is not a nested dict") + target = target[k] + target[keys[-1]] = value + + node.configure(**{param: current}) + + +def read_output(workflow, address: str) -> Any: + """Read a value from an output port by dotted address.""" + node_name, port, keys = split_address(address) + node = _get_node(workflow, node_name) + + if port not in node._output_ports: + raise KeyError( + f"Node {node_name!r} has no output port {port!r} " + f"(have: {', '.join(sorted(node._output_ports))})" + ) + + value = node._output_ports[port].value + for k in keys: + if not isinstance(value, dict): + raise TypeError( + f"Address {address!r}: cannot index {type(value).__name__} with {k!r}" + ) + if k not in value: + raise KeyError( + f"Address {address!r}: key {k!r} not in " + f"{', '.join(map(str, list(value)[:8]))}" + ) + value = value[k] + return value + + +def _is_number(value: Any) -> bool: + # bool is an int subclass but is never a measured quantity. + return isinstance(value, (int, float)) and not isinstance(value, bool) + + +def discover_measurables(workflow) -> Dict[str, float]: + """Walk every output port and collect the numeric leaves it currently holds. + + This is what makes ``measures`` usable: the candidate targets come from the + data a baseline run actually produced, not from a declaration a node author + had to anticipate. Lists and arrays are skipped on purpose — a target that + needs a reduction belongs in an analysis node as its own named output. + """ + found: Dict[str, float] = {} + + def walk(prefix: str, value: Any, depth: int) -> None: + if _is_number(value): + found[prefix] = float(value) + return + if isinstance(value, dict) and depth < MAX_LEAF_DEPTH: + for k, v in value.items(): + if isinstance(k, str): + walk(f"{prefix}.{k}", v, depth + 1) + + for node_name, node in workflow.nodes.items(): + for port_name, port in node._output_ports.items(): + walk(f"{node_name}.{port_name}", port.value, 1) + + return found diff --git a/src/neuroworkflow/optimization/engine.py b/src/neuroworkflow/optimization/engine.py new file mode 100644 index 00000000..2f2dd2c2 --- /dev/null +++ b/src/neuroworkflow/optimization/engine.py @@ -0,0 +1,357 @@ +"""The optimization loop. + +The workflow is the objective function; the optimizer is the outer loop. A +workflow is a DAG and runs feed-forward once, so the loop cannot live inside it — +it sits outside and calls the workflow repeatedly: + + ask -> configure nodes -> workflow.execute() -> read measured values + -> fitness -> tell -> log -> repeat + +The workflow is built once and reconfigured between trials; it is never rebuilt. + +The loop is fully usable with no agent attached: it narrates to stdout, writes the +ledger, and stops on its own. An agent or a GUI panel participates by reading the +ledger and writing ``control.json`` — nothing here requires that to happen. +""" + +import time +from dataclasses import dataclass, field +from datetime import datetime +from typing import Any, Callable, Dict, List, Optional + +from .addressing import read_output, set_parameter +from .ledger import Ledger +from .optimizers import create_optimizer +from .spec import AlgorithmConfig, Objective, OptimizationSpec, build_spec + +#: A hook that inspects a trial's outputs and returns a reason to reject it, or +#: None to accept. A scalar fitness cannot tell a healthy network from a +#: pathological one that merely averages to the right number — this is where that +#: judgement plugs in. +RejectFn = Callable[[Any, Dict[str, float]], Optional[str]] + + +@dataclass +class OptimizationResult: + run_id: str + run_dir: str + spec: OptimizationSpec + trials: List[Dict[str, Any]] = field(default_factory=list) + best: Optional[Dict[str, Any]] = None + pareto_front: List[Dict[str, Any]] = field(default_factory=list) + stop_reason: str = "" + + def configure_snippet(self) -> str: + """A ready-to-paste snippet applying the best configuration.""" + if not self.best: + return "# no successful trial" + by_node: Dict[str, Dict[str, Any]] = {} + for address, value in self.best["params"].items(): + node, _, rest = address.partition(".") + by_node.setdefault(node, {})[rest] = value + lines = [] + for node, params in by_node.items(): + args = ", ".join(f"{k.replace('.', '__')}={v!r}" for k, v in params.items()) + lines.append(f"{node}.configure({args})") + return "\n".join(lines) + + +# --------------------------------------------------------------------------- +# Fitness +# --------------------------------------------------------------------------- + +def objective_fitness(objective: Objective, value: float) -> float: + """Distance from the target, always minimized. + + ``in_range`` is zero anywhere inside the band and grows with the distance + outside it — a band, not a point, so seed-to-seed noise is absorbed rather + than chased. + """ + if objective.goal == "minimize": + return float(value) + if objective.goal == "maximize": + return -float(value) + if value < objective.low: + return float(objective.low - value) + if value > objective.high: + return float(value - objective.high) + return 0.0 + + +def _dominates(a: List[float], b: List[float]) -> bool: + return all(x <= y for x, y in zip(a, b)) and any(x < y for x, y in zip(a, b)) + + +def _pareto_front(rows: List[Dict[str, Any]]) -> List[Dict[str, Any]]: + scored = [r for r in rows if r.get("fitness")] + return [ + r for r in scored + if not any(_dominates(o["fitness"], r["fitness"]) + for o in scored if o is not r) + ] + + +# --------------------------------------------------------------------------- +# The loop +# --------------------------------------------------------------------------- + +def optimize(workflow, + spec: Optional[OptimizationSpec] = None, + results_path: str = "results/optimization", + algorithm: Optional[AlgorithmConfig] = None, + reject_fn: Optional[RejectFn] = None, + run_id: Optional[str] = None, + verbose: bool = True) -> OptimizationResult: + """Optimize a built workflow against the targets declared in its schemas. + + Args: + workflow: a built workflow that already runs at its current parameters. + spec: the optimization spec. Built by introspection when omitted — which + also runs the workflow once to establish the baseline. + results_path: directory the run directory is created under. + algorithm: algorithm config, when letting the spec be built here. + reject_fn: optional dynamics check; return a reason to reject a trial. + run_id: overrides the generated run id. + verbose: narrate progress to stdout. + """ + if spec is None: + spec = build_spec(workflow, algorithm=algorithm) + elif algorithm is not None: + spec.algorithm = algorithm + spec.validate() + + run_id = run_id or f"opt_{datetime.now().strftime('%Y%m%d_%H%M%S')}" + ledger = Ledger(f"{results_path}/{run_id}", run_id) + ledger.write_manifest(spec, extra={ + "created_at": datetime.now().isoformat(timespec="seconds"), + "workflow_name": getattr(workflow, "name", ""), + }) + + optimizer = create_optimizer(spec.dimensions, len(spec.objectives), spec.algorithm) + + def say(message: str) -> None: + if verbose: + print(message, flush=True) + + say(f"[{run_id}] {spec.algorithm.name}: " + f"{len(spec.dimensions)} dimensions, {len(spec.objectives)} objective(s), " + f"up to {spec.algorithm.max_generations} generations " + f"x {spec.algorithm.pop_size} candidates") + for line in spec.summary().splitlines(): + say(" " + line) + + trials: List[Dict[str, Any]] = [] + best_by_generation: List[Optional[float]] = [] + control_ack: Optional[Dict[str, Any]] = None + stop_reason = "" + paused = False + trial_no = 0 + + for generation in range(1, spec.algorithm.max_generations + 1): + candidates = optimizer.ask() + fitnesses: List[Optional[List[float]]] = [] + + for index, candidate in enumerate(candidates): + trial_no += 1 + row = _evaluate(workflow, spec, candidate, reject_fn, + trial_no, generation, index) + fitnesses.append(row["fitness"]) + trials.append(row) + ledger.append_trial(row) + + optimizer.tell(candidates, fitnesses) + + scored = [t for t in trials if t["fitness"] is not None] + best = min(scored, key=lambda t: sum(t["fitness"]), default=None) + best_by_generation.append(round(sum(best["fitness"]), 6) if best else None) + + in_range = bool(best and all(f == 0.0 for f in best["fitness"])) + n_failed = sum(1 for t in trials if t["status"] == "failed") + n_rejected = sum(1 for t in trials if t["status"] == "rejected") + + # Stop conditions, checked before honouring control so an explicit + # command always wins over an automatic stop. + if in_range: + stop_reason = "a candidate is inside every target band" + + command = ledger.read_control() + if command: + control_ack, stop_reason, paused = _apply_control( + command, optimizer, say, stop_reason, paused) + + ledger.write_status({ + "state": "done" if stop_reason else ("paused" if paused else "running"), + "updated_at": datetime.now().isoformat(timespec="seconds"), + "generation": generation, + "max_generations": spec.algorithm.max_generations, + "n_evals": len(trials), + "n_ok": len(scored), + "n_failed": n_failed, + "n_rejected": n_rejected, + "best": best, + "pareto_front": _pareto_front(trials) if len(spec.objectives) > 1 else [], + "progress": { + "best_fitness_by_gen": best_by_generation, + "gens_since_improvement": _gens_since_improvement(best_by_generation), + }, + "control_ack": control_ack, + "stop_reason": stop_reason or None, + "message": _narrate(generation, spec, best, in_range, + n_failed, n_rejected), + }) + + say(f" gen {generation}/{spec.algorithm.max_generations}: " + + _narrate(generation, spec, best, in_range, n_failed, n_rejected)) + + if stop_reason: + break + while paused: + time.sleep(2) + command = ledger.read_control() + if command: + control_ack, stop_reason, paused = _apply_control( + command, optimizer, say, stop_reason, paused) + if stop_reason: + break + if stop_reason: + break + else: + stop_reason = "generation budget exhausted" + + scored = [t for t in trials if t["fitness"] is not None] + best = min(scored, key=lambda t: sum(t["fitness"]), default=None) + say(f"[{run_id}] stopped: {stop_reason}") + + return OptimizationResult( + run_id=run_id, + run_dir=str(ledger.run_dir), + spec=spec, + trials=trials, + best=best, + pareto_front=_pareto_front(trials) if len(spec.objectives) > 1 else [], + stop_reason=stop_reason, + ) + + +def _evaluate(workflow, spec, candidate, reject_fn, + trial_no: int, generation: int, index: int) -> Dict[str, Any]: + """Run one candidate and produce its ledger row.""" + started = time.time() + row: Dict[str, Any] = { + "trial": trial_no, + "generation": generation, + "candidate": index, + "started_at": datetime.now().isoformat(timespec="seconds"), + "source": "ask", + "params": dict(candidate), + "measured": {}, + "fitness": None, + "status": "ok", + "reject_reason": None, + "error": None, + } + + try: + for address, value in candidate.items(): + set_parameter(workflow, address, value) + + if not workflow.execute(): + row.update(status="failed", error="workflow.execute() returned False") + return _finish(row, started) + + measured = {} + for objective in spec.objectives: + value = read_output(workflow, objective.measures) + if not isinstance(value, (int, float)) or isinstance(value, bool): + row.update(status="failed", + error=f"{objective.measures} is not numeric: {value!r}") + return _finish(row, started) + measured[objective.name] = float(value) + row["measured"] = measured + + if reject_fn is not None: + reason = reject_fn(workflow, measured) + if reason: + row.update(status="rejected", reject_reason=reason) + return _finish(row, started) + + row["fitness"] = [objective_fitness(o, measured[o.name]) + for o in spec.objectives] + + except Exception as exc: # a bad candidate must not kill the run + row.update(status="failed", error=f"{type(exc).__name__}: {exc}") + + return _finish(row, started) + + +def _finish(row: Dict[str, Any], started: float) -> Dict[str, Any]: + row["duration_s"] = round(time.time() - started, 3) + return row + + +def _apply_control(command, optimizer, say, stop_reason: str, paused: bool): + """Apply a control command and build the acknowledgement for status.json.""" + name = command.get("command", "") + args = command.get("args", {}) or {} + result = "" + + if name == "stop": + stop_reason = f"stopped by {command.get('issued_by', 'control.json')}" + result = "stopping" + elif name == "pause": + paused, result = True, "paused" + elif name == "resume": + paused, result = False, "resumed" + elif name == "inject": + accepted = 0 + for params in args.get("candidates", []): + try: + optimizer.enqueue(params) + accepted += 1 + except NotImplementedError: + result = f"{type(optimizer).__name__} cannot inject candidates" + break + result = result or f"{accepted} candidate(s) injected" + else: + result = f"unknown command {name!r}" + + say(f" control: {name} -> {result}") + return ( + { + "seq": command.get("seq"), + "command": name, + "issued_by": command.get("issued_by"), + "reason": command.get("reason"), + "applied_at": datetime.now().isoformat(timespec="seconds"), + "result": result, + }, + stop_reason, + paused, + ) + + +def _gens_since_improvement(history: List[Optional[float]]) -> int: + scored = [h for h in history if h is not None] + if not scored: + return 0 + best = min(scored) + for count, value in enumerate(reversed(history)): + if value is not None and value <= best: + return count + return len(history) + + +def _narrate(generation, spec, best, in_range, n_failed, n_rejected) -> str: + if best is None: + return "no candidate has produced a usable measurement yet" + values = ", ".join( + f"{o.name.split('.')[-1]}={best['measured'][o.name]:.4g}" + f"{' ' + o.unit if o.unit else ''}" + for o in spec.objectives + ) + state = "inside every target band" if in_range else \ + f"distance {sum(best['fitness']):.4g}" + extra = "" + if n_failed or n_rejected: + extra = f" ({n_failed} failed, {n_rejected} rejected)" + return f"best {values} — {state}{extra}" diff --git a/src/neuroworkflow/optimization/ledger.py b/src/neuroworkflow/optimization/ledger.py new file mode 100644 index 00000000..9148830f --- /dev/null +++ b/src/neuroworkflow/optimization/ledger.py @@ -0,0 +1,100 @@ +"""The ledger — the run's durable record and its steering seam. + +Everything the engine knows is written to plain files in the run directory, and +everything that steers the engine is read from one. No sockets, no queues: an +agent, a notebook or a GUI panel participates by reading and writing files. + + run.json manifest, written once + trials.jsonl one line per evaluation, append-only + status.json replaced each generation, the cheap poll + control.json written by a human or agent to steer the loop + +Write discipline: whole-file writes go through a temp file and ``os.replace`` so a +reader never sees half a document; ``trials.jsonl`` is appended and flushed per +line, so the only partial read possible is a truncated last line. +""" + +import json +import os +from pathlib import Path +from typing import Any, Dict, List, Optional + +SCHEMA_VERSION = 1 + + +def _write_atomic(path: Path, payload: Dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + with open(tmp, "w") as fh: + json.dump(payload, fh, indent=2, default=str) + os.replace(tmp, path) + + +class Ledger: + """Writes the run record; reads control commands.""" + + def __init__(self, run_dir: str, run_id: str): + self.run_dir = Path(run_dir) + self.run_id = run_id + self.run_dir.mkdir(parents=True, exist_ok=True) + self.run_path = self.run_dir / "run.json" + self.trials_path = self.run_dir / "trials.jsonl" + self.status_path = self.run_dir / "status.json" + self.control_path = self.run_dir / "control.json" + self._last_control_seq = 0 + + # -- writes ---------------------------------------------------------- + def write_manifest(self, spec, extra: Optional[Dict[str, Any]] = None) -> None: + payload = { + "schema_version": SCHEMA_VERSION, + "run_id": self.run_id, + **(extra or {}), + **spec.to_dict(), + } + _write_atomic(self.run_path, payload) + + def append_trial(self, trial: Dict[str, Any]) -> None: + with open(self.trials_path, "a") as fh: + fh.write(json.dumps({"schema_version": SCHEMA_VERSION, **trial}, + default=str) + "\n") + fh.flush() + + def write_status(self, status: Dict[str, Any]) -> None: + _write_atomic(self.status_path, { + "schema_version": SCHEMA_VERSION, + "run_id": self.run_id, + **status, + }) + + # -- reads ----------------------------------------------------------- + def read_trials(self) -> List[Dict[str, Any]]: + """Read every logged trial, tolerating a truncated final line.""" + if not self.trials_path.exists(): + return [] + rows = [] + for line in self.trials_path.read_text().splitlines(): + try: + rows.append(json.loads(line)) + except json.JSONDecodeError: + continue # a partially written tail line + return rows + + def read_control(self) -> Optional[Dict[str, Any]]: + """Return a control command if a new one has been written. + + A command is applied at most once: it is only returned when its ``seq`` + is higher than the last one acknowledged, which the writer can confirm by + reading ``control_ack`` back from ``status.json``. + """ + if not self.control_path.exists(): + return None + try: + command = json.loads(self.control_path.read_text()) + except (json.JSONDecodeError, OSError): + return None # being written right now; try again next generation + + seq = command.get("seq", 0) + if not isinstance(seq, int) or seq <= self._last_control_seq: + return None + + self._last_control_seq = seq + return command diff --git a/src/neuroworkflow/optimization/optimizers.py b/src/neuroworkflow/optimization/optimizers.py new file mode 100644 index 00000000..b81649b3 --- /dev/null +++ b/src/neuroworkflow/optimization/optimizers.py @@ -0,0 +1,208 @@ +"""Optimizer backends behind one ask / tell interface. + +The engine never talks to a search library directly. It asks for a generation of +candidates, evaluates them, and tells the fitnesses back. Everything else — +which algorithm, how it adapts, whether it is population-based — lives behind +this interface. + +Adding an algorithm: + +* if the library is Optuna, add one entry to ``_OPTUNA_SAMPLERS`` +* otherwise, subclass ``Optimizer`` and call ``register_optimizer`` + +Fitness is always a **list**, one entry per objective, and always **minimized** +(the engine converts targets into distances). Single-objective backends refuse a +multi-objective spec rather than silently collapsing it into a weighted sum. +""" + +import random +from abc import ABC, abstractmethod +from typing import Any, Callable, Dict, List, Optional, Sequence, Type + +from .spec import AlgorithmConfig, Dimension + + +class Optimizer(ABC): + """Proposes parameter vectors and learns from their fitnesses.""" + + #: Can this backend handle more than one objective at a time? + supports_multi_objective: bool = False + + def __init__(self, dimensions: Sequence[Dimension], n_objectives: int, + config: AlgorithmConfig): + if n_objectives > 1 and not self.supports_multi_objective: + raise ValueError( + f"{type(self).__name__} is single-objective but the spec declares " + f"{n_objectives} objectives. Choose a multi-objective algorithm " + f"(e.g. 'nsga2') — the engine will not collapse them into a " + f"weighted sum on its own." + ) + self.dimensions = list(dimensions) + self.n_objectives = n_objectives + self.config = config + + @abstractmethod + def ask(self) -> List[Dict[str, float]]: + """Propose the next generation as a list of {address: value} dicts.""" + + @abstractmethod + def tell(self, candidates: List[Dict[str, float]], + fitnesses: List[List[float]]) -> None: + """Report the measured fitness of each candidate from the last ``ask``.""" + + def enqueue(self, params: Dict[str, float]) -> None: + """Seed a chosen candidate into the next generation. + + Backends that cannot honour this should leave it as a no-op; the engine + logs whether an injection was accepted. + """ + raise NotImplementedError( + f"{type(self).__name__} does not support injecting candidates" + ) + + +# --------------------------------------------------------------------------- +# Registry +# --------------------------------------------------------------------------- + +_REGISTRY: Dict[str, Callable[..., Optimizer]] = {} + + +def register_optimizer(name: str, factory: Callable[..., Optimizer]) -> None: + _REGISTRY[name] = factory + + +def available() -> List[str]: + return sorted(_REGISTRY) + + +def create_optimizer(dimensions: Sequence[Dimension], n_objectives: int, + config: AlgorithmConfig) -> Optimizer: + if config.name not in _REGISTRY: + raise ValueError( + f"Unknown algorithm {config.name!r}. Available: {', '.join(available())}" + ) + return _REGISTRY[config.name](dimensions, n_objectives, config) + + +# --------------------------------------------------------------------------- +# RandomSearch — no dependencies, so the engine is always runnable +# --------------------------------------------------------------------------- + +class RandomSearch(Optimizer): + """Uniform sampling inside the bounds. A baseline, and the smoke test.""" + + supports_multi_objective = True + + def __init__(self, dimensions, n_objectives, config): + super().__init__(dimensions, n_objectives, config) + self._rng = random.Random(config.seed) + self._queued: List[Dict[str, float]] = [] + + def ask(self) -> List[Dict[str, float]]: + out: List[Dict[str, float]] = [] + while self._queued and len(out) < self.config.pop_size: + out.append(self._queued.pop(0)) + while len(out) < self.config.pop_size: + out.append({d.address: self._rng.uniform(d.low, d.high) + for d in self.dimensions}) + return out + + def tell(self, candidates, fitnesses) -> None: + pass # memoryless by design + + def enqueue(self, params: Dict[str, float]) -> None: + self._queued.append(dict(params)) + + +register_optimizer("random", RandomSearch) + + +# --------------------------------------------------------------------------- +# Optuna backends — CMA-ES, NSGA-II, NSGA-III, TPE, ... +# --------------------------------------------------------------------------- + +#: name -> (optuna sampler class attribute, multi-objective?, extra sampler kwargs) +_OPTUNA_SAMPLERS: Dict[str, tuple] = { + "cmaes": ("CmaEsSampler", False, {}), + "nsga2": ("NSGAIISampler", True, {}), + "nsga3": ("NSGAIIISampler", True, {}), + "tpe": ("TPESampler", True, {}), + "optuna_random": ("RandomSampler", True, {}), +} + + +class OptunaOptimizer(Optimizer): + """Adapter over Optuna's ask/tell API. + + Optuna hands out one trial at a time; a generation is simply ``pop_size`` + consecutive asks. Population-based samplers (NSGA-II/III) manage their own + generations internally, so this stays correct for them too. + """ + + def __init__(self, dimensions, n_objectives, config, sampler_name: str, + multi_objective: bool, sampler_kwargs: Dict[str, Any]): + self.supports_multi_objective = multi_objective + super().__init__(dimensions, n_objectives, config) + + try: + import optuna + from optuna.distributions import FloatDistribution + except ImportError as exc: # pragma: no cover - depends on environment + raise ImportError( + f"The {config.name!r} algorithm needs Optuna. " + f"Install it with: pip install optuna cmaes" + ) from exc + + optuna.logging.set_verbosity(optuna.logging.WARNING) + + sampler_cls = getattr(optuna.samplers, sampler_name, None) + if sampler_cls is None: # pragma: no cover - depends on optuna version + raise ImportError( + f"This Optuna version has no {sampler_name} " + f"(needed for algorithm {config.name!r})" + ) + + kwargs = dict(sampler_kwargs) + kwargs.update(config.options) + if config.seed is not None: + kwargs.setdefault("seed", config.seed) + if sampler_name.startswith("NSGA"): + kwargs.setdefault("population_size", config.pop_size) + + self._optuna = optuna + self._distributions = { + d.address: FloatDistribution(d.low, d.high) for d in self.dimensions + } + self._study = optuna.create_study( + directions=["minimize"] * n_objectives, + sampler=sampler_cls(**kwargs), + ) + self._pending: List[Any] = [] + + def ask(self) -> List[Dict[str, float]]: + self._pending = [self._study.ask(self._distributions) + for _ in range(self.config.pop_size)] + return [dict(t.params) for t in self._pending] + + def tell(self, candidates, fitnesses) -> None: + for trial, fitness in zip(self._pending, fitnesses): + if fitness is None: + self._study.tell(trial, state=self._optuna.trial.TrialState.FAIL) + else: + self._study.tell(trial, list(fitness)) + self._pending = [] + + def enqueue(self, params: Dict[str, float]) -> None: + self._study.enqueue_trial(dict(params), skip_if_exists=False) + + +def _make_optuna_factory(sampler_name: str, multi: bool, kwargs: Dict[str, Any]): + def factory(dimensions, n_objectives, config): + return OptunaOptimizer(dimensions, n_objectives, config, + sampler_name, multi, kwargs) + return factory + + +for _name, (_sampler, _multi, _kwargs) in _OPTUNA_SAMPLERS.items(): + register_optimizer(_name, _make_optuna_factory(_sampler, _multi, _kwargs)) diff --git a/src/neuroworkflow/optimization/spec.py b/src/neuroworkflow/optimization/spec.py new file mode 100644 index 00000000..b2feecba --- /dev/null +++ b/src/neuroworkflow/optimization/spec.py @@ -0,0 +1,358 @@ +"""The optimization spec — what to tune, what to hit, and with which algorithm. + +The spec is plain data. It is built from the node schemas by introspection, then +handed to a human or an agent to review and edit, then consumed by the engine and +frozen into ``run.json``. Nothing in it is Python-specific, so an agent can change +the algorithm, widen a range or retarget a band without touching code. +""" + +from dataclasses import dataclass, field, asdict +from typing import Any, Dict, List, Optional + +from neuroworkflow.core.schema import ParameterDefinition + +from .addressing import discover_measurables + + +@dataclass +class Dimension: + """One axis of the search space.""" + + address: str # "Model.nest_params.C_m" + low: float + high: float + unit: str = "" + description: str = "" + source: str = "" # where the range came from + note: str = "" # e.g. why it was clipped + + +@dataclass +class Objective: + """One target the search is steering toward.""" + + name: str # "Population_exc.target_rate_hz" + measures: str # "Analysis.firing_rate_hz.exc" + low: Optional[float] = None # target band, for goal="in_range" + high: Optional[float] = None + goal: str = "in_range" # in_range | minimize | maximize + unit: str = "" + description: str = "" + source: str = "" + + +@dataclass +class AlgorithmConfig: + """Which optimizer to run and how. Editable by a human or an agent.""" + + name: str = "random" # see optimizers.available() + pop_size: int = 16 + max_generations: int = 20 + seed: Optional[int] = None + options: Dict[str, Any] = field(default_factory=dict) + + +@dataclass +class OptimizationSpec: + dimensions: List[Dimension] = field(default_factory=list) + objectives: List[Objective] = field(default_factory=list) + algorithm: AlgorithmConfig = field(default_factory=AlgorithmConfig) + locked_protocol: Dict[str, Any] = field(default_factory=dict) + baseline: Dict[str, Any] = field(default_factory=dict) + skipped: List[Dict[str, str]] = field(default_factory=list) + + # -- serialization --------------------------------------------------- + def to_dict(self) -> Dict[str, Any]: + return asdict(self) + + @classmethod + def from_dict(cls, data: Dict[str, Any]) -> "OptimizationSpec": + return cls( + dimensions=[Dimension(**d) for d in data.get("dimensions", [])], + objectives=[Objective(**o) for o in data.get("objectives", [])], + algorithm=AlgorithmConfig(**data.get("algorithm", {})), + locked_protocol=data.get("locked_protocol", {}), + baseline=data.get("baseline", {}), + skipped=data.get("skipped", []), + ) + + # -- validation ------------------------------------------------------ + def validate(self) -> None: + """Raise if the spec cannot be run. Called by the engine before starting.""" + if not self.dimensions: + raise ValueError( + "No search dimensions — mark at least one parameter " + "optimizable=True with a range, or add a Dimension by hand." + ) + if not self.objectives: + raise ValueError( + "No objectives — optimization without a target has no direction. " + "Declare is_objective=True with objective_range and measures, or " + "add an Objective by hand." + ) + for d in self.dimensions: + if d.low >= d.high: + raise ValueError(f"Dimension {d.address}: low {d.low} >= high {d.high}") + for o in self.objectives: + if o.goal not in ("in_range", "minimize", "maximize"): + raise ValueError(f"Objective {o.name}: unknown goal {o.goal!r}") + if o.goal == "in_range" and (o.low is None or o.high is None): + raise ValueError( + f"Objective {o.name}: goal 'in_range' needs both low and high " + f"(set objective_range on the parameter)" + ) + + def summary(self) -> str: + lines = [ + f"algorithm : {self.algorithm.name} " + f"(pop_size={self.algorithm.pop_size}, " + f"max_generations={self.algorithm.max_generations})", + f"dimensions: {len(self.dimensions)}", + ] + for d in self.dimensions: + unit = f" {d.unit}" if d.unit else "" + note = f" [{d.note}]" if d.note else "" + lines.append(f" {d.address:<40} [{d.low}, {d.high}]{unit}{note}") + lines.append(f"objectives: {len(self.objectives)}") + for o in self.objectives: + band = ( + f"in [{o.low}, {o.high}]" if o.goal == "in_range" else o.goal + ) + unit = f" {o.unit}" if o.unit else "" + lines.append(f" {o.name:<40} {band}{unit} <- {o.measures}") + if self.skipped: + lines.append(f"skipped : {len(self.skipped)}") + for s in self.skipped: + lines.append(f" {s['address']:<40} {s['reason']}") + return "\n".join(lines) + + +# --------------------------------------------------------------------------- +# Building a spec from the node schemas +# --------------------------------------------------------------------------- + +def _numeric_pair(value: Any) -> Optional[List[float]]: + if isinstance(value, (list, tuple)) and len(value) == 2: + if all(isinstance(v, (int, float)) and not isinstance(v, bool) for v in value): + return [float(value[0]), float(value[1])] + return None + + +def collect_dimensions(workflow) -> tuple: + """Collect search dimensions from every ``optimizable=True`` parameter. + + Returns ``(dimensions, skipped)``. A parameter is skipped rather than + guessed at when no usable range can be derived — the engine reports those so + a human or agent can supply ranges deliberately. + """ + dimensions: List[Dimension] = [] + skipped: List[Dict[str, str]] = [] + + for node_name, node in workflow.nodes.items(): + params = getattr(type(node), "NODE_DEFINITION", None) + if params is None: + continue + for pname, pdef in params.parameters.items(): + if not isinstance(pdef, ParameterDefinition) or not pdef.optimizable: + continue + + address = f"{node_name}.{pname}" + + # The node's live value, not the schema default: a key added through + # configure() (a NEST parameter the default dict does not list, say) + # is just as tunable as one that was declared. + value = node._parameters.get(pname) + + # A dict-valued parameter declares one range per key. Each becomes its + # own dimension, addressed as Node.parameter.key — the address the + # engine reassembles into the whole dict before calling configure(). + if isinstance(pdef.optimization_range, dict): + for key, pair in pdef.optimization_range.items(): + key_address = f"{address}.{key}" + rng = _numeric_pair(pair) + if rng is None: + skipped.append({ + "address": key_address, + "reason": f"range is not [min, max]: {pair}", + }) + continue + if isinstance(value, dict) and key not in value: + skipped.append({ + "address": key_address, + "reason": "key is not present in the parameter's " + "current value — configure() it first", + }) + continue + dimensions.append(Dimension( + address=key_address, low=rng[0], high=rng[1], + unit=pdef.unit, description=pdef.description, + source="schema.optimization_range", + )) + continue + + if isinstance(value, dict): + skipped.append({ + "address": address, + "reason": "dict parameter with no per-key optimization_range — " + 'declare one, e.g. {"V_th": [-60.0, -45.0]}', + }) + continue + + c_min = pdef.constraints.get("min") + c_max = pdef.constraints.get("max") + rng = _numeric_pair(pdef.optimization_range) + source, note = "schema.optimization_range", "" + + if rng is None: + if isinstance(c_min, (int, float)) and isinstance(c_max, (int, float)): + rng, source = [float(c_min), float(c_max)], "schema.constraints" + else: + skipped.append({ + "address": address, + "reason": "optimizable but no optimization_range and no " + "min/max constraints to fall back on", + }) + continue + + # Constraints are the authority: a range reaching past them describes + # points configure() would reject anyway, so clip rather than fail. + low, high = rng + clipped = [] + if isinstance(c_min, (int, float)) and low < c_min: + clipped.append(f"low raised to {c_min}") + low = float(c_min) + if isinstance(c_max, (int, float)) and high > c_max: + clipped.append(f"high lowered to {c_max}") + high = float(c_max) + if clipped: + source, note = "clipped", "; ".join(clipped) + " (constraints)" + + if low >= high: + skipped.append({ + "address": address, + "reason": f"empty range after clipping to constraints: [{low}, {high}]", + }) + continue + + dimensions.append(Dimension( + address=address, low=low, high=high, + unit=pdef.unit, description=pdef.description, + source=source, note=note, + )) + + return dimensions, skipped + + +def collect_objectives(workflow, measurables: Dict[str, float]) -> tuple: + """Collect objectives from every ``is_objective=True`` parameter. + + ``measures`` is resolved against the measurables discovered in a baseline + run, so a broken address fails here — before any search budget is spent — + rather than midway through the loop. + """ + objectives: List[Objective] = [] + skipped: List[Dict[str, str]] = [] + + for node_name, node in workflow.nodes.items(): + definition = getattr(type(node), "NODE_DEFINITION", None) + if definition is None: + continue + for pname, pdef in definition.parameters.items(): + if not isinstance(pdef, ParameterDefinition) or not pdef.is_objective: + continue + + name = f"{node_name}.{pname}" + + if not pdef.measures: + skipped.append({ + "address": name, + "reason": "is_objective=True but no measures address — set it to " + "the output that holds the measured value", + }) + continue + + if pdef.measures not in measurables: + near = [m for m in measurables if m.startswith(pdef.measures.split(".")[0])] + skipped.append({ + "address": name, + "reason": f"measures {pdef.measures!r} did not resolve to a number " + f"in the baseline run" + + (f" (available on that node: {', '.join(sorted(near)[:6])})" + if near else ""), + }) + continue + + band = _numeric_pair(pdef.objective_range) + if band is None: + skipped.append({ + "address": name, + "reason": "is_objective=True but objective_range is not [min, max]", + }) + continue + + # The schema can only express a target band. minimize/maximize are set + # by editing the spec, which is also where an agent would change them. + objectives.append(Objective( + name=name, + measures=pdef.measures, + low=band[0], + high=band[1], + goal="in_range", + unit=pdef.unit, + description=pdef.description, + source="schema.objective_range", + )) + + return objectives, skipped + + +def build_spec(workflow, algorithm: Optional[AlgorithmConfig] = None, + run_baseline: bool = True) -> OptimizationSpec: + """Introspect a built workflow and produce a spec ready for review. + + With ``run_baseline=True`` the workflow is executed once at its current + parameters. That run does two jobs: it is the reference point every result is + compared against, and its outputs are what ``measures`` addresses resolve + against. + """ + baseline: Dict[str, Any] = {} + measurables: Dict[str, float] = {} + + if run_baseline: + ok = workflow.execute() + measurables = discover_measurables(workflow) + baseline = { + "executed": bool(ok), + "measurables": measurables, + } + if not ok: + raise RuntimeError( + "The workflow failed at its current parameters — fix that before " + "optimizing (check the printed node errors)." + ) + + dimensions, skipped_dims = collect_dimensions(workflow) + objectives, skipped_objs = collect_objectives(workflow, measurables) + + if baseline: + baseline["params"] = {d.address: _read_param(workflow, d.address) + for d in dimensions} + baseline["measured"] = {o.name: measurables.get(o.measures) + for o in objectives} + + return OptimizationSpec( + dimensions=dimensions, + objectives=objectives, + algorithm=algorithm or AlgorithmConfig(), + baseline=baseline, + skipped=skipped_dims + skipped_objs, + ) + + +def _read_param(workflow, address: str) -> Any: + from .addressing import split_address + node_name, param, keys = split_address(address) + value = workflow.nodes[node_name]._parameters[param] + for k in keys: + value = value[k] + return value From d99dd8910c76cd90f17bd34a369ea2f501cd6be8 Mon Sep 17 00:00:00 2001 From: Carlos Gutierrez Date: Mon, 10 Aug 2026 01:59:30 +0900 Subject: [PATCH 2/8] Give each node instance its own NODE_DEFINITION copy --- .../codes/neuroworkflow/core/node.py | 37 +++++++++++++------ .../codes/neuroworkflow/core/workflow.py | 4 +- src/neuroworkflow/core/node.py | 37 +++++++++++++------ src/neuroworkflow/core/workflow.py | 4 +- src/neuroworkflow/optimization/spec.py | 4 +- 5 files changed, 56 insertions(+), 30 deletions(-) diff --git a/gui/workflow_backend/django-project/codes/neuroworkflow/core/node.py b/gui/workflow_backend/django-project/codes/neuroworkflow/core/node.py index 5179e7c3..ee12aa81 100644 --- a/gui/workflow_backend/django-project/codes/neuroworkflow/core/node.py +++ b/gui/workflow_backend/django-project/codes/neuroworkflow/core/node.py @@ -6,6 +6,7 @@ """ from typing import Dict, List, Any, Callable, Optional, Type, Union +import copy import inspect from neuroworkflow.core.schema import NodeDefinitionSchema, PortDefinition, ParameterDefinition, MethodDefinition @@ -52,7 +53,19 @@ def __init__(self, name: str, description: str = ""): description: Description of the node (optional) """ self.name = name - self.description = description or self.__class__.NODE_DEFINITION.description + # Each node gets its own copy of its definition, the same way it gets its own + # parameter values below. Without this, two nodes of the same class share one + # NodeDefinitionSchema, so per-node schema edits — an optimization range on + # one population but not the other — would overwrite each other. + try: + self.NODE_DEFINITION = copy.deepcopy(type(self).NODE_DEFINITION) + except Exception: + # A default_value that cannot be copied (an open handle, a simulator + # object) must not stop the node from being constructed; fall back to + # the shared definition, which is how it behaved before. + self.NODE_DEFINITION = type(self).NODE_DEFINITION + + self.description = description or self.NODE_DEFINITION.description self._input_ports: Dict[str, InputPort] = {} self._output_ports: Dict[str, OutputPort] = {} self._process_steps: List[ProcessStep] = [] @@ -68,7 +81,7 @@ def __init__(self, name: str, description: str = ""): def _initialize_parameters(self) -> None: """Initialize parameters from NODE_DEFINITION schema.""" - for name, param_def in self.__class__.NODE_DEFINITION.parameters.items(): + for name, param_def in self.NODE_DEFINITION.parameters.items(): if isinstance(param_def, ParameterDefinition): self._parameters[name] = param_def.default_value @@ -98,7 +111,7 @@ def _initialize_parameters(self) -> None: def _define_ports_from_definition(self) -> None: """Define input and output ports from NODE_DEFINITION.""" # Create input ports from NODE_DEFINITION - for name, port_def in self.__class__.NODE_DEFINITION.inputs.items(): + for name, port_def in self.NODE_DEFINITION.inputs.items(): if isinstance(port_def, PortDefinition): port_type = port_def.type if isinstance(port_def.type, PortType) else None data_type = port_def.type.to_python_type() if isinstance(port_def.type, PortType) else port_def.type @@ -118,7 +131,7 @@ def _define_ports_from_definition(self) -> None: self.register_input(name, object, str(port_def)) # Create output ports from NODE_DEFINITION - for name, port_def in self.__class__.NODE_DEFINITION.outputs.items(): + for name, port_def in self.NODE_DEFINITION.outputs.items(): if isinstance(port_def, PortDefinition): port_type = port_def.type if isinstance(port_def.type, PortType) else None data_type = port_def.type.to_python_type() if isinstance(port_def.type, PortType) else port_def.type @@ -205,8 +218,8 @@ def add_process_step(self, name: str, method: Callable, description: str = "", method_key = method.__name__ # If the method is in NODE_DEFINITION, use its definition - if method_key in self.__class__.NODE_DEFINITION.methods: - method_def = self.__class__.NODE_DEFINITION.methods[method_key] + if method_key in self.NODE_DEFINITION.methods: + method_def = self.NODE_DEFINITION.methods[method_key] if isinstance(method_def, MethodDefinition): # Use description from NODE_DEFINITION if not explicitly provided @@ -258,7 +271,7 @@ def get_info(self) -> Dict[str, Any]: """ return { 'name': self.name, - 'type': self.__class__.NODE_DEFINITION.type, + 'type': self.NODE_DEFINITION.type, 'description': self.description, 'parameters': self._parameters, 'optimizable_parameters': self._optimizable_parameters, @@ -277,7 +290,7 @@ def get_info(self) -> Dict[str, Any]: for step in self._process_steps], 'methods': {name: (method_def.description if isinstance(method_def, MethodDefinition) else (method_def.get('description', '') if isinstance(method_def, dict) else str(method_def))) - for name, method_def in self.__class__.NODE_DEFINITION.methods.items()} + for name, method_def in self.NODE_DEFINITION.methods.items()} } def get_input_port(self, name: str) -> InputPort: @@ -325,8 +338,8 @@ def connect_to(self, output_port: str, target_node: 'Node', input_port: str) -> TypeError: If the ports are not compatible """ # Get node types for informational purposes only - source_type = self.__class__.NODE_DEFINITION.type - target_type = target_node.__class__.NODE_DEFINITION.type + source_type = self.NODE_DEFINITION.type + target_type = target_node.NODE_DEFINITION.type source_port = self.get_output_port(output_port) target_port = target_node.get_input_port(input_port) @@ -397,7 +410,7 @@ def configure(self, **parameters) -> 'Node': for param_name, value in parameters.items(): if param_name in self._parameters: # Get parameter definition - param_def = self.__class__.NODE_DEFINITION.parameters.get(param_name) + param_def = self.NODE_DEFINITION.parameters.get(param_name) # Check parameter constraints if isinstance(param_def, ParameterDefinition) and param_def.constraints: @@ -514,7 +527,7 @@ def __str__(self) -> str: Returns: String representation """ - result = [f"Node: {self.name} ({self.__class__.NODE_DEFINITION.type})"] + result = [f"Node: {self.name} ({self.NODE_DEFINITION.type})"] result.append(f"Description: {self.description}") if self._parameters: diff --git a/gui/workflow_backend/django-project/codes/neuroworkflow/core/workflow.py b/gui/workflow_backend/django-project/codes/neuroworkflow/core/workflow.py index 8a501605..84be8049 100644 --- a/gui/workflow_backend/django-project/codes/neuroworkflow/core/workflow.py +++ b/gui/workflow_backend/django-project/codes/neuroworkflow/core/workflow.py @@ -147,8 +147,8 @@ def validate(self) -> bool: return False # Get node types for informational purposes only - source_type = source_node.__class__.NODE_DEFINITION.type - target_type = target_node.__class__.NODE_DEFINITION.type + source_type = source_node.NODE_DEFINITION.type + target_type = target_node.NODE_DEFINITION.type # Check type compatibility if not target_port.is_compatible_with(source_port): diff --git a/src/neuroworkflow/core/node.py b/src/neuroworkflow/core/node.py index 5179e7c3..ee12aa81 100644 --- a/src/neuroworkflow/core/node.py +++ b/src/neuroworkflow/core/node.py @@ -6,6 +6,7 @@ """ from typing import Dict, List, Any, Callable, Optional, Type, Union +import copy import inspect from neuroworkflow.core.schema import NodeDefinitionSchema, PortDefinition, ParameterDefinition, MethodDefinition @@ -52,7 +53,19 @@ def __init__(self, name: str, description: str = ""): description: Description of the node (optional) """ self.name = name - self.description = description or self.__class__.NODE_DEFINITION.description + # Each node gets its own copy of its definition, the same way it gets its own + # parameter values below. Without this, two nodes of the same class share one + # NodeDefinitionSchema, so per-node schema edits — an optimization range on + # one population but not the other — would overwrite each other. + try: + self.NODE_DEFINITION = copy.deepcopy(type(self).NODE_DEFINITION) + except Exception: + # A default_value that cannot be copied (an open handle, a simulator + # object) must not stop the node from being constructed; fall back to + # the shared definition, which is how it behaved before. + self.NODE_DEFINITION = type(self).NODE_DEFINITION + + self.description = description or self.NODE_DEFINITION.description self._input_ports: Dict[str, InputPort] = {} self._output_ports: Dict[str, OutputPort] = {} self._process_steps: List[ProcessStep] = [] @@ -68,7 +81,7 @@ def __init__(self, name: str, description: str = ""): def _initialize_parameters(self) -> None: """Initialize parameters from NODE_DEFINITION schema.""" - for name, param_def in self.__class__.NODE_DEFINITION.parameters.items(): + for name, param_def in self.NODE_DEFINITION.parameters.items(): if isinstance(param_def, ParameterDefinition): self._parameters[name] = param_def.default_value @@ -98,7 +111,7 @@ def _initialize_parameters(self) -> None: def _define_ports_from_definition(self) -> None: """Define input and output ports from NODE_DEFINITION.""" # Create input ports from NODE_DEFINITION - for name, port_def in self.__class__.NODE_DEFINITION.inputs.items(): + for name, port_def in self.NODE_DEFINITION.inputs.items(): if isinstance(port_def, PortDefinition): port_type = port_def.type if isinstance(port_def.type, PortType) else None data_type = port_def.type.to_python_type() if isinstance(port_def.type, PortType) else port_def.type @@ -118,7 +131,7 @@ def _define_ports_from_definition(self) -> None: self.register_input(name, object, str(port_def)) # Create output ports from NODE_DEFINITION - for name, port_def in self.__class__.NODE_DEFINITION.outputs.items(): + for name, port_def in self.NODE_DEFINITION.outputs.items(): if isinstance(port_def, PortDefinition): port_type = port_def.type if isinstance(port_def.type, PortType) else None data_type = port_def.type.to_python_type() if isinstance(port_def.type, PortType) else port_def.type @@ -205,8 +218,8 @@ def add_process_step(self, name: str, method: Callable, description: str = "", method_key = method.__name__ # If the method is in NODE_DEFINITION, use its definition - if method_key in self.__class__.NODE_DEFINITION.methods: - method_def = self.__class__.NODE_DEFINITION.methods[method_key] + if method_key in self.NODE_DEFINITION.methods: + method_def = self.NODE_DEFINITION.methods[method_key] if isinstance(method_def, MethodDefinition): # Use description from NODE_DEFINITION if not explicitly provided @@ -258,7 +271,7 @@ def get_info(self) -> Dict[str, Any]: """ return { 'name': self.name, - 'type': self.__class__.NODE_DEFINITION.type, + 'type': self.NODE_DEFINITION.type, 'description': self.description, 'parameters': self._parameters, 'optimizable_parameters': self._optimizable_parameters, @@ -277,7 +290,7 @@ def get_info(self) -> Dict[str, Any]: for step in self._process_steps], 'methods': {name: (method_def.description if isinstance(method_def, MethodDefinition) else (method_def.get('description', '') if isinstance(method_def, dict) else str(method_def))) - for name, method_def in self.__class__.NODE_DEFINITION.methods.items()} + for name, method_def in self.NODE_DEFINITION.methods.items()} } def get_input_port(self, name: str) -> InputPort: @@ -325,8 +338,8 @@ def connect_to(self, output_port: str, target_node: 'Node', input_port: str) -> TypeError: If the ports are not compatible """ # Get node types for informational purposes only - source_type = self.__class__.NODE_DEFINITION.type - target_type = target_node.__class__.NODE_DEFINITION.type + source_type = self.NODE_DEFINITION.type + target_type = target_node.NODE_DEFINITION.type source_port = self.get_output_port(output_port) target_port = target_node.get_input_port(input_port) @@ -397,7 +410,7 @@ def configure(self, **parameters) -> 'Node': for param_name, value in parameters.items(): if param_name in self._parameters: # Get parameter definition - param_def = self.__class__.NODE_DEFINITION.parameters.get(param_name) + param_def = self.NODE_DEFINITION.parameters.get(param_name) # Check parameter constraints if isinstance(param_def, ParameterDefinition) and param_def.constraints: @@ -514,7 +527,7 @@ def __str__(self) -> str: Returns: String representation """ - result = [f"Node: {self.name} ({self.__class__.NODE_DEFINITION.type})"] + result = [f"Node: {self.name} ({self.NODE_DEFINITION.type})"] result.append(f"Description: {self.description}") if self._parameters: diff --git a/src/neuroworkflow/core/workflow.py b/src/neuroworkflow/core/workflow.py index 8a501605..84be8049 100644 --- a/src/neuroworkflow/core/workflow.py +++ b/src/neuroworkflow/core/workflow.py @@ -147,8 +147,8 @@ def validate(self) -> bool: return False # Get node types for informational purposes only - source_type = source_node.__class__.NODE_DEFINITION.type - target_type = target_node.__class__.NODE_DEFINITION.type + source_type = source_node.NODE_DEFINITION.type + target_type = target_node.NODE_DEFINITION.type # Check type compatibility if not target_port.is_compatible_with(source_port): diff --git a/src/neuroworkflow/optimization/spec.py b/src/neuroworkflow/optimization/spec.py index b2feecba..93fbe34e 100644 --- a/src/neuroworkflow/optimization/spec.py +++ b/src/neuroworkflow/optimization/spec.py @@ -149,7 +149,7 @@ def collect_dimensions(workflow) -> tuple: skipped: List[Dict[str, str]] = [] for node_name, node in workflow.nodes.items(): - params = getattr(type(node), "NODE_DEFINITION", None) + params = getattr(node, "NODE_DEFINITION", None) if params is None: continue for pname, pdef in params.parameters.items(): @@ -254,7 +254,7 @@ def collect_objectives(workflow, measurables: Dict[str, float]) -> tuple: skipped: List[Dict[str, str]] = [] for node_name, node in workflow.nodes.items(): - definition = getattr(type(node), "NODE_DEFINITION", None) + definition = getattr(node, "NODE_DEFINITION", None) if definition is None: continue for pname, pdef in definition.parameters.items(): From 929661b820ff43a7ce6c2eb5ec3da9e866645074 Mon Sep 17 00:00:00 2001 From: Carlos Gutierrez Date: Tue, 11 Aug 2026 19:04:41 +0900 Subject: [PATCH 3/8] Add naming rules for instance names and pop_name to chat system prompt --- .../django-project/app/chat/services/chat_orchestrator.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/gui/workflow_backend/django-project/app/chat/services/chat_orchestrator.py b/gui/workflow_backend/django-project/app/chat/services/chat_orchestrator.py index 80558233..71359649 100644 --- a/gui/workflow_backend/django-project/app/chat/services/chat_orchestrator.py +++ b/gui/workflow_backend/django-project/app/chat/services/chat_orchestrator.py @@ -30,6 +30,13 @@ "Key rules:\n" "- When reading parameter values, always use 'default_value' as the current value. Ignore any 'value' field.\n" "- When a user asks to change a parameter, call update_node_parameter with parameter_field='default_value'.\n" + "- Node instance names become Python variable names in the generated code and are NOT sanitized: use " + "only letters, digits and underscores (e.g. 'Excitatory_Pop1' or 'excPop1'). A name containing a space " + "produces invalid Python and the whole workflow fails to run.\n" + "- Give every population a unique pop_name. This matters most for the generic NW_* builder nodes, where " + "pop_name names the generated network files: the default is 'v1', so a workflow with more than one " + "population must rename them (e.g. 'exc_1', 'exc_2', 'inh'). Populations sharing a name overwrite each " + "other's network files and cannot be told apart in the simulation output.\n" "- When a user asks to generate a report, methods section, or paper section about a workflow:\n" " 1. Call get_workflow_facts (NOT get_flow) to collect all node parameters and results.\n" " 2. Write the report as a proper scientific Methods section following these rules:\n" From 523ab88bceb14fc203e36347c9401417eb8937ab Mon Sep 17 00:00:00 2001 From: Carlos Gutierrez Date: Mon, 7 Sep 2026 19:08:56 +0900 Subject: [PATCH 4/8] Add NW_Optimization node, network reuse and optimization notebooks --- .gitignore | 4 + docs/OPTIMIZATION.md | 377 + docs/OPTIMIZATION_GUI_HANDOFF.md | 317 + .../neuroworkflow/optimization/__init__.py | 47 + .../neuroworkflow/optimization/addressing.py | 136 + .../neuroworkflow/optimization/engine.py | 695 + .../neuroworkflow/optimization/ledger.py | 100 + .../neuroworkflow/optimization/optimizers.py | 208 + .../codes/neuroworkflow/optimization/spec.py | 396 + .../codes/nodes/analysis/NW_Analysis.py | 112 +- .../codes/nodes/network/NW_Connectivity.py | 48 +- .../codes/nodes/network/NW_Population.py | 29 +- .../optimization/JointOptimizationNode.py | 391 - .../nodes/optimization/NW_Optimization.py | 126 + .../codes/nodes/optimization/__init__.py | 11 +- .../codes/nodes/simulation/NW_SimConfig.py | 117 +- notebooks/NW_Clamp_Weight_Optimization.ipynb | 15048 +++++++++++++++ notebooks/NW_Network_Optimization.ipynb | 2040 ++ notebooks/NW_SingleCell_Optimization.ipynb | 7425 ++++++++ .../generated_multiobjective_example.ipynb | 11286 ++++++++++++ notebooks/generated_multiobjective_example.py | 258 + .../generated_optimization_example.ipynb | 15352 ++++++++++++++++ notebooks/generated_optimization_example.py | 182 + .../nodes/analysis/NW_Analysis.py | 112 +- .../nodes/network/NW_Connectivity.py | 48 +- .../nodes/network/NW_Population.py | 29 +- .../optimization/JointOptimizationNode.py | 391 - .../nodes/optimization/NW_Optimization.py | 126 + .../nodes/optimization/__init__.py | 11 +- .../nodes/simulation/NW_SimConfig.py | 117 +- src/neuroworkflow/optimization/__init__.py | 4 +- src/neuroworkflow/optimization/addressing.py | 6 +- src/neuroworkflow/optimization/engine.py | 392 +- src/neuroworkflow/optimization/spec.py | 38 + 34 files changed, 55122 insertions(+), 857 deletions(-) create mode 100644 docs/OPTIMIZATION.md create mode 100644 docs/OPTIMIZATION_GUI_HANDOFF.md create mode 100644 gui/workflow_backend/django-project/codes/neuroworkflow/optimization/__init__.py create mode 100644 gui/workflow_backend/django-project/codes/neuroworkflow/optimization/addressing.py create mode 100644 gui/workflow_backend/django-project/codes/neuroworkflow/optimization/engine.py create mode 100644 gui/workflow_backend/django-project/codes/neuroworkflow/optimization/ledger.py create mode 100644 gui/workflow_backend/django-project/codes/neuroworkflow/optimization/optimizers.py create mode 100644 gui/workflow_backend/django-project/codes/neuroworkflow/optimization/spec.py delete mode 100644 gui/workflow_backend/django-project/codes/nodes/optimization/JointOptimizationNode.py create mode 100644 gui/workflow_backend/django-project/codes/nodes/optimization/NW_Optimization.py create mode 100644 notebooks/NW_Clamp_Weight_Optimization.ipynb create mode 100644 notebooks/NW_Network_Optimization.ipynb create mode 100644 notebooks/NW_SingleCell_Optimization.ipynb create mode 100644 notebooks/generated_multiobjective_example.ipynb create mode 100644 notebooks/generated_multiobjective_example.py create mode 100644 notebooks/generated_optimization_example.ipynb create mode 100644 notebooks/generated_optimization_example.py delete mode 100644 src/neuroworkflow/nodes/optimization/JointOptimizationNode.py create mode 100644 src/neuroworkflow/nodes/optimization/NW_Optimization.py diff --git a/.gitignore b/.gitignore index fd606da8..5520b122 100644 --- a/.gitignore +++ b/.gitignore @@ -60,6 +60,10 @@ temp/ # Sandbox nodes (local experimentation only) src/neuroworkflow/nodes/sandbox/ +# Simulation output written by the tutorial notebooks (SONATA networks, spike +# files, figures, optimization ledgers) — regenerated by running them +notebooks/results/ + # Remote (Slurm) execution runtime dirs: per-run staged inputs + fetched # results, co-located under each project (codes/projects//batch//) gui/workflow_backend/django-project/codes/projects/*/batch/ diff --git a/docs/OPTIMIZATION.md b/docs/OPTIMIZATION.md new file mode 100644 index 00000000..974a97a4 --- /dev/null +++ b/docs/OPTIMIZATION.md @@ -0,0 +1,377 @@ +# Parameter optimization + +Tune parameters of an existing workflow until a measured quantity lands in a target band. + +A workflow is a DAG: it runs once, feed-forward, and produces outputs. Optimization is a loop — +propose parameters, run the DAG, measure, propose again — and a loop cannot live inside an acyclic +graph. So the optimizer sits **outside** the workflow and calls it repeatedly: + +``` +ask → configure nodes → workflow.execute() → read measured value → fitness → tell → repeat +``` + +**The workflow is the objective function.** It is built once and reconfigured between trials; it is +never rebuilt. + +## Quick start + +```python +from neuroworkflow.optimization import AlgorithmConfig, build_spec, optimize + +spec = build_spec(workflow, AlgorithmConfig(name="cmaes", pop_size=8, max_generations=10, seed=1)) +print(spec.summary()) # review before spending simulation time + +result = optimize(workflow, spec=spec, results_path="./results/optimization") +print(result.configure_snippet()) # ready-to-paste best configuration +``` + +`build_spec()` runs the workflow once at its current values. That run is the baseline every result +is compared against, and it is what every `measures` address is resolved against. + +## Declaring what to optimize + +The spec is read from the node schemas. Two declarations matter, both on `ParameterDefinition`. + +### What to explore + +```python +"amp_na": ParameterDefinition( + default_value=0.15, unit="nA", + constraints={"min": -1000.0, "max": 1000.0}, # hard validity — never proposed outside + optimizable=True, + optimization_range=[0.0, 800.0], # where to search, within the constraints +), +``` + +`constraints` is the fence: what the model considers valid at all, enforced by `configure()`. +`optimization_range` is the patch of ground inside it that this study wants searched. A range +reaching past the constraints is clipped, and the clip is recorded in the spec. + +For a **dict-valued parameter**, give a range per key. Each key becomes its own search dimension: + +```python +"nest_params": ParameterDefinition( + default_value={"C_m": 250.0, "V_th": -55.0, "I_e": 0.0}, + optimizable=True, + optimization_range={"I_e": [0.0, 800.0], "V_th": [-60.0, -45.0]}, +), +``` + +Tunable keys are read from the node's **live** value, so a key added through `configure()` is just +as tunable as one in the declared default. + +### What to hit + +```python +"mean_firing_rate": ParameterDefinition( + default_value=10.0, unit="Hz", + is_objective=True, + objective_range=[8.0, 12.0], # reached anywhere inside this band + measures="Analysis.firing_rate_hz.v1", # the measurement it is compared against +), +``` + +A target declares a desired value; `measures` says **where the achieved value is read from**. +Without it the band is not interpretable — "firing rate" means different things in different nodes — +so a target without `measures` is skipped and reported. + +### Addresses + +Everything is addressed by a dotted path starting with the **node name** — the string passed to the +constructor, `node.name`, not the Python variable: + +| kind | shape | example | +|---|---|---| +| parameter to tune | `Node.parameter[.key]` | `Population.nest_params.V_th` | +| value to measure | `Node.output_port[.key]` | `Analysis.firing_rate_hz.v1` | + +`discover_measurables(workflow)` lists every numeric leaf a run actually produced — the menu a +`measures` address can point at. It reads the data, not a declaration, so it cannot go stale. + +Setting a dict key goes through `configure()` with the whole dict rebuilt, never by mutating in +place, so a rejected value cannot leave the node half-changed. + +## Algorithms + +```python +from neuroworkflow.optimization import available +available() # ['cmaes', 'nsga2', 'nsga3', 'optuna_random', 'random', 'tpe'] +``` + +| name | method | objectives | needs | use it when | +|---|---|---|---|---| +| `random` | uniform sampling | any | — | smoke-testing the loop, or a baseline to beat | +| `cmaes` | CMA-ES | **1 only** | `optuna`, `cmaes` | default for continuous single-objective search | +| `tpe` | Tree-structured Parzen Estimator | any | `optuna` | trials are expensive and the budget is small | +| `nsga2` | NSGA-II | any (built for 2–3) | `optuna` | 2 or 3 objectives; returns a Pareto front | +| `nsga3` | NSGA-III | any (built for 3+) | `optuna` | more than 3 objectives, where NSGA-II degrades | +| `optuna_random` | Optuna's random sampler | any | `optuna` | comparing fairly against the Optuna backends | + +Everything except `random` needs Optuna: + +```bash +pip install optuna cmaes # 'cmaes' is only required by the cmaes algorithm +``` + +Without it those names still appear in `available()` and raise an `ImportError` naming the install +command. Restart the kernel after installing. + +**Single-objective backends refuse a multi-objective spec.** `cmaes` raises rather than collapsing +objectives into a weighted sum, because the weights would be an invented scientific judgement. Use +`nsga2` / `nsga3` and read the Pareto front instead. + +### Configuration + +`AlgorithmConfig` is plain data — editable by hand, by an agent, or loaded from JSON. + +| field | default | meaning | +|---|---|---| +| `name` | `"random"` | one of the names above | +| `pop_size` | `16` | candidates per generation, i.e. workflow runs per generation | +| `max_generations` | `20` | generation budget | +| `seed` | `None` | makes a run reproducible | +| `options` | `{}` | extra keyword arguments forwarded verbatim to the underlying sampler | + +At most `pop_size × max_generations` executions, plus one baseline. With a simulation costing +seconds, that product is the number to think about first. + +For `nsga2` / `nsga3`, `pop_size` is also passed as the sampler's `population_size`. + +`options` is merged into the sampler's constructor arguments, so anything the underlying Optuna +sampler accepts can be set without changing this package: + +```python +AlgorithmConfig(name="cmaes", pop_size=8, seed=1, options={"sigma0": 0.2}) +AlgorithmConfig(name="tpe", pop_size=8, options={"n_startup_trials": 20}) +``` + +The names are Optuna's — see its sampler documentation. A wrong option surfaces as a `TypeError` +when the run starts, not silently. + +### Choosing one + +- **1 objective, continuous parameters** → `cmaes`. It adapts a covariance model, so it handles + correlated parameters (`I_e` trading off against `V_th`) far better than independent sampling. +- **1 objective, few trials affordable** → `tpe`. +- **2–3 objectives** → `nsga2`. There is no single best answer; it returns the Pareto front, the + configurations where improving one objective costs another. +- **More than 3** → `nsga3`. +- **Checking the setup** → `random`. If random search hits the target immediately, the ranges are + too generous or the band too wide. + +### Adding one + +An Optuna sampler is one line in `_OPTUNA_SAMPLERS` (`optimization/optimizers.py`): + +```python +"gp": ("GPSampler", True, {}), # name -> (sampler class, multi-objective?, default kwargs) +``` + +Anything else subclasses `Optimizer` and registers: + +```python +from neuroworkflow.optimization import Optimizer, register_optimizer + +class MySearch(Optimizer): + supports_multi_objective = False + def ask(self): ... # -> list of {address: value} + def tell(self, candidates, fitnesses): ... + def enqueue(self, params): ... # optional: seed a candidate + +register_optimizer("mysearch", MySearch) +``` + +Fitness is always a **list** — one entry per objective, in spec order — and always **minimized**; +the engine converts a target band into a distance before telling. A failed or rejected trial is +reported as `None`, not as a large number, so a backend can mark it failed rather than let an +invented penalty distort its model. + +### Comparing objectives that are not in the same unit + +Each entry of `fitness` is **how far that objective missed, in its own unit** — 14.1 Hz past a +firing-rate target, 8.2 ms past an interval target. Those numbers must never be added: the sum has +no unit and no meaning, and it silently favours whichever objective happens to use bigger numbers. + +The search itself does not care, and needs no rescaling: a multi-objective sampler ranks by **Pareto +dominance**, which compares one objective against the same objective, and NSGA-II rescales each +objective internally before computing crowding distance. Mixed units are only a *reporting* problem +— ranking trials in a table, drawing a convergence curve, and picking one configuration to apply all +need a single number. + +That number is **how many target ranges the worst objective missed by**: + +``` + how far this objective missed +target ranges missed by = ───────────────────────────── + the width of its target range + +reported value = the largest of those, across the objectives +``` + +A target of 40–50 Hz is a range 10 Hz wide. A trial measuring 25.9 Hz missed it by 14.1 Hz, so +14.1 / 10 = **1.4**: the miss is 1.4 times as wide as the range that was asked for. `0` means the +value landed inside. There is no upper bound. + +Dividing by the width of the range is not an invented weighting: by asking for 40–50, the user +already stated that a 10 Hz spread is acceptable, so the width is the yardstick they themselves set. +For a `minimize`/`maximize` goal, which has no range, the baseline value is used instead. + +It is the **largest**, not the sum — what the literature calls the Chebyshev or achievement +scalarizing function. With target ranges you want *every* objective met, so a trial is only as good as +whatever it is doing worst, and `0` can only happen when all of them are inside. Unlike a weighted +sum, this can also single out configurations anywhere on the Pareto front, not only on its convex +hull. + +Both numbers are on every trial row, and the output distinguishes them: a miss is printed with its +unit (`off 8.2 ms`), the comparable figure always as `1.4x its target range`, and it names the +objective that is worst. Ranking, `result.best` and `progress.best_target_ranges_off_by_gen` all use +it; what is told to the optimizer is still the per-objective list of raw misses. + +With a single objective none of this applies — the output stays in that objective's own unit, and +the multiple is not shown. + +## Running + +```python +result = optimize(workflow, spec=spec, results_path="./results/optimization", + reject_fn=None, per_trial_results=True, verbose=True) +``` + +**`per_trial_results` (default `True`)** gives each trial its own directory under the run and points +`results_path` — in the workflow context and in every node's context — at it. Any workflow whose +nodes write files needs this: sharing one directory loses each trial's output, and rebuilding a file +in place can fail outright while a handle from the previous trial is still open. + +**Reusing expensive artifacts across trials.** A node can tell the engine that something it +writes under `results_path` survives a trial unchanged: + +```python +class NW_SimConfig(Node): + REUSABLE_PATHS = ("network",) # relative to results_path +``` + +Before each trial the engine copies those directories in from the baseline run, so a node that +recognises its own earlier work can skip redoing it — for the `NW_*` builders, that means the +SONATA network is built once instead of once per trial. The engine does not know what the +directory holds; it only copies what nodes declare, and a node that declares nothing is +unaffected. Copies rather than sharing one directory: a trial that *does* change the artifact +rebuilds it inside its own directory, which is exactly the isolation this provides. + +**`reject_fn(workflow, measured) -> str | None`** is the dynamics check. A scalar fitness cannot tell +a healthy network from a pathological one that merely averages to the right number, so this hook can +inspect the full outputs and return a reason to reject a trial whose number is right but whose +behaviour is wrong. + +The run stops when a candidate lands inside every target band, when the generation budget is +exhausted, or when a `stop` command arrives. The reason is always stated. + +## The ledger + +Everything the engine knows is written to plain files under `results_path//`. Monitoring is +reading them; steering is writing one. No sockets, no queues. + +``` +run.json manifest, written once +trials.jsonl one line per evaluation, append-only +status.json replaced each generation, the cheap poll +control.json written by a human or agent to steer the loop +trials/0001/ that trial's results_path (with per_trial_results) +``` + +`run_id` is `opt__`, suffixed `_2`, `_3` … if that directory already exists, so +two runs starting in the same second cannot share a ledger. + +**Write discipline.** Whole-file writes go through a temp file and `os.replace`, so a reader never +sees half a document. `trials.jsonl` is appended and flushed per line, so the only partial read +possible is a truncated final line — readers skip an unparseable last line. One writer per file: the +loop owns `run.json` / `trials.jsonl` / `status.json`, and only agents or a UI write `control.json`. + +### `run.json` + +Written once, before the first evaluation: `schema_version`, `run_id`, `created_at`, +`workflow_name`, then the whole spec — `dimensions`, `objectives`, `algorithm`, `locked_protocol`, +`baseline`, `skipped`. + +`locked_protocol` and `baseline` are the comparability guarantee. Everything not in the exploration +space is frozen for the run; if the target or the protocol changes, fitnesses stop being comparable, +so that is a **new run**, not an edit to this one. + +### `trials.jsonl` + +One object per line, appended the moment a trial finishes: + +```json +{"schema_version": 1, "trial": 1, "generation": 1, "candidate": 0, + "started_at": "2026-08-12T12:34:11", "duration_s": 12.4, "source": "ask", + "params": {"Population.nest_params.I_e": 243.1}, + "results_path": ".../trials/0001", + "measured": {"Population.mean_firing_rate": 9.6}, + "fitness": [0.0], "target_ranges_off": 0.0, + "status": "ok", "reject_reason": null, "error": null} +``` + +- **`fitness` is what was told to the optimizer**, not merely what was measured — recording it is + what makes a run replayable. It is `null` for failed and rejected trials. One raw distance per + objective, each in that objective's own unit. +- **`target_ranges_off`** is the same trial reduced to one comparable number: how many target + ranges the worst objective missed by (see above). `0` means every target is met. Used for ranking + and display only, never told to the optimizer. +- **`status`** is `ok`, `failed` (simulator error, or the measured value was not a number) or + `rejected` (the number was in range but `reject_fn` refused the dynamics). `rejected` is + first-class, not a footnote: it is the whole reason a human or agent is in the loop. +- **`source`** is `ask` for algorithm proposals, `inject` for seeded candidates. + +### `status.json` + +Replaced at the end of every generation, and once more when the run ends, so a poller always sees it +finish: + +```json +{"state": "done", "generation": 8, "max_generations": 8, + "n_evals": 48, "n_ok": 45, "n_failed": 1, "n_rejected": 2, + "best": { ...the winning trial row... }, + "pareto_front": [], + "progress": {"best_target_ranges_off_by_gen": [1.62, 1.28, 0.78, 0.0], "gens_since_improvement": 0}, + "control_ack": {"seq": 1, "command": "stop", "result": "stopping"}, + "stop_reason": "a candidate is inside every target band", + "message": "finished after 48 evaluations: ..."} +``` + +`state` is `running`, `paused` or `done`. `pareto_front` is populated only for multi-objective runs. +`best_target_ranges_off_by_gen` exists so a UI can draw the convergence curve from this file alone, +without parsing every trial. Being a multiple of each objective's own target range rather than a raw +value, a run with several objectives in different units still plots as one curve. + +## Steering a running search + +Write `control.json` into the run directory. The loop reads it **between generations**, never +mid-evaluation: + +```json +{"seq": 1, "command": "stop", "issued_by": "me", "reason": "converged"} +``` + +| command | args | effect | +|---|---|---| +| `stop` | — | finish the current generation, record the reason, exit | +| `pause` / `resume` | — | hold before the next `ask` / continue | +| `inject` | `{"candidates": [{address: value}, ...]}` | seed candidates into the next generation | + +`seq` is a monotonic integer chosen by the writer. A command is applied only when +`seq > status.control_ack.seq`, and the outcome is recorded back in `control_ack` — at-most-once +delivery with no locking, confirmable by polling the same `status.json` a reader already watches. + +There is deliberately **no `retarget` command**: changing an objective mid-run invalidates every +fitness already recorded. Stop, and start a new run. + +## Current limitations + +- **No parallel evaluation.** Candidates in a generation run one after another. +- **Per-key `unit`.** A dict parameter has one `unit` for the whole parameter, so per-key + dimensions of `nest_params` (pF, ms, mV) share it. +- **`measures` is resolved once**, at setup, against the baseline run. It names a node instance, so + renaming a node invalidates it — the failure is reported at setup, not mid-run. +- **The engine sets `results_path`** to isolate trials. A node that writes to a hardcoded or + parameter-supplied absolute path bypasses that convention and will still collide. +- **No repeated evaluation of a candidate.** Objectives are bands, not points, so seed-to-seed noise + is absorbed by the band rather than averaged away. diff --git a/docs/OPTIMIZATION_GUI_HANDOFF.md b/docs/OPTIMIZATION_GUI_HANDOFF.md new file mode 100644 index 00000000..fde9ed2f --- /dev/null +++ b/docs/OPTIMIZATION_GUI_HANDOFF.md @@ -0,0 +1,317 @@ +# Optimization in the GUI — handoff + +The optimization engine, the schema fields it reads and the node that configures it are done and +tested from Python. What is missing is the GUI half. This is the list, with the files involved. + +Background reading: `docs/OPTIMIZATION.md` (how the engine works). A runnable example of the code +the generator should produce: `src/neuroworkflow/nodes/sandbox/generated_optimization_example.py` +and its `.ipynb`. + +## The one idea to hold on to + +**Optimization is not a step inside a workflow.** A workflow is a DAG that runs once; a search is a +loop that runs it many times, so the loop lives outside the graph. The `NW_Optimization` node does +not consume or produce data — it declares *how* to search. Its presence on the canvas is the signal +to generate an optimization run instead of a single execution. + +**The study lives in the optimization node.** A user configuring a search should see the whole thing +in one panel, not hunt through five nodes. So `NW_Optimization` holds all three parts: + +| what | example | +|---|---| +| how to search | `algorithm`, `pop_size`, `max_generations`, `seed`, `options`, `results_path` | +| what to explore | `conn.syn_weight` over `[1, 100]` pA; `exc.nest_params.I_e` over `[0, 400]` pA | +| what to hit | `exc.mean_firing_rate` in `[40, 50]` Hz, measured from `ana.firing_rate_hz.exc` | + +The per-parameter fields in a node file (`optimizable`, `optimization_range`, `is_objective`, +`objective_range`, `measures`, `unit`) then act as **defaults authored by the node developer** — the +range a modeller considered sensible, the physical `constraints`, the unit. The study started in the +optimization panel is seeded from them and may narrow or override them. Two levels, same split as +`constraints` versus `optimization_range`: the node says what is reasonable, the study says what this +investigation searches. + +Three things this buys, beyond convenience: + +- **Two studies over one model.** Per-parameter flags allow exactly one configuration at a time; two + `NW_Optimization` nodes are two studies — a coarse search and a fine one, or different targets. +- **The model stays clean.** Ranges belong to an investigation, not to a neuron model. Reusing `exc` + in another workflow should not carry someone's search ranges along. +- **One panel to review before spending compute**, rather than opening every node to check what is + marked. + +**One thing to get right, or it will bite:** an entry like `conn.syn_weight` references a node by its +*instance name*, so renaming `conn` breaks it — a fragility per-parameter flags do not have, since +the flag lives on the node itself. Store the `node_id` alongside the address and resolve it at +generation time; `FlowNode.id` survives renames. + +--- + +## 1. The optimization panel + +Editing `NW_Optimization` should open a panel with three parts. The first is ordinary parameters +(`algorithm` is a dropdown already, since it declares `allowed_values`). The other two are lists. + +### Parameters to explore + +Each entry: an **address**, a **range**, and a unit for display. + +| parameter shape | address | range | +|---|---|---| +| scalar | `conn.syn_weight` | `[1.0, 100.0]` | +| key inside a dict | `exc.nest_params.I_e` | `[0.0, 400.0]` | + +Adding one is: pick a node, pick a parameter (or a key within a dict parameter), then set the range. +Prefill it from the node's own declaration — `optimization_range` if present, otherwise the `min`/`max` +in `constraints` — and carry the `unit` across. Never propose a range outside `constraints`: those are +the model's hard bounds and `configure()` rejects values beyond them. + +Only numeric things are tunable. Strings, booleans and lists are not: `connection_rule` is an int but +means "a rule", and `connections` is a list, which addresses cannot index. A sensible picker offers +scalar float/int parameters and the numeric keys of dict parameters. + +### Objectives + +Each entry: a **target parameter**, a **band**, and a **`measures` address**. + +`measures` is the field that makes a target usable — without it a band is not interpretable, since +"firing rate" means different things in different nodes. Its value is an address into the run's +outputs, made of three parts: + +``` +ana . firing_rate_hz . exc + | | | + | | +-- a key inside that port's dict; here the population name, + | | which comes from NW_Population's pop_name parameter + | +--------------- an output port of that node + +-------------------------- the node's instance name +``` + +**It needs a picker, not a text box.** Valid values can only be known from *data*, because a port's +contents depend on what a run produced. After a baseline run, `discover_measurables(workflow)` returns +every numeric leaf with its current value — `ana.firing_rate_hz.exc = 8.3` — so the picker is that +list. Typing an address by hand must keep working, since an agent sets it that way. + +Two or three objectives are legitimate and switch the algorithm to `nsga2`/`nsga3`, which return a +Pareto front instead of one answer. A single-objective algorithm refuses a multi-objective study +rather than silently collapsing it into a weighted sum. + +### Show it on the graph + +The panel is where the study is edited, but the canvas should show what is being tuned and measured: +a badge on a node whose parameter is in the exploration list, and a badge next to the **port** that a +`measures` address resolves to. Users think *"this output is my objective"*, so drawing it there costs +nothing and prevents hunting. + +### If you also expose the per-parameter fields + +They are the node author's defaults, so exposing them in the node modal is optional — but if you do, +the plumbing is nearly there. `update_node_parameter` already writes any field by name +(`app/workflow/views.py:645`); what is missing is `measures` and `unit` in the editable union at +`nodeDetailModal.tsx:173`, in the parameter type at `views/home/type.ts:32`, in the passthrough at +`box/models.py:204`, and in the AST extraction at `python_analyzer.py:466`. + +Two existing rough edges to fix if you render `optimization_range` there: the editor is a single-line +`Input` 120px wide receiving pretty-printed JSON (it wants a `Textarea`), and `formatDataForDisplay` +renders `{"V_th": [-60, -45]}` as `{V_th: -60,-45}`, losing the brackets. + +--- + +## 2. Add `NW_Optimization` to the palette + +`NW_Optimization.py` **is already synced** into +`gui/workflow_backend/django-project/codes/nodes/optimization/`, together with the four changed +`NW_*` nodes and — new — the whole `codes/neuroworkflow/optimization/` package, which is what +generated code imports `build_spec` and `optimize` from. Nothing else needs copying. + +No ports, no process steps — a workflow containing it executes exactly as it would without it. +`algorithm` carries `constraints={"allowed_values": [...]}`, so it renders as a dropdown for free. + +`JointOptimizationNode` was deleted: it was an in-graph grid search, i.e. the design this replaces. +A saved project that placed it will no longer find it. + +### The kernel image needs Optuna — do this first, it is the one blocker + +Workflows run in the nest kernel image, and that image has **no `optuna` and no `cmaes`**. Since +`NW_Optimization` defaults to `algorithm="cmaes"`, the first optimization anyone generates in the +GUI will stop at an `ImportError` — a clear one naming the install command, but a failure. Only +`algorithm="random"` runs without it. + +One line, in the pip block that already exists at +`gui/workflow_backend/django-project/neuroworkflow/Dockerfile.nest:128`: + +```dockerfile + pip install --no-cache-dir nestml nest-desktop "pandas>=2.2,<3.0" jupyterlab notebook \ + jupyterhub tvb-library tvb-framework statsmodels hdf5storage bmtk "numpy<2.5" \ + httpx ipywidgets optuna cmaes \ + "siibra==1.0.1a15" "traitlets==5.14.3" && \ +``` + +`cmaes` is a separate package from `optuna` and is required by the CMA-ES sampler specifically; the +NSGA-II/III and TPE samplers need only `optuna`. Adding them costs a rebuild of the nest image, +which is why it was left undone rather than slipped in. + +Optional, unrelated to the GUI but the same dependency: `pyproject.toml` declares extras for `nest`, +`visualization` and `dev` but none for this. Adding + +```toml +optimization = ["optuna>=3.0", "cmaes"] +``` + +to `[project.optional-dependencies]` gives library users `pip install -e ".[optimization]"`. + +--- + +## 3. One code-generation button + +If the canvas contains an `NW_Optimization` node, generate an optimization run; otherwise generate +what it generates today. No second button. + +Everything above `workflow_builder.build()` is unchanged — node creation, `configure()`, `add_node`, +`connect`. Only the tail differs. Today (`code_generation_service.py:328`): + +```python + success = workflow.execute() +``` + +With optimization: + +```python + # Parameters marked optimizable in the editor + clamp.NODE_DEFINITION.parameters["amp_na"].optimizable = True + clamp.NODE_DEFINITION.parameters["amp_na"].optimization_range = [100.0, 1000.0] + clamp.NODE_DEFINITION.parameters["amp_na"].unit = "nA" + + conn.NODE_DEFINITION.parameters["syn_weight"].optimizable = True + conn.NODE_DEFINITION.parameters["syn_weight"].optimization_range = [1.0, 100.0] + + # Parameters marked as objectives in the editor + exc.NODE_DEFINITION.parameters["mean_firing_rate"].is_objective = True + exc.NODE_DEFINITION.parameters["mean_firing_rate"].objective_range = [40.0, 50.0] + exc.NODE_DEFINITION.parameters["mean_firing_rate"].measures = "ana.firing_rate_hz.exc" + + spec = build_spec(workflow, opt.algorithm_config()) + result = optimize(workflow, spec=spec, results_path=opt.results_path()) +``` + +Copy the shape from `generated_optimization_example.py` — it runs. + +Three things to know while implementing it: + +- **The declarations are a translation, not a copy.** The study is stored on the optimization node, + and the generator turns each entry into the assignment on the owning node shown above. Emitting the + same shape a hand-written notebook uses means one code shape to understand, and `build_spec()` still + performs its validation and range-clipping. The existing "changed parameters only" logic does not + help here: `_get_modified_parameters_for_configure` (`code_generation_service.py:502`) looks solely + at `default_value`. +- **The optimization node is configured but not added to the workflow.** It declares how to search + and takes no part in execution. +- **A search has no boolean outcome.** Not reaching the target is a *result*, not a failure — the run + answered "nothing in these ranges hits the band". Only a run where no trial produced a usable + measurement (`result.best is None`) should exit non-zero. + +--- + +## 4. Adopt the best configuration — an explicit action + +The run does not write anything back: `apply_best()` changes the in-memory nodes inside that +process, and the `FlowNode` rows still hold what the user typed. + +Everything needed is in the ledger: + +``` +//status.json → best.params + {"clamp.amp_na": 430.67, "conn.syn_weight": 7.84} +``` + +Each key is `instance_name.parameter[.key]`, so an "adopt" button is: resolve the instance name to a +`node_id`, call `update_node_parameter(..., parameter_field="default_value")` once per address, then +regenerate the code. + +### With several objectives, let the user pick from the front + +A multi-objective run has no single winner. `status.json` carries `pareto_front`, a list of +configurations where improving one objective would cost another, each with both its `measured` +values and the `params` that produced them. + +The natural interface is a plot: objective 1 against objective 2, one point per front member, the +target bands shaded. Clicking a point adopts *that* configuration — the same +`update_node_parameter` loop as the adopt button, using that member's `params` instead of +`best.params`. + +This is where the choice belongs. The script falls back to the member whose *worst* objective is +closest to its target, each miss sized against its own target range (`target_ranges_off`), which is +a tie-break and nothing more; +deciding whether to favour firing rate over regularity is the scientist's call, and a picture is how +it gets made. + +Keep it a deliberate button, never a side effect of the run. `run.json` records the baseline the +result is compared against; silently overwriting the user's parameters destroys that reference and is +very hard to explain afterwards. + +--- + +## 5. A panel over the ledger (later) + +Everything a UI needs is already written to files under `results_path//`, and monitoring is +just reading them: + +| file | for | +|---|---| +| `run.json` | the manifest: dimensions, objectives, algorithm, baseline. Written once | +| `trials.jsonl` | one line per evaluation, append-only | +| `status.json` | replaced each generation: `state`, counts, `best`, `progress.best_target_ranges_off_by_gen` | +| `control.json` | **written by the UI** to steer: `stop`, `pause`, `resume`, `inject` | + +`progress.best_target_ranges_off_by_gen` exists so a convergence curve can be drawn from +`status.json` alone, without parsing every trial. Its unit is **target ranges missed by**: how far +the worst objective landed outside its target, divided by the width of that target range, so `1.4` +means the miss is 1.4 times as wide as the range the user asked for and `0` means every target is +met. Objectives in Hz and in ms cannot share an axis otherwise. The per-trial misses, each in its +own unit, are in `trials.jsonl` under `fitness`. + +Label the two apart in the UI, because users confuse them: a miss is shown with its unit +(`off 8.2 ms`), the comparable figure as a multiple (`1.4x its target range`) and never with a unit. +`status.json.message` is a ready-made one-line summary including the target. + +A command is applied at most once: the loop acts only when `control.seq > status.control_ack.seq`, +and records the outcome in `control_ack` — so the writer confirms delivery by polling the same file +it already watches. No locking, no sockets. + +Reuse the viewer's path resolver (`app/workflow/viewer_tools/resolver.py`) — `existing_project_dir()` +plus `_resolve_explicit()`, which already guards against path traversal. + +--- + +## 6. Two pre-existing bugs worth fixing while in there + +**Instance names are not sanitized.** `code_generation_service.py:388,406`: + +```python +var_name = instance_name +code_block = f""" {var_name} = {label}("{var_name}")""" +``` + +A node named `Excitatory Pop` generates `Excitatory Pop = NW_Population("Excitatory Pop")` — a +`SyntaxError` that kills the whole script. `_sanitize_variable_name()` exists but is applied to node +*IDs*, never to `instanceName`. A rule was added to the chat system prompt +(`app/chat/services/chat_orchestrator.py:12`) so the assistant avoids it, but that does not help a +human typing in the modal. + +**Booleans are emitted as integers.** `_convert_parameter_value` treats `True` as numeric, so +`plot_raster=True` is written as `plot_raster=1`. It works, being truthy, but the generated code +misstates the type. + +--- + +## Recommended order + +1. **`optuna` and `cmaes` in the nest image** — one line, but until it is there every optimization + fails on import, so nothing downstream can be tested end to end +2. `NW_Optimization` in the palette — nothing can be declared without it (files already synced) +3. The optimization panel: exploration list and objectives, with the `measures` picker +4. Generator optimization mode +5. Adopt-best button +6. The ledger panel + +Steps 1-4 make the loop usable end to end; a user can then configure a search, generate it and run +it. Step 5 closes it back to the editor. Step 6 is what turns a long run from opaque into watchable. diff --git a/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/__init__.py b/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/__init__.py new file mode 100644 index 00000000..17c7fb55 --- /dev/null +++ b/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/__init__.py @@ -0,0 +1,47 @@ +"""Parameter optimization for NeuroWorkflow workflows. + +The workflow is the objective function; the optimizer wraps it. Typical use:: + + from neuroworkflow.optimization import build_spec, optimize, AlgorithmConfig + + spec = build_spec(workflow, AlgorithmConfig(name="cmaes", pop_size=12)) + print(spec.summary()) # review, edit, or hand to an agent + result = optimize(workflow, spec=spec) + print(result.configure_snippet()) +""" + +from .addressing import discover_measurables, read_output, set_parameter +from .engine import (OptimizationResult, objective_fitness, optimize, + reusable_paths) +from .ledger import Ledger +from .optimizers import Optimizer, available, register_optimizer +from .spec import ( + AlgorithmConfig, + Dimension, + Objective, + OptimizationSpec, + build_spec, + collect_dimensions, + collect_objectives, +) + +__all__ = [ + "AlgorithmConfig", + "Dimension", + "Ledger", + "Objective", + "OptimizationResult", + "OptimizationSpec", + "Optimizer", + "available", + "build_spec", + "collect_dimensions", + "collect_objectives", + "discover_measurables", + "objective_fitness", + "optimize", + "read_output", + "reusable_paths", + "register_optimizer", + "set_parameter", +] diff --git a/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/addressing.py b/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/addressing.py new file mode 100644 index 00000000..91f7e177 --- /dev/null +++ b/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/addressing.py @@ -0,0 +1,136 @@ +"""Dotted addresses into a workflow. + +Two kinds of address are used by the optimizer, both rooted at a node name: + +* a **parameter** address names something to set — ``"Model.nest_params.C_m"`` +* a **measurement** address names something to read — ``"Analysis.firing_rate_hz.exc"`` + +The first segment is always the node name. The second is the parameter or output +port name. Any further segments index into a nested dict. +""" + +from copy import deepcopy +from typing import Any, Dict, List, Tuple + +# Deeper than this and an "objective" is almost certainly a data structure +# rather than a measured quantity. +MAX_LEAF_DEPTH = 4 + + +def split_address(address: str) -> Tuple[str, str, List[str]]: + """Split ``"Node.port.k1.k2"`` into ``("Node", "port", ["k1", "k2"])``.""" + parts = address.split(".") + if len(parts) < 2: + raise ValueError( + f"Address {address!r} must be at least 'Node.name' " + f"(e.g. 'Analysis.firing_rate_hz.exc')" + ) + return parts[0], parts[1], parts[2:] + + +def _get_node(workflow, node_name: str): + if node_name not in workflow.nodes: + raise KeyError( + f"No node named {node_name!r} in the workflow " + f"(have: {', '.join(sorted(workflow.nodes))})" + ) + return workflow.nodes[node_name] + + +def set_parameter(workflow, address: str, value: Any) -> None: + """Set a parameter by dotted address, going through ``Node.configure()``. + + ``configure()`` only accepts whole parameters, so a nested key is applied by + copying the current dict, updating the key, and configuring the result. The + copy matters: mutating the live dict in place would edit the node's state + even if ``configure()`` then rejected the value. + """ + node_name, param, keys = split_address(address) + node = _get_node(workflow, node_name) + + if param not in node._parameters: + raise KeyError( + f"Node {node_name!r} has no parameter {param!r} " + f"(have: {', '.join(sorted(node._parameters))})" + ) + + if not keys: + node.configure(**{param: value}) + return + + current = deepcopy(node._parameters[param]) + if not isinstance(current, dict): + raise TypeError( + f"Address {address!r} indexes into {param!r}, but it holds " + f"{type(current).__name__}, not a dict" + ) + + target = current + for k in keys[:-1]: + if not isinstance(target.get(k), dict): + raise KeyError(f"Address {address!r}: {k!r} is not a nested dict") + target = target[k] + target[keys[-1]] = value + + node.configure(**{param: current}) + + +def read_output(workflow, address: str) -> Any: + """Read a value from an output port by dotted address.""" + node_name, port, keys = split_address(address) + node = _get_node(workflow, node_name) + + if port not in node._output_ports: + raise KeyError( + f"Node {node_name!r} has no output port {port!r} " + f"(have: {', '.join(sorted(node._output_ports))})" + ) + + value = node._output_ports[port].value + for k in keys: + if not isinstance(value, dict): + raise TypeError( + f"Address {address!r}: cannot index {type(value).__name__} with {k!r}" + ) + if k not in value: + raise KeyError( + f"Address {address!r}: key {k!r} not in " + f"{', '.join(map(str, list(value)[:8]))}" + ) + value = value[k] + return value + + +def _is_number(value: Any) -> bool: + # bool is an int subclass but is never a measured quantity. + return isinstance(value, (int, float)) and not isinstance(value, bool) + + +def discover_measurables(workflow) -> Dict[str, float]: + """Walk every output port and collect the numeric leaves it currently holds. + + This is what makes ``measures`` usable: the candidate targets come from the + data a baseline run actually produced, not from a declaration a node author + had to anticipate. Lists and arrays are skipped on purpose — a target that + needs a reduction belongs in an analysis node as its own named output. + """ + found: Dict[str, float] = {} + + def walk(prefix: str, value: Any, depth: int) -> None: + if _is_number(value): + found[prefix] = float(value) + return + if isinstance(value, dict) and depth < MAX_LEAF_DEPTH: + for k, v in value.items(): + # A leading underscore marks a key as internal plumbing a node passes + # to another node — not something anyone would target. Without this, + # a builder's bookkeeping shows up in the menu of measurable values + # alongside the real measurements. + if isinstance(k, str) and not k.startswith("_"): + walk(f"{prefix}.{k}", v, depth + 1) + + for node_name, node in workflow.nodes.items(): + for port_name, port in node._output_ports.items(): + walk(f"{node_name}.{port_name}", port.value, 1) + + return found diff --git a/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/engine.py b/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/engine.py new file mode 100644 index 00000000..093fb201 --- /dev/null +++ b/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/engine.py @@ -0,0 +1,695 @@ +"""The optimization loop. + +The workflow is the objective function; the optimizer is the outer loop. A +workflow is a DAG and runs feed-forward once, so the loop cannot live inside it — +it sits outside and calls the workflow repeatedly: + + ask -> configure nodes -> workflow.execute() -> read measured values + -> fitness -> tell -> log -> repeat + +The workflow is built once and reconfigured between trials; it is never rebuilt. + +The loop is fully usable with no agent attached: it narrates to stdout, writes the +ledger, and stops on its own. An agent or a GUI panel participates by reading the +ledger and writing ``control.json`` — nothing here requires that to happen. +""" + +import os +import shutil +import time +from dataclasses import dataclass, field +from datetime import datetime +from typing import Any, Callable, Dict, List, Optional, Sequence + +from .addressing import read_output, set_parameter +from .ledger import Ledger +from .optimizers import create_optimizer +from .spec import AlgorithmConfig, Objective, OptimizationSpec, build_spec + +#: A hook that inspects a trial's outputs and returns a reason to reject it, or +#: None to accept. A scalar fitness cannot tell a healthy network from a +#: pathological one that merely averages to the right number — this is where that +#: judgement plugs in. +RejectFn = Callable[[Any, Dict[str, float]], Optional[str]] + + +@dataclass +class OptimizationResult: + run_id: str + run_dir: str + spec: OptimizationSpec + trials: List[Dict[str, Any]] = field(default_factory=list) + best: Optional[Dict[str, Any]] = None + pareto_front: List[Dict[str, Any]] = field(default_factory=list) + stop_reason: str = "" + + def apply_best(self, workflow, execute: bool = False) -> bool: + """Set the workflow's parameters to those of the best trial. + + The search leaves the workflow configured with whatever the *last* trial + used, which is rarely the best one. This applies the winner instead. + + Deliberately opt-in: parameters define a run, so the loop never writes a + result back on its own. With ``execute=True`` the workflow is re-run + afterwards, so its output ports match its parameters again — without it, + the ports still hold the last trial's values. + """ + if not self.best: + return False + for address, value in self.best["params"].items(): + set_parameter(workflow, address, value) + return workflow.execute() if execute else True + + def configure_snippet(self) -> str: + """A ready-to-paste snippet applying the best configuration. + + A dict key cannot be passed as a keyword argument, so those are emitted as + a copy of the current dict with the tuned keys replaced — the same + read-modify-write a notebook does by hand. + """ + if not self.best: + return "# no successful trial" + + scalars: Dict[str, Dict[str, Any]] = {} + nested: Dict[str, Dict[str, Dict[str, Any]]] = {} + for address, value in self.best["params"].items(): + node, _, rest = address.partition(".") + param, _, key = rest.partition(".") + if key: + nested.setdefault(node, {}).setdefault(param, {})[key] = value + else: + scalars.setdefault(node, {})[param] = value + + lines = [] + for node in dict.fromkeys(list(scalars) + list(nested)): + args = [f"{k}={v!r}" for k, v in scalars.get(node, {}).items()] + for param, keys in nested.get(node, {}).items(): + updates = ", ".join(f'"{k}": {v!r}' for k, v in keys.items()) + args.append( + f'{param}={{**{node}._parameters["{param}"], {updates}}}' + ) + lines.append(f"{node}.configure({', '.join(args)})") + return "\n".join(lines) + + +# --------------------------------------------------------------------------- +# Fitness +# --------------------------------------------------------------------------- + +def objective_fitness(objective: Objective, value: float) -> float: + """Distance from the target, always minimized. + + ``in_range`` is zero anywhere inside the band and grows with the distance + outside it — a band, not a point, so seed-to-seed noise is absorbed rather + than chased. + """ + if objective.goal == "minimize": + return float(value) + if objective.goal == "maximize": + return -float(value) + if value < objective.low: + return float(objective.low - value) + if value > objective.high: + return float(value - objective.high) + return 0.0 + + +def objective_scales(spec) -> List[float]: + """The scale each objective's distance is measured against, one per objective. + + Misses live in each objective's own unit — Hz for one, ms for another — so they + cannot be added or compared as they stand. Dividing each by its own scale makes them + comparable, and for a target range the natural scale is the width of that range: by + asking for 40-50 Hz the user already said a 10 Hz spread is acceptable. It also + avoids the usual difficulty of scaling by the nadir point, which needs knowledge of + the Pareto front we do not have. + + Falls back to the magnitude of the target when a range has zero width, and to the + baseline measurement for a minimize/maximize goal, which has no range at all. + """ + scales = [] + for objective in spec.objectives: + scale = None + if objective.goal == "in_range" and objective.low is not None and objective.high is not None: + width = float(objective.high) - float(objective.low) + if width > 0: + scale = width + else: + scale = abs(float(objective.high)) or None + else: + baseline = (spec.baseline.get("measured") or {}).get(objective.name) + if isinstance(baseline, (int, float)) and baseline: + scale = abs(float(baseline)) + scales.append(scale or 1.0) + return scales + + +def target_ranges_off(spec, fitness: Optional[Sequence[float]]) -> Optional[float]: + """How far the worst objective missed, counted in its own target range. + + One objective, targeted at 40-50 Hz, is a target range 10 Hz wide. A trial measuring + 25.9 Hz missed it by 14.1 Hz, so 14.1 / 10 = 1.4: the miss is 1.4 times the size of + the range that was asked for. 0 means the value landed inside the range. + + Dividing is what makes two objectives comparable at all: a 14.1 Hz miss and an 8.2 ms + miss cannot be ranked as they stand, but "1.4 times its range" and "0.4 times its + range" can. The divisor comes from the user, who said by choosing 40-50 that a 10 Hz + spread is acceptable. + + The value reported is the LARGEST of the objectives, not their sum: a trial is only + as good as whatever it is doing worst, so 0 requires every objective to be inside its + range. (Adding them would need a unit they do not share, and would quietly favour + whichever objective uses bigger numbers.) + + Only ever used for reporting and for picking a representative. What the optimizer is + told stays raw and per-objective, so the search itself is unaffected. + """ + worst = worst_objective(spec, fitness) + return None if worst is None else worst[1] + + +def worst_objective(spec, fitness: Optional[Sequence[float]]): + """The objective furthest from its target, as ``(name, target ranges missed by)``.""" + if fitness is None: + return None + scales = objective_scales(spec) + ranked = [(o.name, abs(f) / s) + for o, f, s in zip(spec.objectives, fitness, scales)] + return max(ranked, key=lambda pair: pair[1], default=None) + + +def reusable_paths(workflow) -> List[str]: + """Artifacts the workflow's nodes say a later run can reuse. + + A node opts in with a class attribute, relative to ``results_path``:: + + class MyBuilder(Node): + REUSABLE_PATHS = ("network",) + + The engine neither knows nor cares what they contain — only that copying them + into a trial lets a node recognise its own earlier work as still current and + skip redoing it. A node that declares nothing simply gets no help, which is + the correct default for any node whose outputs are cheap or always differ. + """ + names = set() + for node in workflow.nodes.values(): + for name in getattr(type(node), "REUSABLE_PATHS", ()) or (): + name = str(name).strip() + # Relative names only: a declaration must not reach outside the trial. + if name and not os.path.isabs(name) and ".." not in name.split(os.sep): + names.add(name) + return sorted(names) + + +def _point_at_trial_dir(workflow, run_dir: str, trial_no: int, + seed_root: Optional[str] = None, + seed_names: Sequence[str] = ()) -> str: + """Give a trial its own results directory and return it. + + Nodes that write files — a network builder, a simulator config — otherwise + rewrite the same paths on every trial. Beyond losing each trial's outputs, + rebuilding a file in place can fail outright while a handle from the previous + trial is still open. This is the same thing a notebook does by hand when it + re-runs a workflow into a fresh directory. + + Anything the nodes declared reusable is copied in from ``seed_root``, so a + trial that changes nothing relevant can skip rebuilding it. Sharing one + directory between trials would save the copy, but a trial that *does* change + the artifact would then rewrite it in place — the failure this isolation + exists to prevent. + """ + trial_dir = os.path.join(run_dir, "trials", f"{trial_no:04d}") + os.makedirs(trial_dir, exist_ok=True) + + if seed_root: + for name in seed_names: + source = os.path.join(seed_root, name) + target = os.path.join(trial_dir, name) + if os.path.isdir(source) and not os.path.exists(target): + shutil.copytree(source, target) + + workflow.context["results_path"] = trial_dir + for node in workflow.nodes.values(): + node._context["results_path"] = trial_dir + return trial_dir + + +def _dominates(a: List[float], b: List[float]) -> bool: + return all(x <= y for x, y in zip(a, b)) and any(x < y for x, y in zip(a, b)) + + +def _pareto_front(rows: List[Dict[str, Any]]) -> List[Dict[str, Any]]: + scored = [r for r in rows if r.get("fitness")] + return [ + r for r in scored + if not any(_dominates(o["fitness"], r["fitness"]) + for o in scored if o is not r) + ] + + +# --------------------------------------------------------------------------- +# The loop +# --------------------------------------------------------------------------- + +def optimize(workflow, + spec: Optional[OptimizationSpec] = None, + results_path: str = "results/optimization", + algorithm: Optional[AlgorithmConfig] = None, + reject_fn: Optional[RejectFn] = None, + run_id: Optional[str] = None, + per_trial_results: bool = True, + stop_when_reached: Optional[bool] = None, + verbose: bool = True) -> OptimizationResult: + """Optimize a built workflow against the targets declared in its schemas. + + Args: + workflow: a built workflow that already runs at its current parameters. + spec: the optimization spec. Built by introspection when omitted — which + also runs the workflow once to establish the baseline. + results_path: directory the run directory is created under. + algorithm: algorithm config, when letting the spec be built here. + reject_fn: optional dynamics check; return a reason to reject a trial. + run_id: overrides the generated run id. + per_trial_results: give each trial its own results directory under the + run (default). Any workflow whose nodes write files needs this: + rewriting the same paths every trial loses each trial's outputs, and + rebuilding a file in place can fail outright while a handle from the + previous trial is still open. A workflow that writes nothing loses + nothing by having it on, so set it False only to keep every trial in + one directory on purpose. The workflow's results_path is left + pointing at the last trial when the run ends. + stop_when_reached: end the run as soon as one candidate satisfies every + target. Defaults to True for a single objective — the question is + answered, so more simulations are waste — and to False for several, + where the useful answer is the Pareto front: the set of trade-offs + between objectives. Stopping at the first candidate that satisfies + everything would return a front of one, which says nothing about the + trade-off. Only targets expressed as a band can be "reached" at all; + a minimize or maximize goal has nothing to hit, so it never triggers. + verbose: narrate progress to stdout. + """ + if spec is None: + spec = build_spec(workflow, algorithm=algorithm) + elif algorithm is not None: + spec.algorithm = algorithm + spec.validate() + + if stop_when_reached is None: + stop_when_reached = len(spec.objectives) == 1 + + if run_id is None: + # Second-resolution timestamps collide when runs start in the same second, + # which would silently append one run's trials to another's ledger. + run_id = base_id = f"opt_{datetime.now().strftime('%Y%m%d_%H%M%S')}" + attempt = 2 + while os.path.exists(os.path.join(results_path, run_id)): + run_id = f"{base_id}_{attempt}" + attempt += 1 + + ledger = Ledger(os.path.join(results_path, run_id), run_id) + ledger.write_manifest(spec, extra={ + "created_at": datetime.now().isoformat(timespec="seconds"), + "workflow_name": getattr(workflow, "name", ""), + }) + + optimizer = create_optimizer(spec.dimensions, len(spec.objectives), spec.algorithm) + + def say(message: str) -> None: + if verbose: + print(message, flush=True) + + say(f"[{run_id}] {spec.algorithm.name}: " + f"{len(spec.dimensions)} dimensions, {len(spec.objectives)} objective(s), " + f"up to {spec.algorithm.max_generations} generations " + f"x {spec.algorithm.pop_size} candidates") + for line in spec.summary().splitlines(): + say(" " + line) + if len(spec.objectives) > 1: + say(" each objective reports how far it missed, in its own unit. To compare " + "objectives measured in different units, that miss is also given as a " + "multiple of the target range asked for: '1.4x its target range' means the " + "miss is 1.4 times as wide as the range. 0 = the target was met.") + + # Captured before the first rotation: where the baseline ran, and whatever the + # nodes declared as reusable from it. + seed_root = workflow.context.get("results_path") if per_trial_results else None + seed_names = reusable_paths(workflow) if per_trial_results else [] + if seed_root and seed_names: + say(f" reusing {', '.join(seed_names)} from {seed_root}") + + reported_reached = False + trials: List[Dict[str, Any]] = [] + best_by_generation: List[Optional[float]] = [] + control_ack: Optional[Dict[str, Any]] = None + stop_reason = "" + paused = False + trial_no = 0 + + for generation in range(1, spec.algorithm.max_generations + 1): + candidates = optimizer.ask() + fitnesses: List[Optional[List[float]]] = [] + + for index, candidate in enumerate(candidates): + trial_no += 1 + trial_dir = (_point_at_trial_dir(workflow, str(ledger.run_dir), trial_no, + seed_root, seed_names) + if per_trial_results else None) + row = _evaluate(workflow, spec, candidate, reject_fn, + trial_no, generation, index, trial_dir) + fitnesses.append(row["fitness"]) + trials.append(row) + ledger.append_trial(row) + + previous = [t for t in trials[:-1] if t["target_ranges_off"] is not None] + is_best = row["target_ranges_off"] is not None and ( + not previous or row["target_ranges_off"] < min(t["target_ranges_off"] for t in previous) + ) + say(" " + _narrate_trial(spec, row, generation, index, + spec.algorithm.pop_size, is_best)) + + optimizer.tell(candidates, fitnesses) + + scored = [t for t in trials if t["fitness"] is not None] + best = min(scored, key=lambda t: t["target_ranges_off"], default=None) + best_by_generation.append(round(best["target_ranges_off"], 6) if best else None) + + # "Reached" only means something for a target expressed as a band: a + # minimize or maximize goal has no value that counts as arrival. + bands = [i for i, o in enumerate(spec.objectives) if o.goal == "in_range"] + in_range = bool( + best and bands and len(bands) == len(spec.objectives) + and all(best["fitness"][i] == 0.0 for i in bands) + ) + n_failed = sum(1 for t in trials if t["status"] == "failed") + n_rejected = sum(1 for t in trials if t["status"] == "rejected") + + # Stop conditions, checked before honouring control so an explicit + # command always wins over an automatic stop. + if in_range and stop_when_reached: + stop_reason = "a candidate is inside every target band" + elif in_range and not reported_reached: + reported_reached = True + say(" a candidate satisfies every target; continuing to develop " + "the Pareto front") + + command = ledger.read_control() + if command: + control_ack, stop_reason, paused = _apply_control( + command, optimizer, say, stop_reason, paused) + + ledger.write_status({ + "state": "done" if stop_reason else ("paused" if paused else "running"), + "updated_at": datetime.now().isoformat(timespec="seconds"), + "generation": generation, + "max_generations": spec.algorithm.max_generations, + "n_evals": len(trials), + "n_ok": len(scored), + "n_failed": n_failed, + "n_rejected": n_rejected, + "best": best, + "pareto_front": _pareto_front(trials) if len(spec.objectives) > 1 else [], + "progress": { + "best_target_ranges_off_by_gen": best_by_generation, + "gens_since_improvement": _gens_since_improvement(best_by_generation), + }, + "control_ack": control_ack, + "stop_reason": stop_reason or None, + "message": _narrate(generation, spec, best, in_range, + n_failed, n_rejected), + }) + + say(f" gen {generation}/{spec.algorithm.max_generations}: " + + _narrate(generation, spec, best, in_range, n_failed, n_rejected)) + + if stop_reason: + break + while paused: + time.sleep(2) + command = ledger.read_control() + if command: + control_ack, stop_reason, paused = _apply_control( + command, optimizer, say, stop_reason, paused) + if stop_reason: + break + if stop_reason: + break + else: + stop_reason = "generation budget exhausted" + + scored = [t for t in trials if t["fitness"] is not None] + best = min(scored, key=lambda t: t["target_ranges_off"], default=None) + front = _pareto_front(trials) if len(spec.objectives) > 1 else [] + + # A final status write, so a reader sees the run end. The per-generation write + # happens before the loop decides to stop, and the budget-exhausted case is + # decided after the loop entirely — without this, status.json would sit at + # "running" forever. + ledger.write_status({ + "state": "done", + "updated_at": datetime.now().isoformat(timespec="seconds"), + "generation": generation, + "max_generations": spec.algorithm.max_generations, + "n_evals": len(trials), + "n_ok": len(scored), + "n_failed": sum(1 for t in trials if t["status"] == "failed"), + "n_rejected": sum(1 for t in trials if t["status"] == "rejected"), + "best": best, + "pareto_front": front, + "progress": { + "best_target_ranges_off_by_gen": best_by_generation, + "gens_since_improvement": _gens_since_improvement(best_by_generation), + }, + "control_ack": control_ack, + "stop_reason": stop_reason, + "message": f"finished after {len(trials)} evaluations: {stop_reason}", + }) + + say(f"[{run_id}] stopped: {stop_reason}") + if best: + for objective, distance in zip(spec.objectives, best["fitness"]): + unit = f" {objective.unit}" if objective.unit else "" + band = (f"target {objective.low}-{objective.high}{unit}" + if objective.goal == "in_range" else objective.goal) + state = "in target" if distance == 0.0 else f"off {distance:.4g}{unit}" + say(f" {objective.name} = {best['measured'][objective.name]:.4g}{unit}" + f" ({band}, {state})") + if len(spec.objectives) > 1: + furthest = worst_objective(spec, best["fitness"]) + if furthest and furthest[1] > 0: + say(f" furthest from target: {furthest[0]}, " + f"{furthest[1]:.3g}x its target range") + + return OptimizationResult( + run_id=run_id, + run_dir=str(ledger.run_dir), + spec=spec, + trials=trials, + best=best, + pareto_front=front, + stop_reason=stop_reason, + ) + + +def _evaluate(workflow, spec, candidate, reject_fn, + trial_no: int, generation: int, index: int, + trial_dir: Optional[str] = None) -> Dict[str, Any]: + """Run one candidate and produce its ledger row.""" + started = time.time() + row: Dict[str, Any] = { + "trial": trial_no, + "generation": generation, + "candidate": index, + "started_at": datetime.now().isoformat(timespec="seconds"), + "source": "ask", + "params": dict(candidate), + "results_path": trial_dir, + "measured": {}, + "fitness": None, + "status": "ok", + "reject_reason": None, + "error": None, + } + + try: + for address, value in candidate.items(): + set_parameter(workflow, address, value) + + if not workflow.execute(): + row.update(status="failed", error="workflow.execute() returned False") + return _finish(row, started) + + measured = {} + for objective in spec.objectives: + value = read_output(workflow, objective.measures) + if not isinstance(value, (int, float)) or isinstance(value, bool): + row.update(status="failed", + error=f"{objective.measures} is not numeric: {value!r}") + return _finish(row, started) + measured[objective.name] = float(value) + row["measured"] = measured + + if reject_fn is not None: + reason = reject_fn(workflow, measured) + if reason: + row.update(status="rejected", reject_reason=reason) + return _finish(row, started) + + row["fitness"] = [objective_fitness(o, measured[o.name]) + for o in spec.objectives] + + except Exception as exc: # a bad candidate must not kill the run + row.update(status="failed", error=f"{type(exc).__name__}: {exc}") + + # Normalised, unit-free, for ranking and reporting only — the raw per-objective + # fitness above is what the optimizer was told. + row["target_ranges_off"] = target_ranges_off(spec, row["fitness"]) + return _finish(row, started) + + +def _finish(row: Dict[str, Any], started: float) -> Dict[str, Any]: + row.setdefault("target_ranges_off", None) + row["duration_s"] = round(time.time() - started, 3) + return row + + +def _apply_control(command, optimizer, say, stop_reason: str, paused: bool): + """Apply a control command and build the acknowledgement for status.json.""" + name = command.get("command", "") + args = command.get("args", {}) or {} + result = "" + + if name == "stop": + stop_reason = f"stopped by {command.get('issued_by', 'control.json')}" + result = "stopping" + elif name == "pause": + paused, result = True, "paused" + elif name == "resume": + paused, result = False, "resumed" + elif name == "inject": + accepted = 0 + for params in args.get("candidates", []): + try: + optimizer.enqueue(params) + accepted += 1 + except NotImplementedError: + result = f"{type(optimizer).__name__} cannot inject candidates" + break + result = result or f"{accepted} candidate(s) injected" + else: + result = f"unknown command {name!r}" + + say(f" control: {name} -> {result}") + return ( + { + "seq": command.get("seq"), + "command": name, + "issued_by": command.get("issued_by"), + "reason": command.get("reason"), + "applied_at": datetime.now().isoformat(timespec="seconds"), + "result": result, + }, + stop_reason, + paused, + ) + + +def _gens_since_improvement(history: List[Optional[float]]) -> int: + scored = [h for h in history if h is not None] + if not scored: + return 0 + best = min(scored) + for count, value in enumerate(reversed(history)): + if value is not None and value <= best: + return count + return len(history) + + +def _narrate_trial(spec, row, generation, index, pop_size, is_best) -> str: + """One line per trial: which trial, what it tried, what came out. + + A generation line alone leaves long stretches of simulator logging with nothing + readable in them, and hides the fact that the search is exploring rather than + stuck. + """ + label = f"gen {generation}, trial {index + 1}/{pop_size} (#{row['trial']})" + + tried = " ".join( + f"{d.address}={row['params'][d.address]:.4g}" + f"{' ' + d.unit if d.unit else ''}" + for d in spec.dimensions + ) + + if row["status"] != "ok": + why = row.get("reject_reason") or row.get("error") or "" + return f"{label}: {tried} -> {row['status']}: {why}" + + # Each distance in its own unit. Adding them would mean adding, say, Hz to ms — + # a number with no meaning, dominated by whichever objective has the larger range. + got = [] + for objective, distance in zip(spec.objectives, row["fitness"]): + unit = f" {objective.unit}" if objective.unit else "" + state = "in target" if distance == 0.0 else f"off {distance:.4g}{unit}" + got.append(f"{objective.name.split('.')[-1]}=" + f"{row['measured'][objective.name]:.4g}{unit} ({state})") + + # With one objective the miss above says everything. With several, name the one + # doing worst and size its miss against its own target range, the only way to + # compare a miss in Hz with a miss in ms. + worst = "" + if len(spec.objectives) > 1: + furthest = worst_objective(spec, row["fitness"]) + if furthest and furthest[1] > 0: + worst = (f"\n furthest from target: {furthest[0]}, " + f"{furthest[1]:.3g}x its target range") + elif furthest: + worst = "\n every target met" + + # The marker ranks this trial against the others, so it belongs on the line of + # measurements — not after the indented line below, which compares this trial's + # own objectives against each other. + marker = " <- best so far" if is_best else "" + return f"{label}: {tried} -> {', '.join(got)}{marker}{worst}" + + +def _narrate(generation, spec, best, in_range, n_failed, n_rejected) -> str: + """One line per generation: what the best candidate measured, against the goal. + + The goal is repeated every generation on purpose. A long run scrolls the spec far + out of view, and "46 Hz" means nothing without "target 40-50 Hz" beside it. + """ + if best is None: + return "no candidate has produced a usable measurement yet" + + # The parameter values that produced it, so a generation line answers both + # "how good" and "with what". + values = " ".join( + f"{d.address}={best['params'][d.address]:.4g}" + f"{' ' + d.unit if d.unit else ''}" + for d in spec.dimensions + ) + + parts = [] + for objective, distance in zip(spec.objectives, best["fitness"]): + unit = f" {objective.unit}" if objective.unit else "" + goal = (f"target {objective.low}-{objective.high}{unit}" + if objective.goal == "in_range" else objective.goal) + state = "in target" if distance == 0.0 else f"off {distance:.4g}{unit}" + parts.append( + f"{objective.name.split('.')[-1]}=" + f"{best['measured'][objective.name]:.4g}{unit} [{goal}, {state}]" + ) + + if in_range: + state = " — all targets met" + elif len(spec.objectives) > 1: + # "its" on purpose: this line is about the best trial, and the objective named + # is the weakest one inside that trial — not a comparison against other trials. + furthest = worst_objective(spec, best["fitness"]) + state = (f" — its furthest objective from target: {furthest[0]}, " + f"{furthest[1]:.3g}x its target range") if furthest else "" + else: + state = "" + extra = "" + if n_failed or n_rejected: + extra = f" ({n_failed} failed, {n_rejected} rejected)" + return f"best {values} -> {'; '.join(parts)}{state}{extra}" diff --git a/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/ledger.py b/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/ledger.py new file mode 100644 index 00000000..9148830f --- /dev/null +++ b/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/ledger.py @@ -0,0 +1,100 @@ +"""The ledger — the run's durable record and its steering seam. + +Everything the engine knows is written to plain files in the run directory, and +everything that steers the engine is read from one. No sockets, no queues: an +agent, a notebook or a GUI panel participates by reading and writing files. + + run.json manifest, written once + trials.jsonl one line per evaluation, append-only + status.json replaced each generation, the cheap poll + control.json written by a human or agent to steer the loop + +Write discipline: whole-file writes go through a temp file and ``os.replace`` so a +reader never sees half a document; ``trials.jsonl`` is appended and flushed per +line, so the only partial read possible is a truncated last line. +""" + +import json +import os +from pathlib import Path +from typing import Any, Dict, List, Optional + +SCHEMA_VERSION = 1 + + +def _write_atomic(path: Path, payload: Dict[str, Any]) -> None: + tmp = path.with_suffix(path.suffix + ".tmp") + with open(tmp, "w") as fh: + json.dump(payload, fh, indent=2, default=str) + os.replace(tmp, path) + + +class Ledger: + """Writes the run record; reads control commands.""" + + def __init__(self, run_dir: str, run_id: str): + self.run_dir = Path(run_dir) + self.run_id = run_id + self.run_dir.mkdir(parents=True, exist_ok=True) + self.run_path = self.run_dir / "run.json" + self.trials_path = self.run_dir / "trials.jsonl" + self.status_path = self.run_dir / "status.json" + self.control_path = self.run_dir / "control.json" + self._last_control_seq = 0 + + # -- writes ---------------------------------------------------------- + def write_manifest(self, spec, extra: Optional[Dict[str, Any]] = None) -> None: + payload = { + "schema_version": SCHEMA_VERSION, + "run_id": self.run_id, + **(extra or {}), + **spec.to_dict(), + } + _write_atomic(self.run_path, payload) + + def append_trial(self, trial: Dict[str, Any]) -> None: + with open(self.trials_path, "a") as fh: + fh.write(json.dumps({"schema_version": SCHEMA_VERSION, **trial}, + default=str) + "\n") + fh.flush() + + def write_status(self, status: Dict[str, Any]) -> None: + _write_atomic(self.status_path, { + "schema_version": SCHEMA_VERSION, + "run_id": self.run_id, + **status, + }) + + # -- reads ----------------------------------------------------------- + def read_trials(self) -> List[Dict[str, Any]]: + """Read every logged trial, tolerating a truncated final line.""" + if not self.trials_path.exists(): + return [] + rows = [] + for line in self.trials_path.read_text().splitlines(): + try: + rows.append(json.loads(line)) + except json.JSONDecodeError: + continue # a partially written tail line + return rows + + def read_control(self) -> Optional[Dict[str, Any]]: + """Return a control command if a new one has been written. + + A command is applied at most once: it is only returned when its ``seq`` + is higher than the last one acknowledged, which the writer can confirm by + reading ``control_ack`` back from ``status.json``. + """ + if not self.control_path.exists(): + return None + try: + command = json.loads(self.control_path.read_text()) + except (json.JSONDecodeError, OSError): + return None # being written right now; try again next generation + + seq = command.get("seq", 0) + if not isinstance(seq, int) or seq <= self._last_control_seq: + return None + + self._last_control_seq = seq + return command diff --git a/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/optimizers.py b/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/optimizers.py new file mode 100644 index 00000000..b81649b3 --- /dev/null +++ b/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/optimizers.py @@ -0,0 +1,208 @@ +"""Optimizer backends behind one ask / tell interface. + +The engine never talks to a search library directly. It asks for a generation of +candidates, evaluates them, and tells the fitnesses back. Everything else — +which algorithm, how it adapts, whether it is population-based — lives behind +this interface. + +Adding an algorithm: + +* if the library is Optuna, add one entry to ``_OPTUNA_SAMPLERS`` +* otherwise, subclass ``Optimizer`` and call ``register_optimizer`` + +Fitness is always a **list**, one entry per objective, and always **minimized** +(the engine converts targets into distances). Single-objective backends refuse a +multi-objective spec rather than silently collapsing it into a weighted sum. +""" + +import random +from abc import ABC, abstractmethod +from typing import Any, Callable, Dict, List, Optional, Sequence, Type + +from .spec import AlgorithmConfig, Dimension + + +class Optimizer(ABC): + """Proposes parameter vectors and learns from their fitnesses.""" + + #: Can this backend handle more than one objective at a time? + supports_multi_objective: bool = False + + def __init__(self, dimensions: Sequence[Dimension], n_objectives: int, + config: AlgorithmConfig): + if n_objectives > 1 and not self.supports_multi_objective: + raise ValueError( + f"{type(self).__name__} is single-objective but the spec declares " + f"{n_objectives} objectives. Choose a multi-objective algorithm " + f"(e.g. 'nsga2') — the engine will not collapse them into a " + f"weighted sum on its own." + ) + self.dimensions = list(dimensions) + self.n_objectives = n_objectives + self.config = config + + @abstractmethod + def ask(self) -> List[Dict[str, float]]: + """Propose the next generation as a list of {address: value} dicts.""" + + @abstractmethod + def tell(self, candidates: List[Dict[str, float]], + fitnesses: List[List[float]]) -> None: + """Report the measured fitness of each candidate from the last ``ask``.""" + + def enqueue(self, params: Dict[str, float]) -> None: + """Seed a chosen candidate into the next generation. + + Backends that cannot honour this should leave it as a no-op; the engine + logs whether an injection was accepted. + """ + raise NotImplementedError( + f"{type(self).__name__} does not support injecting candidates" + ) + + +# --------------------------------------------------------------------------- +# Registry +# --------------------------------------------------------------------------- + +_REGISTRY: Dict[str, Callable[..., Optimizer]] = {} + + +def register_optimizer(name: str, factory: Callable[..., Optimizer]) -> None: + _REGISTRY[name] = factory + + +def available() -> List[str]: + return sorted(_REGISTRY) + + +def create_optimizer(dimensions: Sequence[Dimension], n_objectives: int, + config: AlgorithmConfig) -> Optimizer: + if config.name not in _REGISTRY: + raise ValueError( + f"Unknown algorithm {config.name!r}. Available: {', '.join(available())}" + ) + return _REGISTRY[config.name](dimensions, n_objectives, config) + + +# --------------------------------------------------------------------------- +# RandomSearch — no dependencies, so the engine is always runnable +# --------------------------------------------------------------------------- + +class RandomSearch(Optimizer): + """Uniform sampling inside the bounds. A baseline, and the smoke test.""" + + supports_multi_objective = True + + def __init__(self, dimensions, n_objectives, config): + super().__init__(dimensions, n_objectives, config) + self._rng = random.Random(config.seed) + self._queued: List[Dict[str, float]] = [] + + def ask(self) -> List[Dict[str, float]]: + out: List[Dict[str, float]] = [] + while self._queued and len(out) < self.config.pop_size: + out.append(self._queued.pop(0)) + while len(out) < self.config.pop_size: + out.append({d.address: self._rng.uniform(d.low, d.high) + for d in self.dimensions}) + return out + + def tell(self, candidates, fitnesses) -> None: + pass # memoryless by design + + def enqueue(self, params: Dict[str, float]) -> None: + self._queued.append(dict(params)) + + +register_optimizer("random", RandomSearch) + + +# --------------------------------------------------------------------------- +# Optuna backends — CMA-ES, NSGA-II, NSGA-III, TPE, ... +# --------------------------------------------------------------------------- + +#: name -> (optuna sampler class attribute, multi-objective?, extra sampler kwargs) +_OPTUNA_SAMPLERS: Dict[str, tuple] = { + "cmaes": ("CmaEsSampler", False, {}), + "nsga2": ("NSGAIISampler", True, {}), + "nsga3": ("NSGAIIISampler", True, {}), + "tpe": ("TPESampler", True, {}), + "optuna_random": ("RandomSampler", True, {}), +} + + +class OptunaOptimizer(Optimizer): + """Adapter over Optuna's ask/tell API. + + Optuna hands out one trial at a time; a generation is simply ``pop_size`` + consecutive asks. Population-based samplers (NSGA-II/III) manage their own + generations internally, so this stays correct for them too. + """ + + def __init__(self, dimensions, n_objectives, config, sampler_name: str, + multi_objective: bool, sampler_kwargs: Dict[str, Any]): + self.supports_multi_objective = multi_objective + super().__init__(dimensions, n_objectives, config) + + try: + import optuna + from optuna.distributions import FloatDistribution + except ImportError as exc: # pragma: no cover - depends on environment + raise ImportError( + f"The {config.name!r} algorithm needs Optuna. " + f"Install it with: pip install optuna cmaes" + ) from exc + + optuna.logging.set_verbosity(optuna.logging.WARNING) + + sampler_cls = getattr(optuna.samplers, sampler_name, None) + if sampler_cls is None: # pragma: no cover - depends on optuna version + raise ImportError( + f"This Optuna version has no {sampler_name} " + f"(needed for algorithm {config.name!r})" + ) + + kwargs = dict(sampler_kwargs) + kwargs.update(config.options) + if config.seed is not None: + kwargs.setdefault("seed", config.seed) + if sampler_name.startswith("NSGA"): + kwargs.setdefault("population_size", config.pop_size) + + self._optuna = optuna + self._distributions = { + d.address: FloatDistribution(d.low, d.high) for d in self.dimensions + } + self._study = optuna.create_study( + directions=["minimize"] * n_objectives, + sampler=sampler_cls(**kwargs), + ) + self._pending: List[Any] = [] + + def ask(self) -> List[Dict[str, float]]: + self._pending = [self._study.ask(self._distributions) + for _ in range(self.config.pop_size)] + return [dict(t.params) for t in self._pending] + + def tell(self, candidates, fitnesses) -> None: + for trial, fitness in zip(self._pending, fitnesses): + if fitness is None: + self._study.tell(trial, state=self._optuna.trial.TrialState.FAIL) + else: + self._study.tell(trial, list(fitness)) + self._pending = [] + + def enqueue(self, params: Dict[str, float]) -> None: + self._study.enqueue_trial(dict(params), skip_if_exists=False) + + +def _make_optuna_factory(sampler_name: str, multi: bool, kwargs: Dict[str, Any]): + def factory(dimensions, n_objectives, config): + return OptunaOptimizer(dimensions, n_objectives, config, + sampler_name, multi, kwargs) + return factory + + +for _name, (_sampler, _multi, _kwargs) in _OPTUNA_SAMPLERS.items(): + register_optimizer(_name, _make_optuna_factory(_sampler, _multi, _kwargs)) diff --git a/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/spec.py b/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/spec.py new file mode 100644 index 00000000..4ca54860 --- /dev/null +++ b/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/spec.py @@ -0,0 +1,396 @@ +"""The optimization spec — what to tune, what to hit, and with which algorithm. + +The spec is plain data. It is built from the node schemas by introspection, then +handed to a human or an agent to review and edit, then consumed by the engine and +frozen into ``run.json``. Nothing in it is Python-specific, so an agent can change +the algorithm, widen a range or retarget a band without touching code. +""" + +from dataclasses import dataclass, field, asdict +from typing import Any, Dict, List, Optional + +from neuroworkflow.core.schema import ParameterDefinition + +from .addressing import discover_measurables + + +@dataclass +class Dimension: + """One axis of the search space.""" + + address: str # "Model.nest_params.C_m" + low: float + high: float + unit: str = "" + description: str = "" + source: str = "" # where the range came from + note: str = "" # e.g. why it was clipped + + +@dataclass +class Objective: + """One target the search is steering toward.""" + + name: str # "Population_exc.target_rate_hz" + measures: str # "Analysis.firing_rate_hz.exc" + low: Optional[float] = None # target band, for goal="in_range" + high: Optional[float] = None + goal: str = "in_range" # in_range | minimize | maximize + unit: str = "" + description: str = "" + source: str = "" + + +@dataclass +class AlgorithmConfig: + """Which optimizer to run and how. Editable by a human or an agent.""" + + name: str = "random" # see optimizers.available() + pop_size: int = 16 + max_generations: int = 20 + seed: Optional[int] = None + options: Dict[str, Any] = field(default_factory=dict) + + +@dataclass +class OptimizationSpec: + dimensions: List[Dimension] = field(default_factory=list) + objectives: List[Objective] = field(default_factory=list) + algorithm: AlgorithmConfig = field(default_factory=AlgorithmConfig) + locked_protocol: Dict[str, Any] = field(default_factory=dict) + baseline: Dict[str, Any] = field(default_factory=dict) + skipped: List[Dict[str, str]] = field(default_factory=list) + + # -- serialization --------------------------------------------------- + def to_dict(self) -> Dict[str, Any]: + return asdict(self) + + @classmethod + def from_dict(cls, data: Dict[str, Any]) -> "OptimizationSpec": + return cls( + dimensions=[Dimension(**d) for d in data.get("dimensions", [])], + objectives=[Objective(**o) for o in data.get("objectives", [])], + algorithm=AlgorithmConfig(**data.get("algorithm", {})), + locked_protocol=data.get("locked_protocol", {}), + baseline=data.get("baseline", {}), + skipped=data.get("skipped", []), + ) + + # -- validation ------------------------------------------------------ + def validate(self) -> None: + """Raise if the spec cannot be run. Called by the engine before starting.""" + if not self.dimensions: + raise ValueError( + "No search dimensions — mark at least one parameter " + "optimizable=True with a range, or add a Dimension by hand." + ) + if not self.objectives: + raise ValueError( + "No objectives — optimization without a target has no direction. " + "Declare is_objective=True with objective_range and measures, or " + "add an Objective by hand." + ) + for d in self.dimensions: + if d.low >= d.high: + raise ValueError(f"Dimension {d.address}: low {d.low} >= high {d.high}") + for o in self.objectives: + if o.goal not in ("in_range", "minimize", "maximize"): + raise ValueError(f"Objective {o.name}: unknown goal {o.goal!r}") + if o.goal == "in_range" and (o.low is None or o.high is None): + raise ValueError( + f"Objective {o.name}: goal 'in_range' needs both low and high " + f"(set objective_range on the parameter)" + ) + + def add_objective(self, name: str, measures: str, + low: Optional[float] = None, high: Optional[float] = None, + goal: str = "in_range", unit: str = "", + description: str = "") -> "OptimizationSpec": + """Declare a target that no node parameter carries. + + An objective is a label, a measurement address and a band — nothing about it + requires a parameter to hang it on. Declaring it here keeps a study's target + out of the model, and avoids inventing a parameter the simulation never reads + purely as somewhere to store a number. + + The address is checked against the baseline run, so a typo fails here, naming + what *is* available, rather than at the first trial. + """ + if any(o.name == name for o in self.objectives): + raise ValueError(f"An objective named {name!r} is already declared") + + available = self.baseline.get("measurables") or {} + if available and measures not in available: + node = measures.split(".")[0] + if node not in {a.split(".")[0] for a in available}: + raise ValueError( + f"measures {measures!r}: no node named {node!r} produced anything " + f"measurable. Nodes that did: " + f"{', '.join(sorted({a.split('.')[0] for a in available}))}" + ) + near = sorted(a for a in available if a.startswith(node + ".")) + raise ValueError( + f"measures {measures!r} is not a number produced by the baseline run. " + f"On {node!r}: {', '.join(near)}" + ) + + self.objectives.append(Objective( + name=name, measures=measures, low=low, high=high, + goal=goal, unit=unit, description=description, source="study", + )) + return self + + def summary(self) -> str: + lines = [ + f"algorithm : {self.algorithm.name} " + f"(pop_size={self.algorithm.pop_size}, " + f"max_generations={self.algorithm.max_generations})", + f"dimensions: {len(self.dimensions)}", + ] + for d in self.dimensions: + unit = f" {d.unit}" if d.unit else "" + note = f" [{d.note}]" if d.note else "" + lines.append(f" {d.address:<40} [{d.low}, {d.high}]{unit}{note}") + lines.append(f"objectives: {len(self.objectives)}") + for o in self.objectives: + band = ( + f"in [{o.low}, {o.high}]" if o.goal == "in_range" else o.goal + ) + unit = f" {o.unit}" if o.unit else "" + lines.append(f" {o.name:<40} {band}{unit} <- {o.measures}") + if self.skipped: + lines.append(f"skipped : {len(self.skipped)}") + for s in self.skipped: + lines.append(f" {s['address']:<40} {s['reason']}") + return "\n".join(lines) + + +# --------------------------------------------------------------------------- +# Building a spec from the node schemas +# --------------------------------------------------------------------------- + +def _numeric_pair(value: Any) -> Optional[List[float]]: + if isinstance(value, (list, tuple)) and len(value) == 2: + if all(isinstance(v, (int, float)) and not isinstance(v, bool) for v in value): + return [float(value[0]), float(value[1])] + return None + + +def collect_dimensions(workflow) -> tuple: + """Collect search dimensions from every ``optimizable=True`` parameter. + + Returns ``(dimensions, skipped)``. A parameter is skipped rather than + guessed at when no usable range can be derived — the engine reports those so + a human or agent can supply ranges deliberately. + """ + dimensions: List[Dimension] = [] + skipped: List[Dict[str, str]] = [] + + for node_name, node in workflow.nodes.items(): + params = getattr(node, "NODE_DEFINITION", None) + if params is None: + continue + for pname, pdef in params.parameters.items(): + if not isinstance(pdef, ParameterDefinition) or not pdef.optimizable: + continue + + address = f"{node_name}.{pname}" + + # The node's live value, not the schema default: a key added through + # configure() (a NEST parameter the default dict does not list, say) + # is just as tunable as one that was declared. + value = node._parameters.get(pname) + + # A dict-valued parameter declares one range per key. Each becomes its + # own dimension, addressed as Node.parameter.key — the address the + # engine reassembles into the whole dict before calling configure(). + if isinstance(pdef.optimization_range, dict): + for key, pair in pdef.optimization_range.items(): + key_address = f"{address}.{key}" + rng = _numeric_pair(pair) + if rng is None: + skipped.append({ + "address": key_address, + "reason": f"range is not [min, max]: {pair}", + }) + continue + if isinstance(value, dict) and key not in value: + skipped.append({ + "address": key_address, + "reason": "key is not present in the parameter's " + "current value — configure() it first", + }) + continue + dimensions.append(Dimension( + address=key_address, low=rng[0], high=rng[1], + unit=pdef.unit, description=pdef.description, + source="schema.optimization_range", + )) + continue + + if isinstance(value, dict): + skipped.append({ + "address": address, + "reason": "dict parameter with no per-key optimization_range — " + 'declare one, e.g. {"V_th": [-60.0, -45.0]}', + }) + continue + + c_min = pdef.constraints.get("min") + c_max = pdef.constraints.get("max") + rng = _numeric_pair(pdef.optimization_range) + source, note = "schema.optimization_range", "" + + if rng is None: + if isinstance(c_min, (int, float)) and isinstance(c_max, (int, float)): + rng, source = [float(c_min), float(c_max)], "schema.constraints" + else: + skipped.append({ + "address": address, + "reason": "optimizable but no optimization_range and no " + "min/max constraints to fall back on", + }) + continue + + # Constraints are the authority: a range reaching past them describes + # points configure() would reject anyway, so clip rather than fail. + low, high = rng + clipped = [] + if isinstance(c_min, (int, float)) and low < c_min: + clipped.append(f"low raised to {c_min}") + low = float(c_min) + if isinstance(c_max, (int, float)) and high > c_max: + clipped.append(f"high lowered to {c_max}") + high = float(c_max) + if clipped: + source, note = "clipped", "; ".join(clipped) + " (constraints)" + + if low >= high: + skipped.append({ + "address": address, + "reason": f"empty range after clipping to constraints: [{low}, {high}]", + }) + continue + + dimensions.append(Dimension( + address=address, low=low, high=high, + unit=pdef.unit, description=pdef.description, + source=source, note=note, + )) + + return dimensions, skipped + + +def collect_objectives(workflow, measurables: Dict[str, float]) -> tuple: + """Collect objectives from every ``is_objective=True`` parameter. + + ``measures`` is resolved against the measurables discovered in a baseline + run, so a broken address fails here — before any search budget is spent — + rather than midway through the loop. + """ + objectives: List[Objective] = [] + skipped: List[Dict[str, str]] = [] + + for node_name, node in workflow.nodes.items(): + definition = getattr(node, "NODE_DEFINITION", None) + if definition is None: + continue + for pname, pdef in definition.parameters.items(): + if not isinstance(pdef, ParameterDefinition) or not pdef.is_objective: + continue + + name = f"{node_name}.{pname}" + + if not pdef.measures: + skipped.append({ + "address": name, + "reason": "is_objective=True but no measures address — set it to " + "the output that holds the measured value", + }) + continue + + if pdef.measures not in measurables: + near = [m for m in measurables if m.startswith(pdef.measures.split(".")[0])] + skipped.append({ + "address": name, + "reason": f"measures {pdef.measures!r} did not resolve to a number " + f"in the baseline run" + + (f" (available on that node: {', '.join(sorted(near)[:6])})" + if near else ""), + }) + continue + + band = _numeric_pair(pdef.objective_range) + if band is None: + skipped.append({ + "address": name, + "reason": "is_objective=True but objective_range is not [min, max]", + }) + continue + + # The schema can only express a target band. minimize/maximize are set + # by editing the spec, which is also where an agent would change them. + objectives.append(Objective( + name=name, + measures=pdef.measures, + low=band[0], + high=band[1], + goal="in_range", + unit=pdef.unit, + description=pdef.description, + source="schema.objective_range", + )) + + return objectives, skipped + + +def build_spec(workflow, algorithm: Optional[AlgorithmConfig] = None, + run_baseline: bool = True) -> OptimizationSpec: + """Introspect a built workflow and produce a spec ready for review. + + With ``run_baseline=True`` the workflow is executed once at its current + parameters. That run does two jobs: it is the reference point every result is + compared against, and its outputs are what ``measures`` addresses resolve + against. + """ + baseline: Dict[str, Any] = {} + measurables: Dict[str, float] = {} + + if run_baseline: + ok = workflow.execute() + measurables = discover_measurables(workflow) + baseline = { + "executed": bool(ok), + "measurables": measurables, + } + if not ok: + raise RuntimeError( + "The workflow failed at its current parameters — fix that before " + "optimizing (check the printed node errors)." + ) + + dimensions, skipped_dims = collect_dimensions(workflow) + objectives, skipped_objs = collect_objectives(workflow, measurables) + + if baseline: + baseline["params"] = {d.address: _read_param(workflow, d.address) + for d in dimensions} + baseline["measured"] = {o.name: measurables.get(o.measures) + for o in objectives} + + return OptimizationSpec( + dimensions=dimensions, + objectives=objectives, + algorithm=algorithm or AlgorithmConfig(), + baseline=baseline, + skipped=skipped_dims + skipped_objs, + ) + + +def _read_param(workflow, address: str) -> Any: + from .addressing import split_address + node_name, param, keys = split_address(address) + value = workflow.nodes[node_name]._parameters[param] + for k in keys: + value = value[k] + return value diff --git a/gui/workflow_backend/django-project/codes/nodes/analysis/NW_Analysis.py b/gui/workflow_backend/django-project/codes/nodes/analysis/NW_Analysis.py index d3bffb15..0b29fb3f 100644 --- a/gui/workflow_backend/django-project/codes/nodes/analysis/NW_Analysis.py +++ b/gui/workflow_backend/django-project/codes/nodes/analysis/NW_Analysis.py @@ -102,6 +102,18 @@ class NW_Analysis(Node): "omitted. Empty dict if the spikes file cannot be read." ), ), + + "isi_stats": PortDefinition( + type=PortType.DICT, + description=( + "Inter-spike interval distribution per population, keyed by population " + "name: {'mean_ms', 'std_ms', 'cv', 'n_intervals'}. Intervals are taken " + "per neuron and then pooled - never across neurons, which would be " + "meaningless. 'cv' is std/mean, the classic irregularity measure: near 0 " + "is clock-like firing, near 1 is Poisson-like. A population that never " + "spiked appears with zeros rather than being omitted." + ), + ), }, methods={ "analyze": MethodDefinition( @@ -110,7 +122,7 @@ class NW_Analysis(Node): "produce spike raster and/or membrane potential trace plots." ), inputs=["results"], - outputs=["figures", "firing_rate_hz"], + outputs=["figures", "firing_rate_hz", "isi_stats"], ), }, ) @@ -142,6 +154,89 @@ def _detect_populations(self, output_dir: str, report_name: str) -> list: return [] + def _population_sizes(self) -> Dict[str, int]: + """Neurons per population, from the SONATA node files the network was built from. + + Used as the denominator for firing rate, and to decide whether a spike train + can be split per neuron when the spikes file carries no node_ids. + """ + import glob + import os + + import h5py + + network_dir = os.path.join(self._context.get("results_path", "results"), "network") + sizes: Dict[str, int] = {} + for nodes_file in sorted(glob.glob(os.path.join(network_dir, "*_nodes.h5"))): + with h5py.File(nodes_file, "r") as f: + for pop, group in f.get("nodes", {}).items(): + if "node_id" in group: + sizes[pop] = len(group["node_id"]) + return sizes + + def _measure_isi_stats(self, output_dir: str) -> Dict[str, Dict[str, float]]: + """Summarise each population's inter-spike interval distribution. + + Intervals are computed per neuron and then pooled, so a population of one and a + population of many are described the same way. Pooling the raw timestamps + instead would produce intervals *between different neurons*, which mean nothing. + """ + try: + import os + + import h5py + import numpy as np + + spikes_path = os.path.join(output_dir, "spikes.h5") + if not os.path.exists(spikes_path): + return {} + + sizes = self._population_sizes() + empty = {"mean_ms": 0.0, "std_ms": 0.0, "cv": 0.0, "n_intervals": 0} + stats: Dict[str, Dict[str, float]] = {pop: dict(empty) for pop in sizes} + + with h5py.File(spikes_path, "r") as f: + for pop, group in f.get("spikes", {}).items(): + if "timestamps" not in group: + continue + times = np.asarray(group["timestamps"], dtype=float) + ids = (np.asarray(group["node_ids"]) + if "node_ids" in group else None) + + per_neuron = [] + if ids is not None and len(ids) == len(times): + for neuron in np.unique(ids): + train = np.sort(times[ids == neuron]) + if train.size > 1: + per_neuron.append(np.diff(train)) + elif sizes.get(pop, 0) == 1: + # One neuron: every timestamp is its own, so no grouping needed. + train = np.sort(times) + if train.size > 1: + per_neuron.append(np.diff(train)) + else: + print(f"[NW_Analysis] isi stats skipped for {pop!r}: " + f"spikes.h5 has no node_ids to separate neurons") + continue + + pooled = np.concatenate(per_neuron) if per_neuron else np.array([]) + if pooled.size == 0: + continue + mean = float(pooled.mean()) + std = float(pooled.std()) + stats[pop] = { + "mean_ms": mean, + "std_ms": std, + "cv": std / mean if mean > 0 else 0.0, + "n_intervals": int(pooled.size), + } + + return stats + + except Exception as e: + print(f"[NW_Analysis] isi statistics skipped: {e}") + return {} + def _measure_firing_rates(self, config_file: str, output_dir: str) -> Dict[str, float]: """Mean firing rate per population, in Hz, read from the SONATA output. @@ -170,14 +265,9 @@ def _measure_firing_rates(self, config_file: str, output_dir: str) -> Dict[str, # Same run root NW_SimConfig used to build the network, and the value # a re-run updates when it points the workflow at a new results dir. - base_dir = self._context.get("results_path", "results") - network_dir = os.path.join(base_dir, "network") - sizes: Dict[str, int] = {} - for nodes_file in sorted(glob.glob(os.path.join(network_dir, "*_nodes.h5"))): - with h5py.File(nodes_file, "r") as f: - for pop, group in f.get("nodes", {}).items(): - if "node_id" in group: - sizes[pop] = len(group["node_id"]) + network_dir = os.path.join( + self._context.get("results_path", "results"), "network") + sizes = self._population_sizes() spikes_path = os.path.join(output_dir, "spikes.h5") if not sizes: @@ -214,6 +304,7 @@ def analyze(self, results: Dict) -> Dict[str, Any]: # Measured before plotting, so it does not depend on the plotting flags. firing_rate_hz = self._measure_firing_rates(config_file, output_dir) + isi_stats = self._measure_isi_stats(output_dir) populations = list(p["populations"]) or self._detect_populations(output_dir, str(p["report_name"])) node_ids = list(p["trace_node_ids"]) or None @@ -262,4 +353,5 @@ def analyze(self, results: Dict) -> Dict[str, Any]: except Exception as e: print(f"[NW_Analysis] plot_traces skipped: {e}") - return {"figures": figures, "firing_rate_hz": firing_rate_hz} + return {"figures": figures, "firing_rate_hz": firing_rate_hz, + "isi_stats": isi_stats} diff --git a/gui/workflow_backend/django-project/codes/nodes/network/NW_Connectivity.py b/gui/workflow_backend/django-project/codes/nodes/network/NW_Connectivity.py index c491b5b5..f5e5dc9b 100644 --- a/gui/workflow_backend/django-project/codes/nodes/network/NW_Connectivity.py +++ b/gui/workflow_backend/django-project/codes/nodes/network/NW_Connectivity.py @@ -203,6 +203,40 @@ def _write_syn_json(self, params_dict: dict, filename: str) -> None: with open(os.path.join(syn_dir, filename), "w") as f: json.dump(float_params, f, indent=2) + @staticmethod + def _coerce_connection_rule(value): + """Return what BMTK's add_edges() expects: an int or a callable. + + connection_rule can arrive as: + - an int (e.g. 1, 3) -> passed through + - a real callable (notebook lambda) -> passed through + - a numeric string ("3") -> int + - a lambda string ("lambda src, tgt: ...") -> eval'd to a callable + + The last case is the GUI path: a lambda cannot be JSON-encoded, and the + code generator only un-quotes a lambda at the TOP LEVEL of configure(), + not one nested inside the `connections` list. So a per-connection rule + reaches here as a string and must be evaluated. numpy is available as + `np` for rules that use np.random / np.exp etc. + """ + if callable(value) or isinstance(value, (int, bool)): + return value + if isinstance(value, str): + s = value.strip() + if s.lstrip("+-").isdigit(): + return int(s) + import numpy as np + fn = eval(s, {"np": np, "__builtins__": __builtins__}) + if not callable(fn): + raise ValueError( + f"connection_rule string did not evaluate to a callable: {value!r}" + ) + return fn + raise ValueError( + f"connection_rule must be an int, a callable, or a lambda string; " + f"got {type(value).__name__}" + ) + def connect(self, populations: List[Dict]) -> Dict[str, Any]: p = self._parameters @@ -253,7 +287,7 @@ def connect(self, populations: List[Dict]) -> Dict[str, Any]: src_builder.add_edges( source = src_builder.nodes(), target = tgt_builder.nodes(), - connection_rule = spec["connection_rule"], + connection_rule = self._coerce_connection_rule(spec["connection_rule"]), model_template = str(spec["model_template"]), dynamics_params = str(spec["dynamics_params"]), delay = float(spec["delay"]), @@ -262,4 +296,16 @@ def connect(self, populations: List[Dict]) -> Dict[str, Any]: allow_multapses = bool(spec["allow_multapses"]), ) + # Structural parameters of this node, carried inside the payload that already + # flows to NW_SimConfig — no new port, so existing workflows are untouched. + # dynamics_params_dict is excluded: it is written to a JSON that edge_types.csv + # references by name, so its values are read at simulation time. + conn_signature = {k: v for k, v in p.items() if k != "dynamics_params_dict"} + conn_signature["connections"] = [ + {k: v for k, v in spec.items() if k != "dynamics_params_dict"} + for spec in p["connections"] + ] + for pop in pop_lookup.values(): + pop.setdefault("_signature", {})["connectivity"] = conn_signature + return {"network": pop_lookup} diff --git a/gui/workflow_backend/django-project/codes/nodes/network/NW_Population.py b/gui/workflow_backend/django-project/codes/nodes/network/NW_Population.py index 7103acda..c5de14c7 100644 --- a/gui/workflow_backend/django-project/codes/nodes/network/NW_Population.py +++ b/gui/workflow_backend/django-project/codes/nodes/network/NW_Population.py @@ -122,6 +122,22 @@ class NW_Population(Node): "Ignored for biophysical models (use dynamics_params_file instead)." ), ), + "mean_firing_rate": ParameterDefinition( + default_value=10.0, + description=( + "Desired mean firing rate of this population, averaged over its " + "neurons and the whole simulation. Declares the target an " + "optimization steers toward; it does not affect the simulation. " + "The measured value it is compared against is named by 'measures'." + ), + unit="Hz", + # Opt-in: a population is a target only when a study says so. + # Defaulting to True made every population declare an objective + # against an address that exists in no particular workflow. + is_objective=False, + objective_range=[8.0, 12.0], + measures="", + ), "dynamics_params_file": ParameterDefinition( default_value="", description=( @@ -177,7 +193,7 @@ class NW_Population(Node): type=PortType.OBJECT, description=( "Dict with: builder (live NetworkBuilder), pop_name (str), " - "network_dir (str), and optionally current_clamp (dict). " + "network_dir (str), and optionally _current_clamp (dict). " "Consumed by NW_Connectivity or NW_SimConfig." ), ), @@ -301,8 +317,17 @@ def build(self, iclamp: Optional[Dict] = None) -> Dict[str, Any]: "builder": net, "pop_name": str(p["pop_name"]), "network_dir": network_dir, + # Parameters that end up inside the SONATA network files. Changing any of + # them invalidates the built network, so NW_SimConfig hashes this to decide + # whether to rebuild. nest_params is excluded: it is written to + # _params.json, which node_types.csv references by name, so its + # values are read at simulation time rather than baked into the h5. + "_signature": {k: v for k, v in p.items() if k not in ("nest_params",)}, } if iclamp: - out["current_clamp"] = iclamp + # Underscored: internal plumbing for NW_SimConfig, not a measurable + # value. Without the prefix it shows up in discover_measurables() as a + # candidate target, echoing back a parameter the user set. + out["_current_clamp"] = iclamp return {"population": out} diff --git a/gui/workflow_backend/django-project/codes/nodes/optimization/JointOptimizationNode.py b/gui/workflow_backend/django-project/codes/nodes/optimization/JointOptimizationNode.py deleted file mode 100644 index b4359d45..00000000 --- a/gui/workflow_backend/django-project/codes/nodes/optimization/JointOptimizationNode.py +++ /dev/null @@ -1,391 +0,0 @@ -""" -Joint optimization node for optimizing parameters from multiple nodes. - -This module provides a node for evaluating simulation results from multiple nodes -and optimizing their parameters jointly. -""" - -from typing import Dict, Any, List, Callable, Optional -import numpy as np -from itertools import product - -from neuroworkflow.core.node import Node -from neuroworkflow.core.schema import NodeDefinitionSchema, PortDefinition, ParameterDefinition, MethodDefinition -from neuroworkflow.core.port import PortType - - -class JointOptimizationNode(Node): - """Node for jointly optimizing parameters from multiple nodes.""" - - NODE_DEFINITION = NodeDefinitionSchema( - type='joint_optimization', - description='Jointly optimizes parameters from multiple nodes', - - parameters={ - 'optimization_method': ParameterDefinition( - default_value='grid', - description='Optimization method (grid, random)', - constraints={'allowed_values': ['grid', 'random']} - ), - 'grid_points': ParameterDefinition( - default_value=4, - description='Number of points per dimension for grid search', - constraints={'min': 2, 'max': 10} - ), - 'max_iterations': ParameterDefinition( - default_value=100, - description='Maximum number of iterations', - constraints={'min': 1} - ) - }, - - inputs={ - 'simulation_results': PortDefinition( - type=PortType.DICT, - description='Simulation results from multiple nodes' - ), - 'parameter_metadata': PortDefinition( - type=PortType.DICT, - description='Optimization metadata for parameters from multiple nodes', - optional=True - ), - 'objective_target': PortDefinition( - type=PortType.FLOAT, - description='Target value for the objective function' - ), - 'iteration': PortDefinition( - type=PortType.INT, - description='Current iteration number', - optional=True - ) - }, - - outputs={ - 'error': PortDefinition( - type=PortType.FLOAT, - description='Calculated error value' - ), - 'evaluation_result': PortDefinition( - type=PortType.DICT, - description='Complete evaluation result' - ), - 'parameters': PortDefinition( - type=PortType.DICT, - description='Parameters for the next iteration (for all nodes)' - ) - }, - - methods={ - 'evaluate': MethodDefinition( - description='Evaluate simulation results', - inputs=['simulation_results', 'objective_target', 'iteration'], - outputs=['error', 'evaluation_result'] - ), - 'suggest_parameters': MethodDefinition( - description='Suggest parameters for next iteration', - inputs=['evaluation_result', 'parameter_metadata'], - outputs=['parameters'] - ) - } - ) - - def __init__(self, name: str): - """Initialize the JointOptimizationNode. - - Args: - name: Name of the node - """ - super().__init__(name) - self._define_process_steps() - self._optimization_history = [] - self._best_error = float('inf') - self._best_params = {} - self._best_simulation = None - self._param_grid = None - self._param_combinations = None - self._current_combination = 0 - self._param_sources = {} # Maps full parameter names to source nodes - self._current_parameters = {} # Tracks current parameters for all nodes - - def _define_process_steps(self) -> None: - """Define the process steps for this node.""" - self.add_process_step( - "evaluate", - self.evaluate, - method_key="evaluate" - ) - - self.add_process_step( - "suggest_parameters", - self.suggest_parameters, - method_key="suggest_parameters" - ) - - def evaluate(self, simulation_results: Dict[str, Any], objective_target: float, - iteration: int = 0) -> Dict[str, Any]: - """Evaluate simulation results using the objective function. - - Args: - simulation_results: Simulation results (without parameters) - objective_target: Target value for the objective function - iteration: Current iteration number - - Returns: - Dictionary with error and evaluation result - """ - # We already know what parameters were used from our internal tracking - all_parameters = self._current_parameters.copy() - - # Extract spike count from simulation results - spike_count = simulation_results.get('spike_count', 0) - if not spike_count and 'spike_times' in simulation_results: - spike_count = len(simulation_results['spike_times']) - - # Calculate error using default objective function (spike count) - print('here: ',objective_target) - objective_target = 10 ##error here - error = abs(spike_count - objective_target) - - # Create evaluation result - evaluation_result = { - 'iteration': iteration, - 'parameters': all_parameters, - 'error': error, - 'spike_count': spike_count, - 'objective_target': objective_target - } - - # Update optimization history - self._optimization_history.append(evaluation_result) - - # Update best result if better - if error < self._best_error: - self._best_error = error - self._best_params = all_parameters.copy() - self._best_simulation = simulation_results - - print(f"New best parameters at iteration {iteration}:") - for name, value in self._best_params.items(): - print(f" {name}: {value}") - print(f" Error: {self._best_error}") - - return { - 'error': error, - 'evaluation_result': evaluation_result - } - - def suggest_parameters(self, evaluation_result: Dict[str, Any], - parameter_metadata: Optional[Dict[str, Any]] = None) -> Dict[str, Any]: - """Suggest parameters for the next iteration. - - Implements grid search and random search optimization strategies for joint optimization - of parameters from multiple nodes. - - Args: - evaluation_result: Current evaluation result - parameter_metadata: Metadata about optimizable parameters from multiple nodes - - Returns: - Dictionary with suggested parameters for next iteration, grouped by node - """ - # Get current iteration and parameters - iteration = evaluation_result.get('iteration', 0) - current_params = evaluation_result.get('parameters', {}) - - # Get optimization method - method = self._parameters['optimization_method'] - - # Initialize next parameters - next_params_flat = {} - - # If we have parameter metadata, use it to determine optimization ranges - if parameter_metadata and not self._param_grid: - # Store which node each parameter comes from - self._param_sources = {} - optimizable_params = {} - - # Collect optimizable parameters and their ranges from all nodes - for node_name, node_metadata in parameter_metadata.items(): - for param_name, param_info in node_metadata.items(): - if param_info.get('optimizable', False): - full_param_name = f"{node_name}.{param_name}" - self._param_sources[full_param_name] = node_name - - # Get current value from evaluation result if available - current_value = None - if node_name in evaluation_result.get('simulation_results', {}): - node_results = evaluation_result['simulation_results'][node_name] - if 'parameters' in node_results and param_name in node_results['parameters']: - current_value = node_results['parameters'][param_name] - - # Use default value if current value not available - if current_value is None and param_name in current_params: - current_value = current_params.get(param_name) - - # Store parameter with its optimization range - if current_value is not None: - optimizable_params[full_param_name] = { - 'current_value': current_value, - 'range': param_info.get('range', []), - 'constraints': param_info.get('constraints', {}) - } - - # Now create the parameter grid based on the method - if method == 'grid': - self._create_grid_search(optimizable_params) - elif method == 'random': - # For random search, we'll just store the parameter ranges - self._param_ranges = optimizable_params - - # Generate next parameters based on the method - if method == 'grid': - next_params_flat = self._get_next_grid_parameters() - elif method == 'random': - next_params_flat = self._get_random_parameters() - - # Group parameters by their source node - next_params_by_node = self._group_parameters_by_node(next_params_flat) - - # Store the current parameters for tracking - self._current_parameters = next_params_flat.copy() - - return { - 'parameters': next_params_by_node - } - - def _create_grid_search(self, optimizable_params: Dict[str, Dict[str, Any]]) -> None: - """Create a grid search for the given optimizable parameters. - - Args: - optimizable_params: Dictionary of optimizable parameters with their metadata - """ - self._param_grid = {} - grid_points = self._parameters['grid_points'] - - for param_name, param_info in optimizable_params.items(): - current_value = param_info['current_value'] - - # Use defined optimization range if available - if param_info['range'] and len(param_info['range']) == 2: - min_val, max_val = param_info['range'] - else: - # Fallback to scaling current value - min_val = current_value * 0.8 - max_val = current_value * 1.2 - - # Create linspace for this parameter - self._param_grid[param_name] = np.linspace(min_val, max_val, grid_points) - - # Generate all parameter combinations - param_names = list(self._param_grid.keys()) - param_values = [self._param_grid[name] for name in param_names] - self._param_combinations = list(product(*param_values)) - self._current_combination = 0 - - print(f"Grid search: {len(self._param_combinations)} parameter combinations") - - def _get_next_grid_parameters(self) -> Dict[str, Any]: - """Get the next parameter combination from the grid search. - - Returns: - Dictionary with parameter names and values - """ - if not self._param_grid or not self._param_combinations: - return {} - - # If we've tried all combinations, return the best parameters - if self._current_combination >= len(self._param_combinations): - print("Grid search complete - using best parameters") - return self._best_params.copy() - - # Get the next combination - combination = self._param_combinations[self._current_combination] - param_names = list(self._param_grid.keys()) - next_params = {name: value for name, value in zip(param_names, combination)} - - self._current_combination += 1 - return next_params - - def _get_random_parameters(self) -> Dict[str, Any]: - """Generate random parameters within the optimization ranges. - - Returns: - Dictionary with parameter names and values - """ - if not hasattr(self, '_param_ranges') or not self._param_ranges: - return {} - - next_params = {} - - for param_name, param_info in self._param_ranges.items(): - current_value = param_info['current_value'] - - # Use defined optimization range if available - if param_info['range'] and len(param_info['range']) == 2: - min_val, max_val = param_info['range'] - else: - # Fallback to scaling current value - min_val = current_value * 0.8 - max_val = current_value * 1.2 - - # Generate random value within range - next_params[param_name] = np.random.uniform(min_val, max_val) - - return next_params - - def _group_parameters_by_node(self, flat_params: Dict[str, Any]) -> Dict[str, Dict[str, Any]]: - """Group parameters by their source node. - - Args: - flat_params: Dictionary with full parameter names (node.param) and values - - Returns: - Dictionary with parameters grouped by node - """ - params_by_node = {} - - for full_param_name, value in flat_params.items(): - # Split the parameter name to get node and parameter - if '.' in full_param_name: - node_name, param_name = full_param_name.split('.', 1) - elif full_param_name in self._param_sources: - # Use stored mapping if available - node_name = self._param_sources[full_param_name] - param_name = full_param_name.split('.', 1)[1] if '.' in full_param_name else full_param_name - else: - # Skip parameters we can't map to a node - continue - - # Initialize node dictionary if needed - if node_name not in params_by_node: - params_by_node[node_name] = {} - - # Add parameter to the node - params_by_node[node_name][param_name] = value - - return params_by_node - - def get_optimization_results(self) -> Dict[str, Any]: - """Get the current optimization results. - - Returns: - Dictionary with optimization results - """ - return { - 'best_parameters': self._best_params, - 'best_error': self._best_error, - 'best_simulation': self._best_simulation, - 'history': self._optimization_history - } - - def reset_optimization(self) -> None: - """Reset the optimization state.""" - self._optimization_history = [] - self._best_error = float('inf') - self._best_params = {} - self._best_simulation = None - self._param_grid = None - self._param_combinations = None - self._current_combination = 0 - self._param_sources = {} - self._current_parameters = {} \ No newline at end of file diff --git a/gui/workflow_backend/django-project/codes/nodes/optimization/NW_Optimization.py b/gui/workflow_backend/django-project/codes/nodes/optimization/NW_Optimization.py new file mode 100644 index 00000000..39ba4ac4 --- /dev/null +++ b/gui/workflow_backend/django-project/codes/nodes/optimization/NW_Optimization.py @@ -0,0 +1,126 @@ +from typing import Any, Dict + +from neuroworkflow.core.node import Node +from neuroworkflow.core.schema import ( + NodeDefinitionSchema, ParameterDefinition, +) + + +class NW_Optimization(Node): + """Declares how to search a workflow's parameter space. + + This node holds *how* to search — algorithm and budget. It deliberately does not + hold *what* to search or *what to hit*: those live on the parameters themselves, + as ``optimizable`` / ``optimization_range`` and ``is_objective`` / + ``objective_range`` / ``measures``. Duplicating them here would create two + sources of truth that can disagree. + + It is also not a step in the workflow. A workflow is a DAG that runs once; a + search is a loop that runs it many times, so the loop cannot be a node inside + the graph. Placing this node marks a workflow as one to optimize, and the code + generator emits an optimization run instead of a single execution. It has no + ports and no process steps, so adding it to a workflow changes nothing about + how that workflow executes. + + Typical use, once the workflow is built:: + + opt = NW_Optimization("opt") + opt.configure(algorithm="cmaes", pop_size=16, max_generations=12) + + spec = build_spec(workflow, opt.algorithm_config()) + result = optimize(workflow, spec=spec, results_path=opt.results_path()) + """ + + NODE_DEFINITION = NodeDefinitionSchema( + type="nw_optimization", + stage="optimization", + tool="custom", + model_source="https://github.com/oist/neuro-workflow", + description=( + "Declares how to search a workflow's parameter space: which algorithm and " + "how large a budget. What to explore and what to hit are declared on the " + "parameters themselves, not here. Its presence marks the workflow as one " + "to optimize; it takes no part in the workflow's own execution." + ), + parameters={ + "algorithm": ParameterDefinition( + default_value="cmaes", + description=( + "Search algorithm. 'cmaes' is the default for a single objective and " + "continuous parameters; 'tpe' when each trial is expensive; 'nsga2' or " + "'nsga3' for several objectives, returning a Pareto front; 'random' as " + "a dependency-free baseline. Everything except 'random' needs Optuna " + "(pip install optuna cmaes)." + ), + constraints={"allowed_values": ["random", "cmaes", "tpe", + "nsga2", "nsga3", "optuna_random"]}, + ), + "pop_size": ParameterDefinition( + default_value=16, + description=( + "Candidates proposed per generation, i.e. workflow runs before the " + "algorithm learns from them and proposes the next batch." + ), + constraints={"min": 1}, + ), + "max_generations": ParameterDefinition( + default_value=20, + description=( + "Generation budget. At most pop_size x max_generations runs, plus one " + "baseline; the search stops earlier once a candidate lands inside every " + "target band." + ), + constraints={"min": 1}, + ), + "seed": ParameterDefinition( + default_value=None, + description=( + "Random seed, making a run reproducible. Leave empty for an unseeded run." + ), + ), + "options": ParameterDefinition( + default_value={}, + description=( + "Extra keyword arguments passed straight to the underlying sampler, e.g. " + "{\"sigma0\": 0.2} for CMA-ES or {\"n_startup_trials\": 20} for TPE. " + "Names are the sampler's own." + ), + ), + "results_path": ParameterDefinition( + default_value="results/optimization", + description=( + "Directory the run is written under. Each run creates its own " + "subdirectory holding the manifest, the per-trial log, live status and " + "the per-trial results." + ), + ), + }, + inputs={}, + outputs={}, + methods={}, + ) + + def __init__(self, name: str): + super().__init__(name) + + def algorithm_config(self): + """This node's settings as an ``AlgorithmConfig`` for ``build_spec()``.""" + from neuroworkflow.optimization import AlgorithmConfig + + p = self._parameters + seed = p["seed"] + return AlgorithmConfig( + name=str(p["algorithm"]), + pop_size=int(p["pop_size"]), + max_generations=int(p["max_generations"]), + seed=None if seed in (None, "") else int(seed), + options=dict(p["options"] or {}), + ) + + def results_path(self) -> str: + """Where the run's ledger and per-trial results are written.""" + return str(self._parameters["results_path"]) + + def summary(self) -> Dict[str, Any]: + """The declared settings, for printing or logging.""" + return dict(self._parameters) diff --git a/gui/workflow_backend/django-project/codes/nodes/optimization/__init__.py b/gui/workflow_backend/django-project/codes/nodes/optimization/__init__.py index 91ca5162..a3b25058 100644 --- a/gui/workflow_backend/django-project/codes/nodes/optimization/__init__.py +++ b/gui/workflow_backend/django-project/codes/nodes/optimization/__init__.py @@ -1,9 +1,12 @@ """ Optimization nodes for NeuroWorkflow. -This package contains nodes for parameter optimization in neural simulations. +Optimization itself is not a step inside a workflow: a workflow is a DAG that runs +once, while a search is a loop that runs it repeatedly. The loop therefore lives +outside the graph, in ``neuroworkflow.optimization``. -Import nodes directly from their modules: - from neuroworkflow.nodes.optimization.JointOptimizationNode import JointOptimizationNode -""" +What belongs here is the *specification* of a search — which algorithm, how large a +budget — carried as an ordinary node so it can be placed and edited like any other: + from neuroworkflow.nodes.optimization.NW_Optimization import NW_Optimization +""" diff --git a/gui/workflow_backend/django-project/codes/nodes/simulation/NW_SimConfig.py b/gui/workflow_backend/django-project/codes/nodes/simulation/NW_SimConfig.py index a2e7983c..ad6c892e 100644 --- a/gui/workflow_backend/django-project/codes/nodes/simulation/NW_SimConfig.py +++ b/gui/workflow_backend/django-project/codes/nodes/simulation/NW_SimConfig.py @@ -31,6 +31,13 @@ class NW_SimConfig(Node): ports, or collect them in a list via a fan-in node. """ + #: Artifacts under results_path that a later run can reuse when nothing + #: structural changed — read by the optimization engine, which copies them into + #: each trial so this node's signature check can skip rebuilding. The SONATA + #: network is expensive to build (connection rules are evaluated here) and + #: identical whenever only simulation-time values move. + REUSABLE_PATHS = ("network",) + NODE_DEFINITION = NodeDefinitionSchema( type="nw_sim_config", stage="simulation", @@ -92,13 +99,25 @@ class NW_SimConfig(Node): default_value=True, description="Overwrite existing config files and network files.", ), + "rebuild_network": ParameterDefinition( + default_value="auto", + description=( + "When to regenerate the SONATA network files. 'auto' rebuilds only when " + "a structural parameter changed (population size, neuron model, " + "connectivity, synaptic weights) or the files are missing — values that " + "are read at simulation time (nest_params, synapse dynamics_params_dict) " + "never trigger a rebuild. 'always' rebuilds every run. 'never' reuses " + "whatever is on disk." + ), + constraints={"allowed_values": ["auto", "always", "never"]}, + ), }, inputs={ "populations": PortDefinition( type=PortType.OBJECT, description=( "Single population from NW_Population, or network dict from NW_Connectivity. " - "Single pop keys: builder, pop_name, network_dir, optional current_clamp. " + "Single pop keys: builder, pop_name, network_dir, optional _current_clamp. " "Network dict (multi-pop): keyed by pop_name, each value has the same keys." ), ), @@ -137,6 +156,76 @@ def _define_process_steps(self) -> None: self.add_process_step("setup", self.setup, method_key="setup") self.add_process_step("run", self.run, method_key="run") + @staticmethod + def _stable(value): + """A representation that is identical run to run for unchanged inputs. + + connection_rule may be a callable. repr() of a function embeds its memory + address, which differs on every run, so the signature would never match and + the network would be rebuilt every time. Use the source text instead, plus any + closure values (which the source does not show — changing `eps` in + `lambda s, t: 1 if rand() < eps else 0` leaves the text identical), and fall + back to the bytecode when source is unavailable. + """ + if callable(value): + import inspect + try: + text = inspect.getsource(value).strip() + except (OSError, TypeError): + text = value.__code__.co_code.hex() + repr(value.__code__.co_consts) + # Values the rule reads but does not show in its source. A lambda written + # in a notebook usually reads them as globals (`eps`), not as closure + # cells, so both are captured — otherwise changing eps would leave the + # signature identical and silently reuse a network built with the old value. + referenced = [] + for cell in (value.__closure__ or []): + try: + referenced.append(repr(cell.cell_contents)) + except ValueError: + referenced.append("") + simple = (int, float, str, bool, type(None)) + for name in sorted(value.__code__.co_names): + if name in value.__globals__: + referenced_value = value.__globals__[name] + if isinstance(referenced_value, simple): + referenced.append(f"{name}={referenced_value!r}") + return f"callable:{text}:{referenced}" + if isinstance(value, dict): + return {k: NW_SimConfig._stable(v) for k, v in sorted(value.items())} + if isinstance(value, (list, tuple)): + return [NW_SimConfig._stable(v) for v in value] + return value + + def _network_signature(self, pop_list): + """Hash of everything that ends up inside the SONATA network files.""" + import hashlib + import json + + parts = {pop["pop_name"]: self._stable(pop.get("_signature", {})) + for pop in pop_list} + blob = json.dumps(parts, sort_keys=True, default=repr) + return hashlib.sha256(blob.encode()).hexdigest(), parts + + def _network_is_current(self, network_dir, pop_list, digest): + """True when the network on disk was built from these same parameters.""" + import json + import os + + path = os.path.join(network_dir, ".signature.json") + if not os.path.exists(path): + return False + try: + with open(path) as fh: + stored = json.load(fh) + except (ValueError, OSError): + return False + if stored.get("hash") != digest: + return False + return all( + os.path.exists(os.path.join(network_dir, f"{pop['pop_name']}_nodes.h5")) + for pop in pop_list + ) + def setup(self, populations: Dict) -> Dict[str, Any]: import json import os @@ -165,9 +254,25 @@ def setup(self, populations: Dict) -> Dict[str, Any]: ]: os.makedirs(os.path.join(base_dir, subdir), exist_ok=True) - for pop in pop_list: - pop["builder"].build() - pop["builder"].save(output_dir=network_dir) + mode = str(p["rebuild_network"]).lower() + digest, parts = self._network_signature(pop_list) + current = self._network_is_current(network_dir, pop_list, digest) + + if mode == "never": + if current: + print(f"[NW_SimConfig] network unchanged, reusing {network_dir}") + else: + print("[NW_SimConfig] rebuild_network='never': the network on disk does " + f"not match the current parameters, reusing it anyway: {network_dir}") + elif mode == "always" or not current: + for pop in pop_list: + pop["builder"].build() + pop["builder"].save(output_dir=network_dir) + with open(os.path.join(network_dir, ".signature.json"), "w") as fh: + json.dump({"hash": digest, "parameters": parts}, fh, indent=2, default=repr) + print(f"[NW_SimConfig] network built in {network_dir}") + else: + print(f"[NW_SimConfig] network unchanged, reusing {network_dir}") kwargs: Dict[str, Any] = dict( base_dir=base_dir, @@ -181,8 +286,8 @@ def setup(self, populations: Dict) -> Dict[str, Any]: # current_clamp lives in the primary pop (single-pop case only) primary = pop_list[0] - if primary.get("current_clamp"): - kwargs["current_clamp"] = primary["current_clamp"] + if primary.get("_current_clamp"): + kwargs["current_clamp"] = primary["_current_clamp"] create_environment(str(p["simulator"]), **kwargs) diff --git a/notebooks/NW_Clamp_Weight_Optimization.ipynb b/notebooks/NW_Clamp_Weight_Optimization.ipynb new file mode 100644 index 00000000..3c3ab8e7 --- /dev/null +++ b/notebooks/NW_Clamp_Weight_Optimization.ipynb @@ -0,0 +1,15048 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8a8a1877", + "metadata": {}, + "source": [ + "# Optimizing drive and synaptic weight to hit a target firing rate\n", + "\n", + "One recurrently connected population, driven by a current clamp. Two knobs, deliberately of\n", + "different kinds:\n", + "\n", + "| dimension | where it ends up | rebuild? |\n", + "|---|---|---|\n", + "| `clamp.amp_na` | the simulation config JSON | no |\n", + "| `conn.syn_weight` | `edge_types.csv`, inside the network files | **yes** |\n", + "\n", + "Target: mean firing rate of the population inside a band.\n", + "\n", + "The two interact — external drive and recurrent excitation both push the rate up — so there is a\n", + "whole family of solutions rather than one point. That is exactly the situation CMA-ES handles well\n", + "and independent sampling handles badly.\n", + "\n", + "Because `syn_weight` is structural, **every trial rebuilds the network**. Correct, and the cost of\n", + "tuning something baked into the SONATA files. The run reports how many rebuilds happened." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "200dec5d", + "metadata": {}, + "outputs": [], + "source": [ + "import contextlib\n", + "import io\n", + "import os\n", + "import sys\n", + "\n", + "# Prefer this repository's sources over any previously installed copy:\n", + "# neuroworkflow.optimization is new and an older install would not have it.\n", + "sys.path.insert(0, os.path.abspath('../src'))\n", + "\n", + "from neuroworkflow import WorkflowBuilder\n", + "from neuroworkflow.nodes.network.NW_Population import NW_Population\n", + "from neuroworkflow.nodes.network.NW_Connectivity import NW_Connectivity\n", + "from neuroworkflow.nodes.simulation.NW_SimConfig import NW_SimConfig\n", + "from neuroworkflow.nodes.analysis.NW_Analysis import NW_Analysis\n", + "from neuroworkflow.nodes.stimulus.NW_IClamp import NW_IClamp\n", + "\n", + "from neuroworkflow.optimization import AlgorithmConfig, build_spec, optimize" + ] + }, + { + "cell_type": "markdown", + "id": "2ea9b5d8", + "metadata": {}, + "source": [ + "## 1. Nodes" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "32a1bcdd", + "metadata": {}, + "outputs": [], + "source": [ + "clamp = NW_IClamp(\"clamp\")\n", + "exc = NW_Population(\"exc\")\n", + "conn = NW_Connectivity(\"conn\")\n", + "sim = NW_SimConfig(\"sim\")\n", + "ana = NW_Analysis(\"ana\")" + ] + }, + { + "cell_type": "markdown", + "id": "3dc0cd52", + "metadata": {}, + "source": [ + "## 2. Configure\n", + "\n", + "`I_e = 0`, so the current clamp is the only external drive — otherwise a constant bias current\n", + "would do the work and `amp_na` would barely matter. The clamp covers 450 ms of the 500 ms run, so\n", + "the measured rate reflects the driven state rather than being diluted by silent time.\n", + "\n", + "The single recurrent projection carries no `syn_weight` of its own, so it inherits the node-level\n", + "default — the value the optimizer tunes." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "85d26bbf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "exc.configure(\n", + " pop_name=\"exc\", N=20,\n", + " model_type=\"point_neuron\", model_template=\"nest:iaf_psc_alpha\",\n", + " ei_type=\"exc\", location=\"VISp\", layer=\"L4\",\n", + " nest_params={\"C_m\": 250.0, \"tau_m\": 10.0, \"t_ref\": 2.0,\n", + " \"V_th\": -55.0, \"V_reset\": -70.0, \"E_L\": -70.0, \"I_e\": 0.0},\n", + ")\n", + "\n", + "clamp.configure(amp_na=200.0, delay_ms=50.0, duration_ms=450.0)\n", + "\n", + "conn.configure(\n", + " connection_rule = 1, # deterministic: one synapse per pair\n", + " syn_weight = 5.0, # node default -> tuned\n", + " connections = [{\"source\": \"exc\", \"target\": \"exc\"}],\n", + ")\n", + "\n", + "sim.configure(simulator=\"pointnet\", config_file=\"config_clamp_weight.json\",\n", + " tstop_ms=500.0, dt_ms=0.1)\n", + "ana.configure(plot_raster=False, plot_traces=False)" + ] + }, + { + "cell_type": "markdown", + "id": "a3579a5e", + "metadata": {}, + "source": [ + "## 3. Build" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7b7bd701", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "nodes: ['clamp', 'exc', 'conn', 'sim', 'ana']\n" + ] + } + ], + "source": [ + "wf = WorkflowBuilder(\"NW_Clamp_Weight_Optimization\")\n", + "for node in [clamp, exc, conn, sim, ana]:\n", + " wf.add_node(node)\n", + "\n", + "wf.connect(\"clamp\", \"iclamp\", \"exc\", \"iclamp\")\n", + "wf.connect(\"exc\", \"population\", \"conn\", \"populations\")\n", + "wf.connect(\"conn\", \"network\", \"sim\", \"populations\")\n", + "wf.connect(\"sim\", \"results\", \"ana\", \"results\")\n", + "\n", + "wf.context[\"results_path\"] = \"./results/clamp_weight\"\n", + "workflow = wf.build()\n", + "print(\"nodes:\", list(workflow.nodes))" + ] + }, + { + "cell_type": "markdown", + "id": "64e0cd95", + "metadata": {}, + "source": [ + "## 4. Declare what to optimize\n", + "\n", + "Both dimensions are plain scalars, so both ranges are `[min, max]`. The target reads the measured\n", + "rate of this population from the analysis node." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1c5a6540", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "target measures: ana.firing_rate_hz.exc\n" + ] + } + ], + "source": [ + "explore_clamp_amp_na = clamp.NODE_DEFINITION.parameters[\"amp_na\"]\n", + "explore_clamp_amp_na.optimizable = True\n", + "explore_clamp_amp_na.optimization_range = [100.0, 1000.0]\n", + "explore_clamp_amp_na.unit = \"nA\"\n", + "\n", + "explore_conn_syn_weight = conn.NODE_DEFINITION.parameters[\"syn_weight\"]\n", + "explore_conn_syn_weight.optimizable = True\n", + "explore_conn_syn_weight.optimization_range = [1.0, 100.0]\n", + "explore_conn_syn_weight.unit = \"pA\"\n", + "\n", + "target_exc_mean_firing_rate = exc.NODE_DEFINITION.parameters[\"mean_firing_rate\"]\n", + "target_exc_mean_firing_rate.default_value = 10.0\n", + "target_exc_mean_firing_rate.unit = \"Hz\"\n", + "target_exc_mean_firing_rate.is_objective = True\n", + "target_exc_mean_firing_rate.objective_range = [40.0, 50.0]\n", + "target_exc_mean_firing_rate.measures = (\n", + " f\"{ana.name}.firing_rate_hz.{exc._parameters['pop_name']}\"\n", + ")\n", + "\n", + "print(\"target measures:\", target_exc_mean_firing_rate.measures)" + ] + }, + { + "cell_type": "markdown", + "id": "cd477f10", + "metadata": {}, + "source": [ + "## 5. Spec" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "02d02844", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in ./results/clamp_weight/network\n", + "\n", + " -- N E S T --\n", + " Copyright (C) 2004 The NEST Initiative\n", + "\n", + " Version: 3.7.0\n", + " Built: Mar 4 2025 17:27:39\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", + "2026-09-07 00:17:42,592 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:42,600 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:42,605 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:42,606 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:42,608 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:42,610 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:42,620 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:42,662 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:42,681 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + "baseline measurables:\n", + " ana.firing_rate_hz.exc 0\n", + " ana.isi_stats.exc.cv 0\n", + " ana.isi_stats.exc.mean_ms 0\n", + " ana.isi_stats.exc.n_intervals 0\n", + " ana.isi_stats.exc.std_ms 0\n", + " clamp.iclamp.amp 200\n", + " clamp.iclamp.delay 50\n", + " clamp.iclamp.duration 450\n", + "\n", + "algorithm : cmaes (pop_size=16, max_generations=12)\n", + "dimensions: 2\n", + " clamp.amp_na [100.0, 1000.0] nA\n", + " conn.syn_weight [1.0, 100.0] pA\n", + "objectives: 1\n", + " exc.mean_firing_rate in [40.0, 50.0] Hz <- ana.firing_rate_hz.exc\n" + ] + } + ], + "source": [ + "spec = build_spec(\n", + " workflow,\n", + " algorithm=AlgorithmConfig(name=\"cmaes\", pop_size=16, max_generations=12, seed=1),\n", + ")\n", + "\n", + "print(\"baseline measurables:\")\n", + "for address, value in sorted(spec.baseline[\"measurables\"].items()):\n", + " print(f\" {address:<40} {value:g}\")\n", + "print()\n", + "print(spec.summary())" + ] + }, + { + "cell_type": "markdown", + "id": "162ba286", + "metadata": {}, + "source": [ + "## 6. Run\n", + "\n", + "Per-trial NEST and BMTK logs are captured so they do not bury the result; the engine's narration is\n", + "printed afterwards, with a count of rebuilds." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "335f50e7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,169 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,173 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,177 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,178 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,179 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,182 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,189 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,233 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,260 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,277 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,282 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,285 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,286 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,288 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,290 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,299 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,342 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,362 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,383 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,387 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,391 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,392 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,393 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,396 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,404 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,448 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,468 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,488 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,492 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,496 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,497 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,498 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,500 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,508 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,550 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,569 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,590 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,593 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,597 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,598 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,601 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,603 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,611 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,654 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,679 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,699 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,737 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,742 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,743 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,744 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,747 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,756 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,799 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,826 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,848 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,851 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,855 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,856 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,857 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,859 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,866 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,909 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,928 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,949 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,952 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,957 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,958 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,959 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,961 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:43,969 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,012 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,033 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,052 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,056 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,059 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,060 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,062 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,064 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,072 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,116 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,141 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,161 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,165 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,169 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,170 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,172 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,174 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,181 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,224 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,243 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,261 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,265 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,269 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,270 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,271 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,273 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,281 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,324 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,352 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,375 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,379 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,385 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,386 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,388 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,390 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,398 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,442 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,468 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,489 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,493 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,497 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,498 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,499 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,501 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,509 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,553 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,580 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,599 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,604 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,608 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,609 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,610 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,612 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,620 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,664 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,683 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,703 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,707 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,710 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,711 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,713 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,715 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,723 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,765 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,786 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,806 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,810 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,814 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,815 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,816 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,818 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,825 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,868 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,888 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,918 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,923 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,927 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,928 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,930 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,932 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,940 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:44,984 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,010 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,030 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,035 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,040 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,041 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,042 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,044 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,052 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,096 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,122 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,143 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,147 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,151 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,152 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,153 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,156 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,164 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,207 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,234 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,256 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,260 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,264 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,265 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,266 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,268 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,276 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,320 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,347 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,367 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,371 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,375 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,376 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,378 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,380 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,387 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,431 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,458 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,478 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,482 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,486 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,487 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,489 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,491 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,498 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,542 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,568 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,588 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,593 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,597 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,598 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,599 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,601 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,610 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,653 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,678 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,699 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,703 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,709 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,710 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,712 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,714 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,722 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,769 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,792 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,811 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,815 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,819 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,820 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,822 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,824 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,832 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,876 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,900 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,920 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,924 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,927 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,928 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,930 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,932 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,940 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:45,984 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,010 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,032 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,036 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,040 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,041 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,043 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,045 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,052 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,096 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,124 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,146 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,150 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,154 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,156 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,157 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,159 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,167 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,211 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,238 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,259 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,263 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,267 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,268 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,269 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,271 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,280 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,323 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,350 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,370 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,374 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,378 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,380 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,381 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,383 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,391 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,435 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,463 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,482 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,486 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,491 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,492 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,493 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,495 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,503 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,547 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,573 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,595 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,599 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,603 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,604 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,606 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,608 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,617 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,660 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,686 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,716 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,720 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,725 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,726 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,727 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,729 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,739 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,783 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,807 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,828 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,832 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,836 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,837 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,839 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,841 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,849 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,892 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,917 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,937 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,941 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,945 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,946 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,948 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,950 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:46,957 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,001 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,027 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,047 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,051 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,055 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,056 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,057 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,059 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,067 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,111 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,137 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,158 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,164 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,167 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,168 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,170 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,172 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,180 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,224 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,251 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,272 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,276 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,280 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,281 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,283 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,284 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,292 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,335 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,359 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,380 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,384 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,388 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,390 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,391 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,393 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,401 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,444 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,469 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,486 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,490 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,494 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,495 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,497 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,499 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,507 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,551 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,577 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,599 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,603 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,607 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,609 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,610 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,612 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,620 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,664 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,685 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,706 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,710 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,714 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,715 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,717 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,719 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,727 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,771 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,796 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,815 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,819 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,824 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,825 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,827 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,829 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,837 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,880 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,900 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,922 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,926 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,930 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,932 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,933 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,938 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,946 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:47,991 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,016 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,037 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,041 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,045 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,047 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,048 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,050 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,058 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,102 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,125 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,144 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,149 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,153 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,154 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,156 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,158 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,166 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,209 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,233 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,255 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,258 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,262 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,264 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,265 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,268 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,275 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,320 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,348 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,372 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,376 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,381 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,382 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,383 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,385 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,393 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,438 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,463 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,494 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,500 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,504 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,506 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,508 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,510 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,518 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,562 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,588 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,608 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,613 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,618 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,619 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,621 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,624 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,633 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,676 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,701 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,724 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,728 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,733 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,735 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,736 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,739 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,748 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,792 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,814 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,836 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,843 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,849 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,851 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,852 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,855 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,863 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,908 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,935 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,955 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,959 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,963 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,964 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,966 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,968 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:48,978 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,023 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,049 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,071 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,075 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,079 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,081 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,083 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,085 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,093 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,137 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,162 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,182 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,187 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,191 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,192 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,194 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,196 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,205 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,249 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,275 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,296 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,300 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,304 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,306 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,308 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,310 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,318 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,363 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,388 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,411 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,416 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,420 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,422 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,423 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,425 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,434 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,477 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,502 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,524 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,528 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,533 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,534 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,536 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,538 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,547 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,591 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,612 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,634 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,639 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,647 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,648 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,650 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,652 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,662 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,707 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,733 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,754 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,759 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,763 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,765 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,766 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,768 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,777 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,821 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,850 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,873 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,877 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,881 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,882 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,884 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,886 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,894 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,939 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,962 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,986 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,991 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,995 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,996 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:49,998 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,000 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,008 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,052 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,073 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,094 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,099 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,102 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,104 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,106 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,108 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,116 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,161 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,186 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,207 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,211 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,216 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,217 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,219 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,221 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,229 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,273 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,300 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,331 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,336 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,340 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,342 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,343 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,345 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,354 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,407 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,429 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,451 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,456 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,460 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,462 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,464 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,467 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,476 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,519 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,542 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,563 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,567 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,572 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,573 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,575 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,577 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,585 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,630 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,658 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,680 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,684 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,689 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,691 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,692 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,695 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,705 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,748 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,770 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,792 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,796 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,801 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,802 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,804 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,806 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,814 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,858 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,885 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,907 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,911 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,916 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,917 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,919 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,921 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,930 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,974 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:50,999 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,021 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,026 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,030 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,032 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,033 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,036 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,045 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,089 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,117 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,140 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,144 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,149 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,150 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,152 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,155 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,164 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,208 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,234 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,256 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,260 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,265 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,266 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,268 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,270 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,279 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,323 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,348 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,371 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,378 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,383 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,385 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,387 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,390 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,399 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,443 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,465 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,486 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,490 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,495 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,497 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,499 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,501 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,510 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,553 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,574 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,594 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,600 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,604 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,606 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,608 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,610 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,618 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,662 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,689 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,712 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,717 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,722 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,723 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,725 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,727 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,736 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,780 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,801 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,823 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,827 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,832 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,833 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,835 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,838 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,848 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,892 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,918 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,941 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,946 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,951 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,952 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,954 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,957 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:51,966 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,010 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,032 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,055 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,059 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,063 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,065 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,067 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,069 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,078 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,122 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,147 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,176 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,184 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,189 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,190 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,192 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,194 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,203 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,248 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,273 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,294 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,299 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,303 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,305 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,306 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,309 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,317 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,361 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,387 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,410 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,415 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,420 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,421 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,423 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,426 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,436 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,480 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,502 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,523 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,527 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,533 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,534 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,536 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,539 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,548 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,592 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,619 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,643 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,648 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,653 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,654 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,656 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,658 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,667 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,711 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,733 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,756 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,761 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,766 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,768 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,770 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,773 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,782 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,827 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,860 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,892 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,896 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,902 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,903 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,906 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,908 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,917 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,963 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:52,990 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,012 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,017 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,021 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,025 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,027 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,029 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,039 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,083 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,104 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,125 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,130 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,134 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,136 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,138 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,140 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,149 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,192 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,218 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,240 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,244 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,250 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,251 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,253 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,256 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,265 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,309 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,334 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,359 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,364 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,369 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,370 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,372 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,375 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,384 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,428 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,453 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,479 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,484 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,488 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,490 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,492 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,495 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,504 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,549 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,576 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,602 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,608 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,613 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,615 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,617 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,619 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,628 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,672 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,702 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,727 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,732 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,736 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,738 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,740 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,743 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,752 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,797 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,819 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,844 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,850 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,855 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,857 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,859 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,862 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,871 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,915 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,941 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,964 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,972 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,977 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,978 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,980 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,983 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:53,993 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,039 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,064 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,094 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,099 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,105 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,107 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,109 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,111 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,120 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,164 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,189 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,207 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,212 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,216 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,218 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,219 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,222 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,232 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,276 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,302 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,324 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,329 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,334 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,336 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,337 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,340 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,349 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,395 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,420 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,442 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,447 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,452 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,453 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,455 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,458 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,467 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,511 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,533 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,556 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,560 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,565 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,567 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,569 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,571 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,580 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,625 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,647 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,670 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,675 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,679 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,681 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,684 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,686 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,694 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,739 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,766 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,790 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,797 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,802 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,803 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,805 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,809 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,818 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,861 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,883 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,904 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,909 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,913 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,915 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,917 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,919 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,928 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,972 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:54,994 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,014 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,018 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,022 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,024 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,026 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,028 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,036 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,081 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,108 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,130 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,135 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,139 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,141 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,143 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,145 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,154 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,199 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,221 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,245 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,250 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,255 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,257 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,259 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,261 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,270 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,314 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,340 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,365 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,371 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,376 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,378 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,380 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,383 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,392 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,436 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,458 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,480 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,485 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,490 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,492 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,494 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,496 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,505 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,549 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,572 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,596 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,601 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,609 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,611 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,613 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,616 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,625 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,669 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,694 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,716 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,721 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,726 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,728 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,730 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,733 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,742 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,786 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,814 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,837 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,842 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,847 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,850 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,852 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,855 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,864 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,908 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:55,930 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[opt_20260907_001743] cmaes: 2 dimensions, 1 objective(s), up to 12 generations x 16 candidates\n", + " reusing network from ./results/clamp_weight\n", + " gen 1, trial 1/16 (#1): clamp.amp_na=475.3 nA conn.syn_weight=72.31 pA -> mean_firing_rate=248 Hz (off 198 Hz) <- best so far\n", + " gen 1, trial 2/16 (#2): clamp.amp_na=100.1 nA conn.syn_weight=30.93 pA -> mean_firing_rate=0 Hz (off 40 Hz) <- best so far\n", + " gen 1, trial 3/16 (#3): clamp.amp_na=232.1 nA conn.syn_weight=10.14 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 1, trial 4/16 (#4): clamp.amp_na=267.6 nA conn.syn_weight=35.21 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 1, trial 5/16 (#5): clamp.amp_na=457.1 nA conn.syn_weight=54.34 pA -> mean_firing_rate=212 Hz (off 162 Hz)\n", + " gen 1, trial 6/16 (#6): clamp.amp_na=477.3 nA conn.syn_weight=68.84 pA -> mean_firing_rate=242 Hz (off 192 Hz)\n", + " gen 1, trial 7/16 (#7): clamp.amp_na=284 nA conn.syn_weight=87.93 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 1, trial 8/16 (#8): clamp.amp_na=124.6 nA conn.syn_weight=67.38 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 1, trial 9/16 (#9): clamp.amp_na=475.6 nA conn.syn_weight=56.31 pA -> mean_firing_rate=218 Hz (off 168 Hz)\n", + " gen 1, trial 10/16 (#10): clamp.amp_na=226.3 nA conn.syn_weight=20.61 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 1, trial 11/16 (#11): clamp.amp_na=820.7 nA conn.syn_weight=96.86 pA -> mean_firing_rate=296 Hz (off 246 Hz)\n", + " gen 1, trial 12/16 (#12): clamp.amp_na=382.1 nA conn.syn_weight=69.54 pA -> mean_firing_rate=222 Hz (off 172 Hz)\n", + " gen 1, trial 13/16 (#13): clamp.amp_na=888.8 nA conn.syn_weight=89.57 pA -> mean_firing_rate=296 Hz (off 246 Hz)\n", + " gen 1, trial 14/16 (#14): clamp.amp_na=176.5 nA conn.syn_weight=4.866 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 1, trial 15/16 (#15): clamp.amp_na=252.8 nA conn.syn_weight=87.94 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 1, trial 16/16 (#16): clamp.amp_na=188.5 nA conn.syn_weight=42.69 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 1/12: best clamp.amp_na=100.1 nA conn.syn_weight=30.93 pA -> mean_firing_rate=0 Hz [target 40.0-50.0 Hz, off 40 Hz]\n", + " gen 2, trial 1/16 (#17): clamp.amp_na=592.1 nA conn.syn_weight=50.25 pA -> mean_firing_rate=214 Hz (off 164 Hz)\n", + " gen 2, trial 2/16 (#18): clamp.amp_na=618.5 nA conn.syn_weight=52.59 pA -> mean_firing_rate=220 Hz (off 170 Hz)\n", + " gen 2, trial 3/16 (#19): clamp.amp_na=607.9 nA conn.syn_weight=56.44 pA -> mean_firing_rate=232 Hz (off 182 Hz)\n", + " gen 2, trial 4/16 (#20): clamp.amp_na=622.1 nA conn.syn_weight=47.46 pA -> mean_firing_rate=210 Hz (off 160 Hz)\n", + " gen 2, trial 5/16 (#21): clamp.amp_na=550.2 nA conn.syn_weight=59.21 pA -> mean_firing_rate=230 Hz (off 180 Hz)\n", + " gen 2, trial 6/16 (#22): clamp.amp_na=492.6 nA conn.syn_weight=26.1 pA -> mean_firing_rate=126 Hz (off 76 Hz)\n", + " gen 2, trial 7/16 (#23): clamp.amp_na=381.5 nA conn.syn_weight=49.19 pA -> mean_firing_rate=178 Hz (off 128 Hz)\n", + " gen 2, trial 8/16 (#24): clamp.amp_na=418.9 nA conn.syn_weight=52.43 pA -> mean_firing_rate=198 Hz (off 148 Hz)\n", + " gen 2, trial 9/16 (#25): clamp.amp_na=558.1 nA conn.syn_weight=52.88 pA -> mean_firing_rate=220 Hz (off 170 Hz)\n", + " gen 2, trial 10/16 (#26): clamp.amp_na=675 nA conn.syn_weight=32.03 pA -> mean_firing_rate=178 Hz (off 128 Hz)\n", + " gen 2, trial 11/16 (#27): clamp.amp_na=483.3 nA conn.syn_weight=75.69 pA -> mean_firing_rate=256 Hz (off 206 Hz)\n", + " gen 2, trial 12/16 (#28): clamp.amp_na=479.7 nA conn.syn_weight=73.5 pA -> mean_firing_rate=248 Hz (off 198 Hz)\n", + " gen 2, trial 13/16 (#29): clamp.amp_na=771.7 nA conn.syn_weight=55.15 pA -> mean_firing_rate=240 Hz (off 190 Hz)\n", + " gen 2, trial 14/16 (#30): clamp.amp_na=668.8 nA conn.syn_weight=36.46 pA -> mean_firing_rate=188 Hz (off 138 Hz)\n", + " gen 2, trial 15/16 (#31): clamp.amp_na=465.4 nA conn.syn_weight=44.71 pA -> mean_firing_rate=184 Hz (off 134 Hz)\n", + " gen 2, trial 16/16 (#32): clamp.amp_na=763.7 nA conn.syn_weight=25.39 pA -> mean_firing_rate=168 Hz (off 118 Hz)\n", + " gen 2/12: best clamp.amp_na=100.1 nA conn.syn_weight=30.93 pA -> mean_firing_rate=0 Hz [target 40.0-50.0 Hz, off 40 Hz]\n", + " gen 3, trial 1/16 (#33): clamp.amp_na=409 nA conn.syn_weight=21.41 pA -> mean_firing_rate=78 Hz (off 28 Hz) <- best so far\n", + " gen 3, trial 2/16 (#34): clamp.amp_na=544.4 nA conn.syn_weight=55.08 pA -> mean_firing_rate=220 Hz (off 170 Hz)\n", + " gen 3, trial 3/16 (#35): clamp.amp_na=630.9 nA conn.syn_weight=42.66 pA -> mean_firing_rate=200 Hz (off 150 Hz)\n", + " gen 3, trial 4/16 (#36): clamp.amp_na=514.7 nA conn.syn_weight=35.82 pA -> mean_firing_rate=166 Hz (off 116 Hz)\n", + " gen 3, trial 5/16 (#37): clamp.amp_na=699.4 nA conn.syn_weight=67.33 pA -> mean_firing_rate=252 Hz (off 202 Hz)\n", + " gen 3, trial 6/16 (#38): clamp.amp_na=447.2 nA conn.syn_weight=42.73 pA -> mean_firing_rate=176 Hz (off 126 Hz)\n", + " gen 3, trial 7/16 (#39): clamp.amp_na=385.5 nA conn.syn_weight=54.42 pA -> mean_firing_rate=192 Hz (off 142 Hz)\n", + " gen 3, trial 8/16 (#40): clamp.amp_na=851.3 nA conn.syn_weight=41.22 pA -> mean_firing_rate=218 Hz (off 168 Hz)\n", + " gen 3, trial 9/16 (#41): clamp.amp_na=336.4 nA conn.syn_weight=42.97 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 3, trial 10/16 (#42): clamp.amp_na=413.4 nA conn.syn_weight=25.54 pA -> mean_firing_rate=102 Hz (off 52 Hz)\n", + " gen 3, trial 11/16 (#43): clamp.amp_na=240 nA conn.syn_weight=16.49 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 3, trial 12/16 (#44): clamp.amp_na=542.5 nA conn.syn_weight=43.88 pA -> mean_firing_rate=190 Hz (off 140 Hz)\n", + " gen 3, trial 13/16 (#45): clamp.amp_na=500.4 nA conn.syn_weight=41.24 pA -> mean_firing_rate=178 Hz (off 128 Hz)\n", + " gen 3, trial 14/16 (#46): clamp.amp_na=609.5 nA conn.syn_weight=3.193 pA -> mean_firing_rate=82 Hz (off 32 Hz)\n", + " gen 3, trial 15/16 (#47): clamp.amp_na=510.9 nA conn.syn_weight=45.03 pA -> mean_firing_rate=190 Hz (off 140 Hz)\n", + " gen 3, trial 16/16 (#48): clamp.amp_na=521.7 nA conn.syn_weight=30.36 pA -> mean_firing_rate=146 Hz (off 96 Hz)\n", + " gen 3/12: best clamp.amp_na=409 nA conn.syn_weight=21.41 pA -> mean_firing_rate=78 Hz [target 40.0-50.0 Hz, off 28 Hz]\n", + " gen 4, trial 1/16 (#49): clamp.amp_na=631.6 nA conn.syn_weight=25.52 pA -> mean_firing_rate=150 Hz (off 100 Hz)\n", + " gen 4, trial 2/16 (#50): clamp.amp_na=526.9 nA conn.syn_weight=1.751 pA -> mean_firing_rate=64 Hz (off 14 Hz) <- best so far\n", + " gen 4, trial 3/16 (#51): clamp.amp_na=287.9 nA conn.syn_weight=19.64 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 4, trial 4/16 (#52): clamp.amp_na=486.3 nA conn.syn_weight=49.47 pA -> mean_firing_rate=202 Hz (off 152 Hz)\n", + " gen 4, trial 5/16 (#53): clamp.amp_na=421.5 nA conn.syn_weight=25.65 pA -> mean_firing_rate=106 Hz (off 56 Hz)\n", + " gen 4, trial 6/16 (#54): clamp.amp_na=392.4 nA conn.syn_weight=36.35 pA -> mean_firing_rate=140 Hz (off 90 Hz)\n", + " gen 4, trial 7/16 (#55): clamp.amp_na=549.9 nA conn.syn_weight=23.75 pA -> mean_firing_rate=130 Hz (off 80 Hz)\n", + " gen 4, trial 8/16 (#56): clamp.amp_na=469.8 nA conn.syn_weight=27.65 pA -> mean_firing_rate=126 Hz (off 76 Hz)\n", + " gen 4, trial 9/16 (#57): clamp.amp_na=525.9 nA conn.syn_weight=22.61 pA -> mean_firing_rate=120 Hz (off 70 Hz)\n", + " gen 4, trial 10/16 (#58): clamp.amp_na=243.3 nA conn.syn_weight=41 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 4, trial 11/16 (#59): clamp.amp_na=505 nA conn.syn_weight=34.16 pA -> mean_firing_rate=156 Hz (off 106 Hz)\n", + " gen 4, trial 12/16 (#60): clamp.amp_na=613.9 nA conn.syn_weight=42.78 pA -> mean_firing_rate=196 Hz (off 146 Hz)\n", + " gen 4, trial 13/16 (#61): clamp.amp_na=502.5 nA conn.syn_weight=17.62 pA -> mean_firing_rate=96 Hz (off 46 Hz)\n", + " gen 4, trial 14/16 (#62): clamp.amp_na=329.2 nA conn.syn_weight=19.48 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 4, trial 15/16 (#63): clamp.amp_na=501.2 nA conn.syn_weight=27.86 pA -> mean_firing_rate=134 Hz (off 84 Hz)\n", + " gen 4, trial 16/16 (#64): clamp.amp_na=753 nA conn.syn_weight=39.8 pA -> mean_firing_rate=206 Hz (off 156 Hz)\n", + " gen 4/12: best clamp.amp_na=526.9 nA conn.syn_weight=1.751 pA -> mean_firing_rate=64 Hz [target 40.0-50.0 Hz, off 14 Hz]\n", + " gen 5, trial 1/16 (#65): clamp.amp_na=163.5 nA conn.syn_weight=18.77 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 5, trial 2/16 (#66): clamp.amp_na=293.7 nA conn.syn_weight=27.28 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 5, trial 3/16 (#67): clamp.amp_na=556.7 nA conn.syn_weight=48.37 pA -> mean_firing_rate=204 Hz (off 154 Hz)\n", + " gen 5, trial 4/16 (#68): clamp.amp_na=259.5 nA conn.syn_weight=20.57 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 5, trial 5/16 (#69): clamp.amp_na=568 nA conn.syn_weight=9.926 pA -> mean_firing_rate=90 Hz (off 40 Hz)\n", + " gen 5, trial 6/16 (#70): clamp.amp_na=597.1 nA conn.syn_weight=5.157 pA -> mean_firing_rate=84 Hz (off 34 Hz)\n", + " gen 5, trial 7/16 (#71): clamp.amp_na=764.7 nA conn.syn_weight=27.67 pA -> mean_firing_rate=174 Hz (off 124 Hz)\n", + " gen 5, trial 8/16 (#72): clamp.amp_na=651.3 nA conn.syn_weight=14.52 pA -> mean_firing_rate=118 Hz (off 68 Hz)\n", + " gen 5, trial 9/16 (#73): clamp.amp_na=465.8 nA conn.syn_weight=18.95 pA -> mean_firing_rate=90 Hz (off 40 Hz)\n", + " gen 5, trial 10/16 (#74): clamp.amp_na=329.3 nA conn.syn_weight=3.723 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 5, trial 11/16 (#75): clamp.amp_na=264 nA conn.syn_weight=9.507 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 5, trial 12/16 (#76): clamp.amp_na=639.5 nA conn.syn_weight=21.28 pA -> mean_firing_rate=138 Hz (off 88 Hz)\n", + " gen 5, trial 13/16 (#77): clamp.amp_na=267.7 nA conn.syn_weight=13.01 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 5, trial 14/16 (#78): clamp.amp_na=577.5 nA conn.syn_weight=29.82 pA -> mean_firing_rate=154 Hz (off 104 Hz)\n", + " gen 5, trial 15/16 (#79): clamp.amp_na=169.7 nA conn.syn_weight=20.96 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 5, trial 16/16 (#80): clamp.amp_na=461.6 nA conn.syn_weight=10.21 pA -> mean_firing_rate=62 Hz (off 12 Hz) <- best so far\n", + " gen 5/12: best clamp.amp_na=461.6 nA conn.syn_weight=10.21 pA -> mean_firing_rate=62 Hz [target 40.0-50.0 Hz, off 12 Hz]\n", + " gen 6, trial 1/16 (#81): clamp.amp_na=455.4 nA conn.syn_weight=8.074 pA -> mean_firing_rate=56 Hz (off 6 Hz) <- best so far\n", + " gen 6, trial 2/16 (#82): clamp.amp_na=581.2 nA conn.syn_weight=13.88 pA -> mean_firing_rate=104 Hz (off 54 Hz)\n", + " gen 6, trial 3/16 (#83): clamp.amp_na=119.5 nA conn.syn_weight=9.999 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 6, trial 4/16 (#84): clamp.amp_na=540.1 nA conn.syn_weight=31.73 pA -> mean_firing_rate=154 Hz (off 104 Hz)\n", + " gen 6, trial 5/16 (#85): clamp.amp_na=342.2 nA conn.syn_weight=10.72 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 6, trial 6/16 (#86): clamp.amp_na=459.9 nA conn.syn_weight=29.74 pA -> mean_firing_rate=132 Hz (off 82 Hz)\n", + " gen 6, trial 7/16 (#87): clamp.amp_na=772.8 nA conn.syn_weight=5.593 pA -> mean_firing_rate=116 Hz (off 66 Hz)\n", + " gen 6, trial 8/16 (#88): clamp.amp_na=219 nA conn.syn_weight=11 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 6, trial 9/16 (#89): clamp.amp_na=601.9 nA conn.syn_weight=34.39 pA -> mean_firing_rate=174 Hz (off 124 Hz)\n", + " gen 6, trial 10/16 (#90): clamp.amp_na=574.8 nA conn.syn_weight=21.2 pA -> mean_firing_rate=126 Hz (off 76 Hz)\n", + " gen 6, trial 11/16 (#91): clamp.amp_na=419.6 nA conn.syn_weight=23.57 pA -> mean_firing_rate=94 Hz (off 44 Hz)\n", + " gen 6, trial 12/16 (#92): clamp.amp_na=617.7 nA conn.syn_weight=6.605 pA -> mean_firing_rate=92 Hz (off 42 Hz)\n", + " gen 6, trial 13/16 (#93): clamp.amp_na=407.3 nA conn.syn_weight=53.99 pA -> mean_firing_rate=198 Hz (off 148 Hz)\n", + " gen 6, trial 14/16 (#94): clamp.amp_na=325.5 nA conn.syn_weight=18.94 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 6, trial 15/16 (#95): clamp.amp_na=380.2 nA conn.syn_weight=18.98 pA -> mean_firing_rate=32 Hz (off 8 Hz)\n", + " gen 6, trial 16/16 (#96): clamp.amp_na=491 nA conn.syn_weight=27.28 pA -> mean_firing_rate=130 Hz (off 80 Hz)\n", + " gen 6/12: best clamp.amp_na=455.4 nA conn.syn_weight=8.074 pA -> mean_firing_rate=56 Hz [target 40.0-50.0 Hz, off 6 Hz]\n", + " gen 7, trial 1/16 (#97): clamp.amp_na=430.7 nA conn.syn_weight=7.843 pA -> mean_firing_rate=46 Hz (in target) <- best so far\n", + " gen 7, trial 2/16 (#98): clamp.amp_na=400.7 nA conn.syn_weight=19.04 pA -> mean_firing_rate=60 Hz (off 10 Hz)\n", + " gen 7, trial 3/16 (#99): clamp.amp_na=384.3 nA conn.syn_weight=16.38 pA -> mean_firing_rate=32 Hz (off 8 Hz)\n", + " gen 7, trial 4/16 (#100): clamp.amp_na=273.4 nA conn.syn_weight=9.226 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 7, trial 5/16 (#101): clamp.amp_na=257.2 nA conn.syn_weight=15.03 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 7, trial 6/16 (#102): clamp.amp_na=381.6 nA conn.syn_weight=47.06 pA -> mean_firing_rate=170 Hz (off 120 Hz)\n", + " gen 7, trial 7/16 (#103): clamp.amp_na=321.6 nA conn.syn_weight=7.252 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 7, trial 8/16 (#104): clamp.amp_na=262.5 nA conn.syn_weight=9.975 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 7, trial 9/16 (#105): clamp.amp_na=508.6 nA conn.syn_weight=3.275 pA -> mean_firing_rate=62 Hz (off 12 Hz)\n", + " gen 7, trial 10/16 (#106): clamp.amp_na=198.6 nA conn.syn_weight=2.816 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 7, trial 11/16 (#107): clamp.amp_na=445.4 nA conn.syn_weight=7.913 pA -> mean_firing_rate=52 Hz (off 2 Hz)\n", + " gen 7, trial 12/16 (#108): clamp.amp_na=190.5 nA conn.syn_weight=10.25 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 7, trial 13/16 (#109): clamp.amp_na=355.9 nA conn.syn_weight=21.68 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 7, trial 14/16 (#110): clamp.amp_na=616.9 nA conn.syn_weight=4.625 pA -> mean_firing_rate=88 Hz (off 38 Hz)\n", + " gen 7, trial 15/16 (#111): clamp.amp_na=768.6 nA conn.syn_weight=31.46 pA -> mean_firing_rate=186 Hz (off 136 Hz)\n", + " gen 7, trial 16/16 (#112): clamp.amp_na=356.5 nA conn.syn_weight=11.08 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", + " gen 7/12: best clamp.amp_na=430.7 nA conn.syn_weight=7.843 pA -> mean_firing_rate=46 Hz [target 40.0-50.0 Hz, in target] — all targets met\n", + "[opt_20260907_001743] stopped: a candidate is inside every target band\n", + "\n", + "network rebuilt in 112 runs, reused in 0\n", + "expected: a rebuild every trial, because syn_weight is structural\n" + ] + } + ], + "source": [ + "buffer = io.StringIO()\n", + "with contextlib.redirect_stdout(buffer):\n", + " result = optimize(workflow, spec=spec, results_path=\"./results/clamp_weight/optimization\")\n", + "captured = buffer.getvalue()\n", + "\n", + "for line in captured.splitlines():\n", + " if line.startswith(\"[opt_\") or line.lstrip().startswith(\"gen \") or line.startswith(\" reusing\"):\n", + " print(line)\n", + "\n", + "print(f\"\\nnetwork rebuilt in {captured.count('network built')} runs, \"\n", + " f\"reused in {captured.count('network unchanged')}\")\n", + "print(\"expected: a rebuild every trial, because syn_weight is structural\")" + ] + }, + { + "cell_type": "markdown", + "id": "baaba8da", + "metadata": {}, + "source": [ + "## 7. Result" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "191094d0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "stop reason: a candidate is inside every target band\n", + "best trial: 97\n", + " clamp.amp_na 430.7\n", + " conn.syn_weight 7.843\n", + " measured: {'exc.mean_firing_rate': 46.0}\n", + " distance from target (raw, per objective): [0.0]\n", + "\n", + "clamp.configure(amp_na=430.6735051488371)\n", + "conn.configure(syn_weight=7.8434448541675374)\n" + ] + } + ], + "source": [ + "print(\"stop reason:\", result.stop_reason)\n", + "if result.best:\n", + " print(\"best trial:\", result.best[\"trial\"])\n", + " for address, value in result.best[\"params\"].items():\n", + " print(f\" {address:<30} {value:.4g}\")\n", + " print(\" measured:\", result.best[\"measured\"])\n", + " print(\" distance from target (raw, per objective):\", result.best[\"fitness\"])\n", + " print()\n", + " print(result.configure_snippet())" + ] + }, + { + "cell_type": "markdown", + "id": "c6581c4e", + "metadata": {}, + "source": [ + "## 8. How the search evolved\n", + "\n", + "The bottom row is the interesting one here: with two knobs that both raise the rate, expect the\n", + "good (dark) points to fall along a trade-off rather than converge on one value of each." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "ed19812e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "objective = spec.objectives[0]\n", + "scored = [t for t in result.trials if t[\"fitness\"] is not None]\n", + "\n", + "if not scored:\n", + " print(\"no successful trial to plot\")\n", + "else:\n", + " x = [t[\"trial\"] for t in scored]\n", + " measured = [t[\"measured\"][objective.name] for t in scored]\n", + " # One objective, so this is simply how far it missed, in its own unit.\n", + " # With several objectives use t[\"target_ranges_off\"] instead: misses in different\n", + " # units cannot be compared until each is sized against its own target range.\n", + " fitness = [t[\"fitness\"][0] for t in scored]\n", + " best_so_far, running = [], float(\"inf\")\n", + " for value in fitness:\n", + " running = min(running, value)\n", + " best_so_far.append(running)\n", + " best_trial, pop_size, dims = result.best[\"trial\"], spec.algorithm.pop_size, spec.dimensions\n", + "\n", + " fig = plt.figure(figsize=(11, 9))\n", + " grid = fig.add_gridspec(3, max(len(dims), 1), hspace=0.45, wspace=0.3)\n", + " ax_measured = fig.add_subplot(grid[0, :])\n", + " ax_fitness = fig.add_subplot(grid[1, :])\n", + " dim_axes = [fig.add_subplot(grid[2, i]) for i in range(len(dims))]\n", + "\n", + " def generations(ax):\n", + " for boundary in range(pop_size, max(x) + 1, pop_size):\n", + " ax.axvline(boundary + 0.5, color=\"0.85\", lw=0.8, ls=\"--\", zorder=0)\n", + "\n", + " ax_measured.axhspan(objective.low, objective.high, color=\"tab:green\", alpha=0.15,\n", + " label=f\"target {objective.low}-{objective.high} {objective.unit}\")\n", + " generations(ax_measured)\n", + " ax_measured.plot(x, measured, \"o\", ms=5, color=\"tab:blue\", alpha=0.7, label=\"trial\")\n", + " ax_measured.plot(best_trial, result.best[\"measured\"][objective.name], \"*\",\n", + " ms=18, color=\"tab:red\", label=\"best\", zorder=5)\n", + " baseline = spec.baseline.get(\"measured\", {}).get(objective.name)\n", + " if baseline is not None:\n", + " ax_measured.axhline(baseline, color=\"0.4\", ls=\":\", lw=1.2, label=f\"baseline {baseline:.3g}\")\n", + " ax_measured.set_ylabel(f\"firing rate [{objective.unit}]\")\n", + " ax_measured.set_title(\"Measured value per trial\")\n", + " ax_measured.legend(fontsize=8, loc=\"best\")\n", + "\n", + " generations(ax_fitness)\n", + " ax_fitness.plot(x, fitness, \"o\", ms=4, color=\"0.6\", alpha=0.7, label=\"trial\")\n", + " ax_fitness.step(x, best_so_far, where=\"post\", color=\"tab:red\", lw=2, label=\"best so far\")\n", + " ax_fitness.axhline(0.0, color=\"tab:green\", lw=1.2, ls=\"--\", label=\"0 = inside the band\")\n", + " ax_fitness.set_xlabel(\"trial\")\n", + " ax_fitness.set_ylabel(f\"distance from target [{objective.unit}]\"\n", + " if objective.unit else \"distance from target\")\n", + " ax_fitness.set_title(\"Distance from the target band - raw, in the objective's \"\n", + " \"own unit - smaller is better\")\n", + " ax_fitness.legend(fontsize=8, loc=\"best\")\n", + "\n", + " points = None\n", + " for ax, dimension in zip(dim_axes, dims):\n", + " values = [t[\"params\"][dimension.address] for t in scored]\n", + " points = ax.scatter(x, values, c=fitness, cmap=\"viridis_r\", s=28)\n", + " ax.plot(best_trial, result.best[\"params\"][dimension.address], \"*\",\n", + " ms=16, color=\"tab:red\", zorder=5)\n", + " ax.set_ylim(dimension.low, dimension.high)\n", + " ax.set_xlabel(\"trial\")\n", + " ax.set_title(dimension.address.split(\".\", 1)[1] +\n", + " (f\" [{dimension.unit}]\" if dimension.unit else \"\"), fontsize=9)\n", + " if points is not None:\n", + " fig.colorbar(points, ax=dim_axes, fraction=0.03, pad=0.02,\n", + " label=f\"distance from target [{objective.unit}]\"\n", + " if objective.unit else \"distance from target\")\n", + "\n", + " fig.suptitle(f\"{result.run_id} - {result.stop_reason}\", fontsize=11)\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "59fb8ba7", + "metadata": {}, + "source": [ + "## 9. Adopt the winner" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "be9fcf0d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/clamp_weight/optimization/opt_20260907_001743/trials/0112/network\n", + "2026-09-07 00:17:56,150 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:56,155 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:56,160 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:56,162 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:56,164 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:56,167 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:56,176 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:56,220 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:17:56,244 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + "amp_na = 430.6735051488371\n", + "syn_weight = 7.8434448541675374\n", + "firing rate = {'exc': 46.0}\n" + ] + } + ], + "source": [ + "result.apply_best(workflow, execute=True)\n", + "print(\"amp_na =\", clamp._parameters[\"amp_na\"])\n", + "print(\"syn_weight =\", conn._parameters[\"syn_weight\"])\n", + "print(\"firing rate =\", ana._output_ports[\"firing_rate_hz\"].value)" + ] + }, + { + "cell_type": "markdown", + "id": "9086f4f8", + "metadata": {}, + "source": [ + "## Notes\n", + "\n", + "- **Degenerate by design.** Drive and recurrent weight trade off, so many combinations hit the band.\n", + " The optimizer stops at the first one that does — it is not looking for a unique answer.\n", + "- **Every trial rebuilt the network**, because `syn_weight` lives in the SONATA edge files. Tuning\n", + " `nest_params` or synapse `dynamics_params_dict` instead would reuse the network throughout.\n", + "- **If everything reports 0 Hz**, the clamp is not reaching threshold: raise the `amp_na` range or\n", + " lower `V_th`. If the rate is pinned high, lower both ranges." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "82919aa5-f978-4b36-ba9f-d65431066c76", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1c5d379a-fb95-45de-8504-4eff72d98262", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.12.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/NW_Network_Optimization.ipynb b/notebooks/NW_Network_Optimization.ipynb new file mode 100644 index 00000000..ea932fb4 --- /dev/null +++ b/notebooks/NW_Network_Optimization.ipynb @@ -0,0 +1,2040 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3b64c68a", + "metadata": {}, + "source": [ + "# Optimizing a structural parameter\n", + "\n", + "The single-cell notebook tunes only values the simulator reads at run time, so the SONATA network\n", + "is built once and every trial reuses it. This one tunes a **structural** parameter as well, which\n", + "is the other half of the story.\n", + "\n", + "Two dimensions:\n", + "\n", + "| dimension | kind | consequence |\n", + "|---|---|---|\n", + "| `conn.syn_weight` | **structural** — written into `edge_types.csv` | the network must be rebuilt for every candidate |\n", + "| `exc.nest_params.I_e` | runtime — written to `_params.json` | no rebuild on its own |\n", + "\n", + "Because one dimension is structural, **every trial rebuilds**. That is correct, not a regression:\n", + "each candidate really is a different network. The copy the engine seeds into each trial is simply\n", + "discarded. The last cell counts rebuilds so you can see it.\n", + "\n", + "A limitation to know: addresses index dicts, not lists, so a weight inside `connections[0]` cannot\n", + "be tuned. Only the node-level `syn_weight` default is addressable — and it applies to every\n", + "connection that does not override it." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "c0bdb709", + "metadata": {}, + "outputs": [], + "source": [ + "import contextlib\n", + "import io\n", + "import os\n", + "import sys\n", + "\n", + "# Prefer this repository's sources over any previously installed copy:\n", + "# neuroworkflow.optimization is new and an older install would not have it.\n", + "sys.path.insert(0, os.path.abspath('../src'))\n", + "\n", + "from neuroworkflow import WorkflowBuilder\n", + "from neuroworkflow.nodes.network.NW_Population import NW_Population\n", + "from neuroworkflow.nodes.network.NW_Connectivity import NW_Connectivity\n", + "from neuroworkflow.nodes.simulation.NW_SimConfig import NW_SimConfig\n", + "from neuroworkflow.nodes.analysis.NW_Analysis import NW_Analysis\n", + "\n", + "from neuroworkflow.optimization import AlgorithmConfig, build_spec, optimize" + ] + }, + { + "cell_type": "markdown", + "id": "ecf3239d", + "metadata": {}, + "source": [ + "## 1. Nodes" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4497d68d", + "metadata": {}, + "outputs": [], + "source": [ + "exc = NW_Population(\"exc\")\n", + "inh = NW_Population(\"inh\")\n", + "conn = NW_Connectivity(\"conn\")\n", + "sim = NW_SimConfig(\"sim\")\n", + "ana = NW_Analysis(\"ana\")" + ] + }, + { + "cell_type": "markdown", + "id": "8caeed77", + "metadata": {}, + "source": [ + "## 2. Configure\n", + "\n", + "A small E-I network. Note which connections carry an explicit `syn_weight` and which do not:\n", + "the two **excitatory** projections omit it, so they inherit the node-level default — the value the\n", + "optimizer will tune. The inhibitory projections fix their own weight and stay constant." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9f75c256", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "neuron = dict(\n", + " model_type=\"point_neuron\", model_template=\"nest:iaf_psc_alpha\",\n", + " location=\"VISp\", layer=\"L4\",\n", + " nest_params={\"C_m\": 250.0, \"tau_m\": 10.0, \"t_ref\": 2.0,\n", + " \"V_th\": -55.0, \"V_reset\": -70.0, \"E_L\": -70.0, \"I_e\": 370.0},\n", + " # 370 pA sits just under this neuron's threshold: C_m/tau_m = 25 nS and\n", + " # V_th - E_L = 15 mV, so it cannot spike below 15 mV x 25 nS = 375 pA.\n", + " # The network therefore starts silent and the search has to find the drive\n", + " # that wakes it - which is the point of the example.\n", + ")\n", + "exc.configure(pop_name=\"exc\", N=16, ei_type=\"exc\", **neuron)\n", + "inh.configure(pop_name=\"inh\", N=4, ei_type=\"inh\", **neuron)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4fb8d5a0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "conn.configure(\n", + " connection_rule = 1, # one synapse per pair - deterministic, no RNG noise in the objective\n", + " syn_weight = 5.0, # node-level default: inherited by connections that omit it\n", + " connections = [\n", + " {\"source\": \"exc\", \"target\": \"exc\"}, # tuned\n", + " {\"source\": \"exc\", \"target\": \"inh\"}, # tuned\n", + " {\"source\": \"inh\", \"target\": \"exc\", \"syn_weight\": -40.0}, # fixed\n", + " {\"source\": \"inh\", \"target\": \"inh\", \"syn_weight\": -40.0}, # fixed\n", + " ],\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1a9e92de", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sim.configure(simulator=\"pointnet\", config_file=\"config_net_opt.json\",\n", + " tstop_ms=500.0, dt_ms=0.1)\n", + "ana.configure(plot_raster=False, plot_traces=False)" + ] + }, + { + "cell_type": "markdown", + "id": "2c5635a0", + "metadata": {}, + "source": [ + "## 3. Build" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "fe43a819", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "nodes: ['exc', 'inh', 'conn', 'sim', 'ana']\n" + ] + } + ], + "source": [ + "wf = WorkflowBuilder(\"NW_Network_Optimization\")\n", + "for node in [exc, inh, conn, sim, ana]:\n", + " wf.add_node(node)\n", + "\n", + "wf.connect(\"exc\", \"population\", \"conn\", \"populations\")\n", + "wf.connect(\"inh\", \"population\", \"conn\", \"populations\")\n", + "wf.connect(\"conn\", \"network\", \"sim\", \"populations\")\n", + "wf.connect(\"sim\", \"results\", \"ana\", \"results\")\n", + "\n", + "wf.context[\"results_path\"] = \"./results/net_opt\"\n", + "workflow = wf.build()\n", + "print(\"nodes:\", list(workflow.nodes))" + ] + }, + { + "cell_type": "markdown", + "id": "024f3fb9", + "metadata": {}, + "source": [ + "## 4. Declare what to optimize\n", + "\n", + "`conn.syn_weight` is a plain scalar parameter, so its range is `[min, max]`. `exc.nest_params.I_e`\n", + "is a key inside a dict, so it is declared per key." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "91a59458", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "target measures: ana.firing_rate_hz.exc\n" + ] + } + ], + "source": [ + "explore_conn_syn_weight = conn.NODE_DEFINITION.parameters[\"syn_weight\"]\n", + "explore_conn_syn_weight.optimizable = True\n", + "explore_conn_syn_weight.optimization_range = [0.0, 30.0] # pA, current-based synapses\n", + "explore_conn_syn_weight.unit = \"pA\"\n", + "\n", + "explore_exc_nest_params = exc.NODE_DEFINITION.parameters[\"nest_params\"]\n", + "explore_exc_nest_params.optimizable = True\n", + "explore_exc_nest_params.optimization_range = {\"I_e\": [370.0, 450.0]} # pA, straddles the 375 pA threshold\n", + "\n", + "target_exc_mean_firing_rate = exc.NODE_DEFINITION.parameters[\"mean_firing_rate\"]\n", + "target_exc_mean_firing_rate.unit = \"Hz\"\n", + "target_exc_mean_firing_rate.is_objective = True\n", + "target_exc_mean_firing_rate.objective_range = [28.0, 32.0] # a narrow slice of the\n", + "# reachable range, so the search has to work for it rather than stumbling in\n", + "target_exc_mean_firing_rate.measures = (\n", + " f\"{ana.name}.firing_rate_hz.{exc._parameters['pop_name']}\"\n", + ")\n", + "\n", + "print(\"target measures:\", target_exc_mean_firing_rate.measures)" + ] + }, + { + "cell_type": "markdown", + "id": "be55b988", + "metadata": {}, + "source": [ + "## 5. Spec\n", + "\n", + "`exc` and `inh` are two instances of the same class, and each carries its **own** copy of its\n", + "definition — so marking `nest_params` optimizable on `exc` leaves `inh` untouched. Check the\n", + "summary: only `exc.nest_params.I_e` should appear." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "cbf76777", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: inh\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing ./results/net_opt/network\n", + "\n", + " -- N E S T --\n", + " Copyright (C) 2004 The NEST Initiative\n", + "\n", + " Version: 3.7.0\n", + " Built: Mar 4 2025 17:27:39\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", + "2026-09-07 09:48:49,545 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:48:49,553 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:48:49,557 [INFO] Batch processing nodes for inh/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for inh/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:48:49,569 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:48:49,570 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:48:49,572 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:48:49,577 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:48:49,581 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:48:49,623 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:48:49,642 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + "baseline measurables:\n", + " ana.firing_rate_hz.exc 0\n", + " ana.firing_rate_hz.inh 0\n", + " ana.isi_stats.exc.cv 0\n", + " ana.isi_stats.exc.mean_ms 0\n", + " ana.isi_stats.exc.n_intervals 0\n", + " ana.isi_stats.exc.std_ms 0\n", + " ana.isi_stats.inh.cv 0\n", + " ana.isi_stats.inh.mean_ms 0\n", + " ana.isi_stats.inh.n_intervals 0\n", + " ana.isi_stats.inh.std_ms 0\n", + "\n", + "algorithm : cmaes (pop_size=4, max_generations=6)\n", + "dimensions: 2\n", + " exc.nest_params.I_e [370.0, 450.0]\n", + " conn.syn_weight [0.0, 30.0] pA\n", + "objectives: 1\n", + " exc.mean_firing_rate in [28.0, 32.0] Hz <- ana.firing_rate_hz.exc\n" + ] + } + ], + "source": [ + "spec = build_spec(\n", + " workflow,\n", + " algorithm=AlgorithmConfig(name=\"cmaes\", pop_size=4, max_generations=6, seed=1),\n", + ")\n", + "\n", + "print(\"baseline measurables:\")\n", + "for address, value in sorted(spec.baseline[\"measurables\"].items()):\n", + " print(f\" {address:<40} {value:g}\")\n", + "print()\n", + "print(spec.summary())" + ] + }, + { + "cell_type": "markdown", + "id": "e4d560a5", + "metadata": {}, + "source": [ + "## 6. Run\n", + "\n", + "Output is captured so the per-trial NEST and BMTK logs do not bury the result; the engine's own\n", + "narration is printed afterwards, followed by a count of rebuilds versus reuses." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "5b512693", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,271 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,275 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,279 [INFO] Batch processing nodes for inh/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for inh/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,290 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,292 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,294 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,299 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,305 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,348 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,371 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,410 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,414 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,417 [INFO] Batch processing nodes for inh/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for inh/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,428 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,429 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,431 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,436 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,442 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,484 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,504 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,544 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,548 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,551 [INFO] Batch processing nodes for inh/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for inh/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,561 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,562 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,565 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,569 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,575 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,618 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,643 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,687 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,691 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,695 [INFO] Batch processing nodes for inh/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for inh/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,704 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,706 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,708 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,712 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,717 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,760 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,786 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,831 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,835 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,839 [INFO] Batch processing nodes for inh/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for inh/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,851 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,853 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,854 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,859 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,864 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,907 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,933 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,973 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,978 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,982 [INFO] Batch processing nodes for inh/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for inh/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,992 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,993 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:10,995 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:11,000 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:11,005 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:11,048 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:11,075 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:11,121 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:11,125 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:11,129 [INFO] Batch processing nodes for inh/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for inh/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:11,139 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:11,140 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:11,142 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:11,146 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:11,152 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:11,194 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:11,220 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:11,240 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:11,243 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:11,247 [INFO] Batch processing nodes for inh/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for inh/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:11,259 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:11,260 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:11,262 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:11,266 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:11,272 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:11,315 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:11,341 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[opt_20260907_094910] cmaes: 2 dimensions, 1 objective(s), up to 6 generations x 4 candidates\n", + " reusing network from results/net_opt/optimization/opt_20260907_094850/trials/0008\n", + " gen 1, trial 1/4 (#1): exc.nest_params.I_e=403.4 conn.syn_weight=21.61 pA -> mean_firing_rate=38 Hz (off 6 Hz) <- best so far\n", + " gen 1, trial 2/4 (#2): exc.nest_params.I_e=370 conn.syn_weight=9.07 pA -> mean_firing_rate=0 Hz (off 28 Hz)\n", + " gen 1, trial 3/4 (#3): exc.nest_params.I_e=381.7 conn.syn_weight=2.77 pA -> mean_firing_rate=20 Hz (off 8 Hz)\n", + " gen 1, trial 4/4 (#4): exc.nest_params.I_e=384.9 conn.syn_weight=10.37 pA -> mean_firing_rate=24 Hz (off 4 Hz) <- best so far\n", + " gen 1/6: best exc.nest_params.I_e=384.9 conn.syn_weight=10.37 pA -> mean_firing_rate=24 Hz [target 28.0-32.0 Hz, off 4 Hz]\n", + " gen 2, trial 1/4 (#5): exc.nest_params.I_e=430.5 conn.syn_weight=24.75 pA -> mean_firing_rate=52 Hz (off 20 Hz)\n", + " gen 2, trial 2/4 (#6): exc.nest_params.I_e=380.2 conn.syn_weight=19.25 pA -> mean_firing_rate=22 Hz (off 6 Hz)\n", + " gen 2, trial 3/4 (#7): exc.nest_params.I_e=437 conn.syn_weight=14.23 pA -> mean_firing_rate=44 Hz (off 12 Hz)\n", + " gen 2, trial 4/4 (#8): exc.nest_params.I_e=393.4 conn.syn_weight=7.099 pA -> mean_firing_rate=28 Hz (in target) <- best so far\n", + " gen 2/6: best exc.nest_params.I_e=393.4 conn.syn_weight=7.099 pA -> mean_firing_rate=28 Hz [target 28.0-32.0 Hz, in target] — all targets met\n", + "[opt_20260907_094910] stopped: a candidate is inside every target band\n", + "\n", + "network rebuilt in 7 runs, reused in 1\n", + "expected: rebuilt on every trial, because syn_weight is structural\n" + ] + } + ], + "source": [ + "buffer = io.StringIO()\n", + "with contextlib.redirect_stdout(buffer):\n", + " result = optimize(workflow, spec=spec, results_path=\"./results/net_opt/optimization\")\n", + "captured = buffer.getvalue()\n", + "\n", + "for line in captured.splitlines():\n", + " if line.startswith(\"[opt_\") or line.lstrip().startswith(\"gen \") or line.startswith(\" reusing\"):\n", + " print(line)\n", + "\n", + "built = captured.count(\"network built\")\n", + "reused = captured.count(\"network unchanged\")\n", + "print(f\"\\nnetwork rebuilt in {built} runs, reused in {reused}\")\n", + "print(\"expected: rebuilt on every trial, because syn_weight is structural\")" + ] + }, + { + "cell_type": "markdown", + "id": "5bc87a4f", + "metadata": {}, + "source": [ + "## 7. Result" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b7a39fc3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "stop reason: a candidate is inside every target band\n", + "best trial: 8\n", + " exc.nest_params.I_e 393.4\n", + " conn.syn_weight 7.099\n", + " measured: {'exc.mean_firing_rate': 28.0}\n", + " distance from target (raw, per objective): [0.0]\n", + "\n", + "conn.configure(syn_weight=7.098638567167976)\n", + "exc.configure(nest_params={**exc._parameters[\"nest_params\"], \"I_e\": 393.42826106245246})\n" + ] + } + ], + "source": [ + "print(\"stop reason:\", result.stop_reason)\n", + "if result.best:\n", + " print(\"best trial:\", result.best[\"trial\"])\n", + " for address, value in result.best[\"params\"].items():\n", + " print(f\" {address:<34} {value:.4g}\")\n", + " print(\" measured:\", result.best[\"measured\"])\n", + " print(\" distance from target (raw, per objective):\", result.best[\"fitness\"])\n", + " print()\n", + " print(result.configure_snippet())" + ] + }, + { + "cell_type": "markdown", + "id": "b8faf81d", + "metadata": {}, + "source": [ + "## 8. How the search evolved\n", + "\n", + "Same three views as the single-cell notebook: measured value against the target band, fitness with\n", + "the best-so-far curve, and each dimension coloured by fitness." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "e68e670e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "trials = result.trials\n", + "objective = spec.objectives[0]\n", + "scored = [t for t in trials if t[\"fitness\"] is not None]\n", + "\n", + "if not scored:\n", + " print(\"no successful trial to plot\")\n", + "else:\n", + " x = [t[\"trial\"] for t in scored]\n", + " measured = [t[\"measured\"][objective.name] for t in scored]\n", + " # One objective, so this is simply how far it missed, in its own unit.\n", + " # With several objectives use t[\"target_ranges_off\"] instead: misses in different\n", + " # units cannot be compared until each is sized against its own target range.\n", + " fitness = [t[\"fitness\"][0] for t in scored]\n", + " best_so_far, running = [], float(\"inf\")\n", + " for value in fitness:\n", + " running = min(running, value)\n", + " best_so_far.append(running)\n", + " best_trial = result.best[\"trial\"]\n", + " pop_size = spec.algorithm.pop_size\n", + " dims = spec.dimensions\n", + "\n", + " fig = plt.figure(figsize=(11, 9))\n", + " grid = fig.add_gridspec(3, max(len(dims), 1), hspace=0.45, wspace=0.3)\n", + " ax_measured = fig.add_subplot(grid[0, :])\n", + " ax_fitness = fig.add_subplot(grid[1, :])\n", + " dim_axes = [fig.add_subplot(grid[2, i]) for i in range(len(dims))]\n", + "\n", + " def generations(ax):\n", + " for boundary in range(pop_size, max(x) + 1, pop_size):\n", + " ax.axvline(boundary + 0.5, color=\"0.85\", lw=0.8, ls=\"--\", zorder=0)\n", + "\n", + " ax_measured.axhspan(objective.low, objective.high, color=\"tab:green\", alpha=0.15,\n", + " label=f\"target {objective.low}-{objective.high} {objective.unit}\")\n", + " generations(ax_measured)\n", + " ax_measured.plot(x, measured, \"o\", ms=5, color=\"tab:blue\", alpha=0.7, label=\"trial\")\n", + " ax_measured.plot(best_trial, result.best[\"measured\"][objective.name], \"*\",\n", + " ms=18, color=\"tab:red\", label=\"best\", zorder=5)\n", + " baseline = spec.baseline.get(\"measured\", {}).get(objective.name)\n", + " if baseline is not None:\n", + " ax_measured.axhline(baseline, color=\"0.4\", ls=\":\", lw=1.2,\n", + " label=f\"baseline {baseline:.3g}\")\n", + " ax_measured.set_ylabel(f\"{objective.name.split('.')[-1]} [{objective.unit}]\")\n", + " ax_measured.set_title(\"Measured value per trial\")\n", + " ax_measured.legend(fontsize=8, loc=\"best\")\n", + "\n", + " generations(ax_fitness)\n", + " ax_fitness.plot(x, fitness, \"o\", ms=4, color=\"0.6\", alpha=0.7, label=\"trial\")\n", + " ax_fitness.step(x, best_so_far, where=\"post\", color=\"tab:red\", lw=2, label=\"best so far\")\n", + " ax_fitness.axhline(0.0, color=\"tab:green\", lw=1.2, ls=\"--\", label=\"0 = inside the band\")\n", + " ax_fitness.set_xlabel(\"trial\")\n", + " ax_fitness.set_ylabel(f\"distance from target [{objective.unit}]\"\n", + " if objective.unit else \"distance from target\")\n", + " ax_fitness.set_title(\"Distance from the target band - raw, in the objective's \"\n", + " \"own unit - smaller is better\")\n", + " ax_fitness.legend(fontsize=8, loc=\"best\")\n", + "\n", + " points = None\n", + " for ax, dimension in zip(dim_axes, dims):\n", + " values = [t[\"params\"][dimension.address] for t in scored]\n", + " points = ax.scatter(x, values, c=fitness, cmap=\"viridis_r\", s=28)\n", + " ax.plot(best_trial, result.best[\"params\"][dimension.address], \"*\",\n", + " ms=16, color=\"tab:red\", zorder=5)\n", + " ax.set_ylim(dimension.low, dimension.high)\n", + " ax.set_xlabel(\"trial\")\n", + " ax.set_title(dimension.address.split(\".\", 1)[1] +\n", + " (f\" [{dimension.unit}]\" if dimension.unit else \"\"), fontsize=9)\n", + " if points is not None:\n", + " fig.colorbar(points, ax=dim_axes, fraction=0.03, pad=0.02,\n", + " label=f\"distance from target [{objective.unit}]\"\n", + " if objective.unit else \"distance from target\")\n", + "\n", + " fig.suptitle(f\"{result.run_id} - {result.stop_reason}\", fontsize=11)\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "d1bccec4", + "metadata": {}, + "source": [ + "## 9. Adopt the winner" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "bd579c07", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: inh\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/net_opt/optimization/opt_20260907_094910/trials/0008/network\n", + "2026-09-07 09:49:24,693 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:24,701 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:24,705 [INFO] Batch processing nodes for inh/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for inh/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:24,717 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:24,719 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:24,721 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:24,726 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:24,732 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:24,776 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 09:49:24,802 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + "syn_weight = 7.098638567167976\n", + "I_e = 393.42826106245246\n", + "firing rate = {'exc': 28.0, 'inh': 28.0}\n" + ] + } + ], + "source": [ + "result.apply_best(workflow, execute=True)\n", + "print(\"syn_weight =\", conn._parameters[\"syn_weight\"])\n", + "print(\"I_e =\", exc._parameters[\"nest_params\"][\"I_e\"])\n", + "print(\"firing rate =\", ana._output_ports[\"firing_rate_hz\"].value)" + ] + }, + { + "cell_type": "markdown", + "id": "e57b8068", + "metadata": {}, + "source": [ + "## Notes\n", + "\n", + "- **Every trial rebuilt the network**, unlike the single-cell notebook. That is the honest cost of\n", + " tuning something written into the SONATA files: each candidate is a different network. The\n", + " signature check is still doing its job — it correctly says \"this changed\".\n", + "- **Only the excitatory projections were tuned**, because the inhibitory ones set their own\n", + " `syn_weight` and a per-connection value overrides the node default.\n", + "- **`inh` was unaffected by the declarations on `exc`**, since each node instance owns its\n", + " definition.\n", + "- If the search pins against `syn_weight = 30` or `0`, widen the range; the target band may be\n", + " unreachable with the fixed inhibitory weight." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d20e8b09-1416-415e-a12a-fa5eb1a9f77b", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9a59cbc8-d3eb-4e91-bbd4-e24f2b995d04", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1e4f9938-0d1a-4942-84fb-db6939bc3436", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.12.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/NW_SingleCell_Optimization.ipynb b/notebooks/NW_SingleCell_Optimization.ipynb new file mode 100644 index 00000000..7016a210 --- /dev/null +++ b/notebooks/NW_SingleCell_Optimization.ipynb @@ -0,0 +1,7425 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e64e7184", + "metadata": {}, + "source": [ + "# NeuroWorkflow: optimizing a single point neuron\n", + "\n", + "Same graph as `NW_SingleCell_PointNeuron.ipynb` — `NW_IClamp → NW_Population → NW_SimConfig → NW_Analysis` —\n", + "but an optimizer drives the re-runs instead of editing values by hand.\n", + "\n", + "```\n", + "ask → configure → workflow.execute() → read firing rate → fitness → tell\n", + "```\n", + "\n", + "The workflow is the objective function. It is built **once** and reconfigured between trials,\n", + "exactly like the manual re-run cells in the original notebook.\n", + "\n", + "**Naming.** Each node's variable is given the same word as its instance name — `clamp = NW_IClamp(\"clamp\")` —\n", + "because that is what code generation emits (`var_name = instance_name`). One word then serves as the\n", + "variable, the instance name, and the prefix of every address." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "da4f9d56", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "\n", + "# Prefer this repository's sources over any previously installed copy:\n", + "# neuroworkflow.optimization is new and an older install would not have it.\n", + "sys.path.insert(0, os.path.abspath('../src'))\n", + "\n", + "from neuroworkflow import WorkflowBuilder\n", + "from neuroworkflow.nodes.network.NW_Population import NW_Population\n", + "from neuroworkflow.nodes.simulation.NW_SimConfig import NW_SimConfig\n", + "from neuroworkflow.nodes.analysis.NW_Analysis import NW_Analysis\n", + "from neuroworkflow.nodes.stimulus.NW_IClamp import NW_IClamp\n", + "\n", + "from neuroworkflow.optimization import AlgorithmConfig, build_spec, optimize" + ] + }, + { + "cell_type": "markdown", + "id": "3b0b41dd", + "metadata": {}, + "source": [ + "## 1. Create the nodes\n", + "\n", + "The string passed to the constructor is the node's **instance name**. Keep the variable identical\n", + "to it: that is what the generated code does, and it means an address like `exc.nest_params.V_th`\n", + "reads the same whether you are looking at the notebook or at a generated script." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e5de1f15", + "metadata": {}, + "outputs": [], + "source": [ + "clamp = NW_IClamp(\"clamp\")\n", + "exc = NW_Population(\"exc\")\n", + "sim = NW_SimConfig(\"sim\")\n", + "ana = NW_Analysis(\"ana\")" + ] + }, + { + "cell_type": "markdown", + "id": "6ee2e70e", + "metadata": {}, + "source": [ + "## 2. Configure each node\n", + "\n", + "Same values as the single-cell notebook, with one addition: `I_e` is included in `nest_params`.\n", + "It is not in the node's declared default, but tunable keys are read from the node's **live**\n", + "value, so configuring it here is enough to make it optimizable later." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6742a980", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "exc.configure(\n", + " pop_name = \"v1\",\n", + " N = 1,\n", + " model_type = \"point_neuron\",\n", + " model_template = \"nest:iaf_psc_alpha\",\n", + " ei_type = \"exc\",\n", + " location = \"VISp\",\n", + " layer = \"L4\",\n", + " nest_params = {\n", + " \"C_m\": 250.0, # pF\n", + " \"tau_m\": 10.0, # ms\n", + " \"t_ref\": 2.0, # ms\n", + " \"V_th\": -55.0, # mV\n", + " \"V_reset\": -70.0, # mV\n", + " \"E_L\": -70.0, # mV\n", + " \"I_e\": 0.0, # pA <- added here, not in the node's default dict\n", + " },\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "353f4745", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "clamp.configure(amp_na=0.150, delay_ms=500.0, duration_ms=2000.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "47ed0757", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sim.configure(\n", + " simulator = \"pointnet\",\n", + " config_file = \"config_opt.json\",\n", + " tstop_ms = 3000.0,\n", + " dt_ms = 0.1,\n", + " reports = {\n", + " \"v_report\": {\n", + " \"variable_name\": \"V_m\",\n", + " \"cells\": \"all\",\n", + " \"module\": \"membrane_report\",\n", + " \"sections\": \"soma\",\n", + " }\n", + " },\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "69b1926b", + "metadata": {}, + "source": [ + "## 3. Build the workflow\n", + "\n", + "Built once. Every optimization trial reconfigures and re-executes this same object — it is\n", + "never rebuilt, the same pattern as the manual re-run cells in the original notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "57202066", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "nodes: ['clamp', 'exc', 'sim', 'ana']\n" + ] + } + ], + "source": [ + "wf = WorkflowBuilder(\"NW_SingleCell_Optimization\")\n", + "for node in [clamp, exc, sim, ana]:\n", + " wf.add_node(node)\n", + "\n", + "wf.connect(\"clamp\", \"iclamp\", \"exc\", \"iclamp\")\n", + "wf.connect(\"exc\", \"population\", \"sim\", \"populations\")\n", + "wf.connect(\"sim\", \"results\", \"ana\", \"results\")\n", + "\n", + "wf.context[\"results_path\"] = \"./results/opt_singlecell\"\n", + "\n", + "workflow = wf.build()\n", + "print(\"nodes:\", list(workflow.nodes))" + ] + }, + { + "cell_type": "markdown", + "id": "63b112d2", + "metadata": {}, + "source": [ + "## 4. Where an address comes from\n", + "\n", + "The optimizer refers to everything by dotted address, and both kinds start with the **node's\n", + "instance name**:\n", + "\n", + "| kind | shape | example |\n", + "|---|---|---|\n", + "| what to tune | `node.parameter[.key]` | `exc.nest_params.V_th` |\n", + "| what to measure | `node.output_port[.key]` | `ana.firing_rate_hz.v1` |\n", + "\n", + "Reading `ana.firing_rate_hz.v1` piece by piece:\n", + "\n", + "- `ana` — the **instance name**, from `NW_Analysis(\"ana\")`, readable as `ana.name`.\n", + "- `firing_rate_hz` — an **output port** of that node.\n", + "- `v1` — a **key inside that port's dict**. It is the population name, so it comes from\n", + " `exc.configure(pop_name=...)`. Change `pop_name` and this key changes with it.\n", + "\n", + "The cell below prints all three sources, so nothing has to be guessed." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "75e32e8b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "clamp outputs: ['iclamp']\n", + "exc outputs: ['population']\n", + "sim outputs: ['results']\n", + "ana outputs: ['figures', 'firing_rate_hz', 'isi_stats']\n", + "\n", + "pop_name = v1 -> the key inside ana.firing_rate_hz\n" + ] + } + ], + "source": [ + "for node in [clamp, exc, sim, ana]:\n", + " print(f\"{node.name:<6} outputs: {list(node._output_ports)}\")\n", + "\n", + "print(\"\\npop_name =\", exc._parameters[\"pop_name\"],\n", + " \" -> the key inside ana.firing_rate_hz\")" + ] + }, + { + "cell_type": "markdown", + "id": "ff200918", + "metadata": {}, + "source": [ + "## 5. Declare what to optimize\n", + "\n", + "`optimizable`, `optimization_range`, `unit`, `is_objective`, `objective_range` and `measures`\n", + "are **schema** fields, so they are set on the parameter definitions — `configure()` only writes\n", + "values. This is the same information the GUI stores per node when you tick *optimizable* or\n", + "type a target range in the node panel.\n", + "\n", + "Each node carries its own copy of its definition, so setting these here affects only this node.\n", + "The target below overrides whatever `NW_Population.py` declares.\n", + "\n", + "**Handle naming: `__`.** It cannot collide (parameter names are unique\n", + "per node, instance names unique per workflow), it cannot shadow a module or keyword — `nest` would\n", + "have shadowed the NEST module — and it stays readable when there are several targets." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e21801c8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "target measures: ana.firing_rate_hz.v1\n" + ] + } + ], + "source": [ + "# A handle is a reference to the node's own parameter definition, not a copy —\n", + "# assigning through it edits that node's schema.\n", + "\n", + "# --- what to explore -------------------------------------------------------\n", + "explore_clamp_amp_na = clamp.NODE_DEFINITION.parameters[\"amp_na\"]\n", + "explore_clamp_amp_na.optimizable = True\n", + "explore_clamp_amp_na.optimization_range = [0.0, 800.0] # scalar -> [min, max]\n", + "explore_clamp_amp_na.unit = \"nA\"\n", + "\n", + "explore_exc_nest_params = exc.NODE_DEFINITION.parameters[\"nest_params\"]\n", + "explore_exc_nest_params.optimizable = True\n", + "explore_exc_nest_params.optimization_range = { # dict -> a range per key\n", + " \"I_e\": [0.0, 800.0], # pA\n", + " \"V_th\": [-60.0, -45.0], # mV\n", + "}\n", + "\n", + "# --- what to optimize -----------------------------------------------------------\n", + "target_exc_mean_firing_rate = exc.NODE_DEFINITION.parameters[\"mean_firing_rate\"]\n", + "target_exc_mean_firing_rate.default_value = 10.0 # the desired value\n", + "target_exc_mean_firing_rate.unit = \"Hz\"\n", + "target_exc_mean_firing_rate.is_objective = True # this parameter is a target\n", + "target_exc_mean_firing_rate.objective_range = [8.0, 12.0] # reached inside this band\n", + "target_exc_mean_firing_rate.measures = (\n", + " f\"{ana.name}.firing_rate_hz.{exc._parameters['pop_name']}\"\n", + ")\n", + "\n", + "print(\"target measures:\", target_exc_mean_firing_rate.measures)" + ] + }, + { + "cell_type": "markdown", + "id": "0c022311", + "metadata": {}, + "source": [ + "## 6. Build the spec\n", + "\n", + "The algorithm is chosen here. `cmaes` suits this problem: three continuous dimensions, one\n", + "objective, and `amp_na` and `I_e` are correlated (both inject current), which CMA-ES models and\n", + "random sampling does not. It needs `pip install optuna cmaes` — see the alternatives in the cell.\n", + "\n", + "`build_spec()` runs the workflow once at its current values. That run is the baseline every\n", + "result is compared against, and it is what each `measures` address is resolved against — a\n", + "target pointing at something that does not exist, or is not a number, is reported here rather\n", + "than failing midway through the search." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e7e75ef8", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:root:No edges have been made for this network, skipping saving of edges file.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in ./results/opt_singlecell/network\n", + "\n", + " -- N E S T --\n", + " Copyright (C) 2004 The NEST Initiative\n", + "\n", + " Version: 3.7.0\n", + " Built: Mar 4 2025 17:27:39\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", + "2026-09-07 00:21:02,939 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:02,947 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:02,948 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:02,949 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:02,951 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:02,952 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:02,955 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:02,972 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:02,983 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + "[NW_Analysis] plot_raster skipped: Could not fine spikes file with node population \"v1\".\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "measurable values found in the baseline run:\n", + " ana.firing_rate_hz.v1 0\n", + " ana.isi_stats.v1.cv 0\n", + " ana.isi_stats.v1.mean_ms 0\n", + " ana.isi_stats.v1.n_intervals 0\n", + " ana.isi_stats.v1.std_ms 0\n", + " clamp.iclamp.amp 0.15\n", + " clamp.iclamp.delay 500\n", + " clamp.iclamp.duration 2000\n", + "\n", + "algorithm : cmaes (pop_size=6, max_generations=8)\n", + "dimensions: 3\n", + " clamp.amp_na [0.0, 800.0] nA\n", + " exc.nest_params.I_e [0.0, 800.0]\n", + " exc.nest_params.V_th [-60.0, -45.0]\n", + "objectives: 1\n", + " exc.mean_firing_rate in [8.0, 12.0] Hz <- ana.firing_rate_hz.v1\n" + ] + } + ], + "source": [ + "spec = build_spec(\n", + " workflow,\n", + " algorithm=AlgorithmConfig(name=\"cmaes\", pop_size=6, max_generations=8, seed=1),\n", + "\n", + " # Other algorithms — same call, one word different:\n", + " #\n", + " # name=\"random\" no dependency at all; uniform sampling, useful as a baseline\n", + " # name=\"cmaes\" CMA-ES, single objective only; adapts to correlated parameters\n", + " # name=\"tpe\" Bayesian; pays off when each trial is expensive\n", + " # name=\"nsga2\" 2-3 objectives, returns a Pareto front (use pop_size >= 16)\n", + " # name=\"nsga3\" more than 3 objectives\n", + " #\n", + " # Everything except \"random\" needs: pip install optuna cmaes\n", + " #\n", + " # Sampler-specific settings pass straight through in `options`:\n", + " # AlgorithmConfig(name=\"cmaes\", pop_size=6, seed=1, options={\"sigma0\": 0.2})\n", + " # AlgorithmConfig(name=\"tpe\", pop_size=6, options={\"n_startup_trials\": 20})\n", + ")\n", + "\n", + "print(\"measurable values found in the baseline run:\")\n", + "for address, value in sorted(spec.baseline[\"measurables\"].items()):\n", + " print(f\" {address:<45} {value:g}\")\n", + "\n", + "print()\n", + "print(spec.summary())" + ] + }, + { + "cell_type": "markdown", + "id": "91af982b", + "metadata": {}, + "source": [ + "## 7. Run the search\n", + "\n", + "Plotting is switched off first: the firing rate is measured before the plotting blocks in\n", + "`analyze()`, so every trial is still measured while no PNGs are written.\n", + "\n", + "Every trial gets its own results directory under the run — this is the default\n", + "(`per_trial_results=True`). The `NW_*` nodes rebuild the SONATA network and rewrite `spikes.h5`\n", + "on each run, so sharing one directory would lose every trial's output and fail outright while a\n", + "handle from the previous trial is still open." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "9f20da7d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[opt_20260907_002103] cmaes: 3 dimensions, 1 objective(s), up to 8 generations x 6 candidates\n", + " algorithm : cmaes (pop_size=6, max_generations=8)\n", + " dimensions: 3\n", + " clamp.amp_na [0.0, 800.0] nA\n", + " exc.nest_params.I_e [0.0, 800.0]\n", + " exc.nest_params.V_th [-60.0, -45.0]\n", + " objectives: 1\n", + " exc.mean_firing_rate in [8.0, 12.0] Hz <- ana.firing_rate_hz.v1\n", + " reusing network from ./results/opt_singlecell\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0001/network\n", + "2026-09-07 00:21:03,398 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,402 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,404 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,405 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,405 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,406 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,408 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,427 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,439 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 1/6 (#1): clamp.amp_na=333.6 nA exc.nest_params.I_e=576.3 exc.nest_params.V_th=-60 -> mean_firing_rate=169 Hz (off 157 Hz) <- best so far\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0002/network\n", + "2026-09-07 00:21:03,450 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,454 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,455 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,455 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,457 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,457 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,460 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,479 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,490 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 2/6 (#2): clamp.amp_na=241.9 nA exc.nest_params.I_e=117.4 exc.nest_params.V_th=-58.61 -> mean_firing_rate=37.33 Hz (off 25.33 Hz) <- best so far\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0003/network\n", + "2026-09-07 00:21:03,504 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,543 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,544 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,545 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,547 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,547 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,550 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,570 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,583 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 3/6 (#3): clamp.amp_na=149 nA exc.nest_params.I_e=276.4 exc.nest_params.V_th=-54.05 -> mean_firing_rate=22.33 Hz (off 10.33 Hz) <- best so far\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0004/network\n", + "2026-09-07 00:21:03,594 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,597 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,599 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,600 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,601 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,601 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,604 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,622 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,633 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 4/6 (#4): clamp.amp_na=431.1 nA exc.nest_params.I_e=335.4 exc.nest_params.V_th=-49.72 -> mean_firing_rate=51.67 Hz (off 39.67 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0005/network\n", + "2026-09-07 00:21:03,644 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,648 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,650 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,651 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,652 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,653 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,655 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,674 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,686 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 5/6 (#5): clamp.amp_na=163.6 nA exc.nest_params.I_e=702.5 exc.nest_params.V_th=-59.59 -> mean_firing_rate=168.7 Hz (off 156.7 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0006/network\n", + "2026-09-07 00:21:03,697 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,700 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,702 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,703 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,704 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,704 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,707 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,725 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,737 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 6/6 (#6): clamp.amp_na=536.4 nA exc.nest_params.I_e=333.8 exc.nest_params.V_th=-51.62 -> mean_firing_rate=69.67 Hz (off 57.67 Hz)\n", + " gen 1/8: best clamp.amp_na=149 nA exc.nest_params.I_e=276.4 exc.nest_params.V_th=-54.05 -> mean_firing_rate=22.33 Hz [target 8.0-12.0 Hz, off 10.33 Hz]\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0007/network\n", + "2026-09-07 00:21:03,755 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,759 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,760 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,761 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,762 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,763 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,766 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,785 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,796 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 1/6 (#7): clamp.amp_na=334.1 nA exc.nest_params.I_e=491.1 exc.nest_params.V_th=-53.2 -> mean_firing_rate=88 Hz (off 76 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0008/network\n", + "2026-09-07 00:21:03,807 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,811 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,812 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,813 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,815 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,815 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,818 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,837 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,848 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 2/6 (#8): clamp.amp_na=459.4 nA exc.nest_params.I_e=362.6 exc.nest_params.V_th=-57.19 -> mean_firing_rate=109.3 Hz (off 97.33 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0009/network\n", + "2026-09-07 00:21:03,859 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,863 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,864 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,865 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,866 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,867 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,870 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,888 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,899 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 3/6 (#9): clamp.amp_na=312.5 nA exc.nest_params.I_e=408.2 exc.nest_params.V_th=-50.88 -> mean_firing_rate=51.67 Hz (off 39.67 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0010/network\n", + "2026-09-07 00:21:03,911 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,915 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,916 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,918 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,919 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,920 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,922 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,940 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,952 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 4/6 (#10): clamp.amp_na=206.3 nA exc.nest_params.I_e=412.7 exc.nest_params.V_th=-51.63 -> mean_firing_rate=43 Hz (off 31 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0011/network\n", + "2026-09-07 00:21:03,962 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,966 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,967 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,968 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,969 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,970 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,972 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:03,991 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,003 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 5/6 (#11): clamp.amp_na=188.5 nA exc.nest_params.I_e=483.7 exc.nest_params.V_th=-50.93 -> mean_firing_rate=53.67 Hz (off 41.67 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0012/network\n", + "2026-09-07 00:21:04,014 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,019 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,020 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,021 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,022 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,022 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,025 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,044 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,056 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 6/6 (#12): clamp.amp_na=479.5 nA exc.nest_params.I_e=440.7 exc.nest_params.V_th=-56.5 -> mean_firing_rate=121 Hz (off 109 Hz)\n", + " gen 2/8: best clamp.amp_na=149 nA exc.nest_params.I_e=276.4 exc.nest_params.V_th=-54.05 -> mean_firing_rate=22.33 Hz [target 8.0-12.0 Hz, off 10.33 Hz]\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0013/network\n", + "2026-09-07 00:21:04,070 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,074 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,076 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,077 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,078 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,078 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,081 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,100 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,112 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 1/6 (#13): clamp.amp_na=460.7 nA exc.nest_params.I_e=316 exc.nest_params.V_th=-49.29 -> mean_firing_rate=51.33 Hz (off 39.33 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0014/network\n", + "2026-09-07 00:21:04,127 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,130 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,131 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,132 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,134 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,135 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,137 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,156 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,167 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 2/6 (#14): clamp.amp_na=623.8 nA exc.nest_params.I_e=404.7 exc.nest_params.V_th=-52.83 -> mean_firing_rate=89 Hz (off 77 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0015/network\n", + "2026-09-07 00:21:04,179 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,182 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,184 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,185 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,186 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,187 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,189 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,208 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,222 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 3/6 (#15): clamp.amp_na=326.6 nA exc.nest_params.I_e=276.8 exc.nest_params.V_th=-55.24 -> mean_firing_rate=58 Hz (off 46 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0016/network\n", + "2026-09-07 00:21:04,233 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,237 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,238 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,239 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,240 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,241 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,244 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,262 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,271 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 4/6 (#16): clamp.amp_na=43.5 nA exc.nest_params.I_e=379.1 exc.nest_params.V_th=-47.92 -> mean_firing_rate=0 Hz (off 8 Hz) <- best so far\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0017/network\n", + "2026-09-07 00:21:04,283 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,287 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,288 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,289 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,290 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,291 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,294 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,313 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,324 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 5/6 (#17): clamp.amp_na=373.4 nA exc.nest_params.I_e=588.6 exc.nest_params.V_th=-50.83 -> mean_firing_rate=92.33 Hz (off 80.33 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0018/network\n", + "2026-09-07 00:21:04,336 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,340 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,341 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,342 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,343 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,344 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,346 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,365 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,377 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 6/6 (#18): clamp.amp_na=269.9 nA exc.nest_params.I_e=569.8 exc.nest_params.V_th=-51.25 -> mean_firing_rate=82.33 Hz (off 70.33 Hz)\n", + " gen 3/8: best clamp.amp_na=43.5 nA exc.nest_params.I_e=379.1 exc.nest_params.V_th=-47.92 -> mean_firing_rate=0 Hz [target 8.0-12.0 Hz, off 8 Hz]\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0019/network\n", + "2026-09-07 00:21:04,394 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,397 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,399 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,400 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,401 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,402 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,404 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,423 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,434 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 1/6 (#19): clamp.amp_na=140.2 nA exc.nest_params.I_e=482.3 exc.nest_params.V_th=-48.31 -> mean_firing_rate=29.67 Hz (off 17.67 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0020/network\n", + "2026-09-07 00:21:04,445 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,449 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,450 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,452 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,453 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,454 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,456 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,474 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,488 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 2/6 (#20): clamp.amp_na=168.5 nA exc.nest_params.I_e=322.5 exc.nest_params.V_th=-51.6 -> mean_firing_rate=22.33 Hz (off 10.33 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0021/network\n", + "2026-09-07 00:21:04,499 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,503 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,505 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,506 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,507 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,508 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,511 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,531 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,544 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 3/6 (#21): clamp.amp_na=513.6 nA exc.nest_params.I_e=453.4 exc.nest_params.V_th=-50.44 -> mean_firing_rate=73.33 Hz (off 61.33 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0022/network\n", + "2026-09-07 00:21:04,555 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,559 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,561 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,562 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,563 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,564 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,568 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,587 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,598 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 4/6 (#22): clamp.amp_na=240.4 nA exc.nest_params.I_e=345.4 exc.nest_params.V_th=-51.23 -> mean_firing_rate=36.67 Hz (off 24.67 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0023/network\n", + "2026-09-07 00:21:04,607 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,611 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,613 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,614 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,615 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,616 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,619 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,639 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,651 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 5/6 (#23): clamp.amp_na=343.5 nA exc.nest_params.I_e=435.4 exc.nest_params.V_th=-51.72 -> mean_firing_rate=61.33 Hz (off 49.33 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0024/network\n", + "2026-09-07 00:21:04,662 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,666 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,667 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,669 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,670 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,671 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,674 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,693 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,704 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 6/6 (#24): clamp.amp_na=306 nA exc.nest_params.I_e=461.9 exc.nest_params.V_th=-50.18 -> mean_firing_rate=54 Hz (off 42 Hz)\n", + " gen 4/8: best clamp.amp_na=43.5 nA exc.nest_params.I_e=379.1 exc.nest_params.V_th=-47.92 -> mean_firing_rate=0 Hz [target 8.0-12.0 Hz, off 8 Hz]\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0025/network\n", + "2026-09-07 00:21:04,719 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,722 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,724 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,725 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,726 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,727 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,730 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,749 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,761 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 1/6 (#25): clamp.amp_na=443.2 nA exc.nest_params.I_e=643.2 exc.nest_params.V_th=-51.31 -> mean_firing_rate=108.7 Hz (off 96.67 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0026/network\n", + "2026-09-07 00:21:04,770 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,773 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,775 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,776 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,777 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,778 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,780 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,799 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,810 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 2/6 (#26): clamp.amp_na=366.7 nA exc.nest_params.I_e=454.9 exc.nest_params.V_th=-54.35 -> mean_firing_rate=93.67 Hz (off 81.67 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0027/network\n", + "2026-09-07 00:21:04,819 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,823 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,825 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,826 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,827 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,828 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,830 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,849 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,861 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 3/6 (#27): clamp.amp_na=191.4 nA exc.nest_params.I_e=498.1 exc.nest_params.V_th=-51.63 -> mean_firing_rate=63.33 Hz (off 51.33 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0028/network\n", + "2026-09-07 00:21:04,871 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,875 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,877 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,878 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,879 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,880 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,883 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,902 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,914 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 4/6 (#28): clamp.amp_na=136 nA exc.nest_params.I_e=323 exc.nest_params.V_th=-52.08 -> mean_firing_rate=17 Hz (off 5 Hz) <- best so far\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0029/network\n", + "2026-09-07 00:21:04,927 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,930 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,932 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,933 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,935 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,935 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,938 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,957 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,969 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 5/6 (#29): clamp.amp_na=178.8 nA exc.nest_params.I_e=347.5 exc.nest_params.V_th=-53.38 -> mean_firing_rate=38 Hz (off 26 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0030/network\n", + "2026-09-07 00:21:04,981 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,985 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,987 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,988 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,989 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,990 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:04,993 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,012 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,027 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 6/6 (#30): clamp.amp_na=291.7 nA exc.nest_params.I_e=389.9 exc.nest_params.V_th=-54.56 -> mean_firing_rate=71 Hz (off 59 Hz)\n", + " gen 5/8: best clamp.amp_na=136 nA exc.nest_params.I_e=323 exc.nest_params.V_th=-52.08 -> mean_firing_rate=17 Hz [target 8.0-12.0 Hz, off 5 Hz]\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0031/network\n", + "2026-09-07 00:21:05,045 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,049 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,051 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,052 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,053 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,054 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,056 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,075 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,085 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 1/6 (#31): clamp.amp_na=166.9 nA exc.nest_params.I_e=353.2 exc.nest_params.V_th=-46.26 -> mean_firing_rate=0 Hz (off 8 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0032/network\n", + "2026-09-07 00:21:05,097 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,101 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,102 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,103 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,104 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,105 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,108 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,127 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,137 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 2/6 (#32): clamp.amp_na=120.7 nA exc.nest_params.I_e=209.2 exc.nest_params.V_th=-49 -> mean_firing_rate=0 Hz (off 8 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0033/network\n", + "2026-09-07 00:21:05,148 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,152 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,154 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,155 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,156 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,157 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,160 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,178 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,188 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 3/6 (#33): clamp.amp_na=157.9 nA exc.nest_params.I_e=312 exc.nest_params.V_th=-48.99 -> mean_firing_rate=0 Hz (off 8 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0034/network\n", + "2026-09-07 00:21:05,199 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,203 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,205 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,206 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,207 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,208 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,211 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,230 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,241 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 4/6 (#34): clamp.amp_na=305.8 nA exc.nest_params.I_e=509.2 exc.nest_params.V_th=-48.92 -> mean_firing_rate=53.33 Hz (off 41.33 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0035/network\n", + "2026-09-07 00:21:05,253 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,257 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,259 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,260 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,262 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,262 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,265 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,283 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,293 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 5/6 (#35): clamp.amp_na=145.7 nA exc.nest_params.I_e=177.1 exc.nest_params.V_th=-51.25 -> mean_firing_rate=0 Hz (off 8 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0036/network\n", + "2026-09-07 00:21:05,305 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,309 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,311 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,312 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,313 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,314 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,317 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,336 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,347 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 6/6 (#36): clamp.amp_na=166.4 nA exc.nest_params.I_e=442.6 exc.nest_params.V_th=-50.24 -> mean_firing_rate=35.67 Hz (off 23.67 Hz)\n", + " gen 6/8: best clamp.amp_na=136 nA exc.nest_params.I_e=323 exc.nest_params.V_th=-52.08 -> mean_firing_rate=17 Hz [target 8.0-12.0 Hz, off 5 Hz]\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0037/network\n", + "2026-09-07 00:21:05,363 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,367 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,369 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,370 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,372 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,372 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,375 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,394 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,406 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 7, trial 1/6 (#37): clamp.amp_na=362.4 nA exc.nest_params.I_e=507.3 exc.nest_params.V_th=-53.37 -> mean_firing_rate=94.67 Hz (off 82.67 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0038/network\n", + "2026-09-07 00:21:05,418 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,422 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,423 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,424 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,426 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,427 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,430 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,448 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,461 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 7, trial 2/6 (#38): clamp.amp_na=181.2 nA exc.nest_params.I_e=491.8 exc.nest_params.V_th=-49.82 -> mean_firing_rate=42 Hz (off 30 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0039/network\n", + "2026-09-07 00:21:05,482 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,486 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,488 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,489 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,490 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,491 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,494 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,513 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,524 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 7, trial 3/6 (#39): clamp.amp_na=221.9 nA exc.nest_params.I_e=319.4 exc.nest_params.V_th=-48.07 -> mean_firing_rate=0 Hz (off 8 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0040/network\n", + "2026-09-07 00:21:05,535 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,540 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,541 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,543 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,544 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,545 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,548 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,566 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,579 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 7, trial 4/6 (#40): clamp.amp_na=310.5 nA exc.nest_params.I_e=311.4 exc.nest_params.V_th=-49.57 -> mean_firing_rate=34.67 Hz (off 22.67 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0041/network\n", + "2026-09-07 00:21:05,590 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,594 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,596 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,597 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,598 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,599 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,603 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,621 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,634 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 7, trial 5/6 (#41): clamp.amp_na=122 nA exc.nest_params.I_e=560.2 exc.nest_params.V_th=-50.88 -> mean_firing_rate=62.67 Hz (off 50.67 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0042/network\n", + "2026-09-07 00:21:05,644 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,648 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,650 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,652 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,653 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,654 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,658 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,677 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,689 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 7, trial 6/6 (#42): clamp.amp_na=270.8 nA exc.nest_params.I_e=250.7 exc.nest_params.V_th=-52.19 -> mean_firing_rate=31.33 Hz (off 19.33 Hz)\n", + " gen 7/8: best clamp.amp_na=136 nA exc.nest_params.I_e=323 exc.nest_params.V_th=-52.08 -> mean_firing_rate=17 Hz [target 8.0-12.0 Hz, off 5 Hz]\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0043/network\n", + "2026-09-07 00:21:05,707 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,711 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,712 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,714 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,715 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,716 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,719 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,738 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,748 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 8, trial 1/6 (#43): clamp.amp_na=20.53 nA exc.nest_params.I_e=385.6 exc.nest_params.V_th=-52.15 -> mean_firing_rate=0 Hz (off 8 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0044/network\n", + "2026-09-07 00:21:05,758 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,762 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,764 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,765 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,767 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,768 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,771 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,789 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,799 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 8, trial 2/6 (#44): clamp.amp_na=181.8 nA exc.nest_params.I_e=277.9 exc.nest_params.V_th=-45.65 -> mean_firing_rate=0 Hz (off 8 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0045/network\n", + "2026-09-07 00:21:05,811 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,815 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,816 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,818 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,819 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,820 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,823 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,842 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,854 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 8, trial 3/6 (#45): clamp.amp_na=411.8 nA exc.nest_params.I_e=343.9 exc.nest_params.V_th=-45.97 -> mean_firing_rate=37.33 Hz (off 25.33 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0046/network\n", + "2026-09-07 00:21:05,866 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,870 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,872 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,873 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,874 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,876 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,879 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,897 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,910 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 8, trial 4/6 (#46): clamp.amp_na=562.7 nA exc.nest_params.I_e=324 exc.nest_params.V_th=-51.73 -> mean_firing_rate=71.67 Hz (off 59.67 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0047/network\n", + "2026-09-07 00:21:05,921 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,927 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,929 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,930 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,932 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,932 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,936 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,955 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,964 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 8, trial 5/6 (#47): clamp.amp_na=393.3 nA exc.nest_params.I_e=127.7 exc.nest_params.V_th=-47.11 -> mean_firing_rate=0 Hz (off 8 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0048/network\n", + "2026-09-07 00:21:05,976 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,980 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,981 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,983 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,985 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,985 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:05,988 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:06,007 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:06,020 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 8, trial 6/6 (#48): clamp.amp_na=245.1 nA exc.nest_params.I_e=429.6 exc.nest_params.V_th=-52.33 -> mean_firing_rate=52.67 Hz (off 40.67 Hz)\n", + " gen 8/8: best clamp.amp_na=136 nA exc.nest_params.I_e=323 exc.nest_params.V_th=-52.08 -> mean_firing_rate=17 Hz [target 8.0-12.0 Hz, off 5 Hz]\n", + "[opt_20260907_002103] stopped: generation budget exhausted\n", + " exc.mean_firing_rate = 17 Hz (target 8.0-12.0 Hz, off 5 Hz)\n" + ] + } + ], + "source": [ + "ana.configure(plot_raster=False, plot_traces=False)\n", + "\n", + "result = optimize(\n", + " workflow,\n", + " spec=spec,\n", + " results_path=\"./results/opt_singlecell/optimization\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "2dd68f10", + "metadata": {}, + "source": [ + "## 8. Result\n", + "\n", + "`best` is the trial closest to the target band — fitness is a distance, so **smaller is better and\n", + "0.0 means inside the band**.\n", + "\n", + "Note the search leaves the workflow holding the **last** trial's parameters, not the best ones —\n", + "the loop never writes a result back on its own, because parameters define a run. `apply_best()`\n", + "below is the deliberate step that adopts the winner." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "9e747647", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "stop reason: generation budget exhausted\n", + "run dir : results/opt_singlecell/optimization/opt_20260907_002103\n", + "\n", + "best trial: 28\n", + " clamp.amp_na 136\n", + " exc.nest_params.I_e 323\n", + " exc.nest_params.V_th -52.08\n", + " measured: {'exc.mean_firing_rate': 17.0}\n", + " distance from target (raw, per objective): [5.0]\n", + "\n", + "equivalent code:\n", + "\n", + "clamp.configure(amp_na=136.0280981926223)\n", + "exc.configure(nest_params={**exc._parameters[\"nest_params\"], \"I_e\": 323.0420933149711, \"V_th\": -52.084990627197})\n" + ] + } + ], + "source": [ + "print(\"stop reason:\", result.stop_reason)\n", + "print(\"run dir :\", result.run_dir)\n", + "\n", + "if result.best:\n", + " print(\"\\nbest trial:\", result.best[\"trial\"])\n", + " for address, value in result.best[\"params\"].items():\n", + " print(f\" {address:<34} {value:.4g}\")\n", + " print(\" measured:\", result.best[\"measured\"])\n", + " print(\" distance from target (raw, per objective):\", result.best[\"fitness\"])\n", + " print(\"\\nequivalent code:\\n\")\n", + " print(result.configure_snippet())" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "af33b70f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "state : done - generation budget exhausted\n", + "evaluations: 48 | failed: 0 | rejected: 0\n", + "convergence: [2.583333, 2.583333, 2.0, 2.0, 1.25, 1.25, 1.25, 1.25] (how far the worst objective missed, as a multiple of its target range; 0 = target met)\n" + ] + } + ], + "source": [ + "import json\n", + "\n", + "status = json.load(open(os.path.join(result.run_dir, \"status.json\")))\n", + "print(\"state :\", status[\"state\"], \"-\", status[\"stop_reason\"])\n", + "print(\"evaluations:\", status[\"n_evals\"],\n", + " \"| failed:\", status[\"n_failed\"],\n", + " \"| rejected:\", status[\"n_rejected\"])\n", + "print(\"convergence:\", status[\"progress\"][\"best_target_ranges_off_by_gen\"],\n", + " \" (how far the worst objective missed, as a multiple of its target range;\"\n", + " \" 0 = target met)\")" + ] + }, + { + "cell_type": "markdown", + "id": "6959901a", + "metadata": {}, + "source": [ + "## 9. How the search evolved\n", + "\n", + "Three views of the same run:\n", + "\n", + "1. **Measured value per trial** against the target band — did the search get inside it, and when?\n", + "2. **Fitness**, the distance from that band. Per-trial points plus the best-so-far curve, which can\n", + " only go down.\n", + "3. **Each search dimension** over the run, coloured by fitness. Dark points are good candidates, so a\n", + " dimension whose dark points cluster is one the search has settled; one whose dark points stay\n", + " scattered is a dimension the objective does not really constrain.\n", + "\n", + "Dashed vertical lines mark generation boundaries.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "46baac78", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "48 scored trials, 0 inside the target band, smallest distance 5 Hz\n" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "trials = result.trials\n", + "objective = spec.objectives[0]\n", + "scored = [t for t in trials if t[\"fitness\"] is not None]\n", + "\n", + "if not scored:\n", + " print(\"no successful trial to plot\")\n", + "else:\n", + " x = [t[\"trial\"] for t in scored]\n", + " measured = [t[\"measured\"][objective.name] for t in scored]\n", + " # One objective, so this is simply how far it missed, in its own unit.\n", + " # With several objectives use t[\"target_ranges_off\"] instead: misses in different\n", + " # units cannot be compared until each is sized against its own target range.\n", + " fitness = [t[\"fitness\"][0] for t in scored]\n", + "\n", + " best_so_far, running = [], float(\"inf\")\n", + " for value in fitness:\n", + " running = min(running, value)\n", + " best_so_far.append(running)\n", + "\n", + " best_trial = result.best[\"trial\"]\n", + " pop_size = spec.algorithm.pop_size\n", + " dims = spec.dimensions\n", + "\n", + " fig = plt.figure(figsize=(11, 9))\n", + " grid = fig.add_gridspec(3, max(len(dims), 1), hspace=0.45, wspace=0.3)\n", + " ax_measured = fig.add_subplot(grid[0, :])\n", + " ax_fitness = fig.add_subplot(grid[1, :])\n", + " dim_axes = [fig.add_subplot(grid[2, i]) for i in range(len(dims))]\n", + "\n", + " def generations(ax):\n", + " for boundary in range(pop_size, max(x) + 1, pop_size):\n", + " ax.axvline(boundary + 0.5, color=\"0.85\", lw=0.8, ls=\"--\", zorder=0)\n", + "\n", + " # 1 - measured value against the target band\n", + " ax_measured.axhspan(objective.low, objective.high, color=\"tab:green\", alpha=0.15,\n", + " label=f\"target {objective.low}-{objective.high} {objective.unit}\")\n", + " generations(ax_measured)\n", + " ax_measured.plot(x, measured, \"o\", ms=5, color=\"tab:blue\", alpha=0.7, label=\"trial\")\n", + " ax_measured.plot(best_trial, result.best[\"measured\"][objective.name], \"*\",\n", + " ms=18, color=\"tab:red\", label=\"best\", zorder=5)\n", + " baseline = spec.baseline.get(\"measured\", {}).get(objective.name)\n", + " if baseline is not None:\n", + " ax_measured.axhline(baseline, color=\"0.4\", ls=\":\", lw=1.2,\n", + " label=f\"baseline {baseline:.3g}\")\n", + " ax_measured.set_ylabel(f\"{objective.name.split('.')[-1]} [{objective.unit}]\")\n", + " ax_measured.set_title(\"Measured value per trial\")\n", + " ax_measured.legend(fontsize=8, loc=\"best\")\n", + "\n", + " # 2 - fitness: distance from the band, 0 means inside it\n", + " generations(ax_fitness)\n", + " ax_fitness.plot(x, fitness, \"o\", ms=4, color=\"0.6\", alpha=0.7, label=\"trial\")\n", + " ax_fitness.step(x, best_so_far, where=\"post\", color=\"tab:red\", lw=2, label=\"best so far\")\n", + " ax_fitness.axhline(0.0, color=\"tab:green\", lw=1.2, ls=\"--\", label=\"0 = inside the band\")\n", + " ax_fitness.set_xlabel(\"trial\")\n", + " ax_fitness.set_ylabel(f\"distance from target [{objective.unit}]\"\n", + " if objective.unit else \"distance from target\")\n", + " ax_fitness.set_title(\"Distance from the target band - raw, in the objective's \"\n", + " \"own unit - smaller is better\")\n", + " ax_fitness.legend(fontsize=8, loc=\"best\")\n", + "\n", + " # 3 - what each dimension was doing, coloured by fitness\n", + " points = None\n", + " for ax, dimension in zip(dim_axes, dims):\n", + " values = [t[\"params\"][dimension.address] for t in scored]\n", + " points = ax.scatter(x, values, c=fitness, cmap=\"viridis_r\", s=28)\n", + " ax.plot(best_trial, result.best[\"params\"][dimension.address], \"*\",\n", + " ms=16, color=\"tab:red\", zorder=5)\n", + " ax.set_ylim(dimension.low, dimension.high)\n", + " ax.set_xlabel(\"trial\")\n", + " ax.set_title(dimension.address.split(\".\", 1)[1] +\n", + " (f\" [{dimension.unit}]\" if dimension.unit else \"\"), fontsize=9)\n", + " if points is not None:\n", + " fig.colorbar(points, ax=dim_axes, fraction=0.03, pad=0.02,\n", + " label=f\"distance from target [{objective.unit}]\"\n", + " if objective.unit else \"distance from target\")\n", + "\n", + " fig.suptitle(f\"{result.run_id} - {result.stop_reason}\", fontsize=11)\n", + " plt.show()\n", + "\n", + " inside = [t for t in scored if t[\"fitness\"][0] == 0.0]\n", + " print(f\"{len(scored)} scored trials, {len(inside)} inside the target band, \"\n", + " f\"smallest distance {min(fitness):.4g} {objective.unit}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "951e377f", + "metadata": {}, + "source": [ + "## 10. Adopt the winning configuration\n", + "\n", + "`apply_best()` sets the workflow's parameters to the best trial's. With `execute=True` it also\n", + "re-runs, so the output ports match the parameters again — without it the ports would still hold\n", + "the last trial's values." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "7e2f6a95", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0048/network\n", + "2026-09-07 00:21:06,232 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:06,236 [INFO] Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:06,237 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:06,239 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:06,240 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:06,241 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:06,245 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:06,264 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-07 00:21:06,275 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + "amp_na = 136.0280981926223\n", + "nest_params = {'C_m': 250.0, 'tau_m': 10.0, 't_ref': 2.0, 'V_th': -52.084990627197, 'V_reset': -70.0, 'E_L': -70.0, 'I_e': 323.0420933149711}\n", + "firing rate = {'v1': 17.0}\n" + ] + } + ], + "source": [ + "result.apply_best(workflow, execute=True)\n", + "\n", + "print(\"amp_na =\", clamp._parameters[\"amp_na\"])\n", + "print(\"nest_params =\", exc._parameters[\"nest_params\"])\n", + "print(\"firing rate =\", ana._output_ports[\"firing_rate_hz\"].value)" + ] + }, + { + "cell_type": "markdown", + "id": "3f8a51f3", + "metadata": {}, + "source": [ + "## Notes\n", + "\n", + "- **The workflow was never rebuilt** — every trial is `configure()` + `execute()` on the same\n", + " built workflow.\n", + "- **`I_e` was tunable without touching the node file** — tunable keys come from the live value.\n", + "- **The address is built from live values** (`ana.name`, `pop_name`), so renaming the node or\n", + " the population keeps it correct.\n", + "- **The ranges are first guesses.** If every trial reports 0 Hz the cell never reached\n", + " threshold — widen `amp_na` / `I_e`. If the target is hit immediately, narrow the band." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "284a5f68-1243-49ee-8a53-1162f8b73d62", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "87c9b1b5-d011-4fad-aaeb-5d61d4e1d184", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8566a1f8-6558-4aec-a54d-4cba7c486825", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a1bc27e1-d122-4613-aff5-befa83eb0c87", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.12.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/generated_multiobjective_example.ipynb b/notebooks/generated_multiobjective_example.ipynb new file mode 100644 index 00000000..494902b7 --- /dev/null +++ b/notebooks/generated_multiobjective_example.ipynb @@ -0,0 +1,11286 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\"\\nGenerated workflow for project: Network and probe, two objectives\\n\\nSame shape as generated_optimization_example.py, with two differences that matter:\\n\\n * a second population, `probe`: a SINGLE inhibitory neuron that fires from its own\\n injected current and presses down on the network. It receives nothing from the\\n network - it is a tonic source of inhibition, not a read-out.\\n\\n clamp --> exc --> exc drive and recurrent excitation, both fixed\\n ^\\n +---- probe inhibition, negative weight\\n\\n * TWO objectives, so there is no single best answer. NSGA-II returns a Pareto front:\\n the set of configurations where improving one objective costs the other.\\n\\n 1. the network's firing rate ana.firing_rate_hz.exc\\n 2. the probe's mean inter-spike interval ana.isi_stats.probe.mean_ms\\n\\nWhy these two compete: the probe's own I_e and tau_m decide how fast it fires, which\\ndecides how much inhibition the network receives, which decides the network's rate.\\nTwo knobs, two targets, one causal path between them.\\n\\nFour dimensions: the drive, the recurrent excitatory weight, and the probe's I_e and\\ntau_m. The probe's two are read at simulation time, but the recurrent weight is written\\ninto the SONATA edge files - so every trial rebuilds the network.\\n\\nThe probe's inhibition of the network is fixed at -60 pA, so what the search controls\\nis how hard the network is driven and how fast the probe fires against it.\\n\\nRun it directly:\\n\\n python generated_multiobjective_example.py\\n\\nNeeds Optuna: pip install optuna cmaes\\n\"" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#!/usr/bin/env python3\n", + "\"\"\"\n", + "Generated workflow for project: Network and probe, two objectives\n", + "\n", + "Same shape as generated_optimization_example.py, with two differences that matter:\n", + "\n", + " * a second population, `probe`: a SINGLE inhibitory neuron that fires from its own\n", + " injected current and presses down on the network. It receives nothing from the\n", + " network - it is a tonic source of inhibition, not a read-out.\n", + "\n", + " clamp --> exc --> exc drive and recurrent excitation, both fixed\n", + " ^\n", + " +---- probe inhibition, negative weight\n", + "\n", + " * TWO objectives, so there is no single best answer. NSGA-II returns a Pareto front:\n", + " the set of configurations where improving one objective costs the other.\n", + "\n", + " 1. the network's firing rate ana.firing_rate_hz.exc\n", + " 2. the probe's mean inter-spike interval ana.isi_stats.probe.mean_ms\n", + "\n", + "Why these two compete: the probe's own I_e and tau_m decide how fast it fires, which\n", + "decides how much inhibition the network receives, which decides the network's rate.\n", + "Two knobs, two targets, one causal path between them.\n", + "\n", + "Four dimensions: the drive, the recurrent excitatory weight, and the probe's I_e and\n", + "tau_m. The probe's two are read at simulation time, but the recurrent weight is written\n", + "into the SONATA edge files - so every trial rebuilds the network.\n", + "\n", + "The probe's inhibition of the network is fixed at -60 pA, so what the search controls\n", + "is how hard the network is driven and how fast the probe fires against it.\n", + "\n", + "Run it directly:\n", + "\n", + " python generated_multiobjective_example.py\n", + "\n", + "Needs Optuna: pip install optuna cmaes\n", + "\"\"\"\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "import os\n", + "import numpy as np\n", + "\n", + "# Add paths for JupyterLab environment\n", + "sys.path.append('../../')\n", + "\n", + "from neuroworkflow.core.workflow import WorkflowBuilder\n", + "\n", + "from neuroworkflow.nodes.stimulus.NW_IClamp import NW_IClamp\n", + "from neuroworkflow.nodes.network.NW_Population import NW_Population\n", + "from neuroworkflow.nodes.network.NW_Connectivity import NW_Connectivity\n", + "from neuroworkflow.nodes.simulation.NW_SimConfig import NW_SimConfig\n", + "from neuroworkflow.nodes.analysis.NW_Analysis import NW_Analysis\n", + "from neuroworkflow.nodes.optimization.NW_Optimization import NW_Optimization\n", + "\n", + "from neuroworkflow.optimization import build_spec, optimize\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def main():\n", + " \"\"\"Optimize a neural simulation workflow against two objectives.\"\"\"\n", + "\n", + " # workflow_builder creation\n", + " workflow_builder = WorkflowBuilder(\n", + " \"Network_and_probe\",\n", + " context={\n", + " \"results_path\": \"./results/multiobjective_example\"\n", + " }\n", + " )\n", + "\n", + " # Create nodes\n", + "\n", + " # Stimulus\n", + " clamp = NW_IClamp(\"clamp\")\n", + " clamp.configure(\n", + " amp_na=200.0,\n", + " delay_ms=50.0,\n", + " duration_ms=450.0\n", + " )\n", + "\n", + " # Network\n", + " exc = NW_Population(\"exc\")\n", + " exc.configure(\n", + " pop_name='exc',\n", + " N=20,\n", + " model_type='point_neuron',\n", + " model_template='nest:iaf_psc_alpha',\n", + " ei_type='exc',\n", + " location='VISp',\n", + " layer='L4',\n", + " nest_params={'C_m': 250.0, 'tau_m': 10.0, 't_ref': 2.0, 'V_th': -55.0, 'V_reset': -70.0, 'E_L': -70.0, 'I_e': 0.0}\n", + " )\n", + "\n", + " # A single inhibitory neuron. It receives nothing from the network: its firing comes\n", + " # from its own injected current, and it inhibits the network. I_e and tau_m are the\n", + " # two tuned values, so they set both how fast it fires and how hard it inhibits.\n", + " probe = NW_Population(\"probe\")\n", + " probe.configure(\n", + " pop_name='probe',\n", + " N=1,\n", + " model_type='point_neuron',\n", + " model_template='nest:iaf_psc_alpha',\n", + " ei_type='inh',\n", + " location='VISp',\n", + " layer='L4',\n", + " nest_params={'C_m': 250.0, 'tau_m': 10.0, 't_ref': 2.0, 'V_th': -55.0, 'V_reset': -70.0, 'E_L': -70.0, 'I_e': 200.0}\n", + " )\n", + "\n", + " # E->E does not set its own weight, so it inherits the node-level syn_weight - the\n", + " # value the search tunes, i.e. the strength of recurrent excitation. probe->exc\n", + " # carries its own, fixed: a negative weight is what makes a synapse inhibitory in\n", + " # NEST; ei_type is metadata carried into SONATA, not what inhibits.\n", + " conn = NW_Connectivity(\"conn\")\n", + " conn.configure(\n", + " connection_rule=1,\n", + " syn_weight=5.0,\n", + " connections=[\n", + " {'source': 'exc', 'target': 'exc'},\n", + " {'source': 'probe', 'target': 'exc', 'syn_weight': -60.0}\n", + " ]\n", + " )\n", + "\n", + " # Simulation\n", + " sim = NW_SimConfig(\"sim\")\n", + " sim.configure(\n", + " simulator='pointnet',\n", + " config_file='config_multiobjective_example.json',\n", + " tstop_ms=500.0,\n", + " dt_ms=0.1\n", + " )\n", + "\n", + " # Analysis\n", + " ana = NW_Analysis(\"ana\")\n", + " ana.configure(\n", + " plot_raster=False,\n", + " plot_traces=False\n", + " )\n", + "\n", + " # Optimization\n", + " # Not added to the workflow: it declares how to search, and takes no part in the\n", + " # workflow's own execution. Two objectives require a multi-objective algorithm;\n", + " # a single-objective one refuses rather than inventing weights between them.\n", + " opt = NW_Optimization(\"opt\")\n", + " opt.configure(\n", + " algorithm='nsga2',\n", + " pop_size=12,\n", + " max_generations=6,\n", + " seed=1,\n", + " results_path='./results/multiobjective_example/optimization'\n", + " )\n", + "\n", + " # workflow_builder_ready\n", + " workflow_builder.add_node(clamp)\n", + " workflow_builder.add_node(exc)\n", + " workflow_builder.add_node(probe)\n", + " workflow_builder.add_node(conn)\n", + " workflow_builder.add_node(sim)\n", + " workflow_builder.add_node(ana)\n", + "\n", + " workflow_builder.connect(\"clamp\", \"iclamp\", \"exc\", \"iclamp\")\n", + " workflow_builder.connect(\"exc\", \"population\", \"conn\", \"populations\")\n", + " workflow_builder.connect(\"probe\", \"population\", \"conn\", \"populations\")\n", + " workflow_builder.connect(\"conn\", \"network\", \"sim\", \"populations\")\n", + " workflow_builder.connect(\"sim\", \"results\", \"ana\", \"results\")\n", + "\n", + " workflow = workflow_builder.build()\n", + "\n", + " # Print workflow information\n", + " print(workflow)\n", + "\n", + " # Parameters marked optimizable in the editor\n", + " clamp.NODE_DEFINITION.parameters[\"amp_na\"].optimizable = True\n", + " clamp.NODE_DEFINITION.parameters[\"amp_na\"].optimization_range = [100.0, 1000.0]\n", + " clamp.NODE_DEFINITION.parameters[\"amp_na\"].unit = \"nA\"\n", + "\n", + " # Reaches E->E, the only connection that does not set its own weight.\n", + " conn.NODE_DEFINITION.parameters[\"syn_weight\"].optimizable = True\n", + " conn.NODE_DEFINITION.parameters[\"syn_weight\"].optimization_range = [1.0, 100.0]\n", + " conn.NODE_DEFINITION.parameters[\"syn_weight\"].unit = \"pA\"\n", + "\n", + " # Keys inside a dict parameter get one range each. These belong to `probe` alone:\n", + " # each node instance carries its own definition, so `exc` is unaffected.\n", + " probe.NODE_DEFINITION.parameters[\"nest_params\"].optimizable = True\n", + " probe.NODE_DEFINITION.parameters[\"nest_params\"].optimization_range = {\n", + " 'I_e': [0.0, 600.0],\n", + " 'tau_m': [5.0, 50.0]\n", + " }\n", + "\n", + " # Execute optimization\n", + " print(\"\\nOptimizing workflow...\")\n", + " spec = build_spec(workflow, opt.algorithm_config())\n", + "\n", + " # Objectives declared by the study. Two of them, so the result is a Pareto front\n", + " # rather than a single answer.\n", + " spec.add_objective(\n", + " name=\"network_rate\",\n", + " measures=\"ana.firing_rate_hz.exc\",\n", + " low=40.0,\n", + " high=50.0,\n", + " unit=\"Hz\"\n", + " )\n", + " spec.add_objective(\n", + " name=\"probe_isi\",\n", + " measures=\"ana.isi_stats.probe.mean_ms\",\n", + " low=20.0,\n", + " high=40.0,\n", + " unit=\"ms\"\n", + " )\n", + "\n", + " result = optimize(workflow, spec=spec, results_path=opt.results_path())\n", + "\n", + " if result.best is None:\n", + " print(\"Optimization failed: no trial produced a usable measurement!\")\n", + " return 1\n", + "\n", + " print(f\"Optimization finished: {result.stop_reason}\")\n", + "\n", + " # With two objectives there is no single winner. The Pareto front is the set of\n", + " # configurations where improving one objective would cost the other.\n", + " # Measured values are given as measured, each in its own unit. The trailing figure\n", + " # is the only derived one: the objective that missed by most, sized against the\n", + " # target range asked for - \"1.4x\" meaning the miss is 1.4 times as wide as the range.\n", + " units = {o.name: o.unit for o in spec.objectives}\n", + " print(f\"\\nPareto front: {len(result.pareto_front)} configuration(s)\")\n", + " for row in result.pareto_front:\n", + " measured = \", \".join(f\"{k}={v:.4g} {units.get(k, '')}\".rstrip()\n", + " for k, v in row[\"measured\"].items())\n", + " tuned = \", \".join(f\"{k.split('.', 1)[1]}={v:.4g}\" for k, v in row[\"params\"].items())\n", + " missed = row[\"target_ranges_off\"]\n", + " state = (\"every target met\" if not missed\n", + " else f\"worst objective off by {missed:.3g}x its target range\")\n", + " print(f\" trial {row['trial']:>4}: {measured} <- {tuned} [{state}]\")\n", + "\n", + " # Picking one of them is a scientific judgement, not something the search can make.\n", + " # apply_best() takes the configuration whose WORST objective missed by the least,\n", + " # each miss sized against its own target range - the only way to weigh a miss in Hz\n", + " # against a miss in ms. That is a reasonable default and nothing more: any member of\n", + " # the front above may suit the question better, and applying a different one is one\n", + " # configure() call.\n", + " result.apply_best(workflow)\n", + "\n", + " measured = \", \".join(\n", + " f\"{o.name}={result.best['measured'][o.name]:.4g}\"\n", + " f\"{' ' + o.unit if o.unit else ''} (target {o.low}-{o.high})\"\n", + " for o in spec.objectives\n", + " )\n", + " missed = result.best[\"target_ranges_off\"]\n", + " state = (\"meets every target\" if not missed\n", + " else f\"misses by {missed:.3g}x its target range on its worst objective\")\n", + " print(f\"\\nApplied one configuration of the {len(result.pareto_front)} on the front - \"\n", + " f\"trial {result.best['trial']}, which {state}:\")\n", + " print(f\" it gives {measured}\")\n", + " print()\n", + " print(result.configure_snippet())\n", + " print(f\"\\nResults for this configuration: {result.best['results_path']}\")\n", + "\n", + " return 0\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Workflow: Network_and_probe\n", + "Nodes:\n", + " clamp\n", + " exc\n", + " probe\n", + " conn\n", + " sim\n", + " ana\n", + "Connections:\n", + " clamp.iclamp -> exc.iclamp\n", + " exc.population -> conn.populations\n", + " probe.population -> conn.populations\n", + " conn.network -> sim.populations\n", + " sim.results -> ana.results\n", + "\n", + "Optimizing workflow...\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing ./results/multiobjective_example/network\n", + "\n", + " -- N E S T --\n", + " Copyright (C) 2004 The NEST Initiative\n", + "\n", + " Version: 3.7.0\n", + " Built: Mar 4 2025 17:27:39\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", + "2026-09-06 23:33:30,676 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:30,684 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:30,688 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:30,695 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:30,696 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:30,698 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:30,702 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:30,711 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:30,757 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:30,780 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + "[opt_20260906_233330] nsga2: 4 dimensions, 2 objective(s), up to 6 generations x 12 candidates\n", + " algorithm : nsga2 (pop_size=12, max_generations=6)\n", + " dimensions: 4\n", + " clamp.amp_na [100.0, 1000.0] nA\n", + " probe.nest_params.I_e [0.0, 600.0]\n", + " probe.nest_params.tau_m [5.0, 50.0]\n", + " conn.syn_weight [1.0, 100.0] pA\n", + " objectives: 2\n", + " network_rate in [40.0, 50.0] Hz <- ana.firing_rate_hz.exc\n", + " probe_isi in [20.0, 40.0] ms <- ana.isi_stats.probe.mean_ms\n", + " skipped : 2\n", + " exc.mean_firing_rate measures 'Analysis.firing_rate_hz.v1' did not resolve to a number in the baseline run\n", + " probe.mean_firing_rate measures 'Analysis.firing_rate_hz.v1' did not resolve to a number in the baseline run\n", + " each objective reports how far it missed, in its own unit. To compare objectives measured in different units, that miss is also given as a multiple of the target range asked for: '1.4x its target range' means the miss is 1.4 times as wide as the range. 0 = the target was met.\n", + " reusing network from ./results/multiobjective_example\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0001/network\n", + "2026-09-06 23:33:31,020 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,027 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,032 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,073 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,075 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,077 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,113 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,122 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,170 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,199 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 1/12 (#1): clamp.amp_na=475.3 nA probe.nest_params.I_e=432.2 probe.nest_params.tau_m=5.005 conn.syn_weight=30.93 pA -> network_rate=134 Hz (off 84 Hz), probe_isi=10.8 ms (off 9.2 ms) <- best so far\n", + " furthest from target: network_rate, 8.4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0002/network\n", + "2026-09-06 23:33:31,227 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,230 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,234 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,240 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,241 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,243 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,247 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,255 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,302 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,325 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 2/12 (#2): clamp.amp_na=232.1 nA probe.nest_params.I_e=55.4 probe.nest_params.tau_m=13.38 conn.syn_weight=35.21 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=51.3 ms (off 11.3 ms) <- best so far\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0003/network\n", + "2026-09-06 23:33:31,351 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,355 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,358 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,364 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,365 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,366 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,370 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,379 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,426 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,457 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 3/12 (#3): clamp.amp_na=457.1 nA probe.nest_params.I_e=323.3 probe.nest_params.tau_m=23.86 conn.syn_weight=68.84 pA -> network_rate=236 Hz (off 186 Hz), probe_isi=7.721 ms (off 12.28 ms)\n", + " furthest from target: network_rate, 18.6x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0004/network\n", + "2026-09-06 23:33:31,485 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,488 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,491 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,497 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,498 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,500 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,503 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,511 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,559 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,581 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 4/12 (#4): clamp.amp_na=284 nA probe.nest_params.I_e=526.9 probe.nest_params.tau_m=6.232 conn.syn_weight=67.38 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=10.5 ms (off 9.5 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0005/network\n", + "2026-09-06 23:33:31,611 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,614 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,618 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,623 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,624 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,628 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,631 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,640 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,688 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,714 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 5/12 (#5): clamp.amp_na=475.6 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=11.32 conn.syn_weight=20.61 pA -> network_rate=86 Hz (off 36 Hz), probe_isi=8 ms (off 12 ms) <- best so far\n", + " furthest from target: network_rate, 3.6x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0006/network\n", + "2026-09-06 23:33:31,742 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,746 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,748 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,754 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,755 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,757 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,760 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,768 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,815 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,847 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 6/12 (#6): clamp.amp_na=820.7 nA probe.nest_params.I_e=581 probe.nest_params.tau_m=19.1 conn.syn_weight=69.54 pA -> network_rate=260 Hz (off 210 Hz), probe_isi=5.112 ms (off 14.89 ms)\n", + " furthest from target: network_rate, 21x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0007/network\n", + "2026-09-06 23:33:31,875 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,879 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,881 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,887 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,888 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,890 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,893 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,903 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,951 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:31,978 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 7/12 (#7): clamp.amp_na=888.8 nA probe.nest_params.I_e=536.8 probe.nest_params.tau_m=8.827 conn.syn_weight=4.866 pA -> network_rate=122 Hz (off 72 Hz), probe_isi=5.457 ms (off 14.54 ms)\n", + " furthest from target: network_rate, 7.2x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0008/network\n", + "2026-09-06 23:33:32,008 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,012 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,016 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,022 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,023 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,025 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,028 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,037 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,083 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,107 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 8/12 (#8): clamp.amp_na=252.8 nA probe.nest_params.I_e=526.9 probe.nest_params.tau_m=9.426 conn.syn_weight=42.69 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=9.075 ms (off 10.92 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0009/network\n", + "2026-09-06 23:33:32,138 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,141 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,145 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,153 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,154 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,157 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,161 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,170 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,217 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,247 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 9/12 (#9): clamp.amp_na=962.1 nA probe.nest_params.I_e=319.9 probe.nest_params.tau_m=36.13 conn.syn_weight=32.24 pA -> network_rate=202 Hz (off 152 Hz), probe_isi=5.359 ms (off 14.64 ms)\n", + " furthest from target: network_rate, 15.2x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0010/network\n", + "2026-09-06 23:33:32,278 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,281 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,285 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,291 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,292 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,294 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,297 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,306 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,354 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,384 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 10/12 (#10): clamp.amp_na=717.9 nA probe.nest_params.I_e=500.8 probe.nest_params.tau_m=5.823 conn.syn_weight=75.26 pA -> network_rate=268 Hz (off 218 Hz), probe_isi=6.4 ms (off 13.6 ms)\n", + " furthest from target: network_rate, 21.8x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0011/network\n", + "2026-09-06 23:33:32,413 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,417 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,420 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,426 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,427 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,429 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,431 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,440 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,487 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,520 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 11/12 (#11): clamp.amp_na=990 nA probe.nest_params.I_e=448.9 probe.nest_params.tau_m=17.62 conn.syn_weight=79.14 pA -> network_rate=286 Hz (off 236 Hz), probe_isi=5.159 ms (off 14.84 ms)\n", + " furthest from target: network_rate, 23.6x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0012/network\n", + "2026-09-06 23:33:32,552 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,555 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,559 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,565 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,566 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,568 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,571 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,580 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,627 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,650 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 12/12 (#12): clamp.amp_na=192.9 nA probe.nest_params.I_e=268.7 probe.nest_params.tau_m=45.89 conn.syn_weight=30.07 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=11.32 ms (off 8.681 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + " gen 1/6: best clamp.amp_na=475.6 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=11.32 conn.syn_weight=20.61 pA -> network_rate=86 Hz [target 40.0-50.0 Hz, off 36 Hz]; probe_isi=8 ms [target 20.0-40.0 ms, off 12 ms] — its furthest objective from target: network_rate, 3.6x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0013/network\n", + "2026-09-06 23:33:32,680 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,684 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,687 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,695 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,696 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,698 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,702 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,711 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,759 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,791 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 1/12 (#13): clamp.amp_na=717.9 nA probe.nest_params.I_e=500.8 probe.nest_params.tau_m=17.95 conn.syn_weight=75.26 pA -> network_rate=268 Hz (off 218 Hz), probe_isi=5.643 ms (off 14.36 ms)\n", + " furthest from target: network_rate, 21.8x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0014/network\n", + "2026-09-06 23:33:32,821 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,825 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,829 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,835 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,836 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,838 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,840 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,849 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,897 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,930 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 2/12 (#14): clamp.amp_na=962.1 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=36.13 conn.syn_weight=20.61 pA -> network_rate=172 Hz (off 122 Hz), probe_isi=5.361 ms (off 14.64 ms)\n", + " furthest from target: network_rate, 12.2x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0015/network\n", + "2026-09-06 23:33:32,960 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,964 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,968 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,974 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,975 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,977 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,980 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:32,989 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,038 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,061 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 3/12 (#15): clamp.amp_na=192.9 nA probe.nest_params.I_e=319.9 probe.nest_params.tau_m=45.89 conn.syn_weight=32.24 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=10.27 ms (off 9.734 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0016/network\n", + "2026-09-06 23:33:33,088 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,092 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,096 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,101 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,102 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,104 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,107 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,115 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,162 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,192 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 4/12 (#16): clamp.amp_na=475.3 nA probe.nest_params.I_e=432.2 probe.nest_params.tau_m=6.232 conn.syn_weight=67.38 pA -> network_rate=238 Hz (off 188 Hz), probe_isi=8.8 ms (off 11.2 ms)\n", + " furthest from target: network_rate, 18.8x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0017/network\n", + "2026-09-06 23:33:33,222 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,225 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,229 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,235 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,236 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,238 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,240 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,248 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,296 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,324 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 5/12 (#17): clamp.amp_na=717.9 nA probe.nest_params.I_e=500.8 probe.nest_params.tau_m=5.823 conn.syn_weight=13.87 pA -> network_rate=120 Hz (off 70 Hz), probe_isi=6.4 ms (off 13.6 ms)\n", + " furthest from target: network_rate, 7x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0018/network\n", + "2026-09-06 23:33:33,353 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,357 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,361 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,366 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,367 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,369 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,372 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,380 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,428 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,450 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 6/12 (#18): clamp.amp_na=284 nA probe.nest_params.I_e=526.9 probe.nest_params.tau_m=9.426 conn.syn_weight=2.917 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=8.677 ms (off 11.32 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0019/network\n", + "2026-09-06 23:33:33,479 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,484 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,487 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,492 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,494 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,496 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,498 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,507 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,555 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,584 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 7/12 (#19): clamp.amp_na=475.6 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=36.13 conn.syn_weight=32.24 pA -> network_rate=136 Hz (off 86 Hz), probe_isi=7.289 ms (off 12.71 ms)\n", + " furthest from target: network_rate, 8.6x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0020/network\n", + "2026-09-06 23:33:33,613 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,617 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,621 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,627 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,628 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,630 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,633 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,641 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,689 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,718 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 8/12 (#20): clamp.amp_na=711 nA probe.nest_params.I_e=432.2 probe.nest_params.tau_m=23.86 conn.syn_weight=30.93 pA -> network_rate=170 Hz (off 120 Hz), probe_isi=5.86 ms (off 14.14 ms)\n", + " furthest from target: network_rate, 12x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0021/network\n", + "2026-09-06 23:33:33,747 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,751 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,754 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,760 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,761 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,763 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,766 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,774 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,822 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,846 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 9/12 (#21): clamp.amp_na=252.8 nA probe.nest_params.I_e=526.9 probe.nest_params.tau_m=14.52 conn.syn_weight=30.93 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=8.112 ms (off 11.89 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0022/network\n", + "2026-09-06 23:33:33,876 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,880 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,886 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,893 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,894 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,896 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,899 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,907 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,955 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:33,982 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 10/12 (#22): clamp.amp_na=717.9 nA probe.nest_params.I_e=500.8 probe.nest_params.tau_m=5.823 conn.syn_weight=27.29 pA -> network_rate=162 Hz (off 112 Hz), probe_isi=6.4 ms (off 13.6 ms)\n", + " furthest from target: network_rate, 11.2x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0023/network\n", + "2026-09-06 23:33:34,007 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,011 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,014 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,019 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,020 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,022 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,025 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,034 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,081 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,107 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 11/12 (#23): clamp.amp_na=542.4 nA probe.nest_params.I_e=32.02 probe.nest_params.tau_m=30.84 conn.syn_weight=15.53 pA -> network_rate=92 Hz (off 42 Hz), probe_isi=9.4 ms (off 10.6 ms)\n", + " furthest from target: network_rate, 4.2x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0024/network\n", + "2026-09-06 23:33:34,135 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,139 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,141 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,147 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,149 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,151 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,154 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,163 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,211 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,234 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 12/12 (#24): clamp.amp_na=252.8 nA probe.nest_params.I_e=526.9 probe.nest_params.tau_m=9.426 conn.syn_weight=30.07 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=9.075 ms (off 10.92 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + " gen 2/6: best clamp.amp_na=475.6 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=11.32 conn.syn_weight=20.61 pA -> network_rate=86 Hz [target 40.0-50.0 Hz, off 36 Hz]; probe_isi=8 ms [target 20.0-40.0 ms, off 12 ms] — its furthest objective from target: network_rate, 3.6x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0025/network\n", + "2026-09-06 23:33:34,268 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,272 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,275 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,280 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,281 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,283 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,287 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,295 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,343 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,370 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 1/12 (#25): clamp.amp_na=475.6 nA probe.nest_params.I_e=353.6 probe.nest_params.tau_m=6.232 conn.syn_weight=20.61 pA -> network_rate=90 Hz (off 40 Hz), probe_isi=10.1 ms (off 9.9 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0026/network\n", + "2026-09-06 23:33:34,401 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,405 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,408 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,414 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,415 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,417 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,422 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,431 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,478 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,507 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 2/12 (#26): clamp.amp_na=475.6 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=11.32 conn.syn_weight=70.28 pA -> network_rate=240 Hz (off 190 Hz), probe_isi=8 ms (off 12 ms)\n", + " furthest from target: network_rate, 19x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0027/network\n", + "2026-09-06 23:33:34,538 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,542 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,545 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,551 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,552 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,554 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,556 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,565 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,613 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,641 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 3/12 (#27): clamp.amp_na=475.6 nA probe.nest_params.I_e=61.4 probe.nest_params.tau_m=11.32 conn.syn_weight=41.99 pA -> network_rate=174 Hz (off 124 Hz), probe_isi=12.9 ms (off 7.1 ms)\n", + " furthest from target: network_rate, 12.4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0028/network\n", + "2026-09-06 23:33:34,670 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,674 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,678 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,684 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,685 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,687 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,690 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,698 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,746 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,770 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 4/12 (#28): clamp.amp_na=252.8 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=9.426 conn.syn_weight=69.75 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=12.7 ms (off 7.3 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0029/network\n", + "2026-09-06 23:33:34,801 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,805 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,809 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,815 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,817 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,819 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,822 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,831 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,878 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,906 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 5/12 (#29): clamp.amp_na=475.6 nA probe.nest_params.I_e=319.9 probe.nest_params.tau_m=23.64 conn.syn_weight=32.24 pA -> network_rate=136 Hz (off 86 Hz), probe_isi=7.617 ms (off 12.38 ms)\n", + " furthest from target: network_rate, 8.6x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0030/network\n", + "2026-09-06 23:33:34,941 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,945 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,948 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,955 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,956 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,958 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,961 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:34,970 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,018 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,043 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 6/12 (#30): clamp.amp_na=192.9 nA probe.nest_params.I_e=319.9 probe.nest_params.tau_m=45.89 conn.syn_weight=32.24 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=10.27 ms (off 9.734 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0031/network\n", + "2026-09-06 23:33:35,074 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,078 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,081 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,090 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,091 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,093 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,096 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,105 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,152 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,182 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 7/12 (#31): clamp.amp_na=475.3 nA probe.nest_params.I_e=432.2 probe.nest_params.tau_m=7.248 conn.syn_weight=54.05 pA -> network_rate=206 Hz (off 156 Hz), probe_isi=8.2 ms (off 11.8 ms)\n", + " furthest from target: network_rate, 15.6x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0032/network\n", + "2026-09-06 23:33:35,212 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,216 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,220 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,226 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,228 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,230 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,233 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,241 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,289 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,312 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 8/12 (#32): clamp.amp_na=192.9 nA probe.nest_params.I_e=268.7 probe.nest_params.tau_m=9.426 conn.syn_weight=30.07 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=20.7 ms (in target)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0033/network\n", + "2026-09-06 23:33:35,343 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,347 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,350 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,356 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,358 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,360 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,363 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,371 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,419 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,443 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 9/12 (#33): clamp.amp_na=252.8 nA probe.nest_params.I_e=526.9 probe.nest_params.tau_m=6.232 conn.syn_weight=66.72 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=11.3 ms (off 8.7 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0034/network\n", + "2026-09-06 23:33:35,472 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,477 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,480 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,486 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,487 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,489 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,493 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,502 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,550 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,580 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 10/12 (#34): clamp.amp_na=563.4 nA probe.nest_params.I_e=32.02 probe.nest_params.tau_m=30.84 conn.syn_weight=30.07 pA -> network_rate=148 Hz (off 98 Hz), probe_isi=9.1 ms (off 10.9 ms)\n", + " furthest from target: network_rate, 9.8x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0035/network\n", + "2026-09-06 23:33:35,612 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,616 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,620 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,626 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,627 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,629 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,632 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,641 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,689 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,713 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 11/12 (#35): clamp.amp_na=284 nA probe.nest_params.I_e=526.9 probe.nest_params.tau_m=6.232 conn.syn_weight=67.38 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=10.5 ms (off 9.5 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0036/network\n", + "2026-09-06 23:33:35,745 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,749 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,753 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,758 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,759 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,761 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,764 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,773 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,821 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,845 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 12/12 (#36): clamp.amp_na=192.9 nA probe.nest_params.I_e=319.9 probe.nest_params.tau_m=45.89 conn.syn_weight=30.93 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=10.27 ms (off 9.734 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + " gen 3/6: best clamp.amp_na=475.6 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=11.32 conn.syn_weight=20.61 pA -> network_rate=86 Hz [target 40.0-50.0 Hz, off 36 Hz]; probe_isi=8 ms [target 20.0-40.0 ms, off 12 ms] — its furthest objective from target: network_rate, 3.6x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0037/network\n", + "2026-09-06 23:33:35,879 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,883 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,887 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,893 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,894 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,897 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,899 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,908 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,956 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:35,978 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 1/12 (#37): clamp.amp_na=252.8 nA probe.nest_params.I_e=319.9 probe.nest_params.tau_m=45.89 conn.syn_weight=66.72 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=9.384 ms (off 10.62 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0038/network\n", + "2026-09-06 23:33:36,005 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,009 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,013 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,019 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,020 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,021 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,025 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,033 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,081 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,105 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 2/12 (#38): clamp.amp_na=192.9 nA probe.nest_params.I_e=319.9 probe.nest_params.tau_m=47.51 conn.syn_weight=32.24 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=10.26 ms (off 9.736 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0039/network\n", + "2026-09-06 23:33:36,135 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,139 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,143 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,149 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,150 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,152 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,155 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,164 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,212 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,241 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 3/12 (#39): clamp.amp_na=627.9 nA probe.nest_params.I_e=268.7 probe.nest_params.tau_m=45.65 conn.syn_weight=30.07 pA -> network_rate=156 Hz (off 106 Hz), probe_isi=6.7 ms (off 13.3 ms)\n", + " furthest from target: network_rate, 10.6x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0040/network\n", + "2026-09-06 23:33:36,275 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,279 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,286 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,292 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,294 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,295 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,298 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,307 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,355 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,376 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 4/12 (#40): clamp.amp_na=252.8 nA probe.nest_params.I_e=82.48 probe.nest_params.tau_m=11.27 conn.syn_weight=66.72 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=57.2 ms (off 17.2 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0041/network\n", + "2026-09-06 23:33:36,402 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,406 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,409 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,415 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,417 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,419 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,422 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,430 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,478 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,506 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 5/12 (#41): clamp.amp_na=826.7 nA probe.nest_params.I_e=238.6 probe.nest_params.tau_m=9.426 conn.syn_weight=32.24 pA -> network_rate=190 Hz (off 140 Hz), probe_isi=6.5 ms (off 13.5 ms)\n", + " furthest from target: network_rate, 14x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0042/network\n", + "2026-09-06 23:33:36,539 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,543 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,546 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,552 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,553 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,555 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,557 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,567 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,614 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,636 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 6/12 (#42): clamp.amp_na=248.8 nA probe.nest_params.I_e=432.2 probe.nest_params.tau_m=5.005 conn.syn_weight=30.93 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=0 ms (off 20 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0043/network\n", + "2026-09-06 23:33:36,667 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,671 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,674 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,680 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,681 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,684 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,687 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,696 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,743 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,773 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 7/12 (#43): clamp.amp_na=934.8 nA probe.nest_params.I_e=61.4 probe.nest_params.tau_m=11.32 conn.syn_weight=41.99 pA -> network_rate=222 Hz (off 172 Hz), probe_isi=6.6 ms (off 13.4 ms)\n", + " furthest from target: network_rate, 17.2x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0044/network\n", + "2026-09-06 23:33:36,804 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,808 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,812 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,818 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,819 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,821 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,824 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,833 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,880 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,904 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 8/12 (#44): clamp.amp_na=252.8 nA probe.nest_params.I_e=61.4 probe.nest_params.tau_m=6.232 conn.syn_weight=41.99 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=0 ms (off 20 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0045/network\n", + "2026-09-06 23:33:36,933 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,937 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,940 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,947 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,948 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,950 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,953 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:36,961 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,009 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,032 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 9/12 (#45): clamp.amp_na=252.8 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=9.426 conn.syn_weight=69.75 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=12.7 ms (off 7.3 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0046/network\n", + "2026-09-06 23:33:37,064 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,068 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,071 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,077 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,078 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,080 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,083 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,092 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,141 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,165 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 10/12 (#46): clamp.amp_na=192.9 nA probe.nest_params.I_e=319.9 probe.nest_params.tau_m=45.89 conn.syn_weight=32.24 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=10.27 ms (off 9.734 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0047/network\n", + "2026-09-06 23:33:37,197 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,201 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,204 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,211 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,213 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,215 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,218 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,227 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,275 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,299 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 11/12 (#47): clamp.amp_na=192.9 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=9.426 conn.syn_weight=69.75 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=15.2 ms (off 4.8 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0048/network\n", + "2026-09-06 23:33:37,332 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,337 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,340 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,346 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,348 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,350 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,353 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,362 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,410 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,434 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 12/12 (#48): clamp.amp_na=192.9 nA probe.nest_params.I_e=319.9 probe.nest_params.tau_m=20.65 conn.syn_weight=69.75 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=11.42 ms (off 8.583 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + " gen 4/6: best clamp.amp_na=475.6 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=11.32 conn.syn_weight=20.61 pA -> network_rate=86 Hz [target 40.0-50.0 Hz, off 36 Hz]; probe_isi=8 ms [target 20.0-40.0 ms, off 12 ms] — its furthest objective from target: network_rate, 3.6x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0049/network\n", + "2026-09-06 23:33:37,473 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,478 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,481 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,486 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,488 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,490 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,493 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,502 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,550 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,579 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 1/12 (#49): clamp.amp_na=475.6 nA probe.nest_params.I_e=61.4 probe.nest_params.tau_m=38.79 conn.syn_weight=41.99 pA -> network_rate=174 Hz (off 124 Hz), probe_isi=9.7 ms (off 10.3 ms)\n", + " furthest from target: network_rate, 12.4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0050/network\n", + "2026-09-06 23:33:37,610 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,615 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,618 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,623 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,625 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,627 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,630 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,639 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,687 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,714 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 2/12 (#50): clamp.amp_na=475.6 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=11.32 conn.syn_weight=20.61 pA -> network_rate=86 Hz (off 36 Hz), probe_isi=8 ms (off 12 ms)\n", + " furthest from target: network_rate, 3.6x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0051/network\n", + "2026-09-06 23:33:37,745 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,750 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,753 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,759 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,760 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,762 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,765 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,774 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,831 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,861 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 3/12 (#51): clamp.amp_na=475.6 nA probe.nest_params.I_e=61.4 probe.nest_params.tau_m=11.32 conn.syn_weight=41.99 pA -> network_rate=174 Hz (off 124 Hz), probe_isi=12.9 ms (off 7.1 ms)\n", + " furthest from target: network_rate, 12.4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0052/network\n", + "2026-09-06 23:33:37,894 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,898 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,902 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,907 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,909 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,911 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,914 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,924 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:37,973 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,006 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 4/12 (#52): clamp.amp_na=753.4 nA probe.nest_params.I_e=530 probe.nest_params.tau_m=9.426 conn.syn_weight=69.75 pA -> network_rate=260 Hz (off 210 Hz), probe_isi=5.767 ms (off 14.23 ms)\n", + " furthest from target: network_rate, 21x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0053/network\n", + "2026-09-06 23:33:38,040 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,044 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,048 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,055 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,056 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,059 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,063 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,072 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,120 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,147 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 5/12 (#53): clamp.amp_na=475.6 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=9.426 conn.syn_weight=20.61 pA -> network_rate=88 Hz (off 38 Hz), probe_isi=8.4 ms (off 11.6 ms)\n", + " furthest from target: network_rate, 3.8x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0054/network\n", + "2026-09-06 23:33:38,179 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,182 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,186 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,193 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,195 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,197 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,200 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,210 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,257 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,282 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 6/12 (#54): clamp.amp_na=192.9 nA probe.nest_params.I_e=268.7 probe.nest_params.tau_m=9.426 conn.syn_weight=30.07 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=20.7 ms (in target)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0055/network\n", + "2026-09-06 23:33:38,315 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,320 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,323 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,329 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,330 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,332 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,336 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,344 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,392 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,415 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 7/12 (#55): clamp.amp_na=192.9 nA probe.nest_params.I_e=374.2 probe.nest_params.tau_m=9.426 conn.syn_weight=67.38 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=13.4 ms (off 6.6 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0056/network\n", + "2026-09-06 23:33:38,449 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,454 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,457 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,464 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,465 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,468 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,471 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,480 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,527 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,548 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 8/12 (#56): clamp.amp_na=192.9 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=5.005 conn.syn_weight=30.93 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=0 ms (off 20 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0057/network\n", + "2026-09-06 23:33:38,581 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,585 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,589 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,595 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,597 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,598 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,602 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,611 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,657 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,688 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 9/12 (#57): clamp.amp_na=775.8 nA probe.nest_params.I_e=268.7 probe.nest_params.tau_m=20.65 conn.syn_weight=69.75 pA -> network_rate=260 Hz (off 210 Hz), probe_isi=6.254 ms (off 13.75 ms)\n", + " furthest from target: network_rate, 21x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0058/network\n", + "2026-09-06 23:33:38,719 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,726 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,730 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,736 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,737 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,739 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,742 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,750 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,798 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,822 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 10/12 (#58): clamp.amp_na=284 nA probe.nest_params.I_e=268.7 probe.nest_params.tau_m=20.7 conn.syn_weight=27.72 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=10.64 ms (off 9.359 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0059/network\n", + "2026-09-06 23:33:38,853 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,857 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,861 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,867 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,868 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,870 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,873 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,882 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,930 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,961 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 11/12 (#59): clamp.amp_na=906.3 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=24.26 conn.syn_weight=69.75 pA -> network_rate=270 Hz (off 220 Hz), probe_isi=5.569 ms (off 14.43 ms)\n", + " furthest from target: network_rate, 22x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0060/network\n", + "2026-09-06 23:33:38,991 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,995 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:38,999 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,005 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,006 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,009 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,012 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,020 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,067 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,090 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 12/12 (#60): clamp.amp_na=192.9 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=9.426 conn.syn_weight=69.75 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=15.2 ms (off 4.8 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + " gen 5/6: best clamp.amp_na=475.6 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=11.32 conn.syn_weight=20.61 pA -> network_rate=86 Hz [target 40.0-50.0 Hz, off 36 Hz]; probe_isi=8 ms [target 20.0-40.0 ms, off 12 ms] — its furthest objective from target: network_rate, 3.6x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0061/network\n", + "2026-09-06 23:33:39,125 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,129 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,132 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,138 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,140 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,142 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,145 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,153 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,200 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,223 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 1/12 (#61): clamp.amp_na=192.9 nA probe.nest_params.I_e=268.7 probe.nest_params.tau_m=9.426 conn.syn_weight=30.07 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=20.7 ms (in target)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0062/network\n", + "2026-09-06 23:33:39,251 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,255 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,258 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,267 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,269 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,271 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,274 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,282 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,331 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,359 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 2/12 (#62): clamp.amp_na=968.4 nA probe.nest_params.I_e=268.7 probe.nest_params.tau_m=11.32 conn.syn_weight=30.07 pA -> network_rate=198 Hz (off 148 Hz), probe_isi=5.6 ms (off 14.4 ms)\n", + " furthest from target: network_rate, 14.8x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0063/network\n", + "2026-09-06 23:33:39,389 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,392 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,396 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,402 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,404 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,406 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,409 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,417 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,464 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,488 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 3/12 (#63): clamp.amp_na=192.9 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=9.426 conn.syn_weight=67.38 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=15.2 ms (off 4.8 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0064/network\n", + "2026-09-06 23:33:39,519 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,522 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,526 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,532 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,534 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,536 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,539 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,547 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,594 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,622 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 4/12 (#64): clamp.amp_na=475.6 nA probe.nest_params.I_e=61.4 probe.nest_params.tau_m=9.426 conn.syn_weight=41.99 pA -> network_rate=176 Hz (off 126 Hz), probe_isi=14.8 ms (off 5.2 ms)\n", + " furthest from target: network_rate, 12.6x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0065/network\n", + "2026-09-06 23:33:39,651 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,655 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,659 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,664 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,666 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,668 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,671 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,680 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,727 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,754 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 5/12 (#65): clamp.amp_na=475.6 nA probe.nest_params.I_e=61.4 probe.nest_params.tau_m=34.85 conn.syn_weight=20.61 pA -> network_rate=90 Hz (off 40 Hz), probe_isi=9.8 ms (off 10.2 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0066/network\n", + "2026-09-06 23:33:39,787 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,791 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,796 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,804 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,805 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,808 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,811 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,820 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,869 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,900 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 6/12 (#66): clamp.amp_na=475.6 nA probe.nest_params.I_e=373 probe.nest_params.tau_m=9.426 conn.syn_weight=69.75 pA -> network_rate=240 Hz (off 190 Hz), probe_isi=8 ms (off 12 ms)\n", + " furthest from target: network_rate, 19x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0067/network\n", + "2026-09-06 23:33:39,935 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,941 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,946 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,952 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,954 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,956 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,959 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:39,968 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,015 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,039 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 7/12 (#67): clamp.amp_na=203.3 nA probe.nest_params.I_e=569.7 probe.nest_params.tau_m=9.426 conn.syn_weight=45.54 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=9.14 ms (off 10.86 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0068/network\n", + "2026-09-06 23:33:40,069 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,073 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,076 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,082 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,083 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,085 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,088 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,097 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,145 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,167 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 8/12 (#68): clamp.amp_na=192.9 nA probe.nest_params.I_e=268.7 probe.nest_params.tau_m=11.32 conn.syn_weight=58.26 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=16.4 ms (off 3.6 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0069/network\n", + "2026-09-06 23:33:40,200 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,204 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,208 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,214 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,216 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,218 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,221 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,230 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,278 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,303 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 9/12 (#69): clamp.amp_na=192.9 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=23.37 conn.syn_weight=30.07 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=10.81 ms (off 9.191 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0070/network\n", + "2026-09-06 23:33:40,334 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,338 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,342 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,348 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,350 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,353 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,356 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,364 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,414 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,440 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 10/12 (#70): clamp.amp_na=313.3 nA probe.nest_params.I_e=61.4 probe.nest_params.tau_m=11.32 conn.syn_weight=41.99 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=26.5 ms (in target)\n", + " furthest from target: network_rate, 4x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0071/network\n", + "2026-09-06 23:33:40,473 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,477 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,480 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,488 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,489 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,492 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,495 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,504 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,552 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,585 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 11/12 (#71): clamp.amp_na=913 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=9.426 conn.syn_weight=69.75 pA -> network_rate=270 Hz (off 220 Hz), probe_isi=5.7 ms (off 14.3 ms)\n", + " furthest from target: network_rate, 22x its target range\n", + "Executing node: probe\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0072/network\n", + "2026-09-06 23:33:40,621 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,625 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,630 [INFO] Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,637 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,638 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,641 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,644 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,653 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,701 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:33:40,727 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 12/12 (#72): clamp.amp_na=252.8 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=11.32 conn.syn_weight=41.99 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=11.4 ms (off 8.6 ms)\n", + " furthest from target: network_rate, 4x its target range\n", + " gen 6/6: best clamp.amp_na=475.6 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=11.32 conn.syn_weight=20.61 pA -> network_rate=86 Hz [target 40.0-50.0 Hz, off 36 Hz]; probe_isi=8 ms [target 20.0-40.0 ms, off 12 ms] — its furthest objective from target: network_rate, 3.6x its target range\n", + "[opt_20260906_233330] stopped: generation budget exhausted\n", + " network_rate = 86 Hz (target 40.0-50.0 Hz, off 36 Hz)\n", + " probe_isi = 8 ms (target 20.0-40.0 ms, off 12 ms)\n", + " furthest from target: network_rate, 3.6x its target range\n", + "Optimization finished: generation budget exhausted\n", + "\n", + "Pareto front: 7 configuration(s)\n", + " trial 5: network_rate=86 Hz, probe_isi=8 ms <- amp_na=475.6, nest_params.I_e=335.2, nest_params.tau_m=11.32, syn_weight=20.61 [worst objective off by 3.6x its target range]\n", + " trial 32: network_rate=0 Hz, probe_isi=20.7 ms <- amp_na=192.9, nest_params.I_e=268.7, nest_params.tau_m=9.426, syn_weight=30.07 [worst objective off by 4x its target range]\n", + " trial 50: network_rate=86 Hz, probe_isi=8 ms <- amp_na=475.6, nest_params.I_e=335.2, nest_params.tau_m=11.32, syn_weight=20.61 [worst objective off by 3.6x its target range]\n", + " trial 53: network_rate=88 Hz, probe_isi=8.4 ms <- amp_na=475.6, nest_params.I_e=335.2, nest_params.tau_m=9.426, syn_weight=20.61 [worst objective off by 3.8x its target range]\n", + " trial 54: network_rate=0 Hz, probe_isi=20.7 ms <- amp_na=192.9, nest_params.I_e=268.7, nest_params.tau_m=9.426, syn_weight=30.07 [worst objective off by 4x its target range]\n", + " trial 61: network_rate=0 Hz, probe_isi=20.7 ms <- amp_na=192.9, nest_params.I_e=268.7, nest_params.tau_m=9.426, syn_weight=30.07 [worst objective off by 4x its target range]\n", + " trial 70: network_rate=0 Hz, probe_isi=26.5 ms <- amp_na=313.3, nest_params.I_e=61.4, nest_params.tau_m=11.32, syn_weight=41.99 [worst objective off by 4x its target range]\n", + "\n", + "Applied one configuration of the 7 on the front - trial 5, which misses by 3.6x its target range on its worst objective:\n", + " it gives network_rate=86 Hz (target 40.0-50.0), probe_isi=8 ms (target 20.0-40.0)\n", + "\n", + "clamp.configure(amp_na=475.57432213041426)\n", + "conn.configure(syn_weight=20.612047419403)\n", + "probe.configure(nest_params={**probe._parameters[\"nest_params\"], \"I_e\": 335.213897067451, \"tau_m\": 11.317412236785518})\n", + "\n", + "Results for this configuration: results/multiobjective_example/optimization/opt_20260906_233330/trials/0005\n" + ] + } + ], + "source": [ + "if __name__ == \"__main__\":\n", + " main()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.12.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/generated_multiobjective_example.py b/notebooks/generated_multiobjective_example.py new file mode 100644 index 00000000..d946eece --- /dev/null +++ b/notebooks/generated_multiobjective_example.py @@ -0,0 +1,258 @@ +#!/usr/bin/env python3 +""" +Generated workflow for project: Network and probe, two objectives + +Same shape as generated_optimization_example.py, with two differences that matter: + + * a second population, `probe`: a SINGLE inhibitory neuron that fires from its own + injected current and presses down on the network. It receives nothing from the + network - it is a tonic source of inhibition, not a read-out. + + clamp --> exc --> exc drive and recurrent excitation, both fixed + ^ + +---- probe inhibition, negative weight + + * TWO objectives, so there is no single best answer. NSGA-II returns a Pareto front: + the set of configurations where improving one objective costs the other. + + 1. the network's firing rate ana.firing_rate_hz.exc + 2. the probe's mean inter-spike interval ana.isi_stats.probe.mean_ms + +Why these two compete: the probe's own I_e and tau_m decide how fast it fires, which +decides how much inhibition the network receives, which decides the network's rate. +Two knobs, two targets, one causal path between them. + +Four dimensions: the drive, the recurrent excitatory weight, and the probe's I_e and +tau_m. The probe's two are read at simulation time, but the recurrent weight is written +into the SONATA edge files - so every trial rebuilds the network. + +The probe's inhibition of the network is fixed at -60 pA, so what the search controls +is how hard the network is driven and how fast the probe fires against it. + +Run it directly: + + python generated_multiobjective_example.py + +Needs Optuna: pip install optuna cmaes +""" +import sys +import os +import numpy as np + +# Add paths for JupyterLab environment +sys.path.append('../../') + +from neuroworkflow.core.workflow import WorkflowBuilder + +from neuroworkflow.nodes.stimulus.NW_IClamp import NW_IClamp +from neuroworkflow.nodes.network.NW_Population import NW_Population +from neuroworkflow.nodes.network.NW_Connectivity import NW_Connectivity +from neuroworkflow.nodes.simulation.NW_SimConfig import NW_SimConfig +from neuroworkflow.nodes.analysis.NW_Analysis import NW_Analysis +from neuroworkflow.nodes.optimization.NW_Optimization import NW_Optimization + +from neuroworkflow.optimization import build_spec, optimize + + +def main(): + """Optimize a neural simulation workflow against two objectives.""" + + # workflow_builder creation + workflow_builder = WorkflowBuilder( + "Network_and_probe", + context={ + "results_path": "./results/multiobjective_example" + } + ) + + # Create nodes + + # Stimulus + clamp = NW_IClamp("clamp") + clamp.configure( + amp_na=200.0, + delay_ms=50.0, + duration_ms=450.0 + ) + + # Network + exc = NW_Population("exc") + exc.configure( + pop_name='exc', + N=20, + model_type='point_neuron', + model_template='nest:iaf_psc_alpha', + ei_type='exc', + location='VISp', + layer='L4', + nest_params={'C_m': 250.0, 'tau_m': 10.0, 't_ref': 2.0, 'V_th': -55.0, 'V_reset': -70.0, 'E_L': -70.0, 'I_e': 0.0} + ) + + # A single inhibitory neuron. It receives nothing from the network: its firing comes + # from its own injected current, and it inhibits the network. I_e and tau_m are the + # two tuned values, so they set both how fast it fires and how hard it inhibits. + probe = NW_Population("probe") + probe.configure( + pop_name='probe', + N=1, + model_type='point_neuron', + model_template='nest:iaf_psc_alpha', + ei_type='inh', + location='VISp', + layer='L4', + nest_params={'C_m': 250.0, 'tau_m': 10.0, 't_ref': 2.0, 'V_th': -55.0, 'V_reset': -70.0, 'E_L': -70.0, 'I_e': 200.0} + ) + + # E->E does not set its own weight, so it inherits the node-level syn_weight - the + # value the search tunes, i.e. the strength of recurrent excitation. probe->exc + # carries its own, fixed: a negative weight is what makes a synapse inhibitory in + # NEST; ei_type is metadata carried into SONATA, not what inhibits. + conn = NW_Connectivity("conn") + conn.configure( + connection_rule=1, + syn_weight=5.0, + connections=[ + {'source': 'exc', 'target': 'exc'}, + {'source': 'probe', 'target': 'exc', 'syn_weight': -60.0} + ] + ) + + # Simulation + sim = NW_SimConfig("sim") + sim.configure( + simulator='pointnet', + config_file='config_multiobjective_example.json', + tstop_ms=500.0, + dt_ms=0.1 + ) + + # Analysis + ana = NW_Analysis("ana") + ana.configure( + plot_raster=False, + plot_traces=False + ) + + # Optimization + # Not added to the workflow: it declares how to search, and takes no part in the + # workflow's own execution. Two objectives require a multi-objective algorithm; + # a single-objective one refuses rather than inventing weights between them. + opt = NW_Optimization("opt") + opt.configure( + algorithm='nsga2', + pop_size=12, + max_generations=6, + seed=1, + results_path='./results/multiobjective_example/optimization' + ) + + # workflow_builder_ready + workflow_builder.add_node(clamp) + workflow_builder.add_node(exc) + workflow_builder.add_node(probe) + workflow_builder.add_node(conn) + workflow_builder.add_node(sim) + workflow_builder.add_node(ana) + + workflow_builder.connect("clamp", "iclamp", "exc", "iclamp") + workflow_builder.connect("exc", "population", "conn", "populations") + workflow_builder.connect("probe", "population", "conn", "populations") + workflow_builder.connect("conn", "network", "sim", "populations") + workflow_builder.connect("sim", "results", "ana", "results") + + workflow = workflow_builder.build() + + # Print workflow information + print(workflow) + + # Parameters marked optimizable in the editor + clamp.NODE_DEFINITION.parameters["amp_na"].optimizable = True + clamp.NODE_DEFINITION.parameters["amp_na"].optimization_range = [100.0, 1000.0] + clamp.NODE_DEFINITION.parameters["amp_na"].unit = "nA" + + # Reaches E->E, the only connection that does not set its own weight. + conn.NODE_DEFINITION.parameters["syn_weight"].optimizable = True + conn.NODE_DEFINITION.parameters["syn_weight"].optimization_range = [1.0, 100.0] + conn.NODE_DEFINITION.parameters["syn_weight"].unit = "pA" + + # Keys inside a dict parameter get one range each. These belong to `probe` alone: + # each node instance carries its own definition, so `exc` is unaffected. + probe.NODE_DEFINITION.parameters["nest_params"].optimizable = True + probe.NODE_DEFINITION.parameters["nest_params"].optimization_range = { + 'I_e': [0.0, 600.0], + 'tau_m': [5.0, 50.0] + } + + # Execute optimization + print("\nOptimizing workflow...") + spec = build_spec(workflow, opt.algorithm_config()) + + # Objectives declared by the study. Two of them, so the result is a Pareto front + # rather than a single answer. + spec.add_objective( + name="network_rate", + measures="ana.firing_rate_hz.exc", + low=40.0, + high=50.0, + unit="Hz" + ) + spec.add_objective( + name="probe_isi", + measures="ana.isi_stats.probe.mean_ms", + low=20.0, + high=40.0, + unit="ms" + ) + + result = optimize(workflow, spec=spec, results_path=opt.results_path()) + + if result.best is None: + print("Optimization failed: no trial produced a usable measurement!") + return 1 + + print(f"Optimization finished: {result.stop_reason}") + + # With two objectives there is no single winner. The Pareto front is the set of + # configurations where improving one objective would cost the other. + # Measured values are given as measured, each in its own unit. The trailing figure + # is the only derived one: the objective that missed by most, sized against the + # target range asked for - "1.4x" meaning the miss is 1.4 times as wide as the range. + units = {o.name: o.unit for o in spec.objectives} + print(f"\nPareto front: {len(result.pareto_front)} configuration(s)") + for row in result.pareto_front: + measured = ", ".join(f"{k}={v:.4g} {units.get(k, '')}".rstrip() + for k, v in row["measured"].items()) + tuned = ", ".join(f"{k.split('.', 1)[1]}={v:.4g}" for k, v in row["params"].items()) + missed = row["target_ranges_off"] + state = ("every target met" if not missed + else f"worst objective off by {missed:.3g}x its target range") + print(f" trial {row['trial']:>4}: {measured} <- {tuned} [{state}]") + + # Picking one of them is a scientific judgement, not something the search can make. + # apply_best() takes the configuration whose WORST objective missed by the least, + # each miss sized against its own target range - the only way to weigh a miss in Hz + # against a miss in ms. That is a reasonable default and nothing more: any member of + # the front above may suit the question better, and applying a different one is one + # configure() call. + result.apply_best(workflow) + + measured = ", ".join( + f"{o.name}={result.best['measured'][o.name]:.4g}" + f"{' ' + o.unit if o.unit else ''} (target {o.low}-{o.high})" + for o in spec.objectives + ) + missed = result.best["target_ranges_off"] + state = ("meets every target" if not missed + else f"misses by {missed:.3g}x its target range on its worst objective") + print(f"\nApplied one configuration of the {len(result.pareto_front)} on the front - " + f"trial {result.best['trial']}, which {state}:") + print(f" it gives {measured}") + print() + print(result.configure_snippet()) + print(f"\nResults for this configuration: {result.best['results_path']}") + + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/notebooks/generated_optimization_example.ipynb b/notebooks/generated_optimization_example.ipynb new file mode 100644 index 00000000..483ef9fa --- /dev/null +++ b/notebooks/generated_optimization_example.ipynb @@ -0,0 +1,15352 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nGenerated workflow for project: Clamp and weight optimization\\n\\nEXAMPLE of what the code generator should emit when an NW_Optimization node is present\\non the canvas. Everything above `workflow_builder.build()` is what the generator already\\nproduces today — node creation, configure() with the edited parameters, add_node, connect.\\nOnly the tail differs: instead of a single `workflow.execute()`, it declares what to\\nexplore and what to hit, then runs the search.\\n\\nRun it directly:\\n\\n python generated_optimization_example.py\\n\\nNeeds Optuna for the default algorithm: pip install optuna cmaes\\n'" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#!/usr/bin/env python3\n", + "\"\"\"\n", + "Generated workflow for project: Clamp and weight optimization\n", + "\n", + "EXAMPLE of what the code generator should emit when an NW_Optimization node is present\n", + "on the canvas. Everything above `workflow_builder.build()` is what the generator already\n", + "produces today — node creation, configure() with the edited parameters, add_node, connect.\n", + "Only the tail differs: instead of a single `workflow.execute()`, it declares what to\n", + "explore and what to hit, then runs the search.\n", + "\n", + "Run it directly:\n", + "\n", + " python generated_optimization_example.py\n", + "\n", + "Needs Optuna for the default algorithm: pip install optuna cmaes\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "import os\n", + "import numpy as np\n", + "\n", + "# Add paths for JupyterLab environment\n", + "sys.path.append('../../')\n", + "\n", + "from neuroworkflow.core.workflow import WorkflowBuilder\n", + "\n", + "from neuroworkflow.nodes.stimulus.NW_IClamp import NW_IClamp\n", + "from neuroworkflow.nodes.network.NW_Population import NW_Population\n", + "from neuroworkflow.nodes.network.NW_Connectivity import NW_Connectivity\n", + "from neuroworkflow.nodes.simulation.NW_SimConfig import NW_SimConfig\n", + "from neuroworkflow.nodes.analysis.NW_Analysis import NW_Analysis\n", + "from neuroworkflow.nodes.optimization.NW_Optimization import NW_Optimization\n", + "\n", + "from neuroworkflow.optimization import build_spec, optimize\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def main():\n", + " \"\"\"Optimize a neural simulation workflow.\"\"\"\n", + "\n", + " # workflow_builder creation\n", + " workflow_builder = WorkflowBuilder(\n", + " \"Clamp_and_weight\",\n", + " context={\n", + " \"results_path\": \"./results/generated_example\"\n", + " }\n", + " )\n", + "\n", + " # Create nodes\n", + "\n", + " # Stimulus\n", + " clamp = NW_IClamp(\"clamp\")\n", + " clamp.configure(\n", + " amp_na=200.0,\n", + " delay_ms=50.0,\n", + " duration_ms=450.0\n", + " )\n", + "\n", + " # Network\n", + " exc = NW_Population(\"exc\")\n", + " exc.configure(\n", + " pop_name='exc',\n", + " N=20,\n", + " model_type='point_neuron',\n", + " model_template='nest:iaf_psc_alpha',\n", + " ei_type='exc',\n", + " location='VISp',\n", + " layer='L4',\n", + " nest_params={'C_m': 250.0, 'tau_m': 10.0, 't_ref': 2.0, 'V_th': -55.0, 'V_reset': -70.0, 'E_L': -70.0, 'I_e': 0.0}\n", + " )\n", + "\n", + " conn = NW_Connectivity(\"conn\")\n", + " conn.configure(\n", + " connection_rule=1,\n", + " syn_weight=5.0,\n", + " connections=[{'source': 'exc', 'target': 'exc'}]\n", + " )\n", + "\n", + " # Simulation\n", + " sim = NW_SimConfig(\"sim\")\n", + " sim.configure(\n", + " simulator='pointnet',\n", + " config_file='config_generated_example.json',\n", + " tstop_ms=500.0,\n", + " dt_ms=0.1\n", + " )\n", + "\n", + " # Analysis\n", + " ana = NW_Analysis(\"ana\")\n", + " ana.configure(\n", + " plot_raster=False,\n", + " plot_traces=False\n", + " )\n", + "\n", + " # Optimization\n", + " # Not added to the workflow: it declares how to search, and takes no part in the\n", + " # workflow's own execution.\n", + " opt = NW_Optimization(\"opt\")\n", + " opt.configure(\n", + " algorithm='cmaes',\n", + " pop_size=16,\n", + " max_generations=12,\n", + " seed=1,\n", + " results_path='./results/generated_example/optimization'\n", + " )\n", + "\n", + " # workflow_builder_ready\n", + " workflow_builder.add_node(clamp)\n", + " workflow_builder.add_node(exc)\n", + " workflow_builder.add_node(conn)\n", + " workflow_builder.add_node(sim)\n", + " workflow_builder.add_node(ana)\n", + "\n", + " workflow_builder.connect(\"clamp\", \"iclamp\", \"exc\", \"iclamp\")\n", + " workflow_builder.connect(\"exc\", \"population\", \"conn\", \"populations\")\n", + " workflow_builder.connect(\"conn\", \"network\", \"sim\", \"populations\")\n", + " workflow_builder.connect(\"sim\", \"results\", \"ana\", \"results\")\n", + "\n", + " workflow = workflow_builder.build()\n", + "\n", + " # Print workflow information\n", + " print(workflow)\n", + "\n", + " # Parameters marked optimizable in the editor\n", + " clamp.NODE_DEFINITION.parameters[\"amp_na\"].optimizable = True\n", + " clamp.NODE_DEFINITION.parameters[\"amp_na\"].optimization_range = [100.0, 1000.0]\n", + " clamp.NODE_DEFINITION.parameters[\"amp_na\"].unit = \"nA\"\n", + "\n", + " conn.NODE_DEFINITION.parameters[\"syn_weight\"].optimizable = True\n", + " conn.NODE_DEFINITION.parameters[\"syn_weight\"].optimization_range = [1.0, 100.0]\n", + " conn.NODE_DEFINITION.parameters[\"syn_weight\"].unit = \"pA\"\n", + "\n", + " # Execute optimization\n", + " print(\"\\nOptimizing workflow...\")\n", + " spec = build_spec(workflow, opt.algorithm_config())\n", + "\n", + " # Objectives declared by the study.\n", + " #\n", + " # An objective is a label, a measurement address and a band - nothing about it\n", + " # needs a parameter to hang it on. Declaring it here keeps the target out of the\n", + " # model, so no node has to carry a parameter the simulation never reads, and a\n", + " # workflow can be optimized towards different targets without editing its nodes.\n", + " # This is the form the GUI will produce, where the study lives on the\n", + " # NW_Optimization node rather than being scattered across the model.\n", + " spec.add_objective(\n", + " name=\"exc_firing_rate\",\n", + " measures=\"ana.firing_rate_hz.exc\",\n", + " low=40.0,\n", + " high=50.0,\n", + " unit=\"Hz\"\n", + " )\n", + "\n", + " # The other way, still supported: declare the target on a node parameter and let\n", + " # build_spec() discover it. Useful when a node author ships a sensible default\n", + " # target with the node, but it needs a parameter to exist for the purpose.\n", + " #\n", + " # exc.NODE_DEFINITION.parameters[\"mean_firing_rate\"].is_objective = True\n", + " # exc.NODE_DEFINITION.parameters[\"mean_firing_rate\"].objective_range = [40.0, 50.0]\n", + " # exc.NODE_DEFINITION.parameters[\"mean_firing_rate\"].unit = \"Hz\"\n", + " # exc.NODE_DEFINITION.parameters[\"mean_firing_rate\"].measures = \"ana.firing_rate_hz.exc\"\n", + " result = optimize(workflow, spec=spec, results_path=opt.results_path())\n", + "\n", + " # Not reaching the target is a result, not an error: the search ran and reported\n", + " # that nothing in the declared ranges hits the band. Only a run that produced no\n", + " # usable measurement at all has failed.\n", + " if result.best is None:\n", + " print(\"Optimization failed: no trial produced a usable measurement!\")\n", + " return 1\n", + "\n", + " print(f\"Optimization finished: {result.stop_reason}\")\n", + "\n", + " # The search leaves the workflow holding the LAST trial's values, not the best\n", + " # ones. Adopting the winner is a separate, deliberate step.\n", + " result.apply_best(workflow)\n", + "\n", + " print(\"\\nApplied the following parameters to the workflow:\")\n", + " print(result.configure_snippet())\n", + " print(f\"\\nResults for this configuration: {result.best['results_path']}\")\n", + "\n", + " return 0\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Workflow: Clamp_and_weight\n", + "Nodes:\n", + " clamp\n", + " exc\n", + " conn\n", + " sim\n", + " ana\n", + "Connections:\n", + " clamp.iclamp -> exc.iclamp\n", + " exc.population -> conn.populations\n", + " conn.network -> sim.populations\n", + " sim.results -> ana.results\n", + "\n", + "Optimizing workflow...\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network unchanged, reusing ./results/generated_example/network\n", + "\n", + " -- N E S T --\n", + " Copyright (C) 2004 The NEST Initiative\n", + "\n", + " Version: 3.7.0\n", + " Built: Mar 4 2025 17:27:39\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", + "2026-09-06 23:34:59,224 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,232 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,236 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,237 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,238 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,240 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,250 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,295 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,314 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + "[opt_20260906_233459] cmaes: 2 dimensions, 1 objective(s), up to 12 generations x 16 candidates\n", + " algorithm : cmaes (pop_size=16, max_generations=12)\n", + " dimensions: 2\n", + " clamp.amp_na [100.0, 1000.0] nA\n", + " conn.syn_weight [1.0, 100.0] pA\n", + " objectives: 1\n", + " exc_firing_rate in [40.0, 50.0] Hz <- ana.firing_rate_hz.exc\n", + " skipped : 1\n", + " exc.mean_firing_rate measures 'Analysis.firing_rate_hz.v1' did not resolve to a number in the baseline run\n", + " reusing network from ./results/generated_example\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0001/network\n", + "2026-09-06 23:34:59,526 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,529 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,533 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,534 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,535 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,537 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,545 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,589 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,616 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 1/16 (#1): clamp.amp_na=475.3 nA conn.syn_weight=72.31 pA -> exc_firing_rate=248 Hz (off 198 Hz) <- best so far\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0002/network\n", + "2026-09-06 23:34:59,636 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,639 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,644 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,645 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,646 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,648 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,655 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,700 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,719 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 2/16 (#2): clamp.amp_na=100.1 nA conn.syn_weight=30.93 pA -> exc_firing_rate=0 Hz (off 40 Hz) <- best so far\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0003/network\n", + "2026-09-06 23:34:59,739 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,742 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,746 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,747 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,748 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,750 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,758 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,804 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,824 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 3/16 (#3): clamp.amp_na=232.1 nA conn.syn_weight=10.14 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0004/network\n", + "2026-09-06 23:34:59,845 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,849 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,854 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,855 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,856 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,858 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,866 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,912 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,932 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 4/16 (#4): clamp.amp_na=267.6 nA conn.syn_weight=35.21 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0005/network\n", + "2026-09-06 23:34:59,953 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,993 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,997 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,998 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:34:59,999 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,002 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,010 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,055 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,080 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 5/16 (#5): clamp.amp_na=457.1 nA conn.syn_weight=54.34 pA -> exc_firing_rate=212 Hz (off 162 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0006/network\n", + "2026-09-06 23:35:00,099 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,103 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,107 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,108 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,109 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,112 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,119 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,164 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,190 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 6/16 (#6): clamp.amp_na=477.3 nA conn.syn_weight=68.84 pA -> exc_firing_rate=242 Hz (off 192 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0007/network\n", + "2026-09-06 23:35:00,211 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,215 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,219 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,220 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,221 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,223 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,231 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,276 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,296 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 7/16 (#7): clamp.amp_na=284 nA conn.syn_weight=87.93 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0008/network\n", + "2026-09-06 23:35:00,316 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,319 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,323 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,324 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,326 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,328 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,335 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,381 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,402 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 8/16 (#8): clamp.amp_na=124.6 nA conn.syn_weight=67.38 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0009/network\n", + "2026-09-06 23:35:00,421 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,425 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,429 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,430 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,431 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,433 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,440 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,485 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,513 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 9/16 (#9): clamp.amp_na=475.6 nA conn.syn_weight=56.31 pA -> exc_firing_rate=218 Hz (off 168 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0010/network\n", + "2026-09-06 23:35:00,535 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,539 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,542 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,544 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,545 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,547 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,555 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,599 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,620 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 10/16 (#10): clamp.amp_na=226.3 nA conn.syn_weight=20.61 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0011/network\n", + "2026-09-06 23:35:00,642 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,646 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,651 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,652 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,653 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,655 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,663 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,708 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,735 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 11/16 (#11): clamp.amp_na=820.7 nA conn.syn_weight=96.86 pA -> exc_firing_rate=296 Hz (off 246 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0012/network\n", + "2026-09-06 23:35:00,757 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,762 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,766 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,767 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,769 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,770 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,778 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,823 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,850 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 12/16 (#12): clamp.amp_na=382.1 nA conn.syn_weight=69.54 pA -> exc_firing_rate=222 Hz (off 172 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0013/network\n", + "2026-09-06 23:35:00,871 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,875 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,879 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,880 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,881 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,883 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,891 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,937 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,964 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 13/16 (#13): clamp.amp_na=888.8 nA conn.syn_weight=89.57 pA -> exc_firing_rate=296 Hz (off 246 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0014/network\n", + "2026-09-06 23:35:00,986 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,989 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,993 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,994 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,996 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:00,998 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,006 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,050 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,070 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 14/16 (#14): clamp.amp_na=176.5 nA conn.syn_weight=4.866 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0015/network\n", + "2026-09-06 23:35:01,088 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,091 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,096 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,097 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,098 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,100 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,107 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,153 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,173 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 15/16 (#15): clamp.amp_na=252.8 nA conn.syn_weight=87.94 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0016/network\n", + "2026-09-06 23:35:01,193 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,197 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,201 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,202 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,204 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,205 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,213 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,258 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,277 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 1, trial 16/16 (#16): clamp.amp_na=188.5 nA conn.syn_weight=42.69 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + " gen 1/12: best clamp.amp_na=100.1 nA conn.syn_weight=30.93 pA -> exc_firing_rate=0 Hz [target 40.0-50.0 Hz, off 40 Hz]\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0017/network\n", + "2026-09-06 23:35:01,312 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,316 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,320 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,321 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,323 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,324 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,332 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,377 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,403 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 1/16 (#17): clamp.amp_na=592.1 nA conn.syn_weight=50.25 pA -> exc_firing_rate=214 Hz (off 164 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0018/network\n", + "2026-09-06 23:35:01,422 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,426 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,430 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,431 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,432 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,434 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,441 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,500 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,526 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 2/16 (#18): clamp.amp_na=618.5 nA conn.syn_weight=52.59 pA -> exc_firing_rate=220 Hz (off 170 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0019/network\n", + "2026-09-06 23:35:01,548 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,552 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,556 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,557 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,558 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,561 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,569 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,615 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,642 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 3/16 (#19): clamp.amp_na=607.9 nA conn.syn_weight=56.44 pA -> exc_firing_rate=232 Hz (off 182 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0020/network\n", + "2026-09-06 23:35:01,664 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,668 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,672 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,673 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,675 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,677 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,685 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,730 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,757 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 4/16 (#20): clamp.amp_na=622.1 nA conn.syn_weight=47.46 pA -> exc_firing_rate=210 Hz (off 160 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0021/network\n", + "2026-09-06 23:35:01,781 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,785 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,789 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,790 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,791 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,794 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,802 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,848 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,873 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 5/16 (#21): clamp.amp_na=550.2 nA conn.syn_weight=59.21 pA -> exc_firing_rate=230 Hz (off 180 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0022/network\n", + "2026-09-06 23:35:01,895 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,900 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,906 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,907 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,909 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,912 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,920 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,966 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:01,990 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 6/16 (#22): clamp.amp_na=492.6 nA conn.syn_weight=26.1 pA -> exc_firing_rate=126 Hz (off 76 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0023/network\n", + "2026-09-06 23:35:02,012 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,015 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,022 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,023 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,025 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,028 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,037 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,082 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,107 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 7/16 (#23): clamp.amp_na=381.5 nA conn.syn_weight=49.19 pA -> exc_firing_rate=178 Hz (off 128 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0024/network\n", + "2026-09-06 23:35:02,128 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,131 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,136 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,137 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,138 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,140 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,148 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,194 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,221 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 8/16 (#24): clamp.amp_na=418.9 nA conn.syn_weight=52.43 pA -> exc_firing_rate=198 Hz (off 148 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0025/network\n", + "2026-09-06 23:35:02,242 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,246 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,250 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,251 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,253 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,255 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,263 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,308 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,336 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 9/16 (#25): clamp.amp_na=558.1 nA conn.syn_weight=52.88 pA -> exc_firing_rate=220 Hz (off 170 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0026/network\n", + "2026-09-06 23:35:02,356 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,360 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,364 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,366 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,367 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,370 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,378 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,423 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,449 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 10/16 (#26): clamp.amp_na=675 nA conn.syn_weight=32.03 pA -> exc_firing_rate=178 Hz (off 128 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0027/network\n", + "2026-09-06 23:35:02,470 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,474 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,479 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,480 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,482 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,484 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,491 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,538 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,565 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 11/16 (#27): clamp.amp_na=483.3 nA conn.syn_weight=75.69 pA -> exc_firing_rate=256 Hz (off 206 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0028/network\n", + "2026-09-06 23:35:02,586 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,590 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,594 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,595 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,597 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,598 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,606 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,651 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,678 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 12/16 (#28): clamp.amp_na=479.7 nA conn.syn_weight=73.5 pA -> exc_firing_rate=248 Hz (off 198 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0029/network\n", + "2026-09-06 23:35:02,701 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,705 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,709 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,710 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,712 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,713 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,721 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,767 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,795 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 13/16 (#29): clamp.amp_na=771.7 nA conn.syn_weight=55.15 pA -> exc_firing_rate=240 Hz (off 190 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0030/network\n", + "2026-09-06 23:35:02,816 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,820 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,824 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,825 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,827 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,829 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,837 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,883 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,909 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 14/16 (#30): clamp.amp_na=668.8 nA conn.syn_weight=36.46 pA -> exc_firing_rate=188 Hz (off 138 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0031/network\n", + "2026-09-06 23:35:02,930 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,934 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,938 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,940 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,941 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,943 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,951 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:02,997 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,023 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 15/16 (#31): clamp.amp_na=465.4 nA conn.syn_weight=44.71 pA -> exc_firing_rate=184 Hz (off 134 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0032/network\n", + "2026-09-06 23:35:03,046 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,050 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,054 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,055 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,056 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,059 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,066 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,113 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,139 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 2, trial 16/16 (#32): clamp.amp_na=763.7 nA conn.syn_weight=25.39 pA -> exc_firing_rate=168 Hz (off 118 Hz)\n", + " gen 2/12: best clamp.amp_na=100.1 nA conn.syn_weight=30.93 pA -> exc_firing_rate=0 Hz [target 40.0-50.0 Hz, off 40 Hz]\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0033/network\n", + "2026-09-06 23:35:03,169 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,173 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,176 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,177 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,179 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,181 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,188 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,234 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,259 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 1/16 (#33): clamp.amp_na=409 nA conn.syn_weight=21.41 pA -> exc_firing_rate=78 Hz (off 28 Hz) <- best so far\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0034/network\n", + "2026-09-06 23:35:03,280 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,285 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,289 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,290 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,291 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,293 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,301 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,347 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,374 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 2/16 (#34): clamp.amp_na=544.4 nA conn.syn_weight=55.08 pA -> exc_firing_rate=220 Hz (off 170 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0035/network\n", + "2026-09-06 23:35:03,397 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,401 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,406 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,408 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,409 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,412 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,420 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,466 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,493 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 3/16 (#35): clamp.amp_na=630.9 nA conn.syn_weight=42.66 pA -> exc_firing_rate=200 Hz (off 150 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0036/network\n", + "2026-09-06 23:35:03,514 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,518 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,525 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,526 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,528 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,530 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,539 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,584 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,610 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 4/16 (#36): clamp.amp_na=514.7 nA conn.syn_weight=35.82 pA -> exc_firing_rate=166 Hz (off 116 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0037/network\n", + "2026-09-06 23:35:03,631 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,636 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,640 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,641 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,643 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,645 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,653 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,698 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,726 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 5/16 (#37): clamp.amp_na=699.4 nA conn.syn_weight=67.33 pA -> exc_firing_rate=252 Hz (off 202 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0038/network\n", + "2026-09-06 23:35:03,748 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,752 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,757 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,758 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,760 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,762 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,771 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,816 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,844 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 6/16 (#38): clamp.amp_na=447.2 nA conn.syn_weight=42.73 pA -> exc_firing_rate=176 Hz (off 126 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0039/network\n", + "2026-09-06 23:35:03,866 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,871 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,875 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,876 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,878 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,880 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,888 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,934 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,963 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 7/16 (#39): clamp.amp_na=385.5 nA conn.syn_weight=54.42 pA -> exc_firing_rate=192 Hz (off 142 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0040/network\n", + "2026-09-06 23:35:03,986 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,989 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,994 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,995 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,996 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:03,998 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,006 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,052 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,079 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 8/16 (#40): clamp.amp_na=851.3 nA conn.syn_weight=41.22 pA -> exc_firing_rate=218 Hz (off 168 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0041/network\n", + "2026-09-06 23:35:04,101 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,105 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,109 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,110 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,112 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,114 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,122 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,167 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,188 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 9/16 (#41): clamp.amp_na=336.4 nA conn.syn_weight=42.97 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0042/network\n", + "2026-09-06 23:35:04,211 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,216 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,220 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,221 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,223 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,225 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,234 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,280 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,305 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 10/16 (#42): clamp.amp_na=413.4 nA conn.syn_weight=25.54 pA -> exc_firing_rate=102 Hz (off 52 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0043/network\n", + "2026-09-06 23:35:04,329 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,333 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,338 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,339 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,340 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,343 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,351 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,397 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,417 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 11/16 (#43): clamp.amp_na=240 nA conn.syn_weight=16.49 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0044/network\n", + "2026-09-06 23:35:04,443 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,447 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,452 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,453 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,455 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,457 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,465 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,510 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,536 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 12/16 (#44): clamp.amp_na=542.5 nA conn.syn_weight=43.88 pA -> exc_firing_rate=190 Hz (off 140 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0045/network\n", + "2026-09-06 23:35:04,556 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,560 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,564 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,566 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,567 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,570 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,578 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,624 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,651 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 13/16 (#45): clamp.amp_na=500.4 nA conn.syn_weight=41.24 pA -> exc_firing_rate=178 Hz (off 128 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0046/network\n", + "2026-09-06 23:35:04,673 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,677 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,681 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,683 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,685 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,687 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,694 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,740 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,764 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 14/16 (#46): clamp.amp_na=609.5 nA conn.syn_weight=3.193 pA -> exc_firing_rate=82 Hz (off 32 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0047/network\n", + "2026-09-06 23:35:04,786 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,790 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,795 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,797 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,798 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,801 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,811 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,856 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,882 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 15/16 (#47): clamp.amp_na=510.9 nA conn.syn_weight=45.03 pA -> exc_firing_rate=190 Hz (off 140 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0048/network\n", + "2026-09-06 23:35:04,905 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,910 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,915 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,916 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,918 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,920 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,928 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,975 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:04,999 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 3, trial 16/16 (#48): clamp.amp_na=521.7 nA conn.syn_weight=30.36 pA -> exc_firing_rate=146 Hz (off 96 Hz)\n", + " gen 3/12: best clamp.amp_na=409 nA conn.syn_weight=21.41 pA -> exc_firing_rate=78 Hz [target 40.0-50.0 Hz, off 28 Hz]\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0049/network\n", + "2026-09-06 23:35:05,029 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,032 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,037 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,038 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,039 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,041 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,049 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,095 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,121 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 1/16 (#49): clamp.amp_na=631.6 nA conn.syn_weight=25.52 pA -> exc_firing_rate=150 Hz (off 100 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0050/network\n", + "2026-09-06 23:35:05,142 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,146 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,151 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,152 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,154 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,156 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,164 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,210 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,233 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 2/16 (#50): clamp.amp_na=526.9 nA conn.syn_weight=1.751 pA -> exc_firing_rate=64 Hz (off 14 Hz) <- best so far\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0051/network\n", + "2026-09-06 23:35:05,256 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,260 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,267 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,268 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,270 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,272 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,280 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,326 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,347 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 3/16 (#51): clamp.amp_na=287.9 nA conn.syn_weight=19.64 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0052/network\n", + "2026-09-06 23:35:05,368 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,372 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,376 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,378 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,379 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,381 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,389 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,435 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,459 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 4/16 (#52): clamp.amp_na=486.3 nA conn.syn_weight=49.47 pA -> exc_firing_rate=202 Hz (off 152 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0053/network\n", + "2026-09-06 23:35:05,482 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,486 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,490 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,491 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,493 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,495 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,503 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,550 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,575 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 5/16 (#53): clamp.amp_na=421.5 nA conn.syn_weight=25.65 pA -> exc_firing_rate=106 Hz (off 56 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0054/network\n", + "2026-09-06 23:35:05,597 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,602 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,606 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,607 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,609 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,612 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,619 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,665 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,690 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 6/16 (#54): clamp.amp_na=392.4 nA conn.syn_weight=36.35 pA -> exc_firing_rate=140 Hz (off 90 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0055/network\n", + "2026-09-06 23:35:05,711 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,715 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,719 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,721 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,722 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,724 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,732 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,778 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,804 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 7/16 (#55): clamp.amp_na=549.9 nA conn.syn_weight=23.75 pA -> exc_firing_rate=130 Hz (off 80 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0056/network\n", + "2026-09-06 23:35:05,826 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,830 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,834 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,835 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,837 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,839 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,847 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,893 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,918 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 8/16 (#56): clamp.amp_na=469.8 nA conn.syn_weight=27.65 pA -> exc_firing_rate=126 Hz (off 76 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0057/network\n", + "2026-09-06 23:35:05,941 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,945 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,949 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,950 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,952 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,955 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:05,963 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,010 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,035 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 9/16 (#57): clamp.amp_na=525.9 nA conn.syn_weight=22.61 pA -> exc_firing_rate=120 Hz (off 70 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0058/network\n", + "2026-09-06 23:35:06,058 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,063 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,067 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,069 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,070 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,073 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,081 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,127 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,149 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 10/16 (#58): clamp.amp_na=243.3 nA conn.syn_weight=41 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0059/network\n", + "2026-09-06 23:35:06,173 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,177 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,183 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,185 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,187 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,189 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,196 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,242 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,268 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 11/16 (#59): clamp.amp_na=505 nA conn.syn_weight=34.16 pA -> exc_firing_rate=156 Hz (off 106 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0060/network\n", + "2026-09-06 23:35:06,289 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,294 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,298 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,299 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,301 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,304 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,311 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,358 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,383 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 12/16 (#60): clamp.amp_na=613.9 nA conn.syn_weight=42.78 pA -> exc_firing_rate=196 Hz (off 146 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0061/network\n", + "2026-09-06 23:35:06,405 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,411 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,415 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,416 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,418 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,421 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,430 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,476 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,501 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 13/16 (#61): clamp.amp_na=502.5 nA conn.syn_weight=17.62 pA -> exc_firing_rate=96 Hz (off 46 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0062/network\n", + "2026-09-06 23:35:06,524 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,528 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,532 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,533 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,535 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,538 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,546 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,592 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,612 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 14/16 (#62): clamp.amp_na=329.2 nA conn.syn_weight=19.48 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0063/network\n", + "2026-09-06 23:35:06,634 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,638 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,643 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,645 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,646 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,648 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,656 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,701 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,725 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 15/16 (#63): clamp.amp_na=501.2 nA conn.syn_weight=27.86 pA -> exc_firing_rate=134 Hz (off 84 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0064/network\n", + "2026-09-06 23:35:06,748 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,753 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,757 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,758 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,760 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,763 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,771 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,817 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,844 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 4, trial 16/16 (#64): clamp.amp_na=753 nA conn.syn_weight=39.8 pA -> exc_firing_rate=206 Hz (off 156 Hz)\n", + " gen 4/12: best clamp.amp_na=526.9 nA conn.syn_weight=1.751 pA -> exc_firing_rate=64 Hz [target 40.0-50.0 Hz, off 14 Hz]\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0065/network\n", + "2026-09-06 23:35:06,876 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,880 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,884 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,886 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,888 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,890 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,899 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,944 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,966 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 1/16 (#65): clamp.amp_na=163.5 nA conn.syn_weight=18.77 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0066/network\n", + "2026-09-06 23:35:06,989 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,993 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:06,998 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,000 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,002 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,004 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,012 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,059 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,083 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 2/16 (#66): clamp.amp_na=293.7 nA conn.syn_weight=27.28 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0067/network\n", + "2026-09-06 23:35:07,104 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,108 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,113 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,115 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,117 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,120 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,128 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,175 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,202 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 3/16 (#67): clamp.amp_na=556.7 nA conn.syn_weight=48.37 pA -> exc_firing_rate=204 Hz (off 154 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0068/network\n", + "2026-09-06 23:35:07,226 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,231 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,235 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,237 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,238 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,241 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,250 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,296 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,318 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 4/16 (#68): clamp.amp_na=259.5 nA conn.syn_weight=20.57 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0069/network\n", + "2026-09-06 23:35:07,343 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,348 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,352 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,354 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,355 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,357 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,367 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,414 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,439 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 5/16 (#69): clamp.amp_na=568 nA conn.syn_weight=9.926 pA -> exc_firing_rate=90 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0070/network\n", + "2026-09-06 23:35:07,462 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,467 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,471 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,472 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,474 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,477 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,485 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,531 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,557 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 6/16 (#70): clamp.amp_na=597.1 nA conn.syn_weight=5.157 pA -> exc_firing_rate=84 Hz (off 34 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0071/network\n", + "2026-09-06 23:35:07,578 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,582 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,587 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,588 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,590 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,592 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,600 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,646 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,673 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 7/16 (#71): clamp.amp_na=764.7 nA conn.syn_weight=27.67 pA -> exc_firing_rate=174 Hz (off 124 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0072/network\n", + "2026-09-06 23:35:07,696 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,701 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,705 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,707 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,708 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,711 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,720 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,766 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,792 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 8/16 (#72): clamp.amp_na=651.3 nA conn.syn_weight=14.52 pA -> exc_firing_rate=118 Hz (off 68 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0073/network\n", + "2026-09-06 23:35:07,816 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,821 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,825 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,827 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,829 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,831 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,840 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,887 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,915 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 9/16 (#73): clamp.amp_na=465.8 nA conn.syn_weight=18.95 pA -> exc_firing_rate=90 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0074/network\n", + "2026-09-06 23:35:07,937 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,941 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,948 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,950 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,952 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,955 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:07,964 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,025 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,047 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 10/16 (#74): clamp.amp_na=329.3 nA conn.syn_weight=3.723 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0075/network\n", + "2026-09-06 23:35:08,070 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,075 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,081 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,082 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,084 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,087 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,096 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,141 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,164 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 11/16 (#75): clamp.amp_na=264 nA conn.syn_weight=9.507 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0076/network\n", + "2026-09-06 23:35:08,186 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,190 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,195 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,197 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,199 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,202 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,211 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,257 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,286 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 12/16 (#76): clamp.amp_na=639.5 nA conn.syn_weight=21.28 pA -> exc_firing_rate=138 Hz (off 88 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0077/network\n", + "2026-09-06 23:35:08,311 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,315 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,320 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,322 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,323 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,326 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,335 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,381 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,403 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 13/16 (#77): clamp.amp_na=267.7 nA conn.syn_weight=13.01 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0078/network\n", + "2026-09-06 23:35:08,427 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,432 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,437 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,439 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,440 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,443 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,452 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,498 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,524 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 14/16 (#78): clamp.amp_na=577.5 nA conn.syn_weight=29.82 pA -> exc_firing_rate=154 Hz (off 104 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0079/network\n", + "2026-09-06 23:35:08,547 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,551 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,556 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,557 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,559 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,562 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,571 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,618 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,638 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 15/16 (#79): clamp.amp_na=169.7 nA conn.syn_weight=20.96 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0080/network\n", + "2026-09-06 23:35:08,660 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,664 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,668 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,670 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,672 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,674 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,682 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,729 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,754 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 5, trial 16/16 (#80): clamp.amp_na=461.6 nA conn.syn_weight=10.21 pA -> exc_firing_rate=62 Hz (off 12 Hz) <- best so far\n", + " gen 5/12: best clamp.amp_na=461.6 nA conn.syn_weight=10.21 pA -> exc_firing_rate=62 Hz [target 40.0-50.0 Hz, off 12 Hz]\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0081/network\n", + "2026-09-06 23:35:08,788 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,793 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,798 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,799 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,802 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,807 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,815 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,862 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,888 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 1/16 (#81): clamp.amp_na=455.4 nA conn.syn_weight=8.074 pA -> exc_firing_rate=56 Hz (off 6 Hz) <- best so far\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0082/network\n", + "2026-09-06 23:35:08,910 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,914 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,918 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,920 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,922 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,924 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,934 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:08,981 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,008 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 2/16 (#82): clamp.amp_na=581.2 nA conn.syn_weight=13.88 pA -> exc_firing_rate=104 Hz (off 54 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0083/network\n", + "2026-09-06 23:35:09,033 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,037 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,042 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,044 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,046 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,048 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,056 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,103 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,125 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 3/16 (#83): clamp.amp_na=119.5 nA conn.syn_weight=9.999 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0084/network\n", + "2026-09-06 23:35:09,149 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,153 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,157 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,159 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,161 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,164 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,172 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,219 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,246 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 4/16 (#84): clamp.amp_na=540.1 nA conn.syn_weight=31.73 pA -> exc_firing_rate=154 Hz (off 104 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0085/network\n", + "2026-09-06 23:35:09,270 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,275 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,280 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,281 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,283 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,286 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,294 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,341 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,363 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 5/16 (#85): clamp.amp_na=342.2 nA conn.syn_weight=10.72 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0086/network\n", + "2026-09-06 23:35:09,385 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,390 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,395 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,396 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,399 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,402 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,410 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,457 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,483 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 6/16 (#86): clamp.amp_na=459.9 nA conn.syn_weight=29.74 pA -> exc_firing_rate=132 Hz (off 82 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0087/network\n", + "2026-09-06 23:35:09,506 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,511 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,516 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,518 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,520 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,522 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,531 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,578 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,604 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 7/16 (#87): clamp.amp_na=772.8 nA conn.syn_weight=5.593 pA -> exc_firing_rate=116 Hz (off 66 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0088/network\n", + "2026-09-06 23:35:09,629 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,634 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,638 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,640 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,642 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,645 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,654 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,699 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,722 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 8/16 (#88): clamp.amp_na=219 nA conn.syn_weight=11 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0089/network\n", + "2026-09-06 23:35:09,744 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,749 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,757 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,759 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,761 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,764 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,773 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,818 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,846 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 9/16 (#89): clamp.amp_na=601.9 nA conn.syn_weight=34.39 pA -> exc_firing_rate=174 Hz (off 124 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0090/network\n", + "2026-09-06 23:35:09,871 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,876 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,880 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,881 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,883 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,886 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,895 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,943 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,968 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 10/16 (#90): clamp.amp_na=574.8 nA conn.syn_weight=21.2 pA -> exc_firing_rate=126 Hz (off 76 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0091/network\n", + "2026-09-06 23:35:09,992 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:09,996 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,001 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,003 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,004 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,007 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,016 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,063 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,089 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 11/16 (#91): clamp.amp_na=419.6 nA conn.syn_weight=23.57 pA -> exc_firing_rate=94 Hz (off 44 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0092/network\n", + "2026-09-06 23:35:10,109 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,114 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,119 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,120 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,122 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,124 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,134 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,182 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,209 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 12/16 (#92): clamp.amp_na=617.7 nA conn.syn_weight=6.605 pA -> exc_firing_rate=92 Hz (off 42 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0093/network\n", + "2026-09-06 23:35:10,234 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,239 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,244 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,245 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,247 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,250 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,259 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,305 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,333 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 13/16 (#93): clamp.amp_na=407.3 nA conn.syn_weight=53.99 pA -> exc_firing_rate=198 Hz (off 148 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0094/network\n", + "2026-09-06 23:35:10,356 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,361 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,366 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,368 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,370 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,373 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,382 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,428 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,451 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 14/16 (#94): clamp.amp_na=325.5 nA conn.syn_weight=18.94 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0095/network\n", + "2026-09-06 23:35:10,473 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,478 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,482 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,484 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,486 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,489 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,497 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,543 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,567 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 15/16 (#95): clamp.amp_na=380.2 nA conn.syn_weight=18.98 pA -> exc_firing_rate=32 Hz (off 8 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0096/network\n", + "2026-09-06 23:35:10,590 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,595 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,599 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,602 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,604 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,606 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,614 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,660 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,688 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 6, trial 16/16 (#96): clamp.amp_na=491 nA conn.syn_weight=27.28 pA -> exc_firing_rate=130 Hz (off 80 Hz)\n", + " gen 6/12: best clamp.amp_na=455.4 nA conn.syn_weight=8.074 pA -> exc_firing_rate=56 Hz [target 40.0-50.0 Hz, off 6 Hz]\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0097/network\n", + "2026-09-06 23:35:10,719 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,727 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,732 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,734 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,736 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,739 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,748 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,795 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,818 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 7, trial 1/16 (#97): clamp.amp_na=430.7 nA conn.syn_weight=7.843 pA -> exc_firing_rate=46 Hz (in target) <- best so far\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0098/network\n", + "2026-09-06 23:35:10,840 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,845 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,851 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,853 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,855 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,857 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,867 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,913 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,939 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 7, trial 2/16 (#98): clamp.amp_na=400.7 nA conn.syn_weight=19.04 pA -> exc_firing_rate=60 Hz (off 10 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0099/network\n", + "2026-09-06 23:35:10,962 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,967 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,972 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,973 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,975 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,979 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:10,988 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,034 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,059 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 7, trial 3/16 (#99): clamp.amp_na=384.3 nA conn.syn_weight=16.38 pA -> exc_firing_rate=32 Hz (off 8 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0100/network\n", + "2026-09-06 23:35:11,082 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,086 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,091 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,092 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,095 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,097 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,106 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,152 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,175 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 7, trial 4/16 (#100): clamp.amp_na=273.4 nA conn.syn_weight=9.226 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0101/network\n", + "2026-09-06 23:35:11,200 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,205 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,210 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,212 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,214 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,216 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,226 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,273 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,294 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 7, trial 5/16 (#101): clamp.amp_na=257.2 nA conn.syn_weight=15.03 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0102/network\n", + "2026-09-06 23:35:11,317 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,321 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,326 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,328 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,330 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,333 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,342 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,389 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,419 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 7, trial 6/16 (#102): clamp.amp_na=381.6 nA conn.syn_weight=47.06 pA -> exc_firing_rate=170 Hz (off 120 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0103/network\n", + "2026-09-06 23:35:11,442 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,447 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,452 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,454 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,455 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,458 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,468 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,514 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,535 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 7, trial 7/16 (#103): clamp.amp_na=321.6 nA conn.syn_weight=7.252 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0104/network\n", + "2026-09-06 23:35:11,557 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,563 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,568 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,570 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,572 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,577 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,586 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,632 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,654 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 7, trial 8/16 (#104): clamp.amp_na=262.5 nA conn.syn_weight=9.975 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0105/network\n", + "2026-09-06 23:35:11,678 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,682 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,687 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,689 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,691 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,693 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,703 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,750 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,777 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 7, trial 9/16 (#105): clamp.amp_na=508.6 nA conn.syn_weight=3.275 pA -> exc_firing_rate=62 Hz (off 12 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0106/network\n", + "2026-09-06 23:35:11,801 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,806 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,811 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,813 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,815 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,817 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,827 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,873 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,895 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 7, trial 10/16 (#106): clamp.amp_na=198.6 nA conn.syn_weight=2.816 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0107/network\n", + "2026-09-06 23:35:11,919 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,924 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,929 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,931 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,933 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,936 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,945 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:11,991 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,017 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 7, trial 11/16 (#107): clamp.amp_na=445.4 nA conn.syn_weight=7.913 pA -> exc_firing_rate=52 Hz (off 2 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0108/network\n", + "2026-09-06 23:35:12,042 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,047 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,051 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,053 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,055 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,057 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,066 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,113 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,136 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 7, trial 12/16 (#108): clamp.amp_na=190.5 nA conn.syn_weight=10.25 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0109/network\n", + "2026-09-06 23:35:12,160 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,164 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,169 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,171 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,173 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,175 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,184 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,231 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,254 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 7, trial 13/16 (#109): clamp.amp_na=355.9 nA conn.syn_weight=21.68 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0110/network\n", + "2026-09-06 23:35:12,278 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,283 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,288 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,290 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,292 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,295 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,304 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,351 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,380 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 7, trial 14/16 (#110): clamp.amp_na=616.9 nA conn.syn_weight=4.625 pA -> exc_firing_rate=88 Hz (off 38 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0111/network\n", + "2026-09-06 23:35:12,406 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,412 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,416 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,419 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,421 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,424 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,434 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,480 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,508 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 7, trial 15/16 (#111): clamp.amp_na=768.6 nA conn.syn_weight=31.46 pA -> exc_firing_rate=186 Hz (off 136 Hz)\n", + "Executing node: clamp\n", + "Executing node: exc\n", + "Executing node: conn\n", + "Executing node: sim\n", + "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0112/network\n", + "2026-09-06 23:35:12,533 [INFO] Created log file\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Created log file\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,539 [INFO] Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,547 [INFO] Setting up output directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Setting up output directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,549 [INFO] Building cells.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building cells.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,551 [INFO] Building recurrent connections\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Building recurrent connections\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,554 [INFO] Network created.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Network created.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,563 [INFO] Starting Simulation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Starting Simulation\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,609 [INFO] Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Simulation finished, finalizing results.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-09-06 23:35:12,631 [INFO] Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:NestIOUtils:Done.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Executing node: ana\n", + " gen 7, trial 16/16 (#112): clamp.amp_na=356.5 nA conn.syn_weight=11.08 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", + " gen 7/12: best clamp.amp_na=430.7 nA conn.syn_weight=7.843 pA -> exc_firing_rate=46 Hz [target 40.0-50.0 Hz, in target] — all targets met\n", + "[opt_20260906_233459] stopped: a candidate is inside every target band\n", + " exc_firing_rate = 46 Hz (target 40.0-50.0 Hz, in target)\n", + "Optimization finished: a candidate is inside every target band\n", + "\n", + "Applied the following parameters to the workflow:\n", + "clamp.configure(amp_na=430.6735051488371)\n", + "conn.configure(syn_weight=7.8434448541675374)\n", + "\n", + "Results for this configuration: results/generated_example/optimization/opt_20260906_233459/trials/0097\n" + ] + } + ], + "source": [ + "if __name__ == \"__main__\":\n", + " main()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.12.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/generated_optimization_example.py b/notebooks/generated_optimization_example.py new file mode 100644 index 00000000..bb91f727 --- /dev/null +++ b/notebooks/generated_optimization_example.py @@ -0,0 +1,182 @@ +#!/usr/bin/env python3 +""" +Generated workflow for project: Clamp and weight optimization + +EXAMPLE of what the code generator should emit when an NW_Optimization node is present +on the canvas. Everything above `workflow_builder.build()` is what the generator already +produces today — node creation, configure() with the edited parameters, add_node, connect. +Only the tail differs: instead of a single `workflow.execute()`, it declares what to +explore and what to hit, then runs the search. + +Run it directly: + + python generated_optimization_example.py + +Needs Optuna for the default algorithm: pip install optuna cmaes +""" +import sys +import os +import numpy as np + +# Add paths for JupyterLab environment +sys.path.append('../../') + +from neuroworkflow.core.workflow import WorkflowBuilder + +from neuroworkflow.nodes.stimulus.NW_IClamp import NW_IClamp +from neuroworkflow.nodes.network.NW_Population import NW_Population +from neuroworkflow.nodes.network.NW_Connectivity import NW_Connectivity +from neuroworkflow.nodes.simulation.NW_SimConfig import NW_SimConfig +from neuroworkflow.nodes.analysis.NW_Analysis import NW_Analysis +from neuroworkflow.nodes.optimization.NW_Optimization import NW_Optimization + +from neuroworkflow.optimization import build_spec, optimize + + +def main(): + """Optimize a neural simulation workflow.""" + + # workflow_builder creation + workflow_builder = WorkflowBuilder( + "Clamp_and_weight", + context={ + "results_path": "./results/generated_example" + } + ) + + # Create nodes + + # Stimulus + clamp = NW_IClamp("clamp") + clamp.configure( + amp_na=200.0, + delay_ms=50.0, + duration_ms=450.0 + ) + + # Network + exc = NW_Population("exc") + exc.configure( + pop_name='exc', + N=20, + model_type='point_neuron', + model_template='nest:iaf_psc_alpha', + ei_type='exc', + location='VISp', + layer='L4', + nest_params={'C_m': 250.0, 'tau_m': 10.0, 't_ref': 2.0, 'V_th': -55.0, 'V_reset': -70.0, 'E_L': -70.0, 'I_e': 0.0} + ) + + conn = NW_Connectivity("conn") + conn.configure( + connection_rule=1, + syn_weight=5.0, + connections=[{'source': 'exc', 'target': 'exc'}] + ) + + # Simulation + sim = NW_SimConfig("sim") + sim.configure( + simulator='pointnet', + config_file='config_generated_example.json', + tstop_ms=500.0, + dt_ms=0.1 + ) + + # Analysis + ana = NW_Analysis("ana") + ana.configure( + plot_raster=False, + plot_traces=False + ) + + # Optimization + # Not added to the workflow: it declares how to search, and takes no part in the + # workflow's own execution. + opt = NW_Optimization("opt") + opt.configure( + algorithm='cmaes', + pop_size=16, + max_generations=12, + seed=1, + results_path='./results/generated_example/optimization' + ) + + # workflow_builder_ready + workflow_builder.add_node(clamp) + workflow_builder.add_node(exc) + workflow_builder.add_node(conn) + workflow_builder.add_node(sim) + workflow_builder.add_node(ana) + + workflow_builder.connect("clamp", "iclamp", "exc", "iclamp") + workflow_builder.connect("exc", "population", "conn", "populations") + workflow_builder.connect("conn", "network", "sim", "populations") + workflow_builder.connect("sim", "results", "ana", "results") + + workflow = workflow_builder.build() + + # Print workflow information + print(workflow) + + # Parameters marked optimizable in the editor + clamp.NODE_DEFINITION.parameters["amp_na"].optimizable = True + clamp.NODE_DEFINITION.parameters["amp_na"].optimization_range = [100.0, 1000.0] + clamp.NODE_DEFINITION.parameters["amp_na"].unit = "nA" + + conn.NODE_DEFINITION.parameters["syn_weight"].optimizable = True + conn.NODE_DEFINITION.parameters["syn_weight"].optimization_range = [1.0, 100.0] + conn.NODE_DEFINITION.parameters["syn_weight"].unit = "pA" + + # Execute optimization + print("\nOptimizing workflow...") + spec = build_spec(workflow, opt.algorithm_config()) + + # Objectives declared by the study. + # + # An objective is a label, a measurement address and a band - nothing about it + # needs a parameter to hang it on. Declaring it here keeps the target out of the + # model, so no node has to carry a parameter the simulation never reads, and a + # workflow can be optimized towards different targets without editing its nodes. + # This is the form the GUI will produce, where the study lives on the + # NW_Optimization node rather than being scattered across the model. + spec.add_objective( + name="exc_firing_rate", + measures="ana.firing_rate_hz.exc", + low=40.0, + high=50.0, + unit="Hz" + ) + + # The other way, still supported: declare the target on a node parameter and let + # build_spec() discover it. Useful when a node author ships a sensible default + # target with the node, but it needs a parameter to exist for the purpose. + # + # exc.NODE_DEFINITION.parameters["mean_firing_rate"].is_objective = True + # exc.NODE_DEFINITION.parameters["mean_firing_rate"].objective_range = [40.0, 50.0] + # exc.NODE_DEFINITION.parameters["mean_firing_rate"].unit = "Hz" + # exc.NODE_DEFINITION.parameters["mean_firing_rate"].measures = "ana.firing_rate_hz.exc" + result = optimize(workflow, spec=spec, results_path=opt.results_path()) + + # Not reaching the target is a result, not an error: the search ran and reported + # that nothing in the declared ranges hits the band. Only a run that produced no + # usable measurement at all has failed. + if result.best is None: + print("Optimization failed: no trial produced a usable measurement!") + return 1 + + print(f"Optimization finished: {result.stop_reason}") + + # The search leaves the workflow holding the LAST trial's values, not the best + # ones. Adopting the winner is a separate, deliberate step. + result.apply_best(workflow) + + print("\nApplied the following parameters to the workflow:") + print(result.configure_snippet()) + print(f"\nResults for this configuration: {result.best['results_path']}") + + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/src/neuroworkflow/nodes/analysis/NW_Analysis.py b/src/neuroworkflow/nodes/analysis/NW_Analysis.py index d3bffb15..0b29fb3f 100644 --- a/src/neuroworkflow/nodes/analysis/NW_Analysis.py +++ b/src/neuroworkflow/nodes/analysis/NW_Analysis.py @@ -102,6 +102,18 @@ class NW_Analysis(Node): "omitted. Empty dict if the spikes file cannot be read." ), ), + + "isi_stats": PortDefinition( + type=PortType.DICT, + description=( + "Inter-spike interval distribution per population, keyed by population " + "name: {'mean_ms', 'std_ms', 'cv', 'n_intervals'}. Intervals are taken " + "per neuron and then pooled - never across neurons, which would be " + "meaningless. 'cv' is std/mean, the classic irregularity measure: near 0 " + "is clock-like firing, near 1 is Poisson-like. A population that never " + "spiked appears with zeros rather than being omitted." + ), + ), }, methods={ "analyze": MethodDefinition( @@ -110,7 +122,7 @@ class NW_Analysis(Node): "produce spike raster and/or membrane potential trace plots." ), inputs=["results"], - outputs=["figures", "firing_rate_hz"], + outputs=["figures", "firing_rate_hz", "isi_stats"], ), }, ) @@ -142,6 +154,89 @@ def _detect_populations(self, output_dir: str, report_name: str) -> list: return [] + def _population_sizes(self) -> Dict[str, int]: + """Neurons per population, from the SONATA node files the network was built from. + + Used as the denominator for firing rate, and to decide whether a spike train + can be split per neuron when the spikes file carries no node_ids. + """ + import glob + import os + + import h5py + + network_dir = os.path.join(self._context.get("results_path", "results"), "network") + sizes: Dict[str, int] = {} + for nodes_file in sorted(glob.glob(os.path.join(network_dir, "*_nodes.h5"))): + with h5py.File(nodes_file, "r") as f: + for pop, group in f.get("nodes", {}).items(): + if "node_id" in group: + sizes[pop] = len(group["node_id"]) + return sizes + + def _measure_isi_stats(self, output_dir: str) -> Dict[str, Dict[str, float]]: + """Summarise each population's inter-spike interval distribution. + + Intervals are computed per neuron and then pooled, so a population of one and a + population of many are described the same way. Pooling the raw timestamps + instead would produce intervals *between different neurons*, which mean nothing. + """ + try: + import os + + import h5py + import numpy as np + + spikes_path = os.path.join(output_dir, "spikes.h5") + if not os.path.exists(spikes_path): + return {} + + sizes = self._population_sizes() + empty = {"mean_ms": 0.0, "std_ms": 0.0, "cv": 0.0, "n_intervals": 0} + stats: Dict[str, Dict[str, float]] = {pop: dict(empty) for pop in sizes} + + with h5py.File(spikes_path, "r") as f: + for pop, group in f.get("spikes", {}).items(): + if "timestamps" not in group: + continue + times = np.asarray(group["timestamps"], dtype=float) + ids = (np.asarray(group["node_ids"]) + if "node_ids" in group else None) + + per_neuron = [] + if ids is not None and len(ids) == len(times): + for neuron in np.unique(ids): + train = np.sort(times[ids == neuron]) + if train.size > 1: + per_neuron.append(np.diff(train)) + elif sizes.get(pop, 0) == 1: + # One neuron: every timestamp is its own, so no grouping needed. + train = np.sort(times) + if train.size > 1: + per_neuron.append(np.diff(train)) + else: + print(f"[NW_Analysis] isi stats skipped for {pop!r}: " + f"spikes.h5 has no node_ids to separate neurons") + continue + + pooled = np.concatenate(per_neuron) if per_neuron else np.array([]) + if pooled.size == 0: + continue + mean = float(pooled.mean()) + std = float(pooled.std()) + stats[pop] = { + "mean_ms": mean, + "std_ms": std, + "cv": std / mean if mean > 0 else 0.0, + "n_intervals": int(pooled.size), + } + + return stats + + except Exception as e: + print(f"[NW_Analysis] isi statistics skipped: {e}") + return {} + def _measure_firing_rates(self, config_file: str, output_dir: str) -> Dict[str, float]: """Mean firing rate per population, in Hz, read from the SONATA output. @@ -170,14 +265,9 @@ def _measure_firing_rates(self, config_file: str, output_dir: str) -> Dict[str, # Same run root NW_SimConfig used to build the network, and the value # a re-run updates when it points the workflow at a new results dir. - base_dir = self._context.get("results_path", "results") - network_dir = os.path.join(base_dir, "network") - sizes: Dict[str, int] = {} - for nodes_file in sorted(glob.glob(os.path.join(network_dir, "*_nodes.h5"))): - with h5py.File(nodes_file, "r") as f: - for pop, group in f.get("nodes", {}).items(): - if "node_id" in group: - sizes[pop] = len(group["node_id"]) + network_dir = os.path.join( + self._context.get("results_path", "results"), "network") + sizes = self._population_sizes() spikes_path = os.path.join(output_dir, "spikes.h5") if not sizes: @@ -214,6 +304,7 @@ def analyze(self, results: Dict) -> Dict[str, Any]: # Measured before plotting, so it does not depend on the plotting flags. firing_rate_hz = self._measure_firing_rates(config_file, output_dir) + isi_stats = self._measure_isi_stats(output_dir) populations = list(p["populations"]) or self._detect_populations(output_dir, str(p["report_name"])) node_ids = list(p["trace_node_ids"]) or None @@ -262,4 +353,5 @@ def analyze(self, results: Dict) -> Dict[str, Any]: except Exception as e: print(f"[NW_Analysis] plot_traces skipped: {e}") - return {"figures": figures, "firing_rate_hz": firing_rate_hz} + return {"figures": figures, "firing_rate_hz": firing_rate_hz, + "isi_stats": isi_stats} diff --git a/src/neuroworkflow/nodes/network/NW_Connectivity.py b/src/neuroworkflow/nodes/network/NW_Connectivity.py index c491b5b5..f5e5dc9b 100644 --- a/src/neuroworkflow/nodes/network/NW_Connectivity.py +++ b/src/neuroworkflow/nodes/network/NW_Connectivity.py @@ -203,6 +203,40 @@ def _write_syn_json(self, params_dict: dict, filename: str) -> None: with open(os.path.join(syn_dir, filename), "w") as f: json.dump(float_params, f, indent=2) + @staticmethod + def _coerce_connection_rule(value): + """Return what BMTK's add_edges() expects: an int or a callable. + + connection_rule can arrive as: + - an int (e.g. 1, 3) -> passed through + - a real callable (notebook lambda) -> passed through + - a numeric string ("3") -> int + - a lambda string ("lambda src, tgt: ...") -> eval'd to a callable + + The last case is the GUI path: a lambda cannot be JSON-encoded, and the + code generator only un-quotes a lambda at the TOP LEVEL of configure(), + not one nested inside the `connections` list. So a per-connection rule + reaches here as a string and must be evaluated. numpy is available as + `np` for rules that use np.random / np.exp etc. + """ + if callable(value) or isinstance(value, (int, bool)): + return value + if isinstance(value, str): + s = value.strip() + if s.lstrip("+-").isdigit(): + return int(s) + import numpy as np + fn = eval(s, {"np": np, "__builtins__": __builtins__}) + if not callable(fn): + raise ValueError( + f"connection_rule string did not evaluate to a callable: {value!r}" + ) + return fn + raise ValueError( + f"connection_rule must be an int, a callable, or a lambda string; " + f"got {type(value).__name__}" + ) + def connect(self, populations: List[Dict]) -> Dict[str, Any]: p = self._parameters @@ -253,7 +287,7 @@ def connect(self, populations: List[Dict]) -> Dict[str, Any]: src_builder.add_edges( source = src_builder.nodes(), target = tgt_builder.nodes(), - connection_rule = spec["connection_rule"], + connection_rule = self._coerce_connection_rule(spec["connection_rule"]), model_template = str(spec["model_template"]), dynamics_params = str(spec["dynamics_params"]), delay = float(spec["delay"]), @@ -262,4 +296,16 @@ def connect(self, populations: List[Dict]) -> Dict[str, Any]: allow_multapses = bool(spec["allow_multapses"]), ) + # Structural parameters of this node, carried inside the payload that already + # flows to NW_SimConfig — no new port, so existing workflows are untouched. + # dynamics_params_dict is excluded: it is written to a JSON that edge_types.csv + # references by name, so its values are read at simulation time. + conn_signature = {k: v for k, v in p.items() if k != "dynamics_params_dict"} + conn_signature["connections"] = [ + {k: v for k, v in spec.items() if k != "dynamics_params_dict"} + for spec in p["connections"] + ] + for pop in pop_lookup.values(): + pop.setdefault("_signature", {})["connectivity"] = conn_signature + return {"network": pop_lookup} diff --git a/src/neuroworkflow/nodes/network/NW_Population.py b/src/neuroworkflow/nodes/network/NW_Population.py index 7103acda..c5de14c7 100644 --- a/src/neuroworkflow/nodes/network/NW_Population.py +++ b/src/neuroworkflow/nodes/network/NW_Population.py @@ -122,6 +122,22 @@ class NW_Population(Node): "Ignored for biophysical models (use dynamics_params_file instead)." ), ), + "mean_firing_rate": ParameterDefinition( + default_value=10.0, + description=( + "Desired mean firing rate of this population, averaged over its " + "neurons and the whole simulation. Declares the target an " + "optimization steers toward; it does not affect the simulation. " + "The measured value it is compared against is named by 'measures'." + ), + unit="Hz", + # Opt-in: a population is a target only when a study says so. + # Defaulting to True made every population declare an objective + # against an address that exists in no particular workflow. + is_objective=False, + objective_range=[8.0, 12.0], + measures="", + ), "dynamics_params_file": ParameterDefinition( default_value="", description=( @@ -177,7 +193,7 @@ class NW_Population(Node): type=PortType.OBJECT, description=( "Dict with: builder (live NetworkBuilder), pop_name (str), " - "network_dir (str), and optionally current_clamp (dict). " + "network_dir (str), and optionally _current_clamp (dict). " "Consumed by NW_Connectivity or NW_SimConfig." ), ), @@ -301,8 +317,17 @@ def build(self, iclamp: Optional[Dict] = None) -> Dict[str, Any]: "builder": net, "pop_name": str(p["pop_name"]), "network_dir": network_dir, + # Parameters that end up inside the SONATA network files. Changing any of + # them invalidates the built network, so NW_SimConfig hashes this to decide + # whether to rebuild. nest_params is excluded: it is written to + # _params.json, which node_types.csv references by name, so its + # values are read at simulation time rather than baked into the h5. + "_signature": {k: v for k, v in p.items() if k not in ("nest_params",)}, } if iclamp: - out["current_clamp"] = iclamp + # Underscored: internal plumbing for NW_SimConfig, not a measurable + # value. Without the prefix it shows up in discover_measurables() as a + # candidate target, echoing back a parameter the user set. + out["_current_clamp"] = iclamp return {"population": out} diff --git a/src/neuroworkflow/nodes/optimization/JointOptimizationNode.py b/src/neuroworkflow/nodes/optimization/JointOptimizationNode.py deleted file mode 100644 index b4359d45..00000000 --- a/src/neuroworkflow/nodes/optimization/JointOptimizationNode.py +++ /dev/null @@ -1,391 +0,0 @@ -""" -Joint optimization node for optimizing parameters from multiple nodes. - -This module provides a node for evaluating simulation results from multiple nodes -and optimizing their parameters jointly. -""" - -from typing import Dict, Any, List, Callable, Optional -import numpy as np -from itertools import product - -from neuroworkflow.core.node import Node -from neuroworkflow.core.schema import NodeDefinitionSchema, PortDefinition, ParameterDefinition, MethodDefinition -from neuroworkflow.core.port import PortType - - -class JointOptimizationNode(Node): - """Node for jointly optimizing parameters from multiple nodes.""" - - NODE_DEFINITION = NodeDefinitionSchema( - type='joint_optimization', - description='Jointly optimizes parameters from multiple nodes', - - parameters={ - 'optimization_method': ParameterDefinition( - default_value='grid', - description='Optimization method (grid, random)', - constraints={'allowed_values': ['grid', 'random']} - ), - 'grid_points': ParameterDefinition( - default_value=4, - description='Number of points per dimension for grid search', - constraints={'min': 2, 'max': 10} - ), - 'max_iterations': ParameterDefinition( - default_value=100, - description='Maximum number of iterations', - constraints={'min': 1} - ) - }, - - inputs={ - 'simulation_results': PortDefinition( - type=PortType.DICT, - description='Simulation results from multiple nodes' - ), - 'parameter_metadata': PortDefinition( - type=PortType.DICT, - description='Optimization metadata for parameters from multiple nodes', - optional=True - ), - 'objective_target': PortDefinition( - type=PortType.FLOAT, - description='Target value for the objective function' - ), - 'iteration': PortDefinition( - type=PortType.INT, - description='Current iteration number', - optional=True - ) - }, - - outputs={ - 'error': PortDefinition( - type=PortType.FLOAT, - description='Calculated error value' - ), - 'evaluation_result': PortDefinition( - type=PortType.DICT, - description='Complete evaluation result' - ), - 'parameters': PortDefinition( - type=PortType.DICT, - description='Parameters for the next iteration (for all nodes)' - ) - }, - - methods={ - 'evaluate': MethodDefinition( - description='Evaluate simulation results', - inputs=['simulation_results', 'objective_target', 'iteration'], - outputs=['error', 'evaluation_result'] - ), - 'suggest_parameters': MethodDefinition( - description='Suggest parameters for next iteration', - inputs=['evaluation_result', 'parameter_metadata'], - outputs=['parameters'] - ) - } - ) - - def __init__(self, name: str): - """Initialize the JointOptimizationNode. - - Args: - name: Name of the node - """ - super().__init__(name) - self._define_process_steps() - self._optimization_history = [] - self._best_error = float('inf') - self._best_params = {} - self._best_simulation = None - self._param_grid = None - self._param_combinations = None - self._current_combination = 0 - self._param_sources = {} # Maps full parameter names to source nodes - self._current_parameters = {} # Tracks current parameters for all nodes - - def _define_process_steps(self) -> None: - """Define the process steps for this node.""" - self.add_process_step( - "evaluate", - self.evaluate, - method_key="evaluate" - ) - - self.add_process_step( - "suggest_parameters", - self.suggest_parameters, - method_key="suggest_parameters" - ) - - def evaluate(self, simulation_results: Dict[str, Any], objective_target: float, - iteration: int = 0) -> Dict[str, Any]: - """Evaluate simulation results using the objective function. - - Args: - simulation_results: Simulation results (without parameters) - objective_target: Target value for the objective function - iteration: Current iteration number - - Returns: - Dictionary with error and evaluation result - """ - # We already know what parameters were used from our internal tracking - all_parameters = self._current_parameters.copy() - - # Extract spike count from simulation results - spike_count = simulation_results.get('spike_count', 0) - if not spike_count and 'spike_times' in simulation_results: - spike_count = len(simulation_results['spike_times']) - - # Calculate error using default objective function (spike count) - print('here: ',objective_target) - objective_target = 10 ##error here - error = abs(spike_count - objective_target) - - # Create evaluation result - evaluation_result = { - 'iteration': iteration, - 'parameters': all_parameters, - 'error': error, - 'spike_count': spike_count, - 'objective_target': objective_target - } - - # Update optimization history - self._optimization_history.append(evaluation_result) - - # Update best result if better - if error < self._best_error: - self._best_error = error - self._best_params = all_parameters.copy() - self._best_simulation = simulation_results - - print(f"New best parameters at iteration {iteration}:") - for name, value in self._best_params.items(): - print(f" {name}: {value}") - print(f" Error: {self._best_error}") - - return { - 'error': error, - 'evaluation_result': evaluation_result - } - - def suggest_parameters(self, evaluation_result: Dict[str, Any], - parameter_metadata: Optional[Dict[str, Any]] = None) -> Dict[str, Any]: - """Suggest parameters for the next iteration. - - Implements grid search and random search optimization strategies for joint optimization - of parameters from multiple nodes. - - Args: - evaluation_result: Current evaluation result - parameter_metadata: Metadata about optimizable parameters from multiple nodes - - Returns: - Dictionary with suggested parameters for next iteration, grouped by node - """ - # Get current iteration and parameters - iteration = evaluation_result.get('iteration', 0) - current_params = evaluation_result.get('parameters', {}) - - # Get optimization method - method = self._parameters['optimization_method'] - - # Initialize next parameters - next_params_flat = {} - - # If we have parameter metadata, use it to determine optimization ranges - if parameter_metadata and not self._param_grid: - # Store which node each parameter comes from - self._param_sources = {} - optimizable_params = {} - - # Collect optimizable parameters and their ranges from all nodes - for node_name, node_metadata in parameter_metadata.items(): - for param_name, param_info in node_metadata.items(): - if param_info.get('optimizable', False): - full_param_name = f"{node_name}.{param_name}" - self._param_sources[full_param_name] = node_name - - # Get current value from evaluation result if available - current_value = None - if node_name in evaluation_result.get('simulation_results', {}): - node_results = evaluation_result['simulation_results'][node_name] - if 'parameters' in node_results and param_name in node_results['parameters']: - current_value = node_results['parameters'][param_name] - - # Use default value if current value not available - if current_value is None and param_name in current_params: - current_value = current_params.get(param_name) - - # Store parameter with its optimization range - if current_value is not None: - optimizable_params[full_param_name] = { - 'current_value': current_value, - 'range': param_info.get('range', []), - 'constraints': param_info.get('constraints', {}) - } - - # Now create the parameter grid based on the method - if method == 'grid': - self._create_grid_search(optimizable_params) - elif method == 'random': - # For random search, we'll just store the parameter ranges - self._param_ranges = optimizable_params - - # Generate next parameters based on the method - if method == 'grid': - next_params_flat = self._get_next_grid_parameters() - elif method == 'random': - next_params_flat = self._get_random_parameters() - - # Group parameters by their source node - next_params_by_node = self._group_parameters_by_node(next_params_flat) - - # Store the current parameters for tracking - self._current_parameters = next_params_flat.copy() - - return { - 'parameters': next_params_by_node - } - - def _create_grid_search(self, optimizable_params: Dict[str, Dict[str, Any]]) -> None: - """Create a grid search for the given optimizable parameters. - - Args: - optimizable_params: Dictionary of optimizable parameters with their metadata - """ - self._param_grid = {} - grid_points = self._parameters['grid_points'] - - for param_name, param_info in optimizable_params.items(): - current_value = param_info['current_value'] - - # Use defined optimization range if available - if param_info['range'] and len(param_info['range']) == 2: - min_val, max_val = param_info['range'] - else: - # Fallback to scaling current value - min_val = current_value * 0.8 - max_val = current_value * 1.2 - - # Create linspace for this parameter - self._param_grid[param_name] = np.linspace(min_val, max_val, grid_points) - - # Generate all parameter combinations - param_names = list(self._param_grid.keys()) - param_values = [self._param_grid[name] for name in param_names] - self._param_combinations = list(product(*param_values)) - self._current_combination = 0 - - print(f"Grid search: {len(self._param_combinations)} parameter combinations") - - def _get_next_grid_parameters(self) -> Dict[str, Any]: - """Get the next parameter combination from the grid search. - - Returns: - Dictionary with parameter names and values - """ - if not self._param_grid or not self._param_combinations: - return {} - - # If we've tried all combinations, return the best parameters - if self._current_combination >= len(self._param_combinations): - print("Grid search complete - using best parameters") - return self._best_params.copy() - - # Get the next combination - combination = self._param_combinations[self._current_combination] - param_names = list(self._param_grid.keys()) - next_params = {name: value for name, value in zip(param_names, combination)} - - self._current_combination += 1 - return next_params - - def _get_random_parameters(self) -> Dict[str, Any]: - """Generate random parameters within the optimization ranges. - - Returns: - Dictionary with parameter names and values - """ - if not hasattr(self, '_param_ranges') or not self._param_ranges: - return {} - - next_params = {} - - for param_name, param_info in self._param_ranges.items(): - current_value = param_info['current_value'] - - # Use defined optimization range if available - if param_info['range'] and len(param_info['range']) == 2: - min_val, max_val = param_info['range'] - else: - # Fallback to scaling current value - min_val = current_value * 0.8 - max_val = current_value * 1.2 - - # Generate random value within range - next_params[param_name] = np.random.uniform(min_val, max_val) - - return next_params - - def _group_parameters_by_node(self, flat_params: Dict[str, Any]) -> Dict[str, Dict[str, Any]]: - """Group parameters by their source node. - - Args: - flat_params: Dictionary with full parameter names (node.param) and values - - Returns: - Dictionary with parameters grouped by node - """ - params_by_node = {} - - for full_param_name, value in flat_params.items(): - # Split the parameter name to get node and parameter - if '.' in full_param_name: - node_name, param_name = full_param_name.split('.', 1) - elif full_param_name in self._param_sources: - # Use stored mapping if available - node_name = self._param_sources[full_param_name] - param_name = full_param_name.split('.', 1)[1] if '.' in full_param_name else full_param_name - else: - # Skip parameters we can't map to a node - continue - - # Initialize node dictionary if needed - if node_name not in params_by_node: - params_by_node[node_name] = {} - - # Add parameter to the node - params_by_node[node_name][param_name] = value - - return params_by_node - - def get_optimization_results(self) -> Dict[str, Any]: - """Get the current optimization results. - - Returns: - Dictionary with optimization results - """ - return { - 'best_parameters': self._best_params, - 'best_error': self._best_error, - 'best_simulation': self._best_simulation, - 'history': self._optimization_history - } - - def reset_optimization(self) -> None: - """Reset the optimization state.""" - self._optimization_history = [] - self._best_error = float('inf') - self._best_params = {} - self._best_simulation = None - self._param_grid = None - self._param_combinations = None - self._current_combination = 0 - self._param_sources = {} - self._current_parameters = {} \ No newline at end of file diff --git a/src/neuroworkflow/nodes/optimization/NW_Optimization.py b/src/neuroworkflow/nodes/optimization/NW_Optimization.py new file mode 100644 index 00000000..39ba4ac4 --- /dev/null +++ b/src/neuroworkflow/nodes/optimization/NW_Optimization.py @@ -0,0 +1,126 @@ +from typing import Any, Dict + +from neuroworkflow.core.node import Node +from neuroworkflow.core.schema import ( + NodeDefinitionSchema, ParameterDefinition, +) + + +class NW_Optimization(Node): + """Declares how to search a workflow's parameter space. + + This node holds *how* to search — algorithm and budget. It deliberately does not + hold *what* to search or *what to hit*: those live on the parameters themselves, + as ``optimizable`` / ``optimization_range`` and ``is_objective`` / + ``objective_range`` / ``measures``. Duplicating them here would create two + sources of truth that can disagree. + + It is also not a step in the workflow. A workflow is a DAG that runs once; a + search is a loop that runs it many times, so the loop cannot be a node inside + the graph. Placing this node marks a workflow as one to optimize, and the code + generator emits an optimization run instead of a single execution. It has no + ports and no process steps, so adding it to a workflow changes nothing about + how that workflow executes. + + Typical use, once the workflow is built:: + + opt = NW_Optimization("opt") + opt.configure(algorithm="cmaes", pop_size=16, max_generations=12) + + spec = build_spec(workflow, opt.algorithm_config()) + result = optimize(workflow, spec=spec, results_path=opt.results_path()) + """ + + NODE_DEFINITION = NodeDefinitionSchema( + type="nw_optimization", + stage="optimization", + tool="custom", + model_source="https://github.com/oist/neuro-workflow", + description=( + "Declares how to search a workflow's parameter space: which algorithm and " + "how large a budget. What to explore and what to hit are declared on the " + "parameters themselves, not here. Its presence marks the workflow as one " + "to optimize; it takes no part in the workflow's own execution." + ), + parameters={ + "algorithm": ParameterDefinition( + default_value="cmaes", + description=( + "Search algorithm. 'cmaes' is the default for a single objective and " + "continuous parameters; 'tpe' when each trial is expensive; 'nsga2' or " + "'nsga3' for several objectives, returning a Pareto front; 'random' as " + "a dependency-free baseline. Everything except 'random' needs Optuna " + "(pip install optuna cmaes)." + ), + constraints={"allowed_values": ["random", "cmaes", "tpe", + "nsga2", "nsga3", "optuna_random"]}, + ), + "pop_size": ParameterDefinition( + default_value=16, + description=( + "Candidates proposed per generation, i.e. workflow runs before the " + "algorithm learns from them and proposes the next batch." + ), + constraints={"min": 1}, + ), + "max_generations": ParameterDefinition( + default_value=20, + description=( + "Generation budget. At most pop_size x max_generations runs, plus one " + "baseline; the search stops earlier once a candidate lands inside every " + "target band." + ), + constraints={"min": 1}, + ), + "seed": ParameterDefinition( + default_value=None, + description=( + "Random seed, making a run reproducible. Leave empty for an unseeded run." + ), + ), + "options": ParameterDefinition( + default_value={}, + description=( + "Extra keyword arguments passed straight to the underlying sampler, e.g. " + "{\"sigma0\": 0.2} for CMA-ES or {\"n_startup_trials\": 20} for TPE. " + "Names are the sampler's own." + ), + ), + "results_path": ParameterDefinition( + default_value="results/optimization", + description=( + "Directory the run is written under. Each run creates its own " + "subdirectory holding the manifest, the per-trial log, live status and " + "the per-trial results." + ), + ), + }, + inputs={}, + outputs={}, + methods={}, + ) + + def __init__(self, name: str): + super().__init__(name) + + def algorithm_config(self): + """This node's settings as an ``AlgorithmConfig`` for ``build_spec()``.""" + from neuroworkflow.optimization import AlgorithmConfig + + p = self._parameters + seed = p["seed"] + return AlgorithmConfig( + name=str(p["algorithm"]), + pop_size=int(p["pop_size"]), + max_generations=int(p["max_generations"]), + seed=None if seed in (None, "") else int(seed), + options=dict(p["options"] or {}), + ) + + def results_path(self) -> str: + """Where the run's ledger and per-trial results are written.""" + return str(self._parameters["results_path"]) + + def summary(self) -> Dict[str, Any]: + """The declared settings, for printing or logging.""" + return dict(self._parameters) diff --git a/src/neuroworkflow/nodes/optimization/__init__.py b/src/neuroworkflow/nodes/optimization/__init__.py index 91ca5162..a3b25058 100644 --- a/src/neuroworkflow/nodes/optimization/__init__.py +++ b/src/neuroworkflow/nodes/optimization/__init__.py @@ -1,9 +1,12 @@ """ Optimization nodes for NeuroWorkflow. -This package contains nodes for parameter optimization in neural simulations. +Optimization itself is not a step inside a workflow: a workflow is a DAG that runs +once, while a search is a loop that runs it repeatedly. The loop therefore lives +outside the graph, in ``neuroworkflow.optimization``. -Import nodes directly from their modules: - from neuroworkflow.nodes.optimization.JointOptimizationNode import JointOptimizationNode -""" +What belongs here is the *specification* of a search — which algorithm, how large a +budget — carried as an ordinary node so it can be placed and edited like any other: + from neuroworkflow.nodes.optimization.NW_Optimization import NW_Optimization +""" diff --git a/src/neuroworkflow/nodes/simulation/NW_SimConfig.py b/src/neuroworkflow/nodes/simulation/NW_SimConfig.py index a2e7983c..ad6c892e 100644 --- a/src/neuroworkflow/nodes/simulation/NW_SimConfig.py +++ b/src/neuroworkflow/nodes/simulation/NW_SimConfig.py @@ -31,6 +31,13 @@ class NW_SimConfig(Node): ports, or collect them in a list via a fan-in node. """ + #: Artifacts under results_path that a later run can reuse when nothing + #: structural changed — read by the optimization engine, which copies them into + #: each trial so this node's signature check can skip rebuilding. The SONATA + #: network is expensive to build (connection rules are evaluated here) and + #: identical whenever only simulation-time values move. + REUSABLE_PATHS = ("network",) + NODE_DEFINITION = NodeDefinitionSchema( type="nw_sim_config", stage="simulation", @@ -92,13 +99,25 @@ class NW_SimConfig(Node): default_value=True, description="Overwrite existing config files and network files.", ), + "rebuild_network": ParameterDefinition( + default_value="auto", + description=( + "When to regenerate the SONATA network files. 'auto' rebuilds only when " + "a structural parameter changed (population size, neuron model, " + "connectivity, synaptic weights) or the files are missing — values that " + "are read at simulation time (nest_params, synapse dynamics_params_dict) " + "never trigger a rebuild. 'always' rebuilds every run. 'never' reuses " + "whatever is on disk." + ), + constraints={"allowed_values": ["auto", "always", "never"]}, + ), }, inputs={ "populations": PortDefinition( type=PortType.OBJECT, description=( "Single population from NW_Population, or network dict from NW_Connectivity. " - "Single pop keys: builder, pop_name, network_dir, optional current_clamp. " + "Single pop keys: builder, pop_name, network_dir, optional _current_clamp. " "Network dict (multi-pop): keyed by pop_name, each value has the same keys." ), ), @@ -137,6 +156,76 @@ def _define_process_steps(self) -> None: self.add_process_step("setup", self.setup, method_key="setup") self.add_process_step("run", self.run, method_key="run") + @staticmethod + def _stable(value): + """A representation that is identical run to run for unchanged inputs. + + connection_rule may be a callable. repr() of a function embeds its memory + address, which differs on every run, so the signature would never match and + the network would be rebuilt every time. Use the source text instead, plus any + closure values (which the source does not show — changing `eps` in + `lambda s, t: 1 if rand() < eps else 0` leaves the text identical), and fall + back to the bytecode when source is unavailable. + """ + if callable(value): + import inspect + try: + text = inspect.getsource(value).strip() + except (OSError, TypeError): + text = value.__code__.co_code.hex() + repr(value.__code__.co_consts) + # Values the rule reads but does not show in its source. A lambda written + # in a notebook usually reads them as globals (`eps`), not as closure + # cells, so both are captured — otherwise changing eps would leave the + # signature identical and silently reuse a network built with the old value. + referenced = [] + for cell in (value.__closure__ or []): + try: + referenced.append(repr(cell.cell_contents)) + except ValueError: + referenced.append("") + simple = (int, float, str, bool, type(None)) + for name in sorted(value.__code__.co_names): + if name in value.__globals__: + referenced_value = value.__globals__[name] + if isinstance(referenced_value, simple): + referenced.append(f"{name}={referenced_value!r}") + return f"callable:{text}:{referenced}" + if isinstance(value, dict): + return {k: NW_SimConfig._stable(v) for k, v in sorted(value.items())} + if isinstance(value, (list, tuple)): + return [NW_SimConfig._stable(v) for v in value] + return value + + def _network_signature(self, pop_list): + """Hash of everything that ends up inside the SONATA network files.""" + import hashlib + import json + + parts = {pop["pop_name"]: self._stable(pop.get("_signature", {})) + for pop in pop_list} + blob = json.dumps(parts, sort_keys=True, default=repr) + return hashlib.sha256(blob.encode()).hexdigest(), parts + + def _network_is_current(self, network_dir, pop_list, digest): + """True when the network on disk was built from these same parameters.""" + import json + import os + + path = os.path.join(network_dir, ".signature.json") + if not os.path.exists(path): + return False + try: + with open(path) as fh: + stored = json.load(fh) + except (ValueError, OSError): + return False + if stored.get("hash") != digest: + return False + return all( + os.path.exists(os.path.join(network_dir, f"{pop['pop_name']}_nodes.h5")) + for pop in pop_list + ) + def setup(self, populations: Dict) -> Dict[str, Any]: import json import os @@ -165,9 +254,25 @@ def setup(self, populations: Dict) -> Dict[str, Any]: ]: os.makedirs(os.path.join(base_dir, subdir), exist_ok=True) - for pop in pop_list: - pop["builder"].build() - pop["builder"].save(output_dir=network_dir) + mode = str(p["rebuild_network"]).lower() + digest, parts = self._network_signature(pop_list) + current = self._network_is_current(network_dir, pop_list, digest) + + if mode == "never": + if current: + print(f"[NW_SimConfig] network unchanged, reusing {network_dir}") + else: + print("[NW_SimConfig] rebuild_network='never': the network on disk does " + f"not match the current parameters, reusing it anyway: {network_dir}") + elif mode == "always" or not current: + for pop in pop_list: + pop["builder"].build() + pop["builder"].save(output_dir=network_dir) + with open(os.path.join(network_dir, ".signature.json"), "w") as fh: + json.dump({"hash": digest, "parameters": parts}, fh, indent=2, default=repr) + print(f"[NW_SimConfig] network built in {network_dir}") + else: + print(f"[NW_SimConfig] network unchanged, reusing {network_dir}") kwargs: Dict[str, Any] = dict( base_dir=base_dir, @@ -181,8 +286,8 @@ def setup(self, populations: Dict) -> Dict[str, Any]: # current_clamp lives in the primary pop (single-pop case only) primary = pop_list[0] - if primary.get("current_clamp"): - kwargs["current_clamp"] = primary["current_clamp"] + if primary.get("_current_clamp"): + kwargs["current_clamp"] = primary["_current_clamp"] create_environment(str(p["simulator"]), **kwargs) diff --git a/src/neuroworkflow/optimization/__init__.py b/src/neuroworkflow/optimization/__init__.py index 9d1453fb..17c7fb55 100644 --- a/src/neuroworkflow/optimization/__init__.py +++ b/src/neuroworkflow/optimization/__init__.py @@ -11,7 +11,8 @@ """ from .addressing import discover_measurables, read_output, set_parameter -from .engine import OptimizationResult, objective_fitness, optimize +from .engine import (OptimizationResult, objective_fitness, optimize, + reusable_paths) from .ledger import Ledger from .optimizers import Optimizer, available, register_optimizer from .spec import ( @@ -40,6 +41,7 @@ "objective_fitness", "optimize", "read_output", + "reusable_paths", "register_optimizer", "set_parameter", ] diff --git a/src/neuroworkflow/optimization/addressing.py b/src/neuroworkflow/optimization/addressing.py index d53f1f97..91f7e177 100644 --- a/src/neuroworkflow/optimization/addressing.py +++ b/src/neuroworkflow/optimization/addressing.py @@ -122,7 +122,11 @@ def walk(prefix: str, value: Any, depth: int) -> None: return if isinstance(value, dict) and depth < MAX_LEAF_DEPTH: for k, v in value.items(): - if isinstance(k, str): + # A leading underscore marks a key as internal plumbing a node passes + # to another node — not something anyone would target. Without this, + # a builder's bookkeeping shows up in the menu of measurable values + # alongside the real measurements. + if isinstance(k, str) and not k.startswith("_"): walk(f"{prefix}.{k}", v, depth + 1) for node_name, node in workflow.nodes.items(): diff --git a/src/neuroworkflow/optimization/engine.py b/src/neuroworkflow/optimization/engine.py index 2f2dd2c2..093fb201 100644 --- a/src/neuroworkflow/optimization/engine.py +++ b/src/neuroworkflow/optimization/engine.py @@ -14,10 +14,12 @@ ledger and writing ``control.json`` — nothing here requires that to happen. """ +import os +import shutil import time from dataclasses import dataclass, field from datetime import datetime -from typing import Any, Callable, Dict, List, Optional +from typing import Any, Callable, Dict, List, Optional, Sequence from .addressing import read_output, set_parameter from .ledger import Ledger @@ -41,18 +43,52 @@ class OptimizationResult: pareto_front: List[Dict[str, Any]] = field(default_factory=list) stop_reason: str = "" + def apply_best(self, workflow, execute: bool = False) -> bool: + """Set the workflow's parameters to those of the best trial. + + The search leaves the workflow configured with whatever the *last* trial + used, which is rarely the best one. This applies the winner instead. + + Deliberately opt-in: parameters define a run, so the loop never writes a + result back on its own. With ``execute=True`` the workflow is re-run + afterwards, so its output ports match its parameters again — without it, + the ports still hold the last trial's values. + """ + if not self.best: + return False + for address, value in self.best["params"].items(): + set_parameter(workflow, address, value) + return workflow.execute() if execute else True + def configure_snippet(self) -> str: - """A ready-to-paste snippet applying the best configuration.""" + """A ready-to-paste snippet applying the best configuration. + + A dict key cannot be passed as a keyword argument, so those are emitted as + a copy of the current dict with the tuned keys replaced — the same + read-modify-write a notebook does by hand. + """ if not self.best: return "# no successful trial" - by_node: Dict[str, Dict[str, Any]] = {} + + scalars: Dict[str, Dict[str, Any]] = {} + nested: Dict[str, Dict[str, Dict[str, Any]]] = {} for address, value in self.best["params"].items(): node, _, rest = address.partition(".") - by_node.setdefault(node, {})[rest] = value + param, _, key = rest.partition(".") + if key: + nested.setdefault(node, {}).setdefault(param, {})[key] = value + else: + scalars.setdefault(node, {})[param] = value + lines = [] - for node, params in by_node.items(): - args = ", ".join(f"{k.replace('.', '__')}={v!r}" for k, v in params.items()) - lines.append(f"{node}.configure({args})") + for node in dict.fromkeys(list(scalars) + list(nested)): + args = [f"{k}={v!r}" for k, v in scalars.get(node, {}).items()] + for param, keys in nested.get(node, {}).items(): + updates = ", ".join(f'"{k}": {v!r}' for k, v in keys.items()) + args.append( + f'{param}={{**{node}._parameters["{param}"], {updates}}}' + ) + lines.append(f"{node}.configure({', '.join(args)})") return "\n".join(lines) @@ -78,6 +114,126 @@ def objective_fitness(objective: Objective, value: float) -> float: return 0.0 +def objective_scales(spec) -> List[float]: + """The scale each objective's distance is measured against, one per objective. + + Misses live in each objective's own unit — Hz for one, ms for another — so they + cannot be added or compared as they stand. Dividing each by its own scale makes them + comparable, and for a target range the natural scale is the width of that range: by + asking for 40-50 Hz the user already said a 10 Hz spread is acceptable. It also + avoids the usual difficulty of scaling by the nadir point, which needs knowledge of + the Pareto front we do not have. + + Falls back to the magnitude of the target when a range has zero width, and to the + baseline measurement for a minimize/maximize goal, which has no range at all. + """ + scales = [] + for objective in spec.objectives: + scale = None + if objective.goal == "in_range" and objective.low is not None and objective.high is not None: + width = float(objective.high) - float(objective.low) + if width > 0: + scale = width + else: + scale = abs(float(objective.high)) or None + else: + baseline = (spec.baseline.get("measured") or {}).get(objective.name) + if isinstance(baseline, (int, float)) and baseline: + scale = abs(float(baseline)) + scales.append(scale or 1.0) + return scales + + +def target_ranges_off(spec, fitness: Optional[Sequence[float]]) -> Optional[float]: + """How far the worst objective missed, counted in its own target range. + + One objective, targeted at 40-50 Hz, is a target range 10 Hz wide. A trial measuring + 25.9 Hz missed it by 14.1 Hz, so 14.1 / 10 = 1.4: the miss is 1.4 times the size of + the range that was asked for. 0 means the value landed inside the range. + + Dividing is what makes two objectives comparable at all: a 14.1 Hz miss and an 8.2 ms + miss cannot be ranked as they stand, but "1.4 times its range" and "0.4 times its + range" can. The divisor comes from the user, who said by choosing 40-50 that a 10 Hz + spread is acceptable. + + The value reported is the LARGEST of the objectives, not their sum: a trial is only + as good as whatever it is doing worst, so 0 requires every objective to be inside its + range. (Adding them would need a unit they do not share, and would quietly favour + whichever objective uses bigger numbers.) + + Only ever used for reporting and for picking a representative. What the optimizer is + told stays raw and per-objective, so the search itself is unaffected. + """ + worst = worst_objective(spec, fitness) + return None if worst is None else worst[1] + + +def worst_objective(spec, fitness: Optional[Sequence[float]]): + """The objective furthest from its target, as ``(name, target ranges missed by)``.""" + if fitness is None: + return None + scales = objective_scales(spec) + ranked = [(o.name, abs(f) / s) + for o, f, s in zip(spec.objectives, fitness, scales)] + return max(ranked, key=lambda pair: pair[1], default=None) + + +def reusable_paths(workflow) -> List[str]: + """Artifacts the workflow's nodes say a later run can reuse. + + A node opts in with a class attribute, relative to ``results_path``:: + + class MyBuilder(Node): + REUSABLE_PATHS = ("network",) + + The engine neither knows nor cares what they contain — only that copying them + into a trial lets a node recognise its own earlier work as still current and + skip redoing it. A node that declares nothing simply gets no help, which is + the correct default for any node whose outputs are cheap or always differ. + """ + names = set() + for node in workflow.nodes.values(): + for name in getattr(type(node), "REUSABLE_PATHS", ()) or (): + name = str(name).strip() + # Relative names only: a declaration must not reach outside the trial. + if name and not os.path.isabs(name) and ".." not in name.split(os.sep): + names.add(name) + return sorted(names) + + +def _point_at_trial_dir(workflow, run_dir: str, trial_no: int, + seed_root: Optional[str] = None, + seed_names: Sequence[str] = ()) -> str: + """Give a trial its own results directory and return it. + + Nodes that write files — a network builder, a simulator config — otherwise + rewrite the same paths on every trial. Beyond losing each trial's outputs, + rebuilding a file in place can fail outright while a handle from the previous + trial is still open. This is the same thing a notebook does by hand when it + re-runs a workflow into a fresh directory. + + Anything the nodes declared reusable is copied in from ``seed_root``, so a + trial that changes nothing relevant can skip rebuilding it. Sharing one + directory between trials would save the copy, but a trial that *does* change + the artifact would then rewrite it in place — the failure this isolation + exists to prevent. + """ + trial_dir = os.path.join(run_dir, "trials", f"{trial_no:04d}") + os.makedirs(trial_dir, exist_ok=True) + + if seed_root: + for name in seed_names: + source = os.path.join(seed_root, name) + target = os.path.join(trial_dir, name) + if os.path.isdir(source) and not os.path.exists(target): + shutil.copytree(source, target) + + workflow.context["results_path"] = trial_dir + for node in workflow.nodes.values(): + node._context["results_path"] = trial_dir + return trial_dir + + def _dominates(a: List[float], b: List[float]) -> bool: return all(x <= y for x, y in zip(a, b)) and any(x < y for x, y in zip(a, b)) @@ -101,6 +257,8 @@ def optimize(workflow, algorithm: Optional[AlgorithmConfig] = None, reject_fn: Optional[RejectFn] = None, run_id: Optional[str] = None, + per_trial_results: bool = True, + stop_when_reached: Optional[bool] = None, verbose: bool = True) -> OptimizationResult: """Optimize a built workflow against the targets declared in its schemas. @@ -112,6 +270,22 @@ def optimize(workflow, algorithm: algorithm config, when letting the spec be built here. reject_fn: optional dynamics check; return a reason to reject a trial. run_id: overrides the generated run id. + per_trial_results: give each trial its own results directory under the + run (default). Any workflow whose nodes write files needs this: + rewriting the same paths every trial loses each trial's outputs, and + rebuilding a file in place can fail outright while a handle from the + previous trial is still open. A workflow that writes nothing loses + nothing by having it on, so set it False only to keep every trial in + one directory on purpose. The workflow's results_path is left + pointing at the last trial when the run ends. + stop_when_reached: end the run as soon as one candidate satisfies every + target. Defaults to True for a single objective — the question is + answered, so more simulations are waste — and to False for several, + where the useful answer is the Pareto front: the set of trade-offs + between objectives. Stopping at the first candidate that satisfies + everything would return a front of one, which says nothing about the + trade-off. Only targets expressed as a band can be "reached" at all; + a minimize or maximize goal has nothing to hit, so it never triggers. verbose: narrate progress to stdout. """ if spec is None: @@ -120,8 +294,19 @@ def optimize(workflow, spec.algorithm = algorithm spec.validate() - run_id = run_id or f"opt_{datetime.now().strftime('%Y%m%d_%H%M%S')}" - ledger = Ledger(f"{results_path}/{run_id}", run_id) + if stop_when_reached is None: + stop_when_reached = len(spec.objectives) == 1 + + if run_id is None: + # Second-resolution timestamps collide when runs start in the same second, + # which would silently append one run's trials to another's ledger. + run_id = base_id = f"opt_{datetime.now().strftime('%Y%m%d_%H%M%S')}" + attempt = 2 + while os.path.exists(os.path.join(results_path, run_id)): + run_id = f"{base_id}_{attempt}" + attempt += 1 + + ledger = Ledger(os.path.join(results_path, run_id), run_id) ledger.write_manifest(spec, extra={ "created_at": datetime.now().isoformat(timespec="seconds"), "workflow_name": getattr(workflow, "name", ""), @@ -139,7 +324,20 @@ def say(message: str) -> None: f"x {spec.algorithm.pop_size} candidates") for line in spec.summary().splitlines(): say(" " + line) - + if len(spec.objectives) > 1: + say(" each objective reports how far it missed, in its own unit. To compare " + "objectives measured in different units, that miss is also given as a " + "multiple of the target range asked for: '1.4x its target range' means the " + "miss is 1.4 times as wide as the range. 0 = the target was met.") + + # Captured before the first rotation: where the baseline ran, and whatever the + # nodes declared as reusable from it. + seed_root = workflow.context.get("results_path") if per_trial_results else None + seed_names = reusable_paths(workflow) if per_trial_results else [] + if seed_root and seed_names: + say(f" reusing {', '.join(seed_names)} from {seed_root}") + + reported_reached = False trials: List[Dict[str, Any]] = [] best_by_generation: List[Optional[float]] = [] control_ack: Optional[Dict[str, Any]] = None @@ -153,26 +351,46 @@ def say(message: str) -> None: for index, candidate in enumerate(candidates): trial_no += 1 + trial_dir = (_point_at_trial_dir(workflow, str(ledger.run_dir), trial_no, + seed_root, seed_names) + if per_trial_results else None) row = _evaluate(workflow, spec, candidate, reject_fn, - trial_no, generation, index) + trial_no, generation, index, trial_dir) fitnesses.append(row["fitness"]) trials.append(row) ledger.append_trial(row) + previous = [t for t in trials[:-1] if t["target_ranges_off"] is not None] + is_best = row["target_ranges_off"] is not None and ( + not previous or row["target_ranges_off"] < min(t["target_ranges_off"] for t in previous) + ) + say(" " + _narrate_trial(spec, row, generation, index, + spec.algorithm.pop_size, is_best)) + optimizer.tell(candidates, fitnesses) scored = [t for t in trials if t["fitness"] is not None] - best = min(scored, key=lambda t: sum(t["fitness"]), default=None) - best_by_generation.append(round(sum(best["fitness"]), 6) if best else None) - - in_range = bool(best and all(f == 0.0 for f in best["fitness"])) + best = min(scored, key=lambda t: t["target_ranges_off"], default=None) + best_by_generation.append(round(best["target_ranges_off"], 6) if best else None) + + # "Reached" only means something for a target expressed as a band: a + # minimize or maximize goal has no value that counts as arrival. + bands = [i for i, o in enumerate(spec.objectives) if o.goal == "in_range"] + in_range = bool( + best and bands and len(bands) == len(spec.objectives) + and all(best["fitness"][i] == 0.0 for i in bands) + ) n_failed = sum(1 for t in trials if t["status"] == "failed") n_rejected = sum(1 for t in trials if t["status"] == "rejected") # Stop conditions, checked before honouring control so an explicit # command always wins over an automatic stop. - if in_range: + if in_range and stop_when_reached: stop_reason = "a candidate is inside every target band" + elif in_range and not reported_reached: + reported_reached = True + say(" a candidate satisfies every target; continuing to develop " + "the Pareto front") command = ledger.read_control() if command: @@ -191,7 +409,7 @@ def say(message: str) -> None: "best": best, "pareto_front": _pareto_front(trials) if len(spec.objectives) > 1 else [], "progress": { - "best_fitness_by_gen": best_by_generation, + "best_target_ranges_off_by_gen": best_by_generation, "gens_since_improvement": _gens_since_improvement(best_by_generation), }, "control_ack": control_ack, @@ -219,8 +437,47 @@ def say(message: str) -> None: stop_reason = "generation budget exhausted" scored = [t for t in trials if t["fitness"] is not None] - best = min(scored, key=lambda t: sum(t["fitness"]), default=None) + best = min(scored, key=lambda t: t["target_ranges_off"], default=None) + front = _pareto_front(trials) if len(spec.objectives) > 1 else [] + + # A final status write, so a reader sees the run end. The per-generation write + # happens before the loop decides to stop, and the budget-exhausted case is + # decided after the loop entirely — without this, status.json would sit at + # "running" forever. + ledger.write_status({ + "state": "done", + "updated_at": datetime.now().isoformat(timespec="seconds"), + "generation": generation, + "max_generations": spec.algorithm.max_generations, + "n_evals": len(trials), + "n_ok": len(scored), + "n_failed": sum(1 for t in trials if t["status"] == "failed"), + "n_rejected": sum(1 for t in trials if t["status"] == "rejected"), + "best": best, + "pareto_front": front, + "progress": { + "best_target_ranges_off_by_gen": best_by_generation, + "gens_since_improvement": _gens_since_improvement(best_by_generation), + }, + "control_ack": control_ack, + "stop_reason": stop_reason, + "message": f"finished after {len(trials)} evaluations: {stop_reason}", + }) + say(f"[{run_id}] stopped: {stop_reason}") + if best: + for objective, distance in zip(spec.objectives, best["fitness"]): + unit = f" {objective.unit}" if objective.unit else "" + band = (f"target {objective.low}-{objective.high}{unit}" + if objective.goal == "in_range" else objective.goal) + state = "in target" if distance == 0.0 else f"off {distance:.4g}{unit}" + say(f" {objective.name} = {best['measured'][objective.name]:.4g}{unit}" + f" ({band}, {state})") + if len(spec.objectives) > 1: + furthest = worst_objective(spec, best["fitness"]) + if furthest and furthest[1] > 0: + say(f" furthest from target: {furthest[0]}, " + f"{furthest[1]:.3g}x its target range") return OptimizationResult( run_id=run_id, @@ -228,13 +485,14 @@ def say(message: str) -> None: spec=spec, trials=trials, best=best, - pareto_front=_pareto_front(trials) if len(spec.objectives) > 1 else [], + pareto_front=front, stop_reason=stop_reason, ) def _evaluate(workflow, spec, candidate, reject_fn, - trial_no: int, generation: int, index: int) -> Dict[str, Any]: + trial_no: int, generation: int, index: int, + trial_dir: Optional[str] = None) -> Dict[str, Any]: """Run one candidate and produce its ledger row.""" started = time.time() row: Dict[str, Any] = { @@ -244,6 +502,7 @@ def _evaluate(workflow, spec, candidate, reject_fn, "started_at": datetime.now().isoformat(timespec="seconds"), "source": "ask", "params": dict(candidate), + "results_path": trial_dir, "measured": {}, "fitness": None, "status": "ok", @@ -281,10 +540,14 @@ def _evaluate(workflow, spec, candidate, reject_fn, except Exception as exc: # a bad candidate must not kill the run row.update(status="failed", error=f"{type(exc).__name__}: {exc}") + # Normalised, unit-free, for ranking and reporting only — the raw per-objective + # fitness above is what the optimizer was told. + row["target_ranges_off"] = target_ranges_off(spec, row["fitness"]) return _finish(row, started) def _finish(row: Dict[str, Any], started: float) -> Dict[str, Any]: + row.setdefault("target_ranges_off", None) row["duration_s"] = round(time.time() - started, 3) return row @@ -341,17 +604,92 @@ def _gens_since_improvement(history: List[Optional[float]]) -> int: return len(history) +def _narrate_trial(spec, row, generation, index, pop_size, is_best) -> str: + """One line per trial: which trial, what it tried, what came out. + + A generation line alone leaves long stretches of simulator logging with nothing + readable in them, and hides the fact that the search is exploring rather than + stuck. + """ + label = f"gen {generation}, trial {index + 1}/{pop_size} (#{row['trial']})" + + tried = " ".join( + f"{d.address}={row['params'][d.address]:.4g}" + f"{' ' + d.unit if d.unit else ''}" + for d in spec.dimensions + ) + + if row["status"] != "ok": + why = row.get("reject_reason") or row.get("error") or "" + return f"{label}: {tried} -> {row['status']}: {why}" + + # Each distance in its own unit. Adding them would mean adding, say, Hz to ms — + # a number with no meaning, dominated by whichever objective has the larger range. + got = [] + for objective, distance in zip(spec.objectives, row["fitness"]): + unit = f" {objective.unit}" if objective.unit else "" + state = "in target" if distance == 0.0 else f"off {distance:.4g}{unit}" + got.append(f"{objective.name.split('.')[-1]}=" + f"{row['measured'][objective.name]:.4g}{unit} ({state})") + + # With one objective the miss above says everything. With several, name the one + # doing worst and size its miss against its own target range, the only way to + # compare a miss in Hz with a miss in ms. + worst = "" + if len(spec.objectives) > 1: + furthest = worst_objective(spec, row["fitness"]) + if furthest and furthest[1] > 0: + worst = (f"\n furthest from target: {furthest[0]}, " + f"{furthest[1]:.3g}x its target range") + elif furthest: + worst = "\n every target met" + + # The marker ranks this trial against the others, so it belongs on the line of + # measurements — not after the indented line below, which compares this trial's + # own objectives against each other. + marker = " <- best so far" if is_best else "" + return f"{label}: {tried} -> {', '.join(got)}{marker}{worst}" + + def _narrate(generation, spec, best, in_range, n_failed, n_rejected) -> str: + """One line per generation: what the best candidate measured, against the goal. + + The goal is repeated every generation on purpose. A long run scrolls the spec far + out of view, and "46 Hz" means nothing without "target 40-50 Hz" beside it. + """ if best is None: return "no candidate has produced a usable measurement yet" - values = ", ".join( - f"{o.name.split('.')[-1]}={best['measured'][o.name]:.4g}" - f"{' ' + o.unit if o.unit else ''}" - for o in spec.objectives + + # The parameter values that produced it, so a generation line answers both + # "how good" and "with what". + values = " ".join( + f"{d.address}={best['params'][d.address]:.4g}" + f"{' ' + d.unit if d.unit else ''}" + for d in spec.dimensions ) - state = "inside every target band" if in_range else \ - f"distance {sum(best['fitness']):.4g}" + + parts = [] + for objective, distance in zip(spec.objectives, best["fitness"]): + unit = f" {objective.unit}" if objective.unit else "" + goal = (f"target {objective.low}-{objective.high}{unit}" + if objective.goal == "in_range" else objective.goal) + state = "in target" if distance == 0.0 else f"off {distance:.4g}{unit}" + parts.append( + f"{objective.name.split('.')[-1]}=" + f"{best['measured'][objective.name]:.4g}{unit} [{goal}, {state}]" + ) + + if in_range: + state = " — all targets met" + elif len(spec.objectives) > 1: + # "its" on purpose: this line is about the best trial, and the objective named + # is the weakest one inside that trial — not a comparison against other trials. + furthest = worst_objective(spec, best["fitness"]) + state = (f" — its furthest objective from target: {furthest[0]}, " + f"{furthest[1]:.3g}x its target range") if furthest else "" + else: + state = "" extra = "" if n_failed or n_rejected: extra = f" ({n_failed} failed, {n_rejected} rejected)" - return f"best {values} — {state}{extra}" + return f"best {values} -> {'; '.join(parts)}{state}{extra}" diff --git a/src/neuroworkflow/optimization/spec.py b/src/neuroworkflow/optimization/spec.py index 93fbe34e..4ca54860 100644 --- a/src/neuroworkflow/optimization/spec.py +++ b/src/neuroworkflow/optimization/spec.py @@ -102,6 +102,44 @@ def validate(self) -> None: f"(set objective_range on the parameter)" ) + def add_objective(self, name: str, measures: str, + low: Optional[float] = None, high: Optional[float] = None, + goal: str = "in_range", unit: str = "", + description: str = "") -> "OptimizationSpec": + """Declare a target that no node parameter carries. + + An objective is a label, a measurement address and a band — nothing about it + requires a parameter to hang it on. Declaring it here keeps a study's target + out of the model, and avoids inventing a parameter the simulation never reads + purely as somewhere to store a number. + + The address is checked against the baseline run, so a typo fails here, naming + what *is* available, rather than at the first trial. + """ + if any(o.name == name for o in self.objectives): + raise ValueError(f"An objective named {name!r} is already declared") + + available = self.baseline.get("measurables") or {} + if available and measures not in available: + node = measures.split(".")[0] + if node not in {a.split(".")[0] for a in available}: + raise ValueError( + f"measures {measures!r}: no node named {node!r} produced anything " + f"measurable. Nodes that did: " + f"{', '.join(sorted({a.split('.')[0] for a in available}))}" + ) + near = sorted(a for a in available if a.startswith(node + ".")) + raise ValueError( + f"measures {measures!r} is not a number produced by the baseline run. " + f"On {node!r}: {', '.join(near)}" + ) + + self.objectives.append(Objective( + name=name, measures=measures, low=low, high=high, + goal=goal, unit=unit, description=description, source="study", + )) + return self + def summary(self) -> str: lines = [ f"algorithm : {self.algorithm.name} " From 5999a9c9e907513fc740717e4739b973a1ffad63 Mon Sep 17 00:00:00 2001 From: Carlos Gutierrez Date: Mon, 7 Sep 2026 19:32:15 +0900 Subject: [PATCH 5/8] Update notebook outputs from verification runs --- notebooks/01_Basic_Simulation.ipynb | 2 +- .../NW_BalancedNetwork_PointNeuron.ipynb | 84 +++++---- notebooks/NW_Ring_PointNeuron.ipynb | 76 ++++---- notebooks/NW_SingleCell_PointNeuron.ipynb | 172 ++++++++++-------- notebooks/vneumod_simulation.ipynb | 2 +- 5 files changed, 191 insertions(+), 145 deletions(-) diff --git a/notebooks/01_Basic_Simulation.ipynb b/notebooks/01_Basic_Simulation.ipynb index d381f51a..1180e840 100644 --- a/notebooks/01_Basic_Simulation.ipynb +++ b/notebooks/01_Basic_Simulation.ipynb @@ -461,7 +461,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.0" + "version": "3.12.10" } }, "nbformat": 4, diff --git a/notebooks/NW_BalancedNetwork_PointNeuron.ipynb b/notebooks/NW_BalancedNetwork_PointNeuron.ipynb index 00a41813..3411cd64 100644 --- a/notebooks/NW_BalancedNetwork_PointNeuron.ipynb +++ b/notebooks/NW_BalancedNetwork_PointNeuron.ipynb @@ -29,11 +29,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "a0000002", "metadata": {}, "outputs": [], - "source": "from neuroworkflow import WorkflowBuilder\nfrom neuroworkflow.nodes.network.NW_Population import NW_Population\nfrom neuroworkflow.nodes.network.NW_Connectivity import NW_Connectivity\nfrom neuroworkflow.nodes.simulation.NW_SimConfig import NW_SimConfig\nfrom neuroworkflow.nodes.analysis.NW_Analysis import NW_Analysis" + "source": [ + "from neuroworkflow import WorkflowBuilder\n", + "from neuroworkflow.nodes.network.NW_Population import NW_Population\n", + "from neuroworkflow.nodes.network.NW_Connectivity import NW_Connectivity\n", + "from neuroworkflow.nodes.simulation.NW_SimConfig import NW_SimConfig\n", + "from neuroworkflow.nodes.analysis.NW_Analysis import NW_Analysis" + ] }, { "cell_type": "markdown", @@ -84,7 +90,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 3, @@ -192,6 +198,7 @@ "Executing node: PopExc\n", "Executing node: Connectivity\n", "Executing node: SimConfig\n", + "[NW_SimConfig] network unchanged, reusing ./results/balanced/network\n", "\n", " -- N E S T --\n", " Copyright (C) 2004 The NEST Initiative\n", @@ -207,7 +214,7 @@ "\n", " Type 'nest.help()' to find out more about NEST.\n", "\n", - "2026-06-17 14:21:04,560 [INFO] Created log file\n" + "2026-09-07 00:17:16,875 [INFO] Created log file\n" ] }, { @@ -221,7 +228,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:21:04,582 [INFO] Batch processing nodes for exc/0.\n" + "2026-09-07 00:17:16,883 [INFO] Batch processing nodes for exc/0.\n" ] }, { @@ -235,7 +242,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:21:04,594 [INFO] Batch processing nodes for inh/0.\n" + "2026-09-07 00:17:16,886 [INFO] Batch processing nodes for inh/0.\n" ] }, { @@ -249,7 +256,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:21:04,629 [INFO] Setting up output directory\n" + "2026-09-07 00:17:16,900 [INFO] Setting up output directory\n" ] }, { @@ -263,7 +270,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:21:04,630 [INFO] Building cells.\n" + "2026-09-07 00:17:16,901 [INFO] Building cells.\n" ] }, { @@ -277,7 +284,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:21:04,632 [INFO] Building recurrent connections\n" + "2026-09-07 00:17:16,904 [INFO] Building recurrent connections\n" ] }, { @@ -291,7 +298,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:21:04,638 [INFO] Network created.\n" + "2026-09-07 00:17:16,909 [INFO] Network created.\n" ] }, { @@ -305,7 +312,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:21:04,654 [INFO] Starting Simulation\n" + "2026-09-07 00:17:16,924 [INFO] Starting Simulation\n" ] }, { @@ -319,7 +326,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:21:05,057 [INFO] Simulation finished, finalizing results.\n" + "2026-09-07 00:17:17,340 [INFO] Simulation finished, finalizing results.\n" ] }, { @@ -333,7 +340,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:21:05,208 [INFO] Done.\n" + "2026-09-07 00:17:17,472 [INFO] Done.\n" ] }, { @@ -352,7 +359,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -362,7 +369,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -372,7 +379,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -382,7 +389,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -442,7 +449,9 @@ " PopInh.population: OK\n", " Connectivity.network: OK\n", " SimConfig.results: OK\n", - " Analysis.figures: OK\n" + " Analysis.figures: OK\n", + " Analysis.firing_rate_hz: OK\n", + " Analysis.isi_stats: OK\n" ] } ], @@ -480,7 +489,8 @@ "Executing node: PopExc\n", "Executing node: Connectivity\n", "Executing node: SimConfig\n", - "2026-06-17 14:21:11,997 [INFO] Created log file\n" + "[NW_SimConfig] network unchanged, reusing ./results/balanced_g6/network\n", + "2026-09-07 00:17:24,027 [INFO] Created log file\n" ] }, { @@ -494,7 +504,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:21:12,009 [INFO] Batch processing nodes for exc/0.\n" + "2026-09-07 00:17:24,035 [INFO] Batch processing nodes for exc/0.\n" ] }, { @@ -508,7 +518,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:21:12,020 [INFO] Batch processing nodes for inh/0.\n" + "2026-09-07 00:17:24,040 [INFO] Batch processing nodes for inh/0.\n" ] }, { @@ -522,7 +532,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:21:12,055 [INFO] Setting up output directory\n" + "2026-09-07 00:17:24,054 [INFO] Setting up output directory\n" ] }, { @@ -536,7 +546,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:21:12,057 [INFO] Building cells.\n" + "2026-09-07 00:17:24,056 [INFO] Building cells.\n" ] }, { @@ -550,7 +560,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:21:12,061 [INFO] Building recurrent connections\n" + "2026-09-07 00:17:24,058 [INFO] Building recurrent connections\n" ] }, { @@ -564,7 +574,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:21:12,068 [INFO] Network created.\n" + "2026-09-07 00:17:24,064 [INFO] Network created.\n" ] }, { @@ -578,7 +588,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:21:12,085 [INFO] Starting Simulation\n" + "2026-09-07 00:17:24,080 [INFO] Starting Simulation\n" ] }, { @@ -592,7 +602,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:21:12,492 [INFO] Simulation finished, finalizing results.\n" + "2026-09-07 00:17:24,496 [INFO] Simulation finished, finalizing results.\n" ] }, { @@ -606,7 +616,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:21:12,645 [INFO] Done.\n" + "2026-09-07 00:17:24,627 [INFO] Done.\n" ] }, { @@ -625,7 +635,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAHHCAYAAABeLEexAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAXZBJREFUeJztnQt4VcW1x1d4BoQEQUqCBkVtFXyhSCVAfVKpWtQL9V1F6wMpioAtJVYF7NVQvUXUAmJV8F6jVqxooYJXAeO15SEBRdAiIkJqeGgliaIBC3O/Ge459yScvc9+zGvv/f993zFhz8yaNWtmdpZnr70mjzHGCAAAAAAgwTQzrQAAAAAAgGngEAEAAAAg8cAhAgAAAEDigUMEAAAAgMQDhwgAAAAAiQcOEQAAAAASDxwiAAAAACQeOEQAAAAASDxwiAAAAACQeOAQAQAAACDxwCECAAAAQOKBQwQAAACAxAOHCAAAAACJBw4RAMA6Pv30U/rZz35GXbp0odatW9Nxxx1HTz75pCj75ptv6NhjjxUf/nuKL774goqLi6lfv360d+/e9PUFCxbQGWecQe3bt6eCggLq06cPPfPMM0bGBQCwFzhEAACr2L59O/Xt25def/11uuWWW+ihhx6io48+mq6//nqaOnUqtWnThp566in66KOP6Ne//nW63ciRI6muro5mz55NzZs3F9f47xdccIFwlsrKymjy5MnUq1cvWrhwocERAgBsJI8xxkwrAQAAKW644QZ65ZVX6L333qNOnTqlr19xxRXi256tW7cKp+iOO+6g3/72t/TGG28IJ+qSSy4RDtNtt90m6nPnqKSkhHr27Cnq5Ofnp2Xx215eXp6R8QEA7AQOEQDAGvjtqGPHjnTppZfSvffe26hs/vz5dN1119Fbb71F/fv3pz179tCpp55KX331lfhwx2fJkiVpR+eFF14QTtLcuXPp4osvNjQiAEBUaGFaAQAASPHZZ59RbW0tPfbYY+KTjR07doifrVq1EnFFPCaIf/sza9asRt/6bNy4Ufw8/vjjNWkPAIgycIgAANawb98+8fOnP/0pDRs2LGudE088Mf37q6++Kn42NDTQhg0bqHv37po0BQDEDThEAABr6Ny5s3gbjL8lNnDgQNe6a9asoXvuuUc8RnvnnXdE7BGPOyosLBTlRx11lPi5du1aEZQNAABuIIYIAGAV3MHhr8VXVVUd8LiLP1LjTtO3335Lp512Gu3cuVM4Rps2bRKPzq666qr06/n19fV02GGHUY8ePaiyshJB1QAAV+AQAQCsgr8xxp0d7vzceOONIliavza/atUq8So+/33ChAn0m9/8hhYtWkRnnXWWaMeDsO+88076y1/+Queff7649sQTT4hvjrhjdeWVV9LBBx9M7777Ln399dfi1X0AAEgBhwgAYB08cJo/Dvvzn/9M27ZtE6/f8+SMl112GfXu3Vs4TCNGjKCHH3443YY/ZistLRVJHdetW0cdOnQQ1+fNmyfyD61evZpatmwpEjqOGTOGLr/8coMjBADYBhwiAAAAACQeZKoGAAAAQOKBQwQAAACAxAOHCAAAAACJx6hDxIMg77rrLpFMjZ9NxPOG8DdHMsOa+O933323OMWa1+G5SXgCNgAAAACAWDhE/GDGGTNm0O9//3v64IMPxL/vv/9+euSRR9J1+L/5mySPPvooLV++nA466CAaNGiQyEwLAAAAABD5t8x+/OMfU5cuXUSukBRDhw4V3wQ9/fTT4tuhrl270u23306/+MUv0idY8zazZ8/Ga7MAAAAAiP7RHf369RMHOH744Yf0ve99TyRM4ydZT5kyRZTz7LM8B0lmCn+elp/nIFm6dGlWh2j37t3ik3k2Ek/kxvOYIDMtAAAAEA0YY/Tll1+KL0aaNWsWb4do/PjxIr0+T5TWvHlzEVPEs83y9Psc7gxx+DdCmfB/p8qaUl5eTpMmTdKgPQAAAABUU11dLY7hibVD9Pzzz1NFRYU4t4hnoeUHNI4ePVp4g04nXeeirKyMxo4dm/43f8TWrVs3YdCCggKJ2gMAAABAFfwLk5KSEnHgsw6MOkS//OUvxbdEqUdfJ5xwAm3evFl8y8MdoqKiovTZRvwtsxT837169coqs3Xr1uLTFO4MwSECAAAAokWepnAXo2+Z8QMWmz4X5I/OeNwPh7+Oz50ifoBjpsfI3zbjZxaFZetWookT9/+0QY6ufqKmr2392TwPMmTqnDfda8RGorZuZQO99Ophy7ishBlk2LBh7NBDD2Xz589nmzZtYi+++CI75JBD2Lhx49J1Jk+ezDp06MBefvlltmbNGnbRRRex7t27s2+++cZTH3V1dfwtOvGzKVVV/A27/T/DIEuOrn6ipq9t/dk8DzJk6pw33WvERqK2bmUDvfTqYcu4wv79VoHRR2Y83xBPzPjzn/9cnG7NY4eGDx8uEjGmGDduHO3atYtuuukmqq2tpQEDBtDChQspPz/fpOoAAAAAiBFGHSIeKDV16lTxcXt2eM8994gPAAAAAIAKEn2WGQ9fOuOM/T+DPmvlZRUVRPzFtoy4b98ydPbDxzthwoFyZOrq1o8XOV6fc2fW4/3o6M/meci0QVA5Te0oe12E7Uu1TkHqhJGVbd2q0N1pf8gaX1A5QcevUieb1maY+2i2OirXm+zxl5eTXljMCRND5OVZqw4ZcdNVli4y6+mUE6V5sLFO3HXSrbtteyjuOsW5jvz+9MYQJfobIgAAAAAADhwiAAAAACSeRDtEbjEnXsp1yYibrrJ0kVlPp5wozYONdeKuk27dbdtDcdcpznVk9zd+POmFJTiGqKaGsQkT9v/0U6ayrVsdkzo5lQftM6gNbLWRbfZTZV/VetnUZ9i+bdQ5aveQsDoFlW9qzQTVKW7zVvN/5evX640hSrRD5BbYFSZYT1XQrEmdnMqD9qkq+NiUjWyzn8rg7iitM9XlpuZPhR1N6axSp6DyTa2ZoDrFbd6q/q+8shJB1QAAAAAAWoFDBAAAAIDEk2iHyC0xIw/o4sn3eBK+bMmj3Nq6lbkl9nNKouaUoMst4ZafMq/l2eyRasd1c5Lpt8zrHGQrDzpvXuYlW4I0L2VOSfFy9Rm0zMta8TIHTrZys3GYfeM0LrfrYfeFn/Iga9zJFm7rMMh6chpzU71M3tecEgwGsYVTn0HWudN9xG8bL+W51rLbmnVb527rwetaKfa5/sPsq1xtcyVNVgaLOaoSM+ossyX+JCqxFDJtbGpsutaQ7DY6dZetd5R19yPPlnkNorvusckeVxz3p4p9lbqGGCIAAAAAAM3AIQIAAABA4km0QxQmqZfOMr/Xw5Tp7i9sYrVs5TJtbGpsutaQ7DY6dZetd5R19yPPlnkNorvusckeVxz3p4p9lbpWVER6YTEnaGJGGeW6ZMjqxyZ9ZeojU5ZN82WjnW3USaYsHfcMmbLCJgiU2Z8pWdBJr041EuWMH4/EjJE57T5XuS4ZsvqxSV+Z+siUZdN82WhnG3WSKUvHPUOmrDCBsLL7MyULOunVqUqqHARVAwAAAABoBQ4RAAAAABJPoh0iFQG9JmTI6scmfWXqI1OWTfNlo51t1EmmLB33DJmywgTCyu7PlCzopFenYolycNq9RUHVXgkqx3T/cZAZlf519x1HW8uUGfe1oKoP2XKDyNPVRqdM2/Uz1bfb328VJNoh8htU6ERQOab7j4PMqPSvu+842lqmzLivBVV9yJYbRJ6uNjpl2q6fqb51O0SJfmQGAAAAAMCBQwQAAACAxJNoh6jpibrZTt31cj3XydRO13KdqOxVHzc5ssYUVI7X079lyHeq6+dkbC9ygtg4M4BQ5pic6oeZPxl20bEmw4yraUCnjjmRve9N7LVcuvu1Wa6T7rPp4uW0+CD7T4fuYcfk57qKPbjV4/7INp4gcsrLSS8s5viJIXJ67un3ulOZLPl+rpvo07axyrKNLDk2jUmlXVTqKLNf1XJs2iOyrkfBBlHY31GxTZWxfYYYIgAAAAAArcAhAgAAAEDiSbRD1DSOwClRlN/rTmWy5Pu5bqJP28Yqyzay5Ng0JpV2UamjzH5Vy7Fpj8i6HgUbRGF/R8U2xYb2me7EjHn8uRnFmPr6eiosLKS6ujoqKChoVMaDtmbOJBo+PPvkAQAAAMC+v98qSPQ3RNwhmjQp+9sGAAAAAEgOiXaIAAAAAAA4cIgAAAAAkHgS7RA5JdYCAAAAQLJItCuwbx9RZeX+nwAAAABILol2iAAAAAAAjDtERxxxBOXl5R3wGTlypChvaGgQv3fq1InatWtHQ4cOpe3bt2PmAAAAABAfh+jtt9+mrVu3pj+vvfaauH7JJZeIn2PGjKF58+bRnDlzqLKykmpqamjIkCHS+ndLIAUAAACA5GDUIercuTMVFRWlP/Pnz6ejjjqKzjjjDJGI6YknnqApU6bQ2WefTb1796ZZs2bR3/72N1q2bBklAbdTmaMuyzZ9bJQT97GZ7MOW/k2N1fQatW09xlWOyb63Gt7HgWCWsHv3btapUyd27733in8vWrRInHK7c+fORvW6devGpkyZ4iinoaFBnIyb+lRXV3s+7d42ZOpnmyzb9LFRjo066dgzpvelzv5NjdX0GrVtPcZVjsm+qyTI4X+3E3na/UsvvUS1tbV07bXXin9v27aNWrVqRR06dGhUr0uXLqLMifLycpHqO/UpKSlRrjsAAAAAoo01DhF/PHbeeedR165dQ8kpKysTj9tSn+rqamk6AgAAACCetCAL2Lx5M73++uv04osvpq/xmKI9e/aIb40yvyXib5nxMidat24tPnEIqpapn22ybNPHRjk26qRjz5jelzr7NzVW02vUtvUYVzkm+y62/O9rVpgFTJgwgRUVFbFvv/02fa22tpa1bNmSvfDCC+lrf//738XzxKVLl0p5BllTw/ve/9Mrftt4qS+rTlRk+unXa13Z9bzUdStXYVsV9bzW1VXH9jUpq56udSi7jq2ybFyfcZ23Go396Y4hMu4Q7d27VwRK/+pXvzqg7OabbxZlixcvZitXrmSlpaXi4wc3g+oIBvRSX1adqMj006/XurLreanrVq7Ctirqea2rq47ta1JWPV3rUHYdW2XZuD7jOm9VGvvT7RAZf2TGH5Vt2bKFfvaznx1Q9uCDD1KzZs1EQsbdu3fToEGDaPr06Ub0BAAAAEB8Me4QnXvuufxbqqxl+fn5NG3aNPEBAAAAAIj9W2Y2nnafLbFUZqBYrsRT/HpFBdHYsdkDy1Ltef/Zgs8y5WcLUHPr38vYvOiWbexcpop+w9jb61x6sbXX8bqVy1onTds2XQdOsr3MlZ++vaw/L2MOY1Ov8xnEZl7ni5dzW3Gbhdn3MveAF5t50VvmHvJ6v9Kpe9B7cdD7sJe1rmtc2XRXeY+fGHCdGE/myGJOmBiiKJebkm1K56jaMq59R1Vv0+UYd7J0s3VcVZbYI7GJGQEAAAAATAGHCAAAAACJJ9EOUa7EUVEuNyXblM5RtWVc+46q3qbLMe5k6WbruIottYdyWMwJk5hRZ5Ium3XTlWDMZN9h6+hK2GfTvHupF2TedY1Rpxxb1oeOsdiwl2zbBzLl+JGlU68aBWsncYkZ4xxUHbSubbrJ6Mvv+HX3HbaO1/GZDh5VIUuGXVToJVO3sHJsWR86xmLDXrJtH8iU40eWTr2qFKwdBFUDAAAAAGgGDhEAAAAAEk+iHaJsCab8JI3yksTKKUmVWwKqIIndgibwk2UHtwRjXvTNZjNZc+CUSMypH7dEa07jdCsLMh4nPXIlRcs1l1519iPLbQ682kVWQjs/9szVj9eEfF72dpD1ESRxXtBEfn7HIlsHv3tRxjhy6etXluz9lOte5DQHfu8pXu7fE30krQxzL3ZK5qgNFnP8xhAFeS6tq01QvYP0Z1v9XGUy29igm1OZ7LWhY96C2EV2Xzr1U33dBp1l6xAlW5rez2Fkmh5Tlc/+EUMEAAAAAKAZOEQAAAAASDyJdoiyxQUESRqlq01QvYP0Z1v9XGUy29igm1OZ7LWhY96C2EV2Xzr1U33dBp1l6xAlW5rez2Fkmh5TccA1ow0Wc8IkZvRaT1fSNpl9eq1rQxI3GXKimlzNdKI+rzJUyIvbnNuyJoLU1Zl80tZ1m+R1aep+hMSMFiVm9FovaECaXz1k9mnL2HTMgc5+/NTTYT+dcyRbXtzm3JY1EaSuzPuYjXaQqb9N60mmHBP3IwRVAwAAAABoBg4RAAAAABJPoh0ir4FcKoI/g+ghs09bxqZjDnT246eeDvvpnCPZ8uI257asiSB1Zd7HbLSDTP1tWk8y5dhyP1IKizlBgqqDBBLraqNLXphgaln6qQj4tsFGUVwPtsgLIsupXPZ4gpTpWHNxu2fJspnNY5Stt1O5DWOtcWmDoGoLgqp1ZfoMGrCsQ16YYGpZ+qkI+LbBRlFcD7bICyLLqVz2eIKU6VhzcbtnybKZzWOUrbdTuQ1jrXJpg6BqAAAAAADNwCECAAAAQOJJtEPkdPKurkyfQQOWdcgLE0wtSz8VAd822CiK68EWeUFkOZXLHk+QMh1rLm73LFk2s3mMsvV2KrdhrMUmg6ibkMefm1GMqa+vp8LCQqqrq6OCgoJGZatWEfXuTVRVRXTKKcZUBAAAAICPv98qSPQ3RAAAAAAAHDhEAAAAAEg8iXaIbHp2CQAAAABzJNohasrWrUQTJ+7/GfR6mGuq6uocVxzGoHNcNtTV2X+261Fah6r0NW0DG2yIvsyPYaul60AbLOb4ScwoIxFWmGuq6uocVxzGoHNcNtTV2X+261Fah6r0NW0DG2yIvsyPocqydYDEjAAAAAAAmoFDBAAAAIDEk2iHqGlixswg68znmNmCr/n1igqisWOdE12lZHD52RJi8bZcRuazUq/tnWSk2vM2TvrnkpstYaVbX17kOiXBdOrLqw1yJdd0s4OfsfqRmWttZLZ3smO29l50cFq3ftein7l1s5cXO/pdh2HWRlhbuc1NGH1zrY0g69jP3LqtNy/3GFVzE/YeJcuGXtrLGJefvaTT3sUS7hFh1rc2WMwJcrhrrjIv5TJkhOlDxdjC6KtCpspylWvDxLzDjup1NrWfVesVpbk1qZNqGUkcWx1iiAAAAAAA9GLcIfr000/ppz/9KXXq1InatGlDJ5xwAq1cuTJdzk8Wufvuu6m4uFiUDxw4kDZs2GBUZwAAAADEC6MO0c6dO6l///7UsmVLWrBgAb3//vv0u9/9jg4++OB0nfvvv58efvhhevTRR2n58uV00EEH0aBBg6ihoSF0/0EPtvNSLkNGmD5UjC2MvipkqixXuTZMzDvsqF5nU/tZtV5RmluTOqmWkdSxaYUZ5Fe/+hUbMGCAY/m+fftYUVERe+CBB9LXamtrWevWrdmzzz7rqQ+3Z5A1NYxNmLD/p1/8ts1V36s82fV09iPbZkHlBm2jSifda0NFe1lj8NvGtn2jqi8ZtojqPcHGdaBTjszxy2hfo6CuUz3dMURGHaIePXqw0aNHs5/85Cesc+fOrFevXuyxxx5Ll2/cuFEYY/Xq1Y3anX766WzUqFFZZTY0NAjjpT7V1dWBgqpz4betjIA0FfV09iPbZkHlBm2jSifda0NFe1lj8NvGtn2jqi9dQa9RHJcK3XTtSd3jl9G+SkFdBFUT0ccff0wzZsyg7373u/Tqq6/SiBEjaNSoUfTUU0+J8m3btomfXbp0adSO/ztV1pTy8nIqLCxMf0pKSjSMBAAAAABRxqhDtG/fPjrllFPovvvuo5NPPpluuukmuvHGG0W8UFDKysqorq4u/amurpaqMwAAAADih1GHiL851rNnz0bXevToQVu2bBG/FxUViZ/bt29vVIf/O1XWlNatW1NBQUGjj3P/wQO5/LaVEZCmop7OfmTbLKjcoG1U6aR7bahoL2sMftvYtm9U9aUr6DWK41Khm649qXv8MtoXK6iLoGrG2BVXXHFAUDWPKSotLW0UVP0f//Ef6XL+LNFUULWu4F1b9VIhR2dge9j+ZMlRPb+qA8Z162bDnMXRrjbrZuOLEmH7CdM+qW3qkhRUvWLFCtaiRQt27733sg0bNrCKigrWtm1b9vTTT6frTJ48mXXo0IG9/PLLbM2aNeyiiy5i3bt3Z998843STNUmg3dt1UuFHJ2B7WH7kyVH9fyqDhjXrZsNcxZHu9qsm40vSoTtJ0z7pLap0+wQtTD57VSfPn1o7ty5Iu7nnnvuoe7du9PUqVPpqquuStcZN24c7dq1S8QX1dbW0oABA2jhwoWUn59vUnUAAAAAxAijDhHnxz/+sfg4kZeXJ5wl/gEAAAAAiOXRHSZxOt2Yk3kSdq4Te93aZgsWyyY787rTKdtN2/itn1nmdLp1rrZu48vVZ7Yyp9Odvejid/68zKHXMTSd11xzGmYdOZ1AHWSMQe3pNhY/8+dl7E5tctk61xiDrBcZe8apX5lzEcSuQfef3z3k9R4RZs27zU+uPoP8HQh6zwq6joLe69z0VLE/twac31zttMFijorT7sMm23Iq99tn1PU3VaZzDCbmwa3cFptFaX2GLdepj049bLKzqj513uvQH0t2YkYAAAAAABuAQwQAAACAxJNoh8gtGVTQsjDlfvuMuv6mynSOwcQ8uJXbYrMorc+w5Tr10amHTXZW1afOex36I8d22mAxJ0hiRrekUUHKwpx4HPSk4zAybbCLDTrKHq8tfXltG0RXVfrq3Fs2rHMV61/n2KIwL0kdWxj9VenqVJaoxIy2BlXrDDIM059bnSgE2tmuo87AQt1BjF7aBtFVlb4695YN61zF+tc5tijMS1LHFkZ/Vbo6lSGoGgAAAABAM3CIAAAAAJB4Eu0QZUt25ZQ4y0tCqczAMD/JC90SaHlJ6pZNfhA9M/XJlpzL6XrQMbiNzW0Ogtrar/6yx+s0NhVrLtdc5hqDW99B5yaXPm62C7KGmurvNaGczDWUy85B2rjNgde5cdJf1tiC6u+23r3sA7/jUr3mnPR0WnN+96lTmd/961V/FfdFt/VQXk56YTHHbwyRrOfJUb9uo05Rv+5UhrnUc91G+8AWGFeYe4FqOeavI4YIAAAAAEArcIgAAAAAkHgS7RBlSwblN3FUXK/bqFPUrzuVYS71XLfRPrAFxhXmXqBajunr48eTXljMCZKYMc6J3XTI0pnoTPaYVJTZoEOYMt1jsKk/L21V6WbDOlSli2w9bUs2qHO+deuvc80iMaMlp917qSMzcE22vDgE1cko1zVHQfrSqUOYMt1jsKk/L21V6WbDOlSli2w9TdxDZOtqYv3KvidXSdYDiRkBAAAAADQDhwgAAAAAiSfRDpFbAj2ZQWhOibmCystW5pREMcpBdTLKZdpBdl86dXArc0vWZmIMNvXnpa3Jfa96HcrWxYtNZN4HvY5Rl61ltzGhv4n9qYs8/tyMYkx9fT0VFhZSXV0dFRQUNCpbtYqod2+iqiqiU05Rp4OOfnSNBcQPrB01wK76bQKbJ+fvtwoS/Q0RAAAAAAAHDhEAAAAAEk+iHSJdzy119GPLM1gQPbB21AC76rcJbA7CkGiHSAbZThhvCt+cw4cTzZzpXs+LLKd2XDbvw8uNwG8/XuvLrhe0fph2qsagq10Q+V7Xp1/5Ku3vt76XeqrH5hXV+0OWLVSvNb/9eLkPhpk3Xfctv21V1N0qYX3bsp98wWJO2MSMuZCRtC2sPn7bqaovu17Q+mHaqRqDrnY2yVdpf9P7L+77OYrjU6lzkLa6+lJRt0rj30a3ukjMCAAAAACgGThEAAAAAEg8iXaIZATgBU3aJlMfv+1U1ZddL2j9MO1UjUFXO5vkq7S/6f0X9/0cxfGp1DlIW119qahbrPFvo6z+ZJDoxIx+g5EBAAAAoAckZtQId4gmTbIgsh0AAAAARkm0QwQAAAAAwIFDBAAAAIDEk2iHyOm0exlJycLKCFoWtm1Y+abL46q7yvVkQ3tTcx5nu+jqA3Nr7l6bBBtohcWcIIkZZST4CisjaFnYtmHlmy6Pq+4q15MN7U3NeZztoqsPzK25e63tY6gK2R6JGQEAAAAANGPUIZo4cSLl5eU1+hx77LHp8oaGBho5ciR16tSJ2rVrR0OHDqXt27ebVBkAAAAAMcT4N0THHXccbd26Nf1566230mVjxoyhefPm0Zw5c6iyspJqampoyJAh0vp2SgYlI8FXWBlBy8K2DSvfdHlcdVe5nmxob2rO42wXXX1gbs3da5NgA60wg0yYMIGddNJJWctqa2tZy5Yt2Zw5c9LXPvjgA/E8cenSpZ77cHsGWVPDddj/Mxu5yr3Wl92PLLle+pVlgzByg9pVdj2dcnSOzTZ9gtS3ae5U1AtSP851VcnWtU507zkTsmTYQXcMkXGHqG3btqy4uJh1796dXXnllWzz5s2ibNGiRcIQO3fubNSmW7dubMqUKY4yGxoahPFSn+rq6sCn3XsJCPNSX3Y/suTKCPoLWt+P3KB2lV1PpxydY7NNnyD1bZo7FfWC1I9zXVWyda0T3XvOhCwZdkhUUPVpp51Gs2fPpoULF9KMGTNo06ZN9IMf/IC+/PJL2rZtG7Vq1Yo6dOjQqE2XLl1EmRPl5eUi1XfqU1JSomEkAAAAAIgyLUx2ft5556V/P/HEE4WDdPjhh9Pzzz9Pbdq0CSSzrKyMxo4d2+gsFDhFAAAAALA6qDoT/m3Q9773Pfroo4+oqKiI9uzZQ7W1tY3q8LfMeJkTrVu3FofAZX6CJmbk1zODvZwSSDnVT5VVVBBxH63p9ZSspkFlufpJXU+14/1mq+80Pq96eenDb30/fafgdXhd3iazzOl6UPv6XQ9OssLOi5+15zW5aKYNgsyx1/nyul68js9r/27jC6OX336Czkuu/eKnf7/r1Y++ufadLn2d1kQQnWXeK9x082uXIDoHkeV3XxYHnP+g618rzCK+/PJLdvDBB7OHHnooHVT9wgsvpMv//ve/Sw2q9hubEiSWRUcbG/uw1Sa6ZJnWLS59mJYVRZ2TPPdJ71/XvapKUz+6Y4iMPjL7xS9+QYMHDxaPyfgr9RMmTKDmzZvTFVdcIeJ/rr/+evH4q2PHjuKbnltvvZVKS0upb9++JtUGAAAAQMww6hD94x//EM7PP//5T+rcuTMNGDCAli1bJn7nPPjgg9SsWTORkHH37t00aNAgmj59ukmVAQAAABBDjDpEzz33nGt5fn4+TZs2TXxU4JQQStZ1XW1s7MNWm+iSZVq3uPRhWlYUdU7y3Ce9f133qmKN90StsJgTJDFjkESAcWpjuv8o6my6/6ToLLtNEHk2j8f0OHX1k5T1oUtnW/WuS1JiRh3oCKqOWxvT/UdRZ9P9J0Vn2W2CyLN5PKbHqaufpKwPXTrbqnddkhIzAgAAAADYABwiAAAAACSeRDtEUQu+09XGdP9R1Nl0/0nRWXabIPJsHo/pcerqJynrQ5fOtuutDRZz/ARVywoQMxlsZ0If1faRJV9m36bGbNt11eNVLd/GgFnbbBR1+arvc7iubt4RVG0wqFpWgJjJYDsT+qi2jyz5Mvs2NWbbrqser2r5NgbM2majqMtXfZ/DdXXzjqBqAAAAAADNwCECAAAAQOJJtEPU9MRiWQFiJoPtTOij2j6y5Mvs29SYbbuueryq5dsYMGubjaIuX/V9Dtf13b9Vk8efm1GMqa+vFwfF1tXViQNiM1m1iqh3b6KqKqJTTjGmIgAAAAB8/P1WQaK/IQIAAAAA4MAhAgAAAEDiCeQQLVy4kN566630v/lp9L169aIrr7ySdu7cSVHB5LNKAAAAAETcIfrlL38pnu1x3nvvPbr99tvp/PPPp02bNtHYsWMpymzdSjRx4v6fbtdsux5V2dA9WWOyRUYUxmlKxyjYIAp2jGqfW32uC9Xj10qQ5EUHHXQQ27Rpk/h9woQJbOjQoeL3qqoq1qVLFxbl0+6jmpArqrKhe7LGZIuMKIzTlI5RsEEU7BjVPqssSqAZicSMrVq1oq+//lr8/vrrr9O5554rfu/YsWP6myMAAAAAgKjQIkijAQMGiEdj/fv3pxUrVtAf//hHcf3DDz+kww47TLaOAAAAAABKCfQN0e9//3tq0aIFvfDCCzRjxgw69NBDxfUFCxbQj370I4pqYsbMQGt+LfU8s2nwdepZJ6/jlIiKh1JVVDR+HppNdub1TDm8jLfncprK96p3U9mZz2j99Bl2PNnslUsXt36zjd+pXz829Kp70DnKZTMnGze9LmOuc+noNt9hbONFtpvubjYPa5cw+9ppjlSuI6+6ONnGSUe/9wcnPVXaQMecer1XB9nrQe+bXvsMY5dmDrKd7CXjb4zbXGiFxRy/MURhy0y3D9OvTrlebKCirS4ZMm3i93qU16jNernVMbG3ZK+LqM6LzfvArdzWcVUp1Mtvue4YIs+PzPzEBunIKAkAAAAAIAvPDlGHDh0oLy/PU929e/eG0QkAAAAAwE6HaMmSJenfP/nkExo/fjxde+21VFpaKq4tXbqUnnrqKSovL6eo4PfQOS9lptuH6VenXK9JMWW31SVDpk38Xo/yGrVZL7c6JvaW7HUR1XmxeR+4lds6rmKFeoUtV06Q52xnn302e+aZZw64XlFRwc444wxmE27PIGtqeB6l/T/94qetl7p+dQmiu6o+VMiVbV8dOquua+NcqpBv0tZh7gkq9JHRzqb6JmXrnFuv9WXtGx1jqzEwz7pjiAI5RG3atGEffvjhAdfXr18vyuIQVJ0LP21lBOaFra+yDxVyZdtXh86q69o4lyrkm7R1mHuCCn1ktLOpvknZOufWa31Z+0bH2KoMzHMkEjOWlJTQH/7whwOuP/7446IMAAAAACD2iRkffPBBGjp0qMg7dNppp4lrPEHjhg0b6E9/+pNsHQEAAAAAlBLoGyJ+kCvPSj148GD64osvxIf/zq/xsqgQJoDLT1sZgXlh66vsQ4Vc2fbVobPqujbOpQr5Jm0dNqgzynOvo75J2Trn1mt9WftGx9iKLZlnpbCYoyqoOqwMGX3LlGO6D9196xyTyXWmUpaOYHbVcmTLCirPxpcqVMuxUac43k+jNqaaDFnWBlW/++67bO/evenf3T5JCKoOK0NG3zLlmO5Dd986x2RynamUpSOYXbUc2bKCyrPxpQrVcmzUKY7306iNqSpDlrWZqnv16kXbtm2j73znO+J3nqSRO1RN4deRmBEAAAAAUcKzQ7Rp0ybq3Llz+ncAAAAAgMQFVR9++OHpozv4726fFBdccAFtNXZsbW7cTvX1ilswWObJv37audFUZhA5bnplw+l0Zhl95KqXa3x+xuLlBHiV9svsy6/eTidEB9FLhj5uJ4i7yTS17v3sRb/zm02e31O7/c5JkDn0YjMvYw9yPwizrr3o5XU9eJUTdmxufflZu0Hvb0H7C7r+w95TcsnShsrnce3atWMbN25kcY4hckOF/KjEPalOBKhSJx1ybLOlbfpEfZ2YkGHrurShL79yorgGbLq/yZITicSMqpg8ebL4Fmr06NHpaw0NDTRy5Ejq1KkTtWvXTuQ/2r59u1E9AQAAABAvrHGI3n77bZo5cyadeOKJja6PGTOG5s2bR3PmzKHKykqqqamhIUOGGNMTAAAAAPHDCofoq6++oquuukocB3LwwQenr9fV1dETTzxBU6ZMobPPPpt69+5Ns2bNor/97W+0bNmy0P2qflapQr4MmToSwqlOBKhSJx1ybLOlbfpEfZ2YkGHrurShL79yorgGbLq/WZVs0Q82xBBdc801bPTo0eL3M844g912223i90WLFonnhzt37mxUv1u3bmzKlCnGEzOGaW9Dsj4dJ3PLkoH+1SfuUyFDVR+2JeKz8ST1oGBOonefNb3faxT1b21iRlUO0bPPPsuOP/549s033xzgEFVUVLBWrVod0KZPnz5s3LhxWeU1NDQI46U+1dXVyoKqdQWxqpIRpUBT9G93gK3uPmwK/JQhx8T8ypZtiy1tk6PjPmt6v1cp6j9WQdV33HEHdezY0bG8urqabrvtNqqoqKD8/HwpfZaXl1NhYWH6U1JSIkUuAAAAAOJLYIfov/7rv6h///7UtWtX2rx5s7g2depUevnll9N1ysrKqEOHDo4yqqqqaMeOHXTKKadQixYtxIcHTj/88MPi9y5dutCePXuotra2UTv+lllRUVFWmbxPHnuU+nCnCwAAAABAukM0Y8YMGjt2rDjZnjsrqaM6uPPDnSKvnHPOOfTee+/RO++8k/6ceuqpIsA69XvLli1p0aJF6Tbr16+nLVu2UGlpaVaZrVu3poKCgkYfVYkZdQWxqpLhN2DPb7K5MP3JbCtjDKbny/YAW9192Bb4qXMvyuhPxT6xxZa2ydERGG16vxdH5H6Tizz+3Mxvo549e9J9991HF198MbVv357effddOvLII2nt2rV05pln0ueffx5YId6en5WWcqxGjBhBr7zyCs2ePVs4N7feequ4zt8080J9fb14dMa/LWrqHK1aRdS7N/+miuiUUwKrnBjiYK84jAEA1WCfABtw+/tt9CyzTPhZZieffHLWb2d27dpFMnnwwQepWbNmIiHj7t27adCgQTR9+nSpfQAAAAAg2QRyiLp37y4eaWWeW8ZZuHAh9ejRI5RCb7zxRqN/82DradOmiQ8AAAAAgDUOEY8f4sdp8GM1+BO3FStW0LPPPive8Hr88ccpKtjwzDJKxMFecRgDAKrBPgFJJFA48Q033EC//e1v6c4776Svv/6arrzyShFo/dBDD9Hll19OcSTIyb1ubfzKy1VfVl9hTvrWpUMY2/EbPP89daPXOQ+yZelaX7bMXRBZsur41d2WdRK0rd99Ymq9ydZNx5qK4jpSIcupTpi/QaEJm8ho165dbPv27cxWZJ12HyTxlFsb2YnYZPUVRo4OHfzKkqmXbN3CytI1rijPnaw6fnW3ZZ3I0sO2eVWlm441FcV1pEKWU53M67oTMwZ6ZJZJ27ZtxQcAAAAAIKp4doj4W2V5eXme6q7i72wCAAAAAMTNIeI5h1LwYGr+6jvPR5RKkMhPn1+3bh39/Oc/p6igOmGWWxvZidhk9RVGjg4d/MqSqZds3cLK0jWuKM+drDp+dbdlncjSw7Z5VaWbjjUVxXWkQpZTHaMB/UGes11//fXszjvvPOD63Xffza677jpmE35Ou3c6sVfGdd11Zci2XYYM2UmwRxTtZMu4o6CLDXXjJtv2tZAUO9VF4bT7goIC9uGHHx5wnV/jZVENqvYS5BX0uu66MmTbLkOG7CTYI4p2smXcUdDFhrpxk237WkiKneqicNp9mzZt6K9//esB1/k1WafWAwAAAADoItBbZqNHjxZnjPHg6e9///vi2vLly+nJJ5+ku+66S7aOAAAAAAD2OUTjx48Xh7nyRIxPP/20uMaP7Jg1axZdeumlFBWannbvN8jLz3XddWXIDiIjdUo2/z1VrkoPGbJ192fCHlGxE9+HPCHb8OH2jFv1dZvn0fZxq5Rt+1pIip0icdp9lMBp93qBTUFQsHYAAJE77T5FVVUVffDBB+L34447TuQqAgAAAACIGoEcoh07dogzy/jJ9B06dBDXamtr6ayzzqLnnnuOOnfuLFtPAAAAAABlBHrL7NZbb6Uvv/xSJGL84osvxGft2rXi661Ro0ZRVLDluWWcgE1BULB2AACRc4gWLlwoMlXzQOoUPGv1tGnTaMGCBRR1VJ0urbvMhFz+x4wHxc6cGf1xxkWfqOjK1w6/zrFBn1xltukTJV2Dtk3CGKErpcu2bSO9BEle1K5dO7Z69eoDrq9atYq1b9+eRf20e6frXsptKouaXOgDXW3TB7rapU8SxghdWbqssjICiRnPPvtsuu2226impiZ97dNPP6UxY8bQOeecI9NfAwAAAABQTiCH6Pe//72IFzriiCPoqKOOEh/+O7/2yCOPyNcSAAAAAMA2h6ikpERkqX7llVdE1mr+4bFD/Nphhx1GUU3M6BTc2fRZZ2a5W1nTtk5Bo7yMJzPkSQ39lLmNwUvbzESK2eI5MpPl+Sn3a4NUOZflFFTrNs5c5V7GKUNXL3MdVtcg8yVzPeeyQdg163UsucapY4yqbBB2/Ln2rJe1bsOezTYWN11U7rsgtlFlu7D3iGx7IFd5seb1kRrH88+TXoI+a3v99ddZWVmZOPmen3Cf+Yl6DJGu57Kq5YftW0a5LTJkzHWuchv6UL3eZOhget/ZMEaV82TavjpleK0jSx8ZclTbLg7r+//L9cYQBcpDNGnSJLrnnnvo1FNPpeLiYsrLy5PvqQEAAAAAaCKQQ/Too4/S7Nmz6eqrr5avEQAAAABAFGKI9uzZQ/369aOkJIJzq5dLhpc+VMkP27eMcltkyJjrXOU29KF6vcnQwfS+s2GMKufJtH11yvBaR5Y+MuSotl0c1jeHXx8/nvQS5DnbuHHj2D333MOigFsMUU0NYxMm7P/pRNg6svpQ3Y8OW/ipE1Zfp/Kg7cK2lS0nTB2Zc2TCPn7q6dgXXuvacJ+Iug3d6tiwP1XvbVX3vbC61yiyvdvfbxUEcohGjRrFOnTowE4//XR2yy23sDFjxjT6xCmo2oYgVR396AxwNBn0aTqgWZacMHVkzpEJ+/ipp2NfeK1rw30i6jZ0q2PD/lS9t1Xd98LqXqXI9rodokAxRGvWrKFevXqJ3/kZZpkgwBoAAAAAUSOQQ7RkyRL5mgAAAAAARCmoOi7oCOrTFRRoi562jNep3HRAsyw5YerInCMT9vFTT8e+8FrXhvtE1G3oVseG/al6b6u674XVvVjz3lcGizlhg6q91NMZEGkqsFJ2PRN9mu5bRwCrKb1Ny7R1zcVdryisDdO62vb3Qfd6qwkhJxJB1VFCdaZqr3J09uWnngqZJgJEbR+v13qqgx9V1jMp09Y1F3e9orA2TOtq298H3eutKoQc3Q5Roh+ZAQAAAABw4BABAAAAIPEk2iHKdVK8l1PqvZyInes06Uz8nEjsRY7Tydde7eB3nF7G4Ec/2bo11c+pjkwdvZx+7jYOL6ezq5qnXCdoex2jn9Ozg/TvZZ14sb+XE8wz9ZKxzmWuH6/6+9Fdxj4Oszay1VHZfzYd3PoPuza9yvEyhqD3j6Dr24vuMta3NljMCRpDZDqRlQ4dZMkIM07T5VHoQ8ezfNVjND3PNpebXqPo3+zaVj2GKNu3LkkxRDNmzKATTzyRCgoKxKe0tJQWLFiQLm9oaKCRI0dSp06dqF27djR06FDavn27SZUBAAAAEEOMOkSHHXYYTZ48maqqqmjlypV09tln00UXXUTr1q0T5WPGjKF58+bRnDlzqLKykmpqamjIkCEmVQYAAABADAmUqVoWgwcPbvTve++9V3xrtGzZMuEsPfHEE/TMM88IR4kza9Ys6tGjhyjv27dv6P5VJ0rTkYhNdSKwsOUqZcsoj0IfspKaqU6sFuV1YLLc9BpF/2bXtuoxRN2+Osnjz83IAvbu3Su+CRo2bBitXr2atm3bRueccw7t3LmTOnTokK53+OGH0+jRo8W3R16or6+nwsJCqqurE4/lmgZyzZxJNHy4+YkAAAAAgLe/37H7hojz3nvvidghHi/E44Tmzp1LPXv2pHfeeYdatWrVyBnidOnSRThLTuzevVt8Mg3qBHeIJk0iuvBCOEQAAABAkjH+2v0xxxwjnJ/ly5fTiBEjxDdE77//fmB55eXlwqNMfUpKSqTqCwAAAID4Ydwh4t8CHX300dS7d2/hzJx00kn00EMPUVFREe3Zs4dqa2sb1edvmfEyJ8rKysTXa6lPdXW1hlEAAAAAIMoYd4iasm/fPvHIiztILVu2pEWLFqXL1q9fT1u2bBGP2Jxo3bp1+jX+1McJLwmjOG5JqbyU+63rVZ5MWXEZR1xs4qVuEubLVnvZKsuPvLjrhTUvVy+T614bzCDjx49nlZWVbNOmTWzNmjXi33l5eey///u/RfnNN9/MunXrxhYvXsxWrlzJSktLxSeKh7v6qStLLxW6qejbVlkq6sqUl4T5stVetsryIy/uemHNy9XLxLrXnZjRaFD1jh076JprrqGtW7eKeB+epPHVV1+lH/7wh6L8wQcfpGbNmomEjPxbo0GDBtH06dNNqgwAAACAGGLUIeJ5htzIz8+nadOmiQ8AAAAAQGJiiHSiI2FWkLqy9FKhm4q+bZWloq5MeUmYL1vtZassP/LirhfWvFy9TK57bbCY4/YMsqaGsQkT9v8MigwZtumiq5+4yrFRJ1Nyoq5/XOXYdL+J876zTaeo/Y2o0xxDlGiHyE+AmBMyZNimi65+4irHRp1MyYm6/nGVY9P9Js77zjadovY3oi5Jp90DAAAAANgAHCIAAAAAJJ5EO0QyEjNmCwwLkgjLKcDMT3KroDK81k2VcXsF7ceLvrL08atXRQXR2LHB9fEjy+u8uo3Nj711yMkmK8z+8GJPv3stzNr1IsevPN6ej4uPL8z+9CIn197ze5/wsl+86p7SJUiyPtnjkrFO3GQFTZSoes62Sky6KCvpsXZYzNGRmFGlXBnJrWQl09KtS1h9VOglS5YuW+qsI1uWl/q6k+GpuGfYsj9V6eynjQq5MsclQ5apvWSjnapy1EMMEQAAAACAZuAQAQAAACDxJNohkpmwSpVcGcmtZCXT0q1LWH1U6CVLli5b6qwjW5aX+jYm+/NTT2bdsGNUpbOfNirkmkom6FTX1F6y0U7FtiVnZDEnSGJGv9dlt9EpL0hfNvdjuo0N8xPVNjboEMU2cZsfm3VLUhsbdEBiRguCqoMEw8lso1NekL5s7sd0GxvmJ6ptbNAhim3iNj8265akNjbogKBqAAAAAADNwCECAAAAQOJJtEPkN+gtSEBj0CBIXfKC9GVzP6bb2DA/UW1jgw5RbBO3+bFZtyS1sUUHneTx52YUY+rr66mwsJDq6uqooKCgURnPjjlzJtHw4eYnAgAAAADe/n6rINHfEHGHaNIki9KGAwAAAMAIiXaIAAAAAAA4cIgAAAAAkHgS7RB5PZEXAAAAAPEm0a7Avn1ElZX7fwIAAAAguSTaIQIAAAAA4MAhAgAAAEDiSbRDZEsyKAAAAACYJdEOkRM8L9HEidnzEzmV+b0epEymLFXjtUVekL5U2dCp3IZxhdEjaJ86bWWDLW2ZF1vkRUlWmDIbxmSD7kHHZQQWc2Sedh+kjcxThlWcpC57vLbIC9KXKhs6ldswrjB6BO1Tp61ssKUt82KLvCjJClNmw5hs0D3ouDg47R4AAAAAQDNwiAAAAACQeBLtEDklZsx1Ku/YsUQVFY2fewY94TebLKd2YU4sdurHj9zM571hT0/mNs98diz7NOYguoc5jTlXeba1pusEaqfrKZtwnWSPO8i8uLUNaisul697vv5l2rLp+g2iu+55sWVOZO4FHfsqaJmbTf3KC3JPlaV7U2SW5VrH2mExJ0gMUS6CtlMtS3U/URy3qf5s699WnVTroEq+Sr1Nz0uU5sS0rWzSMyq28ANiiAAAAAAANAOHCAAAAACJJ9EOUdDnlzKfe+p6hiqjnyiO21R/tvVvq06qdVAlX6XepuclSnNi2lY26RkVW9hMHn9uRjGmvr6eCgsLqa6ujgoKChqV8eCzmTOJhg+3dxFFQUcAkgb2ZfzAnEbr77cKmiV9A0yaZFGWzIjqCEDSwL6MH5hTYNQhKi8vpz59+lD79u3pO9/5Dl188cW0fv36RnUaGhpo5MiR1KlTJ2rXrh0NHTqUtm/fbkxnAAAAAMQPow5RZWWlcHaWLVtGr732Gn377bd07rnn0q5du9J1xowZQ/PmzaM5c+aI+jU1NTRkyBCTagMAAAAgZrQw2fnChQsb/Xv27Nnim6Kqqio6/fTTxXPDJ554gp555hk6++yzRZ1Zs2ZRjx49hBPVt2/f2AehRUFHAJIG9mX8wJwCq2KIuAPE6dixo/jJHSP+rdHAgQPTdY499ljq1q0bLV26VKkuYU4QliEjVcbhP52y8IbVQZa+MvQxLT9ofRl9qrRLkBOtZdUJaxuV7cPIC7ovbbmvmNhjpseWqw6fy8y5lbGuVI9Zty6662iHWcLevXvZBRdcwPr375++VlFRwVq1anVA3T59+rBx48ZlldPQ0CCyWqY+1dXVgTJVhzlBWIYMGfK91pGhrwx9TMsPWl9GnyrtEuREa1l1VK5x3etfh86m7ys2z7cO+TLryJIlY85k6aK7TmIzVfNYorVr19Jzzz0XOlCbv6aX+pSUlEjTEQAAAADxxAqH6JZbbqH58+fTkiVL6LDDDktfLyoqoj179lBtbW2j+vwtM16WjbKyMvHoLfWprq5Wrj8AAAAAoo1Rh4jnhOTO0Ny5c2nx4sXUvXv3RuW9e/emli1b0qJFi9LX+Gv5W7ZsodLS0qwyW7duLRI4ZX78nnafq8ztBO3M56JhTrN269+rjm59ZHt+6/XU5KDlueo0tVdTHXOdyO1Vvpt+bvMXpk+ZMnLpmWsNeFl/Yet4WX9up9B76Z9f4+25HKc4BC/7yMs4sq3BIHVy9ZFrLpvWcdvHXk5ZlzU+L/dFt/l2q5PLPn7udX7t67VOrn3t5Z6Vaz7d7rtu+0CGfbzcT7yuQT/7VzvMICNGjGCFhYXsjTfeYFu3bk1/vv7663Sdm2++mXXr1o0tXryYrVy5kpWWloqP6tPuTT4nl1HHZJxBlMdnc/yHrL5snx+v/cuSY3o/q5xLXXs1CWO0eZ2ovm+pmp9cbXXHEBl97X7GjBni55lnntnoOn+1/tprrxW/P/jgg9SsWTORkHH37t00aNAgmj59uhF9AQAAABBPjDpEXo5Ry8/Pp2nTpokPAAAAAEBsg6pN4fa8VEWZzjq52qtqK0N31TqqmlsZ4/aaHC5MX7bPj9f+ZckxvZ9VzqWuvZqEMdq8TlTft1TNj9e+tcFijtszyJoaxiZM2P8zF37q6qivq41t47BxzDLl2Do+29aNLtua7Dsq6zYJcxFWRtA+TdrJBlm6Y4gS7RB5DSbzW1dHfV1tbBuHjWOWKcfW8dm2bnTZ1mTfUVm3SZiLsDKC9mnSTjbISmxiRgAAAAAAU8AhAgAAAEDiSbRD5CVpm59EU9nquyUB9JqALkiCtFyJETPb5KqfK3mW36RmXnRyatO0rte5kDEGr+Pxu75k2S/XWgu6BryMJUiCPzedwuoTNkmpG36SPXpNiJgNP/PqNfGhl3GGnWsZe0OVrtn01bG3g649v39H3OT4uQe64UWWG14TbRpJ1shijqwYoqDtZCXF8lNX9vNtXYnPVMqVOQ+6dZPdXxTWgM59Y2LuZe97m/aKTvvInltZ+svWzyab67zXIIYIAAAAAEAzcIgAAAAAkHgS7RAFTQrlp52spFh+6vodly2Jz1TKlTkPunWT3V8U1oDOfWNi7mXve5v2ik77yJ5bWfrL1s8mm5u+1yiFxZywiRllJqEy1b9tyb1k2zQuNrJpHDJlmd5DOvuxZQ6jug5NJKO0bc+YTOJYY1nfSMxoWVC1zCRUpvq3LbmXbJvGxUY2jUOmLNN7SGc/tsxhVNehigB3HTJs0CeOfdchqBoAAAAAQC9wiAAAAACQeBLtEKkOVLWlf1ljsE2OTHk2jM2mcciUZXoP6ezHljmM6jpUEeCuQ4YN+iS1b5nk8edmFGPq6+upsLCQ6urqqKCgoFEZz4Q5cybR8OFmJwEAAAAA3v9+qyDR3xBxh2jSJEMpwgEAAABgDYl2iAAAAAAAOHCIAAAAAJB4Eu0QuZ1YnOvEXVPlbu1s1TnsuOJerqJMlt5h65hcr7pkuNVRtS7ClNu6F6K+Vmwcl637e6vHPsvLSS8s5gRNzKj6xOeg5VHUOey44l6uokyW3mHrmFyvumS41VG1LsKU27oXor5WbByXrfu7ynOfSMwIAAAAAKAVOEQAAAAASDyJdojcEkGpPvE5aHkUdQ47rriXqyiTpXfYOibXqy4ZbnVUrYsw5bbuhaivFRvHZev+LvbY5/jxpBcWc8Kedp+NIO10tLHl1GYTbXXNiYz2OudVd1sT86C7X1n7zOa5UVVXthwde0l1H3HRSUV/OO3estPusxGknY42QccjW5aJtrrmREZ7nfOqu62JedDdr6x9ZvPcqKorW46OvaS6j7jopKI/nHYPAAAAAKAZOEQAAAAASDyJdoicEjPmSihVUUE0dmzjgLBciat4H9mCyNzaZevHrV0qUI33FTYRWDZ9vSbayhYwp6ptLlu5tfWbmLPptUxd/SQh89tO5lz4SeTmpa0Mm/jR0amMt+Xzz9eB1yR1KufPhnl10tvL/cGPbrlsH/SeI3vfB7lP6LgPB7lf+h2HF51krU0Z97jU9W3bSC8s5gSJIQqSUEp2ErQwCbdUJQIzIdeUztnKdPVjqixIW5v0t2WdmBifn7mxQTcv5Tas1ajdL6NyL/Vq98pKxBABAAAAAGgFDhEAAAAAEk+iHSKZyaZkJ0FTldAtanJN6ZytTFc/psqCtLVJf1vWiYnx+ZkbG3TzUm7DWo3a/TIq91Kvdi8qIr2wmKMiMWNQOaoScJlKjGZbfRntVc2lzrHEMTGmiroyE5lG1bYq7i+q6qvUwwYdgtTX1YfqdkjMGOHEjEHlBOnPSxvd47C1voz2quZS51jC9BW0rUpbq6ora99E2bYq7i+q6qvUwwYdgtTX1Yfqdk51EpWY8c0336TBgwdT165dKS8vj1566aVG5dxhu/vuu6m4uJjatGlDAwcOpA0bNhjTFwAAAADxxKhDtGvXLjrppJNo2rRpWcvvv/9+evjhh+nRRx+l5cuX00EHHUSDBg2ihoYG7boCAAAAIL60MNn5eeedJz7Z4N8OTZ06le6880666KKLxLX//M//pC5duohvki6//PLQ/ecKMJMtJ0h/XtroHoet9WW0VzWXOscSpq+gbVXaWlVdWfsmyrZVcX9RVV+lHjboEKS+rj5Ut9O9Fx1hlsBVmTt3bvrfGzduFNdWr17dqN7pp5/ORo0apTSoOtv1sHVVtA/bj079TdtK9xh0jldnX24BkqZ1sHV9hNUtDusjKu1VyrBxbm2wgVvd8eMTGlTd1CH661//Kq7VNLHcJZdcwi699FJHOQ0NDcJ4qU91dbWUTNVh66poH7YfnfqbtpXuMegcr86+3AIkTetg6/oIq1sc1kdU2quUYePc2mAD97oJCqpWQXl5ORUWFqY/JSUlplUCAAAAgOVY6xAV/V9Gpu3btze6zv+dKstGWVkZ1dXVpT/V1dXKdQUAAABAtLHWIerevbtwfBYtWpS+Vl9fL942Ky0tdWzXunVrKigoaPRxwum0cz9ZTr3WVdE+bD869TdtK91j0DnebNedTsRWpavO8UZtfYTVLUprMertVcqwcW5tsIFb3fHjSSt5/LkZGeKrr76ijz76SPx+8skn05QpU+iss86ijh07Urdu3ei3v/0tTZ48mZ566inhIN111120Zs0aev/99yk/P99TH9yJ4o/O+LdFTZ2jVauIevcmqqoiOuUUJUMEwAhY2wCAqFPv8vc7dq/dr1y5UjhAKcby/50lomHDhtHs2bNp3LhxIlfRTTfdRLW1tTRgwABauHChZ2cIAAAAAMB6h+jMM88U+Yac4Nmr77nnHvEBAAAAAEhcDJEO3OIhAIgyWNsAAOCPRDtEfuBBqhMn7v8ps26Q+nHuS3UfYcYfRoaXNjJ14/CfXhwi2Wtb5V7RpZct9W3QIWh90+PTcf8J09aGsdu6V43BYo6s0+5V1Q1SP859qe4jzPjDyPDSxmbd/NRVuVd06WVLfRt0CFrf9Ph03H/CtLVh7Lbu1USedg8AAAAAYANwiAAAAACQeBLtEDklZsz2vJPX8Rqk6kVuUNlB+3ILtvX6TDdb8j+3dkH6cgoGdmrnJXg4s63XYGM3Pd1khNGTl/HMEzyhYtDn66l++HrwGr/hZf35qetnHH7Xb1i9gqxfL7b0OxanxJluOnvZp351DirfSWevey3ovc/P2vJrizDr0et8htnvfnTzKtuPjYp93ptljEM7LOaEjSFS+RzaVMyILBk6n9HrfLYfpr+w82FrTI2qeAeT9pKto03xLbrjZ/zKsDVWR/e+t2EPBpGtSy/EEAEAAAAAaAYOEQAAAAAST6IdIq9xHX7je7y2kZE8z6QMlbaR1S5Kespo70eOn7786qVrD+hYFyrGonpN6lzzQWTo3M+q7aarnY3jVq2XdljMcXsGWVPD2IQJ+39mI1e5l3peZITVw6ueMvXy06cMG/jpU6fesnVX0bfKuqbHJXtvyJCnYj34aRO2nkyb6pzvIDbV2beJvaKizxqNa1d3DFGiHaJcwV0yAgRlBLfK0lOmXiYStOmaD5n9BelXdt8q65oel+y9IUOeivXgp03YejJtqnO+VQc2q77Pm9LL5rVbh6BqAAAAAAC9wCECAAAAQOJJtEOULUFUtsRi2ZJWOSUga5qkyi1BVrbkZNmSXDnJcEpulk1GNr3c+nRKNOZVZ7cEbU3ruyU18zofXu3hZdxe9fa6jryuAy9z7nceZMxZtvnyY6Mg9ve6pnOtGz/28TIeL/OSqZNbok63PR3UJn5kO+2nXGu1qc3dEvM5JeHzqovb/ITdY046+rWr13HKvAd4vS+q6LNZyL832cqdZGuHxRy/MURhrkWxrirZfvpTqZtqO8mwSZBYDp1zpnO+bFnTsvqVIduW9SHDHqZ0UTlnfq6buHeZuF7lMw7NqT5iiAAAAAAANAOHCAAAAACJJ9EOUbYEUWGuRbGuKtl++lOpm2o7ybCJ3+sy5Idpr1svv3VlyJbVrwzZtqwPGfYwpYvKOfNz3cS9y8T14hzJF/3YXCss5gRNzGhLWVz7skUPW8ac5DLoEc2ypMlLclmNob6QmNGSxIy2lMW1L1v0sGXMSS6DHtEsS5q8JJdVGeoLQdUAAAAAAJqBQwQAAACAxJNohyhI8Jzusrj2ZYsetow5yWXQI5plSZOX5LJiS/pSDos5soOq3dqEKTchN5fMMO3Dyg4zLhXtwrZV2beNYworV1YdlWs8TNu47SuVslXvO9XjCtPWlOwaA38bs9VBULXlQdVubcKUm5CbS2aY9mFlhxmXinZh26rs28YxhZUrq47KNR6mbdz2lUrZqved6nGFaWtKdpWBv43Z6iCoGgAAAABAM3CIAAAAAJB4Eu0QOZ1Q7FSW6wR4L6d5O50m7KaLmz65+s11ErJTmdN4w56y7PekdCc5Ttdz2dOPHf2M18scuuns1dbZ1pVfuV77TMl2G7NTeRhb+TmpPpccLyezu9kvyDrzcip40H3p9VT1XHbzex/yc9K5k4ygtnRbv17WSa5+3er4uccGsYmM9RvE3n7uN17t7eVe4aZPNtnl5aQXFnNkxhD5fXbq53qQ56+y5IeVY0IP1WOSNV4VesnSSebYVM+dbXJk9WHqHqRSvg5bytJfhTzdcnTcB83pgxgiAAAAAACtwCECAAAAQOJJtEPkN2mU30RSfq7nSkYVVh9ZCbJs0UP1mGSNV4VesnSSOTbVc2ebHFl9mLoHqZSvw5ay9FchT7ccHfdBU/qMH096YTEnSGLGsInRvNSTkcRKRz+2l+voR0eCwCisuSjYQbWOtsyFjDq2j9N2HUzrbqqtzjWOxIwWBFUHDQr0Uy9sua5+bC/X0U/QgEyd/avWISp2UK2jLXMho47t47RdB9O6m2qrc40jMWMWpk2bRkcccQTl5+fTaaedRitWrDCtEgAAAABihPUO0R//+EcaO3YsTZgwgVatWkUnnXQSDRo0iHbs2GFaNQAAAADEBOsdoilTptCNN95I1113HfXs2ZMeffRRatu2LT355JOhZbsltMqVNC0z+MspGViuZGFuybyC9ONVjluitabkSmrmZqsw+uVKytZUVthxuiVIy2UDv3bwMo9ebeB1jF5smaufXHbwIsNL8kq3BJS59kTQOl7sKGsuwtpBRsJBv/c5Nx387G8/c5HL1l7reb2H+V1zpteJ13tOkPktzrFH3O65XnT3Um4EZjG7d+9mzZs3Z3Pnzm10/ZprrmEXXnhh1jYNDQ3ieWPqU11dHSgxo5dymXJ01vFTz+Z+deolc3wmbK9jfFEdu9d6Nu4DXXNv4z4yVc8me9qoTwrEEEnm888/p71791KXLl0aXef/3rZtW9Y25eXlVFhYmP6UlJRo0hYAAAAAUcVqhygIZWVlVFdXl/5UV1ebVgkAAAAAltOCLOaQQw6h5s2b0/bt2xtd5/8uKirK2qZ169bik4KnFuDU19cfULddu/2Jn/jPLMU5y2XK0VnHTz2b+9Wpl8zxmbC9jvFFdexe69m4D3TNvY37yFQ9m+xpoz4y9Ur93U79HVdNHtPVU0D4a/bf//736ZFHHhH/3rdvH3Xr1o1uueUWGu8hjeXHH39MRx11lAZNAQAAACCbjRs30pFHHkmJ/oaIw1+5HzZsGJ166qnCMZo6dSrt2rVLvHXmhY4dO4qfW7ZsETFFwBzc2+cxXfwxZkFBgWl1Eg3mwh4wF/aAubALHvbCvwBJ/R2npDtEl112GX322Wd09913i0DqXr160cKFCw8ItHai2f+908edISxwO+DzgLmwA8yFPWAu7AFzYRepv+OUdIeIwx+P8Q8AAAAAgApi95YZAAAAAIBfYu8Q8TfO+LEfmW+eATNgLuwBc2EPmAt7wFwkez6sf8sMAAAAAEA1sf+GCAAAAAAgF3CIAAAAAJB44BABAAAAIPHAIQIAAABA4om9QzRt2jQ64ogjKD8/XxwDsmLFCtMqxYry8nLq06cPtW/fnr7zne/QxRdfTOvXr29Up6GhgUaOHEmdOnWidu3a0dChQw84n45nEr/ggguobdu2Qs4vf/lL+te//qV5NPFi8uTJlJeXR6NHj05fw1zo49NPP6Wf/vSnwtZt2rShE044gVauXJku5++z8ISzxcXFonzgwIG0YcOGRjK++OILuuqqq0SSwA4dOtD1119PX331lYHRRJe9e/fSXXfdRd27dxd25kc5/eY3v2l0PhbmQh1vvvkmDR48mLp27SruRy+99FKjclm2X7NmDf3gBz8Qf+t5tvH777/fv7Isxjz33HOsVatW7Mknn2Tr1q1jN954I+vQoQPbvn27adViw6BBg9isWbPY2rVr2TvvvMPOP/981q1bN/bVV1+l69x8882spKSELVq0iK1cuZL17duX9evXL13+r3/9ix1//PFs4MCBbPXq1eyVV15hhxxyCCsrKzM0quizYsUKdsQRR7ATTzyR3XbbbenrmAs9fPHFF+zwww9n1157LVu+fDn7+OOP2auvvso++uijdJ3JkyezwsJC9tJLL7F3332XXXjhhax79+7sm2++Sdf50Y9+xE466SS2bNky9j//8z/s6KOPZldccYWhUUWTe++9l3Xq1InNnz+fbdq0ic2ZM4e1a9eOPfTQQ+k6mAt18HvIr3/9a/biiy9yD5TNnTu3UbkM29fV1bEuXbqwq666SvwtevbZZ1mbNm3YzJkzfekaa4fo+9//Phs5cmT633v37mVdu3Zl5eXlRvWKMzt27BCLvrKyUvy7traWtWzZUtyEUnzwwQeiztKlS9MbplmzZmzbtm3pOjNmzGAFBQVs9+7dBkYRbb788kv23e9+l7322mvsjDPOSDtEmAt9/OpXv2IDBgxwLN+3bx8rKipiDzzwQPoan5/WrVuLmznn/fffF3Pz9ttvp+ssWLCA5eXlsU8//VTxCOLDBRdcwH72s581ujZkyBDxx5ODudAHNXGIZNl++vTp7OCDD250j+J78JhjjvGlX2wfme3Zs4eqqqrE12+Z56Hwfy9dutSobnE/jI+TOoyPz8G3337baB6OPfZYcWBfah74T/44IfN8ukGDBomDFtetW6d9DFGHPxLjj7wybc7BXOjjz3/+sziQ+pJLLhGPHU8++WT6wx/+kC7ftGmTOJsxcy74eYv8sX7mXPDHA1xOCl6f38eWL1+ueUTRpV+/frRo0SL68MMPxb/fffddeuutt+i8884T/8ZcmGOTJNvzOqeffjq1atWq0X2Lh2/s3LkzXmeZBeHzzz8Xz46bHgLL//33v//dmF5xZt++fSJepX///nT88ceLa3yx80XKF3TTeeBlqTrZ5ilVBrzz3HPP0apVq+jtt98+oAxzoY+PP/6YZsyYQWPHjqU77rhDzMeoUaOE/YcNG5a2ZTZbZ84Fd6YyadGihfifDcyFd8aPHy8ceu78N2/eXPxduPfee0VMCgdzYY5tkmzPf/IYsaYyUmUHH3xwsh0iYOabibVr14r/+wL6qa6upttuu41ee+01EVgIzP7PAf8/2vvuu0/8m39DxPfGo48+KhwioI/nn3+eKioq6JlnnqHjjjuO3nnnHfE/bjzIF3MBMontI7NDDjlE/N9A0zdo+L+LioqM6RVXbrnlFpo/fz4tWbKEDjvssPR1bmv++LK2ttZxHvjPbPOUKgPe4I/EduzYQaeccor4Pyj+qayspIcfflj8zv+PCXOhB/7GTM+ePRtd69Gjh3iDL9OWbvcn/pPPZyb8bT/+xg3mwjv8LUn+LdHll18uHgdfffXVNGbMGPGGLAdzYY4iSbaXdd+KrUPEv5ru3bu3eHac+X9t/N+lpaVGdYsTPE6OO0Nz586lxYsXH/C1JZ+Dli1bNpoH/lyX/2FIzQP/+d577zVa9PxbDv6KZdM/KsCZc845R9iR/x9w6sO/peCPBlK/Yy70wB8bN00/wWNYDj/8cPE73yf8Rp05F/yxDo+JyJwL7rxyRzcF32P8PsZjLIA3vv76axFvkgn/n2VuRw7mwhzdJdme1+Gv9/MYycz71jHHHOP5cZmAxfy1ex6tPnv2bBGpftNNN4nX7jPfoAHhGDFihHhl8o033mBbt25Nf77++utGr3rzV/EXL14sXvUuLS0Vn6avep977rni1f2FCxeyzp0741VvCWS+ZcbBXOhLe9CiRQvxyveGDRtYRUUFa9u2LXv66acbvW7M70cvv/wyW7NmDbvooouyvm588skni1f333rrLfH2IF719sewYcPYoYcemn7tnr/+zVNJjBs3Ll0Hc6EO/tYrT+HBP9zlmDJlivh98+bN0mzP30zjr91fffXV4rV7/ref7ze8dt+ERx55RPwB4PmI+Gv4PI8BkAdf4Nk+PDdRCr6wf/7zn4vXIvki/bd/+zfhNGXyySefsPPOO0/kjuA3q9tvv519++23BkYUb4cIc6GPefPmCeeS/0/Zscceyx577LFG5fyV47vuukvcyHmdc845h61fv75RnX/+85/ixs/z5vDUB9ddd534AwO8U19fL/YA/zuQn5/PjjzySJEXJ/MVbcyFOpYsWZL1bwR3VGXanucw4qkuuAzuAHNHyy95/D9yvvwCAAAAAIgmsY0hAgAAAADwChwiAAAAACQeOEQAAAAASDxwiAAAAACQeOAQAQAAACDxwCECAAAAQOKBQwQAAACAxAOHCIAE8cYbb1BeXt4B55kB/9x111100003KZP/+eefi1O+//GPfyjrAwDw/yAxIwAx5cwzz6RevXrR1KlT09f44a78UER+0Ct3jEw5ZWeddRbt3LmTOnToQFFk27Zt9L3vfU+c+5Y6n0wFv/jFL4SdnnjiCWV9AAD2g2+IAEgQ/NBjfpiiKWcoLjz++OPUr18/pc4Q57rrrqOKigrhxAIA1AKHCIAYcu2111JlZSU99NBDwvnhn08++eSAR2azZ88W39LMnz9fnAzdtm1b+slPfiJOCH/qqafoiCOOEKdFjxo1ivbu3ZuWv3v3bvHtxaGHHkoHHXSQOHWay06xefNmGjx4sGjLy4877jh65ZVXhA782yEOL+O6cF05CxcupAEDBgh9OnXqRD/+8Y9p48aNaZm8La///PPP0w9+8ANq06YN9enTR5wi//bbb9Opp55K7dq1o/POO48+++yzRra4+OKLadKkSdS5c2cqKCigm2++WXxbluKFF16gE044QcjkfQ8cOJB27drlaN/nnntOjK/pN3K33norjR49WoyNfwv3hz/8Qcjhjk379u3p6KOPpgULFqTb8G9/rrrqKqEX7/u73/0uzZo1K13O7da1a1eaO3dugFUAAPBFqFPbAABWwk9/5qfY33jjjeLwVv7hJ9mnDlrcuXOnqMcP4W3ZsiX74Q9/yFatWsUqKytZp06dxGn3l156KVu3bp04pJQfjsxPkE5xww03sH79+rE333yTffTRR+yBBx4Qhyp++OGHovyCCy4QMvnp1Rs3bhQyuGyuw5/+9CehAz/AkevFdeW88MILooyfDs9Pwx48eDA74YQT2N69e0U5P6mct+MHpS5cuJC9//77rG/fvqx3797szDPPFKdg8zEcffTR7Oabb07ryg+R5IdCXnbZZeIkbH7qeefOndkdd9whymtqasTJ9PwUbt4H13natGmOB3fygybz8vIOOCiaH6Tbvn179pvf/EbYgf9s3ry5OCiXH+zKr40YMULYd9euXaLNyJEjWa9evdjbb78t+n7ttdfYn//850Zyud6pgzABAOqAQwRAQk6652RziPi/uVOTYvjw4axt27aNHIJBgwaJ65zNmzeLP/SffvppI9n8lOqysjLxO3dkJk6cmFWvpjo48dlnn4l67733XiOH6PHHH0/XefbZZ8W1RYsWpa+Vl5ezY445Jv1v7kx07Ngx7YRwZsyYIZwk7mxVVVUJGZ988gnzAnfWeP0tW7YcYG9+2nYK7vwddNBB7Oqrr05f4w4gb7t06VLxb+708ZO73RgzZoxw+AAAasEjMwASDn9MdtRRR6X/zR/18Edl/PFT5rUdO3aI33kgMX98xoOKeZ3Uhz+iSz3i4o/Y/v3f/5369+9PEyZMoDVr1uTUY8OGDXTFFVfQkUceKR5rcR04W7ZsaVTvxBNPbKQXhz/uyqZripNOOkmMM0VpaSl99dVXVF1dLcrOOeccIeOSSy4Rj7n4oywnvvnmG/EzPz//gLJM3Zo3by4evzXVjZPSb8SIEeLxGw9+HzduHP3tb387QCZ/lMYfYQIA1AKHCICE07Jly0b/5nE62a7t27dP/M4dCf7Hvqqqit55553054MPPhAxS5wbbriBPv74Y7r66quFA8Xjex555BFXPXhMDg8e5g7J8uXLxYeTGevTVN9UcHjTayldvcDH8tprr4nYnp49ewo9eTzVpk2bstY/5JBDxM9sTlMuW6b0TenH4514vNWYMWOopqZGOGY8NisTbhMeYwQAUAscIgBi/EZZZiC0LE4++WQhl3/LwYOEMz/8DbYUJSUlInj5xRdfpNtvv104Oim9OJm6/fOf/6T169fTnXfeKZyCHj16uH5L45d33303/c0OZ9myZeJbLa5jylHh32bxwOvVq1cLHZ0Cmfm3afwbrPfff1+KbtzZGTZsGD399NMiRcJjjz3WqHzt2rXC5gAAtcAhAiCm8EdO/FsW/nYWT/Ln51sTN/ijMv5m1DXXXCOcHf5NyooVK6i8vJz+8pe/iDr8TatXX31VlK1atYqWLFkinBwOf1WdOyD8zTb+Nhj/xom/lcUfL3Fn4KOPPqLFixfT2LFjSRb8W6brr79eODH8bTf+GO+WW26hZs2aCRvdd999tHLlSvF4jo+J65XStym8DX8L7a233gqt1913300vv/yyGPO6deuETTL75Y/K+Ddx5557bui+AADuwCECIKbwRy/8cRB/DMS/hWgaixMG/mo4d4j4Nz/88RJ/rZ2/+t6tW7f0tz8jR44Uf9x/9KMfCSdq+vTpooy/qs+/iRk/fryIqUk5JjyWhv/xP/7448UjpAceeECavvxbJ/5K++mnn06XXXYZXXjhhTRx4kRRxr/tefPNN+n8888XevJvqX73u9+Jx1lO8EeCXN+wTib/JqqsrEzEHnHd+HxxuSm4s8RtytMMAADUgkzVAIBYw/MQ8bxLL730kjSZ/LbJcy9xx40Hgquib9++IkD9yiuvVNYHAGA/+IYIAAB8wh/58cd7//rXv5T1wR9zDhkyRKnDBQD4f/ANEQAg1qj4hggAED/gEAEAAAAg8eCRGQAAAAASDxwiAAAAACQeOEQAAAAASDxwiAAAAACQeOAQAQAAACDxwCECAAAAQOKBQwQAAACAxAOHCAAAAACJBw4RAAAAACjp/C8YxOEGG3ZBVgAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -635,7 +645,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -645,7 +655,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj4AAAHHCAYAAAC/R1LgAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAdgBJREFUeJztnQm8ldP6x5/TPM/zXFKpdEWkMuuW4SKSWUUyE4VKwq1LhVzD30UoXcPNTIVIGXJNkVJJSaM0Kc2DU2f/P886d+2z3rXXeoc9nL3fvX/fz2fX2fO732Gt33rGvEgkEiEAAAAAgBygRLo3AAAAAACguIDwAQAAAEDOAOEDAAAAgJwBwgcAAAAAOQOEDwAAAAByBggfAAAAAOQMED4AAAAAyBkgfAAAAACQM0D4AAAAACBngPABAAAAQM4A4QMAAACAnAHCBwAAAAA5A4QPAAAAAHIGCB8AQKhZt24dXXnllVS3bl0qW7YstWvXjiZOnCie27t3L7Vp00bc+G/J1q1bqX79+tS1a1c6ePBg9PH333+fTjzxRKpcuTJVqVKFjj76aHr55ZfT8rsAAKkBwgcAEFo2btxIxx57LH300Ud044030qOPPkotW7akAQMG0COPPELly5enyZMn0/Lly2nEiBHR991www20fft2ev7556lkyZLiMf77zDPPFKJo+PDhNHbsWDriiCNoxowZafyFAIBkkxeJRCJJ/1QAACgGrrrqKnrvvfdo4cKFVLNmzejjF198sbDerF+/XoifO++8k8aNG0effPKJEEt9+vQRwmjQoEHi9SyCGjduTG3bthWvKVeuXPSzeIjMy8tLy+8DACQfCB8AQCjhoatGjRp0wQUX0H333ed4bvr06XTFFVfQ559/Tt26daM///yTOnXqRLt27RI3Fjgff/xxVNC8/vrrQgy99dZb1KtXrzT9IgBAcVCqWL4FAACSzObNm2nbtm00YcIEcTOxadMm8X+ZMmVE3A/H7LA1Z9KkSQ4rzi+//CL+b9++fTFtPQAgXUD4AABCSUFBgfj/sssuo379+hlf06FDh+jfH3zwgfh/37599PPPP1Pz5s2LaUsBAJkEhA8AIJTUrl1bZF9xVlb37t1dX/vDDz/QqFGjhPtr/vz5IjaI44KqVq0qnj/kkEPE/4sWLRLB0QCA7AUxPgCA0MJChtPNv/vuuxg3FbvCWBzl5+dT586d6Y8//hACaOXKlcLldemll0bT3nfs2EGNGjWiww47jD799FMENwOQxUD4AABCC2dosahhkTNw4EARtMzp6PPmzRMp7vz3PffcQ6NHj6ZZs2bRySefLN7HwdB33XUXvfvuu3TGGWeIx5577jlhCWIBdckll1D16tVpwYIFtGfPHpESDwDIDiB8AAChhgOY2Y01depU2rBhg0hr5yKGF154IR111FFCGF133XX02GOPRd/D7rEuXbqI4oeLFy+matWqicenTZsm6vd8//33VLp0aVH48NZbb6WLLroojb8QAJBMIHwAAAAAkDOgcjMAAAAAcgYIHwAAAADkDBA+AAAAAMgZIHwAAAAAkDNA+AAAAAAgZ4DwAQAAAEDOgJYVhv4/v/32myiFj2qtAAAAQDjg6jw7d+6kBg0aUIkSdrsOhI8Gi57GjRunezMAAAAAEAdr164VLWhsQPhosKVH7rgqVaqke3MAAAAA4APuuceGCzmP24Dw0ZDuLRY9ED4AAABAuPAKU0FwMwAAAAByBggfAAAAAOQMED4AAAAAyBkgfAAAAACQM0D4AAAAACBngPABAAAAQM4A4QMAAACAnAHCBwAAAAA5A4QPAAAAAHIGCB8AAAAA5AyhET7NmjUTZajV29ixY6PPr1q1KuZ5vn311Vdp3W4AAAAAZA6h6tU1atQoGjhwYPS+qRHZRx99RO3atYver1mzZrFtHwAAAAAym1AJHxY69erVc30NCx2v1ySTgwcPiv9LlixJkUiEDhw4QCVKlBA3+VypUoW7uaCgIPo+fq1spMavVR/j90mLlfwO+Zn8Gr7x3/Lz+HXyMf2z5X31b/W9f/75p7hfunTp6Oeon6ne5xv/Pv498nH+HPm9/De/Rn6+3AZ1W+Tj6nbI96v7U31M3S7529T7cr/or+f/5e/k46O+Xz4u36/+Xr3Bnb4v5XfJY8yfLfeL/A3qNqh/m44Pb4vcPvV71PNFf6/8zfp268daPzfU18jPl5+lfqb8Xeoxlt8jj6E859XzVP0d+n19H+r7QG6LPD7qNaC/h//mz+fXlS1bNvp96jWg7gv1t6jHQ78e1H2t/m65LabzWj+H+b56Xtl+v0Q9f/XX658t36u+Xv3N6mfIc1Ldt+r1pR8DeX3LYyu/m/+X45rcD+r5YNov+fn5Mdewep2pj+v35fbK60j9HH1fyWNuOlbyHJHIfaF+Hm+nvG7VfSxfw7+b78v3quezOv7KzzEdK/U85veo1496vuj7RD7PYzSPz+pYpo/Tcl/Ix/TxRz2WjOkcVveNfu3Jx9TjrZ9v/JjcT+r7Jer2MabjJr9PHlf1WOjbos8D8jf4IS+i7vEMd3Xt27dPnGBNmjShSy65hG699dboScuurubNm4uW9Py6Vq1a0R133EFnn3226+fu379f3PS29tu3b3d0Z3/tteU0c2YVuuqq3+mYY9qKx3bu3EmrV69O2W8GmUPLli3p119/FeeWDX0CTSXxfFdxbh8AJngC5zE8DIvs3bt3x3W9JOs6K1++PO3du5eylRIpGI927dpFXbp0iZm/Q2vxufnmm+nII4+kGjVq0BdffEHDhw+n9evX08MPPyyer1SpEo0fP566desmdugbb7xBvXr1orfffttV/IwZM4b+/ve/e37/BRe0FP8XFOTRMceQ+O4tW7Yk8ReCTGb58uWerylOURHPd0H0gHQTBtEjF7XxkqzrLJtFT7rHo7RafIYNG0bjxo1zfc2SJUuoTZs2MY9PnDiRrrnmGqHwpKlbp2/fvrRy5UqaM2dOwhYfabXr3n07zZxZlRYtWuTnJwIAAACgGAiFxWfIkCHUv39/19e0aNHC+Hjnzp2F/5VdXK1bt7a+ZubMma6fz6LJJpxMVK6MVTMAAAAQVtIqfGrXri1u8TB//nzh0qpTp47ra+rXr0/JpHLlomA5AAAAAISLUMT4fPnll/T111/TySefLILO+D4HNl922WVUvXp18ZrJkydTmTJlqGPHjuL+m2++Kdxhzz77bFK3pVIlCB8AAAAgrIRC+LArasqUKXTvvfeKeBzO3mLhM3jwYMfrRo8eLbKsONOL44JeeeUVOv/88xP+/u+/X0xEhbWBKlWCqwsAAAAIK6EQPpzN5VWBuV+/fuKWCnbvLqojULEihA8AAAAQVkLTsiKd7NypFtAKRdkjAAAAABiA8PHB7t2x1WcBAAAAED4gfHywaxd2EwAAAJANYEb3ASw+AAAAQHYA4eMDWHwAAACA7AAzesCsrnC0dAUAAACACQgfH+zcCVcXAAAAkA1A+AS0+AAAAAAgvGBG98GuXbD4AAAAANkAhI8PYPEBAAAAsgPM6D6AxQcAAADIDiB84rD4RJDaBQAAAIQSCB8fIKsLAAAAyA4gfHwAiw8AAACQHUD4xFG5GcIHAAAACCcQPnH06oLwAQAAAMIJhI8H33+/iPbtU1tW5EH4AAAAACEFwseDPXtiA5shfAAAAIBwAuHjwd69sbsoPz8/LdsCAAAAgMSA8PFgz568mMdg8QEAAADCCYRPHBafAwcOpGVbAAAAAJAYED4e7NkTu4sKCgrSsi0AAAAASAwIn4AWH/ZyweIDAAAAhBMIHw9g8QEAAACyBwifOGJ8Dh48mJZtAQAAAEBiQPjEIXxg8QEAAADCCYSPB8jqAgAAALIHCJ84YnxQxwcAAAAIJxA+cWR1wdUFAAAAhBMInzhcXbD4AAAAAOEEwscDpLMDAAAA2QOEjwew+AAAAADZA4SPBxA+AAAAQPYA4eMBsroAAACA7AHCx6fFp3z5wrge1jwQPgAAAEA4gfAJKHwAAAAAEF4gfDzYuzdP/F+hQpHwgcUHAAAACCcQPj5jfGDxAQAAAMIPhI8LCxcuon37IHwAAACAbAHCx4V9+/IoEol1dQEAAAAgnED4+ExlL1euKKsLAAAAAOEEwsdHRheLnhLYUwAAAEDowXTugozvYeGTlwdTDwAAABB2IHxc2L+/ML6nbFmIHgAAACAbgPDxafEBAAAAQPiB8HFh/34IHwAAACCbgPDxSGdn4OoCAAAAsgMIHxdg8QEAAACyCwgfnxafvMI/AQAAABBiIHxcgMUHAAAAyC4gfFxAOjsAAACQXUD4+EhnL1sWFh8AAAAgG4DwCVjHRzYtBQAAAED4gPBxAensAAAAQHYB4eMzuBlZXQAAAED4gfBxAcHNAAAAQHYB4eMCgpsBAACA7ALCx4fFp1y5IotPBMYfAAAAILRA+LgAiw8AAACQXUD4BLT4AAAAACC8QPj4yOqCxQcAAADIDiB8fNTxgcUHAAAAyA4gfFyAxQcAAADILiB8AgY3I6sLAAAACC8QPi4guBkAAADILkIlfN59913q3LkzlS9fnqpXr069evVyPL9mzRo688wzqUKFClSnTh26/fbb6cCBA3F/H1xdAAAAQHZRikLCG2+8QQMHDqT777+fTjnlFCFoFi1aFH3+4MGDQvTUq1ePvvjiC1q/fj317duXSpcuLd4TlB9++JEOHDg2avFBry4AAAAg/IRC+LDIGTRoED344IM0YMCA6ONt27aN/v3hhx/Sjz/+SB999BHVrVuXjjjiCBo9ejQNHTqU7r33XipTpkyg7/zzzyJjGDcpBQCEh717C1cq5cvDTQ0ACKGra968ebRu3ToqUaIEdezYkerXr0+nn366w+Lz5Zdf0uGHHy5Ej6Rnz560Y8cOWrx4sfWz9+/fL16j3tRUdgZNSgEIl+g57bTWdMEFLakAaxYAQBiFz4oVK8T/bLm56667aPr06SLG56STTqKtW7eK5zZs2OAQPYy8z8/ZGDNmDFWtWjV6a9y4cUx8z+GHt4++Hlld4Wf37hI0eXJNWr++dOD3HjxI9O23FaIWhXSSn5/+bchEfvutDG3dWopWrSpLW7aEwqgNAMgV4TNs2DDKy8tzvf30009U8L9l24gRI6h379501FFH0aRJk8Tzr732WkLbMHz4cNq+fXv0tnbtWkdGFwKbs4s9e/Lo2GPb0kMP1acBA5oFfv8zz9SmK65oQXfcUSiQ08Uvv5Slzp0Po0cecYp9wG7qIkF4zz0N07otAIDMI63LoSFDhlD//v1dX9OiRQsRqKzH9JQtW1Y8x5lcDAc1f/PNN473bty4MfqcDf4cvukglT07+eijqtG/164tS8uWlaVWrfb7fv+//11L/P/JJ1UonTz6aF3Kzy9Bzz1Xm265pfA8B85rl5kzp3JatwUAQPTFFxWpQoUCOuKIvUS5Lnxq164tbl6whYfFydKlS+m4444Tj+Xn59OqVauoadOm4n6XLl3ovvvuo02bNolUdmbmzJlUpUoVh2AKumqUFh9kdWUH7KpSeeSRevSvf62Oy5qQCKtXl6H//KcG9e//O9WrF7zkwldfVUrKdmQje/eGwoMPXFi1qgx98klluvDCrQhQDzm//16Srrmmufj7hx8WZcRcGooRgsXLtddeS/fcc4/I3mIBdN1114nn+vTpI/7v0aOHEDiXX345LViwgD744AMRD3TDDTcYLTpeFMX4ZO5Fh3ij4JQu7dxpZcoUxHVeJEq/fs3ppZdq0W23NYnr/ZjcU3+McpHXXqsuVufp5qyzWtH48fXp6acLF7G5zOLF5ei001rRBx+k18ocL7//Xjrj4hJDM0JwKvtFF10khM3RRx9Nq1evptmzZ4sgZ6ZkyZIi6Jn/Z+vPZZddJur4jBo1Kq7vkyt7faLMFF58sSaddFIbWrEiuKjLZUqWdN6vWDE9MVxbthQOBosWlU/4s7ZvD81lXGzxTyAYO3eWoIcfrkujRjWMrs5T5Ya8++6GNGuWPxcku3IzgV27SqRt0h40qCmtW1cm7kVSJrFPyZZOJ6EZMbkQ4UMPPSTidjjlnN1Y7dq1c7yG3V7vvfce7dmzhzZv3ixeX6pUfN48eZKXKRPJSCvLuHH1RebKAw/Y45dALLpQTJfwkejnVyIiCsTG9TRvvi9pn7t5cykaP75uxgzeyeSmm5rSpEmpFxkvvVST3nqrOt1yS1PKz6dQsGNHCerSpS2de27LtHz/9u0lrfPP77+Xosceq0Pr1mXuGHDgQJ6xPl46yYytyEDkAUJWl38yxYzpxlNPOU3nHHDnl2TUhOEOKgsXlo/b1WaidGmcoypqwdGVK8slZVJ4/vmadMopbej552vT0Uc7F1x+YRfS44/XiYkzM7FxYylhZSguvvuueNxbv/1WdCymTSu01utkmiD6/vvCfbN6ddm0NsuWsU8qQ4Y0pmeeqSPqVnHZFc5azTT2KQuFVNTVYiviW29Vo23bNHO+CxA+IXV1Sfxun5/BNhF4UO/UqS29/HIN18GcL06+8SoqVfCqyG8QcqVKB4vVhfLYY3XpkksOid7fscP/xWqfGDJvsEsn//2v043Ck0Ki4ofjTRKFXUgTJtSh998vyiy0WZa6d28jrAzJvG7nzy8v3FnprEGlxl9t3VoyFPFr6mQdz8TN4qRr18PiSoz4/HNnEsP48fUcgmLePKdgnTGjGiWTn34qR1dd1Yx++KG80cXuR6SqxzwVHpNBg5rQ3Xc3ogkT/FssM+sMyyB0V1deXnKO2P3316eHHqpXrK6Sf/yjvlitbtkSfJL1y9ChjamgII/GjGlgfc055xwa/btbt+CZdn65/fbG1K3bYSKbQEe34L39tnnVaeK884q2340vv6xIffs2p+XLY4WS7k6IRIIPhnv2OH9XAn140w5v+3ffVUjaKt82uSxYUCFjLJmbNrmLsB49Wkf/Xrs2WKsdNy6//BBx/j3/fGFJBrfJKFULE7XUgD5ph0H4qNvvN3bqww+r0s6dJemNN+xjzYYNpY3Wmuuuc9Ya27ix6Nx5883YzytRIrnK4uqrm9HXX1cSyRgqXPz1uOPaUt++LQJZfGzjHS9Mxo2r57AIBl3ovPCC87x2I7POsAxCT2f34oUXatJZZx3qOoAvXVqW/vOfmjR5ci2H3zbVFp9XXqkp4oFefdVujUkUP0p+9+7UCS+VDz6oKszDU6fGDgzHHbfTcT9e83WbNvZ6FFdf3VyYx88991D6+eeyKak8rcKCM6y891416t+/hTFwMx5Xj+pGTFYsV6Lug7lzK9IddzSK3vdKSFBjIoKskP1ah/Rz3iTsUlUuYenSco5YLNNiLNOEjzpZB80YVCfjWbOqGM8NtoD/9a+tqXPndp7Hu3Llgw6xpFO+fIHRTcsChq+noJbPP/4ojJE9cMD5u2WG2aJF3gsK9Xh+/7359ddd15RefLEW3XhjYXmaVJNZZ1gGxvj4DT594IH6okT+4MFNXAWIxKuUPqcw/vprac8BLlFXXJitBV6Y9s2vv8auoDlAMCh+Td5+rUSJCJ8wH8MRIwoFwezZzklhxowqwtXz0kvJEesVKsTvM9q7NzHBfuWVzen994tcEO+849/K+OST/tK52Wp2xBHt6b77vF1ypUpFPIVGyZKpcfHLidR2X98etwWGF9xa5qKLWljFsF9UK48ab+MHrkUkYcuJ6dxQ+e9/K/kWrXqGKrNkSXmjm/bLLyuJ64ndvt9bxEcQgohT9bVff2228nEsHvPzz0XCOJVA+FiQq6CgwsKtoq9qhnfzR7LgueiilnT66UUmb5XFi4tObt4+rj5sW5WqkyJbfVR4pdGxY3v697+LBFlxkuoJ2yRaly6NHRh69w6erZFOK4sufA4ejG9b1qwpk7GiSQahjx1rd5362TfJWCDYYlGSZflwQxVMbrDVjJkyxfta1veFaRJLVWxj7dr5riJM3x7dtcQihsctjuvwglvLLF5cga69NjErwp49RdsTNKPPZIFx45tvKvp2k9aqlR9X+n9fH+4p5scfy8XEngW1fE2cWEuUSJCksnhhELEO4WNBXnB+LD56zI5tMjnqqN2+FLMqbEzMmFHVsULo3ftQ6tfPfDJ/9FGRELMNig8+mHjgZjxBayYT+5w5leidd6olZTvcBm/VF64LQj8kMzshSDaCKcYnHuHDFpUzz2yV9p5jNuKNbeFeal7wooNjFvzGa4wa1SApVkIVU3yGV4ZastDFhmnR5EdAqdccB01zZo0Xbdo4ywuYGgWrVhU9/VkmBrCFUJ+YbezYYT5WHMfkJ6ZEHauDWny6ddsV6FiqCyqvRUnQRUFQLrzQuSBUx0nbtaOPZf/8p3NurFs3dSl7QcQ6hI/HpOwnxodjdkzvtX0mc8gh9voiXoWq1Eh/7kTN/PSTWSzZXGp+hEph1H5eUgJMTd9net311zeju+5q5IiJCIJ6QbqlebdsmVh9lxUryiUtO4aDsROxanAApW1gtwk0KRBmzqxqPC7FUa/KLSYlXmFpq7SuTiiPP15XBNbee6+/BqZsNYhX+NgmL76u/AjegQM3U7Lx4+oK0uOM41Q4aJoza7zQv+vhh2MTPdTrym38mTYtsQymk09uQz17thbZpiZkvOZnnxXti6BZdmqCgx/R1KDBn3EviJiLLtriuJ/M9Payylyo/xYeL9gSd/zxh9Ftt9nHs5Yt/fdFDAqETxLgBpDqzgxiomMXggl1MOHaC08+6b06XbGiTEInj8mH7sdkyxlRHLV/zjnB3UALFsSKMJNIkPu46H5wE7+OekHqF8KGDUX7onbtA0mJT/EjELwm8aCBpLrwMU0eHEjPmXODB5sHIVshsbVrS1Pnzm1p9Oj4V5MrV5YRwtW0mlfZtcs8sPM+1YMpJX/8UZKefrq2NUOxR4/t4v8aNQ54HoPp0+OfOE0uGik2VfHN2TwmXnuthpgk9OtCn1hNCy/eB1594NzQrwu9thXTsGHRBOyF6gLxQhfapgw31bXklgLOx8Dm2lQDf20uEHkNLFwYK2y5Xg5fP+ed19IRmxM0CzPoOFaz5gFjxukllzgFjQ39tyay8NVR58DXXy+KvePCjmPH1nckl9hI1FKaLOsohI+FP/933Xu5ukyT/Btv1PAV//Ovf9WNqyqv6jJT2bQp9qSyrRq8gtOkSOMO5pyx5hV0p2aimESiabUzfbrzAglqRg76u+65p2iFf9pphRNkIvAgrgYvyoBKHTnp+lkt8oDEdT/Gji0UM1wX6eKLWzjaUuiDvSluSWaTzJpV1fgdtpU0pzrzseSJ2U3Yq9lqfA1wqq4cTM8+u5UY8NW0bBNqDSPVAnriiW2s73niiTr0f/9Xl0466TDj8/J3HXNMkYvB74TFiwHb6l/HdCxZ9PBkyS5EyQknmLdTootDddJntm1zbs/kyTXFZ06ZYj8+N9/cxHV7ddFmiks899w/HBZFt4kykXR/0/jkFuOjwsUkjz22rfGYvfJKDVeRqo6Vpue53hZvhx5sm2hdJS/BoY6j6n698spYy1+LFrFWa7+xN59+6t+i5+VSX768HL38sj/X6H33NciIKvgQPhbkSsNrZ0pXk5cAiR/n93/xRSVxopl48EHv+kCy8qc+wHJxMxX1ec5Yu/ZaZz0JHVW0mISPSZDoAtFL+LCA4EBuNwuK+j3qIKKnEXft6pwYveI99IqpEjVjhAc1Dqi0DXZ+BqX58yuIuh/cwJQnUq6LxCmjl1/ewhrjY0I/vhIWLCwsuPePCX2fmX4LT+ycrSZrvVx22SHCbcQZG7prxy0lXa0Vo36vzUqpZ0ZyPJj+ffIc0q9bzpIs/B77b+vV61BROFC32LZrtyfmtZzBqfPDDxViaq14UULbPbqQfvbZQqswC0uOS3roofqeEwi7YXXU8/vbb+0BtKrgka6arl3bCjFuw++kZ5r0TUkC6jWsW4W9Yh5NmK67U09t42oRsl0/ibqAvax1w4YV7ee2bffFbKNaT85UokG3kNnGnEcftS+6+Tf+6191iq0Irp7pFa+b2zammYDwCRjjo68cTRO6aZUdL+XLRxwR/9dc08xhZlRZubJsjMtBzyrgrsemC5uLmyUSOOeV5ST3U7VqB6wrRd39pm8jr/Y5kNvk2jEFc+srFPXz9AmHrQ88KfL7TVk8tpRY1W1gC7aU54yp7oZEujxUK4ha4E2mezIm876eJWSzfLELy01YeAkf9RjJiV4VA0884RxQTUUcTW4gmaYbJMuM48H0wHw58Otmb1l52U18yoGThZ06+DZqlB+z6uY4PL05LPehUicPrwwdZupUpyvkzjvNAoOFpa3gn59YRPV3c42pyy9vLgpt6kjrh/z9AwY0t8aCmVKoe/RoFfOb3CxRpkWXvnjxmnBtbke/rn2TmLFdP/o4x5Yljm35+GOzBUUvfKtaovxuM1v4ZctJHkvksTGJM1342BaTRx9t9hrIBYWpjIL623VXciJcdZUzpd/m3jTVyItXJEH4WJD+X6+AKVtgaby8/ro92+P//s+9pge7PHr2bCXS4blQFbsc2BxswraiiZd69f6MSa01DSSqENMVun6RcqyJDOTmk57L/ZuCyVVmzrQLHzW7o1Yt54XLgyv7qW+9tYmjpYSkalXz6Kv2wLW1n5CT/y23NPYUbGrMh81yaBI+55/f0lUEe8Wc2PaZbglT43L01Fn+DdJCYRLuOsOHxwbD6sJEnzj0pqO6tUGeQxzkPGPG0pjPV605TZoUxcrpk6tqtZETULNmzti6v//dGRz9+eeVHaJeigZJv36/B7ZW+CnkyNvuZU3Un58/v6IotKkuRlq12huzv4NmPK5fXyZam8lvqQ990aWPA/JY2IrD6osY0+Q5cKDdYq1nHrmNj+p5wsL3H/8oXCDefHNT42f4WSjbkAUPuY+aapWS16gcB9QaVXrsnk3wHXHEHiH45s6tEGOFsmVUqosStZCijXhFiWnxddllLejII9vTc885x/54GwZD+CTo6rL5PeMpwc+DpT6YcmEyvVmel+uNs1bYZeJGsoWPXkxL992bhI+OaXXCLT70ScWNv/1tW/RvFk28Glu0yGyt+eGHRdGVMpvUpRvFZDKV54G+slZXm7ZBTTaAVK02Q4euN66aVfFk+83y2NkanLL/3vQbON3Y5iZluJr4u+8WrdY5QLlTp3YOK5oacMmDsbpaNhVo421ky4Lec4j5/XdTKrPzeqpWzTnAqvvQhBRqLHwaNnRehDxRXXBBy5hrl3uw6VYK1V0rj2u5cs6xwLbKZ446qp2nG0nG0HlhEoiM28pfx22CaNGiUNBdc83m6O82xUQls+bToYfasyr1oPMHHqjnen2ZXFW6G4iFnmlMZUzXhO271P2iFx/UGTEiNmtw2bJyvmOj1G1Qf6M8DvK4P/XUavrLX/YYFypyTG3deq8Y7+SYMXRoY5o9uzJdeWUL4eL1M6epwtXLMqx+d1BMny1bzjzySD2xqJf7Tj9OfjPhIHw8XV3uwuepp8wWFd2dwNky8dQLkT59P+93ZsXkua4gvVYe3btvD+Tf1gdWN+GjppLz++TKhauL6vDr+XnTisqEKlSlef7ii2MtOAwP8tIl4lWkTrqSeOWsBuKqA5LNmmIamC+7bAvNm7coJhhZHQw//rhooFFX4nJ/6aJAoq+KeIJk65FXurFej0pmpLAVzGRRY9Hn1XiR40nYssA9h3i72aLJmWa29+mDpfo6P/2jpGXD5PrhLEXT6p0Hfn3fqMdBbpPuPlOtfX445JD9VLVqMPXAVimbpeTDD6vEpFvbcLMIycmSf5+8Tk2uDm63kwjqMbFV6GUBqsdIyThKm8CTYo17PcmFkkmkcUA4Z3aaLNJ6gLSpwrtu8Vm2rLxrxpJaIblRoz+jfaXknOGVat64ceF7+vff7DjXWJjwWCxj/erX/5MuvXSLUUzJY8vjKO8n1SI0+3/V0nWrnm3ukNl/vN1e8TS8fSYRcthhez3rbnmJKq4+zS0u5N8qpmaqJiB8PC0+BXGVs1eDUd0GDVVMuDXMVIPevGD3nFuKKYsyrwBZU4Cym699+/ZSrgOtdOGw66N378KV70kn7RC1NLhz8e23NxKWKh1eZXMfG7+4CTpZI2PQoA0xQsmU9qm6lKQA1a1KqpndZtq1xSCUVsZ36TO39VM75pjdMT3PbAHZuumfg7pt5wMLKnkOcj0WN/h1ajwHW9L0YFwdtWorby9bNFmQ6jVYSpUqsAof/l4+f0wWIrdJnDniCHssg1vhR1VwFVl8nAfYa2wwMWrUukCvd7MKyMxLP2ODm8WnSCxGjP3tJKoY4nIXPIEHqWqtZqNee+0m42tMbjJ5ztmubd5HLIq51xOPs7xNJpHEAeEm0cNwULs6FtvODWnxMQl3XYCqVnC1Po+Mg5NzB59HckxRqzHLc7lChYIYVxf/ZikQ+Hl5Lurjrur61dlu6RfpZUHUGy2b4IUWx2TqqPtBZs/p+LEmsXWZXXL6eGELSdCB8Ekwxkdl1KhfHasUdSJUm9Wp7p6hQxv58oXaViAmeJsffdQeAMzVSt9/v6pr7SBTMCO7BGyv109WdVIuDBquGvVHSyHAK1mOGeGguRkzzAGRvK90S4pbB2K3i7ZevcJBpWnTootPHl/9O9hFxqmyXJHWzdytukhs7kU/NYNk/IgpI0e3ZMnfqItN3bUm4fPLJnT5txx3XBshYmyrOLm/9RUcf7+fSsmmasD6ceK6PXye6BM0uyBHjmwo+gz5afMgB365vy6/fEtcwsfZn6lo1eynIrCJ225bH5Op4+YWlytjN4uam0iRkzgfe45DtFl8eJ8WTY4FvoXLyScfJibwE080p+vfe28DevVV5/bJ/cf74rrrzMLHBp8btmubq2CrEyAfV9v57mapUEsE2GJY5OLPFM/nNvaY5hH5et4v0sJev36+UbSoixl9XxQKn4hrcLOpxs2nn1YxLk696jL5aXTK8X+mEihq4o/uQZDiTr8ebAs8k3Dz27YCwsdjpaXH+KgHSxcs555bZAlwG7Tee2+pw50gg3VNvVfiCTL08h1z0JytMitbOc45p6gOiYots4OLMeqoAy33A5NFrdjiE0RMmtS/TfiwxeLpp+0B4KYBXh5fm5tKrm7OPHNbVKCoK33VAvLmm05rzZFH7nacB7IzfO/eW6OvkW6/4493do3XqVSpaCC2FW2zwSLcbVDmCfyee+xZfHJ/mwYgUw0hPxYD0znA8Q+muABu6smTmVt/u1iLT8R1VSuvKVsgp3rtcsCuPHfvuSeYxUbSr98Wq7gwWTkuv/x33zVyunRxlmZgZIPj/v2bi3R0mwuAazCpcVFu+F1Ny1IVo0c3NAbGc2IBT+Ty+tCDxk1w8L5NzPA5yEUtJe++WzWuqur3398gWoerYsXC31q+/EHj+P/ss7U8LeKymKZtHJPbyMJF1mtSiynKGD+ezNkCLxeMfC3IMYDPJ3aDyWMXK3yc14ONyZNr0jHHtKPPPqsUdbEFXTBcf/3G6N98Tqk16GrWjJ3bdAse7wfTvrK5ck3uTC/XuwTCx4LcgW6DgVdEuc11pYspTs9mEXXqqTsoGbitBL1U8dtvVwv8PlPWiS2gmFc3ftJP3SbI2FT0EiIA1yvY0DQIyG3hwdKNKlUORgezM87wV/xQHmc5eUn3oQxEVFfRtkrKEnUw+OUXu+XDNBjcdFPTaDyIDT1ewfmZhT2NkhkQbxKvHMQrv8PU0sUtMDu2jk+Br0qxXJnXhDweXCFa7nteNasCVG6zl8BS6wCZVt4ylkrNEJUxHX6sSocfXvj5Z531R8xiRCZE2CzA7I5RFwSnnFI0BulxhX5cEDrq4lBO1jLw+KqrNkfLICxZ4n5s+Zx3C1x99dWaDsEQ77kqLevSnTxhwipjSreptEDz5vuNFdm56rJJwEohx2OiKVBeLnZZ+KvjLwsPaZUpsnAWuFp8vKx5D/3PlT9yZKOYRJWbb97oWLjZxIUULqas2Y4d93jOG3Ks1/eVWnhWxbRI8hpHJRA+CcT4eEWt20yCpsmcs17UYNZE0a1H6qpQdfVI5ArHrX6PLZhTd60wstaObhXjBqxBhI+acizRL0wOvlUDcG3IQUKdfKQ44SKBbqiDts11pa7wnnxyVfQCloHu0vSrimn5t5eIloOgmnrarVuslchmDfISw15wTyM5GSQD00TAbj45WVSqFF8ubFEdn4iv7ti2a1haQdQJjs8b/drlDCS2Arh1AB8woCiN3baQ4v2huy/8IlfONWoUibK33qruW4CqVjI1/m3w4CbGzJogqLWMiq6hgzHn6lVXNXMNHTBtj1v8hxQVpkw6N3hs4uMpt023ckmrjineSBeGUqhzyQW95pVu8XFzycprRQofXtzo9atsokGOeX67xOflRWLGojp18h3WLts4oH6H3o5GBl+ri2dd+Mh5Qd+PNmu8qdUKLD7F0KtLHTRNK1T5Hr1Al0n43HBDM2PfGknTpsGau0kLhUSalfWqr1JY+FnN2dJZ3WrD6AMEZ3MEET5usU3sC+YB85tv/PW6ktuirn78ut3kQKiv+FXkRX3HHevpuON2RQUhV75WV4tqIUO5LV51WORnqedI376xdWGS0fbDhm3lFQ+2wdMWSOwXfYXbp0+wiU8fQNWJxCR8mNdeq+4qnFVXjqnmjJxU1NVqmzbO7BcbbO2U2ZBSUHjF5OnjhPxe3mdqwL3e+JivRc7qC5LWrp7X8phLUate22zZ0mM+gog/HSkiTz45mBWdxyY+B+W1yt3EVde0TEdXK3fLsdVtDFWfkwJBbiP/Thl/KAvPqvB4oi742OKjF0uVi1J9G6SLU14XAwa4N71l95Q+FumCxGZN40ULJ6zo9bUuu+z36LFUe5GpYQJu4s2GacFtEpgmIHwScnUV7b7OnWOzR2T9E7Xdw+mnbwucBssDgqxs65fNm50iqn//2EmSufPOwouKT3Z9QGP1v2BBUcr1e+9Vi7Zv8Grx4Fbg0W8/GeaLL2JNwDwwceAkV7A21Y6xUZTaGQm8ipUrGGmm1+vwyO0q/PzYAVsd1FWrjTy//O5P9Ri1a7eX7r9/raMxqV/h8+qryykothRkFXa3zJwZWzhQR62lolaBlfvJ7wpVF0h6vIqprH+8lcjZOmi6dvVYFp1DD/VetBQGoEsrwwHfkz73BpOWBf09en0WE+rKnC0+XitmtrrYxqJbby2yFknYRVr0XXLxULideiyJOuE9+OAaX8HsNqQ1xW2h8s47PxuD/eV28kKGx4p77/3Ntb+inLBtwke1oqnnthR+/H41/EHuXxlgLRvGqjE+ejypzVrC6fOFv7XQAnjFFe7CxzQWyc+Wx8cmfPgcNi0MuEq07vY3ZSMGET567JWEW/34AcInYAFDdQJTA+hkMOKHHy6NKU6mrm5vuqkoAMzGsGG/0YUXbnGsKIOiW2FswW3qpKP3zuJBQF2h8iqH+6pw2wuveBq3lX2QXkY2eLLhYMQguNV4sVGlygHN4lP4XjUWwo/wUS9mdXCQEzdvG59bXlkJqlWgatUCOvLIIt/5v/9dKyp8bIHyHG/CA368gsCNc875g+6/f51j9epH0Kr7Rv7tZfGRcTN6QGk8x9iE/Fz1c3gSTFW/Ip40ZC0ZzpYLkgAg8SsWVdTyCfxb/VTCtQmqK6+MXVzJSt6836T7SVqmevRwXkOqFePUU3cG7oRuGnfcBKQs3KjCv79okXMwxtJvssTpooP74Q0bVhSw3qnTbuPiRcZdsThR63TJeKciV1gkxtVVu3bhNdanz1ZX4aPjFcDOqItJFl/6Z0vXl84FF/xhzFDmc9nPAs9LQKr46eHmBoSPp6vLfuHIiY6LU8l+Pmo6oglZTdYtJZuD5K6/fpPvFWUiqMJH7bjt1VeFTYrcMFXnn/9c42rx4boqeln8VMP7mt1iRUGqRd/fuXNsRoxKt26Fz6uDoT4hyotdFz4yZZdTVVWRrMYdqAMC32wZE1ykjJGTo3Stqucbi135PTah+/e//yYGfLfzLx7YyvOPf8SX8aSKdBmEbWoCKpk2bRk99ljheaZPjnpWl6lomh/kcZDlBaQ7I5FO5JJXXllOZ5yxzRF3xy1GuI+axK1ivOp6CTqp2VwDPLmxNatNG3tFZTeOOcZ8HbFrlgWNaiWQiwddVKg9+Hh72Dpugo8ni2w3pEs4qLuM94e0+FSuXPReefzPOWdbTCFNXRj069fCUQGdz0V1vDBN7Op3sVWpsE6PHE8OOlxd/H45HkmLls1aIkWKdJf56WD+s2LZffbZlTGCRBZj1OF9ZOpTyYuYouBr75R/9TfYSr3EE2ivAuHjgduJIlfXfvqWSKQF5fvvF9N33y02voZX4/Gs+Ly4+OLYADo1UNctxsgEN0xVay68/vrymLRZ3eJzySVbU/LbvNwWqntNtSbYLmI144YzKHSLjzqxyslWrcuhWl3YkqN+vxTJjBwQuVQA9wqzIS2Nt9/exJHZ5azvkeeo2zF48AZr7Fciq2mT1VKuQCUPPeQUwH6RRd04vsQmSnmwl7/bZvFRkxL08238+DWerRSkq0sWWJNBzn6CJ9V9ccstsceAa/mMG/erI95hyJAmtGFDGc9YIC+Xo5/YIO4ZduqpzsxEeR7qiQN+GTmy0B00d27smHbhhS0d44BtTG3dukh0sShq1crsIhwx4jfhomfLuBdewkePi2L3ub7IYaQVkyfiHj2KCqrysS4SPjZrewE98cTq6H22fHGdMOd2OLdTraUjLT6mdHb5+2wWH7nd0l3mdl6Z4HNVfvaPP5anF1+sGW3tc/bZf9DRR++iFi320fDhv1kXW/y4POay6azNMiSFDxddXbaMXfeJLzRMQPh44LaKSiQQk09A2wCgFqRKJnqnbLY8qBeCnlUmV5ZqiwkdtQkqB0rrKw5p8enQYQ+99dbPdNpp26lXr/gCThNBDYRT962+n/VMEoYFiVwFmiw+crLVLT5FGVtFBeR49aaudNXzS3c1qvB+9Zp0TzhhZ3Qb+BwyxXXJLBW/2Q+2CUqddD77bEnMhMlNEBPFFtjO4lNarFjAqe5nk8VHDaZnK8LJJ5trJvEgLicKm0vLTy0bdnezVefxx1dbY+tMhfVkurAXNjceTyamtGEVnqxuu21DTEudeKxFKnLxx/v9m29ixY9sMaCjuvQPO2xfTCbn1KnLYt7D2Wt8futxLvG4/956a3lMYooei6R3rVdF3D33/BaN+7JZM3h+4BjQ2bN/Mj5vCjhWC6NKQaCms8tFlhRMqihSRYXpevCLdCerAe/jxtV37NuJE1fRO+8sFwtat/NVPb947DGVQJG/k8ewc845lHr3PjTmPFWRzVmfemoVjRlTFOvoBwgfD/xkdbldXC+8ELy/DZ8kyRQ+V19d6HKZO9fpmlK7+uoce+wuuuOODZ71U9TCYXxx9erlHIzkIMEutZYt94v9yLEp7AZi87gtSC2Vok89lvp+VltDSD78kAuiOTNSeLCTg41clcQKn4KoD99WSMw2icnaLBJeKc2bZw7ElpkrLAZUiw//Tl20ym2zZeacf759AFM/Qx3IqlePPYZ+XQw2t82ll/5uTc3XK9nKgZ7/VzOUTBYfnihMcVTc9f3ZZ1c5JhcTxx67mwYO3ET33x8rkCV8bvBK+aSTdrpaUPhzJHzs5LEydXHXe36ZYCvVDTe4V0SWFj+9Do1bTJQfy4o6BqrJAxLbGHL88btisgbVBqbNm8daZOW45Sc71DY2S2sou4r/859fYipB65Y1eb7pFhXO2JPXJYuCm26KTbmX+8O2ve3b73VsK/9vKuqoxvjYXF1++8z54eabN7lut99rvEqVIlcXw9eoXveK65nJx9SgZ7dYUhkzxu68v/1tu+sCXQfCxwXuH9Shg9MkqeIVT6GmMjN33+0vBoJPEpPQYvgi5QN9++2xWUW219sGQ7ftfuaZVb5ObHVlz9ss3yMHJ9PqieEYpuee4+JgqTFl+u0GrZee9zaNF8RMFnwh86Qra+1I07QqqtasKWMcgEwpmczLL68QokAWOOQBVzZgtA2IPPEVCawCo5tHnlecaaS2IJCYstV0+LPdGtYGCbS11URid6CsZqvDv0GNUZLCR7ViqcJMFz4mcz93fefHi4QPWb+bJ4SzztommkfqPPJIkUvDixYtiiZ1/j1Fq3j3xcAtt5gTJFq12udpkbLVR3Kz+PBvlTEiNuKxKNgmVa/Pkr/By2XO46hqrVDp2nWnVajJTCjVZVUkOpzjFZ9PagatqaGsvBZsAkIumOSYzrFfcpsaNy4SQGqMj6y8L8crdawxCR+TsD3xxB2+RLJtu03nzMSJKxz3//rX7cKKyosBec3ydSrH3WrVDtADD6ylRx9dbXThyga1fs6H6tX911mA8HHBdGCdWV3B1LRpZWw6WHXr2iaDP8XqYNaspb4Lc/Hr5UCv+/+5dYUJPhn9IjMA6tWTPuSiSVid8G2DuV8fLq9spk+PNXurgXUjR66jefMW0333xa7G5aTStq1zH+iF3tyEDw+k6gCjFh9Um3XKgU49V265panxnHIrD89ptNKywIMdT85qnINEjXcpOicjxloZ6nuef34lPf/8isATGP8+rl7Ng7LqqlDxW7LBZmnwqhXjtPgUnkNqHJXd4nMwauExITMOOZZBxZTJYiphwVbNeOBJTa5gTecg72uu+M1i2JSR99hjq+nww73je2ztIdzGMD7eXpWVdTGpVid3+36z8HFui97uQF6D+uKQa+74vZb1fWjbXn079VRuN6u5fv7ZBIRcgMjnWRjIRbU6F8jn1QWBFGLqOa4uAIr6zBU9P3v2T8IV+3//5x6HJ4+DbbtNCRJHHOE8B8ePX2tM5JB9BvmYnX76duEFiBdp9QoSyA7h44KXu8mPq8sLU+8feUGrNVr0mAc/rjC9M/W//uVcjdoyZyZPXklBOeWUnVqRLWcpeVuvMb9Bth9//JOx4rTkxhs3iXRKHgC4gjK7ithd4iVSVfMor+p4v7K/WA/+NK2W1eKD6spEng+mDCD9+01p8Sq2bA01oF6uRnlfBjVtH3VU7IB/553urg3+fTxxvPvuz3TXXXZLgHTBqSLthBOcv5f3tynLz+v8VidauVKUgzzvD1V4qQO3HBzfeMNcx0gWImSRqe5zzm7RMbnighTnVOFzSC1op/P006voxRdXRGvKTJni3H5b3JLeS4knGRlz5/x+tzTj2OvUy63AWWt+Cqua9pfuiuzQwTmZqoJHrZFz773OsVTuR1PyiS7whw2LPY9lMT41+03vTG5y6+nI7bWd0w0a5DvGTl4wmUpjyH2lFoWV1zlfD+yh0IWPqbxD7doHjM1ydeRn27bb5MbVj6czrKDIQi7bj/jt/8YCiZNzJk92LtTU46w3XXUDwscFL1OqrW7LBReYV8GmSHa39FG31Hh122xVnXv3/sPVrWBLQdVXMWrKuw05uMhVAJcDePLJ2tbA6qDIgcrUpoFNw2plan4tu4qGDCkaFOWkoguCBg2KxBQfR75Q2V/8yCOxwXK61UoVeabByBQnolt8vESzHHT0gnqmOBWeqKU4jrfysVobhPn3v2MHGrnNNneshFPO581b5Ahm189J3h+vveaMsWDOPntbVHzqK/lCYrPqTPE9JldX4WPkyfffV3C1zKkpyIkKH8ZN+OiPtWu3zxoPZuLTT5fQdddtjgpGfZ+q1kQTrVs7xcfdd7uLY71lgc2abNpfushyq22l9sfi+Dw141CepzxZclC3CheJVOFioG4taGyWU69rQMUrY04uAPhaNy3U5PtVwa0K/KIigSWiAsprIXSTS105Oeba5kGTxcdtf6gd5GU8j1/hw/MLZ/Kpdcsk8WQiQvi44LXq1FMKVeuDiWrVDgYSV24nkbri5SBKE6YGjaqIkcJAj0vQVzGDBm30LXzUyV6tcsoBbn5QRZf8TDXTymSq50BF08mv7qOidhXO33bCCUXiTx8c9JRs3eKjZlKoE4ncFhm0qKJ/h5fwsdWR6tJld0yTS66D8tprNRxxCiqmDskmeDBltyGnYnOWkC6E/axyi7a/cADlQF4WMtIyWPRdEUcas7qvuS7Q6NG/0ptvxlbYlXFUqgvZFkCuXmPqtdqzZ9HENm5crNAdMKB5dKVqct2Z0u1tbup4hI/qmnYz4+sWDTVoWqL28WI4sysI0lIkkenRNmwTre7uNwsf5311UaFnQKklAXi8VveTdANxPNt9961zCChd+JrGWr9FPm+4wTw+8nnD15GKqcSEPl6pgkUdH+T2qxlRauyiPM+lxUe14tlc2D+71G6TCwjbPGga39yQGVrjx9ejhx6qF6iEihocf/zx5vnOtCi2AeHjgrpy1C8MbjswZUpN4wViKw7Hpbu9rEBs0ratQtq3N6/s1LLsag0R08WsutbkoKFPvvp9PwUH5erXFpuhdy628be/baMnnlgl3C1ffLGEFi5c5EhbNYk82/5WhY/N4qO6tPQLXL9vO86qNUZdGZtcc7HWCGegpdq12rQN8hh6rZQ4PZpRRcsLL/h3YbLbUDbX1AsTujXutcEBwSYrmpz4TLE+LH44S5BFszTjq+4HWSdJuqRMNXxsFh+Ggyp18WCK5bGlKcdb80ZFumq4QKWc0OTkrWZ3ucVe6Wn/N93kntmluldMyCr0blYX9Xhx2r6O2UoXew35ET6qiNcXYRxTcttt68WYoW+n3lrDlqlnQ91WN8Fis9rzdcPXkcqvv9onejlec88r2e7I5OpS0+nV46i3hVDb19hi6ZYqbUFOO83pnizKYC2wZjgGQQpR/n3ymlJbBplqXplQx0cVvp79JhBB+MRp8ZkwobZ1NWYaEC+5ZItRiNSpc0BUIu3YcTf98MMi6tpVtUBEHKuJ4cPN8RTqIKNerKaaHs2a/RlzYutWEN0K5afolZw41OJ8KqrbyQS7kXgSGDx4o7DCXHzxVt8Xm+04qft7/XrpAopYrTj65+j7Qe/7o7q6nn22sEfM0qVmk7jks89i/dBPP73aUftEFcMmS4OtZLwJ2UKFYzLcAqndaNLE+b6gvebcXGlyojrvPPdg/SlTfhExW6NGrbPGP8maUXo81Pz5RYOrKgTV81r+rRdiTDXSnc3np6wSLccT9Vx1s/7qwodf+/DDa3zHbOmwxZqtRpzJJc8fPZuJt+2dd5YJq6hpMfLXv+4QMUU6+sLD5HI09Ulz2w/9+m2JWm69Wr4EQR3X9dgkFbX3norJBelm+VYXcAsXVjBYfAr/lwKZCwfaXEnq69yu2Tp1ilaqtgxQ0/iqx4glA7nQ8kLGB5n2rW6ZtAHh44KbG0pNddSFj8kCYTtReMDlQZ0Dik0XtXri664yXumceeY26t59h7EvjMkfqlZa1gvtSfTt4JREr2BGKXxsA7TJzSc/m+EJ7aqrfo+rh5Rb0LNk+vRqxpWPOlDqz+mrUX3b1JovXjESXqiTnN7bR0d3uXEqqC6IpNWDsyW40SwXarPx3HMrXWNF1H2UjLpL6kQsf4vbippp3Xo/DRu2weEqkdfnjBlVRb0s2fKAO0zbzOT6tcr1qni/yRgxW7q3H158MTZWyQs3F4tMTtDjUUyFK03Cw8v6IgvU6fA+Ygvd5ZdviQozPT6QxwxOx+/Zc4d1XOOYogkTVroKH5OFWLeC+8mcSqYVznS9uy2CObDcNOabFoF68VYumqm2LXEbF6TbW6aC21y6UvhMnOgMxDbRQ4ljmjatuu950E8BVFPTWh2TOPZC9R6oVtsgJLh2y27cTnb1wOv9qEwWErcJ3c2iok6++qDBKx2dgQM3C/OnWv9Bhf3d7AvlAU1+r5frguMpeOLUy6yrBGnbocIn7vr1G6hx42BWDC4bz0HN7BoMEmCo70N1oNQFYKzwcf5Guf+GDy9qSBgv/Bs4m2zZsnJ03HHu/cN0y5OczLduLWkcELwsdhwUyqUCbM1FVeFjKskQFF59svjhgV5aONVBXLUIubFmTeFEMXmyv47MJiZMWCUmX2l54ABKrhobD3/5S/CeYKaeQ/J41qp1kD7+eInnYsBWg4fjYbjNgC0mgqvudu7cVvxtqumUDEGhu2TVmBzb79crWAe5vpPZg04VyW5jJC/qvvrqRzrmmHbRx2xVuNWF7M03b3RknqpuH9N4JY+zDAzWxzKZpcuLvE6d9tDMmd5ZTuf9z9LKi61zzmll2eaIiK1Us4Dd6j5xzCjXGbrsMnOSj8qpp9qzWtkDIBu5qoYDtail6voOAoRPnBYfNWtBvzBNg0S83bBN2UK2JpF8QbDoYfFjgyfBp55aHVe5enbJcXYDB3WqHXxtGS5+J8Egoodh0caxP/Ggr5JUUeDl6tLfK4WRWlZd91OPHbvWUYnU5p9mOJuMyNtUq5vLiwqblXAUs0uW1Uw1k/vNwvDC5Mp84YVfRKC2l1s0EfTrkK9d1d1iCp5v1Sq4oPGLqeSBalVj8eOFzVJnK3Romtj1+lbJQs2GYguWXtmdA9v5cXbX3X77BpEwolqrgrZXMRUQjBfV0mQaI//+93XWgH9bwVRV+LC1Rw3SN1nm1DFfjk/S4mNLjODWN1z2QO8ZZru2L9DikBi9OCdbhiZMqKO8zz5nnHrqTnHzg80TwHFF3AZDCh9933C2KLtE4221AleXC26d2RcsKG/1/5pWHUHMtSqqudItm4ZX66bsGD/4PXleeeUX+vzzH0Vp//feW5YUi09x41aa/9tvnVWU9Yv73/+u5Xmc9XgY7k2m1urhzuiJou9rU/B50K7UbqgWnyDxRUHhQFWOY0t2nzp2B/t1i5qsY24LIDn5qeUUErf4+Pv9XMuHrQYcP5goftLwZRB+ECGo9sHiavD6sWXRzkH3H3+8VBTF7NPnj5iFo0zP9oNagoDb4iTP4uPc7ipVDrjGpbGlzYTb4tXU100d8+U22Cw+Khdd1CJwMPfZSso/hx2o6G64RMo22GKMGI5z5cXizJnLHPtfH/N4sZJIfzkIHxfUAU+fXHbsKOWS7UNJm4hU1Z6sk01HjdqXRedMyD5bDAfKykwKk/tFRa8OnE6ClNb32t9+jjMP4mq5/3gFsNt3mLajZs3kCVHVosnB55kCJwSY0NO5VVdPELeJHzcPT35z5iyhSZOCF/20xbh41Q9Ta/mwdddPTSIv/IwtY8b8KtwPTz65OpCY5WyhK67YHHdbiyCwEFTb4pjaseiFDk3xLrE1cpzX3PTpsSUWVKuZbhGXqMdKdxubFrbqQk1ugwzudVsIL15s7uvnRm+lxlZsIod7GECy4OvzzDO3U61azgvDb6cCv0D4uOB3ANL91nzwuAu0GhOSjBV4PIN20N/pp1ihyUzpNviaqgOniyCF/fTjrwYiMqZ+VSbzs/o5iVT5ZmsLpw7r54FueYrX7+3HKsFp15kCx3iZ0N1xbHW75ppN9Mwz/sSJfpy9+lTxdeAn89GE7EguGT48WAZWstAnGhNcC4gtAfoq3YsHH/w1IcHMosmtoa1+rNlVaEom4ZiTb79dHFNEU3LXXfZ9r1sXTLFu6njvVjNr/Pg1opq5bn00ZRSq45UUjrJhstdYJsWC3zGvpCJuvGK64hE+3CYjKK+/vlzsL70VRqJA+AQUPqbJztQj54EHfo1myyQS42MqRpZs1D4ptqaRJvh3c68mt4ap//iHvYt1caDH1Li5uv7v/5wrWV3M/fOfzgyC77+PbTBqEjaqmTyeVS8HC55zzh/CvWhKHdaFkFdxuaCo7q3iWLX7xbaY0LeRB3FO0fZbd0Rd6XOvtHiClv2iZ156NX9NNvz7uL0Eu5gyFbbivPTSL47WJzY4K++zz34yVhxn3NwjLGa4YCYzc+ZPjuf8uF/V11x4oV2k9eixgy66KPZ5Pk/1goeqVUcXMF7tb+bOLRyf/KZ4d+iwV4hLzhb2csPFE+zObTKCuoQ5fIP3V7KB8EmCxcdmiVFLr8e70ndraZFMZHFEWwaI7Xdzr6a+fbdY0xi5s3M68QpQZj77bAlNm7aMTjxxp+t7/QT2miZjdUCMZ6XEgYJcDM02aOvWhnhFtg3+Xo7t4syVVFkd48F2TSXSrkM/RkE6PsdL376/J61GUlD4+hw37lffY1064H3Ck7Jflx5f4/FmoXHwNSdO1KuX2HHXK2X7RW9y67T4OM/rtWvLGC1jen0nvRGzDb62OSjalC3MbtUvvvgxej/eeknz5hUtFm0NjosDZHW5kKgfkzNr2HzJZuR4L0Su0cMR9kcckVp3EWd6cSEutcBhvFx55e+ieCJPTPG6AJLFokXlPS0+vNJLRpq27fPVIPlU+MZ1V1eyhQ+TSPfk4hY+blY9P6jHKBX7UkdtLcAucpB5yKbLbqjZZ6Ymx37Qq/Wr57J+vsvmvJJkJwXoqJm7yRjHEmnvkigQPi64rYI4sJJdHW7ZTHwizpixLKFqoiwchgxJfUApWzOSlapsqxqdDriehFcWjY14ivWZrDLqKr5Ro+THyOjics0a50owW7G5uoL0EjNh6uaeStTWAn572oHixc+CULZM8VuGwIQuKJyuLn+V5Isj3KBkEgpF7tiRvlUxXF2+s7rME5xXOXgWP8msJgqKD7ZySPHjt0S7yXLE5w7XWeIigamY2PRzc8UKe+PBbMIWb5SoxUdNRU4kGN0vQZs9guKHBbB0zZx11h++azIluohxc3XpVcZtxRu9qu7HQzIsPu+8488Flwpg8YnT4iPNmonUEgCph4PDn3mmTtzBox9+uIymTavmqAWjWm/0Pkk2bFWRk8GmTc7LONVu0UxhyZJyKYnxkQ1ei8N9wHBAKU9aXq1KQHoZNmy9aKLMQbomghRatBG7wLYLH90Na+txFm9xWTeS0ROtadPEa5rFC4RP4Kwu2QlaCh+YpjMZ3WceNEOHU5W5Z5EJLvPvV/ikEn2lya0Kctn9kEwLa3E0LeWgXVP1XJBZsMvaLa06GcJHR3V1bdhQ2rWFjtqU1O11mWLxSWdNMLi64rb4lCi2FSFI3uTop16JX7g2jErz5sWTgeeV+ZeKFV4mIpt4psLlIIGbGvhFzgnJRF1Yr1/vXGTpKfO2Ss2JNN7VkVW72fIVD2qduHRW+4fwSdDVBeGT2RxySJE5dfLk5FaQVnuMPfXUKpo6NXiBrmTQsKHTKpHuTLp0X59B+5QBkAxMfd6SKbzVlhIMNyJVsbUsSuYc9dJLK0Q9sXgLCqr1gCB8MhQ3cx5cXeGB63JwDxi9WFwy+OCDpfTkk6uoWzf3juog+ah1XU44YUfSVriyiFyyK2CD7IZrbXExyP/855eUfL5XtqItKzeZtbfKlYuIdkXxwsKHBQ/3fUM6e4YCV1f2kKrCew0a5IsbSO/ChHtWcW8m1cIXLxxvw5WMM6lYI8h8OIGBi0GmClvWlhudO2fWgiwvj+iLL5akezNg8XEDWV0gl83sYRI+HHjK1WWT1VIDogdkGn4yqbhhLlehN1UFB0VA+AR0dcl0aOnqgsUHZALcm4h7al19dep7u2UKaixTgwaZ0zwVgERQu7wHDbTnLFQ15q84CnCGEbi64rD4FBRw5oh0deHEAumHCyfOmrWUco133llGe/eWiLs3EgCZBidh3HlnI9FpPh5Xl7PXHK4LExA+cQgftV4DXF0ApI8WLWDpAdkFu2sffnhtzON+G9iym/bGGzfStm0lqUWL3HOB+wHCJ0HhA4sPAACAVBMkuPmaa3KjiGm8IMbHp8lQDXaUGV15eRHfKhwAAABIRnBzLsXypQIInzgsPkU1fCLI/gAAAFCswfxVqiB2JxEgfAL36lIzuuDmAgAAkHrUUg1du2ZWfZ6wAUdNHBYfmdGFwGYAAADFxZQpy2nTptJ06KEIWk4ECJ8EXF2o4QMAAKC44CKdfAOJAVdXQsIHri4AAAAgTED4JJDVBVcXAAAAEC4gfBIKbobwAQAAAMIEhE8CBQzLloWrCwAAAAgToRI+7777LnXu3JnKly9P1atXp169ejmez8vLi7lNmTIlBcJH9umCxQcAAAAIE6HJ6nrjjTdo4MCBdP/999Mpp5xCBw4coEWLFsW8btKkSXTaaadF71erVi3u70RWFwAAAJBdhEL4sMgZNGgQPfjggzRgwIDo423bto15LQudevXqJeV74eoCAAAAsotQuLrmzZtH69atoxIlSlDHjh2pfv36dPrppxstPjfccAPVqlWLjjnmGJo4cSJFOBo5TkqWJNesLlh8AAAAgHARCovPihUrxP/33nsvPfzww9SsWTMaP348nXTSSbRs2TKqUaOGeH7UqFHCDVahQgX68MMP6frrr6ddu3bRzTffbP3s/fv3i5tkx44d4v9SpQro8MPbW94DVxcAAAAQRtJq8Rk2bJgxIFm9/fTTT1RQUOhSGjFiBPXu3ZuOOuooEcvDz7/22mvRzxs5ciR169ZNWIWGDh1Kd9xxh3CPuTFmzBiqWrVq9Na4cWNXNxcDVxcAAAAQTtJq8RkyZAj179/f9TUtWrSg9evXx8T0lC1bVjy3Zs0a63s5A2z06NHCosOvNzF8+HAaPHiww+LD4sdN+OzfD1cXAAAAEEbSKnxq164tbl6whYeFy9KlS+m4444Tj+Xn59OqVauoadOm1vfNnz9fpL3bRA/Dz5meV6s22y0+ED4AAABAVgufffv20eOPP04ff/wxbdq0KeqGUgORk02VKlXo2muvpXvuuUdYY1jsSBdWnz59xP/Tpk2jjRs30rHHHkvlypWjmTNnitT32267La7v9OPqgsUHAAAAyHLhw+nkHDh8/vnni8wpjrMpDljolCpVii6//HLau3evcGPNnj1bWHSY0qVL0xNPPEG33nqryORq2bKlCITm2j/JED55eRGDqwsxPgAAAEBWC5/p06fTe++9J4KIixMWNg899JC4meCihWrhwkSxuboikTy4ugAAAIBcyepq2LAhVa5cmbIdfzE+sPgAAAAAWS18uH4Op4qvXr2ashk/WV1urwEAAABAFri6OnXqJAKcOZWcCwWyC0pl69atlA34q+MD4QMAAABktfC5+OKLRfsIzpiqW7dusQU3Z5bFB64uAAAAICeEzxdffEFffvkl/eUvf6FcivFBry4AAAAgB2N82rRpI9LJsx17Vhfq+AAAAAA5I3zGjh0rWk188skntGXLFtHiQb1lC3B1AQAAANlHYFeXrJVz6qmnOh7nooEc73Pw4EHK/nR2uLoAAACAnBA+3KoiFyhZ0v4csroAAACAHBE+J554oq/XXX/99TRq1CiqVasWZZvFR7q60LICAAAAyPIYH7+8+OKLoY75sQkf7smanw9XFwAAABBGUiZ8OOYnG11d0s3FwNUFAAAAhIuUCZ+wY7P4yMBmBq4uAAAAIFxA+AQUPjK+p0SJCJUKHCEFAAAAgHQC4ROnq4vje7K0WwcAAACQtfgWPosWLaJcwm7xkYHNcHMBAAAAWSt8OnToQJ07d6ZnnnmGdu7c6fn6yy67jKpUqULZ1qsLNXwAAACAHBA+n376KbVr1060q6hfvz7169eP5syZY339k08+GdoaPkzJku4xPkhlBwAAALJY+Bx//PE0ceJEWr9+PT3++OO0atUqUcywVatWNG7cONqwYQNlE3B1AQAAANlH4ODmihUr0hVXXCEsQMuWLaM+ffrQE088QU2aNKGzzz6bsgVbxhZcXQAAAECOZnW1bNmS7rzzTrrrrruocuXK9O6771K2YHd1oWozAAAAEFbirkTz2WefCdfXG2+8QSVKlKALLriABgwYQNlfwFBafODqAgAAALJa+Pz222/0/PPPi9vy5cupa9eu9NhjjwnRwy6wbEK3+OhZXbD4AAAAAFksfE4//XT66KOPRKZW37596corr6TWrVtTtmKL8dm3D64uAAAAIOuFT+nSpen111+nv/3tb1TSVtY4i4CrCwAAAMhh4TN16lTKJbyEDyw+AAAAQPhAr66AWV2yOzuEDwAAABA+IHwCCp8DB+DqAgAAAMIKhI/vXl3O+7D4AAAAAOEDwidgVpcElZsBAACA8AHhEzC4WQKLDwAAABA+IHwCxvhI0KQUAAAACB8QPnEKH7i6AAAAgPAB4RN3jA8sPgAAAEDYgPCxULo0GXt1FT0Piw8AAAAQNiB8LMDVBQAAAGQfED5xCx+4ugAAAICwAeFjAensAAAAQPYB4WMBri4AAAAg+4Dw8RncrIM6PgAAAED4gPCxAFcXAAAAkH1A+FiAqwsAAADIPiB8LKBlBQAAAJB9QPhYKFnS/Xm4ugAAAIDwAeFjoV27tq7Pw9UFAAAAhA8InziBxQcAAAAIHxA+PlF7deXlRTyzvgAAAACQeUD4xAE3KNWblgIAAAAg84HwiQN0ZgcAAADCCYRPHCC+BwAAAAgnED5xAIsPAAAAEE4gfOIAwgcAAAAIJxA+PlGDmSF8AAAAgHAC4RMHED4AAABAOIHwiQMIHwAAACCcQPjEARqUAgAAAOEEwicOYPEBAAAAwgmETxxA+AAAAADhBMInjqwuFDAEAAAAwgmETxzA4gMAAACEEwifOEBndgAAACCcQPjEAVxdAAAAQDiB8IkDuLoAAACAcALhEwcQPgAAAEA4gfDxSV5ekdiBqwsAAAAIJxA+cQCLDwAAABBOQiF8PvnkE8rLyzPe5s6dG33dDz/8QMcffzyVK1eOGjduTA888EBKtgfCBwAAAAgnpSgEdO3aldavX+94bOTIkTRr1izq1KmTuL9jxw7q0aMHde/enZ566ilauHAhXXnllVStWjW6+uqrk7o96NUFAAAAhJNQCJ8yZcpQvXr1ovfz8/PpnXfeoZtuuklYfZiXXnqJ/vzzT5o4caJ4fbt27Wj+/Pn08MMPJ134wOIDAAAAhJNQuLp0pk6dSlu2bKErrrgi+tiXX35JJ5xwghA9kp49e9LSpUvpjz/+sH7W/v37hbVIvXmBAoYAAABAOAml8HnuueeEqGnUqFH0sQ0bNlDdunUdr5P3+TkbY8aMoapVq0ZvHBtk4oQTdlGNGgeoXr0/qXPn3Un7LQAAAADIEVfXsGHDaNy4ca6vWbJkCbVp0yZ6/9dff6UPPviAXn311aRsw/Dhw2nw4MHR+2zxMYmfq69uRl27LrJ+Tq1atRzuuGyHj8vBgwcdj6nCcevWrfTbb7+Jv6tUqUJNmjRJ+jbw9/N2SCpXrkxNmzZ1vGbRoqJj1r59+5jP4PNp27Zt4u+KFStS8+bNHc9zbBlbFyXsWmU3qgq7XkuUKEElS5akVPH77787BDxvJ2+v5OeffxbWS1X0165d2/EZ/DtkrFzp0qWpdevWlGmsWbNGXIOHHHIIlS9f3td7Dhw4QD/99JP4u2HDhlS9enXKdJYvX0779u0Tf/Pv5N9bHKxYsYL27Nkj/ubjz+dBrlBQUEA//vhjdKzavn27uEb0BTPD5xOfVzym7Ny5k2rUqEENGjSgtWvXivexZ4FDK0xjTjK2T8Lf06pVq+j9X375hfbu3Sv+Nl0jq1evFtsrf58kE6+L5co1wHMnz6HM4sWLKRKJUNmyZcWYpm87j9c8bktKlSoV1Qh+PDbiPZRGhgwZQv3793d9TYsWLRz3J02aRDVr1qSzzz7b8TjvuI0bNzoek/fdBAnvXL4liow1ymV48ldPRtPfyf4+3u98kdi+hwcsFmEc5O513EzH0I+YKY7JQ982dV/LAVIVPqbf4vVbMwEWzixog5wz/FqeAOREFAbU36cfy3Rco7mAes6zyNAfM+0nubiTr9MfT+axM32Wvn18nUvh4+f1Xo+nE3VsVX+LHNNt+1j/LfH8trSe+ay29VWpG7wzWPj07ds3ZrLp0qULjRgxQqy+5XMzZ84Uq5riULqZeGIV9+9VT1A11ipVlhDeBj7WPOHZBnJezXF5A7Y6mVC32TSQ6NtenJOU2/fq9/Xf7nV8UmmdSgTe7ngmZF4g8fiQruMTFuFTqVIl2rVrl/j+XByz9EnVSyjok28qhQ/Dx4UtTRL989V5z3QNy+1OhjhINbbfwr+ZhancD16/JZ6xLByjxP+YPXs2rVy5kq666qqY5y655BIx2Q4YMECYyl555RV69NFHHW6sVJKJJ1Yq8RIJ6kmdDIuaDS/LEm8TW31sk6mX8MmUVbHXqsdLGOnvCYtA8Av/tjD9JvVaKU4RytcCLzaT5Z4JGzZLjpfw0S0++uuShT7euH2fm/BJ9XYm+7farD/xjH2+vptCFtTMNX3UmB8J+zQ//PBDuuGGG+ioo44S/sK777476ansNjLxxEolfiwKPMCyWTaV7odEXWpewidTBpCgg4GX2y5MIiEbsQ36qYaPuymmJVfg389iJqirS95PtQXYS/jwWLp58+aom19HPsbbqVqPMnF+KqX8VnWhHFTohM7VFZSXX37Z9fkOHTrQnDlzUvb9ajyJ6blcwkv4MMUxwKoXTDyxNrpv2e150/3iwms7/GwnhE/m4OWyAKnBZsmxvU6O9zZLSnELnwoVKghrHbvv3babOfTQQ0UwO8f+ZeL8VP5/gdn8G9XQiKBjWzzXT6iETyaTiSdWKok3EDjZ2Nxr8bzfzXRsu19cJGMVFIYYn1wBwic9yGvAy+Jju76K29Vl+nw3C7oq2NTzKhPnp4oVK4psXz3ezGvMTYb4hPAJACw+5DtrqLiQKwU++RN1dfkRPumapHTLVDyDASw+mSl81NUuSC1+J03b61Jt8dHjIYN+vm6p0i1WmUYVQ9JJUAtP1ru60o3bDs7UEytV+MmAKg44tosz+dhsGs8xCIvw8QpMDip8cu18zUThwxlWHIPB7gtQPPgNjLVZHVItfHg8W7duXdKFT5gokQS3vhcQPgGA8KFA8TDFtR1BSiIEDTLNFOGTjFgk9X2pzLQD3vCxaNasWbo3I+fw66qyCZ9UBzfz53H5FdlmKdstPia8LDrJyOqCvTsAED5FBCmelcmwm0H6mE0Bg8kIpEsGXhe331UQ17vhgp68sgQg1/B7nfiN8UnFYk+1AAYdb7JB+JQImMGK4OYU43aSh+nEyqYYn2QcUy79zgOEKTg6GauLZOBVddnvgMyDKlwrIFfxa/HxG+OTioVQIkkI2SZ8Srik7cvflvUFDNMNLD4UKM4kLLDgsQWYZqLw8WNtC+uxACATLT7FFeOTaI2nbBQ+JtQ+hXB1pRhMJtkpfNzIlHR2FVPAolfWFwDA//Xs19WVCotPIhl/2SZ8Slr2LycGeL3GDbi6AuC2g7Nx0ncjV4VPOn8jr3J2797tmQKajccBgHSms9t6YKXiWmPhI2Pw4hU++gIpTMKnpI+yG+pr4iljAuETAMT4ZF9wsxfSeiIHkXSKivr169POnTupZs2agbO+AADxZ3X5FUjJgL+7cePGCX0Gj1dhFT4lfCzibO0u/ALhEwCspCknq81mivDhrDNbqXoIHwBSn9Xl9bp0o7u69MezydVVvXp1IXrg6koxCG7OTRHoFVicCYRhGwEIo8VHj5njyZaLpmbi4k8VPmG1+JTy0Xiaf0/Dhg3j/g6MkAGAqyvz6tsUB+hxBUB24DcWzu11DRo0EOMA18MKi/AJE6VdOrUnCwifAED42PdFPH7WsODVyDRTkAGRNWrUSPemAJCRqOO027Xs9jpuEnrYYYcJV0umkQ0WnxJKt3Y1bT2ZwNUVAAifzE7zznWLDwc/s/hx694MQC7j1+ITVtexSfiEafsl3M5l3759jrT1ZALhEwC/K4RcoDgKeWUimfw72R9uSnUHAPhPldafy+Rr3k86exjnpjJlygRO5Q9CeI5oBoDg5sysb5NqwmoyBgDEJ3zC4t72Y/HBmBVL9s5WKQCurty0+NSqVUv8D2sKAOHGb7G7RNpGZAIQPu7A1RUAWHxy0+LDgqd58+bWGjoAgHDgd5z2axnKNGDx8Ud4jmgGgBif3Exn52PL2QXZ/BsByBWk5dYtK4vHN3m9h2nBowqfgoICx2OgCFh8AoATyL4vIAoAAGGAC99xyQevVGluG7Fr1y6qVq0ahQVYfPwB4ROAMJk8Uw2EDwAgjPBY5SdNml+TqnTqVAHh4w/M5AHw29AuF0ll6iEAAIDcSWdPNRA+SSBXTyzVApbNlZsBACAMwOLjDwifAMDikx2ZDwAAkO0guNkOZqsAQPhkR5EvAADIRuDq8geETxLAiYV9AAAAmTQOHzx4MOYxUAiETwBg8XGCVg4AAJA5wOLjDwifJJCrJ5ZM9czV3w8AAJmEOhYjxscO6vgEABYfJ3Xq1BH/h6nAFwAAZDM8H6FyszsQPgGwnUC5mtHEAc3169dP92YAAAD4HxA+3uTmjJ1kcGIBAADIJKTwydWFuRvYIwGAqwsAAEAmI+cjWHzsQPgkAZxYAAAAMgEIH28gfJIATiwAAACZAISPNxA+SQAnFgAAgEwAwscbCJ8kgBMLAABAJgDh4w2ETxLAiQUAACATgPDxBsInCeDEAgAAkEnzEVpW2IHwSQI4sQAAAGQimJ9igfBJAjixAAAAZOJ8hPkpFgifJIATCwAAQCYA4eMNhE8SwIkFAAAgE4Dw8QbCJwngxAIAAJAJQPh4A+ETENNJhBMLAABAJgDh4w2ET0AgfAAAAGQq+nyE7uyxYI8kAQgfAAAAmQjmp1ggfJIATiwAAACZACw+3mCPBASuLgAAAJkKYny8gfAJCIQPAACATAUWH2+wR5IAhA8AAIBMABYfbyB8AgKLDwAAgEwFwscbCJ+AQPgAAADIVNT5iP/G/BQLhE8SwIkFAAAg08DcZAbCJyCw+AAAAMhU1PkIgc1msFcCAuEDAAAgLK4uEAuET0AgfAAAAGQqsPh4g70SEAgfAAAAmQosPt5A+ATEpKBxcgEAAMgEYPHxBnslILD4AAAAyFTU+ahkyZJp3ZZMBcInIBA+AAAAMhVV7MDiYwZ7JSBwdQEAAAjDHAXhYwZ7JSCw+AAAAMhUIHy8wV4JCIQPAACAMLi6EONjBsInIBA+AAAAMhXVygPhE2Lh88knn0Sbrem3uXPnitesWrXK+PxXX32V1G1B51sAAACZSqlSpaJ/Q/iYKdpDGUzXrl1p/fr1jsdGjhxJs2bNok6dOjke/+ijj6hdu3bR+zVr1kzqtkD4AAAAyFR4TmrQoAHt27ePqlSpku7NyUhCIXzKlClD9erVi97Pz8+nd955h2666aYY4cFCR31tstGDxSB8AAAAZBI1atRI9yZkNKFwdelMnTqVtmzZQldccUXMc2effTbVqVOHjjvuOPE6L/bv3087duxw3IIA4QMAAACEh1AKn+eee4569uxJjRo1ij5WqVIlGj9+PL322mv07rvvCuHTq1cvT/EzZswYqlq1avTWuHFj19fD1QUAAACEl7xIJBJJ15cPGzaMxo0b5/qaJUuWUJs2baL3f/31V2ratCm9+uqr1Lt3b9f39u3bl1auXElz5sxxtfjwTcIWHxY/27dvN/pH2dKkxhuxG65Vq1au2wEAAACA1MLzNxswbPN3RsT4DBkyhPr37+/6mhYtWjjuT5o0ScTxsEvLi86dO9PMmTNdX1O2bFlxixdYfAAAAIDwkFbhU7t2bXHzCxunWPiwJad06dKer58/fz7Vr1+fkokUOvw/bw+EDwAAABAeQpHVJZk9e7ZwXV111VUxz02ePFm4nTp27Cjuv/nmmzRx4kR69tlnU7It0kMI4QMAAACEh1JhC2rmmj5qzI/K6NGjafXq1aKAE7/mlVdeofPPPz+p24DgZgAAACC8pDW4OYzBUdu2bRMB1pKKFStS8+bNi3krAQAAABBPcHMo09nTCSw+AAAAQHiB8EkQCB8AAAAgPED4JCh09BYWAAAAAMhcMGsnCCw+AAAAQHiA8AkIYnwAAACA8ALhExC4ugAAAIDwglk7ILD4AAAAAOEFwicguoUHwgcAAAAID6Gq3JwJwNUFAADh4+DBg5Sfn5/uzQAJULJkSdGZIVGDA4RPQODqAgCAcLFr1y5RcR+NCsJPhQoVRPNx7s0ZLxA+AYHFBwAAwmXpYdHDE2bt2rWxWA0pLFr//PNP2rx5s2hWfuihh8Y9/0L4BAQxPgAAEB7YvcWTJoue8uXLp3tzQALw8StdurRoRs4iqFy5cnF9DswVAYGrCwAAwgfG6uygRBK8LBA+AYGrCwAAAAgvmLUDAosPAAAAkBr69+9PvXr1olQC4RMQCB8AAAAgvED4xIHq3oKrCwAAQLZkwBUUFFC2g1k7DlQrDxdUAgAAAJLNjBkz6LjjjqNq1apRzZo16W9/+xv98ssv4rmuXbvS0KFDHa/nVG/Oevrss8/E/f3799Ntt91GDRs2pIoVK1Lnzp3pk08+ib7++eefF589depUatu2LZUtW5bWrFlDc+fOpb/+9a9Uq1Ytqlq1Kp144ok0b948x3f99NNPYts4s4rf+9FHH4m58e23346+Zu3atXTBBReI76hRowadc845tGrVKofQGjx4cPT33XHHHcVSawnCJ0HhA4sPAACEB55Xd+9Ozy3onL57924hDL799luaNWuWmG/OPfdcYZW59NJLacqUKQ6h8Morr1CDBg3o+OOPF/dvvPFG+vLLL8XrfvjhB+rTpw+ddtpp9PPPP0ffs2fPHho3bhw9++yztHjxYqpTpw7t3LmT+vXrR59//jl99dVXombOGWecIR6XgoXjcLg20tdff00TJkygESNGxJQR6NmzJ1WuXJnmzJlD//3vf6lSpUri+zkVnRk/frwQXxMnThTftXXrVnrrrbco5USAg+3bt/NZJP638dNPP0UWLlwobgcOHCjW7QMAAOCfvXv3Rn788UfxP7NrFyuF9Nz4uxNh8+bNYn7iuWfTpk2RUqVKRT777LPo8126dIkMHTpU/L169epIyZIlI+vWrXN8xqmnnhoZPny4+HvSpEni8+bPn+/6vQcPHoxUrlw5Mm3aNHH//fffF9+9fv366GtmzpwpPuutt94S91944YVI69atIwUFBdHX7N+/P1K+fPnIBx98IO7Xr18/8sADD0Sfz8/PjzRq1Chyzjnn+D6eQedvBuaKBIHFBwAAQCpgy8zFF19MLVq0oCpVqlCzZs3E4+yO4oKMPXr0oJdeekk8xtWM2brDliBm4cKFwjLTqlUrYWmRt08//TTqLmO49UOHDh0c37tx40YaOHCgsPSwq4u/m9t+8PcyS5cupcaNG1O9evWi7znmmGMcn7FgwQJavny5sPjI72Z31759+8T3b9++ndavXy/cbxLuw9WpUydKNajcnKCrC1ldAAAQHipU4N5d6fvuIJx11lnUtGlTeuaZZ4QLi11c7du3j7qKWOTcfPPN9Pjjj9PLL79Mhx9+uLgxLFQ4BvW7776LiUWtVKmSoxqyPo+xm2vLli306KOPiu/n2J8uXbpEv9cP/P1HHXVUVJipsGhLJxA+cYBGdwAAEE54jq9YkTIeFh5sWWHRI2N2OA5GhYOFr776ahEEzcKnb9++0ec6duwoLD6bNm2Kvt8v//3vf+lf//qXiOuRQcq///579PnWrVuLx9gyVLduXfEYB0SrHHnkkSLmiGOG2GJkgpuNcozQCSecIO4fOHBACDV+byqBnyYOOGoeAAAASBXVq1cXmU4cOMwuo9mzZ4tAZxXO1OIg45EjR9KSJUuEW0zCLi62CLEYevPNN4Ur7JtvvqExY8bQu+++6/rd7OJ64YUXxGeyMOHPUfucccbXIYccIixDHDTNQumuu+4Sz0nrEb+Hs8JYnHFwM38/Z5SxhYqbxjKDBg2isWPHikwwzhK7/vrradu2bZRqIHzigFUq+0UbNWqU7k0BAACQpfGjnI3FFhB2b91666304IMPxryOBQbH07BVp0mTJo7nJk2aJITPkCFDhJWGRdLcuXNjXqfz3HPP0R9//CEsL5dffrkQK2y5kbDrjMUKu7OOPvpouuqqq6JZXbJxKGd8cVo9f9d5551Hhx12GA0YMEDE+EgLEG8Xfz4LKHalcTwQZ62lmjyOcE75t4SIHTt2iGAuDryymecAAACEA55o2drQvHnzuLt5A2/Y6sN1fdg6xdagdBxPv/M3YnwAAAAAEAiut8NB0uwWY7HDbqtu3bqlVPQkCwgfAAAAAASCixly5WhOcedYnu7du4uChGEAwgcAAAAAgeDYITWLLEwguBkAAAAAOQOEDwAAAAByBggfAAAAWQ8SmLODSBKOI4QPAACArEW2awjSbgFkLtxNPtFCwghuBgAAkLVw40suprd582YxWaKxdHgtPSx6uAVHtWrVYvqPBQHCBwAAQNbCLRS42j4XvVu9enW6NwckCIsetSt8PED4AAAAyGq4xRAX2oO7K9ywxS4RS48EwgcAAEDWwy4utKwADJydAAAAAMgZIHwAAAAAkDNA+AAAAAAgZ0CMj6U4Ere3BwAAAEA4kPO2V5FDCB9Dx1mmcePG6d4UAAAAAMQxj1etWtX6fF4EdbwdFBQU0G+//UaVK1cW9R9AetU7C9C1a9dSlSpV0r05OQ2OReaAY5FZ4HhkDixnWPQ0aNDAtVAlLD4avLMaNWqU7s0ACjyYYEDJDHAsMgcci8wCxyMzcLP0SBDcDAAAAICcAcIHAAAAADkDhA/IWMqWLUv33HOP+B+kFxyLzAHHIrPA8QgfCG4GAAAAQM4Aiw8AAAAAcgYIHwAAAADkDBA+AAAAAMgZIHwAAAAAkDNA+IBiZcyYMXT00UeLyth16tShXr160dKlSx2v2bdvH91www1Us2ZNqlSpEvXu3Zs2btzoeM2aNWvozDPPpAoVKojPuf322+nAgQPF/Guyi7Fjx4pq5bfcckv0MRyL4mPdunV02WWXiX1dvnx5Ovzww+nbb7+NPs95KHfffTfVr19fPN+9e3f6+eefHZ+xdetWuvTSS0UhvWrVqtGAAQNo165dafg14ebgwYM0cuRIat68udjXhxxyCI0ePdrRAwrHI8RwVhcAxUXPnj0jkyZNiixatCgyf/78yBlnnBFp0qRJZNeuXdHXXHvttZHGjRtHZs2aFfn2228jxx57bKRr167R5w8cOBBp3759pHv37pHvv/8+8t5770Vq1aoVGT58eJp+Vfj55ptvIs2aNYt06NAhMmjQoOjjOBbFw9atWyNNmzaN9O/fP/L1119HVqxYEfnggw8iy5cvj75m7NixkapVq0befvvtyIIFCyJnn312pHnz5pG9e/dGX3PaaadF/vKXv0S++uqryJw5cyItW7aMXHzxxWn6VeHlvvvui9SsWTMyffr0yMqVKyOvvfZapFKlSpFHH300+hocj/AC4QPSyqZNm3gJFfn000/F/W3btkVKly4tBhrJkiVLxGu+/PJLcZ8n1xIlSkQ2bNgQfc2TTz4ZqVKlSmT//v1p+BXhZufOnZFDDz00MnPmzMiJJ54YFT44FsXH0KFDI8cdd5z1+YKCgki9evUiDz74YPQxPj5ly5aN/Oc//xH3f/zxR3Fs5s6dG33N+++/H8nLy4usW7cuxb8guzjzzDMjV155peOx8847L3LppZeKv3E8wg1cXSCtbN++Xfxfo0YN8f93331H+fn5wmwsadOmDTVp0oS+/PJLcZ//ZzdA3bp1o6/p2bOnaBa4ePHiYv8NYYddWeyqUvc5g2NRfEydOpU6depEffr0Ee7Cjh070jPPPBN9fuXKlbRhwwbHseCeRJ07d3YcC3an8OdI+PXcf/Drr78u5l8Ubrp27UqzZs2iZcuWifsLFiygzz//nE4//XRxH8cj3KBJKUgbBQUFIp6kW7du1L59e/EYDyZlypQRA4YKT6z8nHyNOtHK5+VzwD9TpkyhefPm0dy5c2Oew7EoPlasWEFPPvkkDR48mO68805xPG6++Wax//v16xfdl6Z9rR4LFk0qpUqVEosKHItgDBs2TIh3FvolS5YUMT/33XefiNdhcDzCDYQPSKulYdGiRWIlBYqftWvX0qBBg2jmzJlUrly5dG8O5foigC0D999/v7jPFh++Np566ikhfEDx8uqrr9JLL71EL7/8MrVr147mz58vFmkNGjTA8cgC4OoCaeHGG2+k6dOn08cff0yNGjWKPl6vXj36888/adu2bY7XcyYRPydfo2cWyfvyNcAbdmVt2rSJjjzySLES5dunn35Kjz32mPibV684FsUDZwa1bdvW8dhhhx0mMubUfWna1+qx4OOpwtl1nFmEYxEMzkxkq89FF10kXLmXX3453XrrrSIrlcHxCDcQPqBY4YB6Fj1vvfUWzZ49W6SLqhx11FFUunRp4V+XcLo7TwBdunQR9/n/hQsXOgYVtlpwyqg+eQA7p556qtiPvJqVN7Y6sDlf/o1jUTywu1cv68DxJU2bNhV/83XCk6V6LNgVw7Ei6rFgkcqCVsLXGFuTOPYE+GfPnj0iFkeFXV68Lxkcj5CT7uhqkFtcd911IgX0k08+iaxfvz5627NnjyOFmlPcZ8+eLVKou3TpIm56CnWPHj1ESvyMGTMitWvXRgp1ElCzuhgci+IrJ1CqVCmRRv3zzz9HXnrppUiFChUiL774oiN9ulq1apF33nkn8sMPP0TOOeccY/p0x44dRUr8559/LrL1kD4dnH79+kUaNmwYTWd/8803RZmGO+64I/oaHI/wAuEDihXW2qYb1/aR8MBx/fXXR6pXry4G/3PPPVeII5VVq1ZFTj/99Ej58uXFgDRkyJBIfn5+Gn5RdgsfHIviY9q0aUJEckp0mzZtIhMmTHA8zynUI0eOjNStW1e85tRTT40sXbrU8ZotW7aIiZVrznBJgSuuuEKUKwDB2LFjh7gOWPSXK1cu0qJFi8iIESMcJRpwPMJLHv+TbqsTAAAAAEBxgBgfAAAAAOQMED4AAAAAyBkgfAAAAACQM0D4AAAAACBngPABAAAAQM4A4QMAAACAnAHCBwAAAAA5A4QPAAAAAHIGCB8AQFr55JNPKC8vL6YZanHB/Za4IejBgwdT9h3HHnssvfHGGyn7fACAf1C5GQBQbJx00kl0xBFH0COPPBJ9jDvAc8dq7gbPAqi44ca4gwcPFs1ZU8X06dNFd29uRKo3vwQAFC+4AgEAaaVMmTKi03U6RM/nn39Ov/zyC/Xu3Tul33P66afTzp076f3330/p9wAAvIHwAQAUC/3796dPP/2UHn30USFy+LZq1aoYV9fzzz9P1apVE1aS1q1bU4UKFej888+nPXv20OTJk6lZs2ZUvXp1uvnmmx3uqf3799Ntt91GDRs2pIoVK1Lnzp3FZ7sxZcoU+utf/0rlypWLPnbvvfcKq9TEiROpSZMmVKlSJbr++uvFdz3wwANCpNWpU4fuu+++6HvYcM7v49eXLVuWGjRoILZPUrJkSTrjjDPE9wEA0kupNH8/ACBHYMGzbNkyat++PY0aNUo8Vrt2bSF+dFjkPPbYY0IosKXkvPPOo3PPPVcIovfee49WrFghrDTdunWjCy+8ULznxhtvpB9//FG8h4XHW2+9RaeddhotXLiQDj30UOM2zZkzhy655JKYx9kKxNaZGTNmiL9ZePF3tmrVSoi3L774gq688krq3r27EFgcv/PPf/5TfHe7du1ow4YNtGDBAsdnHnPMMTR27Ngk7U0AQLxA+AAAioWqVasKtxZbcNhq4kZ+fj49+eSTdMghh4j7LDxeeOEF2rhxo7DAtG3blk4++WT6+OOPhfBZs2YNTZo0SfzPoodh6w8LF378/vvvN37P6tWro69XKSgoEBafypUrR7+L43NYdHGMDluixo0bJ76fhQ9/L/8mFkKlS5cWlh8WOir8PWvXrhWfjTgfANIHrj4AQMbB4kiKHoYDn9nFxaJHfWzTpk3ib7bqsCuKLTL8Gnlj6wxbbGzs3bvX4eaS8Hex6FG/iwWQKljU7+/Tp4/4rBYtWtDAgQOFtenAgQOOzyxfvrwQPeySAwCkD1h8AAAZB1tNVDgGyPQYCwlm165dIo7mu+++E/+rqGJJp1atWvTHH38k/P2NGzcWFqGPPvqIZs6cKWKCHnzwQSG85Ps4c41jj1gAAQDSB4QPAKDYYFdXKurldOzYUXwuW2COP/74QO/juKBkwILmrLPOErcbbriB2rRpIyxRRx55pHh+0aJF4vsAAOkFwgcAUGywC+nrr78WAc1sialRo0ZSPpddXFyHp2/fvjR+/HghMDZv3iyKE3bo0IHOPPNM4/t69uwpMsUShTPRWHhxvA+76V588UUhhJo2beoIpO7Ro0fC3wUASAzE+AAAig0OOGZXFMfLcEYXBwUnCw5iZuEzZMgQEXzcq1cvmjt3rgg0tsFiafHixcJNlQicbfbMM8+ILDMWWuzymjZtGtWsWVM8v27dOpEJdsUVVyT0PQCAxEHlZgBATnP77bfTjh076Omnn07ZdwwdOlTEEk2YMCFl3wEA8AcsPgCAnGbEiBHCJSUDlVMBFzwcPXp0yj4fAOAfWHwAAAAAkDPA4gMAAACAnAHCBwAAAAA5A4QPAAAAAHIGCB8AAAAA5AwQPgAAAADIGSB8AAAAAJAzQPgAAAAAIGeA8AEAAABAzgDhAwAAAADKFf4fuQCpROORasoAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -655,7 +665,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -699,6 +709,14 @@ "metadata": {}, "outputs": [], "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ad8c1388-66e0-4fc5-a275-3438b58364a6", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -722,4 +740,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/notebooks/NW_Ring_PointNeuron.ipynb b/notebooks/NW_Ring_PointNeuron.ipynb index 0df752ba..b276d4c0 100644 --- a/notebooks/NW_Ring_PointNeuron.ipynb +++ b/notebooks/NW_Ring_PointNeuron.ipynb @@ -25,11 +25,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "b2c3d4e5", "metadata": {}, "outputs": [], - "source": "from neuroworkflow import WorkflowBuilder\nfrom neuroworkflow.nodes.network.NW_Population import NW_Population\nfrom neuroworkflow.nodes.network.NW_Connectivity import NW_Connectivity\nfrom neuroworkflow.nodes.simulation.NW_SimConfig import NW_SimConfig\nfrom neuroworkflow.nodes.analysis.NW_Analysis import NW_Analysis" + "source": [ + "from neuroworkflow import WorkflowBuilder\n", + "from neuroworkflow.nodes.network.NW_Population import NW_Population\n", + "from neuroworkflow.nodes.network.NW_Connectivity import NW_Connectivity\n", + "from neuroworkflow.nodes.simulation.NW_SimConfig import NW_SimConfig\n", + "from neuroworkflow.nodes.analysis.NW_Analysis import NW_Analysis" + ] }, { "cell_type": "markdown", @@ -41,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "d4e5f6a7", "metadata": {}, "outputs": [ @@ -79,17 +85,17 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "f6a7b8c9", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 4, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -198,7 +204,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "b8c9d0e1", "metadata": {}, "outputs": [ @@ -211,6 +217,7 @@ "Executing node: PopA\n", "Executing node: Connectivity\n", "Executing node: SimConfig\n", + "[NW_SimConfig] network unchanged, reusing ./results/ring/network\n", "\n", " -- N E S T --\n", " Copyright (C) 2004 The NEST Initiative\n", @@ -226,7 +233,7 @@ "\n", " Type 'nest.help()' to find out more about NEST.\n", "\n", - "2026-06-17 14:20:41,723 [INFO] Created log file\n" + "2026-09-07 00:20:35,628 [INFO] Created log file\n" ] }, { @@ -240,7 +247,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:41,739 [INFO] Batch processing nodes for popC/0.\n" + "2026-09-07 00:20:35,636 [INFO] Batch processing nodes for popC/0.\n" ] }, { @@ -254,7 +261,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:41,748 [INFO] Batch processing nodes for popB/0.\n" + "2026-09-07 00:20:35,640 [INFO] Batch processing nodes for popB/0.\n" ] }, { @@ -268,7 +275,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:41,757 [INFO] Batch processing nodes for popA/0.\n" + "2026-09-07 00:20:35,643 [INFO] Batch processing nodes for popA/0.\n" ] }, { @@ -282,7 +289,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:41,782 [INFO] Setting up output directory\n" + "2026-09-07 00:20:35,653 [INFO] Setting up output directory\n" ] }, { @@ -296,7 +303,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:41,783 [INFO] Building cells.\n" + "2026-09-07 00:20:35,654 [INFO] Building cells.\n" ] }, { @@ -310,7 +317,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:41,786 [INFO] Building recurrent connections\n" + "2026-09-07 00:20:35,657 [INFO] Building recurrent connections\n" ] }, { @@ -324,7 +331,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:41,790 [INFO] Network created.\n" + "2026-09-07 00:20:35,660 [INFO] Network created.\n" ] }, { @@ -338,7 +345,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:41,793 [INFO] Starting Simulation\n" + "2026-09-07 00:20:35,663 [INFO] Starting Simulation\n" ] }, { @@ -352,7 +359,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:41,833 [INFO] Simulation finished, finalizing results.\n" + "2026-09-07 00:20:35,703 [INFO] Simulation finished, finalizing results.\n" ] }, { @@ -366,7 +373,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:41,866 [INFO] Done.\n" + "2026-09-07 00:20:35,727 [INFO] Done.\n" ] }, { @@ -483,7 +490,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "d0e1f2a3", "metadata": {}, "outputs": [ @@ -497,7 +504,9 @@ " PopC.population: OK\n", " Connectivity.network: OK\n", " SimConfig.results: OK\n", - " Analysis.figures: OK\n" + " Analysis.figures: OK\n", + " Analysis.firing_rate_hz: OK\n", + " Analysis.isi_stats: OK\n" ] } ], @@ -522,7 +531,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "f2a3b4c5", "metadata": {}, "outputs": [ @@ -535,7 +544,8 @@ "Executing node: PopA\n", "Executing node: Connectivity\n", "Executing node: SimConfig\n", - "2026-06-17 14:20:42,962 [INFO] Created log file\n" + "[NW_SimConfig] network unchanged, reusing ./results/ring_strong/network\n", + "2026-09-07 00:20:37,816 [INFO] Created log file\n" ] }, { @@ -549,7 +559,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:42,968 [INFO] Batch processing nodes for popC/0.\n" + "2026-09-07 00:20:37,831 [INFO] Batch processing nodes for popC/0.\n" ] }, { @@ -563,7 +573,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:42,974 [INFO] Batch processing nodes for popB/0.\n" + "2026-09-07 00:20:37,857 [INFO] Batch processing nodes for popB/0.\n" ] }, { @@ -577,7 +587,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:42,980 [INFO] Batch processing nodes for popA/0.\n" + "2026-09-07 00:20:37,912 [INFO] Batch processing nodes for popA/0.\n" ] }, { @@ -591,7 +601,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:42,995 [INFO] Setting up output directory\n" + "2026-09-07 00:20:37,924 [INFO] Setting up output directory\n" ] }, { @@ -605,7 +615,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:42,996 [INFO] Building cells.\n" + "2026-09-07 00:20:37,925 [INFO] Building cells.\n" ] }, { @@ -619,7 +629,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:42,998 [INFO] Building recurrent connections\n" + "2026-09-07 00:20:37,927 [INFO] Building recurrent connections\n" ] }, { @@ -633,7 +643,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:43,002 [INFO] Network created.\n" + "2026-09-07 00:20:37,931 [INFO] Network created.\n" ] }, { @@ -647,7 +657,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:43,004 [INFO] Starting Simulation\n" + "2026-09-07 00:20:37,933 [INFO] Starting Simulation\n" ] }, { @@ -661,7 +671,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:43,043 [INFO] Simulation finished, finalizing results.\n" + "2026-09-07 00:20:37,973 [INFO] Simulation finished, finalizing results.\n" ] }, { @@ -675,7 +685,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:43,070 [INFO] Done.\n" + "2026-09-07 00:20:37,998 [INFO] Done.\n" ] }, { @@ -818,4 +828,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/notebooks/NW_SingleCell_PointNeuron.ipynb b/notebooks/NW_SingleCell_PointNeuron.ipynb index 1fbaec97..8962b1aa 100644 --- a/notebooks/NW_SingleCell_PointNeuron.ipynb +++ b/notebooks/NW_SingleCell_PointNeuron.ipynb @@ -52,7 +52,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'name': 'Population', 'type': 'nw_population', 'description': \"Creates a BMTK NetworkBuilder population and passes the live builder object to NW_Connectivity (for inter-population edges) or directly to NW_SimConfig. build() and save() are called by NW_SimConfig, following BMTK's own sequence.\", 'parameters': {'pop_name': 'v1', 'N': 1, 'ei_type': 'exc', 'location': 'VISp', 'layer': 'L4', 'model_type': 'point_neuron', 'model_template': 'nest:iaf_psc_alpha', 'nest_params': {'C_m': 250.0, 'tau_m': 10.0, 't_ref': 2.0, 'V_th': -55.0, 'V_reset': -70.0, 'E_L': -70.0}, 'dynamics_params_file': '', 'model_processing': '', 'morphology': '', 'mechanisms_source': '', 'hoc_template': ''}, 'optimizable_parameters': {}, 'input_ports': {'iclamp': {'type': 'dict', 'description': 'Current clamp dict from NW_IClamp (keys: amp, delay, duration). Passed through to NW_SimConfig via the population output.', 'optional': True}}, 'output_ports': {'population': {'type': 'object', 'description': 'Dict with: builder (live NetworkBuilder), pop_name (str), network_dir (str), and optionally current_clamp (dict). Consumed by NW_Connectivity or NW_SimConfig.'}}, 'process_steps': [{'name': 'build', 'description': \"Create NetworkBuilder, add nodes, resolve dynamics params, copy biophysical source files. Does not call net.build() or net.save() — that is NW_SimConfig's responsibility.\", 'inputs': ['iclamp'], 'outputs': ['population'], 'method_key': 'build'}], 'methods': {'build': \"Create NetworkBuilder, add nodes, resolve dynamics params, copy biophysical source files. Does not call net.build() or net.save() — that is NW_SimConfig's responsibility.\"}}\n" + "{'name': 'Population', 'type': 'nw_population', 'description': \"Creates a BMTK NetworkBuilder population and passes the live builder object to NW_Connectivity (for inter-population edges) or directly to NW_SimConfig. build() and save() are called by NW_SimConfig, following BMTK's own sequence.\", 'parameters': {'pop_name': 'v1', 'N': 1, 'ei_type': 'exc', 'location': 'VISp', 'layer': 'L4', 'model_type': 'point_neuron', 'model_template': 'nest:iaf_psc_alpha', 'nest_params': {'C_m': 250.0, 'tau_m': 10.0, 't_ref': 2.0, 'V_th': -55.0, 'V_reset': -70.0, 'E_L': -70.0}, 'mean_firing_rate': 10.0, 'dynamics_params_file': '', 'model_processing': '', 'morphology': '', 'mechanisms_source': '', 'hoc_template': ''}, 'optimizable_parameters': {}, 'input_ports': {'iclamp': {'type': 'dict', 'description': 'Current clamp dict from NW_IClamp (keys: amp, delay, duration). Passed through to NW_SimConfig via the population output.', 'optional': True}}, 'output_ports': {'population': {'type': 'object', 'description': 'Dict with: builder (live NetworkBuilder), pop_name (str), network_dir (str), and optionally _current_clamp (dict). Consumed by NW_Connectivity or NW_SimConfig.'}}, 'process_steps': [{'name': 'build', 'description': \"Create NetworkBuilder, add nodes, resolve dynamics params, copy biophysical source files. Does not call net.build() or net.save() — that is NW_SimConfig's responsibility.\", 'inputs': ['iclamp'], 'outputs': ['population'], 'method_key': 'build'}], 'methods': {'build': \"Create NetworkBuilder, add nodes, resolve dynamics params, copy biophysical source files. Does not call net.build() or net.save() — that is NW_SimConfig's responsibility.\"}}\n" ] } ], @@ -87,6 +87,7 @@ " 'V_th': -55.0,\n", " 'V_reset': -70.0,\n", " 'E_L': -70.0},\n", + " 'mean_firing_rate': 10.0,\n", " 'dynamics_params_file': '',\n", " 'model_processing': '',\n", " 'morphology': '',\n", @@ -134,6 +135,7 @@ "model_type = 'point_neuron'\n", "model_template = 'nest:iaf_psc_alpha'\n", "nest_params = {'C_m': 250.0, 'tau_m': 10.0, 't_ref': 2.0, 'V_th': -55.0, 'V_reset': -70.0, 'E_L': -70.0}\n", + "mean_firing_rate = 10.0\n", "dynamics_params_file = ''\n", "model_processing = ''\n", "morphology = ''\n", @@ -159,7 +161,7 @@ "output_type": "stream", "text": [ "[in] iclamp (dict, optional=True) -- Current clamp dict from NW_IClamp (keys: amp, delay, duration). Passed through to NW_SimConfig via the population output.\n", - "[out] population (object) -- Dict with: builder (live NetworkBuilder), pop_name (str), network_dir (str), and optionally current_clamp (dict). Consumed by NW_Connectivity or NW_SimConfig.\n" + "[out] population (object) -- Dict with: builder (live NetworkBuilder), pop_name (str), network_dir (str), and optionally _current_clamp (dict). Consumed by NW_Connectivity or NW_SimConfig.\n" ] } ], @@ -244,10 +246,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "4676db57", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "output port \"population\": None\n", + "input port \"iclamp\" : None\n" + ] + } + ], "source": [ "# Read a single port's value through its accessor.\n", "# NOTE: port values are None until the workflow is built and executed (Section 3).\n", @@ -271,17 +282,17 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 10, "id": "2294029f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 5, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -341,7 +352,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 11, "id": "f6d0be6a-b9ad-44c0-8d32-0f534351ee65", "metadata": {}, "outputs": [ @@ -357,10 +368,11 @@ " 'module': 'membrane_report',\n", " 'sections': 'soma'}},\n", " 'compile_mechanisms': False,\n", - " 'overwrite': True}" + " 'overwrite': True,\n", + " 'rebuild_network': 'auto'}" ] }, - "execution_count": 6, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -379,7 +391,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 12, "id": "e332cb3a", "metadata": {}, "outputs": [ @@ -389,20 +401,8 @@ "text": [ "Executing node: IClamp\n", "Executing node: Population\n", - "Executing node: SimConfig\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:root:No edges have been made for this network, skipping saving of edges file.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Executing node: SimConfig\n", + "[NW_SimConfig] network unchanged, reusing ./results/run1/network\n", "\n", " -- N E S T --\n", " Copyright (C) 2004 The NEST Initiative\n", @@ -418,7 +418,7 @@ "\n", " Type 'nest.help()' to find out more about NEST.\n", "\n", - "2026-06-17 14:20:10,819 [INFO] Created log file\n" + "2026-09-07 08:48:30,142 [INFO] Created log file\n" ] }, { @@ -432,7 +432,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:10,854 [INFO] Batch processing nodes for v1/0.\n" + "2026-09-07 08:48:30,151 [INFO] Batch processing nodes for v1/0.\n" ] }, { @@ -446,7 +446,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:10,857 [INFO] Setting up output directory\n" + "2026-09-07 08:48:30,152 [INFO] Setting up output directory\n" ] }, { @@ -460,7 +460,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:10,859 [INFO] Building cells.\n" + "2026-09-07 08:48:30,153 [INFO] Building cells.\n" ] }, { @@ -474,7 +474,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:10,862 [INFO] Building recurrent connections\n" + "2026-09-07 08:48:30,154 [INFO] Building recurrent connections\n" ] }, { @@ -488,7 +488,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:10,863 [INFO] Network created.\n" + "2026-09-07 08:48:30,154 [INFO] Network created.\n" ] }, { @@ -502,7 +502,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:10,870 [INFO] Starting Simulation\n" + "2026-09-07 08:48:30,157 [INFO] Starting Simulation\n" ] }, { @@ -516,7 +516,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:10,893 [INFO] Simulation finished, finalizing results.\n" + "2026-09-07 08:48:30,176 [INFO] Simulation finished, finalizing results.\n" ] }, { @@ -530,7 +530,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:10,913 [INFO] Done.\n" + "2026-09-07 08:48:30,186 [INFO] Done.\n" ] }, { @@ -599,10 +599,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "97a306c7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "nodes : 4 -> ['IClamp', 'Population', 'SimConfig', 'Analysis']\n", + "connections: 3 edges\n" + ] + } + ], "source": [ "# How many nodes and connections (edges) does the workflow have?\n", "print('nodes :', len(workflow.nodes), '->', list(workflow.nodes))\n", @@ -611,10 +620,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "80ac8fe2", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "IClamp.iclamp -> Population.iclamp\n", + "Population.population -> SimConfig.populations\n", + "SimConfig.results -> Analysis.results\n" + ] + } + ], "source": [ "# List every connection (edge): source node.port -> target node.port\n", "for c in workflow.connections:\n", @@ -623,10 +642,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "9a60c337", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "execution order: IClamp -> Population -> SimConfig -> Analysis\n", + "valid workflow : True\n" + ] + } + ], "source": [ "# Execution order (topological) and a validity check of the graph.\n", "print('execution order:', ' -> '.join(workflow.get_info()['execution_order']))\n", @@ -643,7 +671,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 16, "id": "934ce8d4", "metadata": {}, "outputs": [ @@ -655,7 +683,9 @@ " IClamp.iclamp: OK\n", " Population.population: OK\n", " SimConfig.results: OK\n", - " Analysis.figures: OK\n" + " Analysis.figures: OK\n", + " Analysis.firing_rate_hz: OK\n", + " Analysis.isi_stats: OK\n" ] } ], @@ -677,17 +707,10 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 17, "id": "7e1db1f1", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:root:No edges have been made for this network, skipping saving of edges file.\n" - ] - }, { "name": "stdout", "output_type": "stream", @@ -695,7 +718,8 @@ "Executing node: IClamp\n", "Executing node: Population\n", "Executing node: SimConfig\n", - "2026-06-17 14:20:11,998 [INFO] Created log file\n" + "[NW_SimConfig] network unchanged, reusing ./results/run2/network\n", + "2026-09-07 08:48:32,233 [INFO] Created log file\n" ] }, { @@ -709,7 +733,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:12,013 [INFO] Batch processing nodes for v1/0.\n" + "2026-09-07 08:48:32,242 [INFO] Batch processing nodes for v1/0.\n" ] }, { @@ -723,7 +747,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:12,015 [INFO] Setting up output directory\n" + "2026-09-07 08:48:32,244 [INFO] Setting up output directory\n" ] }, { @@ -737,7 +761,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:12,016 [INFO] Building cells.\n" + "2026-09-07 08:48:32,245 [INFO] Building cells.\n" ] }, { @@ -751,7 +775,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:12,017 [INFO] Building recurrent connections\n" + "2026-09-07 08:48:32,247 [INFO] Building recurrent connections\n" ] }, { @@ -765,7 +789,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:12,018 [INFO] Network created.\n" + "2026-09-07 08:48:32,248 [INFO] Network created.\n" ] }, { @@ -779,7 +803,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:12,021 [INFO] Starting Simulation\n" + "2026-09-07 08:48:32,252 [INFO] Starting Simulation\n" ] }, { @@ -793,7 +817,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:12,040 [INFO] Simulation finished, finalizing results.\n" + "2026-09-07 08:48:32,271 [INFO] Simulation finished, finalizing results.\n" ] }, { @@ -807,7 +831,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:12,057 [INFO] Done.\n" + "2026-09-07 08:48:32,284 [INFO] Done.\n" ] }, { @@ -878,17 +902,10 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 18, "id": "9277ff71-914c-4594-a420-296586fceda8", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:root:No edges have been made for this network, skipping saving of edges file.\n" - ] - }, { "name": "stdout", "output_type": "stream", @@ -896,7 +913,8 @@ "Executing node: IClamp\n", "Executing node: Population\n", "Executing node: SimConfig\n", - "2026-06-17 14:20:12,354 [INFO] Created log file\n" + "[NW_SimConfig] network unchanged, reusing ./results/run3/network\n", + "2026-09-07 08:48:32,919 [INFO] Created log file\n" ] }, { @@ -910,7 +928,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:12,362 [INFO] Batch processing nodes for v1/0.\n" + "2026-09-07 08:48:32,928 [INFO] Batch processing nodes for v1/0.\n" ] }, { @@ -924,7 +942,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:12,363 [INFO] Setting up output directory\n" + "2026-09-07 08:48:32,930 [INFO] Setting up output directory\n" ] }, { @@ -938,7 +956,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:12,364 [INFO] Building cells.\n" + "2026-09-07 08:48:32,932 [INFO] Building cells.\n" ] }, { @@ -952,7 +970,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:12,366 [INFO] Building recurrent connections\n" + "2026-09-07 08:48:32,935 [INFO] Building recurrent connections\n" ] }, { @@ -966,7 +984,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:12,366 [INFO] Network created.\n" + "2026-09-07 08:48:32,936 [INFO] Network created.\n" ] }, { @@ -980,7 +998,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:12,392 [INFO] Starting Simulation\n" + "2026-09-07 08:48:32,965 [INFO] Starting Simulation\n" ] }, { @@ -994,7 +1012,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:13,363 [INFO] Simulation finished, finalizing results.\n" + "2026-09-07 08:48:33,930 [INFO] Simulation finished, finalizing results.\n" ] }, { @@ -1008,7 +1026,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2026-06-17 14:20:13,653 [INFO] Done.\n" + "2026-09-07 08:48:34,195 [INFO] Done.\n" ] }, { @@ -1115,7 +1133,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.15" + "version": "3.12.10" } }, "nbformat": 4, diff --git a/notebooks/vneumod_simulation.ipynb b/notebooks/vneumod_simulation.ipynb index 57484dff..70d813c1 100644 --- a/notebooks/vneumod_simulation.ipynb +++ b/notebooks/vneumod_simulation.ipynb @@ -425,7 +425,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.10" + "version": "3.13.13" } }, "nbformat": 4, From 54614ba116af161b0f2608be8e91624b6ee74a00 Mon Sep 17 00:00:00 2001 From: Carlos Gutierrez Date: Mon, 7 Sep 2026 20:06:06 +0900 Subject: [PATCH 6/8] Rewrite optimize-model-parameters skill against the real optimization API --- .../skills/optimize-model-parameters/SKILL.md | 483 ++++++++++++++++++ 1 file changed, 483 insertions(+) create mode 100644 .claude/skills/optimize-model-parameters/SKILL.md diff --git a/.claude/skills/optimize-model-parameters/SKILL.md b/.claude/skills/optimize-model-parameters/SKILL.md new file mode 100644 index 00000000..6d586c0d --- /dev/null +++ b/.claude/skills/optimize-model-parameters/SKILL.md @@ -0,0 +1,483 @@ +--- +name: optimize-model-parameters +description: Tune the parameters of an existing NeuroWorkflow graph until a measured quantity lands in a target range — choose what to explore and what to hit, check the model can reach the target, run the search, reject degenerate dynamics, and report the result. Use when the user wants to fit, tune, calibrate or optimize a workflow that already runs. +--- + +# Optimize Model Parameters + +Take a workflow that already runs, and search its parameter space until a measured quantity — +a firing rate, an inter-spike interval, anything numeric a node outputs — lands where the user +wants it. + +This skill is written for a person reading it as documentation *and* for an agent executing it. +Everything below is the real API; run it in a notebook, a script, or from an agent. + +> **You orchestrate; the optimizer searches.** Do not try to be the optimizer — you decide what +> to tune, whether the target is reachable, whether a result is scientifically valid, and when to +> stop. CMA-ES proposes better next points than you can. + +--- + +## Mental model — the loop wraps the graph + +A workflow is a DAG: it runs once, feed-forward, and produces outputs. A search is a loop — +propose parameters, run the DAG, measure, propose again. A loop cannot live inside an acyclic +graph, so the optimizer sits **outside** the workflow and calls it repeatedly: + +``` + ask ──► configure nodes ──► workflow.execute() ──► read a measured value + │ + ┌────────────────────── tell ◄───── distance from target + ▼ + propose the next candidates … +``` + +**The workflow is the objective function.** It is built **once** and reconfigured between +trials — never rebuilt. + +--- + +## Quick start + +```python +from neuroworkflow.optimization import AlgorithmConfig, build_spec, optimize + +# 1. the search: which algorithm, how big a budget +spec = build_spec(workflow, AlgorithmConfig(name="cmaes", pop_size=8, + max_generations=10, seed=1)) + +# 2. what to hit: a label, where it is measured, and the acceptable range +spec.add_objective(name="exc_firing_rate", measures="ana.firing_rate_hz.exc", + low=8.0, high=12.0, unit="Hz") + +print(spec.summary()) # ALWAYS read this before spending simulation time + +# 3. run it +result = optimize(workflow, spec=spec, results_path="./results/optimization") + +print(result.stop_reason) +print(result.configure_snippet()) # ready-to-paste best configuration +result.apply_best(workflow) # adopt it — a deliberate step, never automatic +``` + +`build_spec()` runs the workflow once at its current values. That run is the **baseline** every +result is compared against, and it is what every `measures` address is resolved against. + +--- + +## What to explore, and what to hit + +### What to explore — declared on the parameter + +```python +clamp.NODE_DEFINITION.parameters["amp_na"].optimizable = True +clamp.NODE_DEFINITION.parameters["amp_na"].optimization_range = [100.0, 1000.0] +clamp.NODE_DEFINITION.parameters["amp_na"].unit = "nA" +``` + +For a **dict-valued** parameter, give a range per key — each key becomes its own dimension: + +```python +exc.NODE_DEFINITION.parameters["nest_params"].optimizable = True +exc.NODE_DEFINITION.parameters["nest_params"].optimization_range = { + "I_e": [0.0, 400.0], + "tau_m": [5.0, 50.0], +} +``` + +Two bounds that are not the same thing: + +| | meaning | who enforces it | +|---|---|---| +| `constraints={"min":…, "max":…}` | what the model considers **valid at all** | `configure()` rejects violations | +| `optimization_range` | the patch **this study** wants searched | the optimizer samples inside it | + +A range reaching past the constraints is clipped, and the clip is recorded in the spec. Never +propose a range outside `constraints`. + +Each node **instance** carries its own definition, so marking `exc.nest_params` optimizable +leaves `inh` untouched even though both are `NW_Population`. + +### What to hit — two ways, and one is preferred + +**Preferred — declare it on the study:** + +```python +spec.add_objective(name="exc_firing_rate", measures="ana.firing_rate_hz.exc", + low=8.0, high=12.0, unit="Hz") +``` + +An objective is a label, an address and a range. Nothing about it needs a parameter to hang it +on, so no node has to carry a value the simulation never reads, and the same workflow can be +optimized toward different targets without editing its nodes. + +**Also supported — declare it on a node parameter**, for when a node author ships a sensible +default target: + +```python +p = exc.NODE_DEFINITION.parameters["mean_firing_rate"] +p.is_objective, p.objective_range, p.unit = True, [8.0, 12.0], "Hz" +p.measures = "ana.firing_rate_hz.exc" +``` + +`build_spec()` discovers those. A target **without `measures` is skipped and reported** — a +range alone is not interpretable, since "firing rate" means different things in different nodes. + +Goals other than a range: `goal="minimize"` or `goal="maximize"` (no `low`/`high`). + +### Addressing + +Everything is a dotted path starting with the **node's instance name** — the string passed to +the constructor, not the Python variable: + +| kind | shape | example | +|---|---|---| +| parameter to tune | `Node.parameter[.key]` | `exc.nest_params.I_e` | +| value to measure | `Node.output_port[.key]` | `ana.firing_rate_hz.exc` | + +**Never guess a `measures` address.** Ask the data: + +```python +from neuroworkflow.optimization import discover_measurables +discover_measurables(workflow) # every numeric leaf a run actually produced +# {'ana.firing_rate_hz.exc': 8.3, 'ana.isi_stats.exc.cv': 0.94, ...} +``` + +It reads the outputs of a real run, so it cannot go stale. Keys beginning with `_` are internal +plumbing and are deliberately excluded. + +--- + +## Before you run: can the model even reach the target? + +**Do this every time. It is the single most common way an optimization wastes hours.** + +A search can only find what the model can produce. If the target lies outside what the +parameters can generate, the run completes, reports honestly, and tells you nothing — every +trial the same distance from a target none of them could reach. + +This happened in this repository. `NW_Network_Optimization.ipynb` ran 24 trials, each measuring +**0 Hz**, because the explored current sat below the neuron's firing threshold: + +``` +g_L = C_m / tau_m = 250 pF / 10 ms = 25 nS +ΔV = V_th − E_L = −55 − (−70) = 15 mV +rheobase = ΔV × g_L = 375 pA ← cannot spike below this +``` + +The notebook started at `I_e = 300 pA` and explored `[0, 400]`, so 94% of the space was silent — +and with no spikes anywhere, the recurrent weight had nothing to amplify, because silence is +self-sustaining. The loop was perfect; the model could not answer. + +Worse, the target itself was unreachable: for a deterministic leaky integrate-and-fire neuron the +rate jumps from 0 to ~16 Hz as current crosses threshold, so 8–12 Hz existed only within a +**0.1 pA** window. No optimizer finds that, and none should be asked to. + +**The check, before every run:** + +1. **Is the baseline alive?** Read `spec.baseline["measurables"]`. All zeros usually means + nothing is firing and the target is unreachable from here. +2. **Evaluate the extremes by hand.** Configure the low end of each range, execute, measure; + then the high end. If the target does not sit between them, fix the ranges — not the + optimizer. +3. **Know the analytic bound when one exists.** Rheobase for a LIF neuron; a synaptic weight that + cannot produce a rate on its own; a target rate above `1000/t_ref`. +4. **Low rates need noise, not precision.** A deterministic neuron has a steep f–I curve near + threshold. If the user wants a low rate, a stochastic input (Poisson) is the physiological + answer; tightening the current range is not. + +State what you checked. "The target is reachable: `I_e = 378 pA` gives 20 Hz and `417 pA` gives +40 Hz, both inside the explored range" is worth more than any amount of search machinery. + +--- + +## Algorithms + +```python +from neuroworkflow.optimization import available +available() # ['cmaes', 'nsga2', 'nsga3', 'optuna_random', 'random', 'tpe'] +``` + +| name | method | objectives | needs | use when | +|---|---|---|---|---| +| `random` | uniform sampling | any | — | smoke-testing the loop, or a baseline to beat | +| `cmaes` | CMA-ES | **1 only** | `optuna`, `cmaes` | default for continuous single-objective search | +| `tpe` | Tree-structured Parzen | any | `optuna` | trials are expensive, budget is small | +| `nsga2` | NSGA-II | any (built for 2–3) | `optuna` | 2–3 objectives; returns a Pareto front | +| `nsga3` | NSGA-III | any (built for 3+) | `optuna` | more than 3, where NSGA-II degrades | + +```bash +pip install optuna cmaes # everything except 'random' needs Optuna +``` + +Without it, those names still appear in `available()` and raise an `ImportError` naming the +install command. Restart the kernel after installing. + +**A single-objective backend refuses a multi-objective spec.** `cmaes` raises rather than +collapsing objectives into a weighted sum, because those weights would be an invented scientific +judgement. Use `nsga2`/`nsga3` and read the Pareto front. + +Budget: at most `pop_size × max_generations` executions, plus one baseline. With a simulation +costing seconds, that product is the first number to think about. `options` is forwarded verbatim +to the underlying sampler — `AlgorithmConfig(name="cmaes", options={"sigma0": 0.2})`. + +--- + +## Several objectives, and units + +Each objective reports **how far it missed, in its own unit** — 14.1 Hz past a rate target, +8.2 ms past an interval target. **Never add them.** The sum has no unit, no meaning, and quietly +favours whichever objective uses bigger numbers. + +The one comparable figure is the worst objective's miss divided by the width of its own target +range: + +``` +gen 1, trial 1/4 (#1): exc.amp=129.5 nA exc.w=7.542 pA + -> network_rate=25.91 Hz (off 14.09 Hz), probe_isi=11.79 ms (off 8.212 ms) <- best so far + furthest from target: network_rate, 1.41x its target range +``` + +`1.41x` means the miss is 1.41 times as wide as the range that was asked for; `0` means every +target is met. Stored as `target_ranges_off` in the ledger, alongside the raw per-objective +`fitness`. It is used for **ranking and reporting only** — what the optimizer is told stays raw +and per-objective, and Pareto dominance is scale-free anyway. + +When explaining this to a user: give the arithmetic with their numbers ("your target is 40–50 Hz, +that range is 10 Hz wide, the trial missed by 14.1 Hz, so 1.4"). Do not say "normalized", +"achievement" or "band width" — see the wording rule at the end. + +A multi-objective run does not stop at the first candidate that satisfies everything, because the +useful answer is the **front**, not one point: + +```python +for row in result.pareto_front: + print(row["trial"], row["measured"], row["params"], row["target_ranges_off"]) +``` + +Choosing among them is a scientific judgement, not something the search can make. +`apply_best()` falls back to the member whose worst objective missed by the least — a tie-break +and nothing more. + +--- + +## Where you add value, and where you do not + +**For the numerical search you add nothing.** Do not insert yourself into every generation by +reflex: that is latency and tokens for no gain. Your value is at the edges. + +1. **Setup.** Decide what to tune, propose biologically grounded ranges, map each target to the + right measured value when several populations exist, and **verify the target is reachable** + (above). A script cannot do this. *Highest value.* +2. **Rejecting bad dynamics.** A scalar is blind to *how* a target was met — see `reject_fn` + below. *The strongest reason a neuroscientist is in this loop.* +3. **Watching a long run.** Read the ledger and tell the user the *trend* while it is still + running: "gen 40/100, the worst objective is now 0.4x its target range, converging in maybe + 15 more generations" or "stalled for 8 generations — the ranges may be too narrow". Turns an + opaque run into a steerable one. *High value at scale.* +4. **Interpretation.** Explain the front, recommend a configuration, name the trade-off. + +If a run is small, routine and fully specified, set it going and read the result. + +--- + +## Rejecting degenerate dynamics + +A configuration can hit "10 Hz" while the network is silent except a few bursting cells, or +synchronized in an epileptic-like regime that merely *averages* to 10 Hz. Fitness says perfect; +biology says garbage. `reject_fn` is where that judgement goes: + +```python +def reject(workflow, measured): + """Return a reason to reject this trial, or None to accept it.""" + cv = measured.get("ana.isi_stats.exc.cv") + if cv is not None and cv < 0.1: + return f"clock-like firing (ISI CV {cv:.2f}) — not a plausible regime" + return None + +result = optimize(workflow, spec=spec, results_path="./results/opt", reject_fn=reject) +``` + +Signature: `reject_fn(workflow, measured) -> str | None`, where `measured` is the same flat +address→value mapping `discover_measurables()` returns. A rejected trial is recorded as +`status: "rejected"` with the reason, and reported as `null` fitness rather than a large penalty, +so the sampler marks it failed instead of letting an invented number distort its model. + +`rejected` is first-class in the ledger, not a footnote — it is the whole reason a human or an +agent is in the loop. + +--- + +## Watching and steering a running search + +Everything a monitor needs is written to `//`: + +| file | contents | +|---|---| +| `run.json` | the manifest: dimensions, objectives, algorithm, baseline. Written once | +| `trials.jsonl` | one line per evaluation, append-only | +| `status.json` | replaced each generation: `state`, counts, `best`, `progress.best_target_ranges_off_by_gen` | +| `control.json` | **written by you** to steer the run | + +Read `status.json` for a summary; `progress.best_target_ranges_off_by_gen` draws a convergence +curve without parsing every trial. + +To steer, write `control.json` into the run directory: + +```json +{"seq": 1, "command": "stop", "issued_by": "agent", "args": {}} +``` + +Commands: `stop`, `pause`, `resume`, and `inject` (with +`args={"candidates": [{"exc.nest_params.I_e": 390.0, "conn.syn_weight": 12.0}]}`). The loop reads +it **between generations** and applies a command at most once — only when `seq` is higher than +the last acknowledged one, which it records in `status.control_ack`. So increment `seq` for each +new command and confirm delivery by reading the same file you already watch. + +There is deliberately **no retarget command**: changing an objective mid-run invalidates every +fitness already recorded. Stop, and start a new run. + +--- + +## The locked evaluation protocol + +Everything not in the exploration space is **frozen for the whole run**: simulation length, `dt`, +the analysis window and method, and the network topology. Only `optimizable` parameters may vary. +If anything else drifts, fitnesses stop being comparable and the search is invalid. + +Trial-to-trial RNG variation is **acceptable and need not be controlled** — objectives are ranges, +not points, so seed noise is absorbed. Do not spend budget averaging seeds unless asked. + +--- + +## When a search stalls + +Read the ledger first, then work through this in order: + +1. **Check reachability again** (above). A flat objective across every trial almost always means + the target cannot be produced, not that the algorithm is weak. +2. **Combine near-misses** — inject an interpolation of the best candidates so far via + `control.json`. +3. **Probe the boundaries.** If the best points sit against a range edge, the optimum is probably + outside it. Propose widening — and **ask the user** before expanding any range. +4. **Drop dead dimensions.** If a dimension shows no effect on the objective across the log, say + so and propose removing it so the search concentrates where it matters. + +--- + +## Reporting + +- **Single objective**: the best parameters, the measured value, and whether it is inside the + target range — in the objective's own unit. +- **Several**: the Pareto front, with each member's measured values; recommend one and name the + trade-off it represents. +- Always: the baseline-versus-best comparison, the number of evaluations, and the stopping reason. +- Always: a ready-to-use snippet — `result.configure_snippet()` produces it, correctly handling + dict keys (`nest_params={**exc._parameters["nest_params"], "I_e": 390.0}`). + +**Not reaching the target is a result, not a failure.** The run answered "nothing in these ranges +hits that band" — which is information about the model. Only a run where no trial produced a +usable measurement (`result.best is None`) has actually failed. + +The search leaves the workflow holding the **last** trial's values, and its `results_path` +pointing at the last trial's directory. Adopting the winner is a separate, deliberate step +(`apply_best`). Say clearly what was applied. + +--- + +## Expensive artifacts: do not rebuild what did not change + +A search re-runs the whole graph every trial, including anything expensive it builds. Nodes can +declare what survives a trial unchanged: + +```python +class NW_SimConfig(Node): + REUSABLE_PATHS = ("network",) # relative to results_path +``` + +The engine copies those directories in from the baseline before each trial; a node that +recognises its own earlier work skips redoing it. For the `NW_*` builders that means the SONATA +network is built once instead of once per trial, controlled by `rebuild_network` +(`auto` / `always` / `never`). + +Know which parameters are **structural** and which are **runtime**, because only structural ones +force a rebuild: + +| | example | written to | +|---|---|---| +| structural | `syn_weight`, `N`, connection rules | `nodes.h5`, `edge_types.csv` — rebuild required | +| runtime | `nest_params`, synapse `dynamics_params_dict` | a JSON referenced by filename — no rebuild | + +If a search tunes only runtime values, the network is built once for the entire run. + +--- + +## From the GUI + +The same search is declared on canvas with an **`NW_Optimization`** node: it holds *how* to +search (algorithm, budget, seed, results path), has no ports and no process steps, and takes no +part in the workflow's execution. Its presence is the signal for the code generator to emit an +optimization run instead of a single execution. + +```python +opt = NW_Optimization("opt") +opt.configure(algorithm="cmaes", pop_size=16, max_generations=12, seed=1) + +spec = build_spec(workflow, opt.algorithm_config()) # not added to the workflow +spec.add_objective(name="exc_firing_rate", measures="ana.firing_rate_hz.exc", + low=40.0, high=50.0, unit="Hz") +result = optimize(workflow, spec=spec, results_path=opt.results_path()) +``` + +**Caveat as of 2026-09-07: `optuna` and `cmaes` are not installed in the nest kernel image**, so +an optimization generated in the GUI fails on import until they are added to `Dockerfile.nest`. +Only `algorithm="random"` runs there today. See `docs/OPTIMIZATION_GUI_HANDOFF.md`. + +--- + +## Checklist + +- [ ] The workflow runs cleanly at its current values; baseline recorded +- [ ] **Target reachability checked** — baseline alive, range extremes evaluated, analytic bound + considered; stated explicitly +- [ ] Every `measures` address taken from `discover_measurables()`, not guessed +- [ ] Ranges inside `constraints`, and grounded in something — literature, the model, or the user +- [ ] Dict parameters expanded to per-key ranges where keys are explored +- [ ] Objective count matches the algorithm (1 → `cmaes`/`tpe`, 2–3 → `nsga2`, more → `nsga3`) +- [ ] `spec.summary()` reviewed **before** spending simulation time +- [ ] Evaluation protocol locked — only `optimizable` parameters vary +- [ ] Dynamics checked via `reject_fn` where a right number could come from wrong dynamics +- [ ] Long runs narrated from the ledger, not only reported at the end +- [ ] Misses reported in their own units; never summed across objectives +- [ ] Stopping reason stated; "target not reached" reported as a result, not a failure +- [ ] Best configuration reported with a ready-to-use `configure()` snippet, and applying it + described as a separate step + +--- + +## Wording rules for anything a user reads + +The vocabulary here was rewritten after real confusion — keep it: + +- Say **"target range"**, never "band" or "band width" (*bandwidth* means a frequency range to a + neuroscientist). +- Say **"1.4x its target range"**, never "achievement", "normalized" or "ratio" — a ratio invites + "of what to what?". +- Always **name the objective** that is worst: `furthest from target: probe_isi, 1.4x its target + range`. +- Print a miss **with its unit** (`off 8.2 ms`); print the comparable figure **without one**. +- Define any term in plain words the first time it appears, with the user's own numbers. + +--- + +## Scope + +- This skill **optimizes an existing, working workflow**. It does not build nodes — use the + `create-node` skill for that. +- The search itself is `neuroworkflow.optimization`, wrapping Optuna's samplers. Never + reimplement a search; add a backend with `register_optimizer()` if one is missing. +- Reference material: `docs/OPTIMIZATION.md` (how the engine works), + `docs/OPTIMIZATION_GUI_HANDOFF.md` (the GUI half), and five runnable notebooks under + `notebooks/` — `NW_SingleCell_Optimization`, `NW_Clamp_Weight_Optimization`, + `NW_Network_Optimization`, and `generated_optimization_example` / + `generated_multiobjective_example`, which show what generated code looks like. From 1f9ab6358b26ab677bb74e14fdeec34b305c8dcb Mon Sep 17 00:00:00 2001 From: nw-kirill Date: Wed, 9 Sep 2026 22:11:41 +0900 Subject: [PATCH 7/8] Harden the outer-loop optimization engine for first-use correctness Treat NaN as a failed trial, complete injected candidates, pass CMA-ES popsize, restrict connection_rule strings to lambdas, and default NW_Optimization to random so a search runs without Optuna. Add toy-node tests, strip notebook outputs, and document that GUI generate-code and the nest image extra remain follow-ups. --- NODE_SCHEMA.md | 16 +- .../pr95-optimization-audit-progress.log | 174 + docs/OPTIMIZATION.md | 6 + docs/OPTIMIZATION_GUI_HANDOFF.md | 36 +- examples/neuron_optimization.py | 207 +- .../neuroworkflow/optimization/__init__.py | 3 +- .../neuroworkflow/optimization/addressing.py | 46 +- .../neuroworkflow/optimization/engine.py | 382 +- .../neuroworkflow/optimization/ledger.py | 19 +- .../neuroworkflow/optimization/optimizers.py | 92 +- .../codes/neuroworkflow/optimization/spec.py | 219 +- .../codes/nodes/network/NW_Connectivity.py | 37 +- .../nodes/optimization/NW_Optimization.py | 21 +- .../codes/nodes/simulation/NW_SimConfig.py | 45 +- notebooks/01_Basic_Simulation.ipynb | 189 +- .../NW_BalancedNetwork_PointNeuron.ipynb | 461 +- notebooks/NW_Clamp_Weight_Optimization.ipynb | 14646 +-------------- notebooks/NW_Network_Optimization.ipynb | 1605 +- notebooks/NW_Ring_PointNeuron.ipynb | 542 +- notebooks/NW_SingleCell_Optimization.ipynb | 6860 +------ notebooks/NW_SingleCell_PointNeuron.ipynb | 749 +- .../generated_multiobjective_example.ipynb | 10980 +---------- .../generated_optimization_example.ipynb | 15113 +--------------- notebooks/vneumod_simulation.ipynb | 185 +- pyproject.toml | 4 + .../nodes/network/NW_Connectivity.py | 37 +- .../nodes/optimization/NW_Optimization.py | 21 +- .../nodes/simulation/NW_SimConfig.py | 45 +- src/neuroworkflow/optimization/__init__.py | 3 +- src/neuroworkflow/optimization/addressing.py | 46 +- src/neuroworkflow/optimization/engine.py | 382 +- src/neuroworkflow/optimization/ledger.py | 19 +- src/neuroworkflow/optimization/optimizers.py | 92 +- src/neuroworkflow/optimization/spec.py | 219 +- tests/test_optimization_engine.py | 230 + 35 files changed, 1829 insertions(+), 51902 deletions(-) create mode 100644 deployment/pr95-optimization-audit-progress.log create mode 100644 tests/test_optimization_engine.py diff --git a/NODE_SCHEMA.md b/NODE_SCHEMA.md index 67992583..39c056a7 100644 --- a/NODE_SCHEMA.md +++ b/NODE_SCHEMA.md @@ -157,12 +157,20 @@ class ParameterDefinition: description: str = "" # Human-readable description constraints: Dict[str, Any] = field(default_factory=dict) # Validation constraints optimizable: bool = False # Whether this parameter can be tuned during optimization - optimization_range: Optional[List] = None # Range for parameter tuning [min, max] + optimization_range: Optional[Union[List, Dict]] = None # [min, max], or per-key dict is_objective: bool = False # Whether this parameter is an optimization objective/target objective_range: Optional[List] = None # Acceptable range for the objective value [min, max] suggested_values: List[Dict[str, Any]] = field(default_factory=list) # Optional suggestions + unit: str = "" # Physical unit (e.g. "Hz", "pF", "ms") + measures: Optional[str] = None # Objective: "Node.output_port[.key]" to compare against ``` +Each node **instance** holds its own `NODE_DEFINITION` copy (`copy.deepcopy` in `Node.__init__`), +so marking `exc` optimizable does not change `inh`. + +`optimization_range` may be a per-key dict for dict-valued parameters, e.g. +`{"V_th": [-60.0, -45.0], "C_m": [200.0, 300.0]}`. + ### Parameter Constraints Parameters can have constraints that validate their values: @@ -209,14 +217,16 @@ Use `optimizable` and `optimization_range` for parameters that should be tuned d ### Objectives (Targets to Achieve) -Use `is_objective` and `objective_range` for parameters that represent optimization targets or goals: +Use `is_objective`, `objective_range`, `unit`, and `measures` for targets: ```python 'mean_firing_rate': ParameterDefinition( default_value=10.0, description='Target mean firing rate (Hz)', + unit='Hz', is_objective=True, - objective_range=[5.0, 50.0] # Acceptable range for the objective + objective_range=[5.0, 50.0], + measures='Analysis.firing_rate_hz.exc', ) ``` diff --git a/deployment/pr95-optimization-audit-progress.log b/deployment/pr95-optimization-audit-progress.log new file mode 100644 index 00000000..15426f62 --- /dev/null +++ b/deployment/pr95-optimization-audit-progress.log @@ -0,0 +1,174 @@ +================================================================================ +PR #95 optimization engine audit progress log (append-only) +Created: 2026-09-09 +================================================================================ + +PR +-- +https://github.com/oist/neuro-workflow/pull/95 +Branch: feat/schema-improvements (carlosengutierrez) +Head at start: 54614ba1 Rewrite optimize-model-parameters skill against the real optimization API +Mergeable vs main: yes (inspected before this audit) +IzBrain67 review: https://github.com/oist/neuro-workflow/pull/95#issuecomment-5594642414 + +Worktree +-------- +Path: /home/nw-kirill/neuro-workflow-optimization +Branch: feat/schema-improvements tracking origin/feat/schema-improvements +Source: /home/nw-kirill/neuro-workflow-catalog (git worktree add origin/feat/schema-improvements) + +Verdict +------- +PR #95 is applicable and reasonable. It is a complete library engine, not a +GUI product. A workflow stays a one-shot DAG; a search loop sits outside the +graph. NW_Optimization has no ports and does not run during workflow.execute(); +its presence is a future generator signal. JointOptimizationNode is deleted. +Harden the model-independent first-use bugs from IzBrain67's review. Do not +rewrite where the study lives. Do not add a GUI, nest-image rebuild, or MCP +gateway. + +Kirill's choices for this pass +------------------------------- +- Study home: do not pick. Keep Carlos's parameter-level optimizable / + is_objective (including mean_firing_rate on NW_Population). After harden + commits, comment on #95 asking Carlos to settle vs IzBrain67's preference. +- Scope: engine harden only. No GUI panel, no code_generation_service.py, no + python_analyzer.py, no Dockerfile.nest / live nest rebuild, no merge/deploy. + +Non-goals +--------- +- Study-home rewrite / dropping mean_firing_rate +- Canvas study editor, generate-code emitting optimize() +- Dockerfile.nest / live nest rebuild +- Restore JointOptimizationNode +- Merge PRs #90–#94 +- Fuse.js, live /data writes, sudo, force-push, merge, deploy + +Integrity vs other PRs +----------------------- +- #90 / #91 / #93: no file overlap. +- #94: both edit chat_orchestrator.py. #95 inserts naming / pop_name rules + inside DEFAULT_SYSTEM_PROMPT; #94 overlays profiles after that constant. + Small textual merge later. Do not rewrite #94. +- #92: will need a manual merge on src/neuroworkflow/core/schema.py and + node.py (secret vs unit/measures + instance deepcopy). Document only. + +Live UI baseline +---------------- +https://neuro-workflow.dbrain.jp/ still runs the old bundle. origin/main has +JointOptimizationNode and no src/neuroworkflow/optimization/. After +implementation, confirm no NW_Optimization on the live bundle. Do not treat +that as a failed test of #95. Prove the engine with pytest in this worktree. + +================================================================================ + +## Step 1 — Worktree and progress log + +Done. Created /home/nw-kirill/neuro-workflow-optimization from +origin/feat/schema-improvements via /home/nw-kirill/neuro-workflow-catalog. +Attached local branch feat/schema-improvements tracking origin (worktree add +initially left detached HEAD 54614ba1). + +Verify: +- git status -sb: ## feat/schema-improvements...origin/feat/schema-improvements +- git log -1 --oneline: 54614ba1 Rewrite optimize-model-parameters skill against the real optimization API +- HEAD is 54614ba1 (later commits will land in later steps) +- Log file created (this file). Pass. + +================================================================================ + +## Step 2 — Engine correctness (first-use bugs) + +Done. src/ and codes/ copies kept byte-identical. + +- addressing._is_number: finite scalars only (numpy int/float ok; bool/NaN/arrays out). + get_parameter + clear_output_ports added. +- engine: clear ports before each trial execute; non-finite measurements fail the + trial (objective_fitness also refuses NaN instead of scoring 0.0). +- inject: missing dims filled from current parameter values; ledger source + comes from optimizer.last_ask_sources; _narrate_trial uses params.get; + narrate errors cannot kill the run. +- CMA-ES: sampler_init_kwargs passes popsize=config.pop_size to CmaEsSampler + (NSGA still uses population_size). +- NW_SimConfig._stable: functools.partial has no __code__ — hashed via + func/args/keywords; dict/list/tuple/array globals included in the signature. +- Help text: overwrite / rebuild_network mention frozen random rules in auto; + NW_Optimization max_generations no longer promises early-stop for multi-objective. + +Did not change the study model or drop mean_firing_rate. + +================================================================================ + +## Step 3 — eval lockdown + runnable default + +Done. + +- NW_Connectivity._coerce_connection_rule: strings must be a single ast.Lambda; + compiled with np + a small builtin set (no full __builtins__). Non-lambda + expressions raise ValueError. Int/callable unchanged. +- NW_Optimization algorithm default is random (matches AlgorithmConfig). cmaes + remains allowed. Help points at pip install -e ".[optimization]". +- pyproject.toml optional extra: optimization = ["optuna>=3.0", "cmaes"]. + Dockerfile.nest not touched. +- codes/ copies synced for Connectivity, NW_Optimization, optimizers. + +================================================================================ + +## Step 4 — Pytest (toy nodes, no NEST) + +Done. Added tests/test_optimization_engine.py covering: + +- random optimize round-trip +- NaN measurement is a failed trial (fitness None; objective_fitness raises) +- partial inject fills missing dims, source=inject, run continues +- stale outputs cleared between trials +- _is_number: numpy scalars (if numpy), bool/NaN rejected +- _stable(functools.partial) does not raise +- instance NODE_DEFINITION deepcopy isolation +- CMA-ES sampler kwargs include popsize +- connection_rule lambda-only (import os.system rejected) + +No remaining JointOptimizationNode imports in library tests (example fixed in step 5). +Verify deferred to Step 6. + +================================================================================ + +## Step 5 — Docs, example, notebooks, format + +Done. + +- docs/OPTIMIZATION.md: random default, extra, GUI/nest image out of this PR, + study-home unsettled. +- docs/OPTIMIZATION_GUI_HANDOFF.md: path fixed to notebooks/generated_optimization_example.py; + status note; kernel section updated (default random, extra landed, Dockerfile.nest + still follow-up). Did not rewrite the study-home proposal. +- NODE_SCHEMA.md: unit, measures, dict optimization_range, per-instance NODE_DEFINITION. +- examples/neuron_optimization.py: no JointOptimizationNode; points at optimize() + random + and notebooks/generated_optimization_example.py. +- Stripped outputs from the PR's notebooks only (not unrelated notebooks). +- black --line-length 88 and isort --profile black on src/neuroworkflow/optimization/ + and tests/test_optimization_engine.py; codes/ optimization package re-copied. + +No TODO/TBD in new/changed engine files except existing NotImplementedError on enqueue. + +================================================================================ + +## Step 6 — Isolated verification + +Done. Worktree only; no live compose. + +Backend/library (python:3.11.11-slim, PYTHONPATH=src, numpy+pytest): + python -m pytest tests/test_optimization_engine.py -q + → 9 passed in 0.18s + black --check --line-length 88 src/neuroworkflow/optimization tests/test_optimization_engine.py + isort --check --profile black (same paths) + → pass + +Live https://neuro-workflow.dbrain.jp/: +- Sign In gate (old bundle). No optimization UI. +- Live JS /assets/index-CbQzE8nY.js: no NW_Optimization, nw_optimization, + JointOptimization, joint_optimization, ChatProfile. + +No test failures to fix (Probe NODE_DEFINITION.description added during this pass). + +================================================================================ diff --git a/docs/OPTIMIZATION.md b/docs/OPTIMIZATION.md index 974a97a4..7520cb42 100644 --- a/docs/OPTIMIZATION.md +++ b/docs/OPTIMIZATION.md @@ -28,6 +28,12 @@ print(result.configure_snippet()) # ready-to-paste best configuration `build_spec()` runs the workflow once at its current values. That run is the baseline every result is compared against, and it is what every `measures` address is resolved against. +`algorithm="random"` needs only numpy. Optuna algorithms (`cmaes`, `tpe`, `nsga2`, …) need +`pip install -e ".[optimization]"`. The Jupyter GUI code generator and the nest-kernel image extra +are **not** in this PR; until the nest image is rebuilt, generated GUI runs should use `random`. +Where the study is declared (per-parameter fields vs the `NW_Optimization` node) is still +unsettled — see `docs/OPTIMIZATION_GUI_HANDOFF.md`. + ## Declaring what to optimize The spec is read from the node schemas. Two declarations matter, both on `ParameterDefinition`. diff --git a/docs/OPTIMIZATION_GUI_HANDOFF.md b/docs/OPTIMIZATION_GUI_HANDOFF.md index fde9ed2f..cd45dd7e 100644 --- a/docs/OPTIMIZATION_GUI_HANDOFF.md +++ b/docs/OPTIMIZATION_GUI_HANDOFF.md @@ -4,9 +4,16 @@ The optimization engine, the schema fields it reads and the node that configures tested from Python. What is missing is the GUI half. This is the list, with the files involved. Background reading: `docs/OPTIMIZATION.md` (how the engine works). A runnable example of the code -the generator should produce: `src/neuroworkflow/nodes/sandbox/generated_optimization_example.py` +the generator should produce: `notebooks/generated_optimization_example.py` and its `.ipynb`. +**Status of this PR (library only).** GUI generate-code and adding `optuna`/`cmaes` to +`Dockerfile.nest` remain follow-ups. `NW_Optimization` now defaults to `algorithm="random"` so a +library run works without Optuna; `pyproject.toml` has an `optimization` extra. Where the study +lives (per-parameter `optimizable`/`is_objective` vs a study object on `NW_Optimization`) is +**not settled** — the sections below describe one GUI proposal; the engine still reads the +parameter-level fields as Carlos shipped them. + ## The one idea to hold on to **Optimization is not a step inside a workflow.** A workflow is a DAG that runs once; a search is a @@ -129,15 +136,15 @@ No ports, no process steps — a workflow containing it executes exactly as it w `JointOptimizationNode` was deleted: it was an in-graph grid search, i.e. the design this replaces. A saved project that placed it will no longer find it. -### The kernel image needs Optuna — do this first, it is the one blocker +### The kernel image needs Optuna — follow-up, not this PR -Workflows run in the nest kernel image, and that image has **no `optuna` and no `cmaes`**. Since -`NW_Optimization` defaults to `algorithm="cmaes"`, the first optimization anyone generates in the -GUI will stop at an `ImportError` — a clear one naming the install command, but a failure. Only -`algorithm="random"` runs without it. +Workflows run in the nest kernel image, and that image has **no `optuna` and no `cmaes`**. +`NW_Optimization` now defaults to `algorithm="random"`, which runs without those packages. +Optuna algorithms still `ImportError` until one line is added at +`gui/workflow_backend/django-project/neuroworkflow/Dockerfile.nest:128` and the image is rebuilt +(ops approval). Library users can `pip install -e ".[optimization]"` (`optuna>=3.0`, `cmaes`). -One line, in the pip block that already exists at -`gui/workflow_backend/django-project/neuroworkflow/Dockerfile.nest:128`: +The Dockerfile snippet (not applied in this PR): ```dockerfile pip install --no-cache-dir nestml nest-desktop "pandas>=2.2,<3.0" jupyterlab notebook \ @@ -146,19 +153,6 @@ One line, in the pip block that already exists at "siibra==1.0.1a15" "traitlets==5.14.3" && \ ``` -`cmaes` is a separate package from `optuna` and is required by the CMA-ES sampler specifically; the -NSGA-II/III and TPE samplers need only `optuna`. Adding them costs a rebuild of the nest image, -which is why it was left undone rather than slipped in. - -Optional, unrelated to the GUI but the same dependency: `pyproject.toml` declares extras for `nest`, -`visualization` and `dev` but none for this. Adding - -```toml -optimization = ["optuna>=3.0", "cmaes"] -``` - -to `[project.optional-dependencies]` gives library users `pip install -e ".[optimization]"`. - --- ## 3. One code-generation button diff --git a/examples/neuron_optimization.py b/examples/neuron_optimization.py index 0afbfe85..cf695563 100755 --- a/examples/neuron_optimization.py +++ b/examples/neuron_optimization.py @@ -1,199 +1,28 @@ #!/usr/bin/env python3 -""" -Encapsulated optimization example using the NeuroWorkflow library. +"""Outer-loop parameter search (JointOptimizationNode was removed). -This example demonstrates how to create a workflow for optimizing neuron parameters -without creating cycles in the workflow graph, while respecting node encapsulation. -""" +A workflow is a DAG that runs once. Search sits outside it: + + from neuroworkflow.optimization import AlgorithmConfig, build_spec, optimize -import sys -import os -import numpy as np -import matplotlib.pyplot as plt -from typing import Dict, Any + spec = build_spec(workflow, AlgorithmConfig(name="random", pop_size=8, seed=1)) + result = optimize(workflow, spec=spec, results_path="./results/optimization") + print(result.configure_snippet()) -# Add the src directory to the Python path to import the library -sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../src'))) +``random`` needs no extra packages. Optuna algorithms need +``pip install -e ".[optimization]"``. + +A generated example of what the GUI should emit: + + notebooks/generated_optimization_example.py +""" -from neuroworkflow.core.workflow import WorkflowBuilder -from neuroworkflow.nodes.optimization.JointOptimizationNode import JointOptimizationNode -from neuroworkflow.nodes.simulation.NeuronSimulationNode import NeuronSimulationNode -from neuroworkflow.nodes.stimulus.StimulusGeneratorNode import StimulusGeneratorNode -from neuroworkflow.nodes.network.NESTNeuronSetupNode import NESTNeuronSetupNode +from __future__ import annotations -def main(): - """Run an encapsulated optimization workflow example.""" - # Create nodes - neuron_node = NESTNeuronSetupNode("neuron_node") - stimulus_node = StimulusGeneratorNode("stimulus_node") - simulation_node = NeuronSimulationNode("simulation_node") - optimization_node = JointOptimizationNode("optimization_node") - - # Configure nodes with initial parameters - neuron_node.configure( - nest_model='iaf_psc_alpha', - threshold=-55.0, - resting_potential=-70.0, - time_constant=20.0, - refractory_period=2.0 - ) - - stimulus_node.configure( - stimulus_type='step', - amplitude=100.0, - start_time=250.0, - end_time=750.0 - ) - - # Define simulation parameters (these are not node configuration parameters) - simulation_time = 1000.0 - dt = 0.1 - - simulation_node.configure( - dt=0.1, - simulation_time=1000.0 - ) - - optimization_node.configure( - optimization_method='grid', - grid_points=3, # Use fewer points for faster execution - max_iterations=120 - ) - - # Initialize the stimulus generator with the simulation parameters - # This needs to be done before creating the workflow - stimulus_result = stimulus_node.generate_stimulus( - simulation_time=simulation_time, - dt=dt - ) - - # Create a workflow WITHOUT the feedback connections - # This keeps the workflow acyclic (no cycles) - workflow = ( - WorkflowBuilder("encapsulated_optimization_workflow") - .add_node(neuron_node) - .add_node(stimulus_node) - .add_node(simulation_node) - .add_node(optimization_node) - - # Connect neuron and stimulus nodes to simulation node - .connect("neuron_node", "nest_neuron", "simulation_node", "nest_neuron") - .connect("neuron_node", "nest_neuron_config", "simulation_node", "nest_neuron_config") - .connect("stimulus_node", "input_current", "simulation_node", "input_current") - - # Connect simulation results to optimization node - .connect("simulation_node", "simulation_results", "optimization_node", "simulation_results") - - # Connect parameter metadata to optimization node - .connect("neuron_node", "parameter_metadata", "optimization_node", "parameter_metadata") - .connect("stimulus_node", "parameter_metadata", "optimization_node", "parameter_metadata") - - # NO connections from optimization node back to setup nodes - # (These would create cycles) - - .build() - ) - - # Print workflow information - print(workflow) - - # Define optimization parameters - objective_target = 10 # Target number of spikes - max_iterations = 9 # Maximum number of iterations (3^2 grid points) - - # Reset optimization state - optimization_node.reset_optimization() - - # Variable to bridge the gap between optimization and setup nodes - # This breaks the cycle in the workflow - optimization_parameters = {} - - # Simple optimization loop - print("\nRunning encapsulated optimization workflow...") - for iteration in range(max_iterations): - print(f"\nIteration {iteration}:") - - # Apply optimization parameters to setup nodes - # This uses port access methods to get the data and configure to apply it - if optimization_parameters: - # Extract parameters for each node using the node names as keys - neuron_params = optimization_parameters.get(neuron_node.name, {}) - stimulus_params = optimization_parameters.get(stimulus_node.name, {}) - - # Configure nodes with new parameters - if neuron_params: - neuron_node.configure(**neuron_params) - if stimulus_params: - stimulus_node.configure(**stimulus_params) - - # Regenerate the stimulus with the new parameters - # This is necessary because the stimulus generator needs to create - # a new stimulus based on the updated parameters - stimulus_node.generate_stimulus( - simulation_time=simulation_time, - dt=dt - ) - - # Execute the workflow (which is now acyclic) - success = workflow.execute() - if not success: - print(f"Workflow execution failed at iteration {iteration}") - break - - # Get optimization parameters for next iteration using port access methods - # This completes the feedback loop that was removed from the workflow - # We're using get_output_port to get the port object, then accessing its value - params_port = optimization_node.get_output_port('parameters') - optimization_parameters = params_port.value - - # Alternatively, we could use the convenience method: - # optimization_parameters = optimization_node.get_output('parameters') - - # Check if we should continue - # This could be based on error, iteration count, or other criteria - # Get the error using the port access method - error_port = optimization_node.get_output_port('error') - error = error_port.value - print(f" Error: {error}") - - if error == 0 or iteration == max_iterations - 1: - print("Optimization complete or maximum iterations reached") - break - - # Get final optimization results - results = optimization_node.get_optimization_results() - - # Print best parameters - print("\nOptimization complete!") - print("Best parameters:") - for name, value in results['best_parameters'].items(): - print(f" {name}: {value}") - print(f"Best error: {results['best_error']}") - - # Plot optimization history - try: - plt.figure(figsize=(10, 6)) - - # Plot optimization history - history = results['history'] - iterations = [h['iteration'] for h in history] - errors = [h['error'] for h in history] - - plt.plot(iterations, errors, 'o-') - plt.title('Encapsulated Optimization Progress') - plt.xlabel('Iteration') - plt.ylabel('Error') - plt.grid(True) - - plt.tight_layout() - plt.savefig('encapsulated_optimization_results.png') - print("\nPlot saved as 'encapsulated_optimization_results.png'") - except Exception as e: - print(f"Error creating plot: {e}") - - return 0 +def main() -> None: + print(__doc__) if __name__ == "__main__": - sys.exit(main()) \ No newline at end of file + main() diff --git a/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/__init__.py b/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/__init__.py index 17c7fb55..ad9828fa 100644 --- a/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/__init__.py +++ b/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/__init__.py @@ -11,8 +11,7 @@ """ from .addressing import discover_measurables, read_output, set_parameter -from .engine import (OptimizationResult, objective_fitness, optimize, - reusable_paths) +from .engine import OptimizationResult, objective_fitness, optimize, reusable_paths from .ledger import Ledger from .optimizers import Optimizer, available, register_optimizer from .spec import ( diff --git a/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/addressing.py b/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/addressing.py index 91f7e177..513e12c3 100644 --- a/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/addressing.py +++ b/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/addressing.py @@ -9,6 +9,7 @@ port name. Any further segments index into a nested dict. """ +import math from copy import deepcopy from typing import Any, Dict, List, Tuple @@ -75,6 +76,39 @@ def set_parameter(workflow, address: str, value: Any) -> None: node.configure(**{param: current}) +def get_parameter(workflow, address: str) -> Any: + """Read a parameter by dotted address (current configured value).""" + node_name, param, keys = split_address(address) + node = _get_node(workflow, node_name) + + if param not in node._parameters: + raise KeyError( + f"Node {node_name!r} has no parameter {param!r} " + f"(have: {', '.join(sorted(node._parameters))})" + ) + + value = node._parameters[param] + for k in keys: + if not isinstance(value, dict): + raise TypeError( + f"Address {address!r}: cannot index {type(value).__name__} with {k!r}" + ) + if k not in value: + raise KeyError( + f"Address {address!r}: key {k!r} not in " + f"{', '.join(map(str, list(value)[:8]))}" + ) + value = value[k] + return value + + +def clear_output_ports(workflow) -> None: + """Drop every output-port value so a trial cannot be scored on stale data.""" + for node in workflow.nodes.values(): + for port in node._output_ports.values(): + port.value = None + + def read_output(workflow, address: str) -> Any: """Read a value from an output port by dotted address.""" node_name, port, keys = split_address(address) @@ -102,8 +136,16 @@ def read_output(workflow, address: str) -> Any: def _is_number(value: Any) -> bool: - # bool is an int subclass but is never a measured quantity. - return isinstance(value, (int, float)) and not isinstance(value, bool) + """True for a finite scalar (Python or numpy). bool and NaN are not numbers.""" + if isinstance(value, bool) or value is None: + return False + if hasattr(value, "ndim") and getattr(value, "ndim", 0) != 0: + return False + try: + number = float(value) + except (TypeError, ValueError): + return False + return math.isfinite(number) def discover_measurables(workflow) -> Dict[str, float]: diff --git a/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/engine.py b/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/engine.py index 093fb201..cb155791 100644 --- a/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/engine.py +++ b/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/engine.py @@ -14,6 +14,7 @@ ledger and writing ``control.json`` — nothing here requires that to happen. """ +import math import os import shutil import time @@ -21,7 +22,13 @@ from datetime import datetime from typing import Any, Callable, Dict, List, Optional, Sequence -from .addressing import read_output, set_parameter +from .addressing import ( + _is_number, + clear_output_ports, + get_parameter, + read_output, + set_parameter, +) from .ledger import Ledger from .optimizers import create_optimizer from .spec import AlgorithmConfig, Objective, OptimizationSpec, build_spec @@ -85,9 +92,7 @@ def configure_snippet(self) -> str: args = [f"{k}={v!r}" for k, v in scalars.get(node, {}).items()] for param, keys in nested.get(node, {}).items(): updates = ", ".join(f'"{k}": {v!r}' for k, v in keys.items()) - args.append( - f'{param}={{**{node}._parameters["{param}"], {updates}}}' - ) + args.append(f'{param}={{**{node}._parameters["{param}"], {updates}}}') lines.append(f"{node}.configure({', '.join(args)})") return "\n".join(lines) @@ -96,21 +101,26 @@ def configure_snippet(self) -> str: # Fitness # --------------------------------------------------------------------------- + def objective_fitness(objective: Objective, value: float) -> float: """Distance from the target, always minimized. ``in_range`` is zero anywhere inside the band and grows with the distance outside it — a band, not a point, so seed-to-seed noise is absorbed rather - than chased. + than chased. Non-finite values are not a distance of zero; the caller + must treat them as a failed trial. """ + number = float(value) + if not math.isfinite(number): + raise ValueError(f"non-finite measurement {value!r} cannot be scored") if objective.goal == "minimize": - return float(value) + return number if objective.goal == "maximize": - return -float(value) - if value < objective.low: - return float(objective.low - value) - if value > objective.high: - return float(value - objective.high) + return -number + if number < objective.low: + return float(objective.low - number) + if number > objective.high: + return float(number - objective.high) return 0.0 @@ -130,7 +140,11 @@ def objective_scales(spec) -> List[float]: scales = [] for objective in spec.objectives: scale = None - if objective.goal == "in_range" and objective.low is not None and objective.high is not None: + if ( + objective.goal == "in_range" + and objective.low is not None + and objective.high is not None + ): width = float(objective.high) - float(objective.low) if width > 0: scale = width @@ -138,7 +152,7 @@ def objective_scales(spec) -> List[float]: scale = abs(float(objective.high)) or None else: baseline = (spec.baseline.get("measured") or {}).get(objective.name) - if isinstance(baseline, (int, float)) and baseline: + if _is_number(baseline) and baseline: scale = abs(float(baseline)) scales.append(scale or 1.0) return scales @@ -173,8 +187,7 @@ def worst_objective(spec, fitness: Optional[Sequence[float]]): if fitness is None: return None scales = objective_scales(spec) - ranked = [(o.name, abs(f) / s) - for o, f, s in zip(spec.objectives, fitness, scales)] + ranked = [(o.name, abs(f) / s) for o, f, s in zip(spec.objectives, fitness, scales)] return max(ranked, key=lambda pair: pair[1], default=None) @@ -201,9 +214,13 @@ class MyBuilder(Node): return sorted(names) -def _point_at_trial_dir(workflow, run_dir: str, trial_no: int, - seed_root: Optional[str] = None, - seed_names: Sequence[str] = ()) -> str: +def _point_at_trial_dir( + workflow, + run_dir: str, + trial_no: int, + seed_root: Optional[str] = None, + seed_names: Sequence[str] = (), +) -> str: """Give a trial its own results directory and return it. Nodes that write files — a network builder, a simulator config — otherwise @@ -241,9 +258,9 @@ def _dominates(a: List[float], b: List[float]) -> bool: def _pareto_front(rows: List[Dict[str, Any]]) -> List[Dict[str, Any]]: scored = [r for r in rows if r.get("fitness")] return [ - r for r in scored - if not any(_dominates(o["fitness"], r["fitness"]) - for o in scored if o is not r) + r + for r in scored + if not any(_dominates(o["fitness"], r["fitness"]) for o in scored if o is not r) ] @@ -251,15 +268,18 @@ def _pareto_front(rows: List[Dict[str, Any]]) -> List[Dict[str, Any]]: # The loop # --------------------------------------------------------------------------- -def optimize(workflow, - spec: Optional[OptimizationSpec] = None, - results_path: str = "results/optimization", - algorithm: Optional[AlgorithmConfig] = None, - reject_fn: Optional[RejectFn] = None, - run_id: Optional[str] = None, - per_trial_results: bool = True, - stop_when_reached: Optional[bool] = None, - verbose: bool = True) -> OptimizationResult: + +def optimize( + workflow, + spec: Optional[OptimizationSpec] = None, + results_path: str = "results/optimization", + algorithm: Optional[AlgorithmConfig] = None, + reject_fn: Optional[RejectFn] = None, + run_id: Optional[str] = None, + per_trial_results: bool = True, + stop_when_reached: Optional[bool] = None, + verbose: bool = True, +) -> OptimizationResult: """Optimize a built workflow against the targets declared in its schemas. Args: @@ -307,10 +327,13 @@ def optimize(workflow, attempt += 1 ledger = Ledger(os.path.join(results_path, run_id), run_id) - ledger.write_manifest(spec, extra={ - "created_at": datetime.now().isoformat(timespec="seconds"), - "workflow_name": getattr(workflow, "name", ""), - }) + ledger.write_manifest( + spec, + extra={ + "created_at": datetime.now().isoformat(timespec="seconds"), + "workflow_name": getattr(workflow, "name", ""), + }, + ) optimizer = create_optimizer(spec.dimensions, len(spec.objectives), spec.algorithm) @@ -318,21 +341,25 @@ def say(message: str) -> None: if verbose: print(message, flush=True) - say(f"[{run_id}] {spec.algorithm.name}: " + say( + f"[{run_id}] {spec.algorithm.name}: " f"{len(spec.dimensions)} dimensions, {len(spec.objectives)} objective(s), " f"up to {spec.algorithm.max_generations} generations " - f"x {spec.algorithm.pop_size} candidates") + f"x {spec.algorithm.pop_size} candidates" + ) for line in spec.summary().splitlines(): say(" " + line) if len(spec.objectives) > 1: - say(" each objective reports how far it missed, in its own unit. To compare " + say( + " each objective reports how far it missed, in its own unit. To compare " "objectives measured in different units, that miss is also given as a " "multiple of the target range asked for: '1.4x its target range' means the " - "miss is 1.4 times as wide as the range. 0 = the target was met.") + "miss is 1.4 times as wide as the range. 0 = the target was met." + ) # Captured before the first rotation: where the baseline ran, and whatever the # nodes declared as reusable from it. - seed_root = workflow.context.get("results_path") if per_trial_results else None + seed_root = workflow.context.get("results_path") if per_trial_results else None seed_names = reusable_paths(workflow) if per_trial_results else [] if seed_root and seed_names: say(f" reusing {', '.join(seed_names)} from {seed_root}") @@ -347,25 +374,48 @@ def say(message: str) -> None: for generation in range(1, spec.algorithm.max_generations + 1): candidates = optimizer.ask() + sources = list(getattr(optimizer, "last_ask_sources", []) or []) fitnesses: List[Optional[List[float]]] = [] for index, candidate in enumerate(candidates): trial_no += 1 - trial_dir = (_point_at_trial_dir(workflow, str(ledger.run_dir), trial_no, - seed_root, seed_names) - if per_trial_results else None) - row = _evaluate(workflow, spec, candidate, reject_fn, - trial_no, generation, index, trial_dir) + trial_dir = ( + _point_at_trial_dir( + workflow, str(ledger.run_dir), trial_no, seed_root, seed_names + ) + if per_trial_results + else None + ) + row = _evaluate( + workflow, + spec, + candidate, + reject_fn, + trial_no, + generation, + index, + trial_dir, + source=sources[index] if index < len(sources) else "ask", + ) fitnesses.append(row["fitness"]) trials.append(row) ledger.append_trial(row) previous = [t for t in trials[:-1] if t["target_ranges_off"] is not None] is_best = row["target_ranges_off"] is not None and ( - not previous or row["target_ranges_off"] < min(t["target_ranges_off"] for t in previous) + not previous + or row["target_ranges_off"] + < min(t["target_ranges_off"] for t in previous) ) - say(" " + _narrate_trial(spec, row, generation, index, - spec.algorithm.pop_size, is_best)) + try: + say( + " " + + _narrate_trial( + spec, row, generation, index, spec.algorithm.pop_size, is_best + ) + ) + except Exception as exc: + say(f" (could not narrate trial #{row['trial']}: {exc})") optimizer.tell(candidates, fitnesses) @@ -377,7 +427,9 @@ def say(message: str) -> None: # minimize or maximize goal has no value that counts as arrival. bands = [i for i, o in enumerate(spec.objectives) if o.goal == "in_range"] in_range = bool( - best and bands and len(bands) == len(spec.objectives) + best + and bands + and len(bands) == len(spec.objectives) and all(best["fitness"][i] == 0.0 for i in bands) ) n_failed = sum(1 for t in trials if t["status"] == "failed") @@ -389,37 +441,55 @@ def say(message: str) -> None: stop_reason = "a candidate is inside every target band" elif in_range and not reported_reached: reported_reached = True - say(" a candidate satisfies every target; continuing to develop " - "the Pareto front") + say( + " a candidate satisfies every target; continuing to develop " + "the Pareto front" + ) command = ledger.read_control() if command: control_ack, stop_reason, paused = _apply_control( - command, optimizer, say, stop_reason, paused) + command, + optimizer, + say, + stop_reason, + paused, + workflow=workflow, + spec=spec, + ) - ledger.write_status({ - "state": "done" if stop_reason else ("paused" if paused else "running"), - "updated_at": datetime.now().isoformat(timespec="seconds"), - "generation": generation, - "max_generations": spec.algorithm.max_generations, - "n_evals": len(trials), - "n_ok": len(scored), - "n_failed": n_failed, - "n_rejected": n_rejected, - "best": best, - "pareto_front": _pareto_front(trials) if len(spec.objectives) > 1 else [], - "progress": { - "best_target_ranges_off_by_gen": best_by_generation, - "gens_since_improvement": _gens_since_improvement(best_by_generation), - }, - "control_ack": control_ack, - "stop_reason": stop_reason or None, - "message": _narrate(generation, spec, best, in_range, - n_failed, n_rejected), - }) + ledger.write_status( + { + "state": "done" if stop_reason else ("paused" if paused else "running"), + "updated_at": datetime.now().isoformat(timespec="seconds"), + "generation": generation, + "max_generations": spec.algorithm.max_generations, + "n_evals": len(trials), + "n_ok": len(scored), + "n_failed": n_failed, + "n_rejected": n_rejected, + "best": best, + "pareto_front": ( + _pareto_front(trials) if len(spec.objectives) > 1 else [] + ), + "progress": { + "best_target_ranges_off_by_gen": best_by_generation, + "gens_since_improvement": _gens_since_improvement( + best_by_generation + ), + }, + "control_ack": control_ack, + "stop_reason": stop_reason or None, + "message": _narrate( + generation, spec, best, in_range, n_failed, n_rejected + ), + } + ) - say(f" gen {generation}/{spec.algorithm.max_generations}: " - + _narrate(generation, spec, best, in_range, n_failed, n_rejected)) + say( + f" gen {generation}/{spec.algorithm.max_generations}: " + + _narrate(generation, spec, best, in_range, n_failed, n_rejected) + ) if stop_reason: break @@ -428,7 +498,14 @@ def say(message: str) -> None: command = ledger.read_control() if command: control_ack, stop_reason, paused = _apply_control( - command, optimizer, say, stop_reason, paused) + command, + optimizer, + say, + stop_reason, + paused, + workflow=workflow, + spec=spec, + ) if stop_reason: break if stop_reason: @@ -444,40 +521,49 @@ def say(message: str) -> None: # happens before the loop decides to stop, and the budget-exhausted case is # decided after the loop entirely — without this, status.json would sit at # "running" forever. - ledger.write_status({ - "state": "done", - "updated_at": datetime.now().isoformat(timespec="seconds"), - "generation": generation, - "max_generations": spec.algorithm.max_generations, - "n_evals": len(trials), - "n_ok": len(scored), - "n_failed": sum(1 for t in trials if t["status"] == "failed"), - "n_rejected": sum(1 for t in trials if t["status"] == "rejected"), - "best": best, - "pareto_front": front, - "progress": { - "best_target_ranges_off_by_gen": best_by_generation, - "gens_since_improvement": _gens_since_improvement(best_by_generation), - }, - "control_ack": control_ack, - "stop_reason": stop_reason, - "message": f"finished after {len(trials)} evaluations: {stop_reason}", - }) + ledger.write_status( + { + "state": "done", + "updated_at": datetime.now().isoformat(timespec="seconds"), + "generation": generation, + "max_generations": spec.algorithm.max_generations, + "n_evals": len(trials), + "n_ok": len(scored), + "n_failed": sum(1 for t in trials if t["status"] == "failed"), + "n_rejected": sum(1 for t in trials if t["status"] == "rejected"), + "best": best, + "pareto_front": front, + "progress": { + "best_target_ranges_off_by_gen": best_by_generation, + "gens_since_improvement": _gens_since_improvement(best_by_generation), + }, + "control_ack": control_ack, + "stop_reason": stop_reason, + "message": f"finished after {len(trials)} evaluations: {stop_reason}", + } + ) say(f"[{run_id}] stopped: {stop_reason}") if best: for objective, distance in zip(spec.objectives, best["fitness"]): unit = f" {objective.unit}" if objective.unit else "" - band = (f"target {objective.low}-{objective.high}{unit}" - if objective.goal == "in_range" else objective.goal) + band = ( + f"target {objective.low}-{objective.high}{unit}" + if objective.goal == "in_range" + else objective.goal + ) state = "in target" if distance == 0.0 else f"off {distance:.4g}{unit}" - say(f" {objective.name} = {best['measured'][objective.name]:.4g}{unit}" - f" ({band}, {state})") + say( + f" {objective.name} = {best['measured'][objective.name]:.4g}{unit}" + f" ({band}, {state})" + ) if len(spec.objectives) > 1: furthest = worst_objective(spec, best["fitness"]) if furthest and furthest[1] > 0: - say(f" furthest from target: {furthest[0]}, " - f"{furthest[1]:.3g}x its target range") + say( + f" furthest from target: {furthest[0]}, " + f"{furthest[1]:.3g}x its target range" + ) return OptimizationResult( run_id=run_id, @@ -490,9 +576,17 @@ def say(message: str) -> None: ) -def _evaluate(workflow, spec, candidate, reject_fn, - trial_no: int, generation: int, index: int, - trial_dir: Optional[str] = None) -> Dict[str, Any]: +def _evaluate( + workflow, + spec, + candidate, + reject_fn, + trial_no: int, + generation: int, + index: int, + trial_dir: Optional[str] = None, + source: str = "ask", +) -> Dict[str, Any]: """Run one candidate and produce its ledger row.""" started = time.time() row: Dict[str, Any] = { @@ -500,7 +594,7 @@ def _evaluate(workflow, spec, candidate, reject_fn, "generation": generation, "candidate": index, "started_at": datetime.now().isoformat(timespec="seconds"), - "source": "ask", + "source": source, "params": dict(candidate), "results_path": trial_dir, "measured": {}, @@ -514,6 +608,8 @@ def _evaluate(workflow, spec, candidate, reject_fn, for address, value in candidate.items(): set_parameter(workflow, address, value) + clear_output_ports(workflow) + if not workflow.execute(): row.update(status="failed", error="workflow.execute() returned False") return _finish(row, started) @@ -521,9 +617,11 @@ def _evaluate(workflow, spec, candidate, reject_fn, measured = {} for objective in spec.objectives: value = read_output(workflow, objective.measures) - if not isinstance(value, (int, float)) or isinstance(value, bool): - row.update(status="failed", - error=f"{objective.measures} is not numeric: {value!r}") + if not _is_number(value): + row.update( + status="failed", + error=f"{objective.measures} is not numeric: {value!r}", + ) return _finish(row, started) measured[objective.name] = float(value) row["measured"] = measured @@ -534,8 +632,9 @@ def _evaluate(workflow, spec, candidate, reject_fn, row.update(status="rejected", reject_reason=reason) return _finish(row, started) - row["fitness"] = [objective_fitness(o, measured[o.name]) - for o in spec.objectives] + row["fitness"] = [ + objective_fitness(o, measured[o.name]) for o in spec.objectives + ] except Exception as exc: # a bad candidate must not kill the run row.update(status="failed", error=f"{type(exc).__name__}: {exc}") @@ -552,7 +651,20 @@ def _finish(row: Dict[str, Any], started: float) -> Dict[str, Any]: return row -def _apply_control(command, optimizer, say, stop_reason: str, paused: bool): +def _complete_candidate(workflow, spec, params: Dict[str, Any]) -> Dict[str, float]: + """Fill missing dimension keys from the workflow's current parameter values.""" + complete: Dict[str, float] = {} + for dimension in spec.dimensions: + if dimension.address in params: + complete[dimension.address] = params[dimension.address] + else: + complete[dimension.address] = get_parameter(workflow, dimension.address) + return complete + + +def _apply_control( + command, optimizer, say, stop_reason: str, paused: bool, workflow=None, spec=None +): """Apply a control command and build the acknowledgement for status.json.""" name = command.get("command", "") args = command.get("args", {}) or {} @@ -567,14 +679,25 @@ def _apply_control(command, optimizer, say, stop_reason: str, paused: bool): paused, result = False, "resumed" elif name == "inject": accepted = 0 + errors = [] for params in args.get("candidates", []): try: - optimizer.enqueue(params) + complete = ( + _complete_candidate(workflow, spec, params) + if workflow is not None and spec is not None + else dict(params) + ) + optimizer.enqueue(complete) accepted += 1 except NotImplementedError: result = f"{type(optimizer).__name__} cannot inject candidates" break - result = result or f"{accepted} candidate(s) injected" + except Exception as exc: + errors.append(f"{type(exc).__name__}: {exc}") + if not result: + result = f"{accepted} candidate(s) injected" + if errors: + result += f" ({len(errors)} rejected: {errors[0]})" else: result = f"unknown command {name!r}" @@ -614,8 +737,12 @@ def _narrate_trial(spec, row, generation, index, pop_size, is_best) -> str: label = f"gen {generation}, trial {index + 1}/{pop_size} (#{row['trial']})" tried = " ".join( - f"{d.address}={row['params'][d.address]:.4g}" - f"{' ' + d.unit if d.unit else ''}" + ( + f"{d.address}={row['params'][d.address]:.4g}" + f"{' ' + d.unit if d.unit else ''}" + if d.address in row["params"] + else f"{d.address}=?" + ) for d in spec.dimensions ) @@ -629,8 +756,10 @@ def _narrate_trial(spec, row, generation, index, pop_size, is_best) -> str: for objective, distance in zip(spec.objectives, row["fitness"]): unit = f" {objective.unit}" if objective.unit else "" state = "in target" if distance == 0.0 else f"off {distance:.4g}{unit}" - got.append(f"{objective.name.split('.')[-1]}=" - f"{row['measured'][objective.name]:.4g}{unit} ({state})") + got.append( + f"{objective.name.split('.')[-1]}=" + f"{row['measured'][objective.name]:.4g}{unit} ({state})" + ) # With one objective the miss above says everything. With several, name the one # doing worst and size its miss against its own target range, the only way to @@ -639,8 +768,10 @@ def _narrate_trial(spec, row, generation, index, pop_size, is_best) -> str: if len(spec.objectives) > 1: furthest = worst_objective(spec, row["fitness"]) if furthest and furthest[1] > 0: - worst = (f"\n furthest from target: {furthest[0]}, " - f"{furthest[1]:.3g}x its target range") + worst = ( + f"\n furthest from target: {furthest[0]}, " + f"{furthest[1]:.3g}x its target range" + ) elif furthest: worst = "\n every target met" @@ -671,8 +802,11 @@ def _narrate(generation, spec, best, in_range, n_failed, n_rejected) -> str: parts = [] for objective, distance in zip(spec.objectives, best["fitness"]): unit = f" {objective.unit}" if objective.unit else "" - goal = (f"target {objective.low}-{objective.high}{unit}" - if objective.goal == "in_range" else objective.goal) + goal = ( + f"target {objective.low}-{objective.high}{unit}" + if objective.goal == "in_range" + else objective.goal + ) state = "in target" if distance == 0.0 else f"off {distance:.4g}{unit}" parts.append( f"{objective.name.split('.')[-1]}=" @@ -685,8 +819,14 @@ def _narrate(generation, spec, best, in_range, n_failed, n_rejected) -> str: # "its" on purpose: this line is about the best trial, and the objective named # is the weakest one inside that trial — not a comparison against other trials. furthest = worst_objective(spec, best["fitness"]) - state = (f" — its furthest objective from target: {furthest[0]}, " - f"{furthest[1]:.3g}x its target range") if furthest else "" + state = ( + ( + f" — its furthest objective from target: {furthest[0]}, " + f"{furthest[1]:.3g}x its target range" + ) + if furthest + else "" + ) else: state = "" extra = "" diff --git a/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/ledger.py b/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/ledger.py index 9148830f..06e25ba3 100644 --- a/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/ledger.py +++ b/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/ledger.py @@ -54,16 +54,21 @@ def write_manifest(self, spec, extra: Optional[Dict[str, Any]] = None) -> None: def append_trial(self, trial: Dict[str, Any]) -> None: with open(self.trials_path, "a") as fh: - fh.write(json.dumps({"schema_version": SCHEMA_VERSION, **trial}, - default=str) + "\n") + fh.write( + json.dumps({"schema_version": SCHEMA_VERSION, **trial}, default=str) + + "\n" + ) fh.flush() def write_status(self, status: Dict[str, Any]) -> None: - _write_atomic(self.status_path, { - "schema_version": SCHEMA_VERSION, - "run_id": self.run_id, - **status, - }) + _write_atomic( + self.status_path, + { + "schema_version": SCHEMA_VERSION, + "run_id": self.run_id, + **status, + }, + ) # -- reads ----------------------------------------------------------- def read_trials(self) -> List[Dict[str, Any]]: diff --git a/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/optimizers.py b/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/optimizers.py index b81649b3..1db97b26 100644 --- a/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/optimizers.py +++ b/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/optimizers.py @@ -28,8 +28,12 @@ class Optimizer(ABC): #: Can this backend handle more than one objective at a time? supports_multi_objective: bool = False - def __init__(self, dimensions: Sequence[Dimension], n_objectives: int, - config: AlgorithmConfig): + def __init__( + self, + dimensions: Sequence[Dimension], + n_objectives: int, + config: AlgorithmConfig, + ): if n_objectives > 1 and not self.supports_multi_objective: raise ValueError( f"{type(self).__name__} is single-objective but the spec declares " @@ -40,14 +44,16 @@ def __init__(self, dimensions: Sequence[Dimension], n_objectives: int, self.dimensions = list(dimensions) self.n_objectives = n_objectives self.config = config + self.last_ask_sources: List[str] = [] @abstractmethod def ask(self) -> List[Dict[str, float]]: """Propose the next generation as a list of {address: value} dicts.""" @abstractmethod - def tell(self, candidates: List[Dict[str, float]], - fitnesses: List[List[float]]) -> None: + def tell( + self, candidates: List[Dict[str, float]], fitnesses: List[List[float]] + ) -> None: """Report the measured fitness of each candidate from the last ``ask``.""" def enqueue(self, params: Dict[str, float]) -> None: @@ -76,8 +82,9 @@ def available() -> List[str]: return sorted(_REGISTRY) -def create_optimizer(dimensions: Sequence[Dimension], n_objectives: int, - config: AlgorithmConfig) -> Optimizer: +def create_optimizer( + dimensions: Sequence[Dimension], n_objectives: int, config: AlgorithmConfig +) -> Optimizer: if config.name not in _REGISTRY: raise ValueError( f"Unknown algorithm {config.name!r}. Available: {', '.join(available())}" @@ -89,6 +96,7 @@ def create_optimizer(dimensions: Sequence[Dimension], n_objectives: int, # RandomSearch — no dependencies, so the engine is always runnable # --------------------------------------------------------------------------- + class RandomSearch(Optimizer): """Uniform sampling inside the bounds. A baseline, and the smoke test.""" @@ -101,11 +109,16 @@ def __init__(self, dimensions, n_objectives, config): def ask(self) -> List[Dict[str, float]]: out: List[Dict[str, float]] = [] + sources: List[str] = [] while self._queued and len(out) < self.config.pop_size: out.append(self._queued.pop(0)) + sources.append("inject") while len(out) < self.config.pop_size: - out.append({d.address: self._rng.uniform(d.low, d.high) - for d in self.dimensions}) + out.append( + {d.address: self._rng.uniform(d.low, d.high) for d in self.dimensions} + ) + sources.append("ask") + self.last_ask_sources = sources return out def tell(self, candidates, fitnesses) -> None: @@ -132,6 +145,28 @@ def enqueue(self, params: Dict[str, float]) -> None: } +def sampler_init_kwargs( + sampler_name: str, + config: AlgorithmConfig, + sampler_kwargs: Optional[Dict[str, Any]] = None, +) -> Dict[str, Any]: + """Keyword arguments passed to the Optuna sampler constructor. + + NSGA-II/III take ``population_size``; CMA-ES takes ``popsize``. Passing the + wrong name is silently ignored, so CMA-ES would otherwise run at Optuna's + default population (~4+3*ln(n)) and throw away the rest of each generation. + """ + kwargs = dict(sampler_kwargs or {}) + kwargs.update(config.options) + if config.seed is not None: + kwargs.setdefault("seed", config.seed) + if sampler_name.startswith("NSGA"): + kwargs.setdefault("population_size", config.pop_size) + elif sampler_name == "CmaEsSampler": + kwargs.setdefault("popsize", config.pop_size) + return kwargs + + class OptunaOptimizer(Optimizer): """Adapter over Optuna's ask/tell API. @@ -140,8 +175,15 @@ class OptunaOptimizer(Optimizer): generations internally, so this stays correct for them too. """ - def __init__(self, dimensions, n_objectives, config, sampler_name: str, - multi_objective: bool, sampler_kwargs: Dict[str, Any]): + def __init__( + self, + dimensions, + n_objectives, + config, + sampler_name: str, + multi_objective: bool, + sampler_kwargs: Dict[str, Any], + ): self.supports_multi_objective = multi_objective super().__init__(dimensions, n_objectives, config) @@ -151,7 +193,7 @@ def __init__(self, dimensions, n_objectives, config, sampler_name: str, except ImportError as exc: # pragma: no cover - depends on environment raise ImportError( f"The {config.name!r} algorithm needs Optuna. " - f"Install it with: pip install optuna cmaes" + f'Install it with: pip install -e ".[optimization]"' ) from exc optuna.logging.set_verbosity(optuna.logging.WARNING) @@ -163,12 +205,7 @@ def __init__(self, dimensions, n_objectives, config, sampler_name: str, f"(needed for algorithm {config.name!r})" ) - kwargs = dict(sampler_kwargs) - kwargs.update(config.options) - if config.seed is not None: - kwargs.setdefault("seed", config.seed) - if sampler_name.startswith("NSGA"): - kwargs.setdefault("population_size", config.pop_size) + kwargs = sampler_init_kwargs(sampler_name, config, sampler_kwargs) self._optuna = optuna self._distributions = { @@ -179,10 +216,20 @@ def __init__(self, dimensions, n_objectives, config, sampler_name: str, sampler=sampler_cls(**kwargs), ) self._pending: List[Any] = [] + self._inject_remaining = 0 def ask(self) -> List[Dict[str, float]]: - self._pending = [self._study.ask(self._distributions) - for _ in range(self.config.pop_size)] + self._pending = [ + self._study.ask(self._distributions) for _ in range(self.config.pop_size) + ] + sources = [] + for _ in self._pending: + if self._inject_remaining > 0: + sources.append("inject") + self._inject_remaining -= 1 + else: + sources.append("ask") + self.last_ask_sources = sources return [dict(t.params) for t in self._pending] def tell(self, candidates, fitnesses) -> None: @@ -195,12 +242,15 @@ def tell(self, candidates, fitnesses) -> None: def enqueue(self, params: Dict[str, float]) -> None: self._study.enqueue_trial(dict(params), skip_if_exists=False) + self._inject_remaining += 1 def _make_optuna_factory(sampler_name: str, multi: bool, kwargs: Dict[str, Any]): def factory(dimensions, n_objectives, config): - return OptunaOptimizer(dimensions, n_objectives, config, - sampler_name, multi, kwargs) + return OptunaOptimizer( + dimensions, n_objectives, config, sampler_name, multi, kwargs + ) + return factory diff --git a/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/spec.py b/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/spec.py index 4ca54860..4e124bb1 100644 --- a/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/spec.py +++ b/gui/workflow_backend/django-project/codes/neuroworkflow/optimization/spec.py @@ -6,7 +6,7 @@ the algorithm, widen a range or retarget a band without touching code. """ -from dataclasses import dataclass, field, asdict +from dataclasses import asdict, dataclass, field from typing import Any, Dict, List, Optional from neuroworkflow.core.schema import ParameterDefinition @@ -18,24 +18,24 @@ class Dimension: """One axis of the search space.""" - address: str # "Model.nest_params.C_m" + address: str # "Model.nest_params.C_m" low: float high: float unit: str = "" description: str = "" - source: str = "" # where the range came from - note: str = "" # e.g. why it was clipped + source: str = "" # where the range came from + note: str = "" # e.g. why it was clipped @dataclass class Objective: """One target the search is steering toward.""" - name: str # "Population_exc.target_rate_hz" - measures: str # "Analysis.firing_rate_hz.exc" + name: str # "Population_exc.target_rate_hz" + measures: str # "Analysis.firing_rate_hz.exc" low: Optional[float] = None # target band, for goal="in_range" high: Optional[float] = None - goal: str = "in_range" # in_range | minimize | maximize + goal: str = "in_range" # in_range | minimize | maximize unit: str = "" description: str = "" source: str = "" @@ -45,7 +45,7 @@ class Objective: class AlgorithmConfig: """Which optimizer to run and how. Editable by a human or an agent.""" - name: str = "random" # see optimizers.available() + name: str = "random" # see optimizers.available() pop_size: int = 16 max_generations: int = 20 seed: Optional[int] = None @@ -102,10 +102,16 @@ def validate(self) -> None: f"(set objective_range on the parameter)" ) - def add_objective(self, name: str, measures: str, - low: Optional[float] = None, high: Optional[float] = None, - goal: str = "in_range", unit: str = "", - description: str = "") -> "OptimizationSpec": + def add_objective( + self, + name: str, + measures: str, + low: Optional[float] = None, + high: Optional[float] = None, + goal: str = "in_range", + unit: str = "", + description: str = "", + ) -> "OptimizationSpec": """Declare a target that no node parameter carries. An objective is a label, a measurement address and a band — nothing about it @@ -134,10 +140,18 @@ def add_objective(self, name: str, measures: str, f"On {node!r}: {', '.join(near)}" ) - self.objectives.append(Objective( - name=name, measures=measures, low=low, high=high, - goal=goal, unit=unit, description=description, source="study", - )) + self.objectives.append( + Objective( + name=name, + measures=measures, + low=low, + high=high, + goal=goal, + unit=unit, + description=description, + source="study", + ) + ) return self def summary(self) -> str: @@ -153,9 +167,7 @@ def summary(self) -> str: lines.append(f" {d.address:<40} [{d.low}, {d.high}]{unit}{note}") lines.append(f"objectives: {len(self.objectives)}") for o in self.objectives: - band = ( - f"in [{o.low}, {o.high}]" if o.goal == "in_range" else o.goal - ) + band = f"in [{o.low}, {o.high}]" if o.goal == "in_range" else o.goal unit = f" {o.unit}" if o.unit else "" lines.append(f" {o.name:<40} {band}{unit} <- {o.measures}") if self.skipped: @@ -169,6 +181,7 @@ def summary(self) -> str: # Building a spec from the node schemas # --------------------------------------------------------------------------- + def _numeric_pair(value: Any) -> Optional[List[float]]: if isinstance(value, (list, tuple)) and len(value) == 2: if all(isinstance(v, (int, float)) and not isinstance(v, bool) for v in value): @@ -209,31 +222,42 @@ def collect_dimensions(workflow) -> tuple: key_address = f"{address}.{key}" rng = _numeric_pair(pair) if rng is None: - skipped.append({ - "address": key_address, - "reason": f"range is not [min, max]: {pair}", - }) + skipped.append( + { + "address": key_address, + "reason": f"range is not [min, max]: {pair}", + } + ) continue if isinstance(value, dict) and key not in value: - skipped.append({ - "address": key_address, - "reason": "key is not present in the parameter's " - "current value — configure() it first", - }) + skipped.append( + { + "address": key_address, + "reason": "key is not present in the parameter's " + "current value — configure() it first", + } + ) continue - dimensions.append(Dimension( - address=key_address, low=rng[0], high=rng[1], - unit=pdef.unit, description=pdef.description, - source="schema.optimization_range", - )) + dimensions.append( + Dimension( + address=key_address, + low=rng[0], + high=rng[1], + unit=pdef.unit, + description=pdef.description, + source="schema.optimization_range", + ) + ) continue if isinstance(value, dict): - skipped.append({ - "address": address, - "reason": "dict parameter with no per-key optimization_range — " - 'declare one, e.g. {"V_th": [-60.0, -45.0]}', - }) + skipped.append( + { + "address": address, + "reason": "dict parameter with no per-key optimization_range — " + 'declare one, e.g. {"V_th": [-60.0, -45.0]}', + } + ) continue c_min = pdef.constraints.get("min") @@ -245,11 +269,13 @@ def collect_dimensions(workflow) -> tuple: if isinstance(c_min, (int, float)) and isinstance(c_max, (int, float)): rng, source = [float(c_min), float(c_max)], "schema.constraints" else: - skipped.append({ - "address": address, - "reason": "optimizable but no optimization_range and no " - "min/max constraints to fall back on", - }) + skipped.append( + { + "address": address, + "reason": "optimizable but no optimization_range and no " + "min/max constraints to fall back on", + } + ) continue # Constraints are the authority: a range reaching past them describes @@ -266,17 +292,25 @@ def collect_dimensions(workflow) -> tuple: source, note = "clipped", "; ".join(clipped) + " (constraints)" if low >= high: - skipped.append({ - "address": address, - "reason": f"empty range after clipping to constraints: [{low}, {high}]", - }) + skipped.append( + { + "address": address, + "reason": f"empty range after clipping to constraints: [{low}, {high}]", + } + ) continue - dimensions.append(Dimension( - address=address, low=low, high=high, - unit=pdef.unit, description=pdef.description, - source=source, note=note, - )) + dimensions.append( + Dimension( + address=address, + low=low, + high=high, + unit=pdef.unit, + description=pdef.description, + source=source, + note=note, + ) + ) return dimensions, skipped @@ -302,50 +336,64 @@ def collect_objectives(workflow, measurables: Dict[str, float]) -> tuple: name = f"{node_name}.{pname}" if not pdef.measures: - skipped.append({ - "address": name, - "reason": "is_objective=True but no measures address — set it to " - "the output that holds the measured value", - }) + skipped.append( + { + "address": name, + "reason": "is_objective=True but no measures address — set it to " + "the output that holds the measured value", + } + ) continue if pdef.measures not in measurables: - near = [m for m in measurables if m.startswith(pdef.measures.split(".")[0])] - skipped.append({ - "address": name, - "reason": f"measures {pdef.measures!r} did not resolve to a number " - f"in the baseline run" - + (f" (available on that node: {', '.join(sorted(near)[:6])})" - if near else ""), - }) + near = [ + m for m in measurables if m.startswith(pdef.measures.split(".")[0]) + ] + skipped.append( + { + "address": name, + "reason": f"measures {pdef.measures!r} did not resolve to a number " + f"in the baseline run" + + ( + f" (available on that node: {', '.join(sorted(near)[:6])})" + if near + else "" + ), + } + ) continue band = _numeric_pair(pdef.objective_range) if band is None: - skipped.append({ - "address": name, - "reason": "is_objective=True but objective_range is not [min, max]", - }) + skipped.append( + { + "address": name, + "reason": "is_objective=True but objective_range is not [min, max]", + } + ) continue # The schema can only express a target band. minimize/maximize are set # by editing the spec, which is also where an agent would change them. - objectives.append(Objective( - name=name, - measures=pdef.measures, - low=band[0], - high=band[1], - goal="in_range", - unit=pdef.unit, - description=pdef.description, - source="schema.objective_range", - )) + objectives.append( + Objective( + name=name, + measures=pdef.measures, + low=band[0], + high=band[1], + goal="in_range", + unit=pdef.unit, + description=pdef.description, + source="schema.objective_range", + ) + ) return objectives, skipped -def build_spec(workflow, algorithm: Optional[AlgorithmConfig] = None, - run_baseline: bool = True) -> OptimizationSpec: +def build_spec( + workflow, algorithm: Optional[AlgorithmConfig] = None, run_baseline: bool = True +) -> OptimizationSpec: """Introspect a built workflow and produce a spec ready for review. With ``run_baseline=True`` the workflow is executed once at its current @@ -373,10 +421,10 @@ def build_spec(workflow, algorithm: Optional[AlgorithmConfig] = None, objectives, skipped_objs = collect_objectives(workflow, measurables) if baseline: - baseline["params"] = {d.address: _read_param(workflow, d.address) - for d in dimensions} - baseline["measured"] = {o.name: measurables.get(o.measures) - for o in objectives} + baseline["params"] = { + d.address: _read_param(workflow, d.address) for d in dimensions + } + baseline["measured"] = {o.name: measurables.get(o.measures) for o in objectives} return OptimizationSpec( dimensions=dimensions, @@ -389,6 +437,7 @@ def build_spec(workflow, algorithm: Optional[AlgorithmConfig] = None, def _read_param(workflow, address: str) -> Any: from .addressing import split_address + node_name, param, keys = split_address(address) value = workflow.nodes[node_name]._parameters[param] for k in keys: diff --git a/gui/workflow_backend/django-project/codes/nodes/network/NW_Connectivity.py b/gui/workflow_backend/django-project/codes/nodes/network/NW_Connectivity.py index f5e5dc9b..8f69dafd 100644 --- a/gui/workflow_backend/django-project/codes/nodes/network/NW_Connectivity.py +++ b/gui/workflow_backend/django-project/codes/nodes/network/NW_Connectivity.py @@ -211,13 +211,14 @@ def _coerce_connection_rule(value): - an int (e.g. 1, 3) -> passed through - a real callable (notebook lambda) -> passed through - a numeric string ("3") -> int - - a lambda string ("lambda src, tgt: ...") -> eval'd to a callable + - a lambda string ("lambda src, tgt: ...") -> compiled to a callable The last case is the GUI path: a lambda cannot be JSON-encoded, and the code generator only un-quotes a lambda at the TOP LEVEL of configure(), not one nested inside the `connections` list. So a per-connection rule - reaches here as a string and must be evaluated. numpy is available as - `np` for rules that use np.random / np.exp etc. + reaches here as a string. Only a single lambda expression is accepted — + not an arbitrary statement or ``eval`` payload. numpy is available as + ``np`` for rules that use np.random / np.exp etc. """ if callable(value) or isinstance(value, (int, bool)): return value @@ -225,8 +226,36 @@ def _coerce_connection_rule(value): s = value.strip() if s.lstrip("+-").isdigit(): return int(s) + import ast import numpy as np - fn = eval(s, {"np": np, "__builtins__": __builtins__}) + try: + tree = ast.parse(s, mode="eval") + except SyntaxError as exc: + raise ValueError( + f"connection_rule string is not valid Python: {value!r}" + ) from exc + if not isinstance(tree.body, ast.Lambda): + raise ValueError( + "connection_rule strings must be a lambda expression " + f"(e.g. 'lambda src, tgt: 1'); got {value!r}" + ) + safe_builtins = { + "True": True, + "False": False, + "None": None, + "abs": abs, + "min": min, + "max": max, + "round": round, + "int": int, + "float": float, + "len": len, + "range": range, + } + fn = eval( + compile(tree, "", "eval"), + {"__builtins__": safe_builtins, "np": np}, + ) if not callable(fn): raise ValueError( f"connection_rule string did not evaluate to a callable: {value!r}" diff --git a/gui/workflow_backend/django-project/codes/nodes/optimization/NW_Optimization.py b/gui/workflow_backend/django-project/codes/nodes/optimization/NW_Optimization.py index 39ba4ac4..af9df082 100644 --- a/gui/workflow_backend/django-project/codes/nodes/optimization/NW_Optimization.py +++ b/gui/workflow_backend/django-project/codes/nodes/optimization/NW_Optimization.py @@ -25,7 +25,7 @@ class NW_Optimization(Node): Typical use, once the workflow is built:: opt = NW_Optimization("opt") - opt.configure(algorithm="cmaes", pop_size=16, max_generations=12) + opt.configure(algorithm="random", pop_size=16, max_generations=12) spec = build_spec(workflow, opt.algorithm_config()) result = optimize(workflow, spec=spec, results_path=opt.results_path()) @@ -44,13 +44,15 @@ class NW_Optimization(Node): ), parameters={ "algorithm": ParameterDefinition( - default_value="cmaes", + default_value="random", description=( - "Search algorithm. 'cmaes' is the default for a single objective and " - "continuous parameters; 'tpe' when each trial is expensive; 'nsga2' or " - "'nsga3' for several objectives, returning a Pareto front; 'random' as " - "a dependency-free baseline. Everything except 'random' needs Optuna " - "(pip install optuna cmaes)." + "Search algorithm. 'random' is the default and needs no extra " + "packages. 'cmaes' is a good default for a single objective and " + "continuous parameters once Optuna is installed; 'tpe' when each " + "trial is expensive; 'nsga2' or 'nsga3' for several objectives, " + "returning a Pareto front. Everything except 'random' needs " + "pip install -e \".[optimization]\" (optuna + cmaes). The nest " + "kernel image does not yet include those packages." ), constraints={"allowed_values": ["random", "cmaes", "tpe", "nsga2", "nsga3", "optuna_random"]}, @@ -67,8 +69,9 @@ class NW_Optimization(Node): default_value=20, description=( "Generation budget. At most pop_size x max_generations runs, plus one " - "baseline; the search stops earlier once a candidate lands inside every " - "target band." + "baseline. For a single in_range objective the search also stops once a " + "candidate lands inside the target band; with several objectives it keeps " + "going to develop the Pareto front (stop_when_reached defaults to False)." ), constraints={"min": 1}, ), diff --git a/gui/workflow_backend/django-project/codes/nodes/simulation/NW_SimConfig.py b/gui/workflow_backend/django-project/codes/nodes/simulation/NW_SimConfig.py index ad6c892e..33913cb5 100644 --- a/gui/workflow_backend/django-project/codes/nodes/simulation/NW_SimConfig.py +++ b/gui/workflow_backend/django-project/codes/nodes/simulation/NW_SimConfig.py @@ -97,7 +97,13 @@ class NW_SimConfig(Node): ), "overwrite": ParameterDefinition( default_value=True, - description="Overwrite existing config files and network files.", + description=( + "Overwrite existing config files. SONATA network files follow " + "rebuild_network: with 'auto' (the default), an unchanged signature " + "reuses the network on disk, so a random connection_rule is frozen " + "after the first build. Use rebuild_network='always' to draw a " + "new realisation each run." + ), ), "rebuild_network": ParameterDefinition( default_value="auto", @@ -106,8 +112,9 @@ class NW_SimConfig(Node): "a structural parameter changed (population size, neuron model, " "connectivity, synaptic weights) or the files are missing — values that " "are read at simulation time (nest_params, synapse dynamics_params_dict) " - "never trigger a rebuild. 'always' rebuilds every run. 'never' reuses " - "whatever is on disk." + "never trigger a rebuild. A random connection_rule is therefore frozen " + "after the first successful build. 'always' rebuilds every run. " + "'never' reuses whatever is on disk." ), constraints={"allowed_values": ["auto", "always", "never"]}, ), @@ -169,25 +176,43 @@ def _stable(value): """ if callable(value): import inspect + if hasattr(value, "func") and hasattr(value, "args"): + # functools.partial and similar wrappers have no __code__. + return ( + "partial:" + f"{NW_SimConfig._stable(value.func)}:" + f"{NW_SimConfig._stable(getattr(value, 'args', ()))}:" + f"{NW_SimConfig._stable(getattr(value, 'keywords', {}) or {})}" + ) + code = getattr(value, "__code__", None) try: text = inspect.getsource(value).strip() except (OSError, TypeError): - text = value.__code__.co_code.hex() + repr(value.__code__.co_consts) + if code is not None: + text = code.co_code.hex() + repr(code.co_consts) + else: + text = repr(value) # Values the rule reads but does not show in its source. A lambda written # in a notebook usually reads them as globals (`eps`), not as closure # cells, so both are captured — otherwise changing eps would leave the # signature identical and silently reuse a network built with the old value. referenced = [] - for cell in (value.__closure__ or []): + for cell in (getattr(value, "__closure__", None) or []): try: referenced.append(repr(cell.cell_contents)) except ValueError: referenced.append("") - simple = (int, float, str, bool, type(None)) - for name in sorted(value.__code__.co_names): - if name in value.__globals__: - referenced_value = value.__globals__[name] - if isinstance(referenced_value, simple): + if code is not None: + globs = getattr(value, "__globals__", {}) or {} + for name in sorted(code.co_names): + if name not in globs: + continue + referenced_value = globs[name] + if isinstance( + referenced_value, (int, float, str, bool, type(None), dict, list, tuple) + ): + referenced.append(f"{name}={referenced_value!r}") + elif hasattr(referenced_value, "tolist"): referenced.append(f"{name}={referenced_value!r}") return f"callable:{text}:{referenced}" if isinstance(value, dict): diff --git a/notebooks/01_Basic_Simulation.ipynb b/notebooks/01_Basic_Simulation.ipynb index 1180e840..f7c10d9d 100644 --- a/notebooks/01_Basic_Simulation.ipynb +++ b/notebooks/01_Basic_Simulation.ipynb @@ -18,31 +18,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " -- N E S T --\n", - " Copyright (C) 2004 The NEST Initiative\n", - "\n", - " Version: 3.9.0\n", - " Built: Oct 2 2025 07:08:06\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" - ] - } - ], + "outputs": [], "source": [ "import sys\n", "import os\n", @@ -74,34 +52,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Node: SonataNetworkBuilder (network_builder)\n", - "Description: Loads SONATA configuration and builds a network in NEST\n", - "Parameters:\n", - " sonata_path: ../data/300_pointneurons\n", - " net_config_file: circuit_config.json\n", - " sim_config_file: simulation_config.json\n", - " hdf5_hyperslab_size: 1024\n", - "Output Ports:\n", - " sonata_net (object, not connected): SONATA network object\n", - " node_collections (dict, not connected): NEST node collections\n", - "Process Steps:\n", - " initialize_environment: Initialize NEST environment\n", - " Outputs: environment_initialized\n", - " initialize_sonata: Initialize SONATA network\n", - " Outputs: sonata_net\n", - " build_network: Build network in NEST\n", - " Inputs: sonata_net\n", - " Outputs: node_collections\n" - ] - } - ], + "outputs": [], "source": [ "# Create a network builder node\n", "build_network = BuildSonataNetworkNode(\"SonataNetworkBuilder\")\n", @@ -120,35 +73,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Node: SonataNetworkSimulation (simulation_node)\n", - "Description: Simulates a NEST network built from SONATA\n", - "Parameters:\n", - " simulation_time: 1000.0\n", - " record_from_population: internal\n", - " record_n_neurons: 40\n", - "Input Ports:\n", - " sonata_net (object, required, not connected): SONATA network object\n", - " node_collections (dict, required, not connected): NEST node collections\n", - "Output Ports:\n", - " simulation_completed (bool, not connected): Whether simulation completed successfully\n", - " spike_recorder (object, not connected): NEST spike recorder device\n", - "Process Steps:\n", - " initialize_recordables: Setup spike recorders\n", - " Inputs: node_collections\n", - " Outputs: spike_recorder\n", - " simulate_sonata: Run simulation\n", - " Inputs: sonata_net, node_collections, spike_recorder\n", - " Outputs: simulation_completed\n" - ] - } - ], + "outputs": [], "source": [ "# Create a simulation node\n", "simulate_network = SimulateSonataNetworkNode(\"SonataNetworkSimulation\")\n", @@ -175,23 +102,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Workflow: neural_simulation\n", - "Nodes:\n", - " SonataNetworkBuilder\n", - " SonataNetworkSimulation\n", - "Connections:\n", - " SonataNetworkBuilder.sonata_net -> SonataNetworkSimulation.sonata_net\n", - " SonataNetworkBuilder.node_collections -> SonataNetworkSimulation.node_collections\n" - ] - } - ], + "outputs": [], "source": [ "# Create a workflow builder\n", "workflow_builder = WorkflowBuilder(\"neural_simulation\")\n", @@ -231,44 +144,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing workflow...\n", - "Executing node: SonataNetworkBuilder\n", - "Initializing NEST environment\n", - "Initializing SONATA network from ../data/300_pointneurons\n", - "Building network using hdf5_hyperslab_size = 1024\n", - "Executing node: SonataNetworkSimulation\n", - "Creating spike recorder\n", - "SONATA network simulation for 1000.0 ms\n", - "Running NEST simulation for 1000.0 ms...\n", - "Simulation completed in 0.21 seconds\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Workflow execution completed successfully!\n" - ] - } - ], + "outputs": [], "source": [ "# Execute the workflow\n", "print(\"Executing workflow...\")\n", @@ -291,40 +169,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Spike Recorder Information:\n", - "\n", - "Recorded 478 spikes\n", - "From 38 unique neurons\n", - "Neuron IDs: [25 18 29 7 40 14 23 24 35 16 22 28 32 1 3 21 37 13 20 40 19 29 33 6\n", - " 18 4 12 23 28 7 8 14 25 17 31 36 27 26 1 35 6 10 18 24 37 13 14 22\n", - " 23 29 32 4 8 16 25 40 2 12 15 39 34 19 33 17 36 31 14 38 18 21 23 11\n", - " 25 20 1 6 35 16 40 7 34 3 13 29 37 24 28 8 10 17 18 19 27 32 33 23\n", - " 6 12 14 25 26 1 21 29 35 40 31 38 15 25 22 37 12 16 23 18 14 17 33 8\n", - " 20 40 6 21 31 19 25 29 35 38 28 13 18 14 1 16 7 29 37 3 25 26 8 12\n", - " 17 23 33 6 32 34 40 4 21 22 24 31 5 14 18 29 15 13 35 2 17 10 14 25\n", - " 1 12 33 8 21 18 4 26 7 29 3 6 23 27 16 22 31 34 19 35 25 1 28 13\n", - " 18 4 14 29 22 17 12 33 15 25 40 6 21 8 16 29 32 1 38 26 23 31 14 24\n", - " 3 37 18 10 22 28 34 25 29 35 11 33 40 17 21 16 6 7 13 18 20 4 14 1\n", - " 25 35 12 18 23 24 29 16 26 38 17 19 33 36 8 31 3 40 21 34 37 13 14 6\n", - " 22 32 35 18 25 23 27 4 29 21 19 7 16 12 40 37 31 22 6 18 38 25 33 3\n", - " 20 21 1 13 29 36 14 23 16 17 10 6 4 25 7 18 22 12 32 27 14 29 35 33\n", - " 40 3 24 37 11 6 23 8 16 25 34 1 17 19 31 32 26 10 12 14 18 23 36 40\n", - " 8 13 15 27 28 29 6 24 25 37 21 33 38 2 5 7 25 22 1 16 32 23 29 14\n", - " 33 18 21 3 25 40 6 38 31 37 19 27 34 8 26 4 35 13 28 23 7 17 22 18\n", - " 21 25 15 33 40 6 14 1 11 29 3 28 18 16 31 12 8 4 22 25 21 35 19 34\n", - " 16 17 23 29 33 11 12 1 6 7 18 2 14 15 32 24 28 37 13 3 25 22 31 35\n", - " 7 40 8 20 29 32 36 14 16 6 17 21 34 4 33 18 23 19 25 22 8 38 12 15\n", - " 27 28 31 29 14 26 25 18 40 33 13 16 1 32 21 35 3 7 19 23 34 11]\n" - ] - } - ], + "outputs": [], "source": [ "# Get the spike recorder from the simulation node\n", "spike_recorder = simulate_network.get_output_port(\"spike_recorder\").value\n", @@ -349,17 +196,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "NetworkX not installed. Install with: pip install networkx\n" - ] - } - ], + "outputs": [], "source": [ "try:\n", " import networkx as nx\n", diff --git a/notebooks/NW_BalancedNetwork_PointNeuron.ipynb b/notebooks/NW_BalancedNetwork_PointNeuron.ipynb index 3411cd64..0554796f 100644 --- a/notebooks/NW_BalancedNetwork_PointNeuron.ipynb +++ b/notebooks/NW_BalancedNetwork_PointNeuron.ipynb @@ -29,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "a0000002", "metadata": {}, "outputs": [], @@ -51,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "a0000004", "metadata": {}, "outputs": [], @@ -83,21 +83,10 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "a0000006", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "import numpy as np\n", "\n", @@ -186,225 +175,10 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "a0000008", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: PopInh\n", - "Executing node: PopExc\n", - "Executing node: Connectivity\n", - "Executing node: SimConfig\n", - "[NW_SimConfig] network unchanged, reusing ./results/balanced/network\n", - "\n", - " -- N E S T --\n", - " Copyright (C) 2004 The NEST Initiative\n", - "\n", - " Version: 3.7.0\n", - " Built: Mar 4 2025 17:27:39\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", - "2026-09-07 00:17:16,875 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:16,883 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:16,886 [INFO] Batch processing nodes for inh/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for inh/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:16,900 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:16,901 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:16,904 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:16,909 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:16,924 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:17,340 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:17,472 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: Analysis\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Workflow completed successfully\n" - ] - } - ], + "outputs": [], "source": [ "wf = WorkflowBuilder(\"NW_BalancedNetwork\")\n", "\n", @@ -436,25 +210,10 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "a0000010", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Output validation:\n", - " PopExc.population: OK\n", - " PopInh.population: OK\n", - " Connectivity.network: OK\n", - " SimConfig.results: OK\n", - " Analysis.figures: OK\n", - " Analysis.firing_rate_hz: OK\n", - " Analysis.isi_stats: OK\n" - ] - } - ], + "outputs": [], "source": [ "print(\"Output validation:\")\n", "for node_name, node in workflow.nodes.items():\n", @@ -477,210 +236,10 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "a0000012", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: PopInh\n", - "Executing node: PopExc\n", - "Executing node: Connectivity\n", - "Executing node: SimConfig\n", - "[NW_SimConfig] network unchanged, reusing ./results/balanced_g6/network\n", - "2026-09-07 00:17:24,027 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:24,035 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:24,040 [INFO] Batch processing nodes for inh/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for inh/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:24,054 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:24,056 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:24,058 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:24,064 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:24,080 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:24,496 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:24,627 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: Analysis\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAHHCAYAAABeLEexAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAYKtJREFUeJztnQt8VcW1/1d4PxMUKQkKitoqPhBFlAC1vipVS/FCra8qWp8U5WVLE6ui9mKovUXUAmpVsFfUihUtVvAqYPzbIkhQEbSIiJAaHlpJUCSgsP+fGe85NwnnMTN7Xnvv3/fzOSTZM7NmzZrHGfZee01BEAQBAQAAAAAkmGauFQAAAAAAcA02RAAAAABIPNgQAQAAACDxYEMEAAAAgMSDDREAAAAAEg82RAAAAABIPNgQAQAAACDxYEMEAAAAgMSDDREAAAAAEg82RAAAAABIPNgQAQAAACDxYEMEAAAAgMSDDREAAAAAEg82RAAA7/j444/pZz/7GXXt2pVat25NRx99ND3yyCM8befOnXTkkUfyD/s9xWeffUYlJSU0YMAA2rNnT/r6/Pnz6Xvf+x517NiRCgsLqV+/fvT44487aRcAwF+wIQIAeMWWLVuof//+9PLLL9P1119P99xzDx1++OF05ZVX0tSpU6lt27b06KOP0gcffEC//vWv0+VGjRpFdXV1NGvWLGrevDm/xn4/99xz+WapvLycJk+eTH369KEFCxY4bCEAwEcKgiAIXCsBAAAprrrqKnrhhRfonXfeoc6dO6evX3TRRfxuz6ZNm/im6KabbqLf/va39Morr/BN1Pnnn883TGPGjOH52eaoe/fudNRRR/E8bdq0Sctiy15BQYGT9gEA/AQbIgCAN7DlaP/996ef/OQnNGnSpEZpzz//PF1xxRX02muv0cCBA2n37t104okn0hdffME/bOOzePHi9Ebn6aef5pukuXPn0nnnneeoRQCAqNDCtQIAAJDik08+odraWnrwwQf5JxNbt27lP1u1asX9iphPELv7M3PmzEZ3fdatW8d/HnPMMZa0BwBEGWyIAADesHfvXv7zpz/9KY0YMSJjnt69e6d/f/HFF/nP+vp6Wrt2LfXs2dOSpgCAuIENEQDAG7p06cLfBmNviZ155pk5865cuZLuuOMO/hjtrbfe4r5HzO+oqKiIpx922GH856pVq7hTNgAA5AI+RAAAr2AbHPZafFVV1T6Pu9gjNbZp+uqrr+jkk0+mbdu28Y3R+vXr+aOzSy65JP16/vbt2+mggw6iXr16UWVlJZyqAQA5wYYIAOAV7I0xttlhm5+rr76aO0uz1+ZXrFjBX8Vnv0+cOJF+85vf0MKFC+m0007j5ZgT9s0330x/+9vf6JxzzuHXHn74YX7niG2sLr74Ytpvv/3o7bffpi+//JK/ug8AACmwIQIAeAdznGaPw/7617/S5s2b+ev3LDjjBRdcQH379uUbppEjR9K9996bLsMes5WWlvKgjqtXr6ZOnTrx6/PmzePxh958801q2bIlD+g4btw4uvDCCx22EADgG9gQAQAAACDxIFI1AAAAABIPNkQAAAAASDzYEAEAAAAg8TjdEDEnyFtuuYUHU2NnE7G4IezNkYZuTez3W2+9lZ9izfKw2CQsABsAAAAAQCw2ROxgxhkzZtAf/vAHeu+99/jfd911F913333pPOxv9ibJ/fffT0uXLqX27dvT4MGDeWRaAAAAAIDIv2X2wx/+kLp27cpjhaQYPnw4vxP02GOP8btD3bp1oxtvvJF+8YtfpE+wZmVmzZqF12YBAAAAEP2jOwYMGMAPcHz//ffpO9/5Dg+Yxk6ynjJlCk9n0WdZDJKGIfxZWH4Wg2TJkiUZN0S7du3in4ZnI7FAbiyOCSLTAgAAANEgCAL6/PPP+Y2RZs2axXtDVFZWxsPrs0BpzZs35z5FLNosC7/PYJshBrsj1BD2dyqtKRUVFXT77bdb0B4AAAAApqmurubH8MR6Q/TUU0/R7Nmz+blFLAotO6Bx7NixfDeY7aTrfJSXl9P48ePTf7NHbD169OAGLSws1Kg9AAAAAEzBbph0796dH/hsA6cbol/+8pf8LlHq0dexxx5LGzZs4Hd52IaouLg4fbYRe8ssBfu7T58+GWW2bt2af5rCNkPYEAEAAADRosCSu4vTt8zYAYtNnwuyR2fM74fBXsdnmyJ2gGPDHSN724ydWRSWTZuIbrvtm59xw2TbfLCbqg5R1h31+VWnbmC3zCTVLj7oEAcdpQgcMmLEiODAAw8Mnn/++WD9+vXBM888ExxwwAHBhAkT0nkmT54cdOrUKXjuueeClStXBkOHDg169uwZ7Ny5U6iOuro69hYd/9mUqir2ht03P+OGybb5YDdVHaKsO+rzq07dwG6ZSapdfNDBtY65vr9N4PSRGYs3xAIz/vznP+enWzPfoWuvvZYHYkwxYcIE2rFjB11zzTVUW1tLgwYNogULFlCbNm1cqg4AAACAGOF0Q8QcpaZOnco/uZ4d3nHHHfwDAAAAAGCCRJ9lxtyXvve9b36GeU4aJl01LV8+5oM+ceI3P8PW0zS9qWwVGSZ0EJGVr8/D6imSj+nMXoScPdvOmGpoKxNjUcf4CNvmXP2qo89spJseF6bGhk0dRXUJmyfMOqFLvzBj2oZ+mzZ9M1bZmJVdh0V1zBJdxxxBzNHhQ5QvX5h01TTZfGHqCSvfRrpoXlt6uLSHT2k687ieRzbGThTHjU9t0JXHlB2Top8uHSsr7foQJfoOEQAAAAAAAxsiAAAAACSeRG+IcvmhyOQLk66aJpsvTD1h5dtIF81rSw+X9vApTWce1/PIxtiJ4rjxqQ268piyY1L006Xj/8ZmtkeQYB+impogmDjxm582MF1fGPm2baFSv8/2s1VPWB1ttNGnceh6XPuun2j9rvWUJe7zxKVsm/PcdhyiRG+IbAe+Ml1fGPm2baFSv8/2s1VPWB1ttNGnceh6XPuuny6Hc9+I+zxxKdvmPLe9IUr0IzMAAAAAAAY2RAAAAABIPIneEGULfKUS1EqkDKtHR7DEbGm5Arvlk5cpwJZu/VQCoTUsYzrAoOx4UA08FmbchR1DucaIirxM10X6SWUMy+gQNridqTVAx5zVqZuovXWsXbbK6Fjbw641rr8PdM+jXPOctcPWd5Vxgpij4kOkEtTKVpko66ezjA+2Uw085rqPfO7XOI4TH9rkQ1uhN9oqKw8+RAAAAAAAlsGGCAAAAACJJ9EbomyBoVSCWtkqE2X9dJbxwXaqgcdc95HP/RrHceJDm3xoK/RGW3Wsq0YJYo5qYMZ8gaNkg1LpCICmO4ha2Lp02CiMDF3BHH3QwUY92dJ1jSvT6fnyJGXMup4TutY+GTlRWvtcl9dVh8nvSFH9y8oQmNGLwIyqDrPZEM0fRifbdemwURgZOuT7ooONelScInXI15WeL09SxqzrOaFr7ZORE6W1z3V5XXWY/I4U1x9O1QAAAAAAVsGGCAAAAACJJ9EbIlVnMJF01fxhdLJdlw4bhZGhQ74vOtioJ6wTY9j+Nj1ekjJmXc8JXWufjJworX2uy+uqw+R3pKj+ZWVklyDmyDpVyzgAyjoL+iwjKtd9r9OFHi508a2tuuT7LtunOn3S3RcZvl2XleHTmsR+h1O1Y6dqGQdAWWdBn2VE5brvdbrQw4UuvrVVl3zfZftUp0+6+yLDt+uyMnxak765BqdqAAAAAACrYEMEAAAAgMST6A1RphORGzp7ZTv9OFd5WRkyeXXonOukYRk57Dorz+TYlC9ic1EdG+bPdQJ1JhnZrqv0RaYTozNdz+ek2NTm+WT7Ml5kxrRs32W6Lqp7mPloe36J9HU+m5i2Sz7dTfenSL+J2FCkn/P1v2o7ReTnWzNyrWm3Sdaba01SnRsNdRw1iuwSxBzVwIw60kXz6JQnWp/ptptK121P1fps9b1pGT6MF9djxUQf+zo/bI1JE/2ta6yG1U+XrlG0b5Vl21RWwocIAAAAAMAq2BABAAAAIPEkekMUJrCUSLpoHp3yROsz3XZT6brtqVqfrb43LcOH8eJ6rJjoY1/nh60xaaK/dY3VsPrp0jWK9i2xbJviYrJLEHNUT7uXySOST0ddpmWEle+6vK06TKfraEMYGbCRPj1spIeVEYW1yUQ+l3NMh446dPB9bNbl+P42QaI3RDqdyGw4YJuWYcMZ0WR5W3WYTtfRhjAyYCN9ethIDysjCmuTiXwu55gOHXXo4PvYrLO8IUr0IzMAAAAAAAY2RAAAAABIPIneEGULHiabRyRfrkBzonlyOaPlC6olUkc2+SKBzrKVF61DxIa5gtWJ6pHPPiJ15LOTSB9kCk6Wqw7RPhBtR7YgdLnap2Os5rORqA2z1SFTXqQvZOdtUz3y9ZfIeBNZg3L1Zz4dZWwtI1+3HWTsIZJPZg6o9H0uu4rmEbFJrnbK9tsmye8EE+tpNltbIYg5vvgQmapXNb9MGRXZKmV1+RjEoa228odpr299rFre1RwXzWdqXJm0VVRsK5rPxfruQv8qR/mylYEPEQAAAACAZZxuiA455BAqKCjY5zPqfw8wqa+v57937tyZOnToQMOHD6ctW7a4VBkAAAAAMcTphuiNN96gTZs2pT8vvfQSv37++efzn+PGjaN58+bRnDlzqLKykmpqamjYsGHa6tcZiEpHwCpVeSr5ZcqoyFYpqxpQLI5ttZU/THt962PV8q7muGg+U+PKpK2iYlvRfC7Wdxf6lzjKF7aMNgKPGDNmTHDYYYcFe/fuDWpra4OWLVsGc+bMSae/9957/HnikiVLrAVmFEF3QDETOqrKVq1fppwpPWTL6Aoc55sePvSFLd1k84Zti6kxY1K+q/Fo2hZRsqvrNc+Hdb1GQFZiAzPu2rUr6Ny5czBp0iT+98KFC7khtm3b1ihfjx49gilTpmSVU19fz42X+lRXV4dyqhbBloOZbkw4d6uUM6WHbgdQG7YwoYcPfWFLN9m8pp24fZTvajy6cJj31a6u1zwf1vUqAVmJdap+9tlnqba2li6//HL+9+bNm6lVq1bUqVOnRvm6du3K07JRUVFBRUVF6U/37t2N6w4AAACAaOPNhujhhx+ms88+m7p16xZKTnl5OdXV1aU/1dXV2nQEAAAAQDxpQR6wYcMGevnll+mZZ55JXysuLqbdu3fzu0YN7xKxt8xYWjZat27NPzadt6LqYGbCuVulnCk9dDuA2rCFCT186AtbusnmNe3E7aN8V+PRhcO8r3Z1veb5sK6XuHSezkbgARMnTgyKi4uDr776Kn0t5VT99NNPp6/985//dO5Ubcsx0LRzq2s9fHLEdN3GsOV8cI63MRZly5h0Plct53I8ypQzKd+XdUu1HPQPrOmfOKfqPXv2cEfpX/3qV/ukXXfddTxt0aJFwfLly4PS0lL+sRmpWkcZlfKmnVtd6+GTI6brNoYt54NzvI2xKFvGpPO5ajmX41GmnEn5vqxbquWgf2BNf9sbIuePzNijso0bN9LPfvazfdLuvvtuatasGQ/IuGvXLho8eDBNnz7diZ4AAAAAiC/ON0RnnXUWu0uVMa1NmzY0bdo0/gEAAAAAiP1bZi4QPTVZ5MRm0RN6dZ3UnO8U4Xz6yJ7mnO205KayRO0gcuK7aP3ZED0tWqaN+fTQMVYylctVRiR/WF3ytVskn8iJ4SLjR6ZfRcZYPpky/aXDniJzU3aMmJ53+U4/Fz31Pl87RMs21UPn+qxqe1n7i45dXfbfpGn8iM5P0XFtlSDm6PAh0vlcVlc+3YHFXARfM5VXtYyOfvbFH8n2eBTJ58J/xpbeOuszLdNF3abner6yPvjumNTF5rpUZfG7IrGBGQEAAAAAXIENEQAAAAAST6I3RDqDWOkOiBU2qFUUgq+ZyqtaRkc/uw64JpvfZj5dtjExbsLqrbM+0zJd1G16rucra8I2quVc9JPN77ASS4E6jRDEHF2BGXPlDXuqb5TTfdYtCfbVUb+telyNsyiW9SHdBx1U7Ys+1y/bhYzEBWY0ja7AjGGcLuOc7rNuSbCvjvpt1eNqnEWxrA/pPuigal/0uX7ZLmTAqRoAAAAAwDLYEAEAAAAg8SR6Q9Q0CFeuwFSZAnaJBgHLF+QsWzAwGfnZgmWJBJxrKD9bsKxs8nXonqtuWfmu7J9Nvqz9m8rPZx8d+ouMIdvjXOc4yWR/URuHaZNovdlkZ+sTW/0hMv5U1h5d8qPc57rWOxndw/aVizG1eTPZJYg5Mj5Ess9fs+V3cV1Whm9tMt0uV9ejoqdv16MybtFWXNd53SddfLheWQkfIgAAAAAAq2BDBAAAAIDEk+gNUdPAULLB2WSDgJm8rhKQzKc2mW6Xq+tR0dO361EZt2grruu87pMuPlwvLia7BDHHRmBGXeVU6nCtlw/BvHwJPGhDVxvlZfKJ5rdpf5m8OmxlQj9dYzpfPp316Jbpyv4+2NUHHXz43igrQ2DGyAVm1FVOpQ7XeonIyZcnrAwdOujS07SuNsrL5BPNb9P+Mnl12MqEfrrGdL58OuvRLdOV/X2wqw86+PG9AadqAAAAAACrYEMEAAAAgMST6A1RLmfGMHlt1uFaLxE5+fKElaFDB116mtbVRnmZfKL5bdpfJq8OW5nQT9eYzpdPZz26Zbqyvw929UEHH743ysrIKoneEImQiqTJYD8bdmCuyNYpWP5rryV64IHc+VR0SkX9bKiXiE5AHmZP1oesL7NN4lxjRUZGtjxhy5sin865bKJbhuy8yJWvaVq2uprKSunpyxzMtQY1bKOIjXSsebrGaKYoyqJrYa6+Eu3HfHbVve7Lfi9lSgv7/VHi6RjXRhBzwjpV23RQtekICqdq+3VERQeZfDp0jooMnXXZdKrWKc+nvvB9voXRz9ey9m0Lp2oAAAAAAKtgQwQAAACAxJPoDZHsybwyaSL1mJCnUleu58b5TkHWcdp82JPWReyWTwdVu8qe4qyqQ7Z+kLWFiA6idYU5kVzGdqJj1ea8sNVPufQQbZOO8S962rqpMaHSplw62Fjb8ukXZrzmGmP5Tq0X/U7bpDj+ddXjwqkaPkQSJ/CqpsVRnusyum3gu35RleeDbjb1SJp+UdXBhzbFcaxUaS6T6/vbBIm+QwQAAAAAwMCGCAAAAACJJ9EbomzBoVQDSiVJnusyum3gu35RleeDbjb1SJp+UdXBhzbFcazoLmObAvbcjGLM9u3bqaioiOrq6qiwsNB5EDsAAAAAhPv+NkGi7xCxDdHtt8cw2iYAAAAApEj0hggAAAAAgIENEQAAAAAST6I3RLmCXwEAAAAgOSR6K7B3L1Fl5Tc/AQAAAJBcEr0hAgAAAADwYkP08ccf009/+lPq3LkztW3blo499lhavnx5Op1FBbj11luppKSEp5955pm0du1apzoDAAAAIF443RBt27aNBg4cSC1btqT58+fTu+++S7///e9pv/32S+e566676N5776X777+fli5dSu3bt6fBgwdTfX196Pp9CggFAAAAgIRuiH77299S9+7daebMmXTSSSdRz5496ayzzqLDDjssfXdo6tSpdPPNN9PQoUOpd+/e9Kc//Ylqamro2WefdaJzrhOAw5ZRkW2rXL68sjrorNtmPSb7X6cOuvtLpoyp8WhyjNmuR+dY82FMmtLZh3Hqwla+jEFX63eqzObNZJfAIb169QrGjh0b/PjHPw66dOkS9OnTJ3jwwQfT6evWreMn3b755puNyp1yyinB6NGjM8qsr6/nJ+OmPtXV1dKn3efCZBkV2bbK5csrq4POum3WY3rM6NJBd3/JlDE1Hk2OMdv16BxrPoxJUzr7ME5d2MqXMehq/U6VqaxM0Gn3H374Ic2YMYO+/e1v04svvkgjR46k0aNH06OPPsrTN//v9rBr166NyrG/U2lNqaio4KG+Ux92BwoAAAAAIBdON0R79+6lE044ge688046/vjj6ZprrqGrr76a+wupUl5ezs89SX2qq6u16gwAAACA+OF0Q8TeHDvqqKMaXevVqxdt3LiR/15cXMx/btmypVEe9ncqrSmtW7fmh8A1/Oh0qjZZRtXJ20a5fHllddBZt816TI8ZXTro7i+ZMqbGo8kxZrsenWPNhzFpSmcfxqkLW/kyBl2t36kyWb7mzRE45KKLLgoGDRrU6BrzKSotLeW/7927NyguLg7+67/+K53OniW2bt06eOKJJ4TqYPmzPYOsqQmCiRO/+SmalquMqkxd6ab0DtsuXXlc2i9K7XCto29zJ+r29CE9LjrESYbKPHMxx2pC1Jnr+9sETjdEy5YtC1q0aBFMmjQpWLt2bTB79uygXbt2wWOPPZbOM3ny5KBTp07Bc889F6xcuTIYOnRo0LNnz2Dnzp1CdeQyqIpTWxjHz7BOo2EcMU3W7YsjsEn7RakdrnX0be5E3Z4+pMdFhzjJUJlnLuZYVYg6bW+IWpBD+vXrR3PnzuV+P3fccQd/7Z69Zn/JJZek80yYMIF27NjB/Ytqa2tp0KBBtGDBAmrTpo1L1QEAAAAQI5xuiBg//OEP+ScbBQUFfLPEPgAAAAAAsTy6w9fT7jM5grFgUbNnE40fL+f4mQoyxerJ5zTKZLM6MgWxaig7W7CrVB5WV8P0bI5tIrrla3cuO2azSyb9cznf5dMhbLponmz2lWmryb6QHSe6dcyln8j4zpYuq2/D9FxzUjVddg7kGzf5+kylv3TaIFsdpmygooPI3BDRU2Q9E2lrrrGuQ49sYyLX+pFrnJWEGGMq64FIndYJYo6qD1EmZPOrlBPNq+MZtmg+XXWFKeODf4LpvLp11F23SD4b/eSTHrr1tpnHZxuYzGtrrfDV/jrrrzLcBts+RIm+QwQAAAAAwMCGCAAAAACJJ9EbIh8DvekKFqYz6JiuusKUCauDjnaazqtbR911i+Sz0U8+6aFbb5t5fLaByby21gpf7a+z/hJPgqlqI4g5KoEZfQ5i6JtsF8HFwqZHsX9djRsXwdqi1haR9LDyTevnQ6DBsDLCyPfZtkmeg3VJCszoq1O1SWe4sI5qvsk2ZSuXfeBj/7oaN6Zs4UKuyzETVr5p/XxxsHU193y2bZLnYB2cqgEAAAAA7IINEQAAAAAST6I3RNkCX8k6iskEDxMJ2CUTPEs2KJlKcC1VW4UJdBjGxk3TbQZGzNaeMAFB85UJ0+Z8OocJ6KcaIE5EX5EAjjaCTWbTVza4Yr55pDo/s9UtW7+OoKaiY1g0OK2OgKQiuoWxnWp5Wfm65sMmwXp11Sm7rhsniDk6AzNmQ1aOTH7RvGHaouPZftgyOvwPwuqh0w5hfR3CljFZh+6+MqWrq/bY1s+kjjrrt7GWqcqwMWZlypvQR/c4qrLgVwYfIgAAAAAAy2BDBAAAAIDEk+gNka7nlSaDT4nmDdMWHQG4wpbRHeBLpaxOO4j6OvgwxmTL6O4rU7q6ao9t/UzqqLN+G2uZqgwbY1amvAl9dI+jEgeBG40TxByVwIz50kyWFUk3XYevgcR0pNuow3W6Dzr4Or5E0n3QIenpPujgug1JsFFNnnQEZvTEqdpkgDAdDnWugnlFvW4bdbhO90EHX8eXSLoPOiQ93QcdXLchCTaqglM1AAAAAIBfYEMEAAAAgMST6A2RSoA8U0HSRGWHrcN2IDKZoHsqAfBkdNMReDFscDFR+SrB6VT6KFsASZ1jwLT9VXTLFxw1zPySbYPoHDHdv6r6q6xh+dqfT8ewQRxN9VGYOmTL6u4HX8pnGw9WCGKO7sCMOp7r6iinWodqeZ/bJFrOVN+ZaKNpPXwdczbGmUj+MG01Nbd8HBNRrE+lXFTaFYfyVQ3KwocIAAAAAMAy2BABAAAAIPEkekNkKpiZarAp3UGxdJb3uU2i5Uz1nYk2mtbD1zFnY5yJ5A/TVlNzy8cxEcX6VMpFpV1xKF/iMlhjEHNUAzNmQja/7vK6ZKmWtV1Ot6wk6h8le+m0s0s9bPaTLzYLKy8KY9vm90VU5l6N4XIIzOixU7VrRzVdsmw5IoYtp1tWEvWPkr102tmlHjb7yRebhZUXhbFt8/siKnOvynA5OFUDAAAAAFgGGyIAAAAAJJ5Eb4hsORbrKh81R8Sw5XTLSqL+UbKXbmdKV3rY7CdfbBZWXhTGts3vi6jMvRJPxq0uCthzM4ox27dvp6KiIqqrq6PCwsJGaSwS5gMPEF17rX8dAwAAACSZ7Tm+v02Q6DtEbEN0++2OQoQDAAAAwBsSvSECAAAAAGBgQwQAAACAxJPoDVG+E62znbqb6zTefCf1qpQ1ITNsnTrK67avC9vHpU9N9ZdJnXzqT1HZqrq56HMXa0NU0kzJdrHe2F5vN2mYQ8YIYk6YwIzZ0nOVC3OKtkp9pvQJG1BNpLxu+7qwfVz61FR/mdTJp/4Ula2qm09rlat2+pRmSraL9cb2elslIROBGQEAAAAALON0Q3TbbbdRQUFBo8+RRx6ZTq+vr6dRo0ZR586dqUOHDjR8+HDasmWLS5UBAAAAEEOc3yE6+uijadOmTenPa6+9lk4bN24czZs3j+bMmUOVlZVUU1NDw4YN01a36onXucqFOUVbpT5T+oQNqCZSXrd9Xdg+Ln1qqr9M6uRTf4rKVtXNp7XKVTt9SjMl28V6Y3u9LdEwh4wROGTixInBcccdlzGttrY2aNmyZTBnzpz0tffee48/T1yyZIn10+5F8ubLYzpdNI9sXh/0hg726hDNY7s+X2zjky6+2C1XPl3yo2oX3TJ9aFuNpfQ1axJ02j3bELVr1y4oKSkJevbsGVx88cXBhg0beNrChQu5IbZt29aoTI8ePYIpU6ZklVlfX8+Nl/pUV1drOe0+rLObjXTRPLJ5fdAbOtirQzSP7fp8sY1Puvhit1z5dMmPql10y/ShbVWW0isrE+RUffLJJ9OsWbNowYIFNGPGDFq/fj1997vfpc8//5w2b95MrVq1ok6dOjUq07VrV56WjYqKCh7qO/Xp3r27hZYAAAAAIMq0cFn52Wefnf69d+/efIN08MEH01NPPUVt27ZVklleXk7jx49vdBYKNkUAAAAA8NqpuiHsbtB3vvMd+uCDD6i4uJh2795NtbW1jfKwt8xYWjZat27ND4Fr+NERmLGps1emAFL58qTSWX2Zgk81LK8iP5WH7Qdnz84f3IvlYXmzObCl5DN9mzq65bKNbPlMbZO1v2x5ET1z1RGm/7PZqameInXI2klkHMqMo1z5cvW/rO11tF3W/tn00D0WVOvIZ/+mckTWnVy65hovuXQJu+7pGE+ieVTnomhAxWxrro626VyTS0Kup2HbmSqf46veDIFHfP7558F+++0X3HPPPWmn6qeffjqd/s9//lOrU3WY55xhnuOafk5s4zl01MuL5PO5fh16uvYdCVs2Xz5bMlyPZR3tFMkXhXaaqsO0748Nv6CwOlQ5mE+2AzM6fWT2i1/8goYMGcIfk7FX6idOnEjNmzeniy66iPv/XHnllfzx1/7778/v9Nxwww1UWlpK/fv3d6k2AAAAAGKG0w3Rv/71L775+fe//01dunShQYMG0euvv85/Z9x9993UrFkzHpBx165dNHjwYJo+fbpLlQEAAAAQQ5xuiJ588smc6W3atKFp06bxjwlUA0uJlDUZfMu1/DiUF8nnc/069Awz/nXp76rtOmW4Hss62imSLwrtNFWHjrlium2mdSjxaD4ZI4g5ugIziua3HezRhEyXbYi6/jpl2goS6FI313qa0M+38elrfVG1p8/2sj13awzXZ9uHKNEbIlEnMZn8MjJ1y9Ml02Uboq6/Tpm6nGVdjnPdfaFbTxP6+TY+fa0vqvb02V62526V4fpw2j0AAAAAgGWwIQIAAABA4kn0hkjWeUu3Q5gJBzNbznk664uT/jpl6nKWdTnOdfeFbj1N6Ofb+PS1vqja02d72Z67JY7WCmMEMUeHU7UvJ//GNT1fHtf1+1KHDT1t6GgzD9LNzj1dOsjmdamz6z6z6RRdYzBdpGxZGZyqvXOqDusUh3S3EVRtOD7acq503Vc2HS3jYA/f0/Pl8dGp27XOrvvMplN0lcF0sbJwqgYAAAAAsAo2RAAAAABIPIneEOU77V6XUxzS3UZQteH4aMu50nVf2XS0jIM9fE/Pl8dHp27XOrvuM5tO0SUG00XKlpWRVQrYczOKMdu3b+cHxdbV1fEDYhuyYgVR375EVVVEJ5zgTEUAAAAASHx/myDRd4gAAAAAABjYEAEAAAAg8ShtiBYsWECvvfZa+m92Gn2fPn3o4osvpm3btlFU8CIQFAAAAACiuSH65S9/yZ/tMd555x268cYb6ZxzzqH169fT+PHjKc5s2kR0223f/NSZV6WcinxT+vuki2wZkXyy9buws0kdTddjqn99ma9Rs7Xr8e7apq7XYBvjxYe8OsppRSV4Ufv27YP169fz3ydOnBgMHz6c/15VVRV07do1iOtp97JlVOTLlPNJf590kS2jK0igan5deU3qaLoeU/3ry3yNmq1dj3fXNnW9BtsYLz7kjcVp961ataIvv/yS//7yyy/TWWedxX/ff//903eOAAAAAACiQguVQoMGDeKPxgYOHEjLli2jP//5z/z6+++/TwcddJBuHQEAAAAAjKJ0h+gPf/gDtWjRgp5++mmaMWMGHXjggfz6/Pnz6Qc/+AHFKTBj0+ea+RyxG+bPlFfkOSnLz1yxZs8Oly9TXU11yqVPw7z59FZpq2hgTNm8KnbM185UHla/yHNuGX1lZOdqk0zf5pMlO64z5cumV6YyTAemi8i8yidXVNem+Zn988kLO35E+0ZlbIjYUbTfZce7iMx8dlZph6xN88kW1VHVTqJrg+j6IfP9lC/vJsHvApm8Mn5Bmcpt3kx2CWJOWB8i3c/SdT+bDutT4vJZuS/+HSZ0du3zJJrPRZ0m9VTRwcU4de2HZUJPl3NHtJzOvlYt52pdjsI4b1qustKuD5HwIzMZ3yAbESUBAAAAAHQhvCHq1KkTFRQUCOXds2dPGJ0AAAAAAPzcEC1evDj9+0cffURlZWV0+eWXU2lpKb+2ZMkSevTRR6miooKigq4DJl0dzJcvn872qQSxdHHoY9T6z6RsF/1vqt0mx4qLcapbRx/0dDl3RMvp7GvVcq7W5SiM86bliovJ/8NdzzjjDLrqqqvooosuanT98ccfpwcffJBeeeUVisLhcMxx64EHiK69Vr7DAAAAAJDww13Z3aATTzxxn+vsGnsNPyqwDdHttzuOjAkAAAAA5yhtiLp3705//OMf97n+0EMP8TQAAAAAgNgHZrz77rtp+PDhPO7QySefzK+xO0Nr166lv/zlL7p1BAAAAADw7w4RO8iVRaUeMmQIffbZZ/zDfmfXWFpUUHX4AgAAAEC8UNoQMdijsTvvvJOeeeYZ/pk0aVIsH5fli7QZ5uRiVdlhddJ5krNvbTMpW1WuqbJhZEexb30cM2HrN1k2qmuPzzaXyZMvr8s2+DIuNvlwwn1DRCM4vv3228GePXvSv+f6JClSdRgZqrLD6mQj0rGrtpmUrSrXVNkwsqPYtz6OmbD1mywb1bXHZ5vL5MmX12UbfBkXVXnK2T7tXtiHqE+fPrR582b61re+xX9nQRozvbHPriMwIwAAAACihPCGaP369dSlS5f07wAAAAAAifMhOvjgg9NHd7Dfc31SnHvuubTJm4eDYicKN32mme8041ynPGc7OTnf9Xx159Mp20nJovXma1vD/NlOQW5YRyb5ptrWVCeR66J9memU7GzXs+mUrb3ZdBKRrzK+RE6kzmZr1fGlOt7z9Y9qv4n0Qxg76eiHXG3LdSK6b2uPSl9kq0NETi67hl0HZNbQXPPX1bgxoVOzJtdF9RWZX1Yx+TyuQ4cOwbp164Io+RDp9MeI+vVsaabzx+G6Llsk0XYu2+xju+PQBujkT902dNIly7YPkfJbZiaYPHkyvws1duzY9LX6+noaNWoUde7cmTp06MDjH23ZssWpngAAAACIF95siN544w164IEHqHfv3o2ujxs3jubNm0dz5syhyspKqqmpoWHDhjnTEwAAAADxw4sN0RdffEGXXHIJPw5kv/32S19nB7o9/PDDNGXKFDr99NOpb9++NHPmTPrHP/5Br7/+upHAjNmCNeYK4ihbJirXs6WZzh+H67pskUTbuWyzj+2OQxugkz9129BJtyxr+OBDdNlllwVjx47lv3/ve98LxowZw39fuHAhf364bdu2Rvl79OgRTJkyRUiHXM8ga2qCYOLEb35m+jtX3lz5Za7rkBEFXXzXw4UuUb8eVdlR0EVmnEZhTPsiIyl6u7peo1n2mjV2fYicb4ieeOKJ4Jhjjgl27ty5z4Zo9uzZQatWrfYp069fv2DChAkZ5dXX13PjpT7V1dXCTtW6HF5lrvvkWOeLbBd6uNAl6tejKjsKusiM0yiMaV9kJEVvV9erNMuurIyRU/VNN91E+++/f9b06upqGjNmDM2ePZvatGmjpc6KigoqKipKf+J4nAgAAAAA9KK8Ifrv//5vGjhwIHXr1o02bNjAr02dOpWee+65dJ7y8nLq1KlTVhlVVVW0detWOuGEE6hFixb8wxyn7733Xv57165daffu3VRbW9uoHHvLrLi4OKNMVifzPUp92KYLAAAAAED7hmjGjBk0fvx4frI926ykjupgmx+2KRLljDPOoHfeeYfeeuut9OfEE0/kDtap31u2bEkLFy5Ml1mzZg1t3LiRSktLM8ps3bo1FRYWNvpko2kQKl0OrzLXfXKsy5Y3W7AuU+3MdC1XMDEdeujQO2nXoyo7CrrIjNMojGlfZCRFb1fXSzTKZmv9U0+RVQrYczPZQkcddRQ/6f68886jjh070ttvv02HHnoorVq1ik499VT69NNPlRVi5dlZaamN1ciRI+mFF16gWbNm8c3NDTfcwK+zN81E2L59O390xu4WNd0crVhB1Lcvu1NFdMIJyirHHh/s5IMOAAAAbK7524ko8/e307PMGsLOMjv++OMz3p3ZsWMH6eTuu++mZs2a8YCMu3btosGDB9P06dO11gEAAACAZKO0IerZsyd/pNXw3DLGggULqFevXqEUeuWVVxr9zZytp02bxj8AAAAAAN5siJj/EDtOgx2rwZ64LVu2jJ544gn+htdDDz1EUSHXs3fgl5180AEAAIAd2FpfVsaO9PLcqfqqq66i3/72t3TzzTfTl19+SRdffDF3tL7nnnvowgsvpDijeiKvzXK6y7CBydJkNiM6Ti5ueiqyjA62+0m3LNf6u9BdtaytMmHL2tbTVXmb7XQ1TnXJisJY2uRorjzwANEVV5BdwgYy2rFjR7Bly5bAV2RPu8+HShnb5Wy2y6S8MDJs91Pc9Hehe1TGu+9z2XX5KKyrYcvqkhWFsVTlcK7YDsyo9MisIe3ateMfAAAAAICoIrwhYm+VFRQUCOVdwd6XAwAAAACI24aIxRxKwZyp2avvLB5RKkAiO31+9erV9POf/5yigoqjrqpzr81yNttlUl4YGbb7KW76u9A9KuPd97nsunwU1tWwZXXJisJYKnE4V7IcSGEOledsV155ZXDzzTfvc/3WW28NrrjiisAnZE67t4HuOsPKUy2vqx0u+sBnPXwdJ6ZkmZRpQ7bOemXym26TKfm22+hyfXO1NoehxrN1Pdf3twmUNkSFhYXB+++/v891do2lxdmpOiy+OS9H2XlXJ77o4es4MSXLpEwbsnXWK5PfdJtMybfdRpfrm2uHeJd1VmmSY3tDpPTafdu2benvf//7PtfZNV2n1gMAAAAA2ELpLbOxY8fyM8aY8/RJJ53Ery1dupQeeeQRuuWWW3TrCAAAAABgFKU7RGVlZfToo49SVVUVjR49mn/Y5mjmzJk8LSpkO8VdNbiUSL6UsxirUyZgVTbZmZzW8unRNOBhNqe3fMEaG5aTCcAlWn8YubJ5VNujW7+mpz3Pnq1HdsP2hdU5W5+Fkas6DkXy6Gy7STvJ5NfRB7K66LCdTF/IzoFM9araSceYCdtHot9PMjLz5S1RWAdFx6eKjps3k12CmKPDh0h3Ptm8umW7bo/LvEnt87jndd1fURwHUegzU+3xvd2udfSlPZEKzMjuEL333nv896OPPprHKgIAAAAAiBpKG6KtW7fyM8vYyfSdOnXi12pra+m0006jJ598krp06aJbTwAAAAAAv3yIbrjhBvr88895IMbPPvuMf1atWkXbt2/n/kRRQTRolO58snl1y3bdHpd5k9rncc/rur+iOA6i0Gem2uN7u13r6Et7IhGYkcUaWrZs2T7Xly5dGhQVFQVxDMwokjdfHp2B2mwF/dJpo7DtcR3oTkd/hB0juuxkq70m9DKRTzW/ahkX64opW9iYF7r1112f63Frq0yNpfUpla+sLAKBGTt06BC8+eab+1xfsWJF0LFjxyCOgRl1OJfpdBC0FfTLljO3SwdLHfXrsqeOMWQjj8r4893pXSW/ahkX64oLB2WdutleP004KpvqK1tlqiytT/+XLwKBGU8//XQaM2YM1dTUpK99/PHHNG7cODrjjDN03sACAAAAADCO0oboD3/4A/cXOuSQQ+iwww7jH/Y7u3bffffp1xIAAAAAwLcNUffu3XkgxhdeeIFHrWaf+fPn82sHHXQQRQWZwFciQcLyBaOScSpj+VldrM5M+VUDPIrIVgmOJiIzl875bCOjs0h9KgHJcgVrE9Gf5We65HN4z2VvkWBvIkHRRMZirvmhEnQuV52i9skkS2dQRtHxrmsuiqxButYVWT112Fh0nKiO60yIjCWRtsmMHZH1I0y+bDYJ078m1tQSDf3YsP+sx3lWfdb28ssvB+Xl5fzke3bCfcNPXA93telf4NOzZlfP28OWMVmfa38m0/raLBOmnExZk3MqjvZSKeNDX7he32Tyu5zrNsdQleL6Z/twV6U4RLfffjvdcccddOKJJ1JJSQkVFBTo36kBAAAAAFhCaUN0//3306xZs+jSSy/VrxEAAAAAQBR8iHbv3k0DBgygqGMyiFmYMjLlbOikO4CaTTuaqs/k2PFBX5tlwpSTKWtyTsXRXiplfOgL1+ubTH6Xc93mGCoxvP5pQ+U524QJE4I77rgjiAKqgRmzpcle90WeiTaHkRmmTh/6IOp2tD3ubOqiuy7d48OETB909GVO+DQWdfenCf1tjZ0ahXps+xApbYhGjx4ddOrUKTjllFOC66+/Phg3blyjTxycqrOlyV73RZ6JNoeRGaZOH/og6na0Pe5s6qK7Lt3jw4RMH3T0ZU74NBZ196cJ/W2NnSqFeiLhVL1y5Urq06cP/52dYdYQOFgDAAAAIGoobYgWL16sXxMAAAAAgCg5VceFXM5b2dJkr/siz0Sbw8gMU6cPfRB1O9oedzZ10V2X7vFhQqYPOvoyJ3wai7r704T+tsZOSYj+skYQc1ScqqN+Pal143qydc2W5mPdcWizj+PPZd2mdfWxzabriIRTdZRQcaqO+vWk1o3rydY1W5qPdcehzT6OP5d1m9bVxzabrsP2hijRj8wAAAAAABjYEAEAAAAg8SR6Q5TtpOlsTl758jc9ATiTnFwnDIvqI3Kac1hd89XRMH++k6tFZYW1n4ycXCebZ2ubiFOgSH6RfhatN9vJ7Kpt0NEHMjbV2T/ZZOU6UV7XGpDNhqpjWLTfssnK1p8qbZMdG7rmuopOYWTls7nqmpjLaVhmzc91Mr3utayZpr7Op1NDWbnaZ40g5tg87V5EnsqzWN316GqLblk62uVKd9362bZZnMeWjjmnqz6ZOm3WpUuWzrbp0kmX/rrr0p3PJ1vpal+ifIhmzJhBvXv3psLCQv4pLS2l+fPnp9Pr6+tp1KhR1LlzZ+rQoQMNHz6ctmzZ4lJlAAAAAMQQpxuigw46iCZPnkxVVVW0fPlyOv3002no0KG0evVqnj5u3DiaN28ezZkzhyorK6mmpoaGDRvmUmUAAAAAxBClSNW6GDJkSKO/J02axO8avf7663yz9PDDD9Pjjz/ON0qMmTNnUq9evXh6//79Q9cvGxBKNViWaB5RfcLWo6stumXpaJcr3XXrZ9tmcR5bOuacrvpk6rRZly5ZOtumSydd+uuuS3c+n2xlyg7GCTzh66+/Dp544omgVatWwerVq4OFCxfyZ4fbtm1rlK9Hjx7BlClTnARmzJcWpqyKLrbLIQ1pcRp/JuqyWZ8vfR0F/X1ps00dfWlXmLTEBWZcuXJl0L59+6B58+ZBUVFR8Le//Y1fnz17Nt8cNaVfv37BhAkTssqrr6/nxkt9qqurtQVmzJcWpqyKLrbLIQ1pcRp/JuqyWZ8vfR0F/X1ps00dfWlXmLREOVUzjjjiCHrrrbdo6dKlNHLkSBoxYgS9++67yvIqKiqoqKgo/enevbtWfQEAAAAQP5xviFq1akWHH3449e3bl29mjjvuOLrnnnuouLiYdu/eTbW1tY3ys7fMWFo2ysvLqa6uLv2prq620AoAAAAARBnnG6Km7N27l3bt2sU3SC1btqSFCxem09asWUMbN27kr+dno3Xr1unX+FOfbMgGZctVRqRstkBVqsEXwwS5Ugkilk1H2XKi7VMJvparbfnKiQTda1pOJGCaii4qbZfRRaUfZPSUdfAME2xUtW06x7NMffn6VHScqIzXMOVk1i+RdttcM6KwrunQI2xASBPrkmo5lqeiguwSOKSsrCyorKwM1q9fz32J2N8FBQXB//zP//D06667jjtRL1q0KFi+fHlQWlrKP64CM6qWUSkfph7Zsqp12dLR53qSJN+kHJHypse1L3Pb9Bphc23RVVa2fBTaqGscqJSx2Rfh7GPXh8jpa/dbt26lyy67jDZt2sT9fViQxhdffJG+//3v8/S7776bmjVrxgMysrtGgwcPpunTp7tUGQAAAAAxxOmGiMUZykWbNm1o2rRp/AMAAAAAkBgfIpuoBIMKG0DKRqAq2bKqddnS0ed6kiTfpByR8qbHtS9z2/QaYXNt0VVWtnwU2qhrHKiUsdkXYexTVkZ2CWKObGBGnQGwfLselzri3AZfZfloqyi1wcd2+9gGX2WZrsPHceND3WVlCQvMaBpZp2qdAbB8ux6XOuLcBl9l+WirKLXBx3b72AZfZZmuw8dx40fdCQvMCAAAAADgGmyIAAAAAJB4Er0hahqcKltgu2zBtmSuZwuYpeN6tgBf2YJgZQquli1Ql8x12/YQbbeKnbK1L9v4CHvdhD1y9beu67psImNzHfNR1uY6xpSsbXXMSRm75rsuOodl+yJbIEoZm2cLGGnahrrWuzBj0+SYbZYjeHHYMSsy1uBU7dCHyORzUd9l25bhi84yspPQh67qlJEf5Xb6UqdJGT7p4osNfddPVoYtmyTucFcAAAAAANdgQwQAAACAxJPoDVHT597ZgkbpuO67bNsyfNFZRnYS+tBVnTLyo9xOX+o0KcMnXXyxoe/6ycpwYRMrBDFHNjCjSh7ZMrIyZfL7JFumnEnZNuvQIcPEmAsj27ROOvTzRYaN8eiybBzWIxUZJuaXzX4QzV9jsL9Uytn2IUr0hiiXw5hMHtkysjJl8vskW6acSdk269Ahw8SYCyPbtE469PNFho3x6LJsHNYjFRkm5pfNfhDNX2Wwv1TKwakaAAAAAMAy2BABAAAAIPEkekMk4ryl4uCVr4ysTJn8PsmWKWdSts06dMgwMebCyDatkw79fJFhYzy6LBuH9UhFhon5ZbMfRPOXGOwvHeWME8QcXafd+3wicNTriIOuvsqSGeNxb7evuvrYvrivOXGZM7rqdjnOa3Lkh1O1p6fdy0bstHE9LnXEQVdfZcmM8bi321ddfWxf3NecuMwZXXW7HOdVOfLDqRoAAAAAwDLYEAEAAAAg8SR6QyRz2r2J08mzXTd1mrPr09dl2yd7IrXoyeiyp3SHPVnedjtkTtaWOWlcZgyaPE3dxFiT7TuVuRTmRHPb7XM1Nn1th0jfyZwiL9OOsGNNZI7r7IuSLNez6ZtrPdi8mewSxBxTp93b9vEw6Tvia322bWlKtySOibjoZrsdcWmfz2021Q5fdfB5DFflKV9ZCR8iAAAAAACrYEMEAAAAgMST6A1RU/+RbMGiMl2XyatDtim5Ptdn25amdEvimIiLbrbbEZf2+dxmU+3wVQefx3BJnvLFxWSVAvbcjGLM9u3bqaioiOrq6qiwsLBRGnPceuABomuv3bdDAHAJxiYAyQZrAOX8/jZBs6QPuNtv3/etGQBcg7EJQLLBGmCfRG+IAAAAAAAY2BABAAAAIPEkekOULWgXAKo0DWoW1bGpqx1JwHdb+a6fK/19t0s2h2NgjkRvBfbuJaqs/OYnAD4993c9NuG/EB9b+a6fK/19twvbCLENGzZE9kj0hggAAAAAgIENEQAAAAAST6I3RHhGC3wdU67Hpuv6o4TvtvJdP1f6R90uQD+J3hDpdsDLlSdf+bDpUaonjJ10tMFUP+UKpJatXLbrrDyTw+TptKFoWjb/BRlHVNM66qwzjPyGtgpbf9g2mNJPd5pMO5qORV1rVD58Xqfy5XGtu65xjNPuHZ52nwuRvLny5CsfNj1K9YSxk442mOonlTQTdnJpe9c6Rnls6ZDhYl7qHvdh6tNVhw4dbKzFutcVG7rJyE/UafcVFRXUr18/6tixI33rW9+i8847j9asWdMoT319PY0aNYo6d+5MHTp0oOHDh9OWLVuc6QwAAACA+OF0Q1RZWck3O6+//jq99NJL9NVXX9FZZ51FO3bsSOcZN24czZs3j+bMmcPz19TU0LBhw1yqDQAAAICY0cJl5QsWLGj096xZs/idoqqqKjrllFP4gW4PP/wwPf7443T66afzPDNnzqRevXrxTVT//v2tOdWJ5M2VJ1/5sOlRqieMnXS0wVQ/qaSZsJNL27vWMcpjS4cMF/NS97gPU5+uOnToYGMt1r2u2NBNRr7t0+698iFau3Ytf174zjvv8L8XLlzI/962bVujfD169AimTJkS2oeopiYIJk785qfI9bik5Ur3RU/oIZfmSxtUdfRFfxdtMKGr7frC6BOVfvIlLQ5jpUYwLdf3twm82RDt2bMnOPfcc4OBAwemr82ePTto1arVPnn79esXTJgwIaOc+vp6brzUp7q6Wtqp2hfHQ1NpudJ90RN6yKX50gYTjqpRsbNqG0zoaru+MPpEpZ98SYvDWKkSTLO9IfLmtXvmS7Rq1Sp68sknQztqFxUVpT/du3fXpiMAAAAA4okXG6Lrr7+enn/+eVq8eDEddNBB6evFxcW0e/duqq2tbZSfvWXG0jJRXl7OfY9Sn+rqauP6AwAAACDaON0QsUd2bDM0d+5cWrRoEfXs2bNRet++fally5a0cOHC9DX2Wv7GjRuptLQ0o8zWrVtTYWFho4/sieIphy52PVOQs4bOYE0DiIUpx342DVglmibatlTds2cTjR+/b9lc5TLVl9KJ5c+kS666VPXIpyOTx+RmCnaYKy1T38nYP1uf6rBVvnbnShdpd9j25WtbmPaF6dMwYyFT/6j2X76+092OXGtRvnTVNBF9co2zMOtmJlTWEBtzJezaKGovUR1zjefbDKztqmlWCBwycuTIoKioKHjllVeCTZs2pT9ffvllOs91113HnagXLVoULF++PCgtLeUfG4EZ86Vny6NaLl9ZEblh5cjUIZI/Kr4Dpsu6Tg8zJn2XH/WxbrIdvtk8V7qOMWRDf5E8Jvs76utNlUSabR8ip6/dz5gxg/889dRTG11nr9Zffvnl/Pe7776bmjVrxgMy7tq1iwYPHkzTp093oi8AAAAA4kkL14/M8tGmTRuaNm0a/wAAAAAAxNap2hWmgk+5DKgVVo5MHSL5Tehhqk6TZV2nhxmTvsuP+lg32Q7fbJ4rXccYsqG/SB6T/R319aZE45zUThBzdAZm1Bn0yvdAXjZkJb1+X9uC8efH/Ixi/9hqj+s+sFVPrjps1VPjsJ2JDcxoChWnap0Oz7qdp3XqYEtv1B+ttmD8+TE/o9g/ttrjug9s1ZOrDlv1VDlsZ2IDMwIAAAAAuAIbIgAAAAAknkRviGQDM2a7LlIm5SSWK9hVtjTVgH+qgbXCBG5UDcrWNE3UbiIB0FQCtIUJ3CY6bmT6Ml+/5LO/TPA+lTGWy/65bKZi/zBjSSS4qamgcqr9ILqm5Jo3ueyQrd9U1oew7QkTTDDM+qnaTl0BM1Xmokyfqq4rm0IEj9SxFlkniDkmAjOqPm9VLWtCTxftCyNbtY0m5Jrqj7D1mmpP2DaplHfRr2HkutTZth1M9XnU1s8wbbHdL7bTdOkJHyIAAAAAAMtgQwQAAACAxJPoDZFq4KkwgaVUyprQ00X7wshWbaMJuab6I2y9ptoTtk0q5V30axi5LnW2bQdTfR619TNMW2z3i+00k2uRUYKYoxKYMRuqQbLC5JXVUbceKvWrlAurh0h9NurwRVcTeqvULVvWxHhXDTpnqk7T8nT2o295TMkTyW9zXdU9D2yvObrm5Zo1CMzojVO1bH4ZeWEdE3WV0dmmMOXC6hHWAVJXHb7oakJvlbply5oY72EdoXXXaVqezn70LY8peSL5ba6ruueB7TVH17ysrIRTNQAAAACAVbAhAgAAAEDiSfSGSNaBK6xDsUpeFScznXqoOrnZtm1YB0hddfiiqwm9VeqWLWtivJtw4tTdDl/727c8puSJ5Le5ruqeB7bXHF3zsriY7BLEHFWnateOsabKunZe9tnmYdOzpdlyxvZtPNlOC1s2rHzf6w+jn8000zYMW0fU7eT7OGyYDqdqT5yqXTvGmirr2nnZZ5uHTc+WZssZ27fxZDstbNmw8n2vP4x+NtNM2zBsHVG3k+/jsGE6nKoBAAAAACyDDREAAAAAEk+iN0T5Tm536Rhrqqxr52WTuumQYcLutpyxfRtPttPClg0r3/f6w+hnM820DcPWEXU7+T4OXTpVF7DnZhRjtm/fTkVFRVRXV0eFhYWN0lasIOrbl6iqiuiEE5ypCAAAAACJ728TJPoOEQAAAAAAAxsiAAAAACSeRG+IRH07AAAAABBvEr0hasqmTUS33fbNT9E0V9ezpfmmZ1TsI5vflZw4XJct45s+tmRhHEX/uqs54EpP3fpXVJBdgpgjE5hRZ3As09ezpfmmZ1TsI5vflZw4XJct45s+tmRhHEX/uqs54EpP/fojMCMAAAAAgFWwIQIAAABA4kn0hqhpYMZMTtapZ5wsT6a02bOJxo/PHjSLlWv4jLRhHQ2fn+YKvsXks3qaPmfNlNZUTi79c8kX0V/UDrnki+qZLYhmNntmqyObntnaLNvebLrK9rtIm3X0jYicsGNIpG9y6Wp6LKr0j0hQVxN2lZWRS1cZu+aTIzLHba0Vuuwvu+Zkaq+ucSI7h2Xki+g5PmS/yMpI2bOsjOwSxBzVw11F8tgoH1aG6zZGTYYOOb7ooSsPZPiriy/zwrcxraOuKPVPXNfwuhzf3yZI9B0iAAAAAAAGNkQAAAAASDyJ3hCFPeTORvmwMly3MWoydMjxRQ9deSDDX118mRe+jWkddUWpf5KyhhsniDm5nkHW1ATBxInf/BRNUynjQ7oLvVVs6EpXXek+6OC6jbbTwpY1WbcuGXFP910H39ZWHW3Kl17jsF2pPGVldn2IEr0hUnFEM+ngbDLdhd4qNnSlq650H3Rw3UbbaWHLmqxbl4y4p/uug29rq4425Uuvctiu/8uTIKfqV199lYYMGULdunWjgoICevbZZxulsw3brbfeSiUlJdS2bVs688wzae3atc70BQAAAEA8cboh2rFjBx133HE0bdq0jOl33XUX3XvvvXT//ffT0qVLqX379jR48GCqr6+3risAAAAA4ksLl5WfffbZ/JMJdndo6tSpdPPNN9PQoUP5tT/96U/UtWtXfifpwgsvDF2/iiOaSQdnk+ku9FaxoStddaX7oIPrNtpOC1vWZN26ZMQ93XcdfFtbdbQpX3qJw3al8rDAjJMnkz0CT2CqzJ07N/33unXr+LU333yzUb5TTjklGD16tHGnatW8OpzcdNVnWxfd+tvQ04UOpvVUKWPLBjaca0XzqOTXnc9l3VEdhy7XLJvt8H0M1VgYP7YDM3q7Ifr73//Or9U0sdr5558f/OQnP8kqp76+nhsv9amurg4VqVo2rw4nN1312dZFt/429HShg2k9VcrYsoEN51rRPCr5dedzWXdUx6HLNctmO3wfQ1UWxg8iVYekoqKCioqK0p/u3bu7VgkAAAAAnuPthqi4uJj/3LJlS6Pr7O9UWibKy8uprq4u/amurjauKwAAAACijbcbop49e/KNz8KFC9PXtm/fzt82Ky0tzVqudevWVFhY2OiTjVwn/DYk3+nmoqdOi+QR1S2fLBGdReph5DolPJNO+U5xz5ev6cno+U5FzpYnWz7V9onkE7GnaN9mO5E908nWYcZj2P4SHXf5xqTo/BDpB9E+Fc0vqptsvlw2bToOVOeKjLxsMmXXFdW6RNooMlZzrYvZ2iYyv0TWoab5cuXJNeZE6xLV3bb+Yb9LRWVqJXDI559/zp2m2YepMmXKFP77hg0bePrkyZODTp06Bc8991ywcuXKYOjQoUHPnj2DnTt3WjvtXjSf7meuNgJf6c6nS5btZ/m+6W7LPrb9YWz7TOj0I/J1Ptn2M/HVDqJ5XdhUhz1N6G5bf5X6bPsQOX3tfvny5XTaaael/x7Pto1ENGLECJo1axZNmDCBxyq65pprqLa2lgYNGkQLFiygNm3aONQaAAAAAHHD6Ybo1FNP5fGGssGiV99xxx38AwAAAACQOB8iG4gEhxLNpyuPzcBXuvPpkmWzLh91t2Uf3bbJl1fXmBXNKyMvrO5xWFOibAfRvC5sqsOeJnS3rb+pNmgliDm6AjOq5Fct42NwNZ1BxFTyq5aRKeeLzZMo30WQOp1lo1JOtazN+RqmrOuAjGHLJt3OTUlsYEZT6HCqVs2vWkamnI3gWCL5k2RLX/SIk3zbDte6y0alnGpZm/M1TFlTetpqS9Lt3BQEZgQAAAAAsAw2RAAAAABIPIneEIkE0ZMNSqcrWGDYwIy6AnnJBMsTDRqYL6hXmGBhNmypMg5UgqeJ2lK0nSoB1XQE0cwmT0YnmXmkMk7CBPSTsb3usSS7rugOrJirblUdZQJlhu37fIFEZQOXhp3Pst9JTdssqlO+tpuoU2TdcRqUkRHEnLA+RLYDn4nm0aW7S9+gbHlt94uP9cnWqVtH0Xw6dTTRXlvtNOUnojuv67Gnqz021j/dbbK1ZuvM4/r7Bj5EAAAAAACWwYYIAAAAAIkn0RsiHwOfieaxFdjNROCtfHnjHqxNd3A7EzqK5tOpo8sgb2HbacL2JvK6Hnu62mNj/dPdJltrts48vn/faCeIOToDM+rEdBC9sGVd161TjmsZLoLvmZBjUr4rG+m2jemAda7Hskl5NoK72pLr27jULbfGUvsQmNHjwIw6MeXcqKus67p1ynEtw2bwM5NyTMp3ZSPdtlGRZ8rJ2qQME/JMvkRgUg8TMnxum832wakaAAAAAMAy2BABAAAAIPEkekOkGkxNR17RYF2ygcZUgm5l07mpg5vOYIi56tXVftHgdyb1CGOLfHrrCnKnIlfWvvnkquqYL2CoTL+K5M8nP5stdARJ1dWXKjqakpevL0XsJppfVDfZMWHCJjLfTS7WghLF4LEi89ZpcMYg5ujyIYpzXtH8JuqPUvtNy/ZFZ91jQbSM6/FlMr9Om0al33W0x4e5Frdx66rtKmMMPkQAAAAAAJbBhggAAAAAiSfRG6KoBFMznVc0v4vAfzby+iLbF511jwXRMq7Hl8n8Om0alX7X0R4f5lrcxq2rtptcW7QRxByVwIy5gkb5kpYvsJVumar1+dJum/aw2WYf5NlOgx7R098X/VTq80UP2zrWeDAGEJjRA6dqVSc/m2lhnN10t9uETN3ttmkPm232QZ7tNOgRPf190U+lPl/0sK1jlQdjAE7VAAAAAACWwYYIAAAAAIkn0RuibM5bqk5+NtPCOLvpbrcJmbrbbdMeNtvsgzzbadAjevr7op9Kfb7oYVvHEg/GgHWCmGPztPuw8lTKh6lTtKyNOsLWE1amrrpdjAEX5cKWVZETJdvIyhDJZ7OvbK5FNnTTLUPVYVqHDra/J1zOVzhVR/i0+7DyVMqHqVO0rI06wtYTVqauul2MARflwpZVkRMl28jKEMlns69srkU2dNMtQ9VhWocOtr8nXM5XOFUDAAAAAFgGGyIAAAAAJJ5Eb4hkTxTOR1jHMJHysieii9Yne6q0TB2ipyvr7g9bbUzB5LJ2svaGGQMyp1GH1V+lnOhJ87p1sNnGMOVUZIjk0zXXTeQPo5+KbipzROdak09nEfk2x2WuMrKny5cI1q9qY6cO1kHMselDZANTOpu0hW0/nqjL931c+q4fiD+ufPV8kZ+U75Q6+BABAAAAANgFGyIAAAAAJJ5Eb4i8CQblgc4mbWHaR0S3Hq7l+z4ufdcPxB8b/ppJmSNR/E4xRhBzdARmjEoAOpWypgInmmyD78EoXZc3HeRPRIbL4HG6x48v415XeRc6ugi66nugSJ3z1Haf1liYEyx/WRkCM3rnVB2VAHQqZU0FTjTZBt+DUboubzrIn4gMl8HjdI8fX8a9rvIudDThuGtqnbAVKFLnPLXdp1UW5sQ35eBUvQ/Tpk2jQw45hNq0aUMnn3wyLVu2zLVKAAAAAIgR3m+I/vznP9P48eNp4sSJtGLFCjruuONo8ODBtHXrVteqAQAAACAmeL8hmjJlCl199dV0xRVX0FFHHUX3338/tWvXjh555JHQskUDR6kGAlMJoiga3C9bMC3ZAFwy+TPlldFDNABYvmCKosEWRduQKW8Y/XWMmWxBD0V0yDWuZYIq5qsrl41kgzbmGveids9Vd76+zVWXTMBUlWCVsmVzzTmRMSczNlXXsDBzNl87M8lUXd9z6crKia5XsnM93zovOyZ09ekmiTVapL4w85rlLysjuwQes2vXrqB58+bB3LlzG12/7LLLgh/96EcZy9TX1/PnjalPdXW1lsCMtnwiTD4zNvFs3LUNdfoRuPQ90amDLt8em35AOnQ2LcNEOZWyNtvpagyr1h2VuWLC/8nmPLFlXwRmbMCnn35Ke/bsoa5duza6zv7evHlzxjIVFRVUVFSU/nTv3t2StgAAAACIKl5viFQoLy+nurq69Ke6utq1SgAAAADwnBbkMQcccAA1b96ctmzZ0ug6+7u4uDhjmdatW/NPChZagLF9+/Z98nbo8M0zSvYzQ7JyXhtlbOgjkt+1DcOmm5Klkl+XDrnyuO4vlXI65oTJeRWmnEpZm+10NYZV647KXNG91siUsdnmDiHrSn1vp77HTVMQ2KpJEfaa/UknnUT33Xcf/3vv3r3Uo0cPuv7666lMwOPqww8/pMMOO8yCpgAAAADQzbp16+jQQw+lRN8hYrBX7keMGEEnnngi3xhNnTqVduzYwd86E2H//ffnPzdu3Mh9ioA72G6f+XSxx5iFhYWu1Uk06At/QF/4A/rCL5jbC7sBkvoep6RviC644AL65JNP6NZbb+WO1H369KEFCxbs42idjWb/+84l2wxhgPsB6wf0hR+gL/wBfeEP6Au/SH2PU9I3RAz2eIx9AAAAAABMELu3zAAAAAAAZIn9hoi9ccaO/Wj45hlwA/rCH9AX/oC+8Af0RbL7w/u3zAAAAAAATBP7O0QAAAAAAPnAhggAAAAAiQcbIgAAAAAkHmyIAAAAAJB4Yr8hmjZtGh1yyCHUpk0bfgzIsmXLXKsUKyoqKqhfv37UsWNH+ta3vkXnnXcerVmzplGe+vp6GjVqFHXu3Jk6dOhAw4cP3+d8OhZJ/Nxzz6V27dpxOb/85S/p66+/ttyaeDF58mQqKCigsWPHpq+hL+zx8ccf009/+lNu67Zt29Kxxx5Ly5cvT6ez91lYwNmSkhKefuaZZ9LatWsbyfjss8/okksu4UECO3XqRFdeeSV98cUXDloTXfbs2UO33HIL9ezZk9uZHeX0m9/8ptH5WOgLc7z66qs0ZMgQ6tatG1+Pnn322Ubpumy/cuVK+u53v8u/61m08bvuukte2SDGPPnkk0GrVq2CRx55JFi9enVw9dVXB506dQq2bNniWrXYMHjw4GDmzJnBqlWrgrfeeis455xzgh49egRffPFFOs91110XdO/ePVi4cGGwfPnyoH///sGAAQPS6V9//XVwzDHHBGeeeWbw5ptvBi+88EJwwAEHBOXl5Y5aFX2WLVsWHHLIIUHv3r2DMWPGpK+jL+zw2WefBQcffHBw+eWXB0uXLg0+/PDD4MUXXww++OCDdJ7JkycHRUVFwbPPPhu8/fbbwY9+9KOgZ8+ewc6dO9N5fvCDHwTHHXdc8Prrrwf/7//9v+Dwww8PLrroIketiiaTJk0KOnfuHDz//PPB+vXrgzlz5gQdOnQI7rnnnnQe9IU52Bry61//OnjmmWfYDjSYO3duo3Qdtq+rqwu6du0aXHLJJfy76Iknngjatm0bPPDAA1K6xnpDdNJJJwWjRo1K/71nz56gW7duQUVFhVO94szWrVv5oK+srOR/19bWBi1btuSLUIr33nuP51myZEl6wjRr1izYvHlzOs+MGTOCwsLCYNeuXQ5aEW0+//zz4Nvf/nbw0ksvBd/73vfSGyL0hT1+9atfBYMGDcqavnfv3qC4uDj43e9+l77G+qd169Z8MWe8++67vG/eeOONdJ758+cHBQUFwccff2y4BfHh3HPPDX72s581ujZs2DD+5clAX9iDmmyIdNl++vTpwX777ddojWJz8IgjjpDSL7aPzHbv3k1VVVX89lvD81DY30uWLHGqW9wP42OkDuNjffDVV1816ocjjzySH9iX6gf2kz1OaHg+3eDBg/lBi6tXr7behqjDHomxR14Nbc5AX9jjr3/9Kz+Q+vzzz+ePHY8//nj64x//mE5fv349P5uxYV+w8xbZY/2GfcEeDzA5KVh+to4tXbrUcouiy4ABA2jhwoX0/vvv87/ffvtteu211+jss8/mf6Mv3LFek+1ZnlNOOYVatWrVaN1i7hvbtm2L11lmKnz66af82XHTQ2DZ3//85z+d6RVn9u7dy/1VBg4cSMcccwy/xgY7G6RsQDftB5aWypOpn1JpQJwnn3ySVqxYQW+88cY+aegLe3z44Yc0Y8YMGj9+PN100028P0aPHs3tP2LEiLQtM9m6YV+wzVRDWrRowf+zgb4Qp6ysjG/o2ea/efPm/Hth0qRJ3CeFgb5wx2ZNtmc/mY9YUxmptP322y/ZGyLg5s7EqlWr+P++gH2qq6tpzJgx9NJLL3HHQuD2Pwfsf7R33nkn/5vdIWJz4/777+cbImCPp556imbPnk2PP/44HX300fTWW2/x/7gxJ1/0BWhIbB+ZHXDAAfx/A03foGF/FxcXO9Mrrlx//fX0/PPP0+LFi+mggw5KX2e2Zo8va2trs/YD+5mpn1JpQAz2SGzr1q10wgkn8P9BsU9lZSXde++9/Hf2Pyb0hR3YGzNHHXVUo2u9evXib/A1tGWu9Yn9ZP3ZEPa2H3vjBn0hDntLkt0luvDCC/nj4EsvvZTGjRvH35BloC/cUazJ9rrWrdhuiNit6b59+/Jnxw3/18b+Li0tdapbnGB+cmwzNHfuXFq0aNE+ty1ZH7Rs2bJRP7DnuuyLIdUP7Oc777zTaNCzuxzsFcumXyogO2eccQa3I/sfcOrD7lKwRwOp39EXdmCPjZuGn2A+LAcffDD/nc0TtlA37Av2WIf5RDTsC7Z5ZRvdFGyOsXWM+VgAMb788kvub9IQ9p9lZkcG+sIdPTXZnuVhr/czH8mG69YRRxwh/LiME8T8tXvmrT5r1izuqX7NNdfw1+4bvkEDwjFy5Ej+yuQrr7wSbNq0Kf358ssvG73qzV7FX7RoEX/Vu7S0lH+avup91lln8Vf3FyxYEHTp0gWvemug4VtmDPSFvbAHLVq04K98r127Npg9e3bQrl274LHHHmv0ujFbj5577rlg5cqVwdChQzO+bnz88cfzV/dfe+01/vYgXvWWY8SIEcGBBx6Yfu2evf7NQklMmDAhnQd9YQ721isL4cE+bMsxZcoU/vuGDRu02Z69mcZeu7/00kv5a/fsu5/NN7x234T77ruPfwGweETsNXwWxwDogw3wTB8WmygFG9g///nP+WuRbJD+x3/8B980NeSjjz4Kzj77bB47gi1WN954Y/DVV185aFG8N0ToC3vMmzePby7Zf8qOPPLI4MEHH2yUzl45vuWWW/hCzvKcccYZwZo1axrl+fe//80XfhY3h4U+uOKKK/gXDBBn+/btfA6w74E2bdoEhx56KI+L0/AVbfSFORYvXpzxO4JtVHXansUwYqEumAy2AWYbLVkK2D96bn4BAAAAAEST2PoQAQAAAACIgg0RAAAAABIPNkQAAAAASDzYEAEAAAAg8WBDBAAAAIDEgw0RAAAAABIPNkQAAAAASDzYEAGQIF555RUqKCjY5zwzIM8tt9xC11xzjTH5n376KT/l+1//+pexOgAA/wcCMwIQU0499VTq06cPTZ06NX2NHe7KDkVkB72yjZGrTdlpp51G27Zto06dOlEU2bx5M33nO9/h576lziczwS9+8Qtup4cffthYHQCAb8AdIgASBDv0mB2m6GozFBceeughGjBggNHNEOOKK66g2bNn800sAMAs2BABEEMuv/xyqqyspHvuuYdvftjno48+2ueR2axZs/hdmueff56fDN2uXTv68Y9/zE8If/TRR+mQQw7hp0WPHj2a9uzZk5a/a9cufvfiwAMPpPbt2/NTp5nsFBs2bKAhQ4bwsiz96KOPphdeeIHrwO4OMVga04XpyliwYAENGjSI69O5c2f64Q9/SOvWrUvLZGVZ/qeeeoq++93vUtu2balfv378FPk33niDTjzxROrQoQOdffbZ9MknnzSyxXnnnUe33347denShQoLC+m6667jd8tSPP3003TsscdymazuM888k3bs2JHVvk8++SRvX9M7cjfccAONHTuWt43dhfvjH//I5bCNTceOHenwww+n+fPnp8uwuz+XXHIJ14vV/e1vf5tmzpyZTmd269atG82dO1dhFAAApAh1ahsAwEvY6c/sFPurr76aH97KPuwk+9RBi9u2beP52CG8LVu2DL7//e8HK1asCCorK4POnTvz0+5/8pOfBKtXr+aHlLLDkdkJ0imuuuqqYMCAAcGrr74afPDBB8Hvfvc7fqji+++/z9PPPfdcLpOdXr1u3Toug8lmOvzlL3/hOrADHJleTFfG008/zdPY6fDsNOwhQ4YExx57bLBnzx6ezk4qZ+XYQakLFiwI3n333aB///5B3759g1NPPZWfgs3acPjhhwfXXXddWld2iCQ7FPKCCy7gJ2GzU8+7dOkS3HTTTTy9pqaGn0zPTuFmdTCdp02blvXgTnbQZEFBwT4HRbODdDt27Bj85je/4XZgP5s3b84PymUHu7JrI0eO5PbdsWMHLzNq1KigT58+wRtvvMHrfumll4K//vWvjeQyvVMHYQIAzIENEQAJOemekWlDxP5mm5oU1157bdCuXbtGG4LBgwfz64wNGzbwL/qPP/64kWx2SnV5eTn/nW1kbrvttox6NdUhG5988gnP98477zTaED300EPpPE888QS/tnDhwvS1ioqK4Igjjkj/zTYT+++/f3oTwpgxYwbfJLHNVlVVFZfx0UcfBSKwzRrLv3Hjxn3szU7bTsE2f+3btw8uvfTS9DW2AWRllyxZwv9mmz52cncuxo0bxzd8AACz4JEZAAmHPSY77LDD0n+zRz3sURl7/NTw2tatW/nvzJGYPT5jTsUsT+rDHtGlHnGxR2z/+Z//SQMHDqSJEyfSypUr8+qxdu1auuiii+jQQw/lj7WYDoyNGzc2yte7d+9GejHY465MuqY47rjjeDtTlJaW0hdffEHV1dU87YwzzuAyzj//fP6Yiz3KysbOnTv5zzZt2uyT1lC35s2b88dvTXVjpPQbOXIkf/zGnN8nTJhA//jHP/aRyR6lsUeYAACzYEMEQMJp2bJlo7+Zn06ma3v37uW/s40E+7Kvqqqit956K/157733uM8S46qrrqIPP/yQLr30Ur6BYv499913X049mE8Ocx5mG5KlS5fyD6Ohr09TfVPO4U2vpXQVgbXlpZde4r49Rx11FNeT+VOtX78+Y/4DDjiA/8y0acpny5S+Kf2YvxPztxo3bhzV1NTwjRnzzWoIswnzMQIAmAUbIgBi/EZZQ0doXRx//PFcLrvLwZyEG37YG2wpunfvzp2Xn3nmGbrxxhv5RielF6Ohbv/+979pzZo1dPPNN/NNQa9evXLepZHl7bffTt/ZYbz++uv8rhbTMbVRYXezmOP1m2++yXXM5sjM7qaxO1jvvvuuFt3YZmfEiBH02GOP8RAJDz74YKP0VatWcZsDAMyCDREAMYU9cmJ3WdjbWSzIn8xdk1ywR2XszajLLruMb3bYnZRly5ZRRUUF/e1vf+N52JtWL774Ik9bsWIFLV68mG9yGOxVdbYBYW+2sbfB2B0n9lYWe7zENgMffPABLVq0iMaPH0+6YHeZrrzySr6JYW+7scd4119/PTVr1ozb6M4776Tly5fzx3OsTUyvlL5NYWXYW2ivvfZaaL1uvfVWeu6553ibV69ezW3SsF72qIzdiTvrrLNC1wUAyA02RADEFPbohT0OYo+B2F2Ipr44YWCvhrMNEbvzwx4vsdfa2avvPXr0SN/9GTVqFP9y/8EPfsA3UdOnT+dp7FV9diemrKyM+9SkNibMl4Z9+R9zzDH8EdLvfvc7bfqyu07slfZTTjmFLrjgAvrRj35Et912G09jd3teffVVOuecc7ie7C7V73//e/44KxvskSDTN+wmk92JKi8v575HTDfWX0xuCrZZYjZlYQYAAGZBpGoAQKxhcYhY3KVnn31Wm0y2bLLYS2zjxhzBTdG/f3/uoH7xxRcbqwMA8A24QwQAAJKwR37s8d7XX39trA72mHPYsGFGN1wAgP8Dd4gAALHGxB0iAED8wIYIAAAAAIkHj8wAAAAAkHiwIQIAAABA4sGGCAAAAACJBxsiAAAAACQebIgAAAAAkHiwIQIAAABA4sGGCAAAAACJBxsiAAAAACQebIgAAAAAQEnn/wN4ZKJoLxlR8wAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAksAAAHHCAYAAACvJxw8AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAqw5JREFUeJztnQeYFEXax2vJLDnnKEpSTkyI4QwYwJz1FBREMWAEA5jg8EAUw6mfZwYTHuopihgRVFQQ04FkVCSIJEFY4hJ2vuetvZqprq6q7p7YPfv/Pc+IO6G7urvCW28siMViMQYAAAAAALSU078NAAAAAAAICEsAAAAAABYgLAEAAAAAWICwBAAAAABgAcISAAAAAIAFCEsAAAAAABYgLAEAAAAAWICwBAAAAABgAcISAAAAAIAFCEsAgDLHCy+8wAoKCtiyZcuS+t13332XsbYBAMIHhCUAAAAAAAsQlgAAZY4+ffqwHTt2sFatWuW6KQCACFAh1w0AAIBsU758ef4CAAA/QLMEAGBl3WepdevW7LTTTmNffvklO+yww1iVKlVY27Zt2UsvvaT9fXFxMRs0aBBr0KABq1atGjv77LPZ+vXrs3wVAIBsAWEJAAAYYz///DM777zz2IknnsgeeughVqdOHda3b182f/5813evv/56NmfOHDZs2DB2zTXXsHfffZddd911OWk3ACDzwAwHAACMscWLF7Pp06ezo48+mv99wQUXsBYtWrBx48axBx980PHdevXqsY8//phrp4iSkhL22GOPsc2bN7NatWrlpP0AgMwBzRIAADDGOnXqFBeUCDKxtW/fni1dutT13QEDBsQFJYJ+t3fvXrZ8+fKstRcAkD0gLAEAAGOsZcuWrvfIFPfnn396fpe+R+i+CwCIPhCWAADgfxFyOmKxWErfBQBEHwhLAAAAAAAWICwBAAAAAFiAsAQAAAAAYAHCEgAAAACAhYIYPBIBAAAAAIxAswQAAAAAYAHCEgAAAACABQhLAAAAAAAWICwBAAAAAFiAsAQAAAAAYAHCEgAAAACAhQq2D4E/SkpK2O+//85q1KjhqEQOAAAAgPBC2ZO2bNnCmjZtysqVM+uPICylARKUWrRoketmAAAAACAJVq5cyZo3b278HMJSGiCNkrjZNWvWzHVzAAAAAOCDoqIiruwQ67gJCEtpQJjeSFCCsAQAAABECy8XGjh4AwAAAABYgLAEAAAAAGABwhIAAAAAgAUISwAAAAAAFiAsAQAAAABYgLAEAAAAAGABwhIAAAAAgAUISwAAAAAAFiAsAQAAAABYgLAEAAAAAJAPwlLr1q15OnL5NXr06Pjny5Ytc31Or6+//tp63BUrVrBTTz2VFRYWsoYNG7Jbb72V7dmzJwtXBAAAAIAoEKnacCNGjGBXXnll/G9d4btPPvmEde7cOf53vXr1jMfbu3cvF5QaN27MZsyYwVavXs0uvfRSVrFiRTZq1KgMXAEAAAAAokZkNEtCOCLBRryqVavm+g4JR/J3SPAx8fHHH7MFCxawV155hR144IGsV69e7N5772VPPPEE27VrV0auIRaLxf8tKSmJ/237vu436u/kz+hfgfh/+T0Z9X31uKbfyee0/d4L3ffl93TXajtWKuf38zy8vuP3eXpdt+k9v7/LBra+IZD7ru3zZMnVtatt8Lo++V8/31f/308bdOPfdOwgn9OmMpX7bPqtbp4y/e31vm1uFL+T732y12M7vp/x4HVfdcdIVx9P5jhBrilm6XumYyezDpo+T7Zdfu9LQSwMs41PM9zOnTvZ7t27WcuWLdnFF1/Mbr75ZlahQoW4Ga5NmzasRYsW/Hv77bcfu+2229gZZ5xhPOY999zDJk2axGbPnh1/79dff2Vt27ZlP/zwA+vatav2d8XFxfwlKCoq4ufdvHkzq1mzZvz9adMWsffeq80uvHArO+ywduzPP//k2qvy5cvz6yDIVEjX8/vvv7Ny5crxAURmwEaNGrE//viD/03fp+9Q22TIdEi/oWNQe8Qx6ZGSILl9+3ZHR6C27dixgwuU1atXZ2vXrmVbtmzhx6fOROdct24d/4zeo/YSdA76DZkp6TfUrqpVq/JjCeh84m86D52b2kPHohddt/he8+bN+TP67bff+HkrVarEvyt3aHreJOguXbqU3wM6BgmwdG+aNm3Kn/vWrVvZhg0b4vdN0LFjR7Zx40b+/W3btsXvM32PzkPXRr+n89L1165dm9WtW5ctWbKEf4/uK/2OvlO5cmX+ffqb2kPtpvfoedD10ovOXb9+fd6eNWvW8PPR5/RM6B5S2+me0LmoXfRMqC3t2rXj36d7Rfee7lGtWrX4ceg79Bv6vWg7nZ+OSeen81H76f7Qd9u3b88/p2OtWrWKf49+Q1D7W7VqxfsnPTe6h3Reep/aXqdOHd5Geo+uWdwzOj69aJNCbaB7Tc+Izk/3kc7RpEkTtn79eofpmn7TrFmz+POl39Ln1OYGDRrw/kP3ja6ToL5Fz4DuDd17+ozavmnTJv47+n/qM/QZmc0Juk4BjT36DX2X7jFdE52TnindG2ovnYPGqfi9QPR1+pfGoBgvtNGi84v7TW2gc9AzofPR96gv/PLLL45jUb+l49Bzo/tG5xT3WYaOQ/ed7indc3o2dB46Jo0ROj5dI52X+gQ9E+ojVapU4WOUrpXeo9/IcxFdN/1W9HH6f7q39BsB3Qu6FjoPnV/0KzHW6bc0l9Jnor8SdD3Uj2hc/fzzz/x90V/pd+K81AbqH/Se2HTSe/R7eok2Uz+lNoq+Q9+nttJndG10rTTW6W8xf1B/oj5Mx6Pf0rOgZ0rPXUDHEc+B7qe4/9Qv6Tei79DxRf+k9tJnNCbpePQbMX/S/aHf0v/TeehfWiMImpPp92LuomdKz5b+pv5K7ab7Q32D7judk469aNGi+HXTvRZzA/2Ofk/9j8YPPSc6N40zOhZ9TnML3R8ad+I+0PXSdVPb6Zrpb/rdwoULeXvFfaZj01ii79Ix5DWF2kjnIei50fnpvtEzi8Vi8TWDoOdO36F7RNdJ7aLnJPoA/YaORe/TuWluoTFB91LcUzq/6K9i3hDzMj13gq6FzinmJFqD6EWI+ZaenWgn9QfxPKgd1O9F36e+RddAx6TnROOb7iEdp3v37q71O7LC0sMPP8wOOuggPgGSyWzo0KGsX79+/H2CJuCXXnqJHXnkkbwjvPnmm+yBBx5gb7/9tlFgGjBgAFu+fDn76KOP4u/Rw6dJ5P333+eaJh3Dhw9nf//7313vqze7detitnx5ZXbCCZvZlCm12Lx585K+fnlSyRXU0cQCl2mowxPJdE96BrRIhQ3ql0F3n0H6BwkjQljLR1K5f/vss49DsEkFMdHq+mY6z5NLaEGSBSwBCRMkKIUFnSCaCrTwy4J4KvOxrm1iI6FufFNFFjq82kjzBAljuvWIhBix6c5k27ygjQEJMrrxvv/++/N/de2nsUlrFF2D7VnKbYqEsDRkyBB2//33W79DknGHDh1c748dO5ZdddVV/EJpp6KD/I+oU37xxRdpFZb8apb+t96zGjX2sqKi8ikJS+meFPKZTAx4AHItEGcT2pSSpkOFtCOkcQLJQwu60NrnAtJukdCbynqUaUhzReupDhKWaH5fvHhxWs7lV1jKqYP34MGDWd++fa3fEepOlW7dunGpmcxvZIIwfWfKlCnGY5N0/c033zjeE2pG+swECWcmAU1HtWok5JRnqRARBWAowL0CuSIfBCUiWb8n4E2uN71Cax9mCjzamIt7mFNhifwX6JUM5GdEuzhhvzR9R9hgdZA0OXLkSK5uFsch4Yqky06dOrF0Ub166hNovkzC2QATOgCpgfkmf+8thKU8Th0wc+ZMNmvWLHbcccdxJy76m5y7e/fuzVWaxIsvvsjtwcIp+6233uKmuueeey5+nIkTJ3JfJ3KuI0466SQuFPXp04f7N5G/x1133cUGDhwYSHPkRWEhJp6yNBkBEHVMixE2ItGfn2yCSDL+RZnAK7oNwpIBElwmTJjAHavJV4iiB0hYGjRokON7FPZPPkjk2EZ+Tq+99ho777zz4p+TTVK2c5If0OTJk9k111zDtUzkq3TZZZfxfE7ppFo1LN7ZJAyDHYAoA2GpbApLYaHA0kbqm7kQliITDRdmyMFbOKTpHLx79NjMPvkktWg4AADIFqaAkrBGmkYJNd1DthEpIHTrUVgCFOpYnOD33XdfnmohXZG/fh28I5WUMqrADAcAiBLQLGWOXAsjUdcslZSU5ESzBGEpQ6xb90f8/yEsAQDyAQhL0b+HuRbWUr1HEJbyjPXrSzOOEhCWAAD5QBQW2rCT63tIZieTGTDXgpwAwlIZYv36nfH/r1w5HB0QAABSISyLaVQJS7SZnyzlYRaWSnIgcEJYyhDbtiVsrhEwEQMAgCdhWOijjKjXmGsyVdg6XdiEIQhLecb27bi1AID8ItcmpKgjCg7nmrA/xxg0S2WHbdsStzYEYwMAAFImDAt9lAmLZinXJVe8sAlD1HYIS3kENEsAgHwj7Its2AmLsBn251gCM1zZAcISACDfCMtiD1IDZrjgYEXPENu3l891EwAAAIDICUsl0CyVHaBZAgDkG9As5QdhTx2wZ88e42ckKOWiH2JFzxAQlkA+EYUSCQCEnbAImzZhJApmuFyAFT0L0XBhGiQAJEPU+y+EPRAGoj6OyrJzOoSlLGiWMD4AAACA6AqcEJayZIbDjgKA3AHNEgD5wV5olvILCEsAAABksA6kDnyW8gwISwAAAEB6gRkuz0A0HAAAABlsmlMHwlKesW2bMyklBgkAAACQGhCW8gyY4QAAAMhgHYguEJYyxI4dztQBGCQAAADCTOXKlXPdhNACYSkLwhIBYQmA3IHxB4A3EJbMQFjKAOvX/+ESlgAAAAAQTbCiZ4CiomLXe9jZAgBA2Sbs60DY25dLICxlgA0bdrjeQycEIHdg/AEAUgHCUgYoKnJXdMZkDQAAIMxgnTIDYSkD7Nzpvq3ohAAAAMIM1ikzEJayICyh/wEAAADRBcJSBti5013hHBI7AACAMIN1ygyEpQwAMxwAAACQP0BYygAQlgAAAEQNrFNmICxlyQwHAAAAhBkIS3kgLLVu3ZoVFBQ4XqNHj45/Pnz4cNfn9KpWrZr1uLrfTJgwIaW26rJ3oxMCAAAIC7NnV2WnnLIv+/zzGvH3sE6ZqcAixIgRI9iVV14Z/7tGjcRDvuWWW9jVV1/t+H6PHj3YoYce6nnccePGsZ49e8b/rl27dkrthBkOAABAmBkwoA3f2F93XSs2d+48/h7WqTwRlkg4aty4sfaz6tWr85dgzpw5bMGCBeypp57yPC4JR6bjJgOEJQAAAGEG9UuDEam7RWa3evXqsa5du7IxY8awPXvcmbIFzz33HNtvv/3Y0Ucf7XncgQMHsvr167PDDjuMjR07NmXBBqkDAAAARA2sU3mgWbrhhhvYQQcdxOrWrctmzJjBhg4dylavXs0efvhh13d37tzJxo8fz4YMGeLLtHf88cezwsJC9vHHH7Nrr72Wbd26lZ/PRHFxMX8JioqKlPNHSgYFAAAAQFiFJRJm7r//fut3Fi5cyDp06MAGDRoUf69Lly6sUqVK7KqrrmL33Xcfq1y5suM3EydOZFu2bGGXXXaZZxvuvvvu+P+Txmrbtm1ca2UTluicf//7342fQ1gCAAAQNaBZCqmwNHjwYNa3b1/rd9q2bat9v1u3btwMt2zZMta+fXuXCe60005jjRo1CtwmOu69997LNUeqECYgrZYsvJFmqUWLFvG/YYYDAAAA8oecCksNGjTgr2SYPXs2K1euHGvYsKHj/V9//ZV9+umnbNKkSUkft06dOkZBiaDPbJ/DcQ4AAEDUKCkpyXUTQkskfJZmzpzJZs2axY477jgeEUd/33zzzax3795csJEhB+0mTZqwXr16uY5D5jnSCi1atIj//e6777K1a9eyww8/nFWpUoVNmTKFjRo1iqchSAVhhqtSpYT/fyxWAM0SAACAUIN1KuLCEmlxKFEkJZ4k81ibNm24sCSbwoRU/MILL3DTXvny5V3H2bx5M1u8eHH874oVK7InnniCH4s6Sbt27bjDuJzLKR3CEgAAABB2ICxFXFiiKLivv/7a83tkllu5cqXxcxKiZB8pSkQpJ6NMF8XFBXFhSYBOCAAAAEQTqD0ygPBZqlIFAhIAAAAQdSAsZQARDVe1KjRLAAAAQNSBsJQBZJ8lAAAAAEQbCEsZFZagTSprCH81AAAwsXs3WRtYKGjQYHeumxAJICxlQbNEgwJmuPxn7Nj67JBDOrMZMxIFnQEAQGbTpvLsmGM6siFDmrMwUKlSeNem2bOrsptuasF++61irpsCYSndrF//R9xnCWa4ssUjjzTm/w4b1jTXTQEaaFwuXFglNDt6UDaZNKk227KlPHv//do5a8PevYn/r1w5vOtUnz77sKlTa7E77si9YAlhKc0UFRXzJJSqGQ6apbJDmHdqZZkBA1qzCy5oxyZPzt0iBcCuXQWhcheoXDn889Xq1dAs5R2bNu2MhMQOMkfFiuGffMoi//1vNf7vW285s/4DkE127869sLRrV7lIbe4qh0Cgg7CUZrZt28P/LSiIsQoVcv+AQfbJ9eQzdWoN9tBDjRjKPOnBJgaUdWFJLvZerlz416lKIRDoIpHBO0rs3JmQhAukMQEzXNlh4cKqRj8BmigzHSV5002t+L9/+csOdsIJRRk9VxQJw8QLyi6yVidXFBcn2hCFpalSpdxvcHL/1PIMYQsOw8ONElEYsKlywQX7sO7dO7Jt27Iz7DZvdtdHBBCWUqWoqBxbuxb77HzRLEWByjDD5e+uQZ6QkTrAzt13N2O9eu3Htm/P7+64ZElVtmdPOTZnjl7zlC2hgISolStz7zCZK77/vjDXTYg0Rx7ZiZ1wQgcI4xF28Ja1WyIgKcxUDIEfaH6vTjnULKmSMIQlM2+/XYetWlWJ+9rkK7L/ULY0Gybt5lFHdWSnnNK+zGoH/vij7AqKqSJPY7/+WimXTYnEvdq+vSCUwpKsWYrC0lQ5BH6GEJYyaIaTfZZANFSt2QjVzaSwJE98Xucx+VZRdmEAdOzZE62Q81xy113NWLdundlPP1UOnRlO9lmKApWT6GszZlRj//hHk7SZHKN1xyKAUG9CsxQ8OVo+J/EUWd0zLSzJu1bdBOMlTD3+eEPWrVsntnixc4IHgNixA8KSXyZNKk1R8dJL9UMoLOW+DV58801pqo9kzXBXXdWGvfZaPfbKK/VYOoCwlDHNEiYSP+zYkeiC+VxLTxaWsjUJVqxY4qEZcH/+zDMN2e7d5dg//1majTxfwF4l/RoJpEZJzhweDmEp3NFwsRhj/fu3sQrmCxZUYUuWeG/q1qxJj9m9bDotZBCxs1cXImiWvIWlKE++Xo9X3pFnMv+R7LhZoYK9HRs2mId/vgn7YfATyTehH1OaP9SxFI7UAeH2WdohrQs6gXPLlnLswgvb8f+fPXseK2+JNdi7F2a4UIJouGDIEXC5ukV03iefbMA+/LBm0sfYU5qLlNOiRbF1kSkpydzCLdvn33+/lnVHOXx4M+Nx8i31RSZCpanI58kn75fXgQlRdwzOtMBB/khe90E1IWVTcJfdHHKh6U7XeC2nNHfduoq+N5//+U9dtmFD6pGb4b5jEQTRcMnvIDIpRHjZxv/1r0bs1ltbJn0MebdYr54kOWmElGxpliZMqGedJKmYp4kPP8yv+mmZcGilWnO//14pngS0LADNUoIrrmjNzjlnX/bRRzUDaZayZYZ78cV6PPKVikeryAJbGJ9jsTJe1TnTKXB638/p01Pf0EBYSjPiIWZiZy52Muli+vTqbNWq3IZRb9yYWLBzVZ7j998rptlXKJYzM5yX42bUktGF2aF1x46yl2dI7j+52tyEhdmzq8VTn4RRWHrwwSZs69bybNSoJh5Cb/ie405lnlL7WlBhzxSMIFsEvICwlCGJmAZIusudXH55G76TmTIleXOR4Msvq7OBA1uznj3bJy1o3XFHM1/ZqCkU/YsvqrOtW8tpIxZyLSylQyXt5YeQLTOct7BUNoe8l2aJzMFkVgvjLjtMyP3nww/dZt5cQs9u06bsC7BekVo2M5wuD1O60fkfhj0arjiAZsmfsOReXCZMqMsOP7wT++EHf0mCy+bMGVEz3I8/lmYefvvt2mkNy0wGErTefbcOe/55Z1isDoqwuvba1mzgQLu5Ilc71XRMHPIxdNchLzImP4J0EERoo2LPZQWvZ3z55a1Znz77sIkT7VqCso68iKVTy50Ohgxpzo4+uiP77rvsZmjXCSPOJLQlxoV+8uTMm7u/+aZ65MypOxXNktpGitg1fabTGOkirUeObMr787BhzX21CcJSxvIsZS4aLh2RSl5OhqVO6d7HsUVUCf7zn9IF6Icf7AJaspqlVHeUst/U6tUVMxJd4vw8l5ql7LQjbHhp1ObPL11gJ02qbbyvuTZZhwHZnBy2iMn33y99dmPHNkj5WBRufs457dibb9ZJSmshz6+qZikMqQPCHh26Q4mGUyPa5Pbr1g1102jLAO43OziEpSzlWUqnsJSOOjk2DQRJ5VT09frrvR2e/YT7mwamekuSvUUPPNCY7yinTauR8kJ60kntM6LRkQd/ZjVLyZvhwrjDzLb20CQAXHjhPtxkPW9edur6RUGz1L79ThZG0pHc9v77G7OffqpijRgVrF9fMZAPoyws5UrgDL9mqZzj73feqWOc53TO217RdHJ9Tr/JVSEsZSzPUuaEpXRkzrUtqnPnFrJFi6qyzz+v6bnI+BHcZJWprUMnmw/jlVdKTYGPPJJcIsV0+PE4zXD2c2RWs+TfDOf+bbh3m4IZM6rzxSzIDt1vNJwpMOOXX0ojirwin/Iduf+EVVhKhwASpEjw119XD5TvTP4sVwViwz7Wiz3aJ39OUcxqcXJ186rOyb177xP4GUBYyliepUya4UoyKizJnx1ySGdrwVV/wlKBr4U7VQfvZO9LOiYOp8Oh3WdJd52bN5djkyfXStnhM5VouKjUi7rqqtZcQH799TqOe3rVVa140IHXfalbd0/S/dnPQkzBDyZzXtSJQjRlOoqupmoqs5nl5dxyuUrEG3bN0g7FDOe1Ae/bNxEo5MfnKZl1IxqzYx44eKeTTPssqZ89/XTDlCq4yyU2bMJSqhqXZHdpXgPTD/JORjcwnSHX7s9vuKEVGzq0BRs9umna2hFUsyT7o0QBOTHdkiVV2IwZNXjQQSqLg3zMZMceBT/ceWfzvPRxSuciS7+fOLE2L1sRtvlRNq0l499ji9aSNei50iyFPc/STg9tv/pM9uwpZ9002tYWv/0FwlLG8ixR6oBYJHyWKGTa+Zn/ySGVaA63E1/wYyxfXinlSTIdwpKXg7dX6gDh/P7BB7VyljpA1ix167aVpYOlSyuxJ55oyIqK0j/VyM/bS+Phd3EQEafJai1kQbioKP/yMKXTfPP55zXYPfc0j5etCJPPkhy4ousvXtO5bfNUtWpiokt2U00aaEohI2upgsylYU8hUqz0M7XOpbeZTt2Im78LYSnneZbSa4ajWjiZ0ixRyHSykQSpoGoytm0Lvri8807tlO9LEP+EdAhLCxZUzZiJ1dvBu8DXZ9Wrp8cL/cwz92NPPdWQjRnjToyXKvLz9golTpdGxKuPyfc/kyYWWiyzkaPHtrEw3cc//qjATaSmhdzPOEiFdMyPXsJEEJ8a9T7J82uywR7keD5oUEuL2dl/wMnGjdktEfvJJzXZ4sVVAm1gO3Z0+sd5jWH1+dhcPGCGC5mDd6qMGtU0rZOBzSavdjS3szpLC+qAGDbMO/LEdh3JLk7pSGQnT4D6PEuJ95580mzWTLXfeKU+kBcB9X5lcreZiSgyebfpnbrBv7CkTqzy972ej1cm93RASV67devMjjiik6/Flvo3hcDLG65k8ePX1q9fG3bvvc24E34uwtcz6QLhV1gymcPp2clmOGEeoucYxGz7wQelm8SpU/WaaC9Nqzz3kisFtSsbzJ5dld18c0t23nl2baKYi0SdTVXjq/osqXOZev9tZjg4eOfcZym9miWKAErnJGwb7Ookpl6LyQcpKG+9lXoCQHlQJCtE1q2rX3FefbUue+ihRr4WJK/F2q+pj3wlUnGiff11dz04GfnY+++/3SJQ+G/DypUV2VlntWMzZpjzaGUiRFrWTMh99r33aqeU50oVGuXfeu1C5UlcDVdOFxs2lC6qtOh6aW8ISgZLmoi//z3YZmTJksps6VJn4kk/fXPZssq+6nGlM9+QvNinWxPuJXzrkPvMnDmFxkVczC2kJaLUFKR1SQdeGx+132QruGP+/KqB2i/3Ebk0lpeZLpiDN4SlHEfDyf5KqR9XLhWSnmi4cr4nMbUzpctvweSMGwRb8rdUfBx++KGQ3XdfU/bCCw18RTZ57ZKDTEaUhj9TyJOoqG2V+CxxDd9+6z/D+ymntOeh9XLpGpV0aVnksSR21+r9v+OO5uyPP8r77rPu8an2d/8CuZfQ7Ic33qjDTjxxP/bzz/oM2fJzKu9DKSp25UHKJJEW6txz92VnnrmvQ9MWJAWGl4YnnZoleT5Lt2Zp3Lj61ud87LFF1s/ffLOuxfG49N9p00qfzcsv2zc76RKW1M2bXJork+z0qb0W90nuY+XLx3xbP7xSB9h+awLCUkTMcPLD9zNBemHb1akdTRUmwpSjQ9ZOJau9UAcwRefIu+Jff/Uu6yAvqPo8S4l7Vq2aU1W1bp3TZyBZHwI/RSFtk5X82ZYt5dn69enzZUiXsGS6RlUt//LL9X37LLmPWZC0cJIOYWnEiGZszZpK7B//cEdGfvhhTXb66fvF/9bVWzQRROMim3NloSaI0O/laJ1OzZL8jNKtxfzXvxp5zMcx35tRd80zVUMSS/v9EKYsm79otupyFvvsP0KYM5VkUo+jPvNnn3VmcZfHojou89IM995777Fu3bqxqlWrsjp16rCzzjrL8fmKFSvYqaeeygoLC1nDhg3ZrbfeyvZ4rCAbN25kl1xyCatZsyarXbs269+/P9u6dWsaMnhnLs+S7lA0uc2fXyUjqQPcmqXkuk0mHF7lySbZiUZV2V53XavAGiuvaCt5sVYd2R9+2Onbkex1+HkuQfIs+RHaNmzwJ7mnaxEwL0LO61IXMJsw6/ZvSN7fSRbaUl2AdLt9SsAn88wz/kt7BNnAyf31hRfqG8rlpHY+0xxEAiH5OwW5f9nOEeZMBeK+DtOGUn1fjuZNr7Bk1gCSyVINtc+WsLTTp4uBaL/TlF3ge42i7Osy8j1wzxUsv4SlN998k/Xp04f169ePzZkzh3311Vfs4osvjn++d+9eLijt2rWLzZgxg7344ovshRdeYPfcc4/1uCQozZ8/n02ZMoVNnjyZTZ8+nQ0YMCDpdopBSxNFplSbukmKynRcdFE77j/iJ2ne7787B6nNnq1OeslqllS7ssqBB25jqZCseVLVtlDId2rCUkEgnyXVwTzZnbH6XKpWLQm0qKi7TT/386WXvAsp+3n2Kg8+2Jg98oh7R2/qe94Cvi06ye7foBMQTNqpdNYA9KMJWrvWv1OwKZWBbqGU++tHH9VKKgiANEuUHkDNruylWSKBkJKOCtNUGJNleuVVMwmC6vh79FHnRildWjGbUKt/htm5fzt99h/RfnkNla9DvY9eY8X2W7+CYiSEJdIO3XjjjWzMmDHs6quvZvvttx/r1KkTu+CCC+Lf+fjjj9mCBQvYK6+8wg488EDWq1cvdu+997InnniCC1A6Fi5cyD788EP23HPPcY3VUUcdxR5//HE2YcIE9vvvv6ecZylT2HZ0kybV8ZU0z9bR1IGuqkK9Eh+a8LonLVvqn1O2k1LSJC9P5H6O66V9sIfsO89PO/lkdnrqc6lde08goU2dRPxEsPn1OwnybCj0/MUX6/OCqGp4vDnKqCCA6dj5XZMfie6cQjhRr/v11+v6KvApWLmyEhsxoin/18RXX9XwNK0Gua86DQiZgI89tgOvr2jqk6Z8Vl6aJcodRlpaKi2xcKFb6+01jwRJ6eElvASlSxdn8EPQJLOmTYnXRjMd/qheFQN0c0AmNUt//FGBXXttK/bZZzV8b7R1QpVT4LFvjmzX5zXeIy0s/fDDD2zVqlWsXLlyrGvXrqxJkyZcGJo3b178OzNnzmQHHHAAa9QosRs9+eSTWVFREdcc6aDfkOntkEMOib93wgkn8PPMmjUrtGY4G5TTJiiqBsKtkbAvLn6RJ/ZkEr2p/Pqrc6FRo4/IoXXIkOaemandwlIscP0mLzOcTaOjLrxbt5YPtKsOEgEif6dZs13W53rHHS08z+nX7yTI5sEW4WXWLNl9GGw+S15mOPmePfBAE207RFJRv4v2FVe0Zm+8UZddc00r85ek42bKtP388w3Yn39WcPl4yWNGnsuSNXd9+WWNwIJ2kD6TS81SKmY4lXRtsm2bNzHfyb6TOmGJBOl0CFGjRzdhX3xRg11/fSv21lv+glfEeO3b9w/tdXhpkoNolvxqgCMhLC1dupT/O3z4cHbXXXdxcxn5LB177LHc54hYs2aNQ1AixN/0mQ56n3ybZCpUqMDq1q1r/A1RXFzMhTD5pQ4i2XSV7sKp6vHU3Sd18GCOnzGr8GDz4SBsOTrksHu5Q+smSt2kIyBnY1Wdf8stzsVcHdgUjkth5OPH+w+nF8KiM1w8HZolm/mrnHY3FhR3IjbdJO6/HapGkXxJzjmnnUNI9atl9KsBoSgsZx4qVbOkj0JSr50EXtPvgprhdPfMLZyV+DLHCoQZfPlye/CAznk4iLDktQExCRlyX3BqlpLT4OjMJF6CdhDTbRC/Mj+ofUL928uR33RtXsJmMtpxnd+gzadKPFua58QYV/vqwIEtWY8eHditt3pvmLz4/ffgZX9E+/fZpzhNZrgCY5+PhBluyJAhrKCgwPpatGgRK/nf1dx5553s3HPPZQcffDAbN24c//yNN97Iervvu+8+VqtWrfirRYvSDrV27YZ4wrHq1SsEzmlChUDnzvU2fXhN9lde2Zp1796JL25+dv6qJskmLJET+fXXO51MbZiEDt0OyzbJHX98B67Ol01DqgnD9HvaOZug36iCDJlwSLsTzAxnnpzoHDbzl86XRDyTxYsrs6++clc11+GlIQlqhlOvm3xJyHFSzteTbjPcyJFNHSV0bH39s89q+s4NZltM3X3R+TcldFQxmQGc/YCljJeg7pV+Q85wr8MkxMv9RH52yWpwdJFxurlJvmdBBId0R+gGSQUSZFPi1c41a4ILFrr6nPJzVesdysKS0MarfXX69NKx9fHHzqSXsSQE0WSiHhO+vyW+NEtefcX220iY4QYPHsz9hmyvtm3bcrMbQX5KgsqVK/PPKAKOaNy4MVu7dq3j+OJv+kwHvb9u3TqXfxRpq0y/IYYOHco2b94cf61cuZK/v2lTws5dq1blQGa4K69swwuBXnqpOVdN4lj2RfKbb6rHF7e//927MKu6sLgL3Cb+n5zI1Wgu2w5anjTkDq3TSPjptP/9byLB244dznYsXKgXNMV5SdBbtqySayCrkx1p2uRsx0HNcEEnSJ1vhhCWzjtvX3b11a1dJsd0mOG8PjNdt7xT1CWAFGYc+Vn5Xfjk5Ku6Sdy0CKkTsqqRsfnaqL9VP58ypZbnMxUaHqd5hqVMqj4s//lP3aSEJfl98ezUjUUQU7pO6NONmWQzoKdfs2R3AvYSiv2ai3V+aunoI+pzlbXyOs2Sra+Kz15/naw5HTxLlaQjn5ZoIwnZCQ23rB0ym911fn6mXGHqZ6EVlho0aMA6dOhgfVWqVIlrkkg4Wrx4cfy3u3fvZsuWLWOtWpXa/Lt3787mzp3rEH4owo1SAshClgz9ZtOmTez777+Pvzdt2jSuySKHbxPUFjqu/CKKihI+ILVrByvvIMK01ZBOHd474wTvvOPt8O327wgmeds+lycxOZxTt2j7meREW3V+LSb/Dpp0166twAU9OUeNSdOiapb8YPNV8a4z5f5c1fb99lulJCZ4+47Xq50mrcbq1d5tueGGVuzSS9sGXvi8ajr5jYZzH9emWfLWyLnPp79Xfs1wid/ZZ+qKwRUNDrw0Qab7qROWKHO/zVQuvqNDTj9AkCA9b16h9b4G8cdKt8+St2nWboYz9cdk5z0bunGqnkfOmyX80apWjcU1S3JfVYMqRJ65e+9txtcpPxtwmWT83ET7qY0iIs6mHZL7itdGPK+j4UgYoSi4YcOG8ag3EpquueYa/tn555/P/z3ppJO4UETpBSi1wEcffcT9mwYOHMiFG+Kbb77hAhg5ixMdO3ZkPXv2ZFdeeSX/jNIRXHfddeyiiy5iTZsG6xDEtm174w+uUSN/IdXpIEh0mm5gqoPNb2kO2zETx/K/w/KaiOXF5bbbmvtuH032v/xS2Xf7SFCRNUt+BpNtp5nMRE7PRL6v/vym7BM8tcs2cZm0Jcnw9ddODZFfYcm9SKm+I+WSEhSdfdoesOBn8fJjhgsi/Jt+Y0um5weboE5Z6k2aDKeDd0w7VvQpMvR9nTK8y8iCNEHRcn36tGEzZ1ZLKvmuTRgm/78BA1qzqVP9a228tI3JmuF0/ZeeQyroUtS4XQtivs1wapCQ2kfnzi305S6SrBlO1mCWapYS7/sZs3oXj4KyEQ1HUNoAEmJIGDr00EPZ8uXLuRaIHL2J8uXLc8dv+pc0Rr1792aXXnopGzFiRPwY27dv54IWaaUE48eP5wJUjx492CmnnMLTBzzzzDNJtVF0iqA5ZVR0asTmzXcZB2eQxVi386tRY6/DJKQKS15CjF/Nksxrr7nNA346rVh0P//cf7TYhx/WMrZDt5jQABX1t/wKcTaNgnqOdu12+jqe3A/8CEuqoOGllVEnmA8/dJrU0pn+wq+w5JUsz7RjT0UTYFsY5cXbeT69f5d8LD9CNt1jEszFGLa1Zdq04CYaysRu4rLLnAKLl4O3OoZ0ZXmSjZbr378NL78jJ90MlpSywBqNNXNmdXbTTfbIQ3s/K8iYZomixIJgE6jFfaO0GyafMb2Dd+K7P/9cxXPTdPHF+2TMDCdrMMlFRC8smdco3fnsglZBfglLFStWZA8++CD3Q6LoMzKxde7c2fEdMsm9//77XChav349/z5Ftwkoeo58h1q3TuQZosi3V199lW3ZsoX7H40dO5ZVr+7PoVZFTHSpLjIiZ4uM/IDVnCVBOqNu5yc6EhVxPOqojuy//62WNjOcSZB79dVEhNqVV66zHkeeNP3eW/kekfnPj7lBIHUZ1/lNBDFv+REK77+/iVIk2LsRXuexaRl0jsA2AYeOHcSp1iuqy3YeGdM5VSHD5uskV31XP1MLnw4Y0CagZimY7wwJxEcc0YkHMHiZT/zkUPNKePrpp/4ELrmv1K27R9t/Zs1yz5NBklZ6CXVBoojl+y5rscikJCfVfOyxhuySS9p6bjCDREgGiX7VaZZsAq2fDa96fp0WXScs0Xs6M1yyDtB7DDnBNm0KFuwkr1FkhhO1GnVmuAoVSlzjXW+1KCNmuKiQ0CzZVesq773ndCDVRT/Jg08uIBp0N6cbxEIqHzmy1JFexXuwuAfXrbc2Z3fd1czRtnr19DkGmjTZbdXgyIPXr7D0xBMNfUX46SZNNe2Cn8FkC00P6gMmQsrlBdmPSUy0QWiuvDRccjt0EXn77WfWgJVGXHZ0vCcW1XRiM8N167bVl/lOF/FI0acmwefGG713+upvqPAwjX+5HaT9pKAC2/MuKqrgWDDVif7//q9RSo6y6pi6+WZ/kazyuWrW3Otbg51O3yF13NFmzlRkWn5f3og501BQzbCGvLCwzmnfVmvQJrTr5gf1WYkAjXRE7XnNJ7o5XjZpirmwsFBvhlP9Qf3Mf//6V0Mu9P/0k3cdTS9E+2mDRfNeIn+e25TWr98fPs1wrOyY4aIsLHkxZEgLz5pKqURbOb9rdn4z7Ya8OpMa7rpqVUVu0iHnclnwMO0UhZrVlIgxmQgZdcDL1715cznWq9d+bMyYxlpHcbeWwvv+2tTyXhofNTmkwLlw+mlDYsdY2m61HbY+5L4PrVq5C3DKWgV1QTEVvUwl15jNlOjcaZrvsW7sjBnTJKWM9OpvyMxD9czkcz33XAMeVOCV50vGlgNGdx1duwYrEeRV3FYgjwvT/NC+/Q5t6gcv/C5O6rMnQY+Or0aG0vdMQQc6J3Iv5NxwflJY6OYH9V6J7ycjLNG5SSM2cWJt7VhVNaVeTuSyGS5xDYnPt20L5oYhhFI6rlrnMhnEvRMmOLE+6LRHpZonZxvleyw2VM48S8Gvj4CwlEaEejRVM5zO6dOeAbpcWsxwye4K1bIYcmeUNTomNa08CHQJzOTrs7WxTZuEJkRNbyAPoAkT6rFVqyrxumairfJCn0xoaZBoOLltlCWX2qIjqLOw+L6YBN3CkipQ6CeYjh13BJpEdMdzf8aSQr4G8h8aNapp4Cg6XZ9xZqUO3u91v3nttXracarzzzNhy0SuLmJEq1Z6QfvLL6uzpUsrJV1MVx63pvnhjDM2uX73/ff2jONEkIS5ahtKf+8c27ImSUBtpcSK332nb4/NrG3bUCaObzfDufN+6f2+/DB7diHXiN1zT3Ptc5DzkpnOIfcdp4O3MHEVGO9vEN+xSoEy9dv9uoRTuuqzROuIEBCF8K/bOLVsWRzfXNs2HX4ijQkIS2lEPAQv7QdNtLYO6E6oZ5/Mg0z2tpo7prQFXloB1R9F7ozy+cjkoGurPDGrJUtIeBKhq8Tjj7uLq+pQFxa5HXIbxPcOO2wbq1Nnj+9M2EGSUorBL0xplCRO5HuiLLl+jumnYKpcxLkUuxnO9JkQttKRr0aQ7LHkvqf6D8nHdDtGm3eSqtCQjHnLr6O5qaCxXz+w6tUTag5dOgvdff3xx6rsmmtaszPP3C/ptug0rsn6IyUbHWVy2lUX5JdfdgpLvXpt4gKqSKwYdFG3bSh17dHN5eq9EmuC+N0pp7gFTdO51Gz+qjCkJp3UzbE0dj76qKYiLCVMXPI1JOOGID9bOZLYxr//rde4insn+qoqLMnXrxOWEiXH6Prc/k7qs5k/35/2EcJSBs1wupBOMgEdfngnHv1hwlYxPTPCUkFKCx3Zvk2ToXo+OVGhbmJ25ssoYCef3N5xr9QQZGc75d2RaoaTJ163/xcNuksu2aBtMznJ6lTzMrYFV6f29vIdoUEut/PZZ53RLclplsy2ern9OmHJq6Br5oQlf9+zOaXqdtqysBRkt9+6dbHlmCXafkDJUtVkqH6FJeHPZ3aCdh/HFtZtM8Pdc0+z+NiVx+Sjj1LyXtroBA9USE1YMpnindeg3pcGDfawDRvsTsU2DZu+P5g3Hn5qw6mmzGrVzM9hwYIq1vuljmNVS2YSam+5paWSwygRaeb0WVI1S/7XH6oBR75LthJYcnqRoqJyfH59//1a8XbJaQNKcQo88vnEc9QJ1s5IOrcWPWjUOoSlLPss0W6HzHUm9bBwZJTxmsyDTPZytujzztvoa+fgNSk2arTbIiwVeE7WOpU/sWSJWzAS0Q8yjRu7TRHqgJcnELl9wrGZVL5iYKmTzdNPN+Q7dRN0/2T/HZPKXhaW1PBclYsu2uiYFMQOiSbS8ePrWp1KvcxwunsoX7MQfp0TkHcfs/WTdJjh3MeUJ8ByLtOFSbOnam/d+aXMJxXPQbdBoU2OSWimZKh+okrV63jzzbqBzVemxJBewtLEiXXY22/X1gZEkLDuzrPEMiosmXzS1ESdOk2IV644mxnOq+J9aXvsJnL1OQrhTfzO9hzctTcLrJ937rwj0HrgZYZTofsZszxrXSStrAWtWnWvUVg6//x2vKj07be3YI891sgxXoUglFA6FDj6Agk7wqpBPoOijXJ9VlvaAb9aVgGEpSwLS2rH10ngaq0fXeeXow78apaee64+Ly4rIpcOPdTuHCoKlQZNHSBPJKo6X6f+1jmTEn/7mzuXx3HHUYoHpyB0zjl/ur6nTpZOzZJbhS5PHLr7SYMx1azTQQYntUVXKubCC9ux0aOb8p2Y2TFSPwEmhLaYrxp+n32WCDP348/mZ/Gken7nnrsPmzy5dCe5Zo1dA6BuHPw+g7ffrmN0fFf/XxVw1CK8MuqELEMCmG2hmjKlplUALE0aar7PfksE2YQlL5+lpUsra8ft9Ok1XNf20EP66Nl0CUvkU+jHf0/t57TJIr/EZNpAfjRnnrmv631b6gBxz5yfF7hSgei1Jt5uGG7NUjnrZtVrrOpTB5i/T5umPRbNsi6SVt6YqIEgakHpxYurOsaHeo/ExnfFCmdEIfVl2W3ju+8KXWY4neYsMR8Hk/YhLGU5dYC7erX3I9B1fjkCza+DN6nTBZS2XmfPlQdsYtFlHnmQCoyTtSjjYhOWZMHGS8vVrds2Hhki4ydCTp5g5Gcg2ipPXkF9M9zmCef9WLCgqnaC9DLtyRPuMcdscXwm+3EJ1F2rKYWBTmiTd4IiFw+lL0gcO7WpQtyT4cObsiVLqrKhQ1uw00/fl514Ygericq2IHuZ2twOoyWGos7eAr16HTqhhsaLzRxLu2fTb8WxgzoA6zQCNmHJS2B/5ZX6WmGJFrV0+SzZ2mcqXyTfM7ltFHmrImpj2njiCb3v4/vv62sd2lIH0NhQnZXVZyyciOWF3oT6mZcZzp0w079mSSdMqHhl/t+tETydJnx/z1tsUnSaeLlkjlMYirn8OsUYJO2hzWfJb2SoAMJSGkkkpSzx1bG+/77Q1wSkm4CdPhf+fZZ06GzSzgKG9k7v1iyV05oRTMihr5s32zUNujBhPw7J8n2WJ1shsMip/4PeT9szpOct/KJsu1PdokVmEZ3vimivqR3m1AHOz+X2yNo61YRJ/Pyzd/4UcTzdxCs+k5MkrllTKe7n4Oe4usirhKbH/MzEfZaFalmId2uWSi/AtpvWm+H0Pkvy56XnMwVSBO97untt09yYBGnn7/XagHTlUErOoT7RnnHj6sfb07Nn+6TaICceNY1l4Z/mZ+zKflM6c6rQFiVM4bGkAmaoT6rBK1553VTE/Oc0w5m/79UvdyVZFF0lcY/0pkrxd8LMlhD2ZPcBOdBF57Mk7qe8GfQDhKU0IoQJm6ZD7vj0sEy1lLwWY1kg85p8TINHZ88VyD48oqOZ2uq3JIXpXAMHro3//yOP2KPd6Fzq8Tt08C4fImuv5IlNCIry9ZoWM/IXuvvuZrwor9/cOLI/hduPyv7cPv20pvG+CW2V83hO51GTGU5MOuvXJ3blqmlTxeazpbZR9/zFPdHdW69w4xEjzLl7vv66VPtgm8zFZ3JZH7nAtLqw1a6917Nsgk7QLfVZMk+puvpx7r4dVLMUVFiKeX7H5O+TjGbpvvtWBmqfCfmeiegvNUosCGIjSJsAOcWCPCZFMk4/meTVqvfqBlR99rrgH9O55PtFATJ33OHMy/f5587Nhtw3Dz00kbjVXhuuwJi7izazxdbUNbrxXsA3oq++6j9thlAAqO4E6ueydk6+N2IDKYRJ2Qxni4bzC4SlHPos0fdMExN9j0JiKXW9rqPK50gmdwftKGz2allzYVsgSj9X/bDszoJqQsYWLXZryzuYkCeqt9/+yZfdXbarywKMaGup/d6+aJO/EPnCDBvWTGmPeacnTyRq9IX6uwcecC8sAjqvfFxdBmKdmc05SRS4TLjiefz5Z7CSCzZsgosqaPop5fKf/5gn3GXLKvNJ2eYXIcZYnTp7fbX3L3/Z7rljNml77ZolMdnr20paWJsALQt7qTp42zZppjnJK32Fbvztu2+xq+22Z2XKxt+79z6aMPzkly/S7JCG5eyz9+UpFoTvqPxsSjUXscCmLpMgLX9mm2vkupTqfKorLqyG4MvPTxd152WGU7XWXr50xZrPzjprX56+4b77/BekF33TZIYTQlxCc1TiuFaxEfjnP0vdTej52nyWunQpHed+gbCURtTacLrdg7p4mqTcF1+sxx54oAnvdLrOKNcv81Ld6yYx2jXZNEuEKoSY2hpEs0STjmzeeOKJ5b6da0vPVeBoR61adB3u3zRosNuodpf9c3Rh/V4I9S1dB5W52LChfKDs0QJ1YezVa7Pxu2SqUo91223NleOVc6VycCZnLOfaRYq2HnigOxtzUCiPFpUR0S1iwlF7xw73bC8WP5sPl+kzmmCpfIXgmGNKgxIOPnib1cFbRtzXpk13GUOU/Wwc6DpsY1HMCyZBpbQeoPn3++/vfka6saurDSage0Bzy3HHdQiUY4lQzT9HHLHFc5MkTCt+x4SOp55y+igKE1YqZkGaN2TNlHAFUMPSTXOkLVWFrl2qialrV/NC/eCDjY3PI2jCY9V8L7ehsNBfHiLaDO+yCKZqAmBh5pZ9zoJplpxmuM6dS+9VvXqiRmFCsyS3VV0HKIWG7vrE2JXNrH6AsJRGxI7JboZL3HKqsK0Lj1cz4eomYFthQP/CktleTTt2EXFHkTC2yUkVlmw5gVQzWpMmzrB/L6c7+r1sRpO/L1+HzTQna5aESl+ODPFCTHyUUuDyy9uwq65q45jEnfbxcsZdoe65XXHFet+LmFojUAh+8m5SJywJM1NpW0v/FX1h5MjfWCpQBXVdP1m5snLS5qnSz/QPhybMyy9PmAhFhKcsLKuhyKZji+cqNDN6M5x7UfUbDSecfP0mB1Wvw9YeuYD0V1/VsN7rBx9sYtXumIQloc1s2HB3fA6h/iP6mO6567S+foWlCy/cYLgGp29KMlx4oTM1h0A+pqx58fIL0qU5kKPa/vKXHS5TeYcOO3yVj5I3d/6CWUrbduONa1waLGqnHA2X0LyU/g85qqtCDn1/p0UwNaW0CCrMJrSeTjNc9epOtwLZncCZdqbAohBIfObHyV4HhKU0InZWNuc9dXf29783sx5L7hxHHpnYyekylgZRq6sdSecoSlFLcnVxc+045/lNdZpEu2UBQt0pqQkudb+X/WvUMFs/E7Lsi6CbGL0QbVYzB+sczeV2qJoj3WSiq7cl8Modo9OS6SaJ444r1b7IbTWpvoOiS17ohZd5ipgxQx/hRM9fzjyvE1j9apaEVpPMfvSezQwnjvm3vyUWdLp3fgQBm7CkRmkJk6DcTl17BCL8WkXsov1sCLz6megjpI3p3bstT/FhipgSY4q0D0II8yssmeYCERmaimZJNZmaEh6aNUtm03tCOC+Jz9mNG+92CeamZ0FaGbn+XVAfr4Qw5AytF20TY4Pur2qm+ugjt3n/8ccbaseCiADUZZYn1DJO6sZYRS0Jo45X0UZZ2FEjqWWrRY0aemFXHN9PcXIZCEsZNMMJ5Aelq+9kO5YaEi4SMAbZqYmQSxna2cgdKZWK4kHS4cuRFdRZZXMi0bZtsWeaAudOSz62+57p6NLFLZCUOnj7GzxCQFPVz/o6RYl21K7tDK8KKlR4LWIJ9bpe26bTPAlfDLl4pU275QXlLgka0SV2y7bfmTKeq2Zb/eSYGD+6wrOJybfE4czvx0/jkEO2xYUH2gH7uXav5yjjtSnyWsQFRx+9xXeUkkmzJBDX++efFbgJlIINNm4sb7j2mEvjHMQMp5tbKI1BqpqlUj83t7AkC7Kl49ktfJN/k1q8VvZpkpMi1q+/x5HYUa57pka9yTzzTML0OHVqQgDWmXDPOMOZZ07WvKgbQKePjzsppU4wo2LEOzVz/yOPNLauaXLiXZpbvQR11VQp+plakkW+vhYtdhmjEMlPzuazFBQIS1muDWeSwlXkTi1HByTU2u6dswldoVZ5IMmqWRt+fZZsyPZv2bG3Xr3djh1wEMHMyzfMz2dBNEsm9a2ILtNVx9YJ0br7aSst4BW+b/NZoklW5JDROYAnJqhYvG4VJS4NCh07aLSJuO/JLH6qgGuLfqHnpjuHeEby86fr+Mc/3M6p4rgiYICOefXV6+KfeTkdk5+MnwjYxPkKuFM8lSIRmt4RI35j/fu7BdrffqvIXnzRvTEKil/NkixUkcDUq5c7jF++p6JItt+8O6p/ourDpM4RsubdC9UPR6f1UudIv4V2ZbOvbIYkQUTM22rYu4osuMtrhi7zv1raRTazqfOl/Bm5BahmUpMWa5dmzvzqq+rGMjzu6yH/ogJf/SohDJU2ShXo5M2PLCjS5/LYImFJ50ifrJANYSnLqQN0JiAdVE9KoMsbYauirKJrj1pkUJ2URFFZWyfTmTy8kH2WZKFD2PTFoDVN2H4r2wcNdU3GZ8mMbEJ1qvXFhE5+H7rJw3Td5L8hajvJiElefoaysCRq6cmh8rJ6W7db8xNdaIJ+n2yuIJ0G1Au1P9iEJVPbxHuytoCExrlzC12RinRcykIuFq1Sc0osvrh7jUXKQhxEmKTz3XJLC0fOLYowE2Yd+TqHD9eb9AmvYI4gmiXRv+TvDRyY8BsrLNzLzYe33bbaIRCIzYLfKDZqq6kyve44tnprOs2S/KxefbXUpC4/G5MZTh63NgdiuW9QP5V/V2oiMz8MureUtPWpp5z+nw884HT+JlQfNVkzo/Y1OccSoa4npmez01KMulYt700VbYy9hBSxTslabrmN6tpA5yfLxD777NRqlpwZvN3uCEGBsJRGRPipLRpOjdLyg2wm8LvTkaFOpU6SsnaBOpK6SFO0iIq6uLdrtzMlM5ysaVE1BKYJ26ZZkjVoNju/buDrVNZBNHUyJjMcPT+q+UaQCl4n/JhU2iZfom7dOvGM2ySoi8VeFpZEhmPZCVM+lijt4FTdi8XfepnGdgbPQl16LluKANtv/ZrhTJol8Z5N4yHU/XTcV16pp11Qqc95FR19+mmqseZ9f0Q9LTqfLLSJhUeuY9ivXxt+XK/isTqERldAwrxfM5zpexS19MorS1mfPhsUYUkkFfQ30GwabzKTqtXtg2RkLtUCJtrx7LMN2TffVHMspCbNkuzALTYWcvkhnQOx7NNFQhIJBvLmjMZcjx6bHcEbFGSj+rDpoklVZM2MKhiofo0//VTFkSxW92xatix2lD4S0DWQ+XW//byjykioOf74hK+kDreWW5jhnPOR6tPkdCcxCUuJ84jfB90MQljKcp6lZFSAsvOtLoJN18EvuGCDI0WBKjy0b7/T2MmI6tX3sj59/uD/3717aWIz9TvC5h6k08mTlKyhsdnWZXQLuKymFtdpD9l3H5s0CX59loS2xoQpUlFOfGlygjctQDaNGtX7k9XPsrAk8tvI1ywLS8L/Qw7X1SWqCyYsBfsd9Qk1sZ5f1P6QGB+ydi8xucr9Yv780uco3pOP5RbCEsd11tFLLKh+rnvGjBq+NEuyL5bqH1MqoJV+/uWXNXhR7v/7v0bW4wqhedw4p6aiYcM9rk2SGHvNm+sdckX/EZGkKrKQoNcsFWh9bYIIS6JGoum8XtA9VeeI/v3bKONVLyzJDtxCwKayPCK9haxZEpuf0ufj3PTKwhK13U+kmx+cmlTn/TOlSnnyyVLTpnxPxHfOPvtP9uGHtbXWj2OO6ehr7JLT+h13rGbDhq0yfkfMN24zHDOY4ZxKCRq/8oa+tNyJ+G3pv+QA7tcMrAJhKcvCkmkR/+tfzVK33gauN/XoJg5dNXSK4hHHIq2DOinR78VuWiy46mKgW1S9BCe5/pUuZ4i4LpvQINoj/pXzpai7Dx0//lg1Jc2SKbmizsHbvbDab5Dpum05iGjwC60MmUZlYalBgz2udqgFJGVhWY6gScYMR8e2LdqqJiPhl+OdjDSIEGnSLMljReTeEsK2PInaNFaqqUbcL7+O236CKcRGgoQh92exwMedOtUd5aRbNEtNX+XiTuG6RKleEZOmTZAY76ZAGF1uriDO8EGi42ie0KVP8BMNl9Bs6AN55P4mCxnq72QznJcPUxBkgcikWVIjDQ84oNQNQt5Ui2AIL/eEjUr9TxNkJj3vvD+N5seEf6VTc6R+rprpTO4ktA6rmyfZzBj0fkNYSiNisrVlJDYJS5QX6JlnftV+potu0DkRDx+ekNrljqYmy/vxx3k8ikwci3LgzJnjFCB0vivyxEVlDPQqav31iQlWzgarm1S9fJbo9yI52aOPLjdOkvYs4u7P5NT/frjssrau94TpUp6EZaGtZUtz6KyIlDMJS16mERGZIp67cM7W3U91saNw/0TZF3cfC2KOmzmzulZQFQkfdRmI/UZj+tMsJY7ptdOmcTF1ag2tQGoTlpwLakn8d3JuNBt+zGViQdXtguUds4xcd0/mgAPMCRB1go+8oOoSpXpVa3cKc85Nm7PQqf04VDswiLD07rsJvy4vqL/rNIGmaDjZD1E3f+nSSqiLvfo7VbOUjCZXh6wl9vJZEq4URx7pth6I55PMpikZn0+qh7lyZUWHA7cuGk79XE6B8/zzCc2prtyJPM+InGx+gbCU5Wg4kwNdaY4Wu3Od7E8id2DhQyNn+JV3PW3aFEsJM+UdTOI7cidTVf2qtubcczey007b7LIly/dAd32i3YloOLuDow5Z1WrKw0LnsEVo6HYUQTVLOr8leeERC5cY2C1aFHOTh+kcL720lP976aX6RHxvveXPnycxgTj7iXMSLHElkpR/r/42qFlNZOuWEX1E55NFnwVZFAnh1GkSlmRNlTy5yjmmqP/JpWvkxUqtvSdPurLZl8bJhAmlPkx+1fuvvebMz6XDtuGSNR4ycr4pmf/7P2eWfBl1DMmmL5MGyVuzpB/Xbs2StxSebB0vlZNP3uxZY9IdDafXsppqlwmBSueTqeY/0mmW/IwzXa03s9uG26KgPlux8RTXJ49PP0WXk4HMcSZGjmzqGQ2n3n95bMpFuXUBUYmi2iXshBOKjKZmHRCW0ogQSGzJrkwDQueMJ5DDutWMpNOnJ5L1yZMPDb5u3bbGnet0Toc2TYouu6sI/RUZVfVpDLyEpcSOTm+G846GUwfTiSc6kyxOnqw3OQh0i1qpps3Znosu0gsuJuS8KeT4KA/Oww4r3cXoFrnzz9/I2rTZFdc+JROyL1Dt+GoeJV2NNBF5Sf2W7oPbR8A+TZx6ammqAcEPP7gruos+pMsto/OZ80L0Y5MZjq5JRFLJ0aSDByeKNtOmRhaq5X6hbh7ksfD114kxR8cUmbnTic3/hsa5l6ZRxlQTTyf4kNlIHNu0GfGKBpU/lzW8CQdvsWB5r8JBhOi+fc35wVTnYupzcpkcgdPEag+oCa5Zcv5OngtMwQe29tGmlZAXfNJyyudXx5WIrlOfrRAm5I2An2SxyWDTsJdmC3feP1Xg8fpcQPdFjVacNatafK2m3510krnElAqEpYyY4cyTgMk8RA+eEtzpsIV1y3lVZG1SaVhlLO7To49AM1+LbJaic9GOY9KkOp6d1KQdExOEM3WA2QwnJmzVvi1HlYh2qAvLSy8ll2tGvh9CPa3DFNXhzNMjJhrnfdfdc7VP+Nlxm1BDgnXaIZNmQDUP2MpYyPTubRYqVQFU1/9J4Bk7tkGgorG6mmPqdQpfikSocYmjmDGND1mbJLdNRAlJreT/LSoql7ZnZYMioUz3kzY/QQofe41zFZNfi5/jqUKCGsrtVwOvtsUGPdfrr18bNyXpUDew5OD93nu1Xc9S1SzZHbz1Pkvic3deNefvZHOs38AIMS/SBkXUl2vVKhGNdtFFiYLDulQZZNoU5yPU65OjZsXzkQXzWj7SBHhhzy9FWbkLtA7ebjOcmFP1/ahnz80u5cLddzvraQaxJkBYSiPqJKB7iCYpnTpv3bp7tZOX6tBmcmSmwb7vvqWL/LHHFsXLgjz8cGOt6lvWLKmLDtVOks1sS5cmJu+ELdm/GU74qsi5MGyCmz7btNNkowsVVs0kQZDvh1p3SG2DDnHvS4/l3JWpAmYy1eT9YJoEZQ2KSTOgmvD8OMsTchZdmX791rM33vglfiw1D4pADQEnZsxYaD2n6E903AoVShs6ePBq7eIsTAs0ucqaKHWxu/HGhNZJRdxP1dRFx7jppjUsGWx5dkzjSJgW0rXb12mwVL+WZs38myrUcS1rPcT48uvg7bfiwaBBa9iAAeutC5/6mTsDt7sEijxXyvPj0KGlC66qtRGaKhFZZtIsifcXLaoaWFgS90O3TlCkl3xMm7ZKnSeEBlqXMkYWlgo9ylH5wRbkQkKtGGPqOiNwO3gzrZZZns9N1gbbGHR91/c3QUaj4UTH0CWtlM1wqlpRnkxocLz22s/syy8XsMaN9zhC3GVTRILE/4vSHWee+Sf77LOFrGPHRGoBNZOuOEYQM5y8ANsKGapmOHVScDoqi987j+O3pIy7jYn/p4ncbArU/57aKhZu+g5VdxeaP9vCoE6qqUTFqMcSbZWdf9UoHvV99bl6aZZogr32WregUfp8xXMvMOYh0lUt90L2qxJmpsMP3+bof3QfqfK4SI9Ak6soP6Gb+M84Y5PlfPr36V7JQnIQbA69plIY4vkG9SMzmRt0i4WqWfrXv5Z5Chq6Npb+fyIRq+iLfh28/Y5l98LvRv1MJKGUoXlb1ozLfpvymBfuFqpf25tv1uECixg3VA5Gxjbv0b32IwCLsaKrOKD+nvqm6qulzp3q9YkiyeQbJY4v5z+rELCemg6bb598n90WDOd8pEsdoCKKwNsKefsFwlKWzXBmB2izNkoXDScGpFNjUOpzUquWe0L1O0HRoK1Xr3Txkc1wch4f1eYud1JdOO4xxxRJUn4idYA8qZqSUlar5hQeZQFGpyEp1SwF69Yi34vcBrVIo4xYfFXkCYzuA1V3l49HUOI7FXXyTIewpGqW5Inb1AcSi45es2RL+te0aSIlgDi3WizUVOYjSCQcLfqffLLIkbYiYep0agOp/aNHN3GNMTnjr1+CLMTpwBSpI56B3yzYAtmx3ct/RPVZatRoT6DnpfYvoR0W/SmIZknWaPv303PjJ4eaGgIv59CSo+FMkFlP9XmSUX1tZPwWYVa1fjK63w8cuE4rzItnu3p1Rce/ol+Rj2Um+rVX35XHpOrArc5H6jokC2EiqautqLv8Wz9AWMqCZslPaL3NTLN8eWWjz5IsGKhSv7xzTQhLJdZOqxNg6DiyKjahWXKb4XQ73scfX6FNHKZLXieEQJPfhGgHaXCEKUa9ZzqBzYZwqHY6XJrNcG5/lsTCI46hCgZiYOvCu73Lp/jHZMeXfW1ME4QaqkvPQjad+Q1cEMeXo4lMVekJk7Py6NErXebKMWNW8sVb7k9y4VL5HGpKApuQLzjsMLffy+GHJ3bZOrxSTgwZ8jsLAvmgmHbfYpEMqlky+UqSVnDGjAWsTZvEgio00qrwLPByxlc1T6o2XOdWYIIyWXuROE7qWg8ZXei5F/KcoboQqCHvQosTJPO9uLfyxsxW142u4bnn3ClpxLP99dcq8aSZchtlrVq62eljcyQrBkz9R3UbkO+9zpyoI0i6GAhLIcng7UeVLJtPEqHYicXX9ludGU7XaeVzyAudbsekCjgmYZC+58xT4z1ZmiJyEjsr0z3W34T69c1lZsQOV817EqTgKdXSo6g2uQyFjLjvuvuj7rDTq1kq/Z8uXUrTStgmQNW8Wvr7RD+xtUu+XnkxdArJ+r6vCqXCz0UtGkr1xkTb5HpspqSTcuSkaI98HbrMw7rJ8/77EznFdNg+mzJlMbvkko3xyCU//POfKyyBIOZ+ZMM071B/qVEjsfGQEWNPvSdegpqatkM1o9jMUaXfjyXV5+V7RpoFckkgqBJBMmNKl5RSFpp0voaqu4IcKaqGvMum0VIznP9G+tUsEeQL6+f38jGcWrUEIhI6FWxCoahz59y06/uP6jYgzyN+a7BCs5Qj/KiXbdFw3sKSXJgxWNtEuQNZkNN1WlmAcZrh3JqlINFwsm08iM+SOVdJsEF72WWlpVt0iMXZaYYza5ZUvvhiIZs+fRE3gYp7qvpaiPt6yiluH4IgZRqSdfAWO9JHHllh/K26U1M1QpSvy4Sp0KY4VlFRBaPwKQIRBCI5qyrMyzt1cX00uQuBUA2pp7bLC7eqdVuzxp01XDf+Sn2i3M9IZDi2aTREwdsg+VzoGVJ0l+kz08JIBWyTNf/r5iXTBq5tW3stMHWhckdm6jdLdD9POWVToMLc8jXI45UEhE6ddrK5c+ex225bk5SwRCWf1LbLGj+9M3Tic+qPffv+Ed+sqeZsOeVE0JqKpdcs5tSCwKZZk6O2rboCcfDBwRI5Bq1GIJDnd3d0rr7/yGPf5JeZimAOYSnrmiX7pGVD57Pkl8cfb+TqYLq2mMxwuh26TnAzTcqyaUc3WYrrmjSpNluzpgL7+ONaWkdXMSBM9adMQqROIHn44RXs4os3sNNP36TNe+I3l40ufPytt+poz9+qlXvRTGf4uZgETZlrRT+74w63aShRuDLxnlwt3ZaMUF9yx+mzZDJfqpmXW7TYre1Lsv+aOK5ankJeyGlyLSpyRwEmTKXlfE2esmZUhmpm+fGLKL0W97koUakOGoMi75buM0L0Wb/mMVtQgs5kZNMsXXDBxkALseo6oGoGxBh46aVf2f33/8ajGoMg7omsZVf7atCi0HffvYrVrOmOhpMFfn0wTjmjGU91P/j224T/Io3LTGmW/Pxe9PtEWhd94tNjj90Sd9gPgpwDi5JB2rLKyykO1KSUammm0raXfk9ncvcCmqUIR8N5a5ZYUpol2a/DlqxOl7TSpFnS1YZTB/x++wnzj/iuXrMkrodCX++5J5ELQzUPJKtZ0u0CKZnl0KGred4auY2lbSthV11lTnLnJYj997/VDAJRLCUzXM2a9jwnuozMuuhCnXZg/fqKrvPr8lrp0C3Ucp4aYv58d00+lf791xt9z+RrExOoXEyV7qPYyQstgOw/Q5o/+fp0bTbde9374rkLra0N3bgX9bhsWgNTX+nRoyhQdN1ZZ+kj/cQzHTJktUXwdraF7qNtsVOFf3HtooajbrMk961zz7UX2DVdg6zNVYW/IElPSUN3wQV/embCJ82TinueTCz0qkZE/i6dM0i5E53PUjLCFrkOEBddtNGXGa5bt21WoUxNUCu44Ya1jnnh1VeX+t4kytfpzIPl3LTL99OvZgk+SzkXlsydwKQqNeWU8PJZ8osY9LIg99e/bvGl/lQdZcV3fvmlcry2mHp9FAH3zjtL2PjxpWU8vHyW5I6+YUNCQlKdinXCkk2zNHDgWnbUUVvYiSduZmed9WeAPEsxXvTxvfeWsNat7WYHnb9HkIgddWDbVMOHHLI9KTOcVwkL2Qnc5LNkMxfqtHDJOK7Lpj41g7rsL6HeRzG5k6AhfEnknbuM+K1ucQkmLLkXPRO6c9nSA5jasXx56Y47qFnJlMtL9IcmTdw+fYl8ccETC8oILfELL5QmHtX1J1njGmQBK72GWNwRP/Fe8sKSPB7VaDi5PA61/403fjaeR63hp2rUZOHIj2XB2Ub32JILinshBGFRkzIxJhKbavUZ16kjinLr7yWlnLn7bn0wg9ioqLn8gvDFF9WtARtOM1zpZzffnMiB9tNPlcuOZum9995j3bp1Y1WrVmV16tRhZ511VvyzOXPmsL/97W+sRYsW/POOHTuyRx991POYrVu3ZgUFBY7X6NGjk2pfIpmW/rZSDg5TjhLVD0gHDbxkfZbEoPUqd+KcKMSgdi4IYncrclf861+lJj41RUHbtrtcfiKyz5J8LnkAypOI2kYR/efXz+fqq9ezJ59c/j9/IvvIkIUUMdlShJtpUbOhpjwQuyjboqtDhMDKu1kKnTdh0gaowpKuHUL7ZvJZogmIkp3qOO44veAt33MqlBlkEWjQYI+nGU7gNMuW/r+tPqC6sIki1KbNik3IbdfOKUyT1oV8lP75z0RNNp1PkG78CdOlaR5IPCNm5MEH3X5pXhGQpsAMUztt5/dKCZDQcpew55//lZt1yIk+cezkBAfZdKlqWIOkp9C5B4jN6Zdf1nCMaSqALqPOk04znDmwxavenu776obopptaBfq9zh9Inr/V51D1f78xaf4o5UwQ4eOaa9b5+t5HH5UK27NnV4vfQ5qTVU2xPN5vvrlUkyXPVzNmJMoU5bXP0ptvvsn69OnD+vXrxwWjr776il188cXxz7///nvWsGFD9sorr7D58+ezO++8kw0dOpT93//9n+exR4wYwVavXh1/XX/99Sm1tWpV5ySdcMAz9yTxwE2dTSQ7TNZnSQhpqupTVafrHLxJeHGqOM0D21T3TeezJLdFXlTlKCh18dqxo7ynZsk0ALxs+vJx5MkrmWzJlNTTrzCs5rpxtsN5LaedtskqKLo1SwWeOV5UHwzVZ0k2m1KkFkV4iV08JTE1aSnVjMhyqoa//lUvdMn3Xb1X8gKoPmNdZnqTNkHns3Tggdu15+zdu9Ssp48M2hvXospQ2aIPPljCevTYYtUo6zY84vpNmuPate3CEmmQTj65yLd53+bgLdD91qYB9zKvyEkFKZ/PU08tj/up2dpqQten3cKS/zGsT2niTyiUhTJVWNJtEuX2PvGEM/mnjaBuCH410OI+6cxwVf/3m+7dvYv5yuZF0waLojBffrk0w78NuSKDziqxaFHpevH++7XjUbOiqoB8DbpIviB9zb/eLofs2bOH3XjjjWzMmDGsf//+8fc7deoU///LL7/c8Zu2bduymTNnsrfeeotdd9111uPXqFGDNW7cOG3trVlTn0gtaP4fmxlHdO6DDtrGfvihmu9cLuoAV7UtJjOcrOIUna5jxx28YCmVtfAbESj7LMmThsmU0bDhnsCTBdVMonui5unxmjBlIUFetIMULaWBOmdOoet6xOBWI0GGDVvlSOioDmDVDNm9+zZX9JiXgzc9ExHFY9MsCYdW+T7ImiW6BjI5UoTXQw+t4Du1Y47ZEj8eCd5z5xY62qIrlUEFnh944Dd2wAH7uz5zCofOa5f9UGyaJV0osYwQtGwqfYEQAnUCeCIdg/N9nc+iV4V7tV+bfC68UoyoGgovwUWcz8vUnE7NklfqkKBmOH1G7L0pmOHcAjuNo88+q+G7VEzp507tj+266bmJYtt+kIuqJ0NCs+S0VNgEuqo+0tuoQuUXX1CUsLk/HHjgDtar1yZf+bR02buJzZsrGMeAbKWQn6vISp93Pks//PADW7VqFStXrhzr2rUra9KkCevVqxebN2+e9XebN29mdesmUrWbILNbvXr1+LFJICPhzEZxcTErKipyvGRq1tRH/YiOaDPrmLQipoR6YsJt3tycR8h5HOfx1R2vzgxHC6AYBPXq7Y47hgsVNO0QEtfo1hq5/Z/smiWZCy+kaDW32tcWDScENtXJM1nNUpDK56LA6c8/VzbkWXIey7Tr0rUpgbdmSSQyJdW0HM5s01wk+phqhnNPUCRY9exZ5BBuVKGShCVynm/QwNk3bfWl9ttPrq/HAvgsufutScjVaZZMPmWmBYJ84UzaYN0iqva9776br9VYivOZtIde2arVe+tlrhb32MvvToxBU0oDv+fcvTuh5TZ9L6iwpLsX6n0IUpJGZ9Ilrr/eaeZS+zXhLgsViy/os2ZVtyalDIL8/e+/r8aWLnVGZE6evMQaGKJuqhI5jBICnWksMMv8owrKsnbNRJAoPj/BJvJnstO/vPEUGfIXLNCv1ZEVlpYuLXUSHj58OLvrrrvY5MmTuc/SscceyzZu1DuJzZgxg7322mtswIAB1mPfcMMNbMKECezTTz9lV111FRs1ahS77bbbrL+57777WK1ateIv8pMSkKTeqJHeN8NPyRFTxxIDmAaGXJVcl5nbhilSJXEe/YL0ySe1XMVGbakD3BFeie+K75h8llTT0KhRq9g995T6lAhMg0VWd6vX6mVOkydGebINIiytWFHZ8a/6/NTMzIWF7r7gNbnYPlcXiYceahRvP00Wws5v02rIixWF8PrNuKwTlnTtNQlL5J8lRy26fyf7LOn9KfxplkR7zWkFEse1C1G6z3T3STVzUX+49tp1Lq2Ol9Di9QzUceGVE8kvNAap5iQVrPVa4NRxR4IlQb5Jztprpmtxj4njjy/SCjymYBrVfE3h6n//+yqXCem88za6tGp6zZL7evv3FyZavYb8oIO2W33dHnhgpWtMmMrSuI9Rwr7/vjA+p8gFdHUpSu677zfH3+76nm7Njdr2apr0Eio2LZKJIG4OieAAm59nifZZyv7C4voXL46IsDRkyBCXc7X6WrRoESv53zaY/JDOPfdcdvDBB7Nx48bxz9944w3XcUnjdOaZZ7Jhw4axk046ydqGQYMGcaGrS5cu7Oqrr2YPPfQQe/zxx7n2yAT5QpHWSrxWrlxp2OE6fycmCptgY1oIVeEjkZ5eHNPdSSmHUFBbvi6Dt+337qSU+l2jONbIkU3jWg+5w5scMIUwod4Xp5o48f9UA02XJoHwdvBmgXd6IprEC3Gt7dqpvkz+d5TCp8EmLKntpnIGs2cXuj6zZRKXj//227VdZRr8Ckvi++vWVfQlLO23X7FVpa9LSqmeS/5Mbo+ckkC/gDnNEur7altswpJuLOr6E2lmv/2W/CsTJnQ1a7mf48iICNUXX1zKM0T/4x+JRZIiQlNB1JzUzRtUosW0YIpyQnQvnaZP/5qlRx9dEfePkzEdQ82BRMc855w/ebkc9XuUCNN5zMR1ihxaOmOD6I/UNoHoc5dc8oexn4vjy0WdxXMl1wY/0L2UC6XffXciSs/PPU0476tmuMTGSJ0jTvpfxnEvdxIhHPt14Lb5v6moOZZ0yJ/Jc4rOH2vffYujISwNHjyYLVy40Poi3yMyu6k+SpUrV+afrVjhjPxYsGAB69GjB9cokRYqKBRtR2a4ZcvMznZ07po1azpeAj85lmgy3X//hGO1LDx5Ra2o2Bx3dblT1MlWHRC24ra63xPCh4YG3I8/FloFwk2bEvZlZ+kVfVc0hS+bhIxnn21g1G557WBMPksmyMH33Xd/8vxeaXtjWs2BTpMgZ/aVn8Ff/7rVU1jSOTHeeWdzjbBUzpeJh95TyzT4FZZMWhKzZsneN+Vrcwtm7k2KvMvv1csuKKiRNYnjlmj7p01w092nQYPWcA0GaffkWl1y/TwTLVsmJnSvZyAWMtJqPPTQSta4cWJBbt9+p8O3TpQDSQZZqCONk5yWQxV6BWpwh6kfm+6HqfaZzN/+toELbiJhqJcQRX1Oze6vu8eTJ9e2+kiq/VL4/+k1uG6NvB9/IBk1utcre7eXQEJmONlESm2U58tq1fay007b7GvTSfnpPvhgsW9h6dZbE+H9thxWpef21nKrn7Vvv8OYsoI2Khdc4FYqhM7Bu0GDBvzlBWmSSEBZvHgxO+qoo/h7u3fv5gJNq1YJOzJFwR1//PHssssuYyNHjkyqTbNnz+a+URRZlww2YenDD2vFk/+J3ZbfMHjTd2wOebqBp6qnTY7IJuSF7s0368ZDwm+/fQ3PWp0QlvSaJdO5vE1kfnKhlE6oZjNcejVL5JwtopO8COKTYCqiKrBNqPXqubfAYiKV22DKuG0L//fSLPkNYDAJS+rx1Wr3shnu889rGn8rFgZd3hX5cx0mYUkd185rUP003NdHQotJsPZaIGXBLJWiy/J5SJigciDpgDROQuAgnzNR4kVfY9Lur6S2U8arPBNxxx2r/xcR6+/YNCZIe02bEmFq0/Vz25iUNzSJ2pVCWDK32ZmUsvS9pUv1wUE6gjitmwRQU6FraqM8R0yfvih+73TBAHKOK/qeXx/a0uPtigcqeRXC1Tl4e2cnF791C1pUFofSDLz+ep74LJHmhkxkZFb7+OOPudB0zTXX8M/OP//8uOntuOOO42Y3Mq2tWbOGv9avT6jfv/nmG9ahQwfuLE5QtNw///lPnoqA/KLGjx/Pbr75Zta7d2/uE5UMusrsYgfx/PMJwVDecZj8hPS5REonuCuvXOc7JNzWkTp0cKp95U6oW/xsi/748fXi/69OhjotlXwuLwFBVYObrpcmnYS5M5hmSZdnyYbfXE80kQR1Wk20Sfee+7wUdUZJQG1tku+Z7l7o7mmnTjs860UJKKrFDybfB/X8fn2d1N+Ke01RiX7GmBxJavJZUtM72NoStNafrDGRHXFFEkDZj8UrM7Gt38rXlorQZdJ0XHHFH3Htp4zsFyPGZpDQd9LK+S1CTQSJEhP3S9aC6p4f+UyZkM+nJs3Vl5SKaUujqHmcvDBpz4IJSwktl2oi1bWPEBUPZJ580n/aAx2yoKRqluR5xZ+Dt/P5CX8uobFPthZnJIQlgqLULrroIp5r6dBDD2XLly9n06ZNiws1//nPf7hgRHmWyGwnXvRdwfbt27mgRVopgrRV5Nx9zDHHsM6dO3NtFAlLzzzzTNLt9Ovg5nR0lM1R+pEuOiuFWorJ2lknx9/ko36PVPW685jaYlsk5Elf3V3rJrAgNdGmT1fDdvWLH01+Jr+pVGsvqVGMfhccU/bk5IUl93vk60BJQAWqH4Y7d5ROs5S4PuE7QSZWNYrHxLBh/tJXCA1R27ZOzYbIdWTCluVYvrZVq9y12mw+RnLZH1kQpYXENJ7lcaCWqfASKlXkemNyhfjXX/+Z3Xvvb1wIEXg9A5sPnbNQdPJCV1Dk4A6RVd1rcyTTr98fgYSlICQc+GPae9y583ZPLY4siKjJX9WEpfK8sf/+O7iWhvJ0JbQfiWvs0sU+Ho44wn++I69kq9SH1Ug4v5qrmjX3aAWoVJBNxsKcRwKUH82kaYy88UbdlDYKkRGWKlasyB588EG2du1aHqo/ZcoULuAIKFIuFou5XrLvETly03uUtZs46KCD2Ndff802bdrEduzYwf2dyHmbhKjk2+lv8MqChfzwRFZsr4rwcrLA0s/15z355M3WSbBZs92OQSkvJDoVsrladYEiLKmaJd012e+VvMu2+ajIUBoDPz5LIsmnjHy9uig1NSu3bsDqErYlEyFiQ3cv1XN4mWDVfmGqVfbSS/V9L7B+omVK21ES96uREfWpTNg0Bl59ye4QqhekbGVH5HGg1lgMWhhZZ44Rpjuq6SY/Wy8hxmYWDqJZ8hLKTD4ltvNOn16TPfBAk3gghh/k8HqdsJSqhkxcp0mzJAShwYNb+rqvYp4Sx9U9D9Fmeq7vvPMTe/zxFVptvuzQrivVFESD5mWG0+WBsmU9Hzu2NELdawOdLLfdlvC3Fc/GlAVdTebp1XfzXrMUFXRmOB1OM5x/nyU5yZkzp4e+g5hS1suYBoVO+2CarGfNqua4JrfPUizwrvDBB1cazUbygJAnuiZNdsV9D9R7Iu9mdQKMrv6dTRjQfeeww7amdferS1SnmyTd0Yd253xaiNVnKe/mdMUpk12YVC2XmFzl/kVpA2xh85Rvy2by85ogbVGqZmHJ/NxsC0TQ5y2PY9N1CCdVL22CTYjZsEEfXJFMlGeQ8iHJmqD9+DWmqllSN6HqOU0CiRy1pvNZspuMncKYH4Fc1y+CCUsx32Y4nZlQ5dBDt/N0LqQ1V60TyaAW4JUjL0UbZe2XfD9UjbPXxinvNUtRFJZsndnks2RC/Y4sLFGuEZMaVNXI6IQdky+PTvAzCUtqaQu1ve6My+Zdu67Tq5OzOnlQVmj1WmyDRl+qoJx1gleFJd2Ck6q5UYWSAN5yy2r27rtLtOcQuWf69HFG9NjC4wX33Wee5HS5ivxW8lZR2yKi2kw+EX6imFRHdpuwdNddvzvaYPOF8hsRaVsMg5qwKDLN6zomTPiFff31ApcWS8X2jF5+WdYSlvjeqNjqYPohaK030xjTa5bSIyypRbS9hIzHHlvhoVkKNvfokKM/5c1d4tnpj0PZ9YMKrKoZzo9AfP75f7Ivv1wYz2SfCrIG0eaELkzWtkz/pr7tlfDVCwhLacavyeXiizcmpVkSEWiUZ8lPZMC2beV9CEv6QXHKKZut1aNlx1iadOTJzOs+qB364IO3Wb+jFlU13TNxT2iSs2n5dBOWl09T8sJS8hM6RYVcdtkGHjGim8ApDH3mzAWucG29Gc7ZflPEifx7XUkQP5i0NfLE6DQLBTOjqbtem4Dijo4x70T9Ovn7dTb3g5zrxXQfaDPkx8zp99y2+01aJVP4fzKkUpZDHju61AGpmuHEoisLE340S3LEn/xbNRou6P0QuYzcUZBunypTUXZRgsjPOW2Rin58lsqlSYKwBd+I+Y5KRak+YV6aYuLcc0vXWhGBDs1SSLBFw8lce+3aQBOc7gH7ce5ORbPktcjLWW1pwZHt7aaklPL3ZeTEbrpjXHfdOl+RU2IweWmukomiUU0cumeiO8aJJxZZTSs2dO2khZPs9FTVnhyCdbmVdJOYO49ROaPZRQ23DapZMqUpoMK0IgfNTTet8d3XVH8xd34w/w6f/s1w5nFl2wzo/N38EkTQGjv2V4dvR5Df2xYMdWOSKqksqPL1ZMLBW5eM1JSWJBmfpaDIyVPlPk+h9eq8GGTeNhVK1vksmXKLZRJ5ozp16iJjEXZ/wpJ+7UmsDdAsRcpnSdbQmAY8ZYG1LQZ+IgPcwpLd/BQEVU0r+wSpk7G7SnzMpeVQna5l85WqBVHvhxgwiQHvvk6xw9C1jzjttE1cwyUv4rbSEbr7rqrtR41a6XJk/v77+VxV/vzz3uG2psmaQrTlqvbu33mbUOUJStVaiN+ruVf8Ip9LlMohjj460Wa50rzJVEkpMsg/RA2Ttvmw2dqSLp+lTEWSBTkn1bdSk236XQh03yMBnII9HnzQvXFJhSAZmlXkeULOeJ0uzZLQEDodvPVmWT9jTWwYk+0DcjtoTL733hK+KTr66K2u/ipHUTrbw6zCkhzVK0cqqutJkDJPqSKPZ7V4ungGpElLRrMk+p+f9dIGhKU0k0wIpUlYkieHdGmWdDviICH1MvJgUguzqudxa5ZKPP0gTCVNbMKYrXYQZWslR2LVDCoLki+88Gu85pO8iJxxxp/xWl6mNujQ2fPpeZ90UpHVDJYqulpWqqDsdLC2+5ilolmSMZmSTGPghhvWsddf/8WlrVH7rN/Cmvq26jUJpt95bYhSEZaC/9Y7gENX7kTXd0kAHz9+qSMFRToIkiZA5ZBDEhoVqktJ1/DUU8vSplkSY3DjxgqBE5gG8Q9MBtIsUX4vdVMkjq1L/GjSVstaOVl7lTDDuZ2nhTlvv/1S90nywrYGyc9Ap7kzlSiyWR2SIacZvMuyZsnPwJInAiENU/JByiNDA0kIS7YJkiaYu+4qLXdhGthqnphkhCXV1OglvfuZ5GxlYEwDwlY7iLR5lIn2p5+qsM6d/U8AtIjQS71GP6a8dOarCYLOZOHWLCWen5p0UR9xl5xmKRVhyYTbZ8lmFvOvWZInXtM1eD3TZFJFNG26i/3+eyXWs2ew+m3qtcgRjSpnnrmJTZlSKy2O0bYUHOnQXFOC1a++quFIJ0Em54cfdjqeJ3MdpO29444W7NZbV2v7o3zMoGY4L1OsGuauImuLzMlbS4/dpMlubj6XS0ipgRC6+UAuQyJHVwuBRVw/RbuR+U/2o8oUtsLMQX3C1D4hNGmJKGloliInLIk8GmptIt0kLhYqqpIt8uRs3eptg6UJ0m8l63QKS17lTvzsvPwWS9S1ybSw0+8on1AyfhTqpKg7hpdQly10KnS1LbJJ7O67fw+cnsCGaaJPl7AUpEyPyWRb+v8xx7mdfnjJCUvJODS/9dbPbOLEnxx1xvwgn+ucczay00/f5GtBStbEqOLnOKp224+QRdqtPn02BA4U8cPpp29mc+fOY5deqq8JFtQM51XKSUZnSpRxlujRX7t8bDWRq2mMUsoJEsh79NjssH4kwvLdOYzIt5A08PXrZ04DHsTBm9i2zZ2awe9GWgAH7wilDhCFMe+9dxX75pv5rE2bxK6+Z8/EZCdP4urAoUl96NAWVtu1IFPmHjl8WzX7qD4o6s7Bz8IrX7+aINNthiv912/R10yRDs0SFSalzL60800WP7XfaKdO4eizZ89zTeI684MfIUCYTaigqc5XTK7vZmubF+3a7UzaZ2nJksrGxJP//W+h52KVCW0hCZG6bM9eyG0nM7FtcZdNHclowGVI60B9xCvFgElwt2kCg5CqGU6HKTrShG4xNuUMCyJom8ZbMtmr6X6///4S9sgjKz0zeKdLkA6CLbpU7tMiuttkOrc5eAuSXRtghkszfiah++//Lf6Q1UmDzD0ffljb1fFti8H8+YkJPtUEckGujcoQPP10Q220hTqJffllackMv4ujGs2mCoTqfXM78eVGoyNPrnS/ZEd+v1BCNlPRVb/oTB+6Bcqk6Zk/v7SeUlCefnoZW7myksMZXs4NlC7NEtULE2k0vBZfdexs2FDR+LstW7wTROom9mOPLWKffeYs7psNbH5nKvIYTSWcX+TYoazSfvq3Hy1nsmRCc+sndYCKVyFev8+IktCSX5bNnGpzbia3CxM6AU6Ohsvl3Hn77avZH39UcOWLUxGljGz3QG1/smWqVCAspRmd2liYqOgB08Tht36TPJGrD1gWHrxqj6UrqkGdBGjhEz5Ul17a1iq9q0V5vaR71WFc3XWrglu2NUt+Julc+SulY4FS83P5hYSeffYpNpoWTAEQQYUlkX4gVQdv2bFXbatJsMvlc1XxI4j6LSQdFL8bAV1fTNf4TJdmiZLaJmogJo6p09TpNsQ0/8jzvAmvvkMCjeqX5denipLMyvnY/CBHw/kpUpspmjbdzYMLdOj6inwf3WlEvMxw8FkKvWZJ7OxsA1yNxhFmCxFVJT4X2ic/pQk6dNjps+32QRIk5b7XJOYl3euEKzmaRz2v28E7swPeXF4mvMJSKjvGrl3dSUP9ovNZyVSNL/1n/ifHHTvKe5oG9CWDcjOV0riYPn0h++qrBdZyMV5OtJnk4ovdvkHXXWfWgORCWDIlpdSXaXI/f1MG8HTm4BI4tSqxlGq0iXbPmFEj5dD6bCog5PGubgJUIR6apYgJS6QpESG0NqdFtdzCp58u4hOxrUCmVwkEChWlYx17rDkvT7KVyE02fS9zZKYGZLYGvOn4srAknBFzgc70moqfiMkZNl3CUrqSC6YzKaJp8dElAc1mTpqg4z/d2ZaD0qrVLnbkkVt4dJvg1FNTi7A65pgiNnNmdW1B6GSQNdleSSn1Y5/eK/DcJKWjqLbs1J1qXjAyfQk2by6f06AUG1TSS95Am5Le6oBmKaSYzAyyv4BdsxRTNEsx7oib+Dx4BXBaJCl3kGoeERx11BbjDlBGNxhNE7CXrT8Z6d6WiyPbmiXT8TdtKp+yKSuMmqVUfpspYalz5+1aQfDmm/VJRdMnLO011ndTd7FhghJ77r//9rRpdYKQ7sr0jz++gs2cudC3oOiFPD97RcMNHuzuX35rCqbCm2/+xIYNW8WT5wqcJYNKUponch0ck2zgjJdWV1eXNBmgWUozpp2D37ppyZhxUt2VUzbpuXMLtfXZvDVLyZ1TJ3iNGbOC3Xpry6R8LrLts2Q6/r//XY+FAX0EUvKTeCrCpz9hKfjxKcDglltausbU5Zf/wT7+uKZn4IMXpsg93cI/cOA61qDBbnb88XbtbS4hn6Z//1vvF5JpTOU2koXGezoj4ZxFwM3RcFRihjKn69pjGmfvv7+Ya8HULPRBoXp9tpp9yYxR+brV1AFhokBJ9yGvH+Q3a0M1pSIaLuSpA+TJwmaicg46f+HbqWpRSHvVrZu3T4reZym5jqdbHL3aYPO5KCoq73DYzfSAN93zZLOhpxs11UKq/SQVE54ff55kTAiy8KyOi2R9iKi0ysKFVQMn1iQBqm/f5E2V+Y5skg7jYmyKFFS1Eh066JPZ2jK/U1mfFi1SE5RM+PWV8pNdXWywcpE6wAv1/sp//+Uv9gTD6UodADNcmjEJQmKhJydqm++APGh1kzVVXlbJltqUSnRkUrPkhU2z9N131VI+fhBM9zxXjr4qBxzgTFbXq9cmVq9e8iaLVBY4UQQ0lZBqHTZfhWSfw+jRKz1NR2pRX+CNbJL2itrLBaaNmFcOH68o5kyjum0ERV5vRIR1GIXZndJ4Dnp/1XI7SEoZcmFJdEovBz9ZINB1fp3AkI3OTQ6a55+/MW1Oo7o2ewleQaJ5Mn1PTMen7OBhQA4/pj75wAO/pZRbJxWt1PXXr2O33LKavfWWO3cUJaxs2HA3O/fc4DtvWxLHZB2uZR+YoCVbgD9TbBgXYzX61mTCMc3vchRlrhykk9lw6MxwYdQseV3noYcmCg2rPP98/dyY4Xbu3Mkef/xx9umnn7J169axEiUhzg8//MDKMmZhqbQjetnZ5d2yLhRYn5k5c537nXd+Yt99V8gXM7+C0dVXOwvOEpSRetmyyim1OYiJK1d5lq69di276qo2LNc0brw7pcWJalgNHNg6Lbtl0tBcdpneRDV8+O88EikZofugg7bziuxyBvxUE7HKAqUpzBvCUmpmuDBGW5k2YmplAj8bjmymDPHaXHsh52VKtdBsttDdX1uxZncamiw5ePfv3599/PHH7LzzzmOHHXYYK0g1FWyeYdIcJaNZ8mteyOTkQ5mY5WzMKrrHT86uKiNH/sYuuWSflDRLQZLqZd5nSf8cZdNNWMw1ulB3Lxo12pO1PpZKSLtakT2oGU6NXtuzx9vB2ysJLLALS9k0U6UqLCUjdGdTGJT7eTIaoQsv3MgeeKCJ4rMUbmGpUGMeJ6vHf/9bjScX9SJrmqXJkyez999/nx155JFJnbCs+ywF0Sz5FRhMlabDhLpgJ9NhO3fewdatq6h1Dj/wwG1s9uyE31KmVcmmCUX2Acj1c6HowkceacwefnhF4N+q5WXCvttUoVpXflATusoLuZolnEqakHbUTzAEcLJ9e+7NVMkIS8mYc9OdJsGvtj2ZTYe8HiU0S+ETZr00S6edVloiRpfB/IYb1rLHHmuUfc1Ss2bNWI0aieRiIFiepdQ1S+5BfcEFbl+ibOHXNNamTTG3K3/7bXVLh7XfG8oxQuY8XQhu9+5OYSnzPkt2DWIYhKWePYv4KxlU80MyNe6igLqwkYnt5Zd/4eNUHauPPbaCl4XIVXLHfCFM5WIyISxl8/rSEVAi6trt3RteB28vYZSsEqa0Cq1aFecmGu6hhx5it99+O1u+fHlSJ8x3nKkDYq7B6CUsHXnkVmuiSVWY6t37j7Sk0E8Wv5MJdWZRQNik+VEXaBWK5ho0aK0vH5VclTuRbec1aoR70rEhkizmI1S0U3Dwwe7rPPDAHaxz553aPgxBKXVMyXFzyZ495ZLOERYWzVKyqH06ig7eNkTNvqxrlg455BDu5N22bVtWWFjIKipbzo0bc6flCKsZjh6WX80SJTwbP/4X1qKFPtGWKhTk2tk0yM5LFh51pjR54F9wQbCcNeqklnkH75inMBvGHXSQCXTgwLXsiScS6usoQY72//pXI3bTTe5sy717b2CHHbaVTZlSi112mb3KOUg/Op/GsCJrbg4/3NsfJqqaJVGqJaqaJRuqgiFrPkt/+9vf2KpVq9ioUaNYo0aN4OCd5tQBctFcP4MjWsKSXdioW3cPH6jUuYcOXZ1SO3KVOkAWZsn0GGXSXaU+m1x99Xp29tmbWKNGiahAdzbk6CzaUefMM/9k77xTh0fKZlPzkiryvPL008t8/SabDuzp0Cz5zSUVFoIKo6qCIVntcGBhacaMGWzmzJnsL3/5S3JnzHNSjYYLOjhyHXEl7NyCf/wjYWpTkTupTrNESsovvljIUyaYfL/8apZy5eBdq1bieVx7bbQX42TD78MALQBy+gSQW4YN+537VlKQRpSQhSW/i2x2zXCpb2jSVTstKpqlZAksLHXo0IHt2BGtDh8mzVKq9YzUB59rzZKauPLMMxNFHm07GNN9SHZXphatzbTPEuX40XH00VtZ//7r+aIQpmeTDPvvj3EO0gNtEm0a87ASdgdvNWo1HcJS0I1qtgl6f9NVgirwbRk9ejQbPHgwGzlyJDvggANcPks1a9ZkZRlvM1xqA6ldu53s55+rxP8O04Ls1Yn9CEvpyOOSyfvywQeL2dq1FVnHjm4HYHGNN92U/arumaBXr81cc9ilS/46ewMgAmq2bi3PWrZM3XSeTWHJ5JgejHCb3VK9v8lm809ZWOrZsyf/t0ePHo73Y7EY91/aqyteVoZIh8+SDfLlmTWrOvvzzwqhMMMF6cSmyt7pgDQ5P/6YqDKfqfvSvPlu/ioL0I7zjDPMmkIA8oUXXljKnn++AbvuutRN51HyySKiFuFZNbDPUo6EJSpzAsyY8tGkS1iqW3cvF5huu61F6DRLXn5Cders4R2doi9MqRGS5cYb17J//7teqLMEAwDCSfv2xbx+ogoFCJAmmfK7+SVqUbBRE5aqBPRHlf3kKFFv1oSlY445xtf3rr32WjZixAhWv76ziF3ZTB1QEM+/k6qwpIbgh0lY8hKAyBY+ffpCbqrS1b1LBfU+IEgTAJAqzzzzK3vppfrsiivW561mSV5PwkqVKiVxDVFQYbRnT3InKC1yrsvw7ZeMyZSvvPIKKypKLntwlMm0GU4lTMJS375/+NoVhD2dPgAAEG3b7uLFnr1M7zfeuCZj/piZJgoby/r19yQdvEOas9NP35ySoMSPwzIE+TCVRcy14cqlTViSbbBh8VkiNTWZCMOAqQAqAABkaqNI9SnPPTe7SZlF0tURI8wpW7zYvDnk4W/M6e+aKzNnpKyV7733HuvWrRurWrUqq1OnDjvrrLMcn5ODufqaMGGC9ZiUcfySSy7hUXy1a9dm/fv3Z1u3+svUmivNkuzdH5YEYmFSPYdJ2wYAyH/IxeDll3/lWqhs0r//H+zLLxfyBKz5TIk0peeqEHP4Rcr/8eabb7Irr7ySZw4//vjj2Z49e9i8efNc3xs3blw8Yo8gAcgGCUqrV69mU6ZMYbt372b9+vVjAwYMYK+++mokhKWwqFDD5NQYJsENAAAyiZwIN18ZNeo3NmBAm5wqCCIhLJFgdOONN7IxY8ZwzY+gU6dOru+ScNS4cWNfx124cCH78MMP2bfffstr3hGPP/44O+WUU9iDDz7ImjZtGkphKZnijpnigAO2s7lzC3l23rAAYQkAAPKHzlJEW64yjPtedXVanGzxww8/8Hp05cqVY127dmVNmjRhvXr10rZp4MCBPALvsMMOY2PHjrX6TlHZFhKuhKBEnHDCCfw8s2bNMv6uuLiYO6/LL4EsDMlan0xplnLNc8/9yiZM+JknMAwLEJYAAMB/ouOwU0XSJtWunRtNmu9Vt0uXLtxf6Nlnn2Vbtmzx/H7v3r3Tls176dKl/N/hw4ezu+66i02ePJn7LB177LHc50hAqQpef/11blI799xzefoC0hSZWLNmDWvYsKHjvQoVKrC6devyz0zcd999rFatWvFXixalOY+ISpXcdjGS19IpLB166LbQhHwWFsZY5847Q2MOJCAsAQBA/lCpUoy9++4S/sqVGc63sPT555+zzp0781InpNm57LLL2BdffGH8/pNPPumZY2nIkCFap2z5tWjRIlbyP++uO++8kwtBBx98MPdNos/feOON+PHuvvtuduSRR3Lt0+23385uu+02brpLN0OHDmWbN2+Ov1auXBn/rEoVfQKhdApLxxyzhT311DI2ZcrilI+Vj4QlQhAAAKIUaUa+QWGldetdKYf/Z8Vn6eijj+Yv0tSQ9uaFF17gCSrbtWvH/YhIePLrKyQgwatv377W77Rt25Y7YKs+SpUrV+afrVhhzshJmrB7772Xm83o+yrU3nXr1rn8o0hbZbsWOpbueNkSlkiLc+SRyUfs5TvQLAEAQHBh6dRT8zuqLhUCO79Uq1aNR4yRpmnJkiXs/PPPZ0888QRr2bIlO+OMMwIdq0GDBqxDhw7WV6VKlbgmiYSTxYsTmhSKXFu2bBlr1aqV8fizZ8/m5jqTYNO9e3e2adMm9v3338ffmzZtGtdkkaCVDNWqVcpqUkrgBsISAAD4Q+QAjGLpk8hEw5FW6Y477uACC5mmKA9SJiDfp6uvvpoNGzaM+wfR+YR5jYQ14t1332Vr165lhx9+OKtSpQr3W6I0A7fcckv8ON988w279NJL2dSpU1mzZs1Yx44deZoBSknw1FNPcQHsuuuuYxdddFFSkXBE9eqVrdI7hKXMA2EJAACCa5ZABoSl6dOn82gzyn9E0WMXXHCBI6w/3ZBwRM7Xffr0YTt27OCaH9ICkeaIqFixItdw3XzzzTwCjgS5hx9+mAtCgu3bt3PtFAlFgvHjx3MBqUePHvw6yCfqscceS7KVMdaokd5PK5214YAdJKUEAAB/FBdDWEq7sPT7779zXyV6/fzzz+yII47gggUJSmSeyyQkDFHuI3rpIA2RnIxSB0XPqakEKPIt2QSUXjmWMpU6ANiBZgkAAPyxezdsb2kVliiv0SeffMIj3MiUdfnll7P27dv7/XmZwJSQMt2pA4AdaJYAAADkRFgizc5//vMfdtppp7Hy5fURX2Udqg9kQghLUatIHSX23387mzevkB11lHceMAAAKMtQ6p2yWvA+o8LSpEmTkjpBWcKmNYJmKfO8/PJSHtkBMxwAAIAyVxsuKpQv70dYwkKeSc1ehQq4vwAAANILPLvSCDRLAAAAQP4BYSmN+ImGMzmBAwAAALkiDLVGwwyEpTRiE4SQlBIAAEBYQfCRHQhLWfdZQocEAACQ+2g4GQhLdiAsZUmzBGEJAABAWKlUCcExNiAsZSHPEqWy2LOn9FZDWAIAABA2zVLlylibbEBYyoIZTtSFI6DqBAAAEBbOPPNP/u/Agety3ZRQgzxLWTDDCRMcAc0SAACAsDBixCp29dXrWPPmiQLzwA00S2mknHI3hZYTwhIAAICwrlsQlLyBsJQFM5xIG1CuXIyhrB4AAICw+SwBOxCWsmKGg3M3AAAAEFUgLGVBs4S0AQAAAEB0gbCURkwmNmTvBgAAECZghgsGhKU0As0SAACAKABhKRgQlrKYOgDCEgAAABA9ICxl0AwnqjiLpJQQlgAAAIDoAWEpi6kDICwBAAAA0QPCUhYcvGGGAwAAECbgsxQMCEtpBD5LAAAAogCEpWBAWMpguRMBhCUAAAAgukBYSiNIHQAAAADkHxCWsmCG27VLlDspyXKLAAAAADcwwwUDwlIa8SqSC80SAAAAED0gLGXBDCeAsAQAAABEDwhLaQTCEgAAgCgAM1wwICxl0QxXqRKEJQAAACBqQFjKgoO3388BAAAAED4gLKURmOEAAACA/APCUhrx0hxBWAIAAACi528VKWHpvffeY926dWNVq1ZlderUYWeddVb8sxdeeIHfQN1r3bp1xmO2bt3a9f3Ro0enJYO3+jwhLAEAAAgDcPAORgUWEd5880125ZVXslGjRrHjjz+e7dmzh82bNy/++YUXXsh69uzp+E3fvn3Zzp07WcOGDa3HHjFiBD+2oEaNGkm1EWY4AAAAIPOCXiyW3fU0EsISCUY33ngjGzNmDOvfv3/8/U6dOsX/n7RN9BKsX7+eTZs2jT3//POexyfhqHHjxim3E8ISAAAAkH9Ewgz3ww8/sFWrVrFy5cqxrl27siZNmrBevXo5NEsqL730EissLGTnnXee5/HJ7FavXj1+bBLISDizUVxczIqKihwvooKH6AlhCQAAAEgN+CwZWLp0Kf93+PDh7K677mKTJ0/mPkvHHnss27hxo/Y3pFG6+OKLHdomHTfccAObMGEC+/TTT9lVV13FzXy33Xab9Tf33Xcfq1WrVvzVokUL/j40SwAAAEBmKXPC0pAhQ4xO2eK1aNEiVlJSWoD2zjvvZOeeey47+OCD2bhx4/jnb7zxhuu4M2fOZAsXLnSY7EwMGjSIC11dunRhV199NXvooYfY448/zrVHJoYOHco2b94cf61cudKXsISklAAAAMIAHLwj5LM0ePBg7oRto23btmz16tUuH6XKlSvzz1asWOH6zXPPPccOPPBALlQFhaLtyAy3bNky1r59e+136Nz0UkEhXQAAACD/BL2cCksNGjTgLy9I6CHhZPHixeyoo47i7+3evZsLNK1atXJ8d+vWrez111/nprJkmD17NveN8oqg06FqlpA6AAAAQBiJsmapoKwJS36pWbMmN5ENGzaM+weRgESO2MT555/v+O5rr73GNUO9e/d2Heebb75hl156KZs6dSpr1qwZN9fNmjWLHXfccTwijv6++eab+W/JJyoo8FkCAAAAMguEJQskHFWoUIH16dOH7dixg5vLKDWAKtSQY/c555zDateu7TrG9u3buXaKtFIEaavIuZscx8lHqU2bNlxYIj+mZEAGbwAAACCzQFiyULFiRfbggw/yl40ZM2YYPyNHbjmR1UEHHcS+/vrrtLURqQMAAACAzFLmouHyjXLloFkCAAAAMgmEpYjj5bPkZaYDAAAAgB0ISxHHywwHYQkAAABIDYpYzzYQltKImmdJFX4hLAEAAACpAc1SxIEZDgAAAMgsEJYiDsxwAAAAwk6UE1ISEJbyPBoOwhIAAACQGhCWIo53Bu+sNQUAAADISwogLEWbihXtDxCaJQAAALkGZrjgQFhKI5Uq2W8nhCUAAAAgNSAs5ZmwVFDgFI4gLAEAAAiDsBFl7VI55FmKNoWFdqckCEsAAABA9ICwlEaqVati/RzCEgAAgFwTZa0SATNcnjt4qxm+AQAAABAMCEsRp0GDesbPKlQocZU/AQAAALJN1DVL5eCzlL8gxxIAAACQOtAs5THwVwIAABAGoq5ZKoCwlF/IzxPCEgAAgDAAYSk4EJayBAlLUe+gAAAAok/U16ICCEv5CzRLAAAAwgCEpeBAWMoS0CwBAAAA/gjbeglhKUtAswQAACAMhE0QCQo0S3lMhQq5bgEAAAAAYSkZICxlCWiWAAAAhIGoC0u5AMJSlqhYMcZiMQhMAAAAckvUhaUCaJbyF2iWAAAAgNSBsJTHIBoOAABAGMBaFBwIS1kUlmCGAwAAUBYL0aYTaJbyGJjhAAAAQKuTOhCW8jx1ADRLAAAAcg0EtuBAWMoS0CwBkFuwQIAwEIZ+GIY2pAI0S3mG/DwhLAEAAAiDoBKGNkQNCEtZAsISAACAMBB1YakAmiU9n332Gb85ute3334b/96PP/7Ijj76aFalShXWokUL9sADD3gee8WKFezUU09lhYWFrGHDhuzWW29le/bsyUhSSgAAAGWbMAgqYWhD1NofiYplRxxxBFu9erXjvbvvvptNnTqVHXLIIfzvoqIidtJJJ7ETTjiBPfXUU2zu3Lns8ssvZ7Vr12YDBgzQHnfv3r1cUGrcuDGbMWMGP8ell17KKlasyEaNGpXWa4BmCYDcT7AIsgC5JgyCShjaEDUiISxVqlSJCzSC3bt3s3feeYddf/318Yc+fvx4tmvXLjZ27Fj+/c6dO7PZs2ezhx9+2Cgsffzxx2zBggXsk08+YY0aNWIHHnggu/fee9ntt9/Ohg8fzo+TLiAsAQAAAKlvbmCG88mkSZPYhg0bWL9+/eLvzZw5k/31r391CDgnn3wyW7x4Mfvzzz+1x6HfHHDAAVxQkn9DWqr58+cbz19cXMy/I7/8pA4AAABQtgmDVicMbUgFCEs+ef7557lQ07x58/h7a9ascQg9hPibPtORzG+I++67j9WqVSv+Iv8oHYceuo3VrbuH1aixlx1xxBZW1rOuygifs0zdCzKlBm1Pqni1KRsDvIJFKhfnN92bKE+gftpevXr1rLQlX8apSbOeL9eXKqb7IO5b+fLltZ/XrFkz5bGW6u+rVavG6tevz8JKQUGBcbzS/aXPK1eunPSxk7l/OdV3DBkyhN1///3W7yxcuJB16NAh/vdvv/3GPvroI/b666+zXDF06FA2aNCg+N+kWdIJTOef346deOIm3mZ1sLRs2TKlNpDGjMyRRLNmzVidOnVYppk3b158sW3fvn38/fXr13NtW9OmTR0TyJYtW9jy5cu5w327du3Y0qVL2fbt2/m9IiETAADCAvmsksWChAjaNAvrAq0/tk1IMshuJX7ZunUrW7ZsGRcS9t13X7ZkyRLuetKmTRsu/CTD/vvvH7/uevXq8X8zdc3phu5BOvBjGSJyejcGDx7M+vbta/1O27ZtHX+PGzeOP9QzzjjD1fnWrl3reE/8beqY9P4333wT6DcEdVa/Uq1uF5+OnRl1ZCEsmXYwmYKEH5kGDRpovyeus6SkJCvtAgCAZBHahrAGAZjal6qWSaxRtOEVQHsYMmGJFlnTQquDOgkJSyJiTaZ79+7szjvv5AKE+GzKlClcA2LSutBvRo4cydatW8fTBojfkOanU6dOLB3opPN0dES6xh07dmRVWCJtGGmR/O6K1MEt/o2yuQcAkP/IAklY5ivTfJoqwmwoC0thueYwESnxcdq0aezXX39lV1xxheuziy++mD/0/v37c/Xpa6+9xh599FGHuWzixIkOkx6lGiChqE+fPmzOnDncvHfXXXexgQMHJm0P9SMYpUtYEmRLWCIhcp999vF9b6BZAgBEhUxpbtKFOp+ma/Mp1hJhqUjVnzRfKRc1x27KuSQLPALygaFUACRMHXzwwdzEd8899zjSBmzevJn7+shCxuTJk/m/pGXq3bs311qNGDEibW3OlLAkC0hhtS1DswQAiAryfBVGU1ym5lPVSgMTnJ5wrrIGXn31VevnXbp0YV988YXxc/KPUn2kWrVqxd5//32WKTKtWaKBkm2fJb9AswQAiLqwFJbNXaY0X7R+0Fwt5mkIS3kgLEURXUdOh3BDmrSdO3fyMi1hGcwqcrvkCSis7QUAlF3CLiwJIUa0L13aL7o+sk5QZJ18HuAEwlIOSEdnpGM0adKEReU6oV0CAESFMG7sMrn5lDfwEJb04K7kgDANwEwCzRIAIMqapTDNVaa2pKONst9rmK45TEBYygJq5wurj1G6kaMqoFkCAIQZnU9QWAUHaJayD+5KDgjrACyLuzUAAIhSNByR7vbJmqWyspkPCoSlLKBK6mVJcg97VlwAAFAJ48ZObousqU+3GQ7Ckp6ys2rnELUzh2kAZhpolgAAUSAKc1WmTIWygARhSQ+EpSygdr6wDcBs51oqS9cPAIgGURCWBOn2AYVmyRsIS1kAZrjw+gEAAEBUhKVsaJZ0xd8BhKWsoApHYRuAmSRKESYAgLKLzoE6bHOVLro4HW2kep9inapatWrKx8tHkJQyC5RlzZJshoNmCQAQdsKsWRKku32kWWrbti3bu3cvL0gP3EBYygJl2WcJmiUAQBSIwlyVybx1VapUSfsx84myo+LIIfKAC9vgyzTwWQIARIEozFWqQFfW1pNcAmEpC8gOc2XJBKcWfxRggAMAwkaUHLyFZils7ctnytbKnSPKclimPLjDulsDAIAoOHhHpX35CISlLCBrk8qqsATNEgAgCkRBs4SNZ/aBsJRlYamsmuFQSBcAEGZghgM2ytbKnSOgWUIGbwBAuImSsBTW9uUzEJayQFmuu5PJUFcAACiLPkvQLGUfCEtZjoaTnb3LAtAsAQCiRJRSB4DsAWEpC5RlzRIK6QIAokAUglHgs5Q7ICxlAerQdevW5Wnka9WqxcoSMMMBAKKALHiEXRgJu5kwHylbNqEc0rRpU1YWgRkOABAFouCzBM1S7oBmCWTVDIfBDQAII1HQLMFnKXdAWAIZBTshAEAUiJKwFNb25TMQlkBGweAGAESNsJrhotK+fATCEsgoMMMBAKIANEvABoQlkFFgYwcARIWwCyOYT3MHhCWQUdTJJmyTDwAAREUYCbswl89AWAIZRS0cjMENAAgrYRdGUBsud0BYAhkFmiUAQNQIq7AUlfblIxCWQEaBsAQAiAph19yE3UyYz0RCWPrss894J9G9vv322/h3zjzzTNakSRNWrVo1duCBB7Lx48d7Hlt3zAkTJmThqsoGYZtsAAAg6mY409+gjJc7OeKII9jq1asd7919991s6tSp7JBDDuF/z5gxg3Xp0oXdfvvtrFGjRmzy5Mns0ksv5bXYTjvtNOvxx40bx3r27Bn/u3bt2hm6krIHfJYAAFEBwhKItLBEBWgbN24c/3v37t3snXfeYddff328s9xxxx2O39x4443s448/Zm+99ZansETCkXx8kD4wuAEAUSFq81XY25dPRMIMpzJp0iS2YcMG1q9fP+v3Nm/ezOrWret5vIEDB7L69euzww47jI0dOxb24DI8+QAAyi5hn6/C3r58JhKaJZXnn3+enXzyyax58+bG77z++uvcn+npp5+2HmvEiBHs+OOPZ4WFhVwTde2117KtW7eyG264wfib4uJi/hIUFRUleSX5DwY3ACCqhG2+wnxaRjVLQ4YMMTpui9eiRYscv/ntt9/YRx99xPr372887qeffsq1Ts8++yzr3LmztQ3k+3TkkUeyrl27cn+n2267jY0ZM8b6m/vuu4/7QolXixYtAl552UE8R/lvAAAII2EXRsLevnwmp5qlwYMHs759+1q/07ZtW5czdr169dgZZ5yh/f7nn3/OTj/9dPbII49wB++gdOvWjd17771cc1S5cmXtd4YOHcoGDRrk0CxBYDJDAxqmTQBA2Am7MBL29uUzORWWGjRowF9+oQWXhCUSgipWrOj6nNIHkDP3/fffzwYMGJBUm2bPns3q1KljFJQI+sz2OXBHxIU1ugQAAKIqjIS9fflEpHyWpk2bxn799Vd2xRVXaE1vJChRFNy5557L1qxZE4+kE07eEydO5FohYdp799132dq1a9nhhx/OqlSpwqZMmcJGjRrFbrnllixfWX4DMxwAIAqEXVgKe/vymXJRc+ymnEsdOnRwffbiiy+y7du3c38iSkwpXuecc44jOm7x4sXxv0k79cQTT7Du3bvzJJbkDP7www+zYcOGZe2aygIQlgAAUSDswkjY25fPFMTgTJIy5LNEjt4kjNWsWTPXzQkdP/30Uzx6kEyczZo1y3WTAADAxfLly9mWLVvif7dv317r8pErNm3axIOcBDSX0pwKMr9+R0qzBKKfxVvN6A0AAGEh7JqbsLcvn8HKBTIOzHAAgCgQNWEk7O3LJyAsgYwDYQkAEAXCLiyFvX35DIQlkHFk0xsGNwAgrIRdGAl7+/IZCEsg48gDGj5LAICoaMHDJoxAWModWLlAxoEZDgAQNaIwV0WhjfkChCWQcWCGAwBEgbBv7KBZyh2RyuANognMcPnN3r172e7du3PdDJAC5cuXZxUqVCjziy+EJWACwhLIOBCW8petW7fyJHnIbRt9CgsLedUDKhFVVoGwBExAWAIZB8JS/mqUSFCiRZYKYmPijiYk6O7atYutX7+e197cd999y+w4hbAETEBYAhlHnnhJ3Q/yAzK90UJLglLVqlVz3RyQAvT8qKwHlfsgwYkKi5dForaxg7CUPcLfG0DkidoEBIKBCTs/wNgMfzAKNEu5A6MDZBx5QEOzBAAIK1Ezw0HAzR640yDjCJU+DWwISwDkhr59+7Kzzjor180INWHXgkOzlDvgswQyTrVq1Vjjxo1Z5cqVMbgBAKFFFpDCKCypbcJ8mj0gLIGMQwO6fv36uW4GADmNHKRxEMYFGCSAsARMhK83AABAhvnwww/ZUUcdxWrXrs3q1avHTjvtNPbLL7/wz4444gh2++23O75PYfUULTZ9+nT+d3FxMbvllltYs2bNuOa0W7du7LPPPot//4UXXuDHnjRpEuvUqRPXqq5YsYJ9++237MQTT+Sbh1q1arFjjjmG/fDDD45zLVq0iLeNzNf0208++YQvim+//Xb8OytXrmQXXHABP0fdunXZmWeeyZYtW+YQzgYNGhS/vttuuw25sPLQDAeyR/h6AwAgktBavG1bbl5B5YBt27ZxYeK7775jU6dO5Qvj2WefzUpKStgll1zCJkyY4BAuXnvtNda0aVN29NFH87+vu+46NnPmTP69H3/8kZ1//vmsZ8+e7Keffor/Zvv27ez+++9nzz33HJs/fz5r2LAh27JlC7vsssvYl19+yb7++mue0+iUU07h7wshh/yKKHfVrFmz2DPPPMPuvPNOV8qGk08+mdWoUYN98cUX7KuvvmLVq1fn56ewf+Khhx7iAtvYsWP5uTZu3MgmTpyYyuMtE4Q9Gg7kkBhImc2bN9Osyv8FoKywY8eO2IIFC/i/xNatJF3k5kXnToX169fzMTx37tzYunXrYhUqVIhNnz49/nn37t1jt99+O///5cuXx8qXLx9btWqV4xg9evSIDR06lP//uHHj+PFmz55tPe/evXtjNWrUiL377rv87w8++ICfe/Xq1fHvTJkyhR9r4sSJ/O+XX3451r59+1hJSUn8O8XFxbGqVavGPvroI/53kyZNYg888ED88927d8eaN28eO/PMM30/z7LI9u3beR+g15o1a2JhRLSPXiB76zc0SwCAMgdpgP72t7+xtm3bspo1a7LWrVvz98lURkk2TzrpJDZ+/Hj+HmW1Ji0SaZyIuXPncg3QfvvtxzU64vX555/HTXkElQ3p0qWL47xr165lV155JdcokRmOzk0lY+i8xOLFi1mLFi14QITgsMMOcxxjzpw57Oeff+aaJXFuMsXt3LmTn3/z5s1s9erV3DQooLpvhxxySEbuZT6BBLrABBy8AQBpobCQasXl7txBOP3001mrVq3Ys88+y81rZH7bf//942YsEoxuuOEG9vjjj7NXX32VHXDAAfxFkHBDC+n333/vWlBJcJGzYqumHDLBbdiwgT366KP8/OTL1L179/h5/UDnP/jgg+PCnAwJeiB55OcZRp8lkDsgLAEA0gLJBdWqsdBDwgppcEhQEj5I5NcjQw7TAwYM4I7gJCxdeuml8c+6du3KNUvr1q2L/94v5F/0r3/9i/spCUftP/74I/55+/bt+XukgWrUqBF/j5zCZQ466CDuQ0U+UKSZ0kEFccnn6a9//Sv/e8+ePVy4o98Cf8ISaeMAEEB0BgCUKerUqcMjxMh5msxZ06ZN487eMhThRo7Wd999N1u4cCE32QnI/EaaJxKg3nrrLW6m++abb9h9993H3nvvPeu5yfz28ssv82OSMEPHkevqUaTcPvvswzVQ5DhOwtVdd93FPxNaKvoNRdORQEcO3nR+isQjTRgVNiZuvPFGNnr0aB5BR9F11157Ldu0aVNa72M+QveYBE3qI2TmDDMwE2YXCEsAgDIFmVcoio00LWR6u/nmm9mYMWNc3yOhhPyDSHvUsmVLx2fjxo3jwtLgwYO5NogEK9IAqd9Tef7559mff/7JNTx9+vThAg5piOQFkAQcMrUdeuih7IorrohHw4lM+BQpRykM6FznnHMO69ixI+vfvz/3WRKaJmoXHZ+ELjLz0cJP0X7AGxKkKSVEWKPhyL+O/OHIjAuyRwF5eWfxfHlJUVERd9Ykx0qTWhyAfIMWZ9JqtGnTpsxWqc8GpF2ivEukBSOtU6bA8wRlkSKf6zeMsgAAECIoHxI5ipPJjgQkMqkdeeSRGRWUAAB2ICwBAECIoASVlEGc0gmQb9IJJ5zAk0wCAHIHhCUAAAgR5AslR98BAHIPHLwBAAAAACxAWAIAAAAAsABhCQCQEgiozQ/wHAEwA2EJAJBSUrwgpTpAeNm+fTv/t2LFirluCgChAw7eAICkoHIQlCBx/fr1fIFFLa3oapRIUKLyLbVr10ZmaACiKixRKv/jjjtO+xmVGaBMt8uWLePJ1FSoWvjhhx9uPDaF515zzTXs008/5blNKOMtlS1AXSAA/JWGoESGy5cvz3VzQIqQoNS4ceNcNwOAUBIJieCII45gq1evdrxHNZumTp3KDjnkEMf7n3zyCevcubMjdb0JKoZ56qmn8glixowZ/BwUsku75FGjRmXgSgDIL6jsAiVPhCku2tCcB40SABEXlmhClnc8u3fvZu+88w67/vrrXfV7SDjyuzv6+OOP2YIFC7iARRW+DzzwQHbvvffyhHDDhw/n5wUA2CHzG8pjAADymUg6GUyaNIlt2LCB9evXz/XZGWecwQtTUi0l+p4NMtEdcMABXFASnHzyybxWzPz58zPSdgAAAABEi0holnSVu0moad68efw98jeikgBUQ4l2um+++SavBE4VvEmA0rFmzRqHoESIv+kzE8XFxfwlIOEKAAAAAPlJTjVLQ4YM4WY022vRokWO3/z222/so48+Yv3793e8TzWUBg0axLp168YdvkePHs169+7NxowZk/Z2kwM4VSkWrxYtWqT9HAAAAAAIBznVLA0ePJj17dvX+p22bds6/h43bhz3SzJpi2RIcJoyZYrxc/Jtomg6mbVr18Y/MzF06FAumAk2b97MWrZsCQ0TAAAAECHEuu2VlDWnwlKDBg34yy90MSQsiYg1L2bPns1Dm010796djRw5kucXIT8ngoSrmjVrsk6dOhl/V7lyZf5SbzY0TAAAAED02LJlC7cU5YXP0rRp03hOlyuuuML12Ysvvsij17p27cr/fuutt9jYsWPZc889F//OxIkTuVZImPZOOukkLhT16dOHPfDAA9xP6a677mIDBw50CENeNG3alK1cuZLVqFHDFZ0HsgsJriS00vMgoRfkDjyLcIHnER7wLMIDKWFIUKJ13EaFqDl2U86lDh06aD+nsH9KjkcJJek7r732GjvvvPMc5rLFixfH/6a8IpMnT+ZJKUnLVK1aNZ6UcsSIEYHaRQ7lsrM5yD00AWESCgd4FuECzyM84FmEA5tGSVAQQ/VEkGc7Nur4JBhjEsoteBbhAs8jPOBZRI9I5lkCAAAAAMgWEJZAXkG+ZsOGDQvkcwYyA55FuMDzCA94FtEDZjgAAAAAAAvQLAEAAAAAWICwBAAAAABgAcISAAAAAIAFCEsAAAAAABYgLIHQQ4WLqTgyZUinsjRnnXWWI7kosXPnTp55neoGVq9enZ177rnxOn+CFStWsFNPPZUVFhby49x6661sz549Wb6a/IIKVlPW+ptuuin+Hp5F9li1ahUvGE73umrVquyAAw5g3333Xfxzit+55557eNkn+vyEE05gP/30k+MYGzduZJdccgnP91O7dm1epHzr1q05uJpos3fvXnb33XezNm3a8Hu9zz778ETJcgwVnkeEoWg4AMLMySefHBs3blxs3rx5sdmzZ8dOOeWUWMuWLWNbt26Nf+fqq6+OtWjRIjZ16tTYd999Fzv88MNjRxxxRPzzPXv2xPbff//YCSecEPvvf/8be//992P169ePDR06NEdXFX2++eabWOvWrWNdunSJ3XjjjfH38Syyw8aNG2OtWrWK9e3bNzZr1qzY0qVLYx999FHs559/jn9n9OjRsVq1asXefvvt2Jw5c2JnnHFGrE2bNrEdO3bEv9OzZ8/YX/7yl9jXX38d++KLL2Lt2rWL/e1vf8vRVUWXkSNHxurVqxebPHly7Ndff4298cYbserVq8ceffTR+HfwPKILhCUQOdatW0dbtdjnn3/O/960aVOsYsWKfHISLFy4kH9n5syZ/G9akMuVKxdbs2ZN/DtPPvlkrGbNmrHi4uIcXEW02bJlS2zfffeNTZkyJXbMMcfEhSU8i+xx++23x4466ijj5yUlJbHGjRvHxowZE3+Pnk/lypVj//73v/nfCxYs4M/m22+/jX/ngw8+iBUUFMRWrVqV4SvIL0499dTY5Zdf7njvnHPOiV1yySX8//E8og3McCByUIkAom7duvzf77//nu3evZurtAVUG7Bly5Zs5syZ/G/6l0wUjRo1in/n5JNP5mUH5s+fn/VriDpkZiMzmnzPCTyL7DFp0iR2yCGHsPPPP5+bMqmI+LPPPhv/nIqOU3Fw+VlQiY1u3bo5ngWZeug4Avo+1bucNWtWlq8o2lDd0qlTp7IlS5bwv+fMmcO+/PJL1qtXL/43nke0iVQhXQBKSkq4f8yRRx7J9t9/f/4eTUCVKlXik4wMLcb0mfiOvDiLz8VnwD8TJkxgP/zwA/v2229dn+FZZI+lS5eyJ598kg0aNIjdcccd/HnccMMN/P5TQXBxL3X3Wn4WJGjJUCFy2ojgWQRjyJAhXOCnzQEVaScfppEjR3L/IwLPI9pAWAKR02jMmzeP79hA9lm5ciW78cYb2ZQpU1iVKlVy3RxW1jcOpIEYNWoU/5s0SzQ2nnrqKS4sgezy+uuvs/Hjx7NXX32Vde7cmc2ePZtv7Jo2bYrnkQfADAciw3XXXccmT57MPv30U9a8efP4+40bN2a7du1imzZtcnyfIrDoM/EdNSJL/C2+A7whM9u6devYQQcdxHe89Pr888/ZY489xv+fdsl4FtmBIqo6derkeK9jx4480lC+l7p7LT8Lep4yFJVIEVl4FsGgiE7SLl100UXczNynTx92880382heAs8j2kBYAqGHAhFIUJo4cSKbNm0aD82VOfjgg1nFihW5v4CAUgvQotG9e3f+N/07d+5cx0RE2hEKz1UXHGCmR48e/D7Srlm8SLtBpgbx/3gW2YFM0WoKDfKXadWqFf9/Gie0wMrPgsxE5PsiPwsSbEkIFtAYI60V+dIA/2zfvp37FsmQOY7uJYHnEXFy7WEOgBfXXHMND7f97LPPYqtXr46/tm/f7ghXp3QC06ZN4+Hq3bt35y81XP2kk07i6Qc+/PDDWIMGDRCungbkaDgCzyJ7qRsqVKjAQ9Z/+umn2Pjx42OFhYWxV155xRGqXrt27dg777wT+/HHH2NnnnmmNlS9a9euPP3Al19+yaMcEaoenMsuuyzWrFmzeOqAt956i6fEuO222+LfwfOILhCWQOghmV73otxLAppsrr322lidOnX4gnH22WdzgUpm2bJlsV69esWqVq3KJ7HBgwfHdu/enYMrym9hCc8ie7z77rtc8KTw8w4dOsSeeeYZx+cUrn733XfHGjVqxL/To0eP2OLFix3f2bBhA1+MKScQpW/o168fTw0BglFUVMTHAW0UqlSpEmvbtm3szjvvdKTDwPOILgX0n1xrtwAAAAAAwgp8lgAAAAAALEBYAgAAAACwAGEJAAAAAMAChCUAAAAAAAsQlgAAAAAALEBYAgAAAACwAGEJAAAAAMAChCUAAAAAAAsQlgAAkeOzzz5jBQUFroK92YLqe1HR2r1792bsHIcffjh78803M3Z8AIB/kMEbABBqjj32WHbggQeyf/7zn/H3du3axSuxN2rUiAtN2YaKNw8aNIgXEM4UkydP5lXrqViuWqAVAJBdMAIBAJGjUqVKvIJ7LgSlL7/8kv3yyy/s3HPPzeh5evXqxbZs2cI++OCDjJ4HAOANhCUAQGjp27cv+/zzz9mjjz7KBSN6LVu2zGWGe+GFF1jt2rW5NqZ9+/assLCQnXfeeWz79u3sxRdfZK1bt2Z16tRhN9xwg8N0VlxczG655RbWrFkzVq1aNdatWzd+bBsTJkxgJ554IqtSpUr8veHDh3Pt19ixY1nLli1Z9erV2bXXXsvP9cADD3DBrmHDhmzkyJHx35BSn35H369cuTJr2rQpb5+gfPny7JRTTuHnAwDklgo5Pj8AABghIWnJkiVs//33ZyNGjODvNWjQgAtMKiQYPfbYY1y4II3MOeecw84++2wuRL3//vts6dKlXBt05JFHsgsvvJD/5rrrrmMLFizgvyFhZeLEiaxnz55s7ty5bN9999W26YsvvmAXX3yx633SNpEW6MMPP+T/T8IanXO//fbjAt+MGTPY5Zdfzk444QQulJE/0iOPPMLP3blzZ7ZmzRo2Z84cxzEPO+wwNnr06DTdTQBAskBYAgCEllq1anGTG2mKSDtjY/fu3ezJJ59k++yzD/+bhJWXX36ZrV27lmt6OnXqxI477jj26aefcmFpxYoVbNy4cfxfEpQI0jKRsEPvjxo1Snue5cuXx78vU1JSwjVLNWrUiJ+L/I1IUCOfI9J43X///fz8JCzReemaSHiqWLEi1zCRcCRD51m5ciU/NvyWAMgdGH0AgLyABCohKBHk/E3mNxKU5PfWrVvH/5+0R2QmI80PfUe8SAtEmiETO3bscJjgBHQuEpTkc5HQJAs58vnPP/98fqy2bduyK6+8kmu19uzZ4zhm1apVuaBE5kIAQO6AZgkAkBeQdkaGfJp075HwQWzdupX7BX3//ff8XxlZwFKpX78++/PPP1M+f4sWLbjm6ZNPPmFTpkzhPk5jxozhwpr4HUX8kS8VCU0AgNwBYQkAEGrIDJeJfEZdu3blxyVNz9FHHx3od+TnlA5ICDr99NP5a+DAgaxDhw5c43XQQQfxz+fNm8fPBwDILRCWAAChhsxbs2bN4k7dpPGpW7duWo5L5jfKk3TppZeyhx56iAsl69ev5wknu3Tpwk499VTt704++WQeYZcqFMFHwhr5L5EJ8ZVXXuHCU6tWrRzO5CeddFLK5wIApAZ8lgAAoYacrslMRv4/FAlHjtHpghy5SVgaPHgwd8A+66yz2LfffsudrU2QgDV//nxuQksFitJ79tlneXQeCWdkjnv33XdZvXr1+OerVq3iEXT9+vVL6TwAgNRBBm8AAAjIrbfeyoqKitjTTz+dsXPcfvvt3DfqmWeeydg5AAD+gGYJAAACcuedd3JzmXDWzgSUxPLee+/N2PEBAP6BZgkAAAAAwAI0SwAAAAAAFiAsAQAAAABYgLAEAAAAAGABwhIAAAAAgAUISwAAAAAAFiAsAQAAAABYgLAEAAAAAGABwhIAAAAAgAUISwAAAAAAzMz/A/UwIpE8NztCAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Re-run complete (g=6.0)\n" - ] - } - ], + "outputs": [], "source": [ "g_strong = 6.0\n", "\n", diff --git a/notebooks/NW_Clamp_Weight_Optimization.ipynb b/notebooks/NW_Clamp_Weight_Optimization.ipynb index 3c3ab8e7..13dfbeb6 100644 --- a/notebooks/NW_Clamp_Weight_Optimization.ipynb +++ b/notebooks/NW_Clamp_Weight_Optimization.ipynb @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "200dec5d", "metadata": {}, "outputs": [], @@ -61,7 +61,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "32a1bcdd", "metadata": {}, "outputs": [], @@ -90,21 +90,10 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "85d26bbf", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "exc.configure(\n", " pop_name=\"exc\", N=20,\n", @@ -137,18 +126,10 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "7b7bd701", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "nodes: ['clamp', 'exc', 'conn', 'sim', 'ana']\n" - ] - } - ], + "outputs": [], "source": [ "wf = WorkflowBuilder(\"NW_Clamp_Weight_Optimization\")\n", "for node in [clamp, exc, conn, sim, ana]:\n", @@ -177,18 +158,10 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "1c5a6540", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "target measures: ana.firing_rate_hz.exc\n" - ] - } - ], + "outputs": [], "source": [ "explore_clamp_amp_na = clamp.NODE_DEFINITION.parameters[\"amp_na\"]\n", "explore_clamp_amp_na.optimizable = True\n", @@ -222,180 +195,10 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "02d02844", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in ./results/clamp_weight/network\n", - "\n", - " -- N E S T --\n", - " Copyright (C) 2004 The NEST Initiative\n", - "\n", - " Version: 3.7.0\n", - " Built: Mar 4 2025 17:27:39\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", - "2026-09-07 00:17:42,592 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:42,600 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:42,605 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:42,606 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:42,608 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:42,610 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:42,620 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:42,662 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:42,681 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - "baseline measurables:\n", - " ana.firing_rate_hz.exc 0\n", - " ana.isi_stats.exc.cv 0\n", - " ana.isi_stats.exc.mean_ms 0\n", - " ana.isi_stats.exc.n_intervals 0\n", - " ana.isi_stats.exc.std_ms 0\n", - " clamp.iclamp.amp 200\n", - " clamp.iclamp.delay 50\n", - " clamp.iclamp.duration 450\n", - "\n", - "algorithm : cmaes (pop_size=16, max_generations=12)\n", - "dimensions: 2\n", - " clamp.amp_na [100.0, 1000.0] nA\n", - " conn.syn_weight [1.0, 100.0] pA\n", - "objectives: 1\n", - " exc.mean_firing_rate in [40.0, 50.0] Hz <- ana.firing_rate_hz.exc\n" - ] - } - ], + "outputs": [], "source": [ "spec = build_spec(\n", " workflow,\n", @@ -422,14254 +225,10 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "335f50e7", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,169 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,173 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,177 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,178 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,179 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,182 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,189 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,233 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,260 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,277 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,282 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,285 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,286 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,288 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,290 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,299 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,342 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,362 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,383 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,387 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,391 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,392 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,393 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,396 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,404 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,448 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,468 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,488 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,492 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,496 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,497 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,498 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,500 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,508 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,550 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,569 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,590 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,593 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,597 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,598 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,601 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,603 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,611 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,654 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,679 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,699 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,737 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,742 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,743 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,744 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,747 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,756 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,799 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,826 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,848 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,851 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,855 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,856 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,857 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,859 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,866 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,909 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,928 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,949 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,952 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,957 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,958 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,959 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,961 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:43,969 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,012 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,033 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,052 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,056 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,059 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,060 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,062 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,064 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,072 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,116 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,141 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,161 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,165 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,169 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,170 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,172 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,174 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,181 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,224 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,243 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,261 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,265 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,269 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,270 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,271 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,273 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,281 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,324 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,352 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,375 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,379 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,385 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,386 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,388 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,390 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,398 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,442 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,468 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,489 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,493 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,497 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,498 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,499 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,501 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,509 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,553 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,580 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,599 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,604 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,608 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,609 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,610 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,612 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,620 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,664 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,683 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,703 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,707 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,710 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,711 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,713 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,715 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,723 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,765 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,786 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,806 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,810 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,814 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,815 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,816 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,818 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,825 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,868 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,888 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,918 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,923 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,927 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,928 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,930 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,932 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,940 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:44,984 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,010 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,030 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,035 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,040 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,041 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,042 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,044 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,052 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,096 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,122 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,143 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,147 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,151 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,152 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,153 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,156 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,164 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,207 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,234 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,256 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,260 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,264 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,265 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,266 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,268 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,276 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,320 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,347 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,367 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,371 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,375 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,376 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,378 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,380 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,387 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,431 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,458 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,478 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,482 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,486 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,487 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,489 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,491 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,498 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,542 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,568 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,588 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,593 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,597 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,598 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,599 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,601 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,610 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,653 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,678 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,699 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,703 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,709 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,710 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,712 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,714 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,722 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,769 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,792 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,811 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,815 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,819 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,820 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,822 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,824 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,832 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,876 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,900 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,920 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,924 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,927 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,928 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,930 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,932 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,940 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:45,984 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,010 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,032 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,036 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,040 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,041 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,043 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,045 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,052 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,096 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,124 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,146 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,150 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,154 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,156 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,157 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,159 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,167 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,211 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,238 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,259 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,263 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,267 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,268 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,269 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,271 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,280 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,323 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,350 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,370 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,374 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,378 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,380 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,381 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,383 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,391 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,435 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,463 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,482 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,486 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,491 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,492 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,493 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,495 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,503 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,547 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,573 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,595 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,599 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,603 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,604 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,606 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,608 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,617 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,660 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,686 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,716 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,720 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,725 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,726 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,727 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,729 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,739 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,783 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,807 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,828 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,832 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,836 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,837 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,839 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,841 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,849 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,892 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,917 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,937 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,941 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,945 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,946 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,948 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,950 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:46,957 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,001 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,027 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,047 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,051 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,055 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,056 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,057 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,059 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,067 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,111 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,137 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,158 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,164 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,167 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,168 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,170 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,172 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,180 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,224 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,251 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,272 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,276 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,280 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,281 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,283 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,284 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,292 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,335 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,359 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,380 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,384 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,388 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,390 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,391 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,393 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,401 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,444 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,469 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,486 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,490 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,494 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,495 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,497 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,499 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,507 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,551 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,577 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,599 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,603 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,607 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,609 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,610 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,612 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,620 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,664 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,685 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,706 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,710 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,714 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,715 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,717 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,719 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,727 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,771 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,796 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,815 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,819 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,824 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,825 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,827 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,829 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,837 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,880 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,900 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,922 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,926 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,930 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,932 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,933 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,938 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,946 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:47,991 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,016 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,037 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,041 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,045 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,047 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,048 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,050 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,058 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,102 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,125 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,144 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,149 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,153 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,154 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,156 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,158 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,166 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,209 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,233 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,255 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,258 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,262 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,264 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,265 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,268 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,275 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,320 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,348 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,372 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,376 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,381 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,382 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,383 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,385 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,393 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,438 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,463 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,494 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,500 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,504 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,506 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,508 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,510 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,518 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,562 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,588 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,608 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,613 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,618 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,619 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,621 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,624 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,633 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,676 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,701 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,724 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,728 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,733 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,735 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,736 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,739 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,748 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,792 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,814 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,836 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,843 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,849 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,851 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,852 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,855 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,863 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,908 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,935 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,955 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,959 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,963 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,964 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,966 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,968 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:48,978 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,023 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,049 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,071 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,075 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,079 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,081 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,083 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,085 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,093 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,137 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,162 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,182 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,187 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,191 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,192 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,194 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,196 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,205 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,249 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,275 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,296 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,300 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,304 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,306 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,308 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,310 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,318 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,363 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,388 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,411 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,416 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,420 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,422 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,423 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,425 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,434 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,477 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,502 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,524 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,528 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,533 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,534 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,536 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,538 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,547 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,591 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,612 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,634 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,639 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,647 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,648 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,650 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,652 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,662 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,707 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,733 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,754 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,759 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,763 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,765 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,766 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,768 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,777 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,821 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,850 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,873 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,877 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,881 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,882 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,884 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,886 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,894 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,939 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,962 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,986 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,991 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,995 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,996 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:49,998 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,000 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,008 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,052 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,073 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,094 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,099 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,102 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,104 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,106 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,108 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,116 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,161 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,186 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,207 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,211 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,216 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,217 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,219 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,221 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,229 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,273 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,300 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,331 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,336 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,340 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,342 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,343 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,345 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,354 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,407 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,429 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,451 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,456 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,460 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,462 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,464 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,467 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,476 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,519 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,542 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,563 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,567 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,572 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,573 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,575 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,577 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,585 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,630 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,658 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,680 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,684 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,689 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,691 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,692 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,695 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,705 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,748 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,770 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,792 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,796 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,801 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,802 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,804 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,806 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,814 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,858 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,885 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,907 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,911 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,916 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,917 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,919 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,921 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,930 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,974 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:50,999 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,021 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,026 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,030 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,032 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,033 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,036 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,045 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,089 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,117 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,140 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,144 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,149 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,150 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,152 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,155 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,164 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,208 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,234 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,256 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,260 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,265 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,266 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,268 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,270 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,279 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,323 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,348 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,371 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,378 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,383 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,385 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,387 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,390 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,399 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,443 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,465 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,486 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,490 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,495 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,497 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,499 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,501 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,510 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,553 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,574 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,594 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,600 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,604 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,606 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,608 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,610 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,618 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,662 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,689 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,712 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,717 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,722 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,723 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,725 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,727 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,736 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,780 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,801 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,823 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,827 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,832 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,833 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,835 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,838 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,848 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,892 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,918 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,941 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,946 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,951 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,952 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,954 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,957 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:51,966 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,010 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,032 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,055 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,059 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,063 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,065 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,067 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,069 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,078 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,122 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,147 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,176 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,184 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,189 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,190 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,192 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,194 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,203 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,248 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,273 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,294 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,299 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,303 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,305 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,306 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,309 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,317 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,361 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,387 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,410 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,415 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,420 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,421 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,423 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,426 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,436 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,480 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,502 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,523 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,527 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,533 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,534 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,536 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,539 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,548 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,592 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,619 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,643 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,648 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,653 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,654 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,656 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,658 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,667 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,711 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,733 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,756 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,761 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,766 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,768 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,770 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,773 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,782 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,827 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,860 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,892 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,896 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,902 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,903 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,906 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,908 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,917 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,963 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:52,990 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,012 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,017 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,021 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,025 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,027 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,029 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,039 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,083 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,104 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,125 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,130 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,134 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,136 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,138 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,140 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,149 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,192 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,218 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,240 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,244 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,250 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,251 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,253 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,256 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,265 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,309 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,334 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,359 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,364 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,369 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,370 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,372 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,375 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,384 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,428 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,453 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,479 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,484 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,488 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,490 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,492 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,495 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,504 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,549 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,576 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,602 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,608 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,613 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,615 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,617 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,619 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,628 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,672 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,702 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,727 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,732 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,736 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,738 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,740 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,743 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,752 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,797 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,819 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,844 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,850 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,855 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,857 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,859 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,862 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,871 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,915 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,941 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,964 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,972 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,977 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,978 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,980 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,983 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:53,993 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,039 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,064 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,094 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,099 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,105 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,107 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,109 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,111 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,120 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,164 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,189 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,207 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,212 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,216 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,218 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,219 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,222 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,232 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,276 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,302 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,324 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,329 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,334 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,336 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,337 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,340 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,349 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,395 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,420 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,442 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,447 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,452 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,453 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,455 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,458 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,467 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,511 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,533 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,556 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,560 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,565 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,567 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,569 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,571 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,580 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,625 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,647 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,670 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,675 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,679 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,681 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,684 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,686 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,694 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,739 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,766 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,790 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,797 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,802 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,803 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,805 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,809 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,818 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,861 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,883 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,904 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,909 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,913 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,915 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,917 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,919 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,928 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,972 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:54,994 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,014 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,018 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,022 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,024 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,026 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,028 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,036 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,081 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,108 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,130 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,135 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,139 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,141 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,143 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,145 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,154 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,199 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,221 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,245 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,250 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,255 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,257 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,259 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,261 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,270 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,314 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,340 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,365 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,371 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,376 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,378 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,380 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,383 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,392 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,436 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,458 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,480 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,485 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,490 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,492 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,494 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,496 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,505 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,549 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,572 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,596 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,601 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,609 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,611 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,613 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,616 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,625 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,669 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,694 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,716 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,721 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,726 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,728 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,730 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,733 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,742 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,786 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,814 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,837 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,842 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,847 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,850 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,852 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,855 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,864 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,908 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:55,930 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[opt_20260907_001743] cmaes: 2 dimensions, 1 objective(s), up to 12 generations x 16 candidates\n", - " reusing network from ./results/clamp_weight\n", - " gen 1, trial 1/16 (#1): clamp.amp_na=475.3 nA conn.syn_weight=72.31 pA -> mean_firing_rate=248 Hz (off 198 Hz) <- best so far\n", - " gen 1, trial 2/16 (#2): clamp.amp_na=100.1 nA conn.syn_weight=30.93 pA -> mean_firing_rate=0 Hz (off 40 Hz) <- best so far\n", - " gen 1, trial 3/16 (#3): clamp.amp_na=232.1 nA conn.syn_weight=10.14 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 1, trial 4/16 (#4): clamp.amp_na=267.6 nA conn.syn_weight=35.21 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 1, trial 5/16 (#5): clamp.amp_na=457.1 nA conn.syn_weight=54.34 pA -> mean_firing_rate=212 Hz (off 162 Hz)\n", - " gen 1, trial 6/16 (#6): clamp.amp_na=477.3 nA conn.syn_weight=68.84 pA -> mean_firing_rate=242 Hz (off 192 Hz)\n", - " gen 1, trial 7/16 (#7): clamp.amp_na=284 nA conn.syn_weight=87.93 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 1, trial 8/16 (#8): clamp.amp_na=124.6 nA conn.syn_weight=67.38 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 1, trial 9/16 (#9): clamp.amp_na=475.6 nA conn.syn_weight=56.31 pA -> mean_firing_rate=218 Hz (off 168 Hz)\n", - " gen 1, trial 10/16 (#10): clamp.amp_na=226.3 nA conn.syn_weight=20.61 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 1, trial 11/16 (#11): clamp.amp_na=820.7 nA conn.syn_weight=96.86 pA -> mean_firing_rate=296 Hz (off 246 Hz)\n", - " gen 1, trial 12/16 (#12): clamp.amp_na=382.1 nA conn.syn_weight=69.54 pA -> mean_firing_rate=222 Hz (off 172 Hz)\n", - " gen 1, trial 13/16 (#13): clamp.amp_na=888.8 nA conn.syn_weight=89.57 pA -> mean_firing_rate=296 Hz (off 246 Hz)\n", - " gen 1, trial 14/16 (#14): clamp.amp_na=176.5 nA conn.syn_weight=4.866 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 1, trial 15/16 (#15): clamp.amp_na=252.8 nA conn.syn_weight=87.94 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 1, trial 16/16 (#16): clamp.amp_na=188.5 nA conn.syn_weight=42.69 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 1/12: best clamp.amp_na=100.1 nA conn.syn_weight=30.93 pA -> mean_firing_rate=0 Hz [target 40.0-50.0 Hz, off 40 Hz]\n", - " gen 2, trial 1/16 (#17): clamp.amp_na=592.1 nA conn.syn_weight=50.25 pA -> mean_firing_rate=214 Hz (off 164 Hz)\n", - " gen 2, trial 2/16 (#18): clamp.amp_na=618.5 nA conn.syn_weight=52.59 pA -> mean_firing_rate=220 Hz (off 170 Hz)\n", - " gen 2, trial 3/16 (#19): clamp.amp_na=607.9 nA conn.syn_weight=56.44 pA -> mean_firing_rate=232 Hz (off 182 Hz)\n", - " gen 2, trial 4/16 (#20): clamp.amp_na=622.1 nA conn.syn_weight=47.46 pA -> mean_firing_rate=210 Hz (off 160 Hz)\n", - " gen 2, trial 5/16 (#21): clamp.amp_na=550.2 nA conn.syn_weight=59.21 pA -> mean_firing_rate=230 Hz (off 180 Hz)\n", - " gen 2, trial 6/16 (#22): clamp.amp_na=492.6 nA conn.syn_weight=26.1 pA -> mean_firing_rate=126 Hz (off 76 Hz)\n", - " gen 2, trial 7/16 (#23): clamp.amp_na=381.5 nA conn.syn_weight=49.19 pA -> mean_firing_rate=178 Hz (off 128 Hz)\n", - " gen 2, trial 8/16 (#24): clamp.amp_na=418.9 nA conn.syn_weight=52.43 pA -> mean_firing_rate=198 Hz (off 148 Hz)\n", - " gen 2, trial 9/16 (#25): clamp.amp_na=558.1 nA conn.syn_weight=52.88 pA -> mean_firing_rate=220 Hz (off 170 Hz)\n", - " gen 2, trial 10/16 (#26): clamp.amp_na=675 nA conn.syn_weight=32.03 pA -> mean_firing_rate=178 Hz (off 128 Hz)\n", - " gen 2, trial 11/16 (#27): clamp.amp_na=483.3 nA conn.syn_weight=75.69 pA -> mean_firing_rate=256 Hz (off 206 Hz)\n", - " gen 2, trial 12/16 (#28): clamp.amp_na=479.7 nA conn.syn_weight=73.5 pA -> mean_firing_rate=248 Hz (off 198 Hz)\n", - " gen 2, trial 13/16 (#29): clamp.amp_na=771.7 nA conn.syn_weight=55.15 pA -> mean_firing_rate=240 Hz (off 190 Hz)\n", - " gen 2, trial 14/16 (#30): clamp.amp_na=668.8 nA conn.syn_weight=36.46 pA -> mean_firing_rate=188 Hz (off 138 Hz)\n", - " gen 2, trial 15/16 (#31): clamp.amp_na=465.4 nA conn.syn_weight=44.71 pA -> mean_firing_rate=184 Hz (off 134 Hz)\n", - " gen 2, trial 16/16 (#32): clamp.amp_na=763.7 nA conn.syn_weight=25.39 pA -> mean_firing_rate=168 Hz (off 118 Hz)\n", - " gen 2/12: best clamp.amp_na=100.1 nA conn.syn_weight=30.93 pA -> mean_firing_rate=0 Hz [target 40.0-50.0 Hz, off 40 Hz]\n", - " gen 3, trial 1/16 (#33): clamp.amp_na=409 nA conn.syn_weight=21.41 pA -> mean_firing_rate=78 Hz (off 28 Hz) <- best so far\n", - " gen 3, trial 2/16 (#34): clamp.amp_na=544.4 nA conn.syn_weight=55.08 pA -> mean_firing_rate=220 Hz (off 170 Hz)\n", - " gen 3, trial 3/16 (#35): clamp.amp_na=630.9 nA conn.syn_weight=42.66 pA -> mean_firing_rate=200 Hz (off 150 Hz)\n", - " gen 3, trial 4/16 (#36): clamp.amp_na=514.7 nA conn.syn_weight=35.82 pA -> mean_firing_rate=166 Hz (off 116 Hz)\n", - " gen 3, trial 5/16 (#37): clamp.amp_na=699.4 nA conn.syn_weight=67.33 pA -> mean_firing_rate=252 Hz (off 202 Hz)\n", - " gen 3, trial 6/16 (#38): clamp.amp_na=447.2 nA conn.syn_weight=42.73 pA -> mean_firing_rate=176 Hz (off 126 Hz)\n", - " gen 3, trial 7/16 (#39): clamp.amp_na=385.5 nA conn.syn_weight=54.42 pA -> mean_firing_rate=192 Hz (off 142 Hz)\n", - " gen 3, trial 8/16 (#40): clamp.amp_na=851.3 nA conn.syn_weight=41.22 pA -> mean_firing_rate=218 Hz (off 168 Hz)\n", - " gen 3, trial 9/16 (#41): clamp.amp_na=336.4 nA conn.syn_weight=42.97 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 3, trial 10/16 (#42): clamp.amp_na=413.4 nA conn.syn_weight=25.54 pA -> mean_firing_rate=102 Hz (off 52 Hz)\n", - " gen 3, trial 11/16 (#43): clamp.amp_na=240 nA conn.syn_weight=16.49 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 3, trial 12/16 (#44): clamp.amp_na=542.5 nA conn.syn_weight=43.88 pA -> mean_firing_rate=190 Hz (off 140 Hz)\n", - " gen 3, trial 13/16 (#45): clamp.amp_na=500.4 nA conn.syn_weight=41.24 pA -> mean_firing_rate=178 Hz (off 128 Hz)\n", - " gen 3, trial 14/16 (#46): clamp.amp_na=609.5 nA conn.syn_weight=3.193 pA -> mean_firing_rate=82 Hz (off 32 Hz)\n", - " gen 3, trial 15/16 (#47): clamp.amp_na=510.9 nA conn.syn_weight=45.03 pA -> mean_firing_rate=190 Hz (off 140 Hz)\n", - " gen 3, trial 16/16 (#48): clamp.amp_na=521.7 nA conn.syn_weight=30.36 pA -> mean_firing_rate=146 Hz (off 96 Hz)\n", - " gen 3/12: best clamp.amp_na=409 nA conn.syn_weight=21.41 pA -> mean_firing_rate=78 Hz [target 40.0-50.0 Hz, off 28 Hz]\n", - " gen 4, trial 1/16 (#49): clamp.amp_na=631.6 nA conn.syn_weight=25.52 pA -> mean_firing_rate=150 Hz (off 100 Hz)\n", - " gen 4, trial 2/16 (#50): clamp.amp_na=526.9 nA conn.syn_weight=1.751 pA -> mean_firing_rate=64 Hz (off 14 Hz) <- best so far\n", - " gen 4, trial 3/16 (#51): clamp.amp_na=287.9 nA conn.syn_weight=19.64 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 4, trial 4/16 (#52): clamp.amp_na=486.3 nA conn.syn_weight=49.47 pA -> mean_firing_rate=202 Hz (off 152 Hz)\n", - " gen 4, trial 5/16 (#53): clamp.amp_na=421.5 nA conn.syn_weight=25.65 pA -> mean_firing_rate=106 Hz (off 56 Hz)\n", - " gen 4, trial 6/16 (#54): clamp.amp_na=392.4 nA conn.syn_weight=36.35 pA -> mean_firing_rate=140 Hz (off 90 Hz)\n", - " gen 4, trial 7/16 (#55): clamp.amp_na=549.9 nA conn.syn_weight=23.75 pA -> mean_firing_rate=130 Hz (off 80 Hz)\n", - " gen 4, trial 8/16 (#56): clamp.amp_na=469.8 nA conn.syn_weight=27.65 pA -> mean_firing_rate=126 Hz (off 76 Hz)\n", - " gen 4, trial 9/16 (#57): clamp.amp_na=525.9 nA conn.syn_weight=22.61 pA -> mean_firing_rate=120 Hz (off 70 Hz)\n", - " gen 4, trial 10/16 (#58): clamp.amp_na=243.3 nA conn.syn_weight=41 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 4, trial 11/16 (#59): clamp.amp_na=505 nA conn.syn_weight=34.16 pA -> mean_firing_rate=156 Hz (off 106 Hz)\n", - " gen 4, trial 12/16 (#60): clamp.amp_na=613.9 nA conn.syn_weight=42.78 pA -> mean_firing_rate=196 Hz (off 146 Hz)\n", - " gen 4, trial 13/16 (#61): clamp.amp_na=502.5 nA conn.syn_weight=17.62 pA -> mean_firing_rate=96 Hz (off 46 Hz)\n", - " gen 4, trial 14/16 (#62): clamp.amp_na=329.2 nA conn.syn_weight=19.48 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 4, trial 15/16 (#63): clamp.amp_na=501.2 nA conn.syn_weight=27.86 pA -> mean_firing_rate=134 Hz (off 84 Hz)\n", - " gen 4, trial 16/16 (#64): clamp.amp_na=753 nA conn.syn_weight=39.8 pA -> mean_firing_rate=206 Hz (off 156 Hz)\n", - " gen 4/12: best clamp.amp_na=526.9 nA conn.syn_weight=1.751 pA -> mean_firing_rate=64 Hz [target 40.0-50.0 Hz, off 14 Hz]\n", - " gen 5, trial 1/16 (#65): clamp.amp_na=163.5 nA conn.syn_weight=18.77 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 5, trial 2/16 (#66): clamp.amp_na=293.7 nA conn.syn_weight=27.28 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 5, trial 3/16 (#67): clamp.amp_na=556.7 nA conn.syn_weight=48.37 pA -> mean_firing_rate=204 Hz (off 154 Hz)\n", - " gen 5, trial 4/16 (#68): clamp.amp_na=259.5 nA conn.syn_weight=20.57 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 5, trial 5/16 (#69): clamp.amp_na=568 nA conn.syn_weight=9.926 pA -> mean_firing_rate=90 Hz (off 40 Hz)\n", - " gen 5, trial 6/16 (#70): clamp.amp_na=597.1 nA conn.syn_weight=5.157 pA -> mean_firing_rate=84 Hz (off 34 Hz)\n", - " gen 5, trial 7/16 (#71): clamp.amp_na=764.7 nA conn.syn_weight=27.67 pA -> mean_firing_rate=174 Hz (off 124 Hz)\n", - " gen 5, trial 8/16 (#72): clamp.amp_na=651.3 nA conn.syn_weight=14.52 pA -> mean_firing_rate=118 Hz (off 68 Hz)\n", - " gen 5, trial 9/16 (#73): clamp.amp_na=465.8 nA conn.syn_weight=18.95 pA -> mean_firing_rate=90 Hz (off 40 Hz)\n", - " gen 5, trial 10/16 (#74): clamp.amp_na=329.3 nA conn.syn_weight=3.723 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 5, trial 11/16 (#75): clamp.amp_na=264 nA conn.syn_weight=9.507 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 5, trial 12/16 (#76): clamp.amp_na=639.5 nA conn.syn_weight=21.28 pA -> mean_firing_rate=138 Hz (off 88 Hz)\n", - " gen 5, trial 13/16 (#77): clamp.amp_na=267.7 nA conn.syn_weight=13.01 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 5, trial 14/16 (#78): clamp.amp_na=577.5 nA conn.syn_weight=29.82 pA -> mean_firing_rate=154 Hz (off 104 Hz)\n", - " gen 5, trial 15/16 (#79): clamp.amp_na=169.7 nA conn.syn_weight=20.96 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 5, trial 16/16 (#80): clamp.amp_na=461.6 nA conn.syn_weight=10.21 pA -> mean_firing_rate=62 Hz (off 12 Hz) <- best so far\n", - " gen 5/12: best clamp.amp_na=461.6 nA conn.syn_weight=10.21 pA -> mean_firing_rate=62 Hz [target 40.0-50.0 Hz, off 12 Hz]\n", - " gen 6, trial 1/16 (#81): clamp.amp_na=455.4 nA conn.syn_weight=8.074 pA -> mean_firing_rate=56 Hz (off 6 Hz) <- best so far\n", - " gen 6, trial 2/16 (#82): clamp.amp_na=581.2 nA conn.syn_weight=13.88 pA -> mean_firing_rate=104 Hz (off 54 Hz)\n", - " gen 6, trial 3/16 (#83): clamp.amp_na=119.5 nA conn.syn_weight=9.999 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 6, trial 4/16 (#84): clamp.amp_na=540.1 nA conn.syn_weight=31.73 pA -> mean_firing_rate=154 Hz (off 104 Hz)\n", - " gen 6, trial 5/16 (#85): clamp.amp_na=342.2 nA conn.syn_weight=10.72 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 6, trial 6/16 (#86): clamp.amp_na=459.9 nA conn.syn_weight=29.74 pA -> mean_firing_rate=132 Hz (off 82 Hz)\n", - " gen 6, trial 7/16 (#87): clamp.amp_na=772.8 nA conn.syn_weight=5.593 pA -> mean_firing_rate=116 Hz (off 66 Hz)\n", - " gen 6, trial 8/16 (#88): clamp.amp_na=219 nA conn.syn_weight=11 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 6, trial 9/16 (#89): clamp.amp_na=601.9 nA conn.syn_weight=34.39 pA -> mean_firing_rate=174 Hz (off 124 Hz)\n", - " gen 6, trial 10/16 (#90): clamp.amp_na=574.8 nA conn.syn_weight=21.2 pA -> mean_firing_rate=126 Hz (off 76 Hz)\n", - " gen 6, trial 11/16 (#91): clamp.amp_na=419.6 nA conn.syn_weight=23.57 pA -> mean_firing_rate=94 Hz (off 44 Hz)\n", - " gen 6, trial 12/16 (#92): clamp.amp_na=617.7 nA conn.syn_weight=6.605 pA -> mean_firing_rate=92 Hz (off 42 Hz)\n", - " gen 6, trial 13/16 (#93): clamp.amp_na=407.3 nA conn.syn_weight=53.99 pA -> mean_firing_rate=198 Hz (off 148 Hz)\n", - " gen 6, trial 14/16 (#94): clamp.amp_na=325.5 nA conn.syn_weight=18.94 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 6, trial 15/16 (#95): clamp.amp_na=380.2 nA conn.syn_weight=18.98 pA -> mean_firing_rate=32 Hz (off 8 Hz)\n", - " gen 6, trial 16/16 (#96): clamp.amp_na=491 nA conn.syn_weight=27.28 pA -> mean_firing_rate=130 Hz (off 80 Hz)\n", - " gen 6/12: best clamp.amp_na=455.4 nA conn.syn_weight=8.074 pA -> mean_firing_rate=56 Hz [target 40.0-50.0 Hz, off 6 Hz]\n", - " gen 7, trial 1/16 (#97): clamp.amp_na=430.7 nA conn.syn_weight=7.843 pA -> mean_firing_rate=46 Hz (in target) <- best so far\n", - " gen 7, trial 2/16 (#98): clamp.amp_na=400.7 nA conn.syn_weight=19.04 pA -> mean_firing_rate=60 Hz (off 10 Hz)\n", - " gen 7, trial 3/16 (#99): clamp.amp_na=384.3 nA conn.syn_weight=16.38 pA -> mean_firing_rate=32 Hz (off 8 Hz)\n", - " gen 7, trial 4/16 (#100): clamp.amp_na=273.4 nA conn.syn_weight=9.226 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 7, trial 5/16 (#101): clamp.amp_na=257.2 nA conn.syn_weight=15.03 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 7, trial 6/16 (#102): clamp.amp_na=381.6 nA conn.syn_weight=47.06 pA -> mean_firing_rate=170 Hz (off 120 Hz)\n", - " gen 7, trial 7/16 (#103): clamp.amp_na=321.6 nA conn.syn_weight=7.252 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 7, trial 8/16 (#104): clamp.amp_na=262.5 nA conn.syn_weight=9.975 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 7, trial 9/16 (#105): clamp.amp_na=508.6 nA conn.syn_weight=3.275 pA -> mean_firing_rate=62 Hz (off 12 Hz)\n", - " gen 7, trial 10/16 (#106): clamp.amp_na=198.6 nA conn.syn_weight=2.816 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 7, trial 11/16 (#107): clamp.amp_na=445.4 nA conn.syn_weight=7.913 pA -> mean_firing_rate=52 Hz (off 2 Hz)\n", - " gen 7, trial 12/16 (#108): clamp.amp_na=190.5 nA conn.syn_weight=10.25 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 7, trial 13/16 (#109): clamp.amp_na=355.9 nA conn.syn_weight=21.68 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 7, trial 14/16 (#110): clamp.amp_na=616.9 nA conn.syn_weight=4.625 pA -> mean_firing_rate=88 Hz (off 38 Hz)\n", - " gen 7, trial 15/16 (#111): clamp.amp_na=768.6 nA conn.syn_weight=31.46 pA -> mean_firing_rate=186 Hz (off 136 Hz)\n", - " gen 7, trial 16/16 (#112): clamp.amp_na=356.5 nA conn.syn_weight=11.08 pA -> mean_firing_rate=0 Hz (off 40 Hz)\n", - " gen 7/12: best clamp.amp_na=430.7 nA conn.syn_weight=7.843 pA -> mean_firing_rate=46 Hz [target 40.0-50.0 Hz, in target] — all targets met\n", - "[opt_20260907_001743] stopped: a candidate is inside every target band\n", - "\n", - "network rebuilt in 112 runs, reused in 0\n", - "expected: a rebuild every trial, because syn_weight is structural\n" - ] - } - ], + "outputs": [], "source": [ "buffer = io.StringIO()\n", "with contextlib.redirect_stdout(buffer):\n", @@ -14695,26 +254,10 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "191094d0", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "stop reason: a candidate is inside every target band\n", - "best trial: 97\n", - " clamp.amp_na 430.7\n", - " conn.syn_weight 7.843\n", - " measured: {'exc.mean_firing_rate': 46.0}\n", - " distance from target (raw, per objective): [0.0]\n", - "\n", - "clamp.configure(amp_na=430.6735051488371)\n", - "conn.configure(syn_weight=7.8434448541675374)\n" - ] - } - ], + "outputs": [], "source": [ "print(\"stop reason:\", result.stop_reason)\n", "if result.best:\n", @@ -14740,21 +283,10 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "ed19812e", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "\n", @@ -14839,152 +371,10 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "be9fcf0d", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/clamp_weight/optimization/opt_20260907_001743/trials/0112/network\n", - "2026-09-07 00:17:56,150 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:56,155 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:56,160 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:56,162 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:56,164 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:56,167 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:56,176 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:56,220 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:17:56,244 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - "amp_na = 430.6735051488371\n", - "syn_weight = 7.8434448541675374\n", - "firing rate = {'exc': 46.0}\n" - ] - } - ], + "outputs": [], "source": [ "result.apply_best(workflow, execute=True)\n", "print(\"amp_na =\", clamp._parameters[\"amp_na\"])\n", diff --git a/notebooks/NW_Network_Optimization.ipynb b/notebooks/NW_Network_Optimization.ipynb index ea932fb4..b52b42d8 100644 --- a/notebooks/NW_Network_Optimization.ipynb +++ b/notebooks/NW_Network_Optimization.ipynb @@ -29,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "c0bdb709", "metadata": {}, "outputs": [], @@ -62,7 +62,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "4497d68d", "metadata": {}, "outputs": [], @@ -88,21 +88,10 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "9f75c256", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "neuron = dict(\n", " model_type=\"point_neuron\", model_template=\"nest:iaf_psc_alpha\",\n", @@ -120,21 +109,10 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "4fb8d5a0", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "conn.configure(\n", " connection_rule = 1, # one synapse per pair - deterministic, no RNG noise in the objective\n", @@ -150,21 +128,10 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "1a9e92de", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "sim.configure(simulator=\"pointnet\", config_file=\"config_net_opt.json\",\n", " tstop_ms=500.0, dt_ms=0.1)\n", @@ -181,18 +148,10 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "fe43a819", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "nodes: ['exc', 'inh', 'conn', 'sim', 'ana']\n" - ] - } - ], + "outputs": [], "source": [ "wf = WorkflowBuilder(\"NW_Network_Optimization\")\n", "for node in [exc, inh, conn, sim, ana]:\n", @@ -221,18 +180,10 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "91a59458", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "target measures: ana.firing_rate_hz.exc\n" - ] - } - ], + "outputs": [], "source": [ "explore_conn_syn_weight = conn.NODE_DEFINITION.parameters[\"syn_weight\"]\n", "explore_conn_syn_weight.optimizable = True\n", @@ -269,196 +220,10 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "cbf76777", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: inh\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing ./results/net_opt/network\n", - "\n", - " -- N E S T --\n", - " Copyright (C) 2004 The NEST Initiative\n", - "\n", - " Version: 3.7.0\n", - " Built: Mar 4 2025 17:27:39\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", - "2026-09-07 09:48:49,545 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:48:49,553 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:48:49,557 [INFO] Batch processing nodes for inh/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for inh/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:48:49,569 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:48:49,570 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:48:49,572 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:48:49,577 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:48:49,581 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:48:49,623 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:48:49,642 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - "baseline measurables:\n", - " ana.firing_rate_hz.exc 0\n", - " ana.firing_rate_hz.inh 0\n", - " ana.isi_stats.exc.cv 0\n", - " ana.isi_stats.exc.mean_ms 0\n", - " ana.isi_stats.exc.n_intervals 0\n", - " ana.isi_stats.exc.std_ms 0\n", - " ana.isi_stats.inh.cv 0\n", - " ana.isi_stats.inh.mean_ms 0\n", - " ana.isi_stats.inh.n_intervals 0\n", - " ana.isi_stats.inh.std_ms 0\n", - "\n", - "algorithm : cmaes (pop_size=4, max_generations=6)\n", - "dimensions: 2\n", - " exc.nest_params.I_e [370.0, 450.0]\n", - " conn.syn_weight [0.0, 30.0] pA\n", - "objectives: 1\n", - " exc.mean_firing_rate in [28.0, 32.0] Hz <- ana.firing_rate_hz.exc\n" - ] - } - ], + "outputs": [], "source": [ "spec = build_spec(\n", " workflow,\n", @@ -485,1153 +250,10 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "5b512693", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,271 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,275 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,279 [INFO] Batch processing nodes for inh/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for inh/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,290 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,292 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,294 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,299 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,305 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,348 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,371 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,410 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,414 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,417 [INFO] Batch processing nodes for inh/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for inh/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,428 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,429 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,431 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,436 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,442 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,484 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,504 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,544 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,548 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,551 [INFO] Batch processing nodes for inh/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for inh/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,561 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,562 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,565 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,569 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,575 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,618 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,643 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,687 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,691 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,695 [INFO] Batch processing nodes for inh/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for inh/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,704 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,706 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,708 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,712 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,717 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,760 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,786 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,831 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,835 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,839 [INFO] Batch processing nodes for inh/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for inh/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,851 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,853 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,854 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,859 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,864 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,907 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,933 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,973 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,978 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,982 [INFO] Batch processing nodes for inh/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for inh/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,992 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,993 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:10,995 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:11,000 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:11,005 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:11,048 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:11,075 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:11,121 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:11,125 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:11,129 [INFO] Batch processing nodes for inh/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for inh/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:11,139 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:11,140 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:11,142 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:11,146 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:11,152 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:11,194 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:11,220 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:11,240 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:11,243 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:11,247 [INFO] Batch processing nodes for inh/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for inh/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:11,259 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:11,260 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:11,262 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:11,266 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:11,272 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:11,315 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:11,341 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[opt_20260907_094910] cmaes: 2 dimensions, 1 objective(s), up to 6 generations x 4 candidates\n", - " reusing network from results/net_opt/optimization/opt_20260907_094850/trials/0008\n", - " gen 1, trial 1/4 (#1): exc.nest_params.I_e=403.4 conn.syn_weight=21.61 pA -> mean_firing_rate=38 Hz (off 6 Hz) <- best so far\n", - " gen 1, trial 2/4 (#2): exc.nest_params.I_e=370 conn.syn_weight=9.07 pA -> mean_firing_rate=0 Hz (off 28 Hz)\n", - " gen 1, trial 3/4 (#3): exc.nest_params.I_e=381.7 conn.syn_weight=2.77 pA -> mean_firing_rate=20 Hz (off 8 Hz)\n", - " gen 1, trial 4/4 (#4): exc.nest_params.I_e=384.9 conn.syn_weight=10.37 pA -> mean_firing_rate=24 Hz (off 4 Hz) <- best so far\n", - " gen 1/6: best exc.nest_params.I_e=384.9 conn.syn_weight=10.37 pA -> mean_firing_rate=24 Hz [target 28.0-32.0 Hz, off 4 Hz]\n", - " gen 2, trial 1/4 (#5): exc.nest_params.I_e=430.5 conn.syn_weight=24.75 pA -> mean_firing_rate=52 Hz (off 20 Hz)\n", - " gen 2, trial 2/4 (#6): exc.nest_params.I_e=380.2 conn.syn_weight=19.25 pA -> mean_firing_rate=22 Hz (off 6 Hz)\n", - " gen 2, trial 3/4 (#7): exc.nest_params.I_e=437 conn.syn_weight=14.23 pA -> mean_firing_rate=44 Hz (off 12 Hz)\n", - " gen 2, trial 4/4 (#8): exc.nest_params.I_e=393.4 conn.syn_weight=7.099 pA -> mean_firing_rate=28 Hz (in target) <- best so far\n", - " gen 2/6: best exc.nest_params.I_e=393.4 conn.syn_weight=7.099 pA -> mean_firing_rate=28 Hz [target 28.0-32.0 Hz, in target] — all targets met\n", - "[opt_20260907_094910] stopped: a candidate is inside every target band\n", - "\n", - "network rebuilt in 7 runs, reused in 1\n", - "expected: rebuilt on every trial, because syn_weight is structural\n" - ] - } - ], + "outputs": [], "source": [ "buffer = io.StringIO()\n", "with contextlib.redirect_stdout(buffer):\n", @@ -1658,26 +280,10 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "b7a39fc3", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "stop reason: a candidate is inside every target band\n", - "best trial: 8\n", - " exc.nest_params.I_e 393.4\n", - " conn.syn_weight 7.099\n", - " measured: {'exc.mean_firing_rate': 28.0}\n", - " distance from target (raw, per objective): [0.0]\n", - "\n", - "conn.configure(syn_weight=7.098638567167976)\n", - "exc.configure(nest_params={**exc._parameters[\"nest_params\"], \"I_e\": 393.42826106245246})\n" - ] - } - ], + "outputs": [], "source": [ "print(\"stop reason:\", result.stop_reason)\n", "if result.best:\n", @@ -1703,21 +309,10 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "e68e670e", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "\n", @@ -1806,166 +401,10 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "bd579c07", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: inh\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/net_opt/optimization/opt_20260907_094910/trials/0008/network\n", - "2026-09-07 09:49:24,693 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:24,701 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:24,705 [INFO] Batch processing nodes for inh/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for inh/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:24,717 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:24,719 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:24,721 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:24,726 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:24,732 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:24,776 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 09:49:24,802 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - "syn_weight = 7.098638567167976\n", - "I_e = 393.42826106245246\n", - "firing rate = {'exc': 28.0, 'inh': 28.0}\n" - ] - } - ], + "outputs": [], "source": [ "result.apply_best(workflow, execute=True)\n", "print(\"syn_weight =\", conn._parameters[\"syn_weight\"])\n", diff --git a/notebooks/NW_Ring_PointNeuron.ipynb b/notebooks/NW_Ring_PointNeuron.ipynb index b276d4c0..7526e75f 100644 --- a/notebooks/NW_Ring_PointNeuron.ipynb +++ b/notebooks/NW_Ring_PointNeuron.ipynb @@ -25,7 +25,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "b2c3d4e5", "metadata": {}, "outputs": [], @@ -47,18 +47,10 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "d4e5f6a7", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'name': 'Connectivity', 'type': 'nw_connectivity', 'description': 'Receives all population builders via a fan-in port and wires directed projections according to the connections list. Each connection spec can override the node-level synapse defaults (model, weight, delay, etc.), allowing mixed synapse types in a single connectivity node.', 'parameters': {'connections': [{'source': 'popA', 'target': 'popB'}], 'connection_rule': 1, 'model_template': 'static_synapse', 'dynamics_params': 'conn_syn.json', 'dynamics_params_dict': {}, 'delay': 2.0, 'syn_weight': 5.0, 'allow_autapses': False, 'allow_multapses': True}, 'optimizable_parameters': {}, 'input_ports': {'populations': {'type': 'object', 'description': 'Fan-in port: connect any number of NW_Population outputs here. Each carries {builder, pop_name, network_dir}. Populations are identified by their pop_name parameter.', 'optional': False}}, 'output_ports': {'network': {'type': 'object', 'description': 'Dict keyed by pop_name containing all population dicts with edges added. Pass directly to NW_SimConfig.populations.'}}, 'process_steps': [{'name': 'connect', 'description': 'Build pop_name lookup from fan-in list, write synapse JSON files, call source_builder.add_edges() for each connection spec, merging per-connection overrides with node-level defaults.', 'inputs': ['populations'], 'outputs': ['network'], 'method_key': 'connect'}], 'methods': {'connect': 'Build pop_name lookup from fan-in list, write synapse JSON files, call source_builder.add_edges() for each connection spec, merging per-connection overrides with node-level defaults.'}}\n" - ] - } - ], + "outputs": [], "source": [ "popA = NW_Population(\"PopA\")\n", "popB = NW_Population(\"PopB\")\n", @@ -85,21 +77,10 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "f6a7b8c9", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "neuron_params = dict(\n", " model_type = \"point_neuron\",\n", @@ -204,260 +185,10 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "b8c9d0e1", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: PopC\n", - "Executing node: PopB\n", - "Executing node: PopA\n", - "Executing node: Connectivity\n", - "Executing node: SimConfig\n", - "[NW_SimConfig] network unchanged, reusing ./results/ring/network\n", - "\n", - " -- N E S T --\n", - " Copyright (C) 2004 The NEST Initiative\n", - "\n", - " Version: 3.7.0\n", - " Built: Mar 4 2025 17:27:39\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", - "2026-09-07 00:20:35,628 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:20:35,636 [INFO] Batch processing nodes for popC/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for popC/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:20:35,640 [INFO] Batch processing nodes for popB/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for popB/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:20:35,643 [INFO] Batch processing nodes for popA/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for popA/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:20:35,653 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:20:35,654 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:20:35,657 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:20:35,660 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:20:35,663 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:20:35,703 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:20:35,727 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: Analysis\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj4AAAHHCAYAAAC/R1LgAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsfQe4HkXV/7z3plJSIKGH0KSLBPxEBAQEpSmggCJKkaIoKp+gnyAoRWmCWPj72UWxoYgNUAQFVBT5EBSkikIAMdRAem6Se/f/zC77vrszZ+b85uzsDeHOeZ5L2H2n7ZQzZ36nTCfLskwlSpQoUaJEiRKNAOpb3g1IlChRokSJEiUaLkqCT6JEiRIlSpRoxFASfBIlSpQoUaJEI4aS4JMoUaJEiRIlGjGUBJ9EiRIlSpQo0YihJPgkSpQoUaJEiUYMJcEnUaJEiRIlSjRiKAk+iRIlSpQoUaIRQ0nwSZQoUaJEiRKNGEqCT6JEiRIlSpRoxFASfBIlSpSIoV/+8peq0+moddZZRw0NDS3v5iRKlKgBJcEnUaJEiRj63ve+pzbYYAM1a9YsdcMNNyzv5iRKlKgBJcEnUaJEiTy0YMEC9fOf/1yddNJJasaMGbkQlChRohWXkuCTKFGiFzWdeeaZuZrp/vvvV29961vVhAkT1Oqrr65OPPFEtXjx4m66ZcuWqU9+8pNq4403VmPHjs0Rmo997GNqYGCgVp5+/8Y3vlFdd911atttt1Xjxo1TW265pfrJT35C1v/Tn/5ULVq0SB1yyCHq0EMPzdNV602UKNGKRUnwSZQo0QpBWujRAsd5552n9t13X/WFL3xBvfvd7+7+fuyxx6pPfOITarvttlOf/exn1a677pqn1cKKSQ8++KB629vepvbZZ588zahRo3LB5vrrr7fSaoRn9913V2uttVZe1rx589RVV13V+vcmSpSoJcoSJUqU6EVMZ5xxRqZZ1f777197/773vS9/f+edd2Z/+9vf8v8/9thja2k+/OEP5+9vuOGG7rvp06fn76688sruuzlz5mRrr712NmPGjFr+J598Mhs1alT2ta99rfvuNa95TXbAAQe08KWJEiUaDkqIT6JEiVYIOuGEE2rPH/jAB7oeV/pPk7bDqdLJJ5+c/3vNNdfU3mvvrDe/+c3dZ60+O+KII9Rf//pX9cQTT3TfX3755aqvr08ddNBB3Xdvf/vb1a9+9Sv13HPPRf2+RIkSDQ8lwSdRokQrBL3sZS+rPWtbHi2UzJw5Uz3yyCP5/2+yySa1NFo9NWnSpPz3Kul02m6oSptuumn+ry6vpO9+97vqVa96lXr22WfVP//5z/xPGzgvWbJEXXHFFS18ZaJEidqmUa3XkChRokQtkCm4uN5JSdsB3XbbbaTQVdr+VG2MEiVKtGJQEnwSJUq0QpAWRDbccMPus0ZfdDBB7aWVZVn+/zrNFlts0U3z5JNPqueff15Nnz69VpbOq/NUBaV//OMf+b+6vFKwGT16tPrOd76j+vv7a/lvvvnm3Lj60UcfVeuvv35r35woUaL4lFRdiRIlWiHoi1/8Yu35kksuyf/Vnlnay0vT5z73uVqaiy++OP93v/32q73/z3/+k7uplzR37lx12WWX5e7tWj1WCj677LJL7v118MEH1/4+8pGP5Gl+8IMftPKtiRIlao8S4pMoUaIVgh5++GG1//77q7333lvdcsstuf3NYYcdpl7xilfkvx955JHqq1/9ao7waFf2//u//1Pf/va31YEHHpi7o5v2PMccc0yuylpzzTXVN7/5zRwduvTSS/Pfb7311hwVev/730+2Zd11183d5rVw9NGPfnQYvj5RokSxKCE+iRIlWiHohz/8YR6Y8JRTTsm9tLRQ8o1vfKP7+9e//nV11lln5cLMf//3f+dXS5x66qm5Z5ZJ2mZHl6e9wXR5S5cuzZ/32muv/PcyOvOb3vQmZ3v0b3//+9/VXXfd1cr3JkqUqB3qaJ/2lspOlChRoiiRm7VA8/TTT6spU6Y0Lk/b8Gy99dbq6quvjtK+RIkSrViUEJ9EiRIlSpQo0YihJPgkSpQoUaJEiUYMJcEnUaJEiRIlSjRiKNn4JEqUKFGiRIlGDCXEJ1GiRIkSJUo0YigJPokSJUqUKFGiEUMpgKFBOuy9juq66qqrRr33J1GiRIkSJUrUHmnLnXnz5ql11lknv7TYRUnwMUgLPdOmTVvezUiUKFGiRIkSCeixxx5T6623nvP3JPgYpJGesuMmTJiwvJuTKFGiRIkSJQJI37mngYtyH3dREnwMKtVbWuhJgk+iRIkSJUq0YhFnppKMmxMlSpQoUaJEI4aS4JMoUaJEiRIlGjGUBJ9EiRIlSpQo0YihJPgkSpQoUaJEiUYMJcEnUaJEiRIlSjRiKAk+iRIlSpQoUaIRQ0nwSZQoUaJEiRKNGEqCT6JEiRIlSpRoxFASfBIlSpQoUaJEI4aS4JMoUaJEiRIlGjGUBJ9EiRIlSpQo0YihJPgkSpQoUaJEiUYMJcEHoMHBjE2zYMGQGhri073YyfyGpUsz7+9LlmT5H5fHzLdo0ZCon5E+psqWjM2yZZn1LcuTqG+INeeGc/5S4yNJg1Csb0LmpoRifeeLiag+R9YkMlbmeoy11mNRLB5mkoQPIfxi8WJ73Zvf8GLigRRR38BREnwYOuaY+WrNNQfV448vy591B7/+9QvVAQcs6Ka5554lapVV+tQ73rGw++43v1mk1l9/ibriit67X/xikXrrWxeo2bMHu+8uuGCBOvvsXlnPPjuoDjlkgbr66kXdd+efv0BttNES9c9/LsmfFy4cUjNmLFYf+MD8bpo//3mxOuWU+fkGpmnevCH1oQ/NV7fcsrjb7v32W6iOPrqX5yc/Wag+//le3ccdt0BtuOFS9dxzRfs++MH5auLETN11V1HvtdcuUpMnD6mvfW1Bd8Kttdag2nrrJd2Jd8klC9SECZn66U8XdoWHV7xiQO2ww+Jumu98Z4FaaaU+9f/+X6/u/fdfqKZPX6rmzy/ar/t7220X19J8/OPz1dSpg+ruu5d0F+RrX7sob3dJ3/hGUXbZRk2HHbZAbbrpkm7f/Oc/y9Qmmwzk5VXzbbHFQD6WZbs33nipevnLl3QZwR13DKjp05eor3ylV/Z55y1Qm28+oB57bGn+rNO+7nUL8zEs6e9/X5K/u+mmYiyeeGJZPocuv3xhd6w222yg9h0f+9j8vK5HH13abfO0acvyMS3pU5+ar6ZMGczbVdb9hjcsVO95z/zaPNTt+9WvFtXm9Ctesbi7adx/fzF/3/rW3lz9wQ8WqrXXXqp+/etevs9+doG6/vpF3b7fbbeF6r//u1fXWWcVfai/T9OTTy5T2223WH3mM73vOv74+WrCBKVuv32gW47um+pc1v2rx/Bb3+q1R//+6lcvyudc2Wfbb1/M+ZL03P7wh3vPhx++IO+zcj7rsdXtu/TSXrnve98CtfHGS7ppnnpqWZ7mE5+YX1ujkyYNqd//vreWDjxwQT6G5Zz+5S8X5fluvLFI86c/LVYvf/lidc01RX/pdHpsdL6S9Pfp76zOJz02O+ywqLvZPPLI0nzt67Gujo0ePz2vyrp32WWRuvfeAefaOemk+fkcK3mPHqMNNlhS6y+9dtddd2l3bHSb99xzodp550Xd7/zc5xaoHXdclPMpTZpPbbPN4vx7NelD0LbbDqh9913oHc83vrFYk+V4Pvzw0pzP6naWde+666Ian9W8U6eZNauYX7feulitvHKnNgd1fp3mX/8q+kaveT0uRx3VK0ePkR4bvTY0/eUvA/ncKue25q96DMq2lPxB9+k//tHjPa95zSJ15JG9cjWvnzhxSF12We+d/l3Xr8vUpNfmBhss7Y6DHkPNi7761V6eE06YX5uTeg5MmTJUq0vzDj0vbr55cXdO6HpKXqD5xnrrLauNr14r6667LO/rcn1OmZKpN76xt8a//e0F+TeU+5b+Xs3P3/3u3rjosTv44F5bNK/Xe53eH0rS/G/33Xvr44EHirVXnet63pbzRpPmf5tuOpCv7XK96jn6hS/0vkHz7C23HFDPPNNbr/ob9t23VzdEWaIazZkzR49U/q8m3UP67/TT5+XPd9890H23cOFg/u7QQ+d335XU1zdkvSuf3/e+oqznn1/Wfffkk0udZZXPBx88P3/+whfcaU46qSj7Pe+ZV0tzyy2LnHn+8pfFtefzz59fe95vv+J59OjBWhl/+lOvzCVLhmp5Vl11Wf585529/lqwoOiv8plqyw9+sCB/fvOb3d94wAFFe668coEzDfXu+98vyj78cHfZu+5apLnvvl67n3uu+JZNN13szKf7W9Mf/2j387RpvbI0HXJIvf5Pf3qes9z3v78o99hj3W1+3euKNl9zzUJnmk5nyHr3ox8V+Y4+2l3/5MnFvPzFL+plf/e7C9g5eNRR7jbvu29Rtx6TkDG8/PIi39ln19v817+6x0avF03bbONeAxdfPJ9cN9U0L3/5ovx59uzeup05c0ktzSqrFHNlwoReGk133dWbA4sW8etAjyW3DnbYYWHtedttF7F5PvnJYmyOO24eW+5//rO0++7xx4t5UD6feOK82vN66w3kz7/8pXsOlu8GB3u88dpri7o0b6umueOO3nguW1bnLXrsNb3mNe669Pdp+vzn3d85dmwxDlOm9L5Tk54LrjwlL/zxj8PmrV4v1efzzivK2Xpr95y86KIizbvf7f6GDTYYqD1vvnnByw87zP0Nxx5blKvb4Eqj9y+qnHvuWWztf+XzyisXc1/P7/KdTq9pxx3rY/Xgg3WeWC3nK18p2vfKV7rHt9yPTd5p7t8uSogPSKus0sn/ffbZHrTaKV6puXNf+J8KDQ3Z70p66qnit1Jq1dTXV7y7//5+ti3zewKwRffcUwzp7bfXy1nYO2xZ9OSTdbi4r68OG660UvHv0qX16TJ7dmb1RUmrrlqUOXt2r+w+x2yrQqmTJhUF/fvf7qlZtuepp3h4swrbrrpqp9b/dHp7nEeNKt49+aR7bMrxe/ZZu02PPTam9vz442Y/uts/fnzx77PP+tJkbH9kWcfqa31a1vTcc+7+KOnOO3tztWiPW0UzenTx7+OPu8vVSKKmJ57gx1CjbyWNH1+ORT3N3LkZu3Yff3wUMKfcbV5ppaKOEu3QNG5cPf2iRcXYzp1bnytPP11dB3QdVbVNOTZPPuleBwMD9XKeeaaPnF/1byh5j/s7R73QTdW1a39nPc/ChX0WTzCp5Cvlib663s05uFjvrw7eMmFC8WLOHPc3rLwyv24GBoo2P/NMfV48+aT7G5YtK/svTKVVzq+Sxo0r/p01i5+Tzz/v41f154ULi7SzZ7vzjBtXtOv5593fMH58MUZLCoCrS9XvNsel3POq80YjyZpmzaqvhwceGHT2VcnznnrKzW9Hjy7njRJREnw8VB2MiROVc7JQgo+PNHRY5MssoaCcuL6FsEgfEhw0ZgzNFAe0gO34tjJP77lDMhGTfJvfhAnFb889x9swVFV/JSOcO9c9NSdNKv59/nl3mWPH2vVPntxhGYlWaRT57D6eM2cUO6bI9y4tkGZIkNVqIW6OlXPTt+mMGTNkbdplf/g2kFKAXdxDpHNasMCdpyzX1+bJk8v+crd5woRBa36stho9hub8LlUo1f6ZP78+p6q2acjcKIW1aptN5j9u3FDwWhk1KrM2jIkT+bEp55wpcJprpyo4lv3nn092e0wyecYqqxRpiwM3N572xvj88+bYuA8w5fqfM8fNI3pzW7Gbu0k+vjJpUgbznoUasOjmq7d1lVXosQqdk+X6LGn06IydN5MA/qnVXUV78AMGNb79/TQ/r/aNKeiWfeXfA8rvVCJKgo+HqoNTMqLnn7cXi4+JlIugSiUjpiaRb0MpBRBzE6rSmDEZKfhUJ5a5wMaO7TBMjZ7svklXLkjf4io3iepmXEryPqbWYz4ZW3+17PI7/QxTsUyfEh4RRlvSkiUd7/ypMvnevOP7wy9ElP0xZAm4vv4o+9FEDBdopL9CVSSpFNZ85ZZrwHdiKxlpFRntjWE9rcmgq+u0ZKTlCb+kqkDVEzSQfh5i0TeTfBvGqqu6Nwx/H2bk2p83rz6fKMHRtzFSAp5JJo8o54lv/lNzsNOhN2pTkJ07lxIK+50CXo9H+ARHAy55gXx9s9pqChbYSxud8tBa5bkl+myj6PYhEBkrU/g189QFxw7QN0PkPuKbx6WwRAn5phBjHt7nzBmyED0TNS1tNKvfgKDVFCXBx0PVSVhOVIpR+yTTkiFUN8lVVy3zUd4PfSxT9amtyolvTlhzY6gyFhvxUV7EpxTm/MycZ549hk+hK6aqrorc8JvmxIn2ZtIrm99MEAi1uvn7EEGTyZuIz7x5ysPkEeGorFsBgiDVHzyqsHhxPc2CBQpgXH3sGPoRllJdSqGsfd6Nsrp2S9WNSdU0pcDdFKUyEZ9Ro0pjbMVuMtRcNZm/f9MrBZ96nqqg5kKFKETAJ+DZgk8pwGTC7/QjPtUDTKnuNBE8WmhQbHu49VDl3eV6QNCSal9o9WZVxVfuJyZR89bHr0zUrxR+zf6s8pRJk/C1N1DYSlfKkY3vsmX19piH9yr/6O+nzUWqc6DsPx/v8lESfDxU3cRKSJtaSOYCpCDgqoRbnlioSVTqyv2qrnDBx9wYqs/jx/dZTK262E3Bp9xEfSoaRPDpqcN4AbA66cuN1X9icde/YIG5CG1BA7FVqLap7CMfQ1xppaKepUvr7TZP6FW0okQ4fIwsRIig5pxv/pb9aM458/n556uoTNnGernVjRSx0yjrpjZTM5+5Ufo24JIQgapqd9MTCHy2ERlpFzR3rrsdlD2ca65W12WJaphrf968ep552v7TIJ+KBRH+y7p631AKXYodT6rfzTlo8iuKF5d2ayVV+6+HZuKqQtd6rPLu8tCKlGtqB6pr1hQcS6JsBH1Cqkvdac4bSnCc6xHyy/E0Dzx+xIcXCl0aiKrg4yIKEfXxPB8lwcdD1ImHOtGbjIba3KuLoKfftctavLjPebIvDR4XLeIN10x1irkxVCeelrCrMLFmGtXfS+PQ3jMt+FColh+F4FUHJdVPT+U7fqNHBJ8qQyq/1bdRrbyybT9UGqz6mIlL8DHtuqpMoGdA388yMt+m4xN8fJurS/BBdP/z59fbTBm6+9uciTZuV56S+vvdG7CJllTHorfpqQDBh0dHfShCaWzfa58tpJunfVMgoOo2+686n3pqBJ+A13EIqbxahhJKFy6s93uIbUlJlODoUxGXa8Jui3s9lvzBL/jQ9k7InKT63BQKKZWeOQfMAzRllzbH8w2leYMp+PjWa5nHN29KMvcwZHypck0hFaUk+HiIWqDUxmbaDlCbe1Xw6TF9ZIJk1unRh/iUp20b8THbXF0I9SCE+jRSFQZMxKdk5uakq9pEYYywFCAUS9X29N751D/uRWhuJlXG1js18wIMbQDt/oaVV6aFUpO5UPPORMAoAdy0D6sLMApGGevoZNnGeh5TeMMYF4VodJxMvWSkVNnmYcPcKE0bpCqtssqg017P7OfqvCu9+0IQn/LZd0hAbGqozb30fnGhMNQ3uASNulBarl13O7RXEoUKmxtjla+UPMGHFFP5ivbyfYM4nlR5hImWlKpoU/Cp9l/Ju81yq31RzltzHVPjYB6mqDlprs9qmnJdm+ox254NUS9mlW8oy/ELPnUvUcXO45VXHnSounj1MYKIopQEHw9RkxAxXqUWF1WWT3ouqQzoVz1l+RCfUh3GCT7mRmEaO1frLXWuvXaUbau/rxrzuRhhVXVQLlpEAKTSmJtm9TTsqh8t28ecSwGGZibusSk3wWVF/DXn2CBqGqQ/qptFyYypfKYgWLdtK4XtehrTTgkRfELHsGS+1Fhwgo/PDq5ELE07JbTNPhTThfiYgnT1O0MEgrqAYjol0GOAjA19sFBOoVQfsKoCcvnd5nfW0VQFf6ftRZixXnHUWJlCQ93ORpE2UuZcp9Qw5rytIuQl7zHXsU94883J0oWeQuds+0y6Dhpl66s91w+7GST41PszY9dVKeCZxs0+Pl3mmT+f+oaE+EQn6gSBGFPV4XE3vBsq+JQnTp9XV4n4mMZkPsTHfNYnR/PEVSUXk6t+Ywmnmgyizgj5hVIaUtNMzb2ZlMKZj2H22kRtyPxCRBFBE7Ez0RIb8eFVfwgTqPZHKRAjc46ypzDbaApv8ja7me/YseU8s8syT7QhiE+5Jqn2mETNOx8aaKIw5Xr0CQTlvPC1uVSF+IRiE/EpEQyMz2RBm7s+hFW9bMrv9gl45SaNHHRM/uQTZEvhMnRNmEJqKfjYiA9fLjWepuBo8mDafABBttxrzYX6UX2+yEA358yxBSqzzb553LMvcre97BtzD/MJ573xtX9LiE8LRKE7PqZXenBUkY8yUFWo4FOeYqgFb25CVbjR1L338mTe5yqj0QKWOTHrQeTKjcNtlIswnhKW9Z0AfZPed5orN2xf2b2AajzTr/ZxT2CLI/jYLqOKJaTNdYhehiqUZKu6zPbwcxnbmKg+5TcDU1A31cHV+YsY5/va49uESxs7U3gz6wqdq75Tr+v0X8apkX6nuYFVeYbma9X57zKsptrra08p4IUgPi6bQ5RH2IgPbxzuE3xKw1vz202eW9UMlDwFGSufYOFCfKj+W2SpdTP2gGELPvYhydwX6irRIXJ8fcJwiT4h44tSEnxAwUcHxTYnfPnO1tNSSFFm5atOIrOskmlVF2o5gUzBx2RIFNmqLeUUfHRbzGcK1q5utDoN9Y1V2Fi/qzKDMk11Idv9YAsn1Fi40lQXoVl2Tw2RWX1sfhsFA1fTlPnMhVjdcCWCj9nmngBD9YebYZcGr1XmEVK22UbbM81dLrUBu9pMqVyq88N1GaFP1VXMTT/SaJY7erQ9N1w8oH4ooDei6jzUdZntK9rDz9Xq2JhtLgVMZO308rgFKnPtVsMRaPV3VXUzNEQLPtXxpNdWh/zOKtJQ1F3/hrrTh/0N5XeacXJ8vAYRfPJbE9g0xb/VMdbfXuXTOk1drZux7SuJ+s7eNyhyTvjmlu8bTHtEc+5Xx9f13ZSdqrmHmbyh6mlb5qHmvqmmRykJPh6iTt6m/pdCQmgVCH9CpxgAJanbMVWq6gG6PJ+qSzMf8wZeM31V5VbWYSMM/MkIgdSrp3cf4oOczMzTUT2MvNvjxnei60G6/NjU1U0ZqbM3T1VS2BdBTxCjbWqMbJTRLDdj+5neXPkxRDw3bMEnc7rbl+Pnsw+ghIZe2e71Z15NUNZleubQ66D+XF2TFPPnEJ/SKNSPqPpO0/XvNO0yKJsVbL0rdq6Y/Mf2AqJUhYolH7JQjpXtSWen9R0y3IiZ8oStyIA5yaN+puDj20dMohEfkzcj9pG8CYK9H6ko44tSEnw8RAkm5gKsMr0S5qYmJi1EuevuoSpZUBtMQ2TXhDU3Ls4GqCr49K7XME9TfFsRRlg3UnZvQKbAgAhV1Tb6yjZ1x7SBowpS7ZVonMlYzVOVuQnVhWs3IzPHA1EzVE9W5ckZUa+aNj7m/K6ebn2bq9kXyPygVCPmfDbzUGvNbE9V4O6hCAoQfLIaD6gKLKUwYs5DZK5W55xvbKp1UQcxnyeObz6Z7TEFH1rw7wveGKsClMtz1RSyqn3j8pyjyC840r9Rgo9EHWbby1A2kcqDGGOCTxUN6wk+zixdQnisyc/D1YAl4lPPY453/aCZBJ9hJYpZmgu7OglLwYc6CdGIhRs9KicsxejMfD5mWFJIQMPiWbFMzjzFUv2FnAB9wkI56WPZKVQXVE+daJeFoFnUQrTnh9umwJXHhoEpNZtdzpIlyCmUPzljiI+fqdfLxZkvLaz5UFYaIfChoq51Qxm+IoKPOcZVoa88yZuCNCb42CgVh/jUvUBLwYdHIWlUw61SL37nBR9EoKLmijme5lhRtiWIh49faKB/k3osmm22eepQ4CGQX0d6DlCCpA9l67xgBI98J3KFBSLkm+sTKddnOxRKSfDxEOU2zjE992mcL5/ykqAmjY10uK38Sx2vuejME7IvwGHRNh4Gpb8xnBEiJyGKEASmupmUyBVmFMm3mzYGDF+cvtOPy1iWIuS0TZ2sJIiPfRK0UUhkY0KE0Op87wXsrOcxv4H6Jp8rfe/eKwRxzZwhG0rExxZmeR6BCNvmZcMm+oR+J7V2zLUbYnBcEu2JYzpF2GuS4y3Vb+iV60bwfAb2HOIjN4L3C47UQdEnFPaQj8w7B6p5SnWnD70bH2AEb44LcqCnkaT6M2LsbM4B6htQSoJPQ8RHKuQUZbkZaE/ny5flY0Dlrdx2HJ/M+2wiQLTg479xt2irKaSpIGi0l89tBxQinFD2V7TAxNvdIEibRPAxmQAtXPOnH6qvTZSOPlnxY2275IfHRqqq2fxt9qkPh0DBJ0zg9rXHp+qyPSTLd24j2947fmzMfIOD9Y2bmit2/2EHC07VZT5TJLVFM+eTmQcbzzDU0VQTlQbuZv9V0/i/s/5so1iImsgeK7Mucw5Uv7tnlqBY1G+uAPFBkEt6fHE1YK8u9z6RBJ+IRAkr5sVpuOAThvj40CPTU8FnK1SeYjivLtvLK/x0R8UXMm04aMQn3FCw7hZfCokdUdmmKkALEeY4I0JVVQVTEhKXwyQkxoXJ/KhNCEHAUIHOFPi5IIzICbiuJnbbL5jCGuWSbDJkc03Q65QXuGk7P//hp3qyL9tnGrRLXftNnmFeNoxsRNLvtG18lGj+IwKeuQa4Z25z76nM/YgPpSo011pduMRVopwBPvUNnJcjNQdoXhAn1MUSxh4RtTU0BR8EJfJ/g3ppCj4bbLCB6nQ6tb/zzz+/lka7Gl500UVq0003VWPHjlXrrruuOuecc8R12tFq0YXNMyzqHSpEIfWZyJHtjqy8CI+5SM2NhEIYzLbS/WW3UTLpKaaGbBT0STGcIRXveDsSiUGe7RkWtmn7XJR9KGNIm7lrNxCoum7D4ma+ZtnUWHA2PtRmIPFAQgQfsy3UWkGEUmSumpsejcwqkaeVaTNme1qZz7LvpFUhneC+8Y0nojLXiE8ddS/Rcp/AnomNm+n+Qoym/XPAVKlRbZkf6ETQq8uP9KKG35xXFy3Y8vMGpReA2BWDzj77bHXcccd1n1c1Yo6feOKJ6rrrrsuFn5e//OVq9uzZ+Z+UaCPT/miID6IqiiX42F5dfkHHtgnKvCd+2oOL6i87n+0dpkTwKYL4IAuqaHe44TZtAB6+OJt6wpU2NSY0TCMjmJBuEof4IKoIapyRNlP9wXktIoIrAq9rFSuHYpobD7VW6PaYczVs09Pjjtji4ded+Dc5c4yr66ZAEXR0Zyki4J+TofYxvTTKi/hU+7NEEex7pQatrRNBPjCbSH59mt9Zj7pvB59twj/rqHqHFXw06mebgyiL7HLCDyqIFuIlIfhoQWettdYif7vvvvvUl770JXX33XerzTbbLH+34YYbNqoP2chpuxa7LHNgYyI+vjQuxIe3+VHe58KA0+wLajNGBJ9wnTBl0I2gScjY0MIALyBQBpcIfGwyF8wQNhxhiSls27GI/IacVJvpyzNVFMHHbB+G2CH9zM972zGAz1MEeutj2+zb9PTdXSZyW6SRfqdf1WVfE2KrHsz2avsYE0mi1iQnyMZC8Ao0rlNREw0B/acgocEXaLb4Br4c5KBW5d2mV2GvLr5vFnlNJoo5bI4dAg5IvLqQ70ZszFZ4VZcmrdpaffXV1YwZM9SFF16ollWOUldddZXaaKON1NVXX50LPFo1duyxx7KIz8DAgJo7d27tL8w10y4TmdB6wdlRRcOk8F4a32WCGbQxcIiP7cXDn9Io4cT8Ho0kmfeKIZsfouPXTNa2h+JhV4r5IQsxVG2kjSerhpJljAsOBkbrNtus55yEwVBkbkQ2k4/TZjRek/ldyHy1VVZU3YoVbjnBBz21m3ZltBrBLfhQ67hIwwv/vpASrvaYfUwLl2YZ6Jhz46mEcazc5WrBh+4/swzsG2xVF6+us4XfMNSvaAsvaCwkyjXbV6VyH7HLDd8Xiro4NSrVPp6Xv+QQnw9+8INqu+22U6uttpr605/+pE499VQ1a9YsdfHFF+e/P/TQQ+qRRx5RV1xxhbrsssvU4OCg+tCHPqQOPvhgdcMNNzjLPe+889RZZ51F/ua7bsH1znWtBX0irqejF3O9vkK671R00H0OqL13iqFsMnzu7IV+3w3Xm1dYUP2lQ9ibKEQRel55+6F4p0Qqmmo+be9lll2EjUcQHztN9R113QI1F3R9/lul6x4ZPWi9Pi/q30WlqYeF7825ej49htXN1ZxzVMh5F5nqHt/plm6zi7nV02jB2Kda6l1N4BbsdRrOVqe4pkWx7aF4gNnPXLwW9zow39XzULzFXLdUHp+w65or5rylvrM6d83vpK6sKZ7tcrk1WczdjvcKC/Q7aaGh5JX1ayXotmj1nf/w5LrWojpWrnXNhRAovsF/aOXmQJa51qcbDdOCT3GgdvOmom22wEzxGHM/stvH5/Fd1v2iRnxOOeUUy2DZ/Lv//vvztCeddJLabbfd1DbbbKOOP/549ZnPfEZdcsklOWKjaWhoKP9/LfTssssuedpvfOMb6sYbb1QPPPCAsw1agJozZ07377HHHnuhPEpX6d/se5NXAffeUKdAezL6DGhLTxhTOKpOPhfiUxVsTAaqyZx49onLZua2saP1iVa5dDl+poZsmkX9lFDKM0xzbAqkhPqWMFUldTcQFWsEUb2ZTIAWBN1zp5cmLLBmafDpU3W5NjMf46I2YKrN1KZslq3Hy5yvZl2UQIUI3BSKafa9ualwCIveTM0yivu8skiIjyngydaO+a4qbLq+0/Zk8s/B3iZXT2MKWYiQyqnDzL7Qxs2mcGKWW7SXX2t6zVTVQkVdfvWrzmMKeIjwa9+zaDUPEhoGrOspeuUiQiFVLtoeBJU0x5daHysE4nPyySero446yptGq68o2mGHHXJV18yZM3ObnrXXXluNGjUq9+gqaYsttsj/ffTRR7t2PyZp7y/9ZxJixIh6F6C6UMTlvVpf6arugxtLQ1ce8ckYVVfGtpXTaRflIpu6XTaiorEZi93HHMMMMfhFbE+o+qrjVx2HnqrLDwPj/SGDoekwC/2GIM3p6Pn+ojZgROijXK/N9pgbpTlfKaQREaaRfkY2eyQNouLkBB9avcn3Hz3n6s/2NSGy8UQEezNuFIVKIt9gt6c3tzWvlPIs+m5DP++xXfRlcxJRdTXlF2PHavTatvvCeAzCC/xjV8xjHg1bIQSfqVOn5n8S+tvf/qb6+vrUGmuskT/vtNNOuSD0r3/9S2288cb5u3/84x/5v9OnTw8un0Nkeu8U6LouDXxYf6YClPkiWrqYAme87FMduOqQCD7IKYLKh9nqYH2MMAUKBjbth+gQ/h1Y8CmD3XHBvWgmL0N8ECGPErZNRAVBoBCjVts7jLKpscvm5qttGGkzccw+hhcezUMEd3otnu00iNcPt45N9WZRhhTxqT+bB0NqXGynCEz4NtvDIT6U+z2COlbXjeanyBxADiIUf8eEcRVcl21vhyA+WRD/1ug0djDAxlejnP5yKPQpnqprhbDxueWWW9Stt96qdt9999yzSz9r+513vvOdavLkyXmaPffcM7cBOvroo9XnPve5XPV1wgknqNe//vU1FAglNCYLGqUZMWxDoG3EAJqafCE2PtTGgXhV2DC8EjJCvv1SOyAp4oOczpBTVJU0M6n2cxlIDGO0iBARLtBR+arCR9lGzqsrFtzO2Vu5yuY2GekGjDB2ZK0ggqJE4KUFxzioJ4cCY4cKWb/bBy8zPYaW+FT+rvYh85ZGklTQNS+UpyyiPuTmAOXkMTAQuu5dakrZPDaJE1pRpPAl5dWlVVGXX3652nXXXdVWW22VByXUgs9Xv/rVbhqN/mjPrilTpqjXvva1ar/99stVXTqfhGjBB1Vr2RPPDlnPn6iK8sPzYdCx+bvy/m7G8UEWvxQ2pvTlpudXrFNrUR8fPwX7tixY8Kn2qz5x6m9FInNzV0ZQdaM2PgiaFCr46O+S2NRIhVezfbTgar7jy8XqVlGQEOoAZQcVzBi0Ce0/Hi3h7mujvzNcaCjawwmyceYJp6ZE8qBpuDkpFX45j1waDVbEuzA1KlUXergK5WdSgWqFRnw0kvPnP/+ZTbfOOuuoK6+8MkqddNh+BXU+HeqdR24Q6B9DfJDF4heETKaGuAdL7HBoPbz5bPef1O4FsW9ALulEEQP7VvPetxTGlNRG5WdsphGkq24syirfH1S+qvoEUTNI7RdQGzBKxVP/PXz+FPkQgcBfd0wVQajKmjMmdpWLqF24kBhFHtm6MftdIshiqKMfLSnexVHhc8IbvZdQQqFf+PUZ2/fSKACFVGwgTslBtgjh4T+o+NCn3jv10kZ8lgehKhiKWSLB9lAbH3tTlhkQmhI1r+ryL1qqL8w6qJMGctKVMm8J4oN795jlYMaoPli6sPExGa8MbUI2V3ruUG3m+5H73Y4bgvUX0mZqzZlzzxxTW/2ExKmhBExEIDDrUkIkxG6P+V2cmgNZJ9I1YAuXqjWVns1/+PmFqH85tRFqO4TYF3L9hQq/5lznEB8pGrbYaA91BVEMoZC69NX8bsTYPoSS4OMgfIHyE1NqVFqUH243QwscYRCvyWgQZm4LPlRb45z6sRMLIgxgQhVicIx4kVQXvRZ8zA2HunXe3szas12i8nEMBmlPzDYj84pDfJDNC92IaFQvrL1SZwE+wrpsbCSqLmruSlVd5rrgBDN0PYbaSCF9TpVL5bPtJuOo67Ao+/4ykLWHID6SdYUIVKi3GEpJ8HGQeUJEodwiHaJiUELpnp8k1GIxreh5Ly7/70hbpbpwqcGcxJgXNZqLJ0RkNS8u+840/lulCBiCFlLeahQTD20zKrxi8TyoNoQhPlh0WxSlUkF1U+2V2pXZm174PKXnUziyJVV1ISd3Oy5T+CGHescZO+PzljceNg+T2Jw089gRvm0D7XA+iOQz20/bhoUhPjp2GS1QKRG/RSkJPg7CdcbUu3B4HGeQfD4K8bHr958+eNUYouqy65WcvFFpX3KKjgUDu/Jxpy9E1SW3BwmH6GlVW7jggyFkvE0NuqGFIj5yj0PEuNk80VJ1xVGvyhAfmRBv22r465YiPmb/FXWZm710TfjzIYeMWIiPJO4Q0h4JoreMcCCRqbpUIMpuq/uLcuIIzC5Kgo+DzA2AirxJvTMntCtSqrlZUIHGtO6zOhmpKJ1mfUXb622kyGfjQ0VqrjIeM4R82VYzjTkxiwjR4TphhDGbAa6o6MHFOz8KQl0nUNRX/zZkIVLzg7sKxBwX5EoEjeaZUU3N+WRea9GLTl7Phwp0IQzRjCbeq8suxxe5tiQquq7JtM25yLmYU3OD7i+KL7jbVzzbeUIRH9ecMyOwm3OF24josdHzqZ7Hnk9+4+beHPQL31S/U31szgvkCh2zLyh7nVD7GLO99Fqj14zZZuwbwlE/ew5QdkuqkkZfjOxHvqk9QV9LZEcFt4qx+ssOhOnfa13lUldhoJQEHwfRsC0/6bTkbEKRqP4ZQW4wvbVijcc4yLd6mqMmPdJWDoWgGHOxKDteJkwLA6jKSkURYFAEw1zAXMwXRJWJqLqowHWSEAQupuNrM5WHWwMuoYsSTKl+NtP47Cnc1zbUy5C70tfL4RACl5COzTmzXKT//GWgCJR5ZQUi8HGCtStNKIJHCVT2YbZjCWu++7RcdenvtAPy2e3hbHy4tUddbVLUr7zXtUicDzJinpjl0jxXsUJ+vT0dUoXGHUIQPuCjJPg4CBEwqHdIfBfXZmJvkqiKzJ+PE9ioEzHnzo6paGRu2BLXcXSTwsruCHXZKnh+SPoR2QBpLxfe5oHOVz/5FZcX9sgcU6pcqaE5ql42SWLcLPVA4mLOUDGxkMORxMYHOzy1850S+yJ0HpiqLmRzR7ymuFg1yJxEPYC5edHeHIhjQ7PMUEFKY2EhKjSJDVwIJcHHQUiwJkRqd72jvcFUlM0VWfDcXTjmswTxwWxTstZsdaQu78jpW3rHGBc2ALEHkfYHkg8RvOwNTzb2CPNFogGbgljRRnM+q0j3GfGHHy5UBBpXRabm8M83ulwlsqHj4vjE8uTTiLUpKGJ8FxHwssZzABUcOcRHaltoCg5YCIYO63nMG7PLxhcRfBAv4mTj0wIhQdKKd/zG0XZZ3AKSXGHBubNL1HJSRogxHyyOhyTisfSETrXT7AOMmYSrPORGmXzZ1TbqKyykbUYMNzkbn6Js04bB9mK0A6Sp1jz3uLWClots7qF37rX5nbEEPFvwsfMgXqYIjwi1z6LyoPPWRnzCUVHkwBUr2Owixp0dOewidVFeXUhMuKTqaoFwLxR+caGBD5GykM0Li+vjL8PcKDhmjoUzj4fK2GXz9UsvW8Xtl8LHxnZnV0LkjGdkUrdqn+BTXLuBuB/LxhDZuJETZLwYU3x7JG7L1LgjwpqtRvM/U3Wh7Qn9TjTIp33vHIIIhB8GkDWL9J8kdg2NQoYL44jq1xZQ+PYtAua6OQ5U39g2mzqd30yAEnwkkelDKAk+DsKRm/CJ2aQsRGBCAlg1vbLCZjx8f+Hh6uPYY2DoGLVJyozMqY2BcxGVBYFDVB78d1HvaLWHKZzV43AgG5P0TjCJsIYIPrHu5aLe8TGwMHsFBBGwN26TF8hO+4idG+eeLVWhSRAB5H5CZN1galwlUuHzqHkcPicRGpYAB1dJsFUqjUSwReZNCCXBx0HyYIXoJqmiGOMhXmSIbZId8j/stnapjQ9y/QDnGuoqm1oYXHwiKh8dpwYR9Hj0D0HO7G+10yAbHo3MIGiS2cZemv5+V7l8mzmB3f3OLzAhGyV2lQOVhs9nb3DhfUzVj8xxfcKu/061F4mVpASxklQU2xfMBiSO6pKzY5Hyh1iID6bu9PNuDInOrDT2XV3uA5CrLmQNIapMlJ+hlAQfByFMmHLVw9EBFSkAIGJfEW7jw6m6JPf0IP2gFwEXZZpqH4JmUO+QTZuqX+K9QJWFBLtDhBNMxdGJZEcS3mb6hnd/uVT7inT+NkuDa2JoibIEDRPV44Rr5NBTuD/3NVZzUB53iPBPCXP2NRJmuWYZdrlUnCpO/SxVXUrmNvdNRV3I4cl+Z/NUXhjHDhD+NtN8sMO2V+KIgdnmmHkydu4jPCaEkuDjIGQj1wPGxW9wlYVsTJhrM5KGr4vz4uJtfMI3TKocVIBBTiw0kzUDmPFMVXp9CaY39z+jp1upICg5OdsuwPyJXCq8SqLk2l4u9p1oSF9gl27aqJ5E1cWFi8AFH5tHSepC0EtO1YWsSRpN5dNwqnnqHSKIYZu7WS6GZHNIYCw7L2wOdIy6efUrdlDh03BG01Tk7iT4DBNRp2OpezZqK4AhPiqSvYefaXGnE0RFgwgQ2GIK15dTaWhIlRqH8EBdUrUn4ikhOcUjNle6P5Agh3abw4UI6QYSw7gZqVsLxYhwhBiRS2w5JM4CVD5T1SUVdpG1y8crioOqmf2JIgISGynEjgWZ25yqC0W2kW/gPHKlyPeAQA2IpJGUiyLYKI0S53yJkzkJzYjCYcEK4xhtmqq1IpJn+N0t1LeY0WbNxcNFcqa+W3JCkCMV/qisRf2IiqHDMn0qSi0dudZfHxW2nlMFuNOElUO1Dw2aaau6/OOKtsdO07HemaolKrI3Yv+FbOwUBM8dKugo5wgSws85KhqwGQG6Pg/s/tOn6eqGS40DvXbtun2Hp6JtiHrTSmL1KYfKUO0t0tXbI7PPsusyA8baEar1FRD2vK0eMpC7vCjhCDkM19tnR0bOSF7gX/dFnoyd+9wBjFqvXBBXah5rMnleCCXEx0GIegp316Te2cwmhr2FWTa1mekJYy4o27iZU30hMG2cEyAyFlJ9c0wkQqKqlKi6pNA1ggQijNUsG7FPQVxWpbYInHEzMn9QL07EdkmChGDXAfDz0A7056/H3Z52vlOyJpHo5nLVpZkHKZdPw3uLSQ16w42babSuw7bHLjcOzzcFKknfFO+Sqis6IXYx1AkMYaDUCRi576V454fa6bL9AhsldJknds7YmWaM/CkWO1lS70wUhD9d0icJmX0Ktei4C0mp+WF7Siggai3fHqnRNjWn65cM1k9f1BhSKkXO04oaZ+o7JIgUgjwgqJ7ZZipfUbb/uygkSaKqLN6FIRYIslW84wVpzkuJ/k5/e5D+QjZGjWpzgoRZl7kJo/wBsfFpa05S3yBRRS8B+C7iiCGZx5IDMvWdIZQEHwdJvEmKdzJDWDxKs1kfv+jMNJhLZNgpAguuJmMisQxRUeNZOVKEoBNhaI45Du66w+MB0WnCUUbM3kvaz+F2dWb7kHAIuPt/uE0WplYz22OnQfqVO2yg3ylBqTg7QSpPuxtjXyvIDGf/SOVDDh1Ymk4UxGcZJBz5y5Eerrh9AZmPlBowhJKNj4PiBitEDGjtfAjigzBIJOAWp8rivL6odiDQqH2qwDZ6ycLFN2Skfr5NiBDBIT7SeDxSxorF/PC3h7P5cbVHOhZ8UEhZudJ5x208iAeS1MCTuxYBHXNM1RUuZCGHEdsrTwUfREyU1FWXbeMTLrwh3ykZX3reSng3X/cSwO4MCe4oiSeG9CcyB556apm67z7sAq+E+Dio/WCF4fYgRT4VjN4gebhJzjFUZCEjDB+N5YIwdEkbizaFC2xUPuSEyTE7RMDC6+ZthTABMhs2IQLZKGXeJ1I0UAkMlePYMmFrLHzTi6U6jeXFaa+RcESA3jwlHlEyVTgXMgARNtFDDydkId6KS4BvkNg/IXxZIhRSPPCHPxxQu+02ViGUBB8HUZ4D3J0jrneSWCSud5ITHHcRX6EP72OMmznp326HveCk3jW867H0lCBnQB3rhGmeMpHrAmRwchxmjKgni3fcZhqu+8cDVfLt4zZKiT1FEwGTv+6Fz4PY1BTpzHnI1R1H2KXaE2r/VJSrBIiAnQdR70g24VhG+RJUAxdSwwSdpeBclwkokgNxOP9oGsk5CT4OktqHoKouJFy/NHIzp5KTXBLHIz78ZkwhN7G8KBDdt/S0K9FTS9EJTNVl2zMgQqa0P/jglebvUqYus0uSxQXpDKOqK3yttIf48MIc2h7ODpAWssL7XYJaofYxHDpiHxJ5zzmqXKx9/jzud2FmCUtJvsSvWQwNU8ECCnZANsu1kiTBJwZx8CG6sbneSS7QQ/Nx0jFnDIp4cZnPlE5dpnJAJr301IoJpTEM/1BbBI7xIsbNSORd6cmZrs//LBUUY7jHUnlMFAQtVyr48PZxyJhi7bGRx7aEf36TsxHPOHZmNqKICFSYKziv6vI/o+VytnxFnjiq6BjhFCR3s6GHXY4XyIVCu79clAQfB2GnNJknVjMvjo5AOFLMlQPIRuFnoIj6BYHZ5d8cT42GCWOyDYWL46Pd1/m6ZadbOWP1b4LchbbFO77NElUElY8zjqXeoYKY2T9YpG1/Gc0QH79QJUUmMWSLQ3wQJCn8cCCNfC1RSSH9h11IyvPYWPFseFVXZpUhETbkqmDuUM3zLpR/uCgJPg6SM2rUUJq3F0KkcIQJcJutyXyoejkkgl7IyAlQohPmTxHUOyxytJQpyAwRuX6V2jMgaBNyVUGszSEWooEEdUM2GakxMeIizQkAUsSCi4WE2Pgg30nb0PEqH1sFhAg1/OYZSx2OjBVn2yidt4jtkMRho2izWXZnWASqAYDHSGy4sBARycanFZJOeEo1gZw4pbFiJKc1Xv8cHptEoiKhyoklZCBXNFD55EiETBgzUTCbicnajDBWu8/40PBUPm5+Fe/Cx4IOosb3M7LJYLFOzDzYGJttxO7PkqF43MYdw6ameGcejihjZ7O9sYyb/Qg1F4DV9y5UyMJRY7OecMRH8g00Yu3/xsy4+oRKV1x9EW4birnf+5+pb0ACLvooCT4OimVh74owaUvPVFn1NFR4b2piVctGPKAQrxzuCgs54hOOksR0L5fcxE7fx8TnM9tE3a3EMT/6jiSzFluA0WXHctMPNdxEInTHRQSzYMQHKZc+nNj2cXwoiDjfSY0pd6ce7a3Ko2qcZ6iJ+FB35RXf0Bw1QARH+jup9jTziHKVG2ojiUS1pvIV6eo8xSwXEywUUVcY+oXwGDrStH//Qfkt9V0uSoKPg8oFMGrUEBvltr8/swaofOcSEiSeAcU7BGlohvhQzJyrl1pcprsydVkeJ1Ah7XW/4xdhLJUmesdYKHIWM/ieRL1TXArqT4PECZEglXS+cDUa5j4uc3BANnduraPoJOZ9GXbap9qDrAFEHY5sjLYAQF2s2qbq0r/+pIgw591EX+vCIzPcPiFFE5cKxkp+UAlX70tUaD5Kgo+DygEcPZoWhKppRo3KrM73CT7I5KQmOSUwmdIydeLkFiG3kRXvmj1T9RTvzElvo1yIABPLEFwKkceCwJF+RIxIsfhExb+dThbIkDMGhbTL4FRWbjUb389c/eZGid5Uj5yUORssBAFqtnGbdXGbFa+KlyAYtDDClyOxAUHWBB0t35xzWXD/ITZJ1DvOEJzKg4yV2eZYqLbkwKzjwUlQfiSOj9T0xEVJ8HGQidyUJ81SECrS1BGfar6qMGQKSIgNDaozl0jdnB4WiTMSepeX651EKESYmrxsZY1pma+vL7PqK4WGMk1dCEY83ZSgH8NPVb58o0fb30UJ+K45J7GX8c2PqiBm9nNZN3XYcNWFID4S5LTaHr/hfzjT9gny1blZrQsRqELmU32+++07kI3cd4Fmfb1xa4QaK/8zVU5bNj50ubz6FUNm6uvBrEtyMNBEayrMeRxu54i57ft/p97RfNrO56Ik+DjIFlZshtt7V81HvaszLHrhhrt1Uu8oVIi7Y4Vb3LQHRz2NRGVVvMMZsylkUPnKDbvKZHtjWKJ4Q858lABTjnNVQDAFXFrw4fuAQwOaqv7KPqv2R/n9vjbXBfxQYY0/AfvHMLNOkGXfU23mT6KqYXvM/hryzkWuf6hTu+0tZs/VspweH8lq65IWPuhvotL4hHhb1WWqbviDR/W5FKrKNelbNyZv1PPCrgsR3hQr1NtCKq7urJdLpwkRFKmDAHWwrvYXJhR2iG+wxyGOUEgdpOIdnDh+66Ik+Diop9oqnn22O/UTsz0g5cD2NklpLA2ZcBQKWXKeRtQ7O/4MisrQQk2VYbmFDHsx9VSTPRsje9O021Tm6wlH9kmiLvjU5weyWVTzSU9V1W/tpfExeXuDLttMfSvHWGMzrjq6U29f9dv9Aqb/dB0iEFAnyHJuUEIhfcIO20yr7esJBO65So0p9U3FO37jdpVL8TVXueb6p/LU5yAuyHJoc/UbzLqocuvjx6m2/N/kKpc/LODrmprr1XnBqboQgWopMeahBto+RLRJn1Ntofm0gikJPg4qmZW9QBVjz2PD0T2Iup7PBVf23tWfMRgTPw256kGYpW24jDDY+ndXkSRkYzOFDGoDMoUcqmyfoOoTYKg2lWX57L18/WKmCVF1lZukH7mx+8N8RzGlsiwajfC32be5+ttMC6pcP0s2SteaoMrtzQ3+VEy1h4utg85VE01G+t3lSk8fLBSMwiCIj1kX+p22UTkuyCJrgjqUur4DUwPa5doov1lPBhuHUxqF3nqo8+IQhHiUp28oe50QQ/CeiYhdFzdvfSpbX7kvScFngw02UJ1Op/Z3/vnn19L8+te/Vq9+9avVqquuqqZOnaoOOuggNXPmzEb1lh1NoTuUWovaTMqBNBl6XWCiBJY4um0OOuaYGhKzI0RF40MhaBsp14ZtM0u6bJ/gQ2+2lHCEqbpCdf9KYARZr9uH0pjCYvU7KBVeT52C2yJIxp5aO2Z7qoiZibpQm4F7o3QfBsoNjO5DRCiXRDSuHwCq7ZfMVUlsGERIrvIwzqU8ZJ4W7+rl+sYTq6s+VjRvRtQ5mHrHN0+qBzpzo0ZQK3NeIAc1V3upb1rqQb4pftFrs/+5Knz6v8G/PpC5hCBULwnBR9PZZ5+tZs2a1f37wAc+0P3t4YcfVgcccIB63etep/72t7/lQtAzzzyj3vKWtzSqs1z8qKrL1MP7pH9uk5REc0WCnHGGd2ZbuJgddB0+/bTdDnOzo2ykEHi8x/jC1CT2gurVT71D2oQgPk1ivtj2ZwraJHvCPHWy92+u1DssQB/dZp8wWR1D8wASYuPjQ3yQ8auerl1pfPXZnpj8AQBDoMxvstti1+3e/MPUieY323W7Nmm9MZoCp29jDEEEMMTMvVnyt9vb/WfOZUqQxYzB63l8avcyTchByfyG0UTfjBlTRzd9ZZsxg1C0nFNtmeVW24zwaYQqrPLFTxrJWWuttcjfbr/9djU4OKg+9alPqb6+Qp778Ic/nAtDS5cuVaOrPRRAmKpLeXWw5oaPnxzrz8gmJLkR2TZc5FUFqPSvN6yyPJ+NgqlOKBcgnc8NxZsnSc1geypGt5rEtCuhmD4lzPrHtFdWmZ6Dj102PrruMq+rzdU+86lpOh1zjBSbz9dmc+x9F9aabfYx9Wqflm1G1k7IJmPODVq4VTASYrZHM3GXV5cuV/9/tY97CIFbQDFV5ubviFDqQ0IQtS12Su/AKjRqE3aV7UO2kHVcjh/lvo565CH8vfoOC1PRMeaFAvgVX24V3dTfs9TDq1wIVbUcs71mGbrccqzp/bAT4aDCq7xfMoiPVm2tvvrqasaMGerCCy9Uyypfuv322+cCz6WXXpoLQHPmzFHf+c531J577ukVegYGBtTcuXNrf1UyVTCoCoQ2hK1L/3W3VPtdjOspqvX10piqAA4ByoIRH2ojMRdctV2+E70LhfAhHFQ5phqnSFfPR6WhEDpXPp/qxvxm6tknQJp1+1Rd5iZTbhZV2wTT6J7qW8RY3nXqrNuR8G02+9CHsvoYKSb48PPFVgHZAjCH+Pg8yuy+0N5i9XyUUNqbc/xp3zWfELVoW6ouWkVdrasjqKsZKuxytzfnsg+hao748GvEnLeIutNcR8sA3ojYCrnnlv3Op5IKiXFUdV6ptvcla+PzwQ9+UF1++eXqxhtvVO95z3vUueeeq/7nf/6n+/uGG26orrvuOvWxj31MjR07Vk2aNEn9+9//Vj/60Y+85Z533nlq4sSJ3b9p06Z1f9Nqmp6xXP20VX3nW1zVUwVinBsC4aNhzjnkiLf5sesNQXzMd5QA2DvRu/vUDCbps02h0AyfUPMCSOhVX9YNfnFo3bXo6X6kN/GyjGpAR9fpp1quraq1v72cl9Xv6kHe9fZVy3Ix296mnVlRYJETW9lG+jBg90eoMKnbVxqE+tpTjoWJsPjsUarehFTfVPOYddfRpnpf+Oacqy06T9kWl81FlT+ZY04hiCHCiFtwtNscUpcvIKVpBF9Fd3x2b1S51Xem0FCN1m977fKCD/UNvX3CRN4UJGSFC/kK+gYzjVmXuUdSAlXJX6krK0wbvDIPFYrDJRRSgW5ftILPKaecYhksm3/3339/nvakk05Su+22m9pmm23U8ccfrz7zmc+oSy65JEdsND3xxBPquOOOU0ceeaS67bbb1O9+9zs1ZswYdfDBB+cROl106qmn5uhQ+ffYY491f6tuyNTpnWaEbsgc8QDy60LdKgSznPo7/4k4lKlVNw63vpc6Hdf7hlK/UMiJaSjo38TtPu6pduw2mV5lpjqhKLv+rtpfphs8dXL12RRwhn6+zcJGRnwCXe/bbVWXW92EIT71ZwqtcCFJlFuuaYOky7EF42rZfoTAnt+2agmZUz6j+l5d/OnVttOoGoXSfVHNZxp6u76zWjai7i3rouatBPFxfacPmUQQAd+c9KHqnNDgF3zM9lbbV9Zdr6eqZuc9onq/m/3lW/thaJj5DVkln3k4d6ubuENjlceYwhxVjqtc8wBUll0tl+qbF72Nz8knn6yOOuoob5qNNtqIfL/DDjvkqi7ttbXZZpupL37xizli8+lPf7qb5rvf/W6O4Nx66625txdFGh3SfxRRnlk+GK9+V5eypFWfKx6VrxzcUjeLeH5hxs2qUSRexHvERGmq7xB1B3X/Wdn3NqJgCyyUusU3hj6UwWSiFJPyqULrSJG/3+zAkFQfhajnzDQ2A/KhQNTJr/oNhQ0L3eaS+aFtNjcZ31j41IfcfKUEV7Pu6vrzCQ28fZG9Hk0hENng6u8wxKdaf7EONA+pf3c1jU8otQX0TrDdTXU8ywOH+e0Iil3WrRGB8gBmfgO11jlUg0Y5yrp4FNcUAPw2Up2AOYmrusK8QJWVjwo94Cq72j7dLurA4zMvoL69Wm45Z6tzyzx8+gzwX7SCj3Y5138S0p5b2qZnjTXWyJ8XLlzYNWouqf+FXhqiViVAqBGeD4qsVu1zyaWNPXvt0FK6PCJuPQ2nQ+cZj12HC0WijX3rz9SiqG+INGOhN01eGPAhPoiNT/X7bWNKqg+qZWGL3nyuTm2XZwclHJX5EEHDdzqst9l/eqWQNVOIoBANc87Q3o/ufjbr6n2nG2XzGfSa86UqNOiNEFGz+VAYG2V01139Lpf9FbUuzTGmkFjz5E7xOk7Iom1CTKS091yml2yM1Tz6Ny38lAIQhXCa5bpQDeobbFWXPU/MNLRZBP0NVN0+FNJ0qOHQk6J9dN+MJtX5dHupNpvzxnyufoMf8VEw4uPjZyGIzwph43PLLbeoz33uc+rOO+9UDz30kPre976nPvShD6l3vvOdavLkyXma/fbbL1dxaZf3Bx98UN1xxx3qXe96l5o+fXpuDC0hWgWgmCiaZd4yTbW8+jsf3Fy8c6tYzHy9Ntlp7EVWR45CmRrt5UUvQJ/9E83cbZ2wqeqiNk17sdQXezUNfZ0I/Vx919sYet9qwuaUGqRuv+A/OXN6dOo7KIZjIz52f9DqAPq7qsQLGu72+AVTHrWjDyAYI6V+t+uqfocL8VHWGFMxeai6q+XYyFY1HyXgmaoaXq1mGrXTAjC9vnyIjy2wu5Fmc8zr84JC0fx1lWp185uouiihwYWW+LzifBuuy76QEixcz3VhnELr5IhPyDj0ETzOrLskhC+b/BS5CLYnqNXLrZZN8ekVxsYHJa2K0obNu+66q9pqq63UOeeckws+X/3qV7tpdPye73//++pnP/tZLujsvffeeb5rr71WjR8/XlQvb51uvzORm+pE9HkAIRbxmDs7lcZ94i3y+CciwmARC3+TiVCIA6XGKgnZKMw01EmjvrnV2+QTxmhvNPf3UqoubtG70AofAkZB4i5m7NPr06fievuody4IvMqwze+g05Tv6LbUv8N+53r2qRPL+n1qBXNO+XgAp7qspvF53JXl1pG+Ml/92WxvvX56rtBCaf2ZEpJdzwjahMxT6jtcdZnfRNVV/4aSN+PfYAofvnJ9a43joXVUo14XhRi7UD/aTgnnF6McakBfmzF+TreXajMyvj41+Esmjs92222n/vznP7PpDj300PwvFvniJ1Tf+W0kqtIqjoZU05mSel23LUF8uOcwdUz1Xdk2nwBhnzx8yE2vDh+k6jvVlMJTj5FQm7+P2dTb1NuAeu7HSIwgH2MtCbOXob+VEgSpDa/8f3qDM0+U1MlPQW2mja3dbTbXRVUgKL+HUgmHGudX22Ia1fuEcC4GjraVQ9aKa47r5/L/zblavTokbOPufWu9LrdQiqgRXN9J8SbfmEvqMoURVBXiUrWbbaG+y7fhulVdmWDN2M4HlJrbZeAuRf0GHfZsSMwxs1wfXw7hJ8j4+sJarPCIz/Iin30KGvSsOqjmSY1a7DTcXWe8vlg/tP2NifiooOcQButTNdmnfhvNsG1TqhAwb9NiwsS0kbK73RQq5EpDGW5T9165VBNFGn/flkKbf6OiUCHehoUW5hH1Knd6rW9MVbdqpM0+FM3XZld7bLspW4WAqEYlthF+FMF85tGmav0Y6kKvOZ/Kk1YloypZFWjXJa/LLJf6BjosBt1/flVX5uFZ9fb4HDtc3+Sbk9Q+4VZ3ur/BNwcGHd9AlePK4/PgkvATZHypb0AoCT4e8nlUVN/5oO8qU0HuL6EDJJpt6LULQXxCbB6oZ8yri4aEqY3NPGVT6g7TDqhalq9svzGvjYKYG7IPFbLtgOwFTqn2fIueixzrO0X5oGuT4dAqDt/moOATGmfjU1ctmW12fxdtl+RWz7nbh9i5UO2p1+/zgjNtD8wyqmSOFzafqwcA+rv9p336uXhHC1k+PuP6Tp/qMrTfXXWZwgiqDuc2YT9iVq+b8lj0Ifquw4H9TfY7n5NAiPDrV+d3yG8IscXxf4OCr8JwqeaKuHo8n0YoCT4e8m0I1Xc+rxh6kyzL7+Xzw49ZgDstD1E2RXh8V1j4bDhckryPOVXrMjcg+tRq1uU+nVNClV996V7gVFBKsywk8rZ9qqp/q9+DxS7Hhobt/vCpumgEEQ1gWK+n+s530rddkrF1iKtGfCdeN0rl84KjvpV6psrxCbeUWsYVY8mcS9VvcAl9+nd7Y+RP05wnDvXO3+/yumhVCI/gmZuwzz7Gb19YfxeCSvoNjuvl1h096G+gQta5EMZ+D49D1PL2QaX+TVIHHUwtbr9LiE8k4jy4KFWXOyaGHx3weatQcTDMNGY5VQr1ekEZj18vSzGe+mbnOyEghosUmmOqw+hNqp6GekcJA8iJqe7marbJ6ja2701VV70/3P3oUs/5PIeqCBgVZDL0dmVTPVB/V2+fDz2hER/3GuCgc+QkTatY7Tbb7s71vqAPAEXZSJA3qlzUxoc2CqXXYDUNgsK4UGBaVZPB/V4V1np94arLbpvf0Jbmzb221J+p7/KpAX0u77xnmq/celuq6VD+Uc0z5EF/XQJ89bvciLb7AOa6JqRaN1cupwZMiM8wGzfTdh18Ps6GyExHX7LHT3xbHdYJepYYbPrge58g50dlMhi9wE6g1bLp+ul224sOQ3zs01l1sdKXJtbL8Hs42OXY0YHtss35Vf1WzDXXZFyd4DZXy7HHwq3+RWLpuFRLiGdTNR2CULqEQsoYFhOo6vUgdYV4ClXT+ALcoV5dvm/wndx9hwMOwaO89GwEz742BVFLuoSP+lqrv0Oi8LsRcjuNeZgr3tXrcn2Dj8f1e77Bh+qbz36Pt/o7e3/qBdXkyvXxcmqf81ESfDykJ5d53QF9FUXvXdn5vmsZfKquehToPnKS0wLTEGyNH2rTgwTJcnla+JGTHlNxheqvlmufkO36qZOtfWVFPQ31jkboaKZa9Jl7fvi8ulxwe88erN5n1b63+5FXK/rmYX0TrLfPh7C4VF1mwElpm6n5EWLj41JH+dAJem6Uz5TA7TqBd4JUQK65Wl375vi5+sH3DRRa4kKFqLIRGx9XXbSdGV1u8e3+w0DdjtL8Btzmzuet6lOzu76hDHRJfZeJYlTnkesbqAMEZ+dV5xc8ujQqSNVF86bqerVRNkSgqn93ta98KGlCfCIRF7nZr56qn57QYIjUJPfddWMKWogBbVPVV/lcbs7Vd7322wzCFdfDl8a/2dht8p0ufYbTvmjBCOJDC2P1tofExqieZKpl+NATShD0hwBABMF6/SHzpddmd7l+4bWep6gbEXzozSDEM4defz5Utv5cEmUMi8RVseeqLViEhJ3o1UX3Mbp20Hnrq4viX+Z1NEhd5nj67Anr+TABPtQQ3Rdcz6WGNPmlz06PQv24b6iquhA0fJTB46rk+gYsnpjNv3jjdbNcuy3JxqcFomx3aHueTve5nMA9QYRCAqjyfcaMiMBEb67Ve6x6eVRQQEOXPp9epG59vvnOZ7PkN8Sr9wOt2rHz2QiM77QbihjY32KWRXs0mIvedRKs18N9q0tY8xnU0zYEdl9X5wetnuvAba5H6HZ9l1sg0ISruurt8dkMVL/RFyHbvkDXhU6EqWXd9n29NCGqLteao9YAtQmjQpY/bhc1T2nUwFeXywie5hHVueNfj5SZgMsjymezSZsymN+gnIgPIhS6UCv/HFDwOAxCiE/9O/3jEIL4lOX4+obiZwnxiUKcDYepeqJUBRTiQxm/+a4KsCM+Z5CdhtmmXv1hz64ykcCD/sXlPhnZmw12mvMhFS4VDBfIzqeCMb/Nl48ycORsekwBoW4o7G4zop7zGTT293esPuqVrYJUXWib3TY+1HfZ+VztMwWN6lj1IHnl7AufapZDfHyqEdcY+9scbmtF1eVDtiiPGXOMXYIQgvjUVXpm++r1UHW55hfHI8z2cGEZzDZTZfjaQ81t89knbLqMpqvp+Mtj7bU3RNopuQ+FnDu7D+U31wdlBI+WS9mGJcSnBaobdFLITf1d/Q6nehr08krfiZM2gKZPPyVRKANnvMyrutyL1GZGdjmY+sV9SqSRAHoz8Z2i6c3EV1+Zj2q3+1so40TqufrOjFFCncR89jL2Rh6GgJlqBMQ1t1R9uk5sPk+YejqzL+y6SsEsxP4Ecx22VUuIp5ALsaACULrumkJc++shFGiBgHp2rTnKZgxBfGy1B7Le3QcGmYqFRxp89jE+Q2Czfcg9Vy47KsQzDTG4p8YTNQyu5hkEVNEUamXex2aqcX3jYM8/t22OKxSH7wocqn0+SoKPh9CTZinkVBeO7dXlhkar6SjEB4lrYnoqmJtQlTjhiFN9UVI7ogtHTjmYWqL8ZvubfPA34mUSov+mXdfdZSHus72NkmdSfh14R2DzZH8XjfjQp8reCZJG9uj54i6Hmu/mRuRDzUqyhUeqPa7Nyy8Uc15JyBzDbI4QxMf9bBqbmpupz7Oyms78bvN3xB3bF00dQajdiBkvRFe/i0PMcDSnXi6G+ODqHGreuoymzb6g1J1DHjsv8xuqApQpWLh4k99L180nQ2zyTPCguCYpCT5RiL5w0n5nojv8Sbuejwt8WAoxpgG0ma5ati9uQohtQLVM83dEHeQTjnwnXZPR1Jlws+swfNda0AKMi4Hb3+87Cdq2U+7TrWvR+zYY/2nRh251PAKte/662mz2hSl4UH1TlOsaH/d30ZB8p7F7rE8o981FLKIxfQr2IyF2Gs4d27cRUciWWU5IXf6DBm0vRn8ntSb8iECIEF1tjwvBoL7LF8PLHeTQrc4JU3W5y+X6phoTyYXMDHmcD3wCKRLc0YXEhxykKN5qH7ZUECXBJ1DVRW2IpXFz9XRsnvJ9nl/1dG434nIC+NrlMrTzCzYmwmP+buZ3M8sQFKIp4kMLgPU2+1UpVDlUuxXJnKnNrCni4xJ0TDdO+poPdzn+aOE+lYE7LEEvDc3c/IxLiWL92IJGrSnkO8SmBtm8KEGZUzX7vYDo9lW/wbafkNhauTdpau7Qm3vxr3ntjl/4Lt91AlSM9XLpusw8uOBfvKvzazNPlbADFV2XD/FxqeuoNeJDktCo1lWUaMhj6+Q6FIagYYiNj882x42yuZEk6oDvoyT4eIiauJRXl+3GaDNGriyX5xB3H5QpIEkQHz4IFr1ofae7EFd1DKmw22OqVqrf7dMBYwKMe8NDBQSbwZgCJo/4uPT8qHrO3jiraer94bso0Rcvw7RZMZ/9yEO97mo6xPid9gLiTsGKbY8fbeqwrsxmHr8Kw26Pa676UZh6P/jWF6L2o1FP+jsRL04M1ehYoTI4RICuOxzxoTf3DoNm9q6Q8QliLnssk4chBzVqrNztpda0qrWPXnv1NL4DNIJc+r6Bi7Tusx3yucn7KAk+HqJOQXRkzfJE42YYVPwfGj0KNYquv/OFujfLMet2/Y7EJkE2Wix2BS0s+Dbsavv9p2hzsfgYvN2mqj7ZbFP5zh/jxb9RUd9vM1XkFN9jxj6Xd5fgwwlVLtdcDiZHhUKzPVWhy2U/RLXHbl/WCJKnNyf3BkuVW7xTwR49JfmNQutCA6IS9m0qvgOJTP0doiYKubLCXXc5d6qHI/dYleXam6lrrCjbITMPVZfb6BfhBe5yKY8trtzBGv/skGuPMhw2DzTUAcc2Drf5pI1U1teebx77VKQ+SoKPh2hddPW0RwsZXLBCavDdN7G7VWRU/BqXrVCVzEnCRWp2MVjK6NR/Aza9aXE2Nmaaksw01bJ7+ew01RN7tc1cPrM+qn6f/QIXJqAadt3F1BFhsf4d9TqqY9ZLU3+mhSp+wzUZoA+qdo1zNV+vzXYanyrXhRCYApXvhm1f3b7N3Y34UHncjL1XV708iZrDpyIwLzHlnDvciI9dDrJxm3X51InmN/jc2Xt12fyPQjpCA2/S32COFW+L45sDFJ81v5P7Bj9aompU3H5Oo1a+4KtY37jnG4742HPUF//JR0nw8ZDueNN6nhqw0aPrUjIVp0IPPBWK3LyaoBezx80A6MB9Lu8w5ERsCkL0Iu21I46KiurnkszFTqWhFkJVfUiVQ+XjBJhqG7j6fYgK533kOyGZzNrsC3d7+H40+6yahjLsNi+R5BEfn2DGC7RUvhDEx74viEZTqLoogYBC+noBROlDgw/lcNVNtZFCPs1n6qRc8hmX8EHNi2o+H0pQPNvtC/nOcg4igrat5qjyU7MuW2gw57arvRTi4xPeqLWGXqNSd2Yxy7Wf0W+gPMF8/MzVf341oI3GUnOpSj6vLle59D6hRJQEHw/RG6I9AezN3o3SFO8UFAW6WnY1H7WRloKOefrp5RliTwm93+vPbvieQnzqbUPQFPqkK0N8ECZr5uNOu653SNl++w/3pm0yXxvJovq10xil4sbMB3n7bHrc5fJtRjbKUO8mV7khmzTVZpeBsQ/5DBMCbVQjxCakVw5fN/WdLhW6H3X0PxdtrD9TKuOSXMiClI+Y5ZqoR/Wd7xvsdVQtmz5MIgi1D0nivsFVT+h68Nsj0nn8hyufYEuXg/Fpd9/UyoJSjVDCNzb3M3VC8Fm/+4yDXWqt0NO2i2n16qn/jkxME0JvKpwgiwljdHwapI3UO6p+6p1LLUPdq2PasDRBB6p1h7TZV7Y5N4r4GfV81GYf0mbJZoDZ+PjrKcrNgtsXioSYeVzPaBoECZFser65jG5W6Df4BDyXAW8oAuuqOwTx6bU3bN5ydmclIUhu2De4D6CjAN7Qs/Fx10Wh81xd9f2w+NdGF+McVChKgo+HkIUkgccRA9oqE3PHX7DLR4zmOJWLyWhCXFd90HxJ9oSWLkr+HXoyQyBUTEXXgdUy/tu06wzHB9n7TuhNT2MSxIeaH5p0e7l+pr7Lh6JR5FYB2d/E1eVK48pno6WdhgKenYfaHP3RgLNodm4uAdivPuTVrTaqUS3bFRmcby+CZrqCdVa/0R6rMKSSU0n5vgER2F3f4Ed8Okb73XOU9u5UUb7B5SCAHVTMehLi05ioyS2VOrlTq60qsvO50lTTuQz0KAPHUEGoJ5HX66i+Myen9KQrUQMgemx0o6cEmNKWy88o3CoD++RaT+fzIsFQGfsdgsCFoGs+t1aJeg5T4WFr02xPST7hkWsPiuqZ68+u253H9YzOVS7sglTNYc73ajq3Ua1dThnHx1eX7zDkMpI2xw/bGO00rnqq38jNU473uNSSsdaI6xtCbJL6SFTIFKBsno/wXJ+AgqrnEOTXJxTW0mHJRiahdiV25/OnHq58ymXatzBd8LbP6BBFfLAYJ/gGjWwuIQauvWds0wxR7fjKp9vtRnxM8sVL4mwKsE1bJgiGqDg0NVHPye2mzDa7VSM+o3quLkq4pXlAff2ZbYl3ALDT9Oqqp2lud+PmWZxBKpXHVxeC+Pg8Rql6qPb4EB9/fBuzLr5cTMhqpiYyySVQIe0b5VlnSAiIXjn8OPiCrYaUazuqJMSnMaFMGDF8Q0+tISdg2t3StQm5ER9UELIlclv6j2W3INkQfRuSv2zM6NY8AaMCk8vzAEF8XM+IsIgabdsu024G45sr/KnYrhtj0DzTpiN7+0+QUnsnxMHBbotdjkxVo5xkx6Fx23dgiCr/nT63aTNPr9xmiE8ICipDfEy7G/sAIUVgS3L1F23jE474SOZ6n2eeIOEK/LzTXZeN+ISMLw86UJQEHw/hxqs83IachIqyzDRUPsUuTNMNkZLU5YiP3Q6XsZ50c5FAwLjXkKmysutH1FioMOsSfFwGj0Vd9d8Q5AYTOuPMuZIo1LGJulIeWsBuE48Q8HWh65brHwRBDEVC3HXxbcPG3If40IchqaomBuKDbe52ml49najeYr6xohD9OIgPPd+Qg9IoAMnE+A7Phyk1IFeOFE2kKAk+HqLdVhGjNrmdggSiRCYjEvG197s8kiayCCRoDmb/oEQqRsTwD0d8FDymLrVILMQHRbIkjL4kys4MfabajKATvLFkPY17k0EgeVkf9trSiapy9UH5rhASFIqAqZtxA17fxigRsii3fXM8ESeJEBspt0obEebschC3c5m6zllsY9W4LA0iwCOHRn+ahPgME6EbgEQQcb2TnL6lCzNUEPIxuRB4MpYdELIoEZssWjjjFziiRqPsbDDBh2MC8ZixVHA3jTZj2CWh6mUkvo3pZSZxj0V5ABdIjRI+sANAuPGm5PCB2E9Q9XPqCURNVNTPHyq4+SXlNSbFEth9Bvhu4Y2vSyK8SU0F+gV9jBwkJWtPeoimKAk+HkLju5hIgFRgKurky5IIR6ibX4irKmZ7IUNqJGkQjyWqLFQ46hgcHGt3GATuVl0u38CMyPzh1ETYXJC2OZwp0sKIDNXj+gfzppOhu3y5dhoMQaQQH1P495crF2T5NBLUCpnHyDxpivi48kmFQjsPX24f1H88+oXxU2TvCBdspftcEnw8pCeCxLbCdR8SVlY4JOhzQwwpx+16idsOSAKjUX1DqRy42B+ujb5603P5zlcXlaYaT8mXj/o2052XO7XTcyUcfscFd385rrK4+mOdyIv+8KsnJU4HUtUSqrb2lVuUHT5Xsc3U7iuJII2sS7uPwzdK6p3Exo5ub8amMfucOuBJxoUaT0T44K7vKdKElsvbVY0C5joqRNvzrTniI/WMpCgJPh5CkIAmFv5UIDTMw0bCoOz6UX2oqy2htheuNJhuHinHToNs/lKIF0HssJMNItTwjAMVBLl8qAt3aJ9hjgGyNkts4bDxo9LY7ziBRK4i4Mvh8ki9uiSqeGzMVZT1LjGalvRxLAcNijA+w69PSbl9Am9kpC8QRC/WQSWpulogbGPHkAAcMufTyAygw1UukrYhaThhj3onFaCk+eQG63wa/tQsEzpjxcSRMPFCPdeWV1enFcYu7We0X0PLweIV+euh0kg3DPqQ5xfSJUIXjgjE2Bh5JAkxbpaYJFDUlroT4xcdoO445g0xvlPKpylKgo+HEK+GGMEK6+nM8ql2+fNQ9SESNkccrE21BRPA4kCs6IaEeGdJGRvC+Dk7CeyKAb49CAOi28ynQX6PZ0zMrx2JgIsgBFIDdq4tmpADEzJXeXUTlacdtZ8cKTWfw21J4tlDxukbqj0StbtE+EX4UH+k4In8uGCBVGV2jeHG/3k6LNnIJPr6AanxI68ik6uxEClcZmTLtY0rE9vU+XJibX5SGwhXu7l8iFErgvhQmxtfN28XRbURndO+9hV5bKbEMze7zZgRMqLOscvlbKnc6FcW6OKbRbmTjOYHHOoiVelRBv7+slHbEn69qeDxRBF6uz1+QTEm4sML43w5COKDoX4dbx4qnyQ8CCL40GkkKHdCfBqT766a8FM1v3io8qUufJgOOswuQWKTgEj6sTyv8OsFwoVXRICiypactORxQ/x53O1B3PvtstqwIYip6uI2NOSAgggNEnsFVAUkmauIWkGC3iJ8Tb5u/M9Uvljzi7uKBllHqJpdpn41n8NtfCRjF+uwi83Z9lB/ipLg4yFskGUIBvoOERSkag9u8nGLOxbiI1X5STzIqHfIJkSHkuc3ZIk6DDn1yU9n8YzzYwhUmEAQy67A/yxNI2kfihBgQoy/bgzN4dsjUXUhwpzcqaMzTCrRmEbw/vZIhV/eTolqS8ebR6o2xQ7I4bxbmmaFF3yuueYatcMOO6jx48eryZMnqwMPPLD2+6OPPqr2228/tdJKK6k11lhDfeQjH1HLqOukQZIzPdSgL1YcHxmqEAqZIxsrN+mliA+iE0aZrN1GJI3MbksS6ZTKIwmrgKKREkbF1U3lkY4zNT6Y0Wp4XZjQ4H+W1h3LFgfr9/DNXYJEYqoRTO0nUUtiQoNZrmpFIKDKinfA43i37PAwShAvy+xzyvVeoqZE9gBU8AHszl8cdOWVV6rjjjtOnXvuuep1r3tdLtDcfffd3d8HBwdzoWettdZSf/rTn9SsWbPUEUccoUaPHp3nkZB0IUmlf9cENmU3yQkdja9RrYs7NWBM2FwE8dxbEcZMLTpMqJHp8BE1CD82fF3SEAByNZp9uvbdJq8p1s3wklNwsZmGqxXsYKRx1JnInKOuyMHULmbdfB5JXBXMBglBhcMFKsxOhKrL317MxocqN3ye0O3xP4eMVZ13t+PU0A8dQOPwMylfeskIPlrIOfHEE9WFF16ojjnmmO77Lbfcsvv/1113nbr33nvVb37zG7XmmmuqbbfdVn3yk59UH/3oR9WZZ56pxowZE1xvm6dqPIZJpgYG/JupZMJKTj4ynbBMFy4JFoiUg+aTpGlTBYP0B2IUjKBbyPUFeq5WBR9UPWfeSI+1ubmaVnpyltqfxRBGNFGbvdmHMlsmPo3EMcF8Rg4e0rpjfWcco2mq3HC0V8JTY6k7OwJeSUWZl1zajQlHsnJWWFXXHXfcoR5//HHV19enZsyYodZee221zz771BCfW265Rb385S/PhZ6S9tprLzV37lx1zz33OMseGBjI01T//B4w4broIl8cW4EinZkmlo1B2OmNYnLcRoYsQOqddNJLYwRRC9xuI1WfTIjwPcdEwKTqFI4Jye/hCh+LWCdnqbeORBUiU59I+YG/XLw9zQ2DpYfHWGpJmb1JFklNFO68Ig/tkXn5Dm2jmDUWPpC2IKou6rsljjGoqmuFEHweeuih/F+N3Jx++unq6quvzm18dtttNzV79uz8tyeeeKIm9Ggqn/VvLjrvvPPUxIkTu3/Tpk0LtoOJ5bmE5pNEOZUE8grdXNDNmOvT4p39zKEerhOLJJ8U2RsuNC4uSiXxcgs3yMZswuIIa9S4SwwqkbkhW3882oXaBUrUTcj9gpKo2tT859cfhRrYmzIfIJOvSzJWSN8goRGKsvymABQiKxE2qDxc4Ng+MNxEG2YCsfgHEtU6z6eWI51yyin5xY++v/vvv18NvYDtnnbaaeqggw5S22+/vbr00kvz36+44opGbTj11FPVnDlzun+PPfZYEBKBxnehYleY75CJV7zD2lB/phiJP49ZLnf/lwTaLcpFjIvjwc1SNRpigEm52IfHPpHddYMKPtUNxDV3TAbMIz5xNh13m6t5ZCfIWEiDHctLgvjY5Zr8gD4pS9RNmB0GJ0hgMan49krWtjSsB3XdA7L+zHIlMWZ03aGCBBIrid5fuDxxUL9+cA2Z+5pJSJBD+xvs/pQiPsvVxufkk09WRx11lDfNRhttlBsqmzY9Y8eOzX/TnlyatFHz//3f/9XyPvnkk93fXKTL0X8USaP+uiV9f15UbRYDBo6hJ5YYnyEQP3UCpPsPUe3YHgbYyRoxyo51OkPsoOw0Q0P+k1Us+ybE5kIqaMiQrHBjYuodspHrPsyM6mLYZaAop11uJ4q6iUIsuO+U2DtJBXRJFHJ5XRK1ZLhKlG6Pn6dR7+hywwXtfkgY96dBhCUpahrLAPpFJ/hMnTo1/+NIIzxaOHnggQfUzjvvnL9bunSpmjlzppo+fXr+vOOOO6pzzjlHPfXUU7kru6brr79eTZgwoSYwhZDE1sGdj98kcWg7PB8mpHC2J1wdvMcEJhzZaTCXcxUlDZoPCWAoVYMg5ZpGrpJvRfTvVD6Jek6qWpIgR9KYLlQfDg5ydalglUYzexQ/Gie5Z476TkSNYNuW+MtwvePaJ/di5NMg6LhJ0oj0vB1lO0bccsEn8z5j81hmz4apnfm9Y4X16tLCy/HHH6/OOOOM3AZHCzvaw0vTIYcckv/7hje8IRdwDj/8cPXpT386t+vR9kAnnHCCE9HhCNuAMJsEimGhiI/kDhN+IdiIQajtCQXnI3pkyWZMIT6IigixJ6DahNgh0dBrcyQEUdlRNg8S42bkNIaULT21U/MDUZ9IIG8K8UE8UkwB05znVHtiID607Uu4ShGxG6EFPJs/hLqUS+26JIK1PPpvmG1jiOqSa7O5RqSCf1teXaMApwZKJWW2LVR1TrVPeuBZYQUfTVrQGTVqVC7YLFq0KA9keMMNN+RGzpr6+/tzo+f3vve9Ofqz8sorqyOPPFKdffbZ4jrlofLtdxSEKY0JhAlMvMGjjRhwDEBi4+N/pvIhgkjbqh1pPlMVKot9wkPrUsRAYl9Bt9H/O1W2HOUIXyeIIa50vkjGoi21X1F2cxRBqmLkNnIpwhvLiLYttESKCHNoksSOCik3nppZAXnC1c5IOch65a7W6aZTKwjpQIQXXXRR/ucijQT98pe/jFan5OTryidl1nIbHz9zphAUDiKXqc/8ZRblxNKXx0mD5+NVXRL9tvSEKVN1UXVRc8M/RpI5SLeZt2+Sx+iJtcn466bexRICsYCYceqS9AV2GMEMg331UOVgc1Bi2yhd5/zBWWbLFI5sUWu6TzDfkLlleysihumZyrIwntPExgfUiI1Mkgsd2DsM8eEXneQEEOOUGiPAGVUuHsQO6QeeQbV5V5dk00GELGk/YrFskPrbEUYQtC8W4iPf7MMFdZlQiqnROUEi1tpB+BPC05CNERF2Y22MksjNUuSUy4doCxB7R4mxfx+wZrDDevj6kAq2yDhQlAQfD2Hu7HY+qXcWMomodBIBDWFioYIQcuLC1At2P0jzIQxUelcXfUIKRwSHV9UVftpGNjRMpSFTuUjKkSI+0hhToXVJy5UgPu2ig2aeOCoqTNgNV4VINmG5ijaO+hWZk5zRMfYNHTZNrLklsf9DDnIJ8YlAEibT5J0U8YkF33KnBpkHRxx7g1hoAaqywuwHhs+YMtYpHrkiAouZEn6iRG6Gj+XVJWG2tOE7f/CQRMWV2r5IUI14Kkak7vBvkCBmVF0SFBtJEwstkdhIIdHw6fbEmQOjIqx7bE2HO4FQ7xLiE4HMjteT0I67gCEBUmYtFZhCdbMSvTG2cCReXXaaWIaoMcumbw1vRw0SixlLgl/Gs0uKY6CKoKyYYC8Tbm0eQLXH/4zUhXrcxUEsKAGP53UcHxnOjbEtxEeOavDzhI+Tw7cXOZRKXcE7gd6KVDlSVVcsMwmKkuDjIYmAEfZOJkRJrkWIEYiKjxcihcvDVRlo2ZLvlJZNlSVBMKRChER9gaIKvCDdnhcVsgkic9G+Cd4UNGTzDjkpI7e+YyoNStjmvLpUFFUuNi/iqLZjoaAY//ELDbE2d4lKFJ2TMXhzX99wIklxDsTSOD5J8PEQKphQ6hTknR0PxD5loeo2LoQ54t4eereRRADTaWwvLg3nZmxfIWWbZJaFb/T2guIgZ/0NdOwTTrVljw0fkh6xS8L6g44VE9ZmZMxijSFaDhdTClODyvqZM/4u1rrdPm6uYqgLtb78aehrLfi1g3h+Ile2SNLI7MwkvFLn6QT3n83fw73DXHzHbA8ioPAxzhSLisZD2ag+5ngOcmWF3ccUJcHHQ1JVFILuUO+km7IE1sfUEP7nWHpaSUDBmGoSzOU2jkFtPBsfmSeanQY7UXJRcmOhS1g/y9LwAgLVPgSZsfPZh4RYKj3EAJUTRlD1JmJc2paaaPhsQDheGUuFhswv6Z4QI4J2H9A+zERCokJDxhdZi5iuKwk+HkIEjJg2PgiET+dTjY3SJEZ/iA4bg7U7kVQOMa9okECxvIEoVR9mmBuHGUtVXRwzo+dgrA2kuU0NIsyi9l+ywHnh6qdYl5RKxzwGj8DWu6zuWAcGHoFFypXuH34VqFTFLlNJKbZ9sexuJIbpmMdlQnwaE2KohyI+yMaAIwZ82dzEx+Kw+J8Rrw/btoFvK9rPErQAR3z4fHLEp7k+HoX1uXJiCenYxarttTmGe6zU/gtbo53W5mqoKzMlUEndqCXqb2TdIqiaJIgg7ZBg5vE/x7RTMscO6XMEeYsVPqGvLyzmUSyPQdqRSIaGUZQEHw9RUT8xuwCqLP6da3Fz9wkhQhUvCFHt4+yCkBONak0dhejvkTT6HdcGV/3V93IvnHABm/5WJE34aZt6J7GvcNmRhKYp3jU/iaJzg+rDuu0LdV9Rc4QVqZvKF89TCFlf/mfXXDJt+nhj3fDNk24PhapnjYUa7D403tZKeus7Z3sj2SOQwwv1Tcg8RuYRzyvqtqFFmqTqakzSm9iRSUa9Q+B5ue7Yn0e22Unge1kaxLYBU0dRZfP1IX2MeqNxmwWiPpV6y0hUj1QbJZtpLNQMixJtjw0idJnUlou0dB1I+hlBYWKpm2J58kk2bmre2htjHAQ2VlBNbuzwOdDcVqgvkoobs431H5qlcaWScXMEwqLwYi6nchsfvqw4iE/4RhFLTSGBRimmJhUGYjFnHKny55OqReONRzhsL7XBaMuQFDnpI8E1paoubkwR1Y10bJBAjVx76XztXI4Zz3EhA74z/AAVC6Wm2selkaq6kENpv6CP40VcDntG25vi+EQgSQCqEAYqvatLoqYKvYBUEitFeq9YLFVXrE2Kzicz0pQIBMjG3qZxM9bXcQxAY5w6kXLo9slsBmLcRSQ/AISjcZL5hX6nrZJC+gZBS8JVLNhBJFxwHF7DYJmqS3Io7QD2RJJ74GKkQYRzVICnKAk+HkJOjQjDaILcIGVhF9v565JcCBfPCDCcWVLpYqEFaJskqiWqPlk/qigImFStGAvxkVyLQBv4+uuSlhszTkkbxqZYXcvPwD/Wxog5Y5gHEdl6xMIVNEcqYxq4hyI+Hfh6lk6E4I58GkzY5HlFQnwiECJgoHpGivFJQsJT7xAkioMoMSNALg/fVukGFIuBxtzcYhm6t6U2ktsmhDNkSXC2opx21KVcNGO63Pa8umIhn5K6pNGAZcJHnM1dhpbINkZ77rSDJMcKaYAJvx1BezOiXH++9lTBPNqJrg+KkuDjISlEjKA70juSqPIRtRTHDJEJHSpMUe/kyEkcpAg15o2FJklO6MiYxzKOlW8OathUXUiaGMb7+Om6s9wud8SMkLNhQT3ljhft2A5JAktS6bCxQgxtO8MiFFJlc7y6A4Y04NZ9W4ieVCikwAmKkuDjIdOV3LXQKQ8E3N227tbJeTMU8Q3MNJTLu5nGPgFXJ47t0km5XoY9F+WoYJdhOo39jSiTNcu202C2SZh7pd1G3oXVzsOV24ThcH1NzSfeGN4sl3fdpcrF2oyhkdU8SCgKVHBFPI44FIFy26fc5JH2cPdlUVdhcPYxvbrcbucUn6PQEq6fXX1hlsPzYj68BB0uwe8RVdTtd5vW38TxOhQt4ccqnDcjfLAfcCHHeUwWbNzM82k+TVJ1RSCJCsL1TnJrN94GxJUybLOVID7S8OUS+LR4F0d90KahMOZ6rYKeXe9iXfwXQ/UgR+3i2L5IVIO04SuPBiJruS3bF7ouv5ovll1XmwieZDwx5JjK50fQpZeU2ndP8V5niO2QJPSAdG71sUhvLCQ+FhqmIEqCj4ckUYdxAUam6kLgZTrqZZixpYRhxVJ3xIpRg5ZNIxHNF2/xrhPFELE9YQ0VUMKeMVUE6rXE9zNvfxbuseLOpxq760oFAkpYCw+KJxNK7XoQXtSeVxeXB1d1cfYxnWGzU5IYcWsKR4Aytgyqrnj2T+HqfmTdJcQnAiGLGIejZYhPW9cZ8BtZuN2QdKONd+qP42EgzYfYKlD5JK7iUmEN68fw078EYYkpaNjt4/tQHoeJZ/4xTtwIv5EgQLFQT6TuWHMQswGRoSWhat1Yaw07HPDlUu8k868fMhiXHJB5IQs74IfvEy5Kgo+TbNREGleDeie98BSxb5AYHUrQG2qz43T+saBvV3AyCbOJpV5B54d907n/xCkVuOUoFf+Of6ZP5HUbDPobJLY43ElUHoeJvyKC7me/3UgsV2aEH0jcs5H2UPyqrbv5qEMoPy4oqsE9I32DHHBiCVSSw5Rdbgew8zLzIeOLIbTcelXRED2KkuDjIFenIowHMeIMsduoG2nybZXYCskkbj5PDBUangZrM2Y43WnNcNpMhxiim1Qw/g4bBZY3yI5jQyBTdVH1YEgWtw5RQd4cP+SwY266VHt4jx66PWbd1EWNfN2cYbXU9sU0GEe+QYmMkGWCtf3MOZlQ+RBeaAuy/Lw1HUoQY2IkBASVj0NqOsIYR5SKCjkYcFeHUIgeF5cMRS4pSoKPg9DTAnoax3TUSoTmSBCfUDsTaQRpBH6WqDKkSAVqzBurTVQ+/koBvlwMSZPZJiCnOG5+YLYdVN0y1FMiaEjsHij7OQTxwdrTDloiOTQgG2Msd3aJ6kYqdMWyx0IOwBJ1jkTAo95x95j1waouf7n0d/O8gEOoEP6BOiNQlAQfB+EbArrZySaeZMHHQXwkpx5Z22KqumKUTb2TGtshQS9N1RcWcA7ZqOLYJlDvOPs37KJV1Gg7HDVsy5hYyhcwe0G+XEoQC60bEZKlayKWykKiusR4BNUeDjHj65aMZyxeGMO0IabtnMyTl0e5pbycoiT4OEi6ITSNV2ISImFjl6madYVBj20KB1IYu92NHkGqMLVIG4hPLCNI6YlSEoRR7nUTjhTJTtdUueGCBpVPcq+cVDgKnV90Gt4GUb7eEHundhAzxCNKZiPF1xVL+I0hHHWEyHd7F1PHKteeSxQlwcdBqMunNA4KGrkZEy4kJyj/RJMIalL1Rqw08YQqqecXn4ZqJ3/CjOdKL4k4S73j5geCyEmFNUQIjRUpWeryLokkHWtTkRhjY2nChbdYRtyxoilLjMFtgSXOYUE+J8Pbgwib/YL9J5bwFqtvkqqrIUkhbTSvtPxYngD2icp/IsDuH6PqjZWGV+3Qasc4xtVS2yRK1cWpCBFvC8mmXbwLnytI5GgJAtVufCKJMC3tLx5FaOskT4ftb64mkgsWcdTP3EENsbeUurNz61N+6DKfEV4eB6mU2C1JDsh0nnCPyljf7aIk+DioHAjOa8flVsm9K8uqv8PC6lNCSd3bwi7HdEPkPFMoJhfKINzt95dN9SniSePa3HjPK7MuetFJxgYRSDivJfq6BV7t4GLGMfqauyJC2l8uRsqNIX0lSzVPnCsrUAFTcqGvKWDGUt3a84nnTxT/o/Nwc5kPsEjNQerAx88B5IohXhDjXOddB1TqO7n+o9pS7VMXT+HSUOYPof0ntxfD+st8Rvg0N75J1dWQmqi1kNMlAtfHgrapd6FQPAanSo26h0/VFQtRQMvGAueF2zNgiAbfZmyuIt5O/me0bmwj55EZyZpoIhSHli2d47LTPsJ74niPtrXeMLsgpNxw5BpRdckQn/A8sVRdHdAZghNaY81j9BDLpamG+PBREnwchAs0sryotCpz8+Pr5zaqthZpvMVup4nnJcGnofNhDJEbr3iqLr5uaX9IvACRNmMbSPipXY7m8OUgwm1bQo1EiIkXPJFKk7W0JttTWbehxkXa0+ZBLYZXV8cRG6wNXt3mAZWiJPg4CN1IUAOreJsrkoZnbKETT75B8ic1W/UVzwBZckLBg3t1ghEvKp3sbiXzWXoKjaNLlxlkY3ZaMewe4iEPfJqizc3LkY5f6KEGydOmZxXSf1Lhw07TEQRm5euRuHW3GX1dcpDtj1Au9U7i8Rbz8EtREnwchEKBsRZB8Q4RmPh2SRj4cEng0ksopae5eP0XD1rnTuCxTrfxYiapKJsr8l2x5pkMOkcQV0zA5Dcemf1OW+XGQuxkXj98m9sKT0C1kTesjnPIkAofnKOHxBmBTiObSzE0ELHmqIuS4OMgV8cjxpjy05x0MTefjJyXF4o6cFB3LIbl2ugRFYNs06aF0ur3oqobDuGJZQSp33HoEnZi45EZZMNDjETRsef6CDfC5PqQNgpFjIVDrzhAv9NnRI4YcSNzUrrxoLd3h84DpG8oXoMIipznJ+LoIZm3SDkIoiflnx0Gacf6GK0rrM2oMwKy963wgs8111yjdthhBzV+/Hg1efJkdeCBB3Z/u/POO9Xb3/52NW3atPz3LbbYQn3+858X14UKNFKVWKzon9Q7pBx7AofBvUUZPJOLYehGp4nXf5iqK2tN1cUJJ5idkKw/2kNYZOgJEkNIYjfVpl2L5OQunU9cH0oPDZLgktK13Jaqa7jsqJD2SnmqhF/JkJosuL10+4bP3V7SNy4iooy8OOnKK69Uxx13nDr33HPV6173OrVs2TJ19913d3+//fbb1RprrKG++93v5sLPn/70J/Xud79b9ff3q/e///3B9aEbCWLPQ73DFw/fhhiTkWN8sZhIsbgoF9j6ydskJI1+NzTUzkaPqTNk6lEOYZGq54bTq4tjZGjdbcWYabZJ+1E9/a3LlpllceoIvj3FN4VtntJ1ijjDtCV8SA5q8QR2fr7Zl7za5ep3WdZcgGpLMDPnUl80oUbGz2XCJaJCy146go8Wck488UR14YUXqmOOOab7fsstt+z+/9FHH13Ls9FGG6lbbrlF/eQnPxEJPr7BGjVqSK299pL8edVVF6u+vn41fXpvFEaPXqJWXnlQTZ/eW61Ll2Zq6tQBNX16Ucg66wyoxYuVmj59SC1dWrybNGlAjR7d102jqb9/iZo6dbD7bt11B9TQUCfPV9L48QNqypRON8166y1RY8b08hRtGqi1ccKEAbXeepkaP34wf9ZtmzdvUC1cWEyctdYaUOPHZ90y1lxziVpppWW1b+p0lqjp03sTbfLkJTkjmT69N62WLh2qtWPy5MVq5ZVVLc3Q0FK17rr68sfim9ZYYyA3ljXbP3Vqrz3rrrtELVvWVytnwgT9rl7/0NCgWndd/Y29svViXWmlMWrhwv6oQqkUEZQwATSNyYzb8uoaXjstPl97wTVlhuaSKyskbZYKVPZmxbuzSwQWaZpYgqx8zDts/2ne4ytHdt8Y2j7371Q5fZHWQ6w7taQx4ew0LyHE54477lCPP/646uvrUzNmzFBPPPGE2nbbbXNBaOutt3bmmzNnjlpttdVEdbo6fsmSJeqb35yppkwZyifTpElDauzYjvryl3sdPnFipl7zmkxttVWvkMceU+q444bU4YcX78aMydTDD3fUJZf0FtGECUNqzBilvvzlXj6d7t3vztQRRxTvRo/O8s2sWt9qq2nhQql3vrOXRrehWs7qq2dGG4fUK1/ZyYUoTSutpAWwTv6naezYQvdd1qsn+Kqr1svU76plrrpqIVy89rW9NI8/rtuqaml0P265ZS/NggWZOvtspQYHi7LGjx9Sq6xS74c11sjUscdm3W8cNSpTc+fW+0GPhe6bV7yil2/27EydeWa97FVX7ajvf7+jfvGLSerSS9cSMZsiHWqsGIZG4CoPPxKh8w0Wcq2n7lgqIB7RQE7tVH9JVF3tIZZ2mrgekE1PyrzdTazvRBFqTvimiENZJAILnQaZS0j/8aqjtoQPhH8hqFWfuG/C0VZO9RbrEBJN8Fm8eLG65JJL1I033qieeuopNWToFrSQEpseeuih/N8zzzxTXXzxxWqDDTZQn/nMZ9Ruu+2m/vGPf5DCjVZ1/fCHP8ztgnw0MDCQ/5U0V++mTuY6pJ588im14Yb9aty4abqb1RprDKqVVuqowcFej6+//lC+mY8e3eMMG26oBQn9vng3btyQ2nDDvhxhybKisilTBtXYsXlNtbK08FPmGzt2SE2bpgWwXn0a0Xj+edVNM2bMUI6OmOUMDfXyaBRp9uxeuydMGFSLF3e65WpBSG/sZZmjRw+pyZMzNWpUr8wqWqVptdUGcyY3dmz9uxcurAppg/nJsdo3GjUaGsq6Za2yyqCaPFkzzF6aadOG1DPPZLVvXH/9Tt7mkvRY6PrNsvVJrFq2ni5DQ4vV29/+VP6ur29iK/F4ijR8vjZP8YODHFPiVbUyr4yYXnBIPqnrtYlycPYTdjl6PldYCKQ+iWV/JbnjqE30i5rbvPDN1xXLScJ2bJCYBfDlNhO6/MKvxCAa4RcdUd9konXF23DF89qLIvhoVdN1112nDj74YPWqV70KjpRI0SmnnKIuuOACb5r77ruvK1yddtpp6qCDDsr//9JLL1XrrbeeuuKKK9R73vOeWh5t+3PAAQeoM844Q73hDW/wln/eeeeps846y9mB1c/Tm+bChYvUuHHraNEgfzd69KAaM0YnqqI0Q2pgoCp4aJVSR/X3aw5QqleG1LhxOk9vUowaZQs+WtApmFt/V/gq0vTq020oJlKvbC0smeVU8+i6irErEZ3BFzbB3nPx7WFlFqe73nePG5f3orOtmrRKrVhkJZqj+9TfD1qIHDeuY5VdTBV32fq7NEKn1Mpq0iSl9t9fCz+r1L6jN/Y9oRTx3EG8cIp3vBdJ3WtIet0CzZQ4LyAMReDKxRi0yT9cmz3nBcRfM9DelRUUEmK+o7yduLkiUQGhAhVXd7npVd9RsZoQWy/O7o4qR3ZthJ6DPGLG9TElNNt9w6kKe+12tQeb6/YaodO4f6fzKLJu37P8G/jDFXq1EDK+rQg+V199tfrlL3+pdtppJ9WUTj75ZHXUUUd502hbnVmzZlk2PWPHjs1/e/TRR2vp7733XrXHHnvkhs2nn34624ZTTz1VnXTSSTXERxtHU8xeoyAF5bsyzAgpQuVFiVyJ1l9fzM3roWDttkgqb9fzrZQLWFk2SAo+XH3SEwiP+LSjmpC2mdqk7Y0qXO2HpOm9C2vz8KMcvNoxBoIY57TPt0+CNKBphms8pcbqceqWIT4x0sSzbVJsGkw4t/uCuksstG7UJCGK4LPuuuuqVVddVcWgqVOn5n8cbb/99rmg88ADD6idd945f7d06VI1c+ZMNV0bt7xA99xzT+7xdeSRR6pzzjkHaoMuV/+Z5LcYD9t12xRymuRrm1ChMJagGF52ccqQQLxNIhGbZUlug5YwebRsmU0NhtxwdUuFD+oEyZWLeWzxwhpyJUQ8o3J/P7e1mWJ180IhWhcXRFD+nYjHZIxyZe3DDwfNDI47QuEc6wtkrPw2gfK1qCACk/VI29Z89KMfVY888ogaLpowYYI6/vjjc9WVVrNpAei9731v/tshhxzSVW/tvvvuuWpLIzjaAFr/Pf3006I60U6VbuRSiiUcceUg6UPLRGm4+w9jSLJ82Kk4i2Tjw7+LdWFlWydyDOXgoXPE2Hq4TuDU/DHVRvK64hiFyuYFX64kAF+b3xlDUKT7RiKY8QclmX0dUrdi00gEKMTIm3oXS7Cl4qZFQXxe+cpX5gbOWs200korqdGjR9d+nz17tmqDtAfXqFGj1OGHH64WLVqUBzK84YYb8kCGmn784x/nQo6O46P/StKIkEaGQgk1cJVSTBQohgDShrAx3Oo8892ZZx6lRo16Xp199k+8ZUlgfnnMEsSmph0jSLTsGCdcqds31V/IzdwyJCQOvI4jR0g5Ye2hVSzxyy3ehSM3FJoqERKwDXZ4EBV0ndtpTBWuXY4sICXiUUmtoU7jvjFjWLnnTVifxkJ+owk+Ojqydi3XgQTXXHPNRsbNIaQFrIsuuij/o0h7fOm/WBQT8Wlb1SUpO0ZdwylgLe++wZh6W4w2jocI1Ub5Jth8c4iVhnqH340XBp1L7l6j24fUtTzd9hEBKo5dF3b1RSzhLYZXl9SOChV+Q+dkrPZlbPswwbs5qiyZ+653UQQf7SauAwO+4hWvUC9latKpMWm4VE6coTJdpj3By3SDXR9WvtPaUpm56rINc3mPAumdQyZcTCE+thoEW+CmcToljNTTxDltU2mQjV3idUMbidbHS85IMc8vaozNvm+rT7n2mPPZlUdSd+h8p9YWfaGmud7CVZfUd1LIG4KmcmmK9ZhF6GPM+8rMY5cT9oym6RBjx/Eqav7JQnrwqC4ydujeEbyVb7755rmq6aVOTWx3MPVUu6o0k66//lp17LE7q913n6T23HN1dfjh+6vHHvtX/tvRR79GnX/+KbX0s2c/rbbaapy6447f589Llgyos876iNp333XVLrusrI46agf1+9/f1E1/1VXfUltuubq6/vqr1FvfuqXaaaex6sknH1W33XabOuGE16s995yidtttojrooN3V3/9ej/V0//33qyOPfK3aaadxed4//vE3arXVRqmbbvpZN83jjz+mTjzx0Lz9e+yxmvrABw6sqTC1oHXGGSfnbdDf94Uv/I+FdrgIYTbSzWJ52jNIykHL5ry42jWejGV7gNTFp5HcsYWhaNQ8jGEPJkvDxUaS29Tw3ylBZaXrMUZwvXjj0GnFwD2WqpUKccDlkR+cZMh8FMHn/PPPz93Qb7rpJvXss8/m7t/Vv5cKIYOlEZGFC3XgQKW0LFj+6Wf9vnzWV1OY76h8rnfVfIsW6SB+JhrDS0wLFy5Qhx12krrssr+oL37xt3kU7JNOOiiPkbT33u9QV1/9I5VVCv3lL3+k1lhjHTVjxi758znnfEDdfvuf1TnnXK5+8IO71B57HKLe+MZ91KOPPtjNs2jRQvWlL31anXba19Xll9+jJk9eQ82bN0/tt9+R6utfv1ldeumf1UYbvUwdfvib1IIF87oCy1ve8mY1btx4demlt6qPfeyr6jOf+Xit7cuWLVUHHLCPWnnlVdXXvvYH9fWv/1GttNIq6k1v2kctXbokT/O9731G/fCHl6mLLvq6+trXblZz585WN930U2isJcyQehfPDsj/LIfWZd5qw3kBo2TzotLFukBXEqQS6WfJpZFImxGD2Vgbt0yIsNMg62a4LiCl3snWIz+eEqELqYu28/KXEav/0ENjDE/WYTVu3nvvvfN/daycKulNU2/APRXHik1Ix2uBRkdxJlIaz+VgVNOW/18dKKSsIs3vf6+D89Ftpybam998kLrnnl5Zn/3s19VWW62lHnroXvX6179Vffaz/63uuONmtdVWu+a/X3XVD9R++70tH9MnnnhU/exn31J/+cvDatkyHbFaqcMP/7C6++5r1VVXXapOOOHcboiBT33q/6kpU7YrWtqfqR13fJ2aOLHXoE9/+stqiy1WV3fc8Tu1yy5vVLfeer3617/+pX796xvUhAnrvBDf6ZPqiCOKeabpuut+qLJsSJ1zzlfVvHnFlP3Up76pXvOa1dTtt9+kXv3qN6gf/OBz6oMf/Kjad983q1mz+tUpp3xZ/fnPv4b6BkcZmm86kk27TSEiVj4ZY5W53caIho3WFUP1gJSDIyHh5SD3cCEX03LfKUX50CCCfJ7mQgOt3uH7T4JUtoVCYnNAieqmBVLOhjG8rpj8LIrgo6+qGAlEufJRzODFQIiK7J//fFCddtqZ6u67b1Vz5jyTCxKatDpqk022Vrvs8np1zTXfzwWfxx9/WP31r39WZ531pRfy/j0XaHfaaYsa0rR06YDabbfVu89jxoxRW2yxjSojCOh2Pfnkk+pTn/q4uuOOm9Ts2U/lwQI1MqSFKU2PPPJAHjByypS11JICvFHbbvuqWtsffPBO9a9//VNtt92kWv3au/Df//6Xmj9/jnrmmVlq++17+bQH4BZbvBJSd0lOgVQ+ia0Cncb/HMv9GG2PTFiLY5CNem5IBAvJxaHSfubGCwl4h9QlVZ/E2XCpbwjf7DF1k2x+DdeGiyBbsRCyGIJ3rDSo+kkiRC9X4+Zddy0QAY7e9773qbPPPltNmTJFrYhUdrzPCE9fxzBzZnFlxT//2evxLbccUs89l+XIQ3mh5jbbdNSDDw6qefOKd6uuOqhe9rJ+9de/9q5F0Hdu6egAM2f2OPDLX56pmTOHavnWW6+jHn4YHOEX6OCDD1CrrTZdnXba19TUqeuoNddcqnbd9RVdVdGBBx6mzjjjv9VJJ/0/9etff19tttnL8z+tvVy4cL7q7+9Xv/71/6mnn+5Frd5yS33Rai+YpVZXmWo3HZn70UefVSef/Hm11lrT1bRpo9Sb3rRzt15EMFm0aL6aMWN7de65l6n58/u7l43qu7qeemqNoH5AhJpyMVcNvE0D6PIdla/+zv9Ml6OIKyviIRrmnOaNvVG0qxNhA+EFFokQ2q7NUXg5mKF3uKrLVXcMI27uviz3N/BhFzgjWnOe0sKbbTwc3n9yFMY2yjfrlpQTbkjtyhPqWNDXoqqLQo5C627izh62ewaQjqWzItv8uKzyzTQrr1z8abVT+advFl9ppeq7LE9TfUflQ8rS/6/T+BaH6Tn0/PPPqn/84wF19NGnq1e9ag+14YZbqDlznqt9yxvesL8aGFis/vSna9W1135f7b//27u/bbbZjBzxeeaZp9S0aZt0/zbZZJMcqXFTpv74xz+qQw/9oNppp33VxhtvlUfJnj37mW6KDTbYTD322GPq2Wef7L67667baqVsttl26l//elCtvvoa3bqnT99Evexlm6hVVpmY/02Zsra6447/6+ZZtmyZuu++2xVC0pMExRAphlNl0pLNNd4plDeAdpVtMnL+kkGX1009j8SeQqIacY2N7xlNI7tAU6bqkmw8MezM6HLCNyt0PKm7zUJtaDAhkPrd70EmRWpiCto+77A2UatRYJgBn8BM14UZkId+57ALPlVD2RWR0JMm5sGllitNmDBZrb766uqnP/2qeuyxf6rbbrtBnXHGh2tpVl55ZfW61x2gvvzlj6uZM+9T++9/aPe36dM3VW9842Hqgx98l7rhhp/kqrB77vk/dcEF56mbb77G+90ve9nL1C9/+R318MP35Wq2E044PEeGStphh9erjTfeWJ1++lHqwQfvUnfe+Uf1mc984oX8Rcfts8871OqrT1Hvfe+b1V//+oe8/ttuu0l96EMfVE8++e88zaGHnqi+8IVPq2uv/bmaOfN+dcEF71Pz5z9PtikGEoHm4+6kQcqRCjVSw1IkiBpnfBpLJSRXdUnq4suVfBetNjef43gStrnpcWorqfrkxXQYGE6kUmpwL5lvEsG2E2lcqLnOHXCk65VyQhlWwWdFJxR6pkgqDMXKZ0+iPnXZZd9X999/uzr00K3VZz/7IXXGGRdY5WjhRtvTbLvtLmqdddav/Xbuud9UhxzyTvX5z5+sDj54M/XhDx+obrvtL2qtterpTPr617+u5s59Th1++HbqjDMOV8ce+wE1ZUpPPaVVaD/72c9yr7Mjj/wv9alPHave//5T89/GjMmvdlfjxq2krr/+prxN//M/b1FvfesW6vTTj8ttfFZeeUKe5h3vOFm99a3vVB/60LvU0UfvqFZaaVW1++5v5roT6j9U7RBLVSI5JSPMWGoojKCfw7kBD+dGGcNVXRpNWWLnQJ+umwemQ9LEGvPhrAsZK4nwJl+zSnDoiCW8KUE4Bd6jbHkeQqLZ+IwUkt4788JbOIbMcKFFe+yxp/rRj+7tPm+wwaD6298G1dKlfd16dtllH3XbbWW7B63I2R/5yJnq7W//5AtvMrXddkrdcUfRwDe96Sj1vvcdrgYG6vXOmDFDXXZZT3U1bdqg2nffg9R//tPfrVfHhvr2t3+vliwp2vLII0XsIK3SKmmttdZSF1xwqZo7t2frtNFGferOOztdY+ZzzrlYffzjF3dtqzRDmDGjo+66qzDkdpGEIZVtD82HpEECGMqMIGXoCR1af3jQHLocpGw1bJsBJ1jIN7jw9riF9qzx2LTVx4iqS4JYxEUGkf6L4fnVPE1bfeMOPBg2t5rYUdXL5dO4KAk+DkJPYBQh0r+UpGWFXi2CQPGhZbjopz/9qXrqqZXU2mtre59/qs9//kS1ww6vUeutt3FQWbEQs1jqlVinf+npJ959XrZxM3ZDdIzvkqlG4gUVDG+zxH4H/U5e4By+DRfhEXY05fbGMwYygwhmsZDKtpCP5Sl09Tnneie60IUIeI0FH337+dZbb61GCrkGJ5ZQg6q6JJv5cNgd4e3nJ6sOcnjuuR/NXdwnTZqiXvvaPdT551+onnsufhspMscVh+PDr7qg5pAkIi7VZhkKM3wnZ8TrBh2LUAHAJYjV66JjuCCGrT6PGSkKQ88Vuz1m3aHzi3onGRt6XGgh0HTOCEWgzOtG0PZw5SJoBGWUj4y5jnIcZ83GQN4yKAip2T7buLm+Zlz7Qqixs3R8oyM+22yzjfqv//ovdeyxx6pDDz1Urbpqz42Zone+851qwoTC/mJFJHTzezEaM0va1AZKhQpgRxxxhNp223d2VV1rrjmYe7NVBZ82UTT5qT4OqsALPp1oN8PHQBWod9jmygvBEsZPvbO/wc6D9DMmxHDP0phGfF1tGYVKbFTkKMfwfadMYA9PE2tdxXKGQO//C0/Dq/hkqi4pYoxpJsCtXKnf/e53aquttsqvq1h77bXVkUceqf7whz8403/pS19aYWP4oIu4eMfvwFIVGfVOmkbapiZ1xKi3klNQtmyjj2X8GXfjjJGmvTa35dWFGFYj7ZHcNl7UH244KtnsUQSV68O2DJeldSPjiQhZw+WB11bfyNWvHYGBMdW+cE/NvmgeqHGMr5eLV9cuu+yivvnNb6pZs2apSy65JL8gUgcz3HTTTdUFF1ygnnjiCfVSImQxhuSVpIlJTQWd4cwjVflJ88hOdGgE2hibdpvMhHrX/HQoCVNPp0GF13a8zGSIncSLCp1PnVa+QRLCwB7zOAJ68S78O7nYP1Q+5NAT4yoM6p20HJmqq52DSV8k1M9GpBCE1i6HetdI8KnGe3nXu96VI0D/+Mc/1CGHHKK++MUvqvXXX1/tv//+6qVCNGRWDkbVWK/NVtgReymKIRS08R1t9k0c9G0oj8zc398X6dTXjiunZGOg3sVCFZA02AbSnqqLivy7fFVdYXnkgd9ibabhkYfjCZdxBKjhHStEuIwz3yR2Qe0dTBTbXrmqK7x96J7TyKtLR+792Mc+pqZPn65OPfVUdc017mB2KxpRk3JgYNQLF7E+rfr7p+aC0JIlQy90dm8UBgYytWyZdqEuZpe+F2vx4r4XLnAt3g0NDarFi/X/93SZS5cOvlBWOSsztXhxx8o3MNAx6htSg4NZLU1x71V/rU1VddGSJYMvXJVRlLNs2aAaGqo/F/fN9spcutRsm6qVqfMsW1bNU3x3lcw0Zd8Ud4f16qbaPzjY61PdJ0XZ1W8aUsuWZWzZhcv9MrV48dPqmWf61BZbjM6fuUVXvX8XEUbaZCYyQUPqzt6Wa7NUPSeB4CmbgTgbriS2TjyPO76c4RPwwvO4hTdufsVaa23FwEHj7/jnpMz+KY5Q2BlGwTEWP4vu1WXS73//+1z1deWVV+YB8t761reqY445Rr1UqHdfU7Vz+9R6662n/va3f6uJE2fmg1N6gjzzTK/DZ85Uau7cIfX888Vojh6dqdGj9b1SQ2rRouLdokVDeQydZ57p3dWlEQhNejMuSN+F1VFPPtkTIHS+RYs6tfp0+c8/n3XLXrhwKL9jq1eOblNWy6O/a/ZsvZkX77SgtmBBRy1d2ukKU1rQKetdsGBIjR2rr7/o6+YfN063o9c7WsDQAsu8efXvNtNoAaIsR/efLufpp7WwWAqAQ/n9Z9X2PvKIbn/vG3V7dPpqGl2WFpDmzOnrMpaxY+tla+FI1zdrVkfddttK6stfXl/dfjvNZOueCB01NOR3y0W8glBmYnpBxDjluVAFqs3VtJh6h/dYoQwsOeSqLIPrQ6psM0+9ffamQ4+NDFkz66aErPpVJja/QZAt1HbD/HZqPpnjV7bdVTaq0gv1+qHmDiLIoh54vrkt3ZRd3+nvP2osKa89+xt8dVPrCr0Lq2PwHent7L615hpfrm77O6n1oeILPv/5z3/Ut771rfzvn//8p3rNa16jvvCFL+RCj1aBvZTIdQJbZZVV1NFHv0xNnbo0f/7mNxfnTPf448d20919d6a+9rWF6vOfL/pkk00G1NVXj1XnnrtI/eEPxXUNb3nLAnXuuSurAw8cUgMDRWUXX7woL/NDHyrSjBkzpO66q0+dc84idfPNxbsDDlio3vOeUer443uXhV599RL1zW8Oqt/9rkiz774L1Z57dtRJJ43vTry//CVT++3X+6gvfWmxOuOMfvXUUxrtUOqkkxaqq6/uV//4R/EdRxyxQD30UF+33j32WKi22y5TF15YfNPEicvUH//Yr/bdtzf5Lrhgofr73zP13e8WaTbddED94hdj1T77qFqaWbMy9bnPFWnWWGOp+v3vR6tjj12iHn+8+Kb3vneBevnL+9X73ldEbtZ0222D6oILlqjf/75oz557LlRnnjlGvfGNvSn89a8vVnfcMaj+93+Lstddd4n67W/HqOOOW6L+/e+i7OOPX6Be9ap+dcQRK6s5c0blQmd//zJ27BEmL7Xl4NU07amNYp38EAQjntoj/LSP9am0zc3tlFBki8sXCx2UoU1xELM2DbRtIcL8PVYMHNTGpxPUXqQ98VCrDEDeEMQszvgiyFZ0xGefffZRv/nNb3JPLe1+fPTRR6vNNttMvVTJx5QXLepXjz7aizw8NKQRid4mvdJKmVqwYLD7Tnv+jxs3Tj3zzFD33dy5g/m7Rx/toTlalaNtTso048ZpdKJPPf10L9+cOYOqr2+0euSRnuAzapRGjpZ10zz/vFZLdbrP+nb4sWMz9cgjfbW71P7971Fq1qxC8BkYWKZmzRrVzTN//rIcMSqfn3tuUC1cmHWfV199mRo3rl898khvoun2z5nTa+vEicV3P/KIqqXRaE2ZZunSfjVu3Gj1n//0db9p4cJlatmy/lqf6tvYNbpTvps9W99kP1Y98sio2jfNn9/r906nT40bN6ZW9oIFy9TQUL96/vnRUfXqMfXmMiFCBm9TjCIGI21ycg4th3qHXSPRGZY2u3lJDFUXXxcnBMrbnEVyow43rI611jhBSFquRACgUazwuuIdOhRbDmIrin2nv2/0epWgr40FH31lwY9//GP1xje+Mb9f6aVO6AlMpzPvY8UGiLcjQdwSqfJpJs/l4RalWSbVtvA0qNSOMO+Yt6zTZfuN2rFTSngarM2dKKfQNr262tq8kDZLxgEpl25zcxd4qm4qHSaQd1oxzsVQKz4NtcnJ4h41/05MeIuzZhAUUmLrEkuo6YME0HDUDw1gyLeX53mNBZ9f/OIXaiRRyAmsbvSK2g6gZZlpwk/oMTYu+2QUCxKm0mTDKlS1FQ6fKpti8hJX7Fj3XsVya5W47ccSnpE266i5XBlSQYw/JMQy+ESi7fLeWLFUDZJyY6nZpOufPyQi5fI8WNLHseY6ghz1CYVxmYASXi69hsIFUBeB8tHII4TZU+lwlEG6AbflYdPsOWaaeCdvKk17Aht2mefwBBKjy+HT0GVLvKhiqdBknmg84iMtdzg93NrxOJK4ySN1xRrPeN9AzUG/+/9wutJjNit8ObEOSv3DFvk6ztxC7SwpSoKPg3ABRhbYLmTxINb4vrIlkzyGqgtBhWLbnXB9RXvYUF4IWP2Ix4qvLokakm4zUpfdPgmaQ7dRQXMOmcvV98g4U21GGanP84tuc/Hgux8r3iHB9AgsPb/CPXpiHCwob7V6Gdj9T/Y3YN5hvrYUaezNnU/D8wzOi4rKh8xbva6q7ZEeAmV3sXXYb3B5fJp5qvlcY8d9J1U3l4dqXxJ8GlIs+xpXPjlUiwgFzSV36cWZ4fVidicSewJUqGr33qtwNZZEcJXPp1gncEl72rPT4jYHem4gbW7H0yoWmjOcdcXzPuR3K16wjYMMxuqbttRsSD4pL+gYvCquIX/730TV5aIk+DgIXaBSRi037ETQm+YTWHKiMY0Am5wsY1j0t7nR42Pq7xNknsVjxnxdeBv9z2153Ujbg6gV2rItQQJAtimwSDyXEPQy1mFEIjTEMn7FvJKa89OYqi4Jb5YZfmdR6qZvQfDXLWmL6x1FSfBxkPQEgau6+Hco9MlL4c11qu2djFREYTJcqKLSxbIxosqSbQQIyqeipKGEzBfTyU9adqw5haozQ+uShyPIoownot4cLmRLskZdAUXDx0pm+yKZX4jBvYQXIXX3Q8Jvh51LMYQl6h1i35YEnxYIdZWTCivY4pYau8VQdXVeREwuHnIjueeJbpOdRtIn0osd2xIipAJBLNVbPINsf13ScmOdwKVCqZ2m+SZI18WnkdmWxKl7eQoNbQlv8eY6X3dfJOFDduAJF/KlqmkXJcHHQeWGhBi+UWm4d+Wg1d+FhxXv5avHUgg1fLWf62XYxmZ02Htkgpvl2Gns9msyjUzREyjSp0g+ytC0SmYflWX4DDldKkNk/LhyXEze/A7EgJa7Q0h2zQY/hr2rY+x31TZT/VEdI52fuiKCqivGhlavi86D8g3XM9VmVyRiZGyQNVcvG1tbvrFz1c21zzVv6ld+hLeHmuvFO7suXz6a53OHBXquU99q1uXj/2Vdvv6jrvPAUDX/M/XOnDdl3b5nig8kxKcFQiVM88T+YlB1IRM29MTelmstnQZBM6QoSCwoNs4JE5kvyzOarCufxHgYuxQ0HOJGvl2qBpXkQw8AXN3DdUqPp9KLh8KGloPyXXs8+e+Op+riXOlfbKouFVxuvHkcnkdTMm5uSCiMJt2k5bYmbUHQWePF1ZYuHN2MMUZsn7LaMiYuyg8vJ5b7cbyNiX/HqyLQA0H4HMIE+ziqLkmbXageX247qq5Y8cjieXXxh0ceEbDLlahbkfkvXWuc+ibWWElV9f0inq8i8fNwoRBRO7soCT4OionSoIMm2aiKspozXh7haUdgkdqCYMHJkLL5NFJhhEoXC11C+ihe0MfmbvqIwDCctmQI86XStXVajRUqAytXVleMuSxBkuj2yTZGyVjJ0Jx27OLoNocbuPdFWjNSpwE7DaYG5NqTBJ+GJJ2EaD4pQ5epuvg8oe6EbbqFSxh+8S7WKTpmm7j6VSSD2jineNT2JZSJxzRQl6ETvJqNajMyp7hDg3Sty0I/8OViakg+XyzBWsKvJPYnsa5aicV75EJqmLpOKhR2mHlN5YmXxv+MHjRdlAQfB6EdzUHqzSR5qg18Pmwxh53Y20Mq+DSoZN8WWkDnQ8eZQ+PCY7zQG3I7AcmKd83hdnQDjqUKbUtViwk+7QjSiOpb9p1SZDkc5YiVpq3QFdhYxUIqEYQaGSse8TGpA6yZWDw/hsen9PD7khB8rrnmGrXDDjuo8ePHq8mTJ6sDDzyQTPfss8+q9dZbL49D8Pzzz4vq8kHhZrj6ehoqn0yIKtuAWOP76kMWFMdAMX2+6ZGggP5CVDS4Wz8SGp33XsFPJD6vDfN3qmyzzb66XM9lPZwnRyxUAWlTW143uGcgxkh93kQuLxvznekNE1O459tjl0vlibGp2O3x1023DxOyuDQuz88qYZ6FPM+g+BG3Zl1rpt5mzIvX90zVhc6/DpPP5Z0Ycl0LlQbbw3gvNNf6iHo7+/KmK6+8Uh133HHq3HPPVa973evUsmXL1N13302mPeaYY9Q222yjHn/8cXF9sU4QrrJiQYJIG2Swa1gd0pOku294AYavn0+DoDRh7ebzhTI72kXZL7hK2xxL1YWcOttFDf02apiBJZWGF25tATSOt5Nb4HWvFYSP0TdfU2uAcoCou1FzeTD+xZcj8UKj3sUSUiVooex2e37tY3NLsXVJ9qO21jQS/RwRoFcowUcLOSeeeKK68MILc6GmpC233NJK+6UvfSlHeT7xiU+oX/3qV+I6Ta+UakdnWSdws5epv1CkyGa0zeuKIUzR3kDhCIMchUAYsWy8YjFaxINF0vfUO6nxruS72nQfx4QYc1OOY6chscmSCjWSDSyWQIVdM+AXLql38o1RMp6x0HGzDD4Nvh7DkMsY6Otwq7pifIO0XBcFyEjLj+64444cvenr61MzZsxQa6+9ttpnn30sxOfee+9VZ599trrsssvytE0opl0OcscX9Q49ofPGbc1P7DIjQLv92GWR5vfgqi6u/jaFiFheXea3tSlEyASN8OCV0lOnXMANe8brDrelivUNsTY9yTop0oXzGUl7Ym2MMSJ8U+XE4g+xhEKJerE/UkToWDZ5XHgHZC2GqLpWCMHnoYceyv8988wz1emnn66uvvrq3MZnt912U7Nnz85/GxgYUG9/+9tzVGj99deHy9b55s6dW/sLi+ODpJF5tEhO2nib4j636T79YlB1SV1P44TIDzdyldZFz7mscXiEmKquNlS5dBoMqQ2tu832YAIVv2FgThSdFzkiMHwCcYy+kNctKTcLrguL3ByOYCNtxg5kasUQfE455ZRcP+37u//++9XQ0FCe/rTTTlMHHXSQ2n777dWll16a/37FFVfkv5166qlqiy22UO985zuD2nDeeeepiRMndv+mTZvmNCx2bWyUERYXvty1wXCGnXZ9tLGlz2iT+hYzjflsGpIhZboYBNWnvrJ7aTKn4Z2v/lDj6t67MCM+s4967zJBH7nrRj0HEWN5e5wzKA019uYc5IxGqf5yX7Phdygw5wJ37Ydc1Uy9s9vMzV9qjM12SdqDGXHj1+xUiRrzajoXf8TSdNh54WsfNW+l6hx+btvlImPOjSeyPl0ONmYaqh+Qvul40oQIcxzPo+L2mPyjXi5v2B8i+CxXG5+TTz5ZHXXUUd40G220kZo1a5Zl0zN27Nj8t0cffTR/vuGGG9Tf//539eMf/zh/zrKio6ZMmZILTGeddRZZvhaYTjrppO6zRny08IOiDNhGqlpTdbnT1BkJXRe+KJFLAWUBBGXIV5vXOMSC4+n6wg23pW7WsfoDqUsWKVnWHslJ1IbS46hlqHSx5rgM/WpHfULXxSORw9UXiEDqbo+fV3JoJlWuDNWIYz6AuMD3R1J1SSKQI99Z8I9OdN71ohB8pk6dmv9xpBEeLeg88MADauedd87fLV26VM2cOVNNnz696/W1aNGibp7bbrtNHX300eoPf/iD2njjjZ1l63L133Dfzh6rLGQTkiwomaEbvwgQtQmyUNqCm4tyZGVjmwU1Nlxfx1FNtDnn7HL4zUK6UUrXwNCQn5FKghwi7ZGugzjxTxBBA5tPtI1KFcVC2ocKI1wa/7OrnLYERS4wIlIOUjcyB8xDh9RsowPFAQsXfiVp0MPeS8qra8KECer4449XZ5xxRo7GaGFH2/JoOuSQQ/J/TeHmmWeeyf/V6q9JkyYF14lKyfLTuBTpkDDD8DTmhozZz/D1tnmNgoyRtOdmjQg6VHskkVgxQTAOuiY7kcfxukHqkjPSdlCqWN8pVd2EtjemgBcLaePDJfDtpdcWgiyECzUUcQ4lmLDJG/BKQjfIjdfD+wYZX8k+95KM46MFnVGjRqnDDz88R3Z0IEOt3tJGzm2QFKXB88URotw2Ksjptm5zwE/6TvSYDlLkBoexw9vosr/iypbB23x74qm6+DlHEcIAY0RKRvNRdlRcObquwcGwcnH01i/cxjuc8GtddqGmamUuS9MgdSMClSTWD3cAjD2e1dAoiIAimSdY6IbM+s627mdE58kLpr2V9oWXu8ILPqNHj1YXXXRR/oeQ9vgq7XwkZC6sZsxJCcuSLoTmC1VykhxeLw+Z26kEuULzxWCsdDA5vp5Yl95iJ0qkLiU8dfL5sMjezQUxORooUXvQddWZf/j8kqLG2P1w/meqrnh8I44NCCfUo7xbisTHEMZl6KZqySwhXt9wcx+Z6y4KkJFGFrVpV+J6h6kmhkvVxbVNVm8sVCvWd8e0v5KgEzJht725iakM+HKkY4jA/zEYeyxDUro94fY7bW0q8iCeVHs6w7Le4qn0eNs43jO0PXs6iQCP3LslQf06gJDfJo+JEfYjCT4RKKZxc1PEx+fCJ2XgnDU+t3hck7eaDnFBlG9A9PhwLptmGqqNIcyZy4e4OtfdOKm66bGqtsl0Bw25u8z3TLVJEvWYmsuIqssliPnmlK9+X3uosTHTuMa9rTnOCaKm67LrvjxXfjRNmc43fmZbqLJ7fer2KKWIEhr4NYuEVPDf+eXqGwnSRpXN9YMMtTJ/p+dfh5knZtkufo6sxVD+KuHlL7kAhsuDUGYgOQ1X3/ngvFiCVgwvCZmuuRMcvRRpC9UeqmzpyQxRdSFzgXoXJ0iYXU+bUXO5b5DeRSX12FqeJ0isLn6OS1ykkf6KpZIu10DVWoBHtjqiuuLwqzj2fJL+o941EcZ97yR7kHwf6UQpp60Ahki5LkqCj4NwlAYZVPcmXRV8hstji6qLn3hyBlZlnhKGhW5A0lOXpOwQFKrJM/UOgbup9qBzOtaJkmuf65TOtQ9T54S3B5mbMoGgXAdu9EGuPul4421h68Q9n3zfGWMc6Pa0JciGq4nQS3tjfIOc3/sPfNK+6RtGlS0V0NDXFrR9LkqCj4MQpkwRMqgoM5RP2PByOHdCbFOgywj9RonuOyZaIG2TBC1pS5CV5sNOxc09Tei62wstIAu0piIJBHxdbQnyTYWR6neG8ojQuvxCQ/NyYyE+7dnBxRHe2joAdl549sXDkl6RErN9CCXBx0FlR3N6RlcaWjeaeRkooi91X/lQn4w+G4Remqo7O6+7NW0JeLsOerPj7Chc/eBLU7yj28PZJVBtNAmzl6FsHPyh9l1MIdRuI4Tx+8LduxirWT93JYtGHkJ1/75v8K1Dan7T17b47SlCNnIOvZGvY3c+yYZbCgz+Kw7svL1Di7tsiieYxF014UqDjGeVaL5rt5dLg46dScU6t+cX0h5fXRgv1Hyn412vaFs6HuGBUmnbB4oOUVeHXa/F+/p+xLUvqbpaIHRzMSlUDeFTdUnhvTjQotlevkxJoDs5vNuO23W97DCkCiEJ88NUoOEGx2j9XBoJ0kW1GXUfj2HD0FRdUT+w+Ps5lsoa6WeZmoNKg6ipw+uSntxl/IjfCWPME4pobzCO58pCdNh5zGdkrmdsOdj4xom3I1lDybg5AiFuqxQhAkE1XagaKAakSlEoU0N02G3eGC5XO/JpepBuc+PmUMEVERAQQZaum38nQRWkweMwwQxD5Ox8Yc90GvfBI7aqSy7w+utuqubwBdiTCXhxjPAxdI532+fby5dLl0OjxuF1xVenS1XcsQ5Okn00VrndvHjSkUXIRKAIWbToO2zCymwnmm7Ico+ptlAImX2IH40LE0qxDdm/mWGMTXYKjcdY49j4SJBJqj0SoaqpUOxDQkwDY2lATMlBKDYP4VRd9Tx2XYiHm+Sgg8wvZOOW9B997YW/XKqNseak7LqHjC0XWWeIl65EJRVrfbgoCT4Okp7oUakz1glPihA03SjaVWPFSoNstvG8NuIgPjK4GxvjON/V1jijHjSIINje2rJV1G0hPpKxkRiM+9aOz7hZdpKXoYN2Of5ntFx+bkvd5HnVs8w0IHw9SMIgyOdxOI/B+ljGu1yUBB8HIV4yFNFSMZYu9qnUl4YrN0bI/3iokExHLY0RhJ1sVJT50ZYgSJH0NMbbf8XxLJQio8MJnffSdKK6Wkuj9nLlNEe23Kouif2JVB3G5+HTILxZ0n+xLjqWj5VpK9eOl2pfS7HC2jwYuCgJPg5C3ZWRNFL1l3wxxz9BLd8rK6RpZOhJk4jCHNGXA/rbI2MuMiSLnvd+xtou+idTdUnqwjaDjEV8kJN8rECeMdAm1IZOourCDoH++UWRbH4hm3t7KhY7XzgvkqF+SFsUUbf8sBuGFMoOTsjBwEVJ8AmgmIIPpseOAwEiCzM0bk8sVaDEmFaaJmY+qWDMCToIlI2laa8/YtkHYPMljqfLcM4pk2L1j2TTw8pFbVT8z1L+iASBbav/7LaE8zkpyi85TCGHg7bmVl/APPYhhU3KDU2zwt/OPtyEqAUoisUsq22opo21WOy6/M/oAvS1la5HpvN3paFiJZn1V9/38oW1uxo3w5fPJJ3NrItqj6/c8tlXDp3GNaezYZtP1X5zndi4sQhhcKEHBrQPQ+JvNUHauPYU86kaP6aeR460KThWTb0tdj4zjdku6UGtms71DUhf+NJI77lyCXj+NSt1nQ8X3vqAvjHfI3OpJ/jgdTUZOy62mosS4uMgubCC5cOEqDiGrpITlETwkZ16OlHUWOgtylJbHWnkZi4NygRC08hVXVTZnZaiMocjR9Q7ybqUzzvEzdsU6Ki6woV7iiTrVOIKjtQlVXVJ+FUs5FuifpKgtHQ+f910+8LRXukBtK/BIduv6uIFs7b2uW5ePOnIopjQvPTUKoUAkUkdirI0iZJZb0unlY1NirTFzCdBQtqCpWMij1zZbY4hvQbCbUKQk7y8jeGMnSuDyofwg1jrixLWQg9HFEnnIJcn1tyOpeqS5JOqsDnhLRY/6ws4FPnjXHVaUd0nwScCuWBliqg0XL4mG0Fo2TYkyE80HYrcH+aeF6bc/ZUR6o36O7pP66dstB986dANEKnPhLKbqBTrfc2XG7Lo69/Bq1O4+eLqZ2R8JGOInMrNPOaVBzE3NFrlU1c/cUSp+bDNyd8XyNhQ5SNCFtKnXBkuFRAnCKLfWa8H62MJP3e1z98e7BuqfUGnsdew+TvXlk4kwaJME3KJL8an47Sv2wY86cgihMFR5GMYoYsH+b1Xdt1OI5yBYvWg7ZRC9TQzl6n86O8M96KiyoplexLr5IV5q1Flm6cvuo0+QUiqnpNGw6ZUDaHrJpZK0dXGkN/RupD5zG0yVLkhNiq+NNJDRRuqebmhN98W6Tzh2iOdkzaCEt6WPqF2wZXHdyMBdog0n1Mcn2EhZEOmSMq88TaYZYcbB5d5Qizv7WdZXyAkPXnHMAx0vUMEBEl9yEYV6/QT+1QXkgarG0ffYpQTWi76DnFVRwg5AEg27ljry567MkEW2ai5PNJyJfeshayZkMjXFLVxaJWPL47yh1zpIu1jJIK2i5Lg46BYk6XtsiSSOjI5uZOG5BoMimLd54V6RLQViND1LpYHhi8PXY7URZkPBClBFeRIlv2Om6tIXZjhOxqYDjtoLB+jXySNzJuIKwcdT0k8FsmYSzZYaWBJjMd2BH1jpwnl3TERWTuPihLxO11ZsZwo5oYovfA01mnNNdH8N8NzzFxFoVjfiLanLUQDR+PMNOGMrU0BXCKgtDmGCFOUnA4pau+kHJ4HLUfSF219p50nDoInqxsVFMODcyLG9T0BoDPsyJas/7KoTgQhV7ok4+YXESETHs1HkZQZxjjpIJb3ks2urbhHMZm3ZNOmSKoT506UUlsPaX/EQBDbsq+Q5pPfr8TXjSEhOOQ+XIecpmkoksyLknyXvCJ1x7pdXJInZFx8h0tJXRL+EI9XKZYopEuiipOEukiITwRCNm2K8A2YL18Cq1PvXM9NJqfU3glJE+tCSYmahKqfotiMomm5UuNmqYFxaJ5YAp2rrNBypHMq5FQZkodak20Z50o2Rors/sLXbZh9YRw3b6Qc5LoRaf9JxkryDbHUzJ0Gc71p5GaEpPnyvPKsL22SCivSU6u0rCYQoH9yZgxTi4N+xTqNoPVLDTDtcpB34bYvMZERJI1sgwuvK9ZVHNQ7TIBCbKniCPOI7UYMo1AkjXQNSPoiZMMN+c42EYsYalNf3b7vbAsVjcVT+gRXidCRzZv3cSyvs255eNKRRVLpG0UQQjYqLkw81wZXu32Tk4/W629zkSbcSBGty/VN1fpdfUO1MbTdvbEJP/HW85htDvfS88VqQq7w8D1T+SRoTvmMzOVq+S4XfN84hzBS31i40nAkYciUUag9N8p/ffG1+PZiPIReA/5+56/LkCBbIeu4SmjsJt8aQer2CexVVZdrPKu/U9/ApeHKQa5n6Tj7xl+3mbesK+RKF6yP+TQhKuYk+DhIfsrgjcRc5UvaIGknxXwkSERbJDmRomhGrO8aTiGiTVQojuo0a/1E2XSutnUKpkhiD9fbKDutrPWmaShCw2Y0d3dGPA07Ufh1rLlNCbLceErHqi3Uqk8Qgbw3vu55HKuPE+IzTCRhRCHvJPkkk4Y6jfCnBsm9PPgm4Qt4JQ3CJr2rSxp4McaGIhWoQvoj1LCUG49YqJ0vjSQSbGhdtnqXKidcxStd63FcmeMFMOTrxtdWyBzExlMWUkFyEAlR/fpVPuHzrb1vyNhyJWgn0j7pem1yjVISfByEbYgYktOu4MO30zWJmgSZkrbfJElbpGma5Gur7FinPunpJ6YgHVp/yMmUiwTbDgIlDYSYDZuND29g3Bk2G5+QeeFDtpYnghdrPWIHuvCNG0GtYtkO9QnsOumLVsP7WIJEhxg7J8HHQWWnVjvXNTF5PXzHYkKYvtT+HbFD0P/vey6puigpfbhZD9IXrm9xvXcxfPob67p4tD0hahJ/u7MgvXnvfQde0NS8C7Ep8FGvrzuBdwHxz2a7JDYE/jYrbx/S7Ykfoh8T5rE7rKg5HoJsIW123U9FzSeO95gksftz2bD5+ouaXy4Vla+csi+o+V595vgr1jf2oKMCXr0u+x4zqtxQ3tgB6pYcptA03HpF7P+QulyUBB8HIQbJ7au62tF9Ym6d2AbtI+lFphJ3dp8dVdNTNEWYTQEfYVkiiIUYe3NqhhgRUmO12Qf1x/cCkqmAYnl+ufL4hXSEJ8VS++FtRp9xNXu4B57UiDvG5u4rN2zexlHXtTUH+iCBL9yhpU3+4WwDnnRkkXSRxBV8ZG3gJgQlEIQajGKn0U4rkT7RNCVzDIHVXe/ssmU6ccmmHRsabqpWRH6Xwe1uptnUJsTu5/ATuesdXxeep+4FZG7uvJEv15biXbjdCEXc1Q1y4+Zw4TLW5hlr3iICezy1mmQOqFaN9P1pmtstoWlclAQfB0mNqVCDSGzi2YliLEzs1OWvFwn0hTB8xOBWemKhmE+bd3XFYBTDjZ7EMQCVCYEhBoy+DQQh5Dul65tLg62D8js7jdYB1u/trIEQ42bTzbtebhYFCcHmtn8TRvYBX1+FRW7utGLELV17HcGVFTLbMD6ERzJuXgERH4qw6MDtqLpoxMecaP5JFft0HCKEhdYfG+FA8yGbK6ayi3MCLikUXZNcMogwt7bGELtoNc7aokhyEo01V2NE4pamCRvPqoAXY37xaSiy78qLg0YgAjty2anEyDdeYMQOm4YrlyLXNzWd+ymOTwTCBgPraARW97XB9w5DQ+jKqsyHq0fiSRNyajQNrX11oWmoMZScoORonMQYlaorPA3KjLF+5GKdIG3m+8uHUvkv1KXb09xtn08jEwgw1YjEDkM2Nnwaijh3bBT9DlWzSxEBybppGg6g6dUNMeYAcsN8n/A7uTwUufhJOJ8OR6S6edUKRNdcc43aYYcd1Pjx49XkyZPVgQceaKX51re+pbbZZhs1btw4tcYaa6gTTjhBVJfEDoZK43onFXxkC4HWvVe/LbbNj+udK00b7uw9G5822t2W4Xl4HjpNNmxB8hB1SmxPNKR9oeqxWHNDspGX5LPxkfCDNtESiTt2Sb41ibSlvXUTnicmXwtt33DOgU4kxMfFP0JtMSV1lzRKrSB05ZVXquOOO06de+656nWve51atmyZuvvuu2tpLr74YvWZz3xGXXjhhbmAtGDBAjVz5kxRfb1Nwn7neg55J0UVQjY47tkn+HBlSC7zK9pqnjRsFCLGZlx950c4OtEukMWYVL0PXmy3syNp2vLc8DEuiVDuy+O6CiO0zRTZawUvN/YBQDpPJRf1hqht/SogpBx/W+S2aCZ/ssvFDsAUgtdhUBee31PE83tkH1HBaUxeVqQJ9+RF5h/Cp0O8ulYIwUcLOSeeeGIu0BxzzDHd91tuuWX3/5977jl1+umnq6uuukrtscce3fca/ZEQZgfTRPBBGAsVX4NnoqgrelWokxgBc+1o0+AWY7Jl2fWTRL0/qT5WMPnyucox44hwzK1In1nlmnVTbaG+Nbyvsfnke+dqcz1PZtXnspVA7leqniBl96jhc8NeoxmDuHYg4+ZqueX/m++4Z5MkMY2o99Tc4foK4atIW9C6uL7gysHyYN6IZnmuckL5MCagmO+UEV8svP+o+egaSySNCTJwfWy2L4RWCFXXHXfcoR5//HHV19enZsyYodZee221zz771BCf66+/Xg0NDeXptthiC7Xeeuupt771reqxxx7zlj0wMKDmzp1b+6ufwOqbFEcouhOrLKRsxJgsFN2KcWJYHsbNkpMiRVLEIPQyWOqdVM1WUkgMFaRsug/jnPzoMTT7jFflIqiQZE5TxNkeSBEfbK3jdcVSQ6LP1Xc++0LswCRZa3xdWHRiMw/mvYbyouZGvuF5OoI0sdYHJQzH+G5vG9QKQA899FD+75lnnpmjOldffXVu47Pbbrup2bNnd9NowUerwj73uc+pH//4x/lvr3/969WSJUucZZ933nlq4sSJ3b9p06Y5IVkMZZALQ0g+2YR1qVPcs5SbVIghL3LFB8UIJW7FPubYTgDDOPkkXiTSMAeYcXMneC4gGxMtKCLlhAf2Q8ZGOqckKiBszvGqEQS9QTYDxPBcMpexdUvbF/ryydc/Xw6Plsja5xIAQk0nYnynZN5gdTdzaOk9x0L9+bq7edVypFNOOSVnWr6/+++/PxdoNJ122mnqoIMOUttvv7269NJL89+vuOKK/DedZunSpeoLX/iC2muvvdSrX/1q9YMf/EA9+OCD6sYbb3S24dRTT1Vz5szp/pUIESJ9U+8p+K/3zg1/+8qq/56xVwxQag+qLM64uX7FRgdSL5ht5dK49NpIn/J9RX0XfwoMGWfz9/rY8KoSVz/W68qsZ7TNVBr/9SCluqneZt94U99plutqj+/6gGrZnHel9BqUUGPiEObKbTLU3A8RCKh3rvlV//YONH4c4VdNVN/ZwjdXN3U4wuoKT+O6bsTsP7RcH7LlUmP55i0ynojau9Og/1zPrncUcfuRCxlHxuFFb+Nz8sknq6OOOsqbZqONNlKzZs2ybHrGjh2b//boo4/mz1r9ZaaZOnWqmjJlSjcNRboc/WcSAr81sfFBSI48+Ct0eXWFePsgRrkhp8+mrse+E0Ec+yFkUwxHb+w+ymAbH1+b/X1dFWhV4za3eSKnLinl56aCbSWazjuKirrchwQfkuQTfCRq7Ta/k5u76DUyaN2h7s7munUjH2FjFWK7aBKi0vfP23ADbczJQhFp/OXI14fkQlceXQqJ47NcBR8tmOg/jjTCo4WTBx54QO288875O43uaI+t6dOn58877bRT/q9Oo+17NGlV1zPPPNNNE0LUqVEeuZl61wE8nux8kuBUrolWFXQk9YS2wycshLvx4v3Q9MoKVJjF0CRTYAwfTyyNayMIV6eggkZom6XXbKDG1ojLdIhbtTRNiL1TSGytEASxnZAO4b9T7eHyYTzCrizG3Jajq7yNj2RO0t/pb590LPsi3CuI1NVkjkojuq8QNj4TJkxQxx9/vDrjjDPUddddlws3733ve/PfDjnkkPzfTTfdVB1wwAG599ef/vSn3PD5yCOPVJtvvrnafffdg+uU2ofgm6T/2UWS0za6EEImXuyoo/4TYNZoo/fnU6I0lM2KbLPnkTOZ3pxKI0MV2rIhCBkLX5tdhKAcIUiSq41cGmyu2m02SWbcTHs2coQjW9IxxwU8KXKLjWe4IboUbY5j3IwgPkj7OsHltiUwowCCpJwV2p1dk3ZlHzVqlDr88MPVokWL8jg9N9xwQ27kXNJll12mPvShD6n99tsv9wDbdddd1bXXXqtGjx4dXJ/c0hw7IcQSomIt5vDw6nyZmDE4vxlLBUfaQF2CqmGqrhjMGMkT01CYq4t6J5m7TdVzPoTARjRLhIAXamIgulwazLso3OiXemd/p70GuHv3qDaXFHZ1CFUuP54SgSDWzebIQQSp2yXI+uZk797CTlR0Vbr2TEKEsCbG/z5Ej7rTUdc1NOQ3AVjhBR8tvFx00UX5nw8Z+sY3vpH/NSVq4kphUOzkaG+uyAYXS8IOPVFJTsf+E737Q5repB0Cq4eW7c8XDpMj6AmSr83+QELFx9h0pIgPtlHyaWKdaLG+6ABjg532qW+KpdIL6S8pgucqp427nFyCYqy5bfI1RNAOVUVzQoyUx/Uz9kWxEZ82wk+s0Kqu5UGxbE9iBxFDIEoJOsMFfOMMyeSoDMII+W+Uli09DUmZiVmWJAJ2c2NvN4dA5mosxCdsDPE2hwiPoUa/7bmz2+2x03SCx116BxiiMpNsuMh4uniL3+jXLg9D8NqZ24iqC9nclyfi0xGVy59QXJG5R4w7+4uZEG8SelHwti54Wfw7pGx0gjS5kLUpctIUhfDl8xlxxxJgYkVZlben08ppm66/+YZClxunzQjKEQtFoIg/JPiQrbhzNdZ3SsqJhwjYh1CEP8VYW7HnLbK5NzVEl/ALiuz28WsaIdf+hDihhPaNi5Lg4yAECpciAdQ7X5p6PJ0Yxm70LuJblOjJt1o3ZuNj1+0r0102X7+vjf52u8uo/oaOqZmHa7PrdGbmqz/L+lpi0xByUkX6uZpG4uaNtMdlM0DPDd6OwD8PeIHYNTbUmFbLo9Z6PY/df5Jby2kD4w5zDYLUBoTeYH3Xebi+Qbq2fHm4+EXVfJxXV/16FjtNDLtBad90mGsjelfMhO0LyG9mbCJkvSbBJwKFbLZ8vjinETQfJ7S0Y9ycDbONT/aiQJPq7WyeZjjQk9D+QNUp/hMb73UXq81UHlcfNg11ENIepNxQdJJT+WBoCVJXuDqCLjdr5UoDitoeq+aIDz8nJdG72wuRoYLzUIQgXbGuNnK2AU86sog+NfKjiqRBTz60pI6c1vwT3zVBQozqYuiIXe8keuOYAgyyaVPjh10863+O553Cp6Eolnquif6dsy1B24fkaa4CCrc/k48NdQAIe0bTSNQwsb7TPZ7N7HcwNJNvL5amfNkRo+pU2RLEJ/YcaEvwie3R6G0DnnRkEeZmXULP9rt6uvq/5v9X81Eh/LNKI0yIkipP/78JE/rqLsmG2c16O0GndSRUPwLxU/1nqyXcG1BojKDYxs31dnYg42YfJI7YF/nGwxQIuL6m6q9/k91mO4y+3SCXaon7DpNMFYsLVaDXlrt+RDVCkdlf2LxAypWotenvpOaTnz/Z7THngSsPdy0JVzeGSNPto+rwqS7tuU7xeLpcKp8kOr59dZCdptpuk9+bz9Q39DuEc7PcehpE2FQsme0rCRF8/FHncdfPJPg4SCqF+jYl6eky1M5IIqmb9bja0nsOP00tL5dzv/rA/g0P+S7xRPALjJRtQDzEh2bGfJuxuvxtbqoKxduM2DJRazJGpF80DZcn/tjwghhSDnKfkr+9/Ie6ykH453AYBiPBW13z1s/LZfsEPweQcjPnN7jSIP0Za73SPMY//3yUBB8HuYzTQgcZ3Rh8DDTcswxrj0khrrQIMw+BjdtwOUdUZFLVUkl+6J9nJq7fQ4MuhghHTY2b2xLQ0UMD1z5MWOKFwLbUjnKjX6qN/rlBISGIcbMrTVNVlwTZQtA5KYJnI0fhBzo/766/969r6jDVvD1YSIOOVS7Xf00QH+rZf6FrmcbXnoT4NCZkMFChI+TEQk3GKrMJUWn0ykG9utzfihq4+tIMpxtvlZqjSdhGFXq/md+WYnkZCsdTp3AUMj+aGjfHKJd+Fy4c+dA4HzVBLJq6gpcUZtwcLvjT5eBGv36DdmSswlENH+/2BTAcLvQb238y8WXXXPtMQgI3uij0cOWiJPg4SHpbMorcYJCvLalLJjUCQZtlmBTjdOfrr1D1S5hNS1jZISfFUGgdNXwNP53hp/jQIHloAEPfSVWKPGCIII8QyNAvvi9kJ3A+D0WS++Hk88ksh+dFMW2k6nl4dA677oFfNxhSmYnHs/mc5N8hPKVfENJAguJSZF8LgqCvSmRa4CwPTzqyKEQKRSeDX9WF6YkR/SgPtdNt99+HhG1+oWkoVIsrJ7R+/71A4cyw+q5pnCdXnua2CsOHrsVrsztNbK8u14k8pl2SWVdIHro98hu0QyPQu8e4Eyx0ce+4NCGCbBtBDiUk4bE9Xhh7fdo8tiMYK0mU+VgILfUNITY9VnninC9xkiIRvnTSe0ZCI9ByQhV6GgmxLWpq3Izod6Vl+2+CljFDRG9O1xfDdbdNQ+F2VF3NBR9fmztRTpBc+9A2I4caO0+cHdd9MApbA4iBcYzDEEX2pbN23S5qehCRXWLMl9trX5hQY6cJX/sIWkeRRLBtEtIjFA3jBDMfJcGnEeyI6Tilgg8dK4bOFyIJ44JPFgRjo22tp5HZNgznXV1+odQtHEoCV4acvn3vYvYHLqzhgnLobegSVRdiyxTbw416h8wLyXoq3nWgdRFrDYQIFkj/xdoYqe8MmV+u51jrsSRkHoeqX/E50Akygu9jxko6vi7hErm/LfSg6SxPnvWlTVL7EN8ECo06SZ+kecYmhW/NidcU1kaMCxGSCo7IBkjXl4mMmyVxLlzM2acWpdvsf66+8zEYilAjVp8RfpuIYKwTpEwNiqMlrmfXO7tc/h16qOFIghrE+k4X+VUhahhRDT6NZBwwgV3WHrPcPgEygzjJSOcxOkeROEgIJcGHoRjXHaBojisfZtzsk+b5Ddmsh6vXVWY1HYJCSPvBtQjp4Iju7y8F1Xq7+f5qot6pvtft5gI6uiDd+nfQ99b4xkOqVoyBBvjKQe7GQgIEIkKNL3AmFfjNNaer7zmj2hCEAAk0aPYF1V7EMLipdxMSkFISsd6FhFDz3Reo0TW3fXPJJbBzd5KhPJbiO021DC40BwmMWCXXXDKfER5j8jzqN1/fuA6a1BxAKAk+DpKcFlzvsFDzmQjek6AhqMQdYmcS8z4yxGMjVtkSVUWbBr3UeEpsCoazPxCPi5JC+0ti+4KgRJSxrqsc37smY8y9Q4hb21JbJsTGZ7iQrRDULxTxkai6JCq0kpqikLF4SieAx4Xksecjvi+00TcuSoKPgzCjwPq/9fwd0aKk3pv5uBMddSJBJGMO8fGVEbJwwk8IZXuyGvPhrnGQqIiofPRJGxdKfd+LCBFc3yPlUmmotK42m2m49rjnaScIIZCiVBSFng7p78Js0kLnuHSu2vOHF1jMfCHz1ETAfUgXdaVPyBxsaprgUrdyfIxqL8L7JDyWap8PoS7Ht/qOuqSU5p92XX70JlywxfhQnXcjQk2IwwJCSfBxkEQHWuRzvwuN3IyFMLcnBAcnuwMYup9jSP9NT7rDcZM2XrY9NjI3YTpP6LfGui5Acoqj5ze96QwNZa2PIdUeVx7EbiS8n/3tk34nEgvJVVescBEhJ+7lPZ4xeJSUP7h4cChqZacJV3XRgk/HWwb1ri2e32sf3zcxblLQlAQfByGLzZcvxsSj4HjEGJbbXN1qiHq6pmVKBQ+TpAbcsTb6mG2KoTZqaijsI2yzdzF1d7kUc3MJ8VQ+H0k2aakKSNLmJsawofkkaqKQ+bQ8BJ8QgcA3vxCbo1iqLgniI/U0XF6qLopk64P/7pKSqqtlCoHfqHxcWSFMwm802oniZspRjLu6pKoM6hubqHbCIwq7xzm0TVzZiJCMCUeUzZjdHiSNRD0n6S8kgrCvbF9dSHu4cqn2yIRbzEsQaQ+30UiMial8Pc89XICKpX6WjmecsbLLbSLgIUH6wudkxsyBOIepfkd8pXoa/EBvpvEb4HdEArwzLZ50ZFGsE2G1LKmqBlF1UfWF1FW0r/4cwkSa3tXlo7LspjA2RW0aN0uQGYQJlNRGf1DEjXUPdXRXgCCTsdxjeyfI9o2bkc29TcSHsu+o57HXDkLId3J5pN/pihAcOr8k6hzkHqkmh6423NntuulvCHcsUF6SoJ1UvpDvTqqulilW+PBQd+x6G/AJG7LgURi26U3MkvtgKKL6L3bZvnxy9SXCGDpRjPja7I8Ywhp16myrzVI0J4ZNja89zY24O62MTQjKF1KOFIWVjRWPlkgOIsh9iSFqfgQxC41ij/J7312RfaK+odriz+Oru6nhMhIMt5sWTjnCSL5puplTU+MyX74Yqq4mxs1t2p1gyFezsqsktb/CyvanKe1nEKPbwUFfOVh7JJu9qz2hp9m2xhCxzwsxmPW9k8wf+XfymzByMLLby7cHKwdZN/yHoh5lw6G6pOpu4s7uI+k3oPweiWQuQcN870Ku2ECuVUmIT8skPSn5kA8p8wkNxCZVdfkiN3MnBAlTocqlCPNuU43UJNKIr8NxwuTKQMp1vZOU7VJFNI0OTNFw3v2DtC8EqY1hDEulqYZ14DY9xDYCQWsl813q8CBDQWVIKdd/WAw2vtyS2jC45/gshbbGKFeK+Mj6xt4D7HJxyScJPg6SMvOQKJ5cmhBJPcR+CNU/D4c7ewiyFnq7vVSNFrJ42zuddRr1R9O+9r1rgir4+llyXxDVnpIw99gwgSDGvEeEJV97JOsyVAh0tbmpV1cT1SVip9QU1XB9tw9dDeH5bdixcMhMiGAROm9jzIEQ9NzPY5KqK6KNjzsNKmDGOl3iG0o4OkN9a6hawqwrHipjM12Xi3W1vFgIh+9EHBsxiCVQSdE1Oh/dxubIJN2e0DGMYY/CtQNdW1S+WMbNvT7swBdUhggsCKIadmdaM2cGru7w6x7syiUHOol9ozTkA1c3VT+6PjsdThj3XwnR1sEgpG981434KAk+DQhlYFL0KCRf2EkssCHAqQKDy9s86eIuwtW2YhFfKQYe3odl3XVmYkYv5levy1CYYlJcdGuqfaFpMIZNCa983a421/vM1R5nc5z9zN3t5KqLmlNUW6lnqlwqrUstW52L9vyy85iEuDtj5fB3J7Vl3OwyDObaY/YX8t3UGkbb7L83kP9QiQu51PC7jxUKM9H6QAUf37hw6TlKgk8EgYKavBzDQsrqwXv8YubKRiRjv6rLz9RCTiLIiZ4+zdW/AWFqHFEQqqvdVB8iiKBPsHEJcP7TGd5m7p35HvEa0W3mLlZF2xxjDF15fO2hQiS4SGL/hTD6+mWsfMEh16SY5SJjgzhfIOWYz6ZgRhFSTnObLRrVMMvhkCTXgS50o7bbx/cx9c7k77ru0D2CItdccv1Op8GFIx81OcyQaeGUI5RCjQKliI/vdBR6WjPLw7266j80d13NWnNnRwSvEBdIaXCv2KeoECE5tM0SZlzmi7cxuQXwWO7siFtwyPjVVUv+un3tcT273rnK9Qm8rhABsYL/NTVuRr5TZljN7+pIe1xobyx39uEx0Oa/wSQE3ZSML4KyhSF67jQhKHwSfBgK7WifXju8LCQfnqaJcTNfZrjhm+sd4nostVdxUSh6IrXxQccCM4LstB4MkC6bzoOcxpoGmKMI+XZXHsQ929/mLNgmytceiXej/xoQ2T1IMuE2a2k87fbZeeyxQoib21TdTWy2mhpou1Rd1Tvw3Dwl7BDfx8x1KX9DTCBc5Yb2jTMtnnRkUgx3dsRqnZae8cXc1NuCqidkkmELh28bRVJ0RVp2SL7YXkGI6yliKCwXMjuCzUFmQIu0D2kzEkrf/Z1hqBC6lurta28d6O/wXfyKoQjUfOLrdpWDfEMM4+bQ9lGoBir4hPIH9HDJ1eVKY77DDNPDy60SMvexNJl43oSq61yUBB+GQr260ACGWFk4fMsZHSIUoupq2/tBurH66qdIbtwsg9/xE2Ynunpu+bqzy2B8dO762udLg4yfP4wClc8v6MjVsiq4PVhATOo76TUQwg9jjSeGKPJpmqgl/Z50WF1mOe6+CRfGfYKP9B64PqsveAE+VpBDV7mhpicuSoLPi9jGJwTpCIGgEY8ovky6Hb40TVGINtAC6aleymj5jWr5RkFGLtC0ERZ8fNocw5A8lBDhIunccD3HnquxTvvx3dn5NBShhtUxEFjUA88nbMZGfBDh0owrVB0X1zeFB9DNyHJcz3Sa8MOf9PBLCaAuSoJPA0IXtnTjbivoFTrxQlVzXJqYxs1IOSHGzaGn+uGEj5G62zptI23sMSXffOHXQGxjWB8hGzmCBkrGWB5skza0ra5Tt3FzGIog8byJtd5RT0cqT1vrMdyxgu6w0CCfyJzU+ZqrOxVLsYybkVhYsfjtS0Lwueaaa9QOO+ygxo8fryZPnqwOPPDA2u+33Xab2mOPPdSkSZPy3/faay915513NqozhnpFuihDDGibnMQkpxNk8kou7aTriqd2dFEbiI/EAwM7nVHMj/9WpK+RizDt9sQ9zYbUTaWRbNJtImttIp96vJoiPsiVMJI1GGs8Q+puvh7bRVcxAdSXhhKa63NA4jBBEY+GZcHaBaochBD+EUIrjOBz5ZVXqsMPP1y9613vyoWZP/7xj+qwww7r/j5//ny19957q/XXX1/deuut6uabb1arrrpqLvwsXbpUXG84o37xeXXxQgqdublxs//Z9W44EZ+mp/rQhWj3SSYwbubTxLz+AblFnWsPJijyajaKEG8TOw+fRhp0kdtMpWicW9XlO+3beUyiBAuJSzliGxdiP2c/8wh0uODjnzt0cEfk0OduR0j70Dng8/BE7GP6IFMFXqgJueDZV45J0iCMLhqlVgBatmyZOvHEE9WFF16ojjnmmO77Lbfcsvv/999/v5o9e7Y6++yz1bRp0/J3Z5xxhtpmm23UI488ojbZZBNR3eHQaSf6aSTUFZUrW7JRuOr1lRHvpBvHg8qXT474hDGTgjG4NyoMGeGhazqfLA2/kXci3Z4djjYNB+LjR0L4zT32OjDzIYJZ6HxyIxa+csLHE9kYQ9DC8IMINlZt2KZJ8vS+s1PrL4R/hdr49AmMm2PtC648ofzWmVatAHTHHXeoxx9/XPX19akZM2aotddeW+2zzz7q7rvv7qbZbLPN1Oqrr66+8Y1vqCVLlqhFixbl/7/FFluoDTbYwFn2wMCAmjt3bu2vSjFQBuR2dqk6RXrzLvK7BPGplhUb+kY2el/9vjS+WCixDa7N+rn2uMo166bKQfqjuScaL4ghdkB0Pv59E0aKvA8VijlBUdoeatyLTa/DRlgPRY1dyCTHD+t1ywxbUeGjmg6JUO0SHKtpUKSLW1eoPV34+iz3kvrhKRSxRup28SbzOZTnovZjyDzmxneFFnweeuih/N8zzzxTnX766erqq6/ObXh22223HOXRpNVaN910k/rud7+b2wCtssoq6tprr1W/+tWv1KhRbmDrvPPOUxMnTuz+lWhRj3wbEGazEuukLSWbEWMLI6zM8JNvkQ+vqw1X6B5D59UF7Xh1hY+FVOgKMW4OUe9gpzG+zbTRLy/tSvoQ6QsqTQzjZuk6oN3ZdRwfdzm957CxaTLGrjKKd+Z4Zq3dBWenodqD1t0+75Z6i5mCj4s3h/OqTgS0Tib8usp9ScTxOeWUU164pNH9p1VYQy+s7NNOO00ddNBBavvtt1eXXnpp/vsVV1yR/6YRHq0G22mnndSf//zn3AZo6623Vvvtt1/+m4tOPfVUNWfOnO7fY489Vvsd6WjqDqfQU7yZtvr/JvLSVBJGdLVcmQiDwKR/OhF1Cgs9dWECZ3mCqp+aqXJCT2e9fLxqq1e3gr81luqP62sUpYo1l9sQwiV1uVyHfXVTl3W6hCX/esJt/vybHr52fLFqJAIA9Z3I2pLYx0h5LCUoIvxVeieZj5CLcyl01TRwt78BPyh1mL7hCDk0ovyjTa+u5Wrjc/LJJ6ujjjrKm2ajjTZSs2bNsmx6xo4dm//26KOP5s/f//731cyZM9Utt9ySq8TKdxoZ+vnPf64OPfRQsnxdjv5zUdMTRNtxfCRXJ6CMRaLqCg/2xrcj5EQQWrbU6Na1kVNpfO9c/djcUJh6x0vx9Djql1mjTbGpZ6OP2rsign8nQXwQdNJv81d/3/S03xsbdyKk7lgODxJ+JR1PbqxCnA3q77JhNm620zR1huhEmMcYKuRul5knVhyf5Sr4TJ06Nf/jSCM8Wjh54IEH1M4775y/055aWtCZPn16/rxw4cJc4Kka1JXPJWK0vNzZm0YeburVxcO5dOYQF3kKhkdOx9ikz2ADTe6dq/427K+o+iUB02K1GSFqPqGeaM3dje1GS4QYqcrALteedzEMPCV5fIccxBsLQQeRNGbdPjRMImhQ+TAe0Yli3OyOv4PzQimFfKdpk+jzOot1SOsI5nFswXZERW6eMGGCOv7443Mvreuuuy4XgN773vfmvx1yyCH5v69//evVc889p0444QR13333qXvuuSd3fdf2PbvvvvtyjdzcNPIwsrk2ubxN4p4ssZFo6vYZumkisW3kbrB4vB0qn+s5xG2zXZsnvM3xUCrKxkcFUzzEB1m3dn9xqAZiy+RTdZlzLtT42q7bLkdSd6zTflvfgHkuScrlDzgIhdl5VRFYbP6FOkz0M/xbjrLz86RtG58Vwp1dk3Zl10KMjuWjbXZ0IMMbbrghV2Vp2nzzzdVVV12lzjrrLLXjjjt2PcC0gbP2AmuDUMEH2yR9+ZAJiwtoJiTomngS9Zkf8aEYPi5AtRn8To74+Po9a6DqCj99x+kPe7NHT1IYquCrG3sXk5H6KKTNfuQjvH30nKORY796uRP1O333+WFoTkewRuIgtxIECgvVIEMqJXloRLZu4C45mHREiA/Pz6XqYle5sW5nX2EEn9GjR6uLLroo/3ORRn3033CRD46OqRZpqurimF8MwYdiPLFUXZgwkDUqO5SkZXMxlEI8MNoQfKi5at/VxTM3V92hJ7YQ1M6sC2kPkiYUyeKYPyYQuOtsKnzEmk+SukNUelzdVJqmCH2xPjvDstYkeajvNFVdMkS2Y6VBPVD9dYcf/tra52pp4ZSJGiM+MdRmMe5AQiZnqHRNbwD+PK53rjQxYirFKhtBoeg2YUJDO8bNiiUEwXAxLswIv9N6tOlYNj4hKgJf2Uj7Qox+feomyT1IIfPJrLs6TyTrPZYNiNQA2hbizWdeUo+lopWOlSn4uOYAoq4b8hpJZ1HGty3j5hCD8iT4NCDkRF9N144dCV82ql6JgfggRnb1d7htQyha0KaqK1abEOTMVUaosbf0Pi9U8GkeuRl7F9o+imKrgEJVvK5yfORCgJu6+GJjE+6gIUV8mlxBEjoH0bnT9J7AEHUdksZUb8ZyhhgKMOSXHJLQNK48I8q4+cVKyGkFRWV8J8e2GZLrpOGz2bDhaN7IE2MQMsZMoQUhBthSoTS0TRx8HGbc3Ak09sZPqiFeXSUhp7F23Nn5cpC6Yhn92uuLn+NIH7vmXOjcdaWRoIwhxrBUmuEMcOeKUeVrM7Ye+bUWItj6CFGtusptilwi81ES4BND1ey6mlASfBoQekKVoDLVdxJvC6p+V11xEZ9OdOk/BFHwl00xWWRDxgQEhF5Mxs2+NL5LD93t4Rl38zbH3Sh9FNLPIcwfOQCE8JGmYQ3C0JJ6gb55IkVYmiAC2J1kOI+SoqtNvgFJEzYHeB7XB0TvRq7zCOHnvTT8h1N8qYknXRJ8GhCqTmiqFmlq0CVZhBzZ7rcd0s2Sq9fegGSqrjJNdUxc9VfbIYVQm+Qz668+hwWcM99XGXrxY7VsyWnMLJd6xtAv/uSMMUk7rWQ+u/JQ/RUq+KDCLZKGnqvu9ph5YiE+bhVQfb1xaysWCmzmdaEaXP+ZUbZdaARSruv3F2ptdawkzhB9lX522Q75vjMEJQotx3wvKddHSfCJQFTnhzIsKp9LpUFdkRGyMKWIj29iURu25OqH8plelPzGXW8TvtEjp116bJB8nWCm7uv7kNvQ/e8yZ1+blyCa3470ReiVFS7mG/pdCJOMjfiY70IZvSRNSRKBhZpPsT0JQxCB0LHh6vaROber5BKEQnl3E88033tXe0IFPiQeHIpc+oV+Ghyoty+u/RNCSfBpQIhut8lpN2Swm6m6JDYbnWGDtZtsQMs3uCRVnz+NdK4g7ZP2B6oqxTbOTlAaySkzFpMMu3Xe3R4p0jbcqi5EVRniUVaWOzhYRYXC+0I635E00kMgl6bJNyBpbMHH3cAQHjcEXH3R1Li5SRwfHyECVLc8OGUii1APJPkmyZ/sMXi0I5p4EmHKB2sjxo5SwbF3p467fqmtjs8YNbYwhswVTB3GCzD0d9llx2kzn4YqR2IMG9v9GfmuMPf/DFgH7u+0hQ/3piCN1u2q26dicRlohzs88GlceULVrTEOIgjviR9iof6+6drrE0SZp8oNuXPO9Uy3j0+TEJ9hIhQJQE5U8s0VZ1quZ1TdgpThg5GlRoAhgqM0gGKo/ZVUKEVPUZLTd72czDpth/VHlYn7mVmI1wgyhtI2+9JweWK6SPNuwPZmGnJSDjnth6mAJGgTj875v1PGE1x5mqp/EQNepO625qSL78SK7p8FHJSovUeC+EjDbNjl4pM9CT4NCHVzxhYPhh7ZacI3YPQ26xBBDdkAMLdPaT/YglfI3UGhiE8IM6kS1ybk9C11wQ+xO2hqy+FqD3ZytvO5nql3sTaZWAbZbiQkDCFwqSx8mx5yUg4z4u44hS57Ltu8CfnOJgien2eVh4F6GxHD9FDeE7IJm3X502QtIT5KgFyGI2h0ufypMyE+L3KikI+mNj4IY2uC+Ej02u4bgH2CAG3oFtOdPcS7pt5uvmyqLIzh8JtDiCCL9DV2InerXKrzFxVWYwVRa8u4OVQFhM3pMo2vPTyKIEXjzHJceXzURL1a7RvXPVwhaFiRhm6fj0KQW3Oj9m/c+NxGyvFRE+QjFJFCvoE3bpYhPm0jtAglwedFgvggJx+KJGWbcRNkxs3ydoSe6JGyEbQAbZMrTWibqI2K26TDBKr46IkEyULyhJ2cQ21UcCQrJE2YXVJ9jJFTcFWlh9gyuQ4AoXPXlaapjQ9SrgTxaTuAof+w1BGttSaolY96c6f+vml0/z4B8kahRCEouy8N0j5Jmm5aPGkik9BTWZuogmSjQlVdIe2Nhcr4+wE5efuEjKzRqb5K0hgvuIfU8rGXiYEgtoueZMMOnWNIVl3NgXjHyBGfF1MAQ75833f66pI4cEj4j98uUWZD05b61YUKxdojhgTIpe9dLMEWS4MbaibBpwH5NkRKry0Nkhf7ri6UscS28yjJt7h8dWFlS415ffXLBCbq4j/Uw05y+ubSxIpr5DJubn7Lup0GE9ayVowlpSim+YyMcROhdHhUXXJ1uN9uxK1udeWJuSZMxKeJcXOo276rHCSNZA40Rac7wAFZMr6x7HeScfMwkX/jcG/AoWUh+SRqKa6eEDfZEHWU3wDZvVBCF3csV3kErkXbhAqhTVVdGMTsFuhiIz5SdUrbhss+asKQfYauUoRAsulJ739y1W1SqF1Q++7OYQcR3Z4QVbR0nSMUMlYh6s4QZ4ghz7y1DzwyYYnrYyTcA0UhfZ4EnwaECivtXlKKp4lJTRAfpJzQskOYT/U9VjaFRGRwPi6sf3h76DRcOU1QBS4fRyHIGoJSUd9qloO0x/de2maurhA0rpoXtWGgIrv7CFGFuMj8bjqqvF2Xr32osIuMVT1Nh0V8UL7G1Y0aN/vmMZe+SrH4hUlIGkTID/nOkDyh/ddtJ540UcgAUYsAEQrqjK7cOOnJ5CubKsf1jC6mUPjeJIRBlM+hTA25CZ0iDGHJnP0UKiDwp52y3PAxp8rxuRKj87fI23GG9Xfdroy0mdoofW2mCFWNhDLJMIPsTvBaCb3XToL4uPovdD5JNlykPZggi5fbVNWly+HusHLVHQ+1cud18QffumoLRe4IBTXz8IfmkdTloiT4NCD0xCxFZbDFYp9iXG3qlVtP7Jbk3c+uDTzUQDLkBIi4b/vsCXyGsaFjg6nIbDSA+942DYWb3AAe2kakPUiakDF0P1N5ssgGs1nrgf3cwev49sUaG5OGJzwBjuCFOinod4htTlNXcGzjxr/TnG/xjJs7zjRuAT6ut5jvomofJcFnmMh/KvOfZJEJ0p5Xl/lMV+A7WUpsfCjhqM17jGIFMGxueF5HS3xlI7rstgLrSY29w+xI3GmpcmQbJb/pYMbWcYybXZsggnyG1uXK4yNpQEwuT4nCmgEDQ+cppWpG20elCXE2CFlroXdW2e3Dv9MUUJrGeusT8EFkTdN1+fvcZ4vpoyT4DBOhcLREOME313AbA/R3e3G584S0I/RaCwRNopAv/mTRXCj1GVMi/YYYdzdBqUI96CQ3v4ecxkLbjAgx3BxqCp1jyFo9DRJGQOpxtzy8umIhPki5sVQqrjQ+w+Bm7ux8OUj7kDSSOYDxzwxuX8hh1/dOcrhB63KmxZMmChlUX3AyiqQeNiX5JjUfgZMv32yHZBE0hb6Xd9lSZhLiYt+mEBEiZEpOfj4KQZKk8a7caZpB58j6k9hGSG+1tmPphB2ohttBIgQ9bKrqQtKY7UGim/s3906jTdhVd2zBp6mqq9+xj/iivEsEW6ngkxCfFy3iE7Z4Yl/+2CvXrBvbgPzQPI8UxIb462kQexrfRh+2eWDqgSz4e6VqPbt9dpoQ9CRkriIolTQkAUIc40ROnW2qutwG7O40IcJ2U1VXyPoyqan6BFFrtB2eIPR+P7tcm1/aaw2xKeProuLEUc+h5fYJNAcI76R5jB+RpYV+nMcglASfBkQPUEeEDiAnn1j2HuhGYZ+M+M0v1AMmRNoPNW7G7AnC+6/Zjcf+NoUE3wuNmusqp14/n09igxEGt/vS8OsEY6R4myXCWnPj5pC6+Pb5CONPdEHIhmter8C1T4IuNflO5Fb1WPfQIe1D0oQcDkIC+w0JVNyh+xrHA0MiMPvK8VESfBoQxYTb8OqShJL3tZObIG4GmwWdYu12yE5YsQx+5WgS9s5F/gBpPArjqrvp3VhSmyeJqitWmxFVVwiK2HtupvazN1P3HKeRQB4hkBg3xzI8j3GfH5qGQ6ildYUg6Hae9gWfkPvaQoTftgzc+yK5+nMaiGr7fJSurBgm8gkrFPIghQRjqwd4HXpZbz2h74RaUtO7mPzXQziLHhbhMvQUJbm8MNapj7ouACHJyTS2HYmvzTL3WD6PdG4gGxFi48O1L9Za96WRCDEI6oik8dUVGy0xbVIQlSOCVPqICylSrcv17Hq3vAzcO2LeibWFeydJ020DnjQRFtHXPYFCbRdCYvSE2GRwjMV9suywNj5+r4Bmi72pABiz7JCFWI8TMlyGwkga94ky5AQZu81IOfX6/Rkl6rFquUgfSlSDoX3hOpU3Pe03GRtM1YsjLNQ7ZF5gwgc9Vj71eIgNYJj6yV2O61lq5xVP3amieBRLVNNJ8HkRUSz9dLOYKnyaUPdBV5l+WxUZOoVtQHR7qPqlp8um6hU8nx/ODoHEQ4UapH1tIT4hYxjbuBlTnzZTdYWtFXd5sXlLrPnkIsT9WSp8h5AkD0Lx0BJ+nYfEHYutcuwErOGmAjy/XmVzIl1SOkxUDlB14HzMEpkg1bJ6/+9eEK5FR5cT9uxj5u48vpNRB44mXO/TcoGF90M9fea5TyjsRBeyCfnGRrcFuVuJuwPJzBsiNFfzuTZBs+zQzRtrMy7QUWuOKhNpW/WZbjM/p8MMjvFDAtKH3PySzqd6evo9hkbzwlEIv6LeI2lKCuk/bN7yhy7ZN2QBc4DnjUjdWcA+0qtbsWReeVO/UoOfo640SPvIsvGkiUKkWWoytIFGSN2xfb+7vgG5WwjxyGnDkFiiZ6++C1UnxookasPHfJ4mSARXF7LZS1RdYcbNYXOZ68M2wyi4hJim6mnfaT++K7OsPZIDA9I+fjwp1WUW4AreaWWswuxjMtGcbM+dXbHl2OMi4+eucnx5YqFW3fLwpIlCmDA1gdr16nKn4e6NQZkagvg0basvXxsupSFMyxeNFw3Zb1Iz42afENFpZEAbEpQMg8kRNCe8buodYoiLfEPIxh0i+JQkN24216X80FNNIwmEiK3JsHIl/CosPEF9cJp6bElCYlDlhs1JXHgL4ylKEMAwrO5Q0wvXO65cb1o8aaKQiJ30BApjAIg3mOS0wRvY8qdY89spDyZJW6XebdJgWiGBCLmyYoxNmPsxnwZpH102L1S11ebYiCA1n2Pf4xYi+GDu2VkU42bsMtYmiE/8O+V4hFpqA6JY42Y0T2gaFw/2zckQFDJEYIn1DVJ+zjsj2O/SXV0vIvIFZwq18ZHCe5L4C5yE7ZLkQ13VZSiEu0+x02XWIprUiX6KkqAnWJtldgcSZhavzWWasAMCOp/992dlojaXZKZB0JxYY+Mfqw78nRLBp00UFn32ta8pWhJy+AxB8BDEx1dOW15dWcC6l6K4ksOexGzAR0nwaUChG0dTBuDL1+RSSbdNRD1hqFDRxKiTftdprWx/PnuBtw0fNy0XUYdJ3dldCGG8NuN1U+9MRIUqN5aqy4V0Nh8b+x2CxHLlxBJ2sbpla9KsyzWe3DtXmhBbyyZCIZIm9MJmifDb3j6SAXl4WyZ3uWGmBUnVNUwUykSaGm3687kTxwoRHktNIUW+sJOZL417o0fy+aLxtqWGpNvDlxsSA4pqT1NGalKvv3zzVFZ3qGBPvfOrQfkPlmxEvoOEbx5IDKl95TZRdflIrtr2P0tVIa7vlASobMMwuMlYDUfk5o6IV3WCbZkQZwSkfd52qRWAbrrppvzUTf3ddttt3XR33XWX2mWXXdS4cePUtGnT1Kc//elobUDv0kIWAUWxF7Nv0vC3tdOzv+niR8rxbWxtqkmwm4v9ZcVgiFi5OPwuNRRevqouXxq37QtH1bmBxNYJaXNsry46H705ha2nZqpkk9oYT/6ghrePShNmI9XutUFSFNKk5WHcXFIo4sMhxk3VgAiNUisAveY1r1GzZs2qvfv4xz+ufvvb36pXvvKV+fPcuXPVG97wBrXnnnuqL3/5y+rvf/+7Ovroo9WkSZPUu9/97sZtQCDZGJ5LUnWKT+fLCTaoe3JTZh5iAF3Px2/0SMwQqXEzNTYhJxAfY0AMGtsKc9C0P8w8PsLmRzOUypUGOV03NZiV3JguRT5D3LGbGMxy+dC6m9o2IgezF8NYyYybOyKDe/sbOsNu3NwP8HPEiDtGHjTNCiX4jBkzRq211lrd56VLl6qf//zn6gMf+EDX/uJ73/ueWrJkifrmN7+Zp99qq63U3/72N3XxxRe3JvjQE5Nf7L7y5XYkbmbInSRQ1AG59wlBXNq4rbkp4oMYZbdxAtFpYgm7oWmG1yC7FD5844PYDPDvXIiB37g5LuITa60gdTVFFENQz5eGcXM79lih6GoTg/sXh42PgvP4eKfLy6tNxGeFUHWZ9Itf/EI9++yz6l3velf33S233KJe+9rX5kJPSXvttZd64IEH1HPPPecsa2BgIEeLqn8UrbHGMutdpSqr86nfpkyxyyhp3Dj3JJ882Z2vTLPmmkvZNCWNGlV/scoq9bpXX73g2quvXq93lEdMHj26+Hflld0rsOwTqm9KmjRpyNn+qVPd31iePsaOzURlT57sXr1lmdVTZblYV1qp6KsxY+z85XeWfRPCTEaNKspbZRV7By3TTJky2Fp/+MbRdXotGfWkSe75usYa/DwdN06J2lxSf3+97autNmSlM/NQfYnMjfHji7rGj6+/983x8jff2EyY4P5Osw8mTsTHaurUZZ7vHGT5U9m3EyYUaVde2Zmlyy/MvqnSqqtSfK/+zlw/U6fa7SzXY7kOx48fcqYxea1vrMq+KXmib62F8LVyvvmitlNzskxv9tvEie45WpZb9sm4ce655Rsrc1zK7/XlKX/zrT3TeH211QbZPNReECL4aNXACkf77LNP/lel17/+9dm73/3u2rt77rlHj1R27733Oss644wz8jTm35w5c/LfP/e5+dmUKUuz739/QTfPO94xP1t33YHsnnsW58+LFg1m22yzKNt220XZwMBQ/u7uuweyddZZkh1xxPxuvssuK8q65JLeu2OPnZ+n++tfi7Jmz16WbbLJ4uy1r12YDQ4WZX3720W+//f/inz6/S67LMxe9rLF2XPPLcvfffe7C/I0X/hCkebZZ4tydt11Qbecgw6an62//kD2z38O5M//8z/zsjXWWJLdeOOi/Pn884t6rrxyAVnvAw8MZOutN5Ademiv/fr/9Tv9m6bf/W5RtuaaS7KTTprn7C/9r34+/PBeOaefPi+bOnVJdu21C/PnuXMHs803X5ztuOPCbNmyoVr/ld+oad99F2QbbDCQPf740vxZ96Puz2OO6aX5+MeLsn/1q6LshQsHs5e/fFG23XaLsiVLirJ/+tOi/849t5dPj50uS4+lJl2Hrmu//Xppvv71ok1f+Urv3SGHzM+mTRvIHnxwoPa9uh/KMdZjp8dQj43+22mnhdmmm/bG88tfLsr95jeLsdDz6hWvWJT/6fmm6Yc/LNp80UW9ut/0pgXZ9OkD2aOPLsmf77ij6A89z1x9rftgxoxF+Rwuy/7DH4px/NCHinHUbdx5514b9fOeey7INtpoIHvyyaLv//d/izZ/61vzu/289daLsu237/WzOYa6nDe8YUG24YYD2RNPFOX85S+Ls7XXXpK95z3znGOo58QOOyzM58i8eUWbDz643u96LHVdemw1/ec/xfjts09vLZdz/sc/Lt7p7y/7uVzLV121MK/7k5/stefd756X9+vttxdz+k9/WpSttdaS7P3vn+ec44cdVqyD++4r2nfnnQWPOProXrkf/WixJn/722JN6m/T36i/denSoj1XX12056yzirL1OOpnPa7l2tlss/raufji4jsvv9w9n37+84V5mk99ap6TP33pS0U5l15alPP739vr/c1vLvjMww8Xc/C22+zxNHkPNVfe9rY6b9HzXNf9ox8Vdet5qOejnpclj9PrUKfR67KcX7vttiDnhZonatJjpr9JjyHFq825rumKK4q19ulPz2vEe3T+6nwr5+Tee/fm5AUX1NOU61PzLN1Pmm64YVHef3q+aNLl63p0fWV/6vQ6X9mfX/1q0Tdf/aq9j2iepOmWW+rzuByXKq80+bmZR9P73jcvH/P/+78izdNPL8t5heYZ5VgdcEAxT2bOLOaJXl+6fb/4xUJnHs03dBq935XfoPe4cnz1vl3dv13U0f9Ry4lOOeUUdcEFF3jT3HfffWrzzTfvPv/73/9W06dPVz/60Y/UQQcd1H2v7Xs23HBD9ZWvfKX77t57781VXvrfLbbYwon46L+SNOKjDaPnzJmjJkyY0PALEyVKlChRokTDQXr/njhxIrt/L1cbn5NPPlkdddRR3jQbbbRR7fnSSy9Vq6++utp///1r77UN0JNPPll7Vz5X7YNMGjt2bP6XKFGiRIkSJXrp03IVfKZOnZr/oaTBKS34HHHEEWq0ofjdcccd1WmnnZYbPpe/XX/99WqzzTZTkydPjt72RIkSJUqUKNGKRyuUcfMNN9ygHn74YXXsscdavx122GG5YfMxxxyj7rnnHvXDH/5Qff7zn1cnnXTScmlrokSJEiVKlOjFRyuEO3tJ3/jGN/KYPlWbn5K0Xu+6665TJ5xwgtp+++3VlClT1Cc+8YkoruyJEiVKlChRopcGLVfj5hXZOCpRokSJEiVKtOLt3yuUqitRokSJEiVKlKgJJcEnUaJEiRIlSjRiKAk+iRIlSpQoUaIRQ0nwSZQoUaJEiRKNGEqCT6JEiRIlSpRoxFASfBIlSpQoUaJEI4aS4JMoUaJEiRIlGjGUBJ9EiRIlSpQo0YihJPgkSpQoUaJEiUYMrVBXVgwHlYGsdQTIRIkSJUqUKNGKQeW+zV1IkQQfg+bNm5f/O23atOXdlESJEiVKlCiRYB/XV1e4KN3VZdDQ0JD6z3/+o1ZddVXV6XSWd3NWaMlbC4+PPfZYuvOsIaW+jEepL+NQ6sd4lPoyHmlxRgs966yzjurrc1vyJMTHIN1Z66233vJuxkuG9EJOizkOpb6MR6kv41Dqx3iU+jIO+ZCekpJxc6JEiRIlSpRoxFASfBIlSpQoUaJEI4aS4JOoFRo7dqw644wz8n8TNaPUl/Eo9WUcSv0Yj1JfDj8l4+ZEiRIlSpQo0YihhPgkSpQoUaJEiUYMJcEnUaJEiRIlSjRiKAk+iRIlSpQoUaIRQ0nwSZQoUaJEiRKNGEqCTyKYzjzzzDyadfVv88037/6+ePFidcIJJ6jVV19drbLKKuqggw5STz75ZK2MRx99VO23335qpZVWUmussYb6yEc+opYtW6Ze6vT73/9evelNb8ojiup++9nPflb7XfsYfOITn1Brr722Gj9+vNpzzz3Vgw8+WEsze/Zs9Y53vCMPcjZp0iR1zDHHqPnz59fS3HXXXWqXXXZR48aNy6PBfvrTn1YjrS+POuooa57uvffetTSpL5U677zz1H/913/lUer1WjzwwAPVAw88UEsTa03fdNNNarvttss9lzbZZBP1rW99S420vtxtt92seXn88cfX0qS+HCbSXl2JEiF0xhlnZFtttVU2a9as7t/TTz/d/f3444/Ppk2blv32t7/N/vKXv2SvfvWrs9e85jXd35ctW5ZtvfXW2Z577pn99a9/zX75y19mU6ZMyU499dTspU76W0877bTsJz/5ifaizH7605/Wfj///POziRMnZj/72c+yO++8M9t///2zDTfcMFu0aFE3zd5775294hWvyP785z9nf/jDH7JNNtkke/vb3979fc6cOdmaa66ZveMd78juvvvu7Ac/+EE2fvz47Ctf+Uo2kvryyCOPzPuqOk9nz55dS5P6Msv22muv7NJLL82/729/+1u27777Zuuvv342f/78qGv6oYceylZaaaXspJNOyu69997skksuyfr7+7Nrr702G0l9ueuuu2bHHXdcbV7qeVZS6svhoyT4JAoSfPRmQdHzzz+fjR49Orviiiu67+677758Y7rlllvyZ72Q+/r6sieeeKKb5ktf+lI2YcKEbGBgIBspZG7WQ0ND2VprrZVdeOGFtf4cO3ZsvuFq0kxO57vtttu6aX71q19lnU4ne/zxx/Pn//3f/80mT55c68uPfvSj2WabbZa9VMkl+BxwwAHOPKkvaXrqqafyfvnd734XdU3/z//8T35gqtLb3va2XFgYKX1ZCj4nnniiM0/qy+GjpOpKFERa/aJVDBtttFGuKtDQrKbbb79dLV26NFfRlKTVYOuvv7665ZZb8mf978tf/nK15pprdtPstdde+SV999xzjxqp9PDDD6snnnii1nf6vpkddtih1ndaJfPKV76ym0an13fL3Xrrrd00r33ta9WYMWNq/ash9+eee06NJNLqAK0q2GyzzdR73/te9eyzz3Z/S31J05w5c/J/V1tttahrWqepllGmKcsYCX1Z0ve+9z01ZcoUtfXWW6tTTz1VLVy4sPtb6svho3RJaSKY9Eas9cl6M5k1a5Y666yzchuIu+++O9+49SahN5Qq6UWsf9Ok/60u6vL38reRSuW3U31T7Tu9kVdp1KhROWOtptlwww2tMsrfJk+erEYCaXuet7zlLXlf/Otf/1If+9jH1D777JNvDv39/akvCRoaGlL//d//rXbaaad8U9YUa0270ugNfdGiRblN20u9LzUddthhavr06fnBUduPffSjH80F6Z/85Cf576kvh4+S4JMIJr15lLTNNtvkgpBeyD/60Y/Sgkv0oqFDDz20+//6BK3n6sYbb5yjQHvsscdybduLlbQBsz7A3Hzzzcu7KS/Zvnz3u99dm5fakUHPRy2c6/mZaPgoqboSiUmfBDfddFP1z3/+U6211lpqyZIl6vnnn6+l0R4g+jdN+l/TI6R8LtOMRCq/neqbat899dRTtd+1t4f2Tkr96yetltXqBT1PNaW+rNP73/9+dfXVV6sbb7xRrbfeet33sda0K432qHupHZhcfUmRPjhqqs7L1JfDQ0nwSSQm7f6rTyv65LL99tur0aNHq9/+9rfd3zWMq22Adtxxx/xZ//v3v/+9tulcf/31+aLdcsst1UglrVLRDK3adxq61vYm1b7TG5C2uyjphhtuyGH1koHqNNrVW9tlVPtXqyZfaqqZEPr3v/+d2/joeaop9WVB2jZcb9Q//elP8+83VXux1rROUy2jTFOWMRL6kqK//e1v+b/VeZn6cphoGA2pE63gdPLJJ2c33XRT9vDDD2d//OMfc7dL7W6pPRhK11ftwnnDDTfkrq877rhj/me6a77hDW/IXT61C+bUqVNHhDv7vHnzchdV/aeX3cUXX5z//yOPPNJ1Z580aVL285//PLvrrrtyryTKnX3GjBnZrbfemt18883Zy172spoLtvbC0S7Yhx9+eO5We/nll+eury8lF2yuL/VvH/7wh3OvIz1Pf/Ob32Tbbbdd3leLFy/ulpH6Msve+9735iEU9JquulgvXLiwmybGmi5dsD/ykY/kXmFf/OIXX3Iu2Fxf/vOf/8zOPvvsvA/1vNTrfKONNspe+9rXdstIfTl8lASfRDBpt8m11147GzNmTLbuuuvmz3pBl6Q36fe97325G7BenG9+85vzxV+lmTNnZvvss08eE0ULTVqYWrp0afZSpxtvvDHfpM0/7XpdurR//OMfzzdb7ca+xx57ZA888ECtjGeffTbfnFdZZZXcxfVd73pXvtFXSccA2nnnnfMy9BhpgWok9aXeaPTGoTcM7Yo9ffr0PHZK1UVYU+rLIhQA9afj0cRe03rMtt1225x36A2/WsdI6MtHH300F3JWW221fD7puFFaeKnG8dGU+nJ4qKP/M1zoUqJEiRIlSpQo0fKkZOOTKFGiRIkSJRoxlASfRIkSJUqUKNGIoST4JEqUKFGiRIlGDCXBJ1GiRIkSJUo0YigJPokSJUqUKFGiEUNJ8EmUKFGiRIkSjRhKgk+iRIkSJUqUaMRQEnwSJUqUKFGiRCOGkuCTKFGi5Ur61vROp2NdhjlcpO8+2mKLLdTg4GBrdbz61a9WV155ZWvlJ0qUCKcUuTlRokTDRrvttpvadttt1ec+97nuO30DuL4Zfc0118wFoOEmfRnnSSedpN7xjne0Voe+sftDH/pQfslnX186byZKtDwprcBEiRItVxozZkx+O/3yEHpuvvlm9a9//UsddNBBrdazzz77qHnz5qlf/epXrdaTKFEinpLgkyhRomGho446Sv3ud79Tn//853MhR//NnDnTUnV961vfUpMmTcpRks0220yttNJK6uCDD1YLFy5U3/72t9UGG2ygJk+erD74wQ/W1FMDAwPqwx/+sFp33XXVyiuvrHbYYYe8bB9dfvnl6vWvf70aN25c992ZZ56Zo1Lf/OY31frrr69WWWUV9b73vS+v69Of/nQupK2xxhrqnHPO6ebRwLnOp9OPHTtWrbPOOnn7Surv71f77rtvXl+iRImWL41azvUnSpRohJAWeP7xj3+orbfeWp199tn5u6lTp+bCj0layPnCF76QCwoaKXnLW96i3vzmN+cC0S9/+Uv10EMP5SjNTjvtpN72trfled7//vere++9N8+jBY+f/vSnau+991Z///vf1cte9jKyTX/4wx/UYYcdZr3XKJBGZ6699tr8/7XgpevcdNNNc+HtT3/6kzr66KPVnnvumQtY2n7ns5/9bF73VlttpZ544gl155131sp81atepc4///xIvZkoUSIpJcEnUaJEw0ITJ07M1VoawdGoiY+WLl2qvvSlL6mNN944f9aCx3e+8x315JNP5gjMlltuqXbffXd144035oLPo48+qi699NL8Xy30aNLojxZc9Ptzzz2XrOeRRx7ppq/S0NBQjvisuuqq3bq0fY4WurSNjkaiLrjggrx+LfjoevU3aUFo9OjROfKjBZ0q6Xoee+yxvOxk55Mo0fKjtPoSJUr0oiMtHJVCjyZt+KxVXFroqb576qXQAnwAAAJpSURBVKmn8v/XqI5WRWlERqcp/zQ6oxEbFy1atKim5ipJ16WFnmpdWgCqCizV+g855JC8rI022kgdd9xxOdq0bNmyWpnjx4/PhR6tkkuUKNHyo4T4JEqU6EVHGjWpkrYBot5pQULT/Pnzczua22+/Pf+3SlVhyaQpU6ao5557rnH906ZNyxGh3/zmN+r666/PbYIuvPDCXPAq82nPNW17pAWgRIkSLT9Kgk+iRImGjbSqq414OTNmzMjL1QjMLrvsEpRP2wXFIC3QvOlNb8r/TjjhBLX55pvnSNR2222X/3733Xfn9SVKlGj5UhJ8EiVKNGykVUi33nprbtCskZjVVlstSrlaxaXj8BxxxBHqM5/5TC5gPP3003lwwm222Ubtt99+ZL699tor9xRrStoTTQte2t5Hq+m++93v5oLQ9OnTa4bUb3jDGxrXlShRomaUbHwSJUo0bKQNjrUqStvLaI8ubRQci7QRsxZ8Tj755Nz4+MADD1S33XZbbmjsIi0s3XPPPbmaqglpb7Ovfe1ruZeZFrS0yuuqq65Sq6++ev77448/nnuCvetd72pUT6JEiZpTitycKFGiEU0f+chH1Ny5c9VXvvKV1ur46Ec/mtsSffWrX22tjkSJEmGUEJ9EiRKNaDrttNNylVRpqNwG6YCHn/zkJ1srP1GiRDglxCdRokSJEiVKNGIoIT6JEiVKlChRohFDSfBJlChRokSJEo0YSoJPokSJEiVKlGjEUBJ8EiVKlChRokQjhv5/u3VMAwAMAzBsKn/QY9EesRHkzFwHAABsMT4AQIbxAQAyjA8AkGF8AIBX8QG6zPRBYjhaVgAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Workflow completed successfully\n" - ] - } - ], + "outputs": [], "source": [ "wf = WorkflowBuilder(\"NW_Ring_3Pop\")\n", "\n", @@ -490,26 +221,10 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "d0e1f2a3", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Output validation:\n", - " PopA.population: OK\n", - " PopB.population: OK\n", - " PopC.population: OK\n", - " Connectivity.network: OK\n", - " SimConfig.results: OK\n", - " Analysis.figures: OK\n", - " Analysis.firing_rate_hz: OK\n", - " Analysis.isi_stats: OK\n" - ] - } - ], + "outputs": [], "source": [ "print(\"Output validation:\")\n", "for node_name, node in workflow.nodes.items():\n", @@ -531,245 +246,10 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "f2a3b4c5", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: PopC\n", - "Executing node: PopB\n", - "Executing node: PopA\n", - "Executing node: Connectivity\n", - "Executing node: SimConfig\n", - "[NW_SimConfig] network unchanged, reusing ./results/ring_strong/network\n", - "2026-09-07 00:20:37,816 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:20:37,831 [INFO] Batch processing nodes for popC/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for popC/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:20:37,857 [INFO] Batch processing nodes for popB/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for popB/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:20:37,912 [INFO] Batch processing nodes for popA/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for popA/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:20:37,924 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:20:37,925 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:20:37,927 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:20:37,931 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:20:37,933 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:20:37,973 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:20:37,998 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: Analysis\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Re-run complete\n" - ] - } - ], + "outputs": [], "source": [ "conn.configure(syn_weight=50.0)\n", "cfg.configure(config_file=\"config_ring_strong.json\")\n", diff --git a/notebooks/NW_SingleCell_Optimization.ipynb b/notebooks/NW_SingleCell_Optimization.ipynb index 7016a210..b0250932 100644 --- a/notebooks/NW_SingleCell_Optimization.ipynb +++ b/notebooks/NW_SingleCell_Optimization.ipynb @@ -24,7 +24,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "da4f9d56", "metadata": {}, "outputs": [], @@ -59,7 +59,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "e5de1f15", "metadata": {}, "outputs": [], @@ -84,21 +84,10 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "6742a980", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "exc.configure(\n", " pop_name = \"v1\",\n", @@ -122,42 +111,20 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "353f4745", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "clamp.configure(amp_na=0.150, delay_ms=500.0, duration_ms=2000.0)" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "47ed0757", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "sim.configure(\n", " simulator = \"pointnet\",\n", @@ -188,18 +155,10 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "57202066", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "nodes: ['clamp', 'exc', 'sim', 'ana']\n" - ] - } - ], + "outputs": [], "source": [ "wf = WorkflowBuilder(\"NW_SingleCell_Optimization\")\n", "for node in [clamp, exc, sim, ana]:\n", @@ -242,23 +201,10 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "75e32e8b", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "clamp outputs: ['iclamp']\n", - "exc outputs: ['population']\n", - "sim outputs: ['results']\n", - "ana outputs: ['figures', 'firing_rate_hz', 'isi_stats']\n", - "\n", - "pop_name = v1 -> the key inside ana.firing_rate_hz\n" - ] - } - ], + "outputs": [], "source": [ "for node in [clamp, exc, sim, ana]:\n", " print(f\"{node.name:<6} outputs: {list(node._output_ports)}\")\n", @@ -289,18 +235,10 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "e21801c8", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "target measures: ana.firing_rate_hz.v1\n" - ] - } - ], + "outputs": [], "source": [ "# A handle is a reference to the node's own parameter definition, not a copy —\n", "# assigning through it edits that node's schema.\n", @@ -350,204 +288,10 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "e7e75ef8", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:root:No edges have been made for this network, skipping saving of edges file.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in ./results/opt_singlecell/network\n", - "\n", - " -- N E S T --\n", - " Copyright (C) 2004 The NEST Initiative\n", - "\n", - " Version: 3.7.0\n", - " Built: Mar 4 2025 17:27:39\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", - "2026-09-07 00:21:02,939 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:02,947 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:02,948 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:02,949 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:02,951 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:02,952 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:02,955 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:02,972 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:02,983 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - "[NW_Analysis] plot_raster skipped: Could not fine spikes file with node population \"v1\".\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "measurable values found in the baseline run:\n", - " ana.firing_rate_hz.v1 0\n", - " ana.isi_stats.v1.cv 0\n", - " ana.isi_stats.v1.mean_ms 0\n", - " ana.isi_stats.v1.n_intervals 0\n", - " ana.isi_stats.v1.std_ms 0\n", - " clamp.iclamp.amp 0.15\n", - " clamp.iclamp.delay 500\n", - " clamp.iclamp.duration 2000\n", - "\n", - "algorithm : cmaes (pop_size=6, max_generations=8)\n", - "dimensions: 3\n", - " clamp.amp_na [0.0, 800.0] nA\n", - " exc.nest_params.I_e [0.0, 800.0]\n", - " exc.nest_params.V_th [-60.0, -45.0]\n", - "objectives: 1\n", - " exc.mean_firing_rate in [8.0, 12.0] Hz <- ana.firing_rate_hz.v1\n" - ] - } - ], + "outputs": [], "source": [ "spec = build_spec(\n", " workflow,\n", @@ -594,6372 +338,10 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "9f20da7d", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[opt_20260907_002103] cmaes: 3 dimensions, 1 objective(s), up to 8 generations x 6 candidates\n", - " algorithm : cmaes (pop_size=6, max_generations=8)\n", - " dimensions: 3\n", - " clamp.amp_na [0.0, 800.0] nA\n", - " exc.nest_params.I_e [0.0, 800.0]\n", - " exc.nest_params.V_th [-60.0, -45.0]\n", - " objectives: 1\n", - " exc.mean_firing_rate in [8.0, 12.0] Hz <- ana.firing_rate_hz.v1\n", - " reusing network from ./results/opt_singlecell\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0001/network\n", - "2026-09-07 00:21:03,398 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,402 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,404 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,405 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,405 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,406 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,408 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,427 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,439 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 1/6 (#1): clamp.amp_na=333.6 nA exc.nest_params.I_e=576.3 exc.nest_params.V_th=-60 -> mean_firing_rate=169 Hz (off 157 Hz) <- best so far\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0002/network\n", - "2026-09-07 00:21:03,450 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,454 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,455 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,455 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,457 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,457 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,460 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,479 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,490 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 2/6 (#2): clamp.amp_na=241.9 nA exc.nest_params.I_e=117.4 exc.nest_params.V_th=-58.61 -> mean_firing_rate=37.33 Hz (off 25.33 Hz) <- best so far\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0003/network\n", - "2026-09-07 00:21:03,504 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,543 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,544 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,545 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,547 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,547 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,550 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,570 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,583 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 3/6 (#3): clamp.amp_na=149 nA exc.nest_params.I_e=276.4 exc.nest_params.V_th=-54.05 -> mean_firing_rate=22.33 Hz (off 10.33 Hz) <- best so far\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0004/network\n", - "2026-09-07 00:21:03,594 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,597 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,599 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,600 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,601 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,601 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,604 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,622 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,633 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 4/6 (#4): clamp.amp_na=431.1 nA exc.nest_params.I_e=335.4 exc.nest_params.V_th=-49.72 -> mean_firing_rate=51.67 Hz (off 39.67 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0005/network\n", - "2026-09-07 00:21:03,644 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,648 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,650 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,651 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,652 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,653 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,655 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,674 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,686 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 5/6 (#5): clamp.amp_na=163.6 nA exc.nest_params.I_e=702.5 exc.nest_params.V_th=-59.59 -> mean_firing_rate=168.7 Hz (off 156.7 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0006/network\n", - "2026-09-07 00:21:03,697 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,700 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,702 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,703 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,704 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,704 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,707 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,725 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,737 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 6/6 (#6): clamp.amp_na=536.4 nA exc.nest_params.I_e=333.8 exc.nest_params.V_th=-51.62 -> mean_firing_rate=69.67 Hz (off 57.67 Hz)\n", - " gen 1/8: best clamp.amp_na=149 nA exc.nest_params.I_e=276.4 exc.nest_params.V_th=-54.05 -> mean_firing_rate=22.33 Hz [target 8.0-12.0 Hz, off 10.33 Hz]\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0007/network\n", - "2026-09-07 00:21:03,755 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,759 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,760 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,761 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,762 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,763 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,766 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,785 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,796 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 1/6 (#7): clamp.amp_na=334.1 nA exc.nest_params.I_e=491.1 exc.nest_params.V_th=-53.2 -> mean_firing_rate=88 Hz (off 76 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0008/network\n", - "2026-09-07 00:21:03,807 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,811 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,812 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,813 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,815 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,815 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,818 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,837 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,848 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 2/6 (#8): clamp.amp_na=459.4 nA exc.nest_params.I_e=362.6 exc.nest_params.V_th=-57.19 -> mean_firing_rate=109.3 Hz (off 97.33 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0009/network\n", - "2026-09-07 00:21:03,859 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,863 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,864 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,865 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,866 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,867 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,870 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,888 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,899 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 3/6 (#9): clamp.amp_na=312.5 nA exc.nest_params.I_e=408.2 exc.nest_params.V_th=-50.88 -> mean_firing_rate=51.67 Hz (off 39.67 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0010/network\n", - "2026-09-07 00:21:03,911 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,915 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,916 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,918 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,919 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,920 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,922 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,940 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,952 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 4/6 (#10): clamp.amp_na=206.3 nA exc.nest_params.I_e=412.7 exc.nest_params.V_th=-51.63 -> mean_firing_rate=43 Hz (off 31 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0011/network\n", - "2026-09-07 00:21:03,962 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,966 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,967 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,968 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,969 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,970 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,972 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:03,991 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,003 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 5/6 (#11): clamp.amp_na=188.5 nA exc.nest_params.I_e=483.7 exc.nest_params.V_th=-50.93 -> mean_firing_rate=53.67 Hz (off 41.67 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0012/network\n", - "2026-09-07 00:21:04,014 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,019 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,020 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,021 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,022 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,022 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,025 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,044 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,056 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 6/6 (#12): clamp.amp_na=479.5 nA exc.nest_params.I_e=440.7 exc.nest_params.V_th=-56.5 -> mean_firing_rate=121 Hz (off 109 Hz)\n", - " gen 2/8: best clamp.amp_na=149 nA exc.nest_params.I_e=276.4 exc.nest_params.V_th=-54.05 -> mean_firing_rate=22.33 Hz [target 8.0-12.0 Hz, off 10.33 Hz]\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0013/network\n", - "2026-09-07 00:21:04,070 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,074 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,076 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,077 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,078 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,078 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,081 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,100 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,112 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 1/6 (#13): clamp.amp_na=460.7 nA exc.nest_params.I_e=316 exc.nest_params.V_th=-49.29 -> mean_firing_rate=51.33 Hz (off 39.33 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0014/network\n", - "2026-09-07 00:21:04,127 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,130 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,131 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,132 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,134 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,135 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,137 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,156 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,167 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 2/6 (#14): clamp.amp_na=623.8 nA exc.nest_params.I_e=404.7 exc.nest_params.V_th=-52.83 -> mean_firing_rate=89 Hz (off 77 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0015/network\n", - "2026-09-07 00:21:04,179 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,182 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,184 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,185 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,186 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,187 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,189 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,208 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,222 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 3/6 (#15): clamp.amp_na=326.6 nA exc.nest_params.I_e=276.8 exc.nest_params.V_th=-55.24 -> mean_firing_rate=58 Hz (off 46 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0016/network\n", - "2026-09-07 00:21:04,233 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,237 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,238 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,239 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,240 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,241 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,244 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,262 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,271 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 4/6 (#16): clamp.amp_na=43.5 nA exc.nest_params.I_e=379.1 exc.nest_params.V_th=-47.92 -> mean_firing_rate=0 Hz (off 8 Hz) <- best so far\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0017/network\n", - "2026-09-07 00:21:04,283 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,287 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,288 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,289 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,290 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,291 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,294 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,313 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,324 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 5/6 (#17): clamp.amp_na=373.4 nA exc.nest_params.I_e=588.6 exc.nest_params.V_th=-50.83 -> mean_firing_rate=92.33 Hz (off 80.33 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0018/network\n", - "2026-09-07 00:21:04,336 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,340 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,341 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,342 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,343 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,344 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,346 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,365 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,377 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 6/6 (#18): clamp.amp_na=269.9 nA exc.nest_params.I_e=569.8 exc.nest_params.V_th=-51.25 -> mean_firing_rate=82.33 Hz (off 70.33 Hz)\n", - " gen 3/8: best clamp.amp_na=43.5 nA exc.nest_params.I_e=379.1 exc.nest_params.V_th=-47.92 -> mean_firing_rate=0 Hz [target 8.0-12.0 Hz, off 8 Hz]\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0019/network\n", - "2026-09-07 00:21:04,394 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,397 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,399 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,400 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,401 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,402 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,404 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,423 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,434 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 1/6 (#19): clamp.amp_na=140.2 nA exc.nest_params.I_e=482.3 exc.nest_params.V_th=-48.31 -> mean_firing_rate=29.67 Hz (off 17.67 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0020/network\n", - "2026-09-07 00:21:04,445 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,449 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,450 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,452 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,453 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,454 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,456 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,474 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,488 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 2/6 (#20): clamp.amp_na=168.5 nA exc.nest_params.I_e=322.5 exc.nest_params.V_th=-51.6 -> mean_firing_rate=22.33 Hz (off 10.33 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0021/network\n", - "2026-09-07 00:21:04,499 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,503 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,505 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,506 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,507 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,508 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,511 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,531 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,544 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 3/6 (#21): clamp.amp_na=513.6 nA exc.nest_params.I_e=453.4 exc.nest_params.V_th=-50.44 -> mean_firing_rate=73.33 Hz (off 61.33 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0022/network\n", - "2026-09-07 00:21:04,555 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,559 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,561 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,562 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,563 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,564 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,568 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,587 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,598 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 4/6 (#22): clamp.amp_na=240.4 nA exc.nest_params.I_e=345.4 exc.nest_params.V_th=-51.23 -> mean_firing_rate=36.67 Hz (off 24.67 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0023/network\n", - "2026-09-07 00:21:04,607 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,611 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,613 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,614 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,615 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,616 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,619 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,639 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,651 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 5/6 (#23): clamp.amp_na=343.5 nA exc.nest_params.I_e=435.4 exc.nest_params.V_th=-51.72 -> mean_firing_rate=61.33 Hz (off 49.33 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0024/network\n", - "2026-09-07 00:21:04,662 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,666 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,667 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,669 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,670 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,671 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,674 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,693 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,704 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 6/6 (#24): clamp.amp_na=306 nA exc.nest_params.I_e=461.9 exc.nest_params.V_th=-50.18 -> mean_firing_rate=54 Hz (off 42 Hz)\n", - " gen 4/8: best clamp.amp_na=43.5 nA exc.nest_params.I_e=379.1 exc.nest_params.V_th=-47.92 -> mean_firing_rate=0 Hz [target 8.0-12.0 Hz, off 8 Hz]\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0025/network\n", - "2026-09-07 00:21:04,719 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,722 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,724 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,725 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,726 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,727 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,730 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,749 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,761 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 1/6 (#25): clamp.amp_na=443.2 nA exc.nest_params.I_e=643.2 exc.nest_params.V_th=-51.31 -> mean_firing_rate=108.7 Hz (off 96.67 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0026/network\n", - "2026-09-07 00:21:04,770 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,773 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,775 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,776 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,777 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,778 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,780 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,799 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,810 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 2/6 (#26): clamp.amp_na=366.7 nA exc.nest_params.I_e=454.9 exc.nest_params.V_th=-54.35 -> mean_firing_rate=93.67 Hz (off 81.67 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0027/network\n", - "2026-09-07 00:21:04,819 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,823 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,825 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,826 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,827 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,828 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,830 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,849 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,861 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 3/6 (#27): clamp.amp_na=191.4 nA exc.nest_params.I_e=498.1 exc.nest_params.V_th=-51.63 -> mean_firing_rate=63.33 Hz (off 51.33 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0028/network\n", - "2026-09-07 00:21:04,871 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,875 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,877 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,878 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,879 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,880 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,883 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,902 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,914 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 4/6 (#28): clamp.amp_na=136 nA exc.nest_params.I_e=323 exc.nest_params.V_th=-52.08 -> mean_firing_rate=17 Hz (off 5 Hz) <- best so far\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0029/network\n", - "2026-09-07 00:21:04,927 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,930 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,932 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,933 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,935 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,935 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,938 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,957 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,969 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 5/6 (#29): clamp.amp_na=178.8 nA exc.nest_params.I_e=347.5 exc.nest_params.V_th=-53.38 -> mean_firing_rate=38 Hz (off 26 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0030/network\n", - "2026-09-07 00:21:04,981 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,985 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,987 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,988 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,989 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,990 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:04,993 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,012 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,027 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 6/6 (#30): clamp.amp_na=291.7 nA exc.nest_params.I_e=389.9 exc.nest_params.V_th=-54.56 -> mean_firing_rate=71 Hz (off 59 Hz)\n", - " gen 5/8: best clamp.amp_na=136 nA exc.nest_params.I_e=323 exc.nest_params.V_th=-52.08 -> mean_firing_rate=17 Hz [target 8.0-12.0 Hz, off 5 Hz]\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0031/network\n", - "2026-09-07 00:21:05,045 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,049 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,051 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,052 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,053 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,054 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,056 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,075 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,085 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 1/6 (#31): clamp.amp_na=166.9 nA exc.nest_params.I_e=353.2 exc.nest_params.V_th=-46.26 -> mean_firing_rate=0 Hz (off 8 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0032/network\n", - "2026-09-07 00:21:05,097 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,101 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,102 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,103 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,104 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,105 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,108 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,127 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,137 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 2/6 (#32): clamp.amp_na=120.7 nA exc.nest_params.I_e=209.2 exc.nest_params.V_th=-49 -> mean_firing_rate=0 Hz (off 8 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0033/network\n", - "2026-09-07 00:21:05,148 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,152 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,154 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,155 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,156 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,157 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,160 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,178 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,188 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 3/6 (#33): clamp.amp_na=157.9 nA exc.nest_params.I_e=312 exc.nest_params.V_th=-48.99 -> mean_firing_rate=0 Hz (off 8 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0034/network\n", - "2026-09-07 00:21:05,199 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,203 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,205 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,206 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,207 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,208 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,211 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,230 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,241 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 4/6 (#34): clamp.amp_na=305.8 nA exc.nest_params.I_e=509.2 exc.nest_params.V_th=-48.92 -> mean_firing_rate=53.33 Hz (off 41.33 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0035/network\n", - "2026-09-07 00:21:05,253 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,257 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,259 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,260 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,262 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,262 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,265 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,283 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,293 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 5/6 (#35): clamp.amp_na=145.7 nA exc.nest_params.I_e=177.1 exc.nest_params.V_th=-51.25 -> mean_firing_rate=0 Hz (off 8 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0036/network\n", - "2026-09-07 00:21:05,305 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,309 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,311 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,312 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,313 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,314 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,317 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,336 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,347 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 6/6 (#36): clamp.amp_na=166.4 nA exc.nest_params.I_e=442.6 exc.nest_params.V_th=-50.24 -> mean_firing_rate=35.67 Hz (off 23.67 Hz)\n", - " gen 6/8: best clamp.amp_na=136 nA exc.nest_params.I_e=323 exc.nest_params.V_th=-52.08 -> mean_firing_rate=17 Hz [target 8.0-12.0 Hz, off 5 Hz]\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0037/network\n", - "2026-09-07 00:21:05,363 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,367 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,369 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,370 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,372 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,372 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,375 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,394 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,406 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 7, trial 1/6 (#37): clamp.amp_na=362.4 nA exc.nest_params.I_e=507.3 exc.nest_params.V_th=-53.37 -> mean_firing_rate=94.67 Hz (off 82.67 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0038/network\n", - "2026-09-07 00:21:05,418 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,422 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,423 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,424 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,426 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,427 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,430 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,448 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,461 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 7, trial 2/6 (#38): clamp.amp_na=181.2 nA exc.nest_params.I_e=491.8 exc.nest_params.V_th=-49.82 -> mean_firing_rate=42 Hz (off 30 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0039/network\n", - "2026-09-07 00:21:05,482 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,486 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,488 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,489 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,490 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,491 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,494 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,513 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,524 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 7, trial 3/6 (#39): clamp.amp_na=221.9 nA exc.nest_params.I_e=319.4 exc.nest_params.V_th=-48.07 -> mean_firing_rate=0 Hz (off 8 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0040/network\n", - "2026-09-07 00:21:05,535 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,540 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,541 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,543 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,544 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,545 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,548 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,566 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,579 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 7, trial 4/6 (#40): clamp.amp_na=310.5 nA exc.nest_params.I_e=311.4 exc.nest_params.V_th=-49.57 -> mean_firing_rate=34.67 Hz (off 22.67 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0041/network\n", - "2026-09-07 00:21:05,590 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,594 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,596 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,597 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,598 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,599 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,603 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,621 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,634 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 7, trial 5/6 (#41): clamp.amp_na=122 nA exc.nest_params.I_e=560.2 exc.nest_params.V_th=-50.88 -> mean_firing_rate=62.67 Hz (off 50.67 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0042/network\n", - "2026-09-07 00:21:05,644 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,648 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,650 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,652 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,653 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,654 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,658 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,677 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,689 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 7, trial 6/6 (#42): clamp.amp_na=270.8 nA exc.nest_params.I_e=250.7 exc.nest_params.V_th=-52.19 -> mean_firing_rate=31.33 Hz (off 19.33 Hz)\n", - " gen 7/8: best clamp.amp_na=136 nA exc.nest_params.I_e=323 exc.nest_params.V_th=-52.08 -> mean_firing_rate=17 Hz [target 8.0-12.0 Hz, off 5 Hz]\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0043/network\n", - "2026-09-07 00:21:05,707 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,711 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,712 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,714 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,715 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,716 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,719 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,738 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,748 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 8, trial 1/6 (#43): clamp.amp_na=20.53 nA exc.nest_params.I_e=385.6 exc.nest_params.V_th=-52.15 -> mean_firing_rate=0 Hz (off 8 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0044/network\n", - "2026-09-07 00:21:05,758 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,762 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,764 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,765 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,767 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,768 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,771 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,789 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,799 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 8, trial 2/6 (#44): clamp.amp_na=181.8 nA exc.nest_params.I_e=277.9 exc.nest_params.V_th=-45.65 -> mean_firing_rate=0 Hz (off 8 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0045/network\n", - "2026-09-07 00:21:05,811 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,815 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,816 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,818 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,819 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,820 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,823 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,842 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,854 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 8, trial 3/6 (#45): clamp.amp_na=411.8 nA exc.nest_params.I_e=343.9 exc.nest_params.V_th=-45.97 -> mean_firing_rate=37.33 Hz (off 25.33 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0046/network\n", - "2026-09-07 00:21:05,866 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,870 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,872 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,873 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,874 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,876 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,879 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,897 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,910 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 8, trial 4/6 (#46): clamp.amp_na=562.7 nA exc.nest_params.I_e=324 exc.nest_params.V_th=-51.73 -> mean_firing_rate=71.67 Hz (off 59.67 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0047/network\n", - "2026-09-07 00:21:05,921 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,927 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,929 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,930 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,932 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,932 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,936 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,955 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,964 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 8, trial 5/6 (#47): clamp.amp_na=393.3 nA exc.nest_params.I_e=127.7 exc.nest_params.V_th=-47.11 -> mean_firing_rate=0 Hz (off 8 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0048/network\n", - "2026-09-07 00:21:05,976 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,980 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,981 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,983 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,985 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,985 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:05,988 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:06,007 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:06,020 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 8, trial 6/6 (#48): clamp.amp_na=245.1 nA exc.nest_params.I_e=429.6 exc.nest_params.V_th=-52.33 -> mean_firing_rate=52.67 Hz (off 40.67 Hz)\n", - " gen 8/8: best clamp.amp_na=136 nA exc.nest_params.I_e=323 exc.nest_params.V_th=-52.08 -> mean_firing_rate=17 Hz [target 8.0-12.0 Hz, off 5 Hz]\n", - "[opt_20260907_002103] stopped: generation budget exhausted\n", - " exc.mean_firing_rate = 17 Hz (target 8.0-12.0 Hz, off 5 Hz)\n" - ] - } - ], + "outputs": [], "source": [ "ana.configure(plot_raster=False, plot_traces=False)\n", "\n", @@ -6987,31 +369,10 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "9e747647", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "stop reason: generation budget exhausted\n", - "run dir : results/opt_singlecell/optimization/opt_20260907_002103\n", - "\n", - "best trial: 28\n", - " clamp.amp_na 136\n", - " exc.nest_params.I_e 323\n", - " exc.nest_params.V_th -52.08\n", - " measured: {'exc.mean_firing_rate': 17.0}\n", - " distance from target (raw, per objective): [5.0]\n", - "\n", - "equivalent code:\n", - "\n", - "clamp.configure(amp_na=136.0280981926223)\n", - "exc.configure(nest_params={**exc._parameters[\"nest_params\"], \"I_e\": 323.0420933149711, \"V_th\": -52.084990627197})\n" - ] - } - ], + "outputs": [], "source": [ "print(\"stop reason:\", result.stop_reason)\n", "print(\"run dir :\", result.run_dir)\n", @@ -7028,20 +389,10 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "af33b70f", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "state : done - generation budget exhausted\n", - "evaluations: 48 | failed: 0 | rejected: 0\n", - "convergence: [2.583333, 2.583333, 2.0, 2.0, 1.25, 1.25, 1.25, 1.25] (how far the worst objective missed, as a multiple of its target range; 0 = target met)\n" - ] - } - ], + "outputs": [], "source": [ "import json\n", "\n", @@ -7076,28 +427,10 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "46baac78", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "48 scored trials, 0 inside the target band, smallest distance 5 Hz\n" - ] - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "\n", @@ -7199,151 +532,10 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "7e2f6a95", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing results/opt_singlecell/optimization/opt_20260907_002103/trials/0048/network\n", - "2026-09-07 00:21:06,232 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:06,236 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:06,237 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:06,239 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:06,240 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:06,241 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:06,245 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:06,264 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 00:21:06,275 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - "amp_na = 136.0280981926223\n", - "nest_params = {'C_m': 250.0, 'tau_m': 10.0, 't_ref': 2.0, 'V_th': -52.084990627197, 'V_reset': -70.0, 'E_L': -70.0, 'I_e': 323.0420933149711}\n", - "firing rate = {'v1': 17.0}\n" - ] - } - ], + "outputs": [], "source": [ "result.apply_best(workflow, execute=True)\n", "\n", diff --git a/notebooks/NW_SingleCell_PointNeuron.ipynb b/notebooks/NW_SingleCell_PointNeuron.ipynb index 8962b1aa..4b271c5d 100644 --- a/notebooks/NW_SingleCell_PointNeuron.ipynb +++ b/notebooks/NW_SingleCell_PointNeuron.ipynb @@ -22,7 +22,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "85d3ef74", "metadata": {}, "outputs": [], @@ -44,18 +44,10 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "8b299142", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'name': 'Population', 'type': 'nw_population', 'description': \"Creates a BMTK NetworkBuilder population and passes the live builder object to NW_Connectivity (for inter-population edges) or directly to NW_SimConfig. build() and save() are called by NW_SimConfig, following BMTK's own sequence.\", 'parameters': {'pop_name': 'v1', 'N': 1, 'ei_type': 'exc', 'location': 'VISp', 'layer': 'L4', 'model_type': 'point_neuron', 'model_template': 'nest:iaf_psc_alpha', 'nest_params': {'C_m': 250.0, 'tau_m': 10.0, 't_ref': 2.0, 'V_th': -55.0, 'V_reset': -70.0, 'E_L': -70.0}, 'mean_firing_rate': 10.0, 'dynamics_params_file': '', 'model_processing': '', 'morphology': '', 'mechanisms_source': '', 'hoc_template': ''}, 'optimizable_parameters': {}, 'input_ports': {'iclamp': {'type': 'dict', 'description': 'Current clamp dict from NW_IClamp (keys: amp, delay, duration). Passed through to NW_SimConfig via the population output.', 'optional': True}}, 'output_ports': {'population': {'type': 'object', 'description': 'Dict with: builder (live NetworkBuilder), pop_name (str), network_dir (str), and optionally _current_clamp (dict). Consumed by NW_Connectivity or NW_SimConfig.'}}, 'process_steps': [{'name': 'build', 'description': \"Create NetworkBuilder, add nodes, resolve dynamics params, copy biophysical source files. Does not call net.build() or net.save() — that is NW_SimConfig's responsibility.\", 'inputs': ['iclamp'], 'outputs': ['population'], 'method_key': 'build'}], 'methods': {'build': \"Create NetworkBuilder, add nodes, resolve dynamics params, copy biophysical source files. Does not call net.build() or net.save() — that is NW_SimConfig's responsibility.\"}}\n" - ] - } - ], + "outputs": [], "source": [ "pop = NW_Population(\"Population\")\n", "cfg = NW_SimConfig(\"SimConfig\")\n", @@ -67,39 +59,10 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "8f1cb70e-b7f1-41a2-ba73-89c91b5176c0", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'pop_name': 'v1',\n", - " 'N': 1,\n", - " 'ei_type': 'exc',\n", - " 'location': 'VISp',\n", - " 'layer': 'L4',\n", - " 'model_type': 'point_neuron',\n", - " 'model_template': 'nest:iaf_psc_alpha',\n", - " 'nest_params': {'C_m': 250.0,\n", - " 'tau_m': 10.0,\n", - " 't_ref': 2.0,\n", - " 'V_th': -55.0,\n", - " 'V_reset': -70.0,\n", - " 'E_L': -70.0},\n", - " 'mean_firing_rate': 10.0,\n", - " 'dynamics_params_file': '',\n", - " 'model_processing': '',\n", - " 'morphology': '',\n", - " 'mechanisms_source': '',\n", - " 'hoc_template': ''}" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "pop._parameters" ] @@ -119,31 +82,10 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "4db97f3c", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "pop_name = 'v1'\n", - "N = 1\n", - "ei_type = 'exc'\n", - "location = 'VISp'\n", - "layer = 'L4'\n", - "model_type = 'point_neuron'\n", - "model_template = 'nest:iaf_psc_alpha'\n", - "nest_params = {'C_m': 250.0, 'tau_m': 10.0, 't_ref': 2.0, 'V_th': -55.0, 'V_reset': -70.0, 'E_L': -70.0}\n", - "mean_firing_rate = 10.0\n", - "dynamics_params_file = ''\n", - "model_processing = ''\n", - "morphology = ''\n", - "mechanisms_source = ''\n", - "hoc_template = ''\n" - ] - } - ], + "outputs": [], "source": [ "# Parameters and their current values (these are the defaults until you call configure())\n", "for name, value in pop.get_info()['parameters'].items():\n", @@ -152,19 +94,10 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "8bfc1066", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[in] iclamp (dict, optional=True) -- Current clamp dict from NW_IClamp (keys: amp, delay, duration). Passed through to NW_SimConfig via the population output.\n", - "[out] population (object) -- Dict with: builder (live NetworkBuilder), pop_name (str), network_dir (str), and optionally _current_clamp (dict). Consumed by NW_Connectivity or NW_SimConfig.\n" - ] - } - ], + "outputs": [], "source": [ "# Input ports (what the node consumes) and output ports (what it produces),\n", "# with their data type and a scientific description.\n", @@ -177,18 +110,10 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "beb88986", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "build: Create NetworkBuilder, add nodes, resolve dynamics params, copy biophysical source files. Does not call net.build() or net.save() — that is NW_SimConfig's responsibility.\n" - ] - } - ], + "outputs": [], "source": [ "# Methods the node exposes (from its schema) and what each one does.\n", "for name, description in pop.get_info()['methods'].items():\n", @@ -197,18 +122,10 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "8cb8261c", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "build inputs=['iclamp'] -> outputs=['population']\n" - ] - } - ], + "outputs": [], "source": [ "# Process steps: the order the methods run in, and which ports each reads / writes.\n", "for step in pop.get_info()['process_steps']:\n", @@ -217,22 +134,10 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "7abb5871", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "type : nw_population\n", - "stage : population\n", - "tool : BMTK\n", - "model_source: https://alleninstitute.github.io/bmtk/\n", - "description : Creates a BMTK NetworkBuilder population and passes the live builder object to NW_Connectivity (for inter-population edges) or directly to NW_SimConfig. build() and save() are called by NW_SimConfig, following BMTK's own sequence.\n" - ] - } - ], + "outputs": [], "source": [ "# The schema itself (NODE_DEFINITION): the stage in the pipeline, the simulator/tool,\n", "# the source model it implements, and a one-line scientific description.\n", @@ -246,19 +151,10 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "4676db57", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "output port \"population\": None\n", - "input port \"iclamp\" : None\n" - ] - } - ], + "outputs": [], "source": [ "# Read a single port's value through its accessor.\n", "# NOTE: port values are None until the workflow is built and executed (Section 3).\n", @@ -282,21 +178,10 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "2294029f", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "pop.configure(\n", " pop_name = \"v1\",\n", @@ -352,31 +237,10 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "f6d0be6a-b9ad-44c0-8d32-0f534351ee65", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'simulator': 'pointnet',\n", - " 'config_file': 'config_pointneuron.json',\n", - " 'tstop_ms': 3000.0,\n", - " 'dt_ms': 0.1,\n", - " 'reports': {'v_report': {'variable_name': 'V_m',\n", - " 'cells': 'all',\n", - " 'module': 'membrane_report',\n", - " 'sections': 'soma'}},\n", - " 'compile_mechanisms': False,\n", - " 'overwrite': True,\n", - " 'rebuild_network': 'auto'}" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "cfg._parameters" ] @@ -391,181 +255,10 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "e332cb3a", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: IClamp\n", - "Executing node: Population\n", - "Executing node: SimConfig\n", - "[NW_SimConfig] network unchanged, reusing ./results/run1/network\n", - "\n", - " -- N E S T --\n", - " Copyright (C) 2004 The NEST Initiative\n", - "\n", - " Version: 3.7.0\n", - " Built: Mar 4 2025 17:27:39\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", - "2026-09-07 08:48:30,142 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 08:48:30,151 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 08:48:30,152 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 08:48:30,153 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 08:48:30,154 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 08:48:30,154 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 08:48:30,157 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 08:48:30,176 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 08:48:30,186 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: Analysis\n", - "[NW_Analysis] plot_raster skipped: Could not fine spikes file with node population \"v1\".\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Workflow completed successfully\n" - ] - } - ], + "outputs": [], "source": [ "wf = WorkflowBuilder(\"NW_SingleCell_PointNeuron\")\n", "wf.add_node(clamp)\n", @@ -599,19 +292,10 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "97a306c7", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "nodes : 4 -> ['IClamp', 'Population', 'SimConfig', 'Analysis']\n", - "connections: 3 edges\n" - ] - } - ], + "outputs": [], "source": [ "# How many nodes and connections (edges) does the workflow have?\n", "print('nodes :', len(workflow.nodes), '->', list(workflow.nodes))\n", @@ -620,20 +304,10 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "80ac8fe2", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "IClamp.iclamp -> Population.iclamp\n", - "Population.population -> SimConfig.populations\n", - "SimConfig.results -> Analysis.results\n" - ] - } - ], + "outputs": [], "source": [ "# List every connection (edge): source node.port -> target node.port\n", "for c in workflow.connections:\n", @@ -642,19 +316,10 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "9a60c337", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "execution order: IClamp -> Population -> SimConfig -> Analysis\n", - "valid workflow : True\n" - ] - } - ], + "outputs": [], "source": [ "# Execution order (topological) and a validity check of the graph.\n", "print('execution order:', ' -> '.join(workflow.get_info()['execution_order']))\n", @@ -671,24 +336,10 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "id": "934ce8d4", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Output validation:\n", - " IClamp.iclamp: OK\n", - " Population.population: OK\n", - " SimConfig.results: OK\n", - " Analysis.figures: OK\n", - " Analysis.firing_rate_hz: OK\n", - " Analysis.isi_stats: OK\n" - ] - } - ], + "outputs": [], "source": [ "print(\"Output validation:\")\n", "for node_name, node in workflow.nodes.items():\n", @@ -707,175 +358,10 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "7e1db1f1", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: IClamp\n", - "Executing node: Population\n", - "Executing node: SimConfig\n", - "[NW_SimConfig] network unchanged, reusing ./results/run2/network\n", - "2026-09-07 08:48:32,233 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 08:48:32,242 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 08:48:32,244 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 08:48:32,245 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 08:48:32,247 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 08:48:32,248 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 08:48:32,252 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 08:48:32,271 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 08:48:32,284 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: Analysis\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAksAAAHHCAYAAACvJxw8AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAlP9JREFUeJztnQecVcX1x8/bztI7qEgRBUGRomAXLBSNxhoriPrHqBgMoBFEI2IEFSUxfowliaDRBDWW2GIEFRsIloBSLYAgVYqU7eX9P2du5pXdV2bOfXfe3Lvn+/msK7tv3nkzd/bO755z5kwoHA6HgWEYhmEYhklITuIfMwzDMAzDMAiLJYZhGIZhmBSwWGIYhmEYhkkBiyWGYRiGYZgUsFhiGIZhGIZJAYslhmEYhmGYFLBYYhiGYRiGSQGLJYZhGIZhmBSwWGIYhmEYhkkBiyWGYRiGYZgUsFhiGIZJw5YtW2DSpEkwZMgQaNq0KYRCIViwYEG2PxbDMIZgscQwDJOGNWvWwH333QebNm2CI488Mtsfh2EYw7BYYhiGScOAAQNg586d8PXXX8OECROy/XEYhjEMiyWGYRos//znP0VI7f3336/3u8cff1z8bvny5SL01qpVq6x8RoZhsg+LJYZhGixnnXUWNGnSBJ5//vl6v3vuueegd+/ecMQRR2TlszEMYw8slhiGabA0atQIzj77bOFhqqmpifx869atwtt08cUXZ/XzMQxjByyWGIZp0KAg2r59e9zuNhRPtbW1LJYYhhGwWGIYpkEzfPhwaN68uQi7SfD/+/btC4cddlhWPxvDMHbAYolhmAZNYWEhnHvuufDyyy9DdXW1KA/w8ccfs1eJYZgILJYYhmnwoDDasWMHvPPOO/DCCy9AOBxmscQwTIS86P8yDMM0TE4//XRRGgDDb6tWrYKBAwdC165ds/2xGIaxBBZLDMM0ePLz8+H888+HuXPnQklJCTzwwAP1XvO73/1OfF+xYoX4/re//Q0++ugj8f+333674U/MMIxJQmH0NzMMwzRw5s+fD2eccYYoRLlhwwY46KCD4n6PP08G30YZJtiwWGIYhmEYhkkBJ3gzDMMwDMOkgMUSwzAMwzBMClgsMQzDMAzDpIDFEsMwDMMwTApYLDEMwzAMw6SAxRLDMAzDMEwKuChlBsDTyTdv3gxNmzZNWYuFYRiGYRh7wOpJ+/btgwMOOABycpL7j1gsZQAUSp06dcr2x2AYhmEYhsDGjRvrFaKNhcVSBkCPkhzsZs2aZfvjMAzDMAyjwN69e4WzQ67jyWCxlAFk6A2FEoslhmEYhvEX6VJoOMGbYRiGYRgmBSyWGIZhGIZhUsBiiWEYhmEYJgUslhiGYRiGYVLAYolhGIZhGCYFLJYYhmEYhmFSwGKJYRiGYRgmBSyWGIZhGIZhUsBiiWEYhmEYJgUslhiGYRiGYYIglrp06SLKkcd+3XvvvXGv+fLLL+Gkk06CoqIicdbL/fffn/Z9N2zYAGeddRYUFxdDu3bt4JZbboHq6moPe8IwDMMwjJ/w1dlw06ZNgzFjxkT+HXvwHR6GN3ToUDj99NPhscceg6+++gquvvpqaNGiBVx77bUJ36+mpkYIpQ4dOsDChQthy5YtMGrUKMjPz4fp06cb6RPDMAzDMHbjG8+SFEcobORX48aNI7979tlnobKyEp588kno3bs3XHLJJTBu3DiYNWtW0vd7++23YeXKlfDMM89A3759YcSIEXD33XfDI488It6L8Qf799dqt6msDEN5ea0xW/hlwhb2Kai2qqrM2CorC66t6moztkpL7bZVWxsm26qpMWOrpETfFuMdvhJLGHZr3bo19OvXD2bOnBkXLlu0aBGcfPLJUFBQEPnZsGHDYM2aNbB79+6E74dtjjzySGjfvn1cG/RSrVixIunnqKioEK+J/WLMgwv1L35RAs2aheDpp0uU282fXwYdOtTAgAGV4kamulhfeGEJNG8egn/8o1TZ1n/+Uwbt29fAMcdUaC1q553n2Hr+eXVbb76J/aqFQYMqtG7+55xTKmy9+KK6rddfx36F4YQTyrVu/medVQotWoTglVfUbeFr0dbJJ+vZGj7csfXGG2XK7V56qRTatQvDkCHqtnAhHDq0FFq2DMFbb6nbeuGFUmjbNgxnnKHeZs+eGjj9dMcWzmNVnnuuFNq0CcOwYeptfvqpBoYMQVsACxaoj8ezz6ItgDPPVLe1e3cNnHxymbD14YfqtvDvHm2dc466rV270FY5tGoFsHChuq05c0qhdWuA885Tt7VzZw2ceGK5aLd4sbqtv/ylRLS56CL1vxPGY8I+4cEHHwy/99574WXLloUfffTRcIsWLcLjx4+P/P6MM84IX3vttXFtVqxYgStheOXKlQnfc8yYMeGhQ4fG/aykpES0efPNN5N+ljvvvFO8pu7Xnj17XPeTUaO6ujY8YgReq7D4uummfUrt3nuvLNIGv/B9VGwNHRq1NWGCmq1580rjbKmAtk47LWrr1lvVbL31lr6tqqra8ODBUVtTpqjZeuMNfVuVlbXhk06Ktvvtb9Vsvfoqzdbxx0fb3X23mq2XXirRtlVRURs+9tiorRkz9iu1e+EFfVtlZTXhY46J2rr/frV+zZ2rb6u0tCbcv3/0b+X3v1fr17PP6tsqKakJH3VU1NbDD6vZeuqp/ZE2ubnp/46R/ftrwkceGbX1pz+p2XryyWi/CgtrlNrs21cT7t07auuJJ9Rs4etkmyZNqpXaMHRw3VZZv7PqWZo0aVK9pO26X6tXrxavnTBhAgwePBj69OkD1113HTz44IPw8MMPCy+PaSZPngx79uyJfG3cuNH4Z2jozJpVAv/+d3Hk36GQmgfg8stztW3NnFkKb7+tZws9ACNH6qcEzphRAu+8E7Wl6gGg2LrnnlJYsECvX/hUfuWV+TFt1Dxz06aVwIcfNtL6fPhUPnp01FZenloo4447SmDhQj1b27dXw9VXR73SjRqp2brtthL45BM9W1u2VMM11xRG/t20aY1Su8mTS+HTT/VsbdpUDWPGRG21aKG2eeU3vymFL74o0rK1cWMV/PKXUVtt2qjZuvnmMli2TM/W+vVVcP31Rdq2xo8vha++0rP13XeVMHasvq1x40phxQo9W19/XQnjxkWvcevWanODCXiC98SJE2H06NEpX9OtW7eEPx80aJAIw61fvx569Oghcpi2bdsW9xr5b/xdIvDnS5Ys0WqDFBYWii8mO+AiOn263k0I+d3vSmHz5iZQXFwDpaW5yovojBn6tqZNK4OtW5uIRbesLOd/oiK1Gtm6tRruv19vMUSmTi2DH39sAkVFtVBenvM/UZH6OWjz5mp44AH9ft15Zxns2NEECgtroaIiBwoL0/cLF9FZs/T7NWVKGeza1QTy8zGvJwcKCtILs++/r4I//rGYYKsCfvqpsRi76uocyM8PKy2ijzyib+u22zCMH7WVl5fe1jffVMKf/qRva9KkCti3D22Fobo6BHkKd/w1ayrh8cf1bd16ayXs398YcnPDUFMTUurXypUV8Oc/68+N3/ymEkpLG0NOThhqa0OQq/Dn/NVXlTB7djTPVZVbbqmCsrIC8TccDqvZ+u9/K+Dpp2m2ysujtnJ8lSgTbLJ6Kdq2bQs9e/ZM+RWbgxTL0qVLIScnR2z3R4477jj44IMPoKqqKvKaefPmCSHVEgPhCcA2uGtu+/btcW2aNWsGvXr1ynh/mczwyCPl8NNPeXDIIRUwalSJch7Qo482iiz4qjz8cDns3ZsLhx1WAVdcUaKcL/PEE46tqVPVcw4eeqgc9u3LhcMPr4BLLlGztW9fbWSxuesudVt/+EM57N+fC0ccUQ4XXVSi7MH661+dRXTaNHVbv/99hRCnffqUi1wsFdCDNWeOY+vuu9Wv1wMPVAhx2q9fOfz85yXK4vvpp50x/N3v1G3NmlUpxOkxx5TBz36mZmvbtmp45plGEc+eKg88UAmVlTlw3HFlIhdL1YM1d64zhvfco57Td//9lUKcnnBCmciPUgEF8XPPObamT1e3dd991UIwnnJKKZx6aqmyV+mf/yzWHsN7760SghHtYH6UCt9+Wwkvv+yInunTS7X6hYLxjDNK4fjj1WyhSH311cZCKOnYYszgC92Kidh/+MMfYNmyZbB27Vqx8238+PFwxRVXRITQZZddJoTVNddcI5Kzn3vuOXjooYdE+E7y8ssvCwEmwVIDKIpGjhwp3vs///kP3H777TB27Fj2HFnMP/7hPB7fcEO10tMr8s9/lgnR06FDFYwcqeZRweTv555zwkBjx1YpPVEiL7zgCJEDDqiCSy4p1LDlPBjceGO1sq25c8uEEOnUqRIuukjf1q9+VaP89Dp3brkQIl26VMK55xYo23r+eee148bVKPfr738vF54rFMRnn63mAMedQy++6IzBr39doxRWRP72t3IhRHr0qIAzz4yG/VKBu6/++U9pKyxSBlR4+ulyIQ569SqHM85Qs4W75V56qSjGllIzeOqpCiEOUKQOGZKvvGnilVccWxMm6NlCDw+K1BNPzFPeNPGvfzljOHGioiFhq1J4XY4+ugyOPz5XeSPDa68VkWwhxx5bBgMH5io/LL3xhmPr5pvVbc2e7dg6/vhy6N/fF0tzg8IXVwSFy9y5c+GUU04RZQHuueceIZaeeOKJyGuaN28uSgGsW7cOBgwYIEJ8v/3tb+NqLGF+Ee6Ok+Tm5sLrr78uvqOXCcUX1lnCek6MnXz2WQWsXl0oQhhXXKEuaJ991rlpXXBBhbI4WLKkAr75phAKCjDXST1U8OyzzveLLqqA3Fy1m+XChRWwbl2BCKVdeql6eOzvf3fe/6KLKpUXtg8+qIANGwpEiPDSS9X79fe/OwN38cXqtt59txw2bSoQoc+LL9a39YtfRD3F6Zg3rxy2bMmHJk1q4MIL1W394x/6tt56qxy2b8+HZs1q4Lzz1K/X3LmOkLjkkmqtnYc7duSJfKNzz1Xv19y5zuJ+ySXqeS//+heGPvOgdetqOPvsRtr9uvRS9X698ko57NmTB23bVsGIEfpjeOml6tvxX3yxTHht8WFp2DD1h6W5cx2Reeml6mMY+7B02mlF2g8Vl12mX2aA8R5fFKXs378/fPLJJ2lfh8nfH374YdLfY35U3Rypzp07w5tvvpmRz8l4z1NP4YJWCKeeWg7t2qnlVezYUQPvvuvctGIThtMxZ45z4z/9dNz6W6wcZlmwwFlkYhOh0/HUU87NeOhQ3D6tluuAeUcyafqqqwq0bQ0fXgZNmzZWDrN8/LEcQ3VbTz/t3PjPPLMcmjRprBxm+eSTqC3VGjrS1s9+Vg7FxY2VwyxLljQSoY+rriqE/fv1bJ1zTjk0aqRma/XqSpE0jXk2o0YVwq5daovi3/7mfKZzz62AggI1WytWVIqkacwfQlubN6st9s8849g677wKyM9Xs7V0aYVIZEYvL3pt166t1rJ1/vkVkJen9rfy+efOwxLmseHD0urV1doPS7m5+coPS99+WxR5WFq2rIrwsJSv8bBUFHlY+vRTrvNnG77wLDGMZN485+ZzySXqbd58s1zkYHTvXgFHH63ujZo/37F18cXqheFef90JfWBIp18/ii11t/1rr1WIvAgM6RxxhLqAeecdOYY6trAmlRPS6dlTx5bz2ksvVbf16qsVIsyCIZ3DDlMP90lbl12mflt79VVnATz66HLo2jVf2da77zrX9tJLdWw5C+DAgeXQuXO+cmjxvff0bb3yigwflcOBB6qHMRcscETqZZep7xp97TVnDDHHqUMHNVsogN9/37F1+eXqz+z/+pdjC+sktWuXpxxa/OADfVuvvuoIscGD8WEpVzm0+NFHjq0rrlB/WHrtNccW1vdq2VJ/xy7jPSyWGN+AXps1a5yFY9gw9QV7wQJH7Jx8snqYBb02330nbamLnvffB21buINr/XpnBwzF1imnqIcI0JOycWOB8DgMHUrpV7XWNujNm/OFx+GMM9TDLB984AirwYPVbaHXBsNi6HE49VT1fn3wgfN98GD1MVy+vAp27swTOwKHDCnU7pfO9Vq6tFJsZsCQ6eDB6mP44YfOrX3IEHVbn36Ku/RyoXFjLKSo0y9pS/2hYvHiChGqwrIJxx2nbuujjxxbgwerh6oWLXKS/ps3r4aBA3VsOaLl1FPV+/XRRxUi6b9Vq2ro31/9HvXhh46tIUM4BGcrLJYY3/DBB87TcrdulXDAAepPiEuWOK89+WR178b77zu2cBdc+/bqtj791HntKafkaNvq2bNS+Qk23pZ6vz780BEgvXpVQIsWOrbyCf1yBGPv3hXQtGmOtq2TT9ax5fSrT59KaNxYx5azoJ1ySq52v/r2rYBGjdRtffaZY2vIEHVbH3zg9KtfPwzBhZQ9X59/Lm3lac8NrGyfn0+xpd6vDz90RNzRR2MITsdWIblfxxxTqZxDiF62L75w+jV4sH6/Bg6shJyckLKXbelSp1+nnabujWLMwmKJ8Q2ff+48dR11lLrXBt3ia9Y4N71jj1W/EX32mbSl7t3AHTfffCNtqd/Mv/jCeXLt21fdFhbYXLvWsXXccfnaY9i3r7rHAUsGrF/v2DjuOPWn5c8/d/rVr5+6LdzGj8nnura++AK0baGnEj1fyLHH6tvSGUP0VG7bli+8h4MG6dvq31/d1saN1SIhHHOjBg7UsRXStrVuXRXs3p0nvIdHH025XuqelG++qRKeL9zcMWCAfr8GDFC3tXp1FZSU5ArvYf/+6t6opUv1bS1fXik8X+g97NNHvV+MWVgsMb7hv/91pmv//vXd4ng4QOI2lWKrNu5aOvTQfOV2X37p2OrXD5TbfPFFpcghwl1LdfNfMAcnGcuWSVvq7v7PPnNyiLCa8MEH1+1XKlu52v3CZFP8/O3bV9XLf0nWBvnyS8dW//7qtpYscbxsuJOorkdPZQz1bDmi++CD63v0UvVLjmH//vU/T7J2ixc7/ercuaqeRy+Vra++krbUb9WyX+iBbdJEvZ201a+fer+WLHEEfvfulVBcnKPRL+faHn10jsYYOv3q0aMSiop0+uXYGjAgR7tf6O2t62VLPefzXdmq62VLZYsxC4slxjcsX+7ciI4+OrrYpKtv89lnzlNy795Rt7jKtveoreifSLp20tYRR1Rp2nKeJo85JioO0rX79FPnBnvEEZXKbTCMsWKF069jjslVbie9UUceWaVpS/ZLPYzx+ec19WylC2dgyGTlSsfWwIF52tdLp18YMlm9OpGt1KvaF184Y9inj7otrK+U2Jbq9apWboNJ0NIDO2hQvqe2sEDst9/q9+u//3XGuE+fGuU2sR7Y+H6pXi91W3jE0fffOzZivYfp2knP8lFHqdtizMNiifEFeNOTIZN+/dTDTqtWOd8PP1wv7LR1q2NDJ0lz1Srnpterl17YCUMmSN++6v3635GJ0KuXurt/+/YaETJxbOn0y/l++OG1WmeSYcgEQ0FHHaVjK6Tdrw0bqkXIBJPWjzxS3dbq1Y6t3r3VH9/XrsWjL5wjZXr31rfVq5e6LTzixDlSphZ69lSfG2vW6PdrzRqsbu2EghJ5YNPZOuII5SawapVTSRvrYanuQERWr87R7heWUEAPLCZ31/fAprd1xBFhrcR/9H5ijSqdnMqvv5a2lJswWYDFEuMLMIcAwXCaTsL1d985N/NDDw1p3cyRli2rtRKuv/vO+XPq3l25Caxc6djCcJpOwrW0pdcv5+kfC/PphGekrcMO07fVsWOVVhL02rV0WwcdVKWcBI2sW6c/hmvWOEK4U6dq5SRo5LvvnGvbo4f6WKxe7dg6+GCsHq9ua+3aXPIYYphQNTGZakv2q0sXPVvr1umPobxeXbqo5wPG2jrsMHVbX39dS7SVp90vxjx8dRhfIG/mXbuqJ3fH3/TUb8pff13j6qbXs2eu9s1ct1/r1+vfYKO29Pq1fr3+IiUXjq5da0j90hnDqC3d65WvbUsu9N266dn6/nv96/XNN2HiGDr9OvzwPO0x7NZN3RaGWmXYSWcMZb+otnT6RbGFodYNG/RtrVmjP4YYav3hB/0xZMzDYonxBZSFA3NZ5E1PT8A4tg45RO8Gu3Gj/kIfvZmrh50wv0TeYPUWRH1bmF+CR4ggPXt6awtDrTL8qWOLMoaYXyLDn4cfrh6e+e475/shh6jbwkOB8QgRXVvffON87969VmuHH4Y/EZ3Q3bffhrT7tWVLjQh/Yqi1Rw/9fh1ySFgr1Ir1izDUqhMm/OYbp1/du4e1dvhhEVsMtXbrpjM35Biq2/ruOyckiaFWnZAkYx4WS4wviN7M1W9EeGwG5nzgtuZDDy3w1Bbe9PAGi0cj6Nxg5c380EN1clmqxK47PBrh4IMpIUnQymXBnA882021ErRjK0e7X7Gh1nbt1AXnt9/mBDTUGrI61Cr7RQ21Uvp14IF6oVaKLek91A21ypCkjvdQ9ks31MqYh8US4wvWr5eLlPoN5ZtvaiI3WJ2b3vff020ddFC11k3v++9ztW19/XX0BquT80GxJft18MHVmrbkGOqEnaI5Ojq2Nmxw1y8d5Bgeeqh6v7791vHWdO5MC93p2JL90rUlx5DWrxrP+0W1tWGDY+uww3TENy33SNoy0a977tkPt922X6sN0wAO0mWYLVucm13nzuo3og0bnBvRAQfUWGtr61ZpS/1mvnGjuX5t3Oh4hg48ULdfeQRbsl+1pH516aI+hj/84Hw/8MBaUr90bMl+6Ywh5ujQbIW1x9CtLZ0xxND49u36tn74Qd8W5gP9+KObfoW1QuM7dzo2unZVX1Y3bXK+H3RQWGu37u23NxH/P25ctfJ5fIw72LPEWA/ezLdtc24IBx+sf4Pt0KHWmK2OHWkLR6dOOdo32I4dw1oLh8zRofUrrFU1Hc9OQzp3ztMWMAccoG6rpKQW9uzR79emTWFtW/v21cK+fVJw6i+IOmP400+1okSBrq3Nmx3vms5C/+OPNVBZ6djSCetSbG3dWiNydLDOkc5W/k2bQtrXC8tXYAgZ85x0QsiUfm3Y4JQNwDyn9u115qG+rR9+iIpuLlppDhZLjPU0hIWjUydzC4dODZgtWyg3cyd8obtwUGzh0R4IJsi2aZOrfb10xvD77x1bmL+lczL85s3OfDroINC2hflbOrlH0XmoE8asieRv6eQeRccQtBK1kdata7Ryj7ZudV570EHqbTZurInkiqmePxdrS2cMpfewXbsarTD8li052rZixVItn7trDBZLjPXYtnAkepqjLByyX6kWjkS2oqJCvY3sV6qFI9GNl2LL5MIh+9W+vV5OlbSls/hGbdWk9EzWtyUX+hztMcR+JSPx3JBjqN5GpV+J2m3dmuNRv8IZuV7SVocOtNA4RZjp28rR9iz/8ENtnHeaMQOLJcZ65M0h0Q1WHguQaKGXN6JkCwdS974sb3qpFo5EbNtGv+l16KCXSBpdpOJv5qmOSIjaqt+vVO2SLRyp2qRaOGS7VItv3TFMbSv9gpjoTDnZr2S2En2+VGOYim3b9BffqC0918H27bmEkCRtbsh+6VyvVOHq1LbyXFyvWs15mHgMU7WJhlr15rwMw+tcr82bo//PniVzsFhirCf6NKp3Z4jezONvRKk8EKlFRVhBVOgvHKlu5joLhxeLb7IxTIVcOPQX+ryUnopEbN7sLi9Np1+U65XKVup5mMpWOG0OnM48NJkDJ3PFOnTQTZ7OI4TG9ftVWhrNgdOb81IEAikHrq6t1NcrHFffjTEDiyXGeuSCqJ88nfjJN7Ut/Rss3rDcLBw6tkwuHFiQ8qefKE++didP79kTzYHTGUNKTtWOHbQcOIqtbdtoOXAyhKwzhps3OzlwWJDS6xy4jRurSDlwlDxCkzlwMn9LNwdOhiQR9iyZg8USYz3btzvf27dXvxHt3l0rDgZFdG7mFFuYFI4LB9Kxo7qtH3902rRrp5MU7txgcZHSKdy4fXtIu1+YgI5gUU+dhYNia8uW6CLVvLn6bWnHDmkLtG3hItW0qbqtH38EbVtbt9ZG8u10kqejtnTysJzr1aKFXvK0nIcdOoC2rVatarSSp6UtnX7JMcTcPp0cuOjcoNnSyYHbscO5th066F+vNm30wrqyXwiLJXOwWGKsR94c2rQJaT1lI40b6y1SO3c6Nlq3Bm1buCDqFL+Uttq2VW+zfbtzd2zeXG+RctMvXHx1Fo5du/Svl+xXy5Z6tmhjGI7Y0mHnzhzyPNS1tWuXtAWEMdRbQeX1attWR8yFfdCvHPLfF4pAPVv68zA6hnr92r07ep1q9D4m4wIWS4z1RBdfIC2+Xi+IVFu7d+sLmB9/pC0c0la7dvo3c92FQ44hZZEyuyBSRYX+GLZoQeuXzjykzw39MdyxQ84NWr/atdMXZmZt6eUC7d6dS7AlvVi0fiHsWTIHiyXGeuTN3MzCESIvHNSFnnKDpdpq00YnxOXuyVfnerm1peMVidrSWxB/+imXYIu2IMp+6cyNHTuAJCrkQk/7+9IdQ/3rtXMnrV+U67VzZ9jYGEavl/oY4oYB2S+ESweYg8USYz0mn0ZpT4hhV0+Iep4KMNivWuJTNv16tW7t/RO9XKT0BQxlDGkLort5qG4LF1u5+OokT0fHUG8jxJ49+rai/QKtjRBywwDleunYwirycsOAztEjUgTqjCFuhJAbBhAOw5mDxRJjPW4WRBPu9GhIwv4FkSYq9LaU792rvyBSFg48VmX/fjdjqNwE9u+PLoh6/Qpp92vv3lqoqqIvvm3a6G2EqKmRIVp9saRjC3cGyppXbdt6O4bbtkU3QrRurW9Lp1/bt0c3QrRoob85QSe9QObASTgMZw4WS4zV4Pb1khLKk29Y+6aHC2J5ufSK6Dz5grZYwgVR7tZr3159Qdy1i7Ygyt16ti6IcuHQWRDlIkVdECmLL25f19utB+QFEXcG6lSslzlVrVqp29q+PbozsLg4x0geIW6E0NmtJ0Ugb4SI9kvCYThzsFhirEYuiHimWcuW+k9tOjc9uS1fd0GM7shK/brYozDkDbaoKPWCWLfqr8rOwLptVHcG1m2nsnAks2VyZyAuUjpbyt3YSrdbr+54qCyIdSuMq24YqNtOpV91P5/qzsD6cyN9XlqyuaHbr2zsDLRlI0T961VXLGmZZFzAYomxmnQLoqxmnGyhT7cgxrajbl93u1Veh1RP9Mmq/qazlaxdqpt5svFJt/U6mS2VfiVbOJL1KycntYBJJG6TzSdqDpzfdwamu16JbCVrQ90qnypnMdnciObbpZ6H9edG8gT0dPMw3RjWbUfZhSjHUMJhOHOwWGKsRu4mat5cdydMcq9IcnGQept3snbyppco/JGsTbp+JWsndxO1bq2z60YKTuoY6nhtwsTr5aZftB1ZrVvr75LSnRup+pXpeejOFm1noM7uSmlLVyxR5oYM3en2Syag69jatYs6hsl3qCZ7GJFheAmLJXOwWGKsZs8e5wbUtKneXWHfPmdqN2+uftP76SfHRtOmeje9/fsdGzphwr17HRvNmtH61aJFiDCGuv2i22rWTM/Wvn2UMQTSGLrpl81jKG2ZHEMdW+77FdLuV/PmJsdQb4OHmzGUcBjOHCyWGKv56SfaIiUXX53dKXv2AEmYyZuenjADV/3SsRXtl66tHBdjqGsrlzCGYev7FRVL+osvtV+0MQSthb6kRN9WtF+gVW5AbvBo0SKXIG71yg3IDR4610v+LTdrpm6rrCwc2eChNzfix5sTvM3hG7HUpUsXCIVCcV/33ntv5PcLFiyAn//859CxY0do3Lgx9O3bF5599tm071v3PfFr7ty5HveG0fXAUBcpPVEhn3yBtEjRPEu6/co1/kRPGUOd6xW7+OosHPv2gfaCiItLdPGljCFt8dW7Xs735s31do3KcgOtWuVqj6GOB6akJBwpN0ARgTrzEHeNSiiiQmce7t4dddPoCDP5AKNjS3qxMUeuWTP9MZRwGM4c6nuWLWDatGkwZsyYyL+bxtwlFy5cCH369IFbb70V2rdvD6+//jqMGjUKmjdvDj/72c9Svu/s2bNh+PDhkX+3aNHCox4wukSf2nRd3PqigvJE7yy+bjxLoFXDSNb68XqRwsVXFr/TWXwp4Q9n8XUjKtRt7dmDqwtlboS0x9BZfJ1brM6p8nLx1bOF/XL6o7P47tkjbSk3gV27sF85omSDzkHEdFu5kJ9fq1XagCI4nTEEaNSoFgoK9P++dEKt0lbjxrWQm6vz9xVvg8WSOXwlllAcdUhyNPZtt90W9++bbroJ3n77bXjppZfSiiUUR8nel8ku8slXZ+EoLY0uvpRQi84NFp98w+Fc8hO9Tr9iF3qaWALNJ18pAilP9KApKvQXX7qtXFEeoqiIkgMD2t4DLA+hs/hG56GO+HaEGZaHyMujzEPQ9rI1aVILOTkUL1aIZEsnEBIVnPrXCwWMKVtOv/THUMI5S+bwTRgOwbBb69atoV+/fjBz5kyornbq4iRjz5490EqhQtvYsWOhTZs2MHDgQHjyySchXHePZx0qKipg7969cV+MN9CfRikubv0nennTw+q9jRrpLAIy90i/X1issKiI0i/QDklgsUKdon7Rp2zQzptxFl+KLUqOjq4tyhjGLojg6eK7e3esqADtfukIGGq/9u6V4hu0benmEcp+UeeGvbbi/+7Zs2QO33iWxo0bB/379xfiB0NukydPhi1btsCsWbMSvv7555+HTz/9FB5//PG0ob1TTz0ViouLhSfqhhtugP379wt7yZgxYwbcddddrvvE6DyN2vnkG104sDZTHiFRm7ozUF8sURJ/9Z98TT5l52jbivdUeJ1Y784WbbcetV9g0Jb3Yyh3qNLy7Wg7VGnzkLbzVsIJ3g1ELE2aNAnuu+++lK9ZtWoV9OzZEyZMmBD5GeYmFRQUwC9/+UshXAoLC+PavPfee3DVVVfBn//8Z+jdu3fK97/jjjsi/48eq5KSEuG1SiWWUKjFfh70LHXq1CmlHYZGdKGnPo3q5AOYW3yjngrvn+gpC6I/nrL1bVE9FRQBQ+0XTXDSFl/KzsBoiQ1zY6hfikK/ZIPbnbc6OXDRftGEmYTDcA1ELE2cOBFGjx6d8jXdunVL+PNBgwaJMNz69euhR48ekZ+///77cPbZZ8Pvf/97keCtC77v3XffLUJtdUWYBH+e7HdMZrHxiT42SqtTmym2nXxCTGcr1s2u+uRbN4qsOoax7VSffOvakjvodERg1LNEe8qmbV/3flu+29pM6RbfRNcrnaioPzfUREXsUT2qZRTqHluiursy9jPK66U/NyilDcztvFWdh8n+vtCTjZtYOAzXQMRS27ZtxReFpUuXQk5ODrRr1y6ufAAmc6O36tprryW/b8uWLVkMWUK6RSpRZeKo98BkDSNq/gYlNJa4X8lycNItiInGMN0TfbKK0LJfyRb6RO3kGCZ7yk5my02/TBaXNCPM3NUIS+ZZSny9Us+NdPMwWXHJVNcr2Y7HdHODNg/VbansvE09hqAMhtyiDyO1LJYM44ucpUWLFsHixYthyJAhYkcc/nv8+PFwxRVXCGEjQ28olHAX3AUXXABbt24VP8dwnUzyfvnll0UIbfXq1eLfr732Gmzbtg2OPfZYKCoqgnnz5sH06dPh5ptvzmJvGbfFJaNPbenvJM4TcygL1Zb1QxKUEgCmCyNSvAeqoiLZU3a6fsV6Rdw+0XtdsiHelrc1wmKrSFPmoW5xydJS/eKSqrW0Yq9XeXktVFSoXa/4eQhKYxjrMdMpLhnvMdOvzbRvX3TnLR4ntHkzh+FM4guxhF4eLBQ5depUER7r2rWrEEuxeUNPPfUUlJaWihwm/JKccsopwuMkd8etWbMm8rv8/Hx45JFHxHvhDrju3buLhPHYWk5MdpGVnTOZ55DeU5HsCbF+w3QhiWS25NOozhO9+4rV3uaKxBaXpB0XQavsTCnQqZO/pVJcMvH1St2vRG1KS6PFJZPVZko0D9MJs0S2cPGtrZVjqFMd21x9K4qt2LIXOv2i7IaVNad0d97KfiXbNZrcY54LublhKC52PiMneJvDF2IJd8F98sknKV8zZ84c8ZUKzI+KzZHCQpSxxSgZu8hWZWdadWxacUkdW5SdgbGVnfUKI4L2whFbXNJMZWdKzSlqZec8cmVn/VIUzuJLqW+lXwfKWXwbNw4ZqW+FxSUbNfK2lpbMgcPikvn5lL8vfY+ebnHJaNVvIOT21YhrhqSpcsM01DpLTMPCKS6pH4ZTdadn4liFqDDTfcoGwpMvkOtAmSsuCQaLS2J9K73Kzu6LS1IKWeoWl8T6Vrj4hjx9QIhd6HVqTrkvLgkGi0uasaXfL3djKHVZmlKDTAZhscRYS6yA0Vl8S0pC2jtopC1c6HWKS8rcoyZNlJvAnj3OgohP2TqLr7TVuDFo9wsXep3ikvv3O9+bNtVZRMORJ3qdxbekBLTHUNqS4Qh1W/J66fcLBQzNFmjvyKLa0rlecm7oigpKv9yOIWUemu0XbR7qiNtov8KRMB0neJuDxRJjLZhTIRd6nadsufjqhBZKSmpJC31pqbQF2p+vUSO9G6y0pbPQ798fFTB6tkLai4C8Xvr9CpH7pbv4Uq4XdQzLyvTFbbRftMWX1i+T14tmy/5+UeeGzj0q2q+c/63cLJbMwWKJsRZ5c0CxRLkR6S307m6wOje9/fujwozWLyDdYCm2dPolhQhdmFHmhvf9oo4hpV/RMTTZr6DOQxO2qHMjh3DfiApOmbPEu+HMwWKJsRb3T6PmFnrbn3z1+wXaIQm318uMZ8mct6esDFxcL9pCr2NLChiz18v7fpmdh0CyVV6ub0sKM7TFniXzsFhirIX+5Etf6M0+0YeNPdFTFykT/aIsHG77pbdIAXHx1fcemPTARMPBWqYiOzlNjKHJ6yXLQ9AEDHj+QCdDrfFhON4OZwoWS4y1uPXAFBd7s0jFbtfV8VTIdjpPvolspbuZxxbNo+dHqS70oQxeL/B8oXcT/tCdG6oiMLaN7Jf+3JD9Um/j1ttDE2Z6/YoKM50NHibzo7wVZvHXOCrMpFiSu4UZ72GxxFhLrNs5GYmKt1GefKkLh1wQbcipSDQWKgtHonbpFvrEBRUhsltHx1Y670EqW5kOfyRK7s+GZ4neL/Vbuhz3VPMw8dxI/feVeh4CaW4kEzCJbYG2LfTQRPulXnhUerFT2wrXq+mWzlYiYvvFYTjzsFhirEU+tek/jaoLGNlORZhlKs9Bx3vgVgRGPWZgIHFd3VbsTV7Ve5AJD4y0la5fsd45nX65Dy+CtpcNF3o3c0PHk4ILPc3bo98vLN4qC6rS5kZ6G3hyA1JeHobaWn3BSZmH8l6jWxIl9mGEw3DmYbHEWAs1H4DiqYjNB6A9Zas/jdI9ZvRwVSpvT6byN6JP2XbmisSKCtoipXccS2WlG09FqrkRrncciwzH6M3D9Lbqf77oayl5RDrzUO4a1b1elN2wsbZ0xBIlhCxLbDjt9O9RaCu6G47DcKZgscRYCzUfQNV7kMlETdoOGu8XekpuDy708iBSr56yYw89ra729oleEvtET8m30ble1IWeZovmqYgKadpC37ixvqjQmYfSForDoiJvr5e0hRXhdQrFUsZQzg3d+nFSSOPcjeYssWfJFCyWGGtRyQeoC9485ELv9SKFT/TyxHFKzpKOLQwTyNCQXl6KtBXWLtBpwgMjQ0F0TwV47j2g1e2KLvQ6FeFpScZyoQ9rLfQUr4i0VVioVxE+utDr29ItFEvZDUvfrQfkcLVu/bioZykahuOz4czBYomxFor3gO5ONxcmiC6I+ouvvgeGsiBGP5fOQk+xJfuFYQW9J3q6p6KgQG+hp4jb2KKZXleEd1ul3eRCb6LSfXQehkinBXhd6Z5e9gIi10ueDcdhOHOwWGKsxU1lZ6edtwu9FEt4nlxhIWU3nL4tPE8uP9+MBwYXX50wQdQWJQGd5j2geLGoooJWt4u6+OoIGNpCT/HcZmKh17Vl4pgZk/XIooKTXtpA5jRxGM4cLJYYa3GTU6G70NPc6XyeXLytkKvrRbFlprKzuYXeZIXx7Jwnp2/LZIVxE1X1o8KMfp4ch+HMw2KJsRbKIpWJfACvz5OLLlL6YQIT5665ffKl2KKHWsDgE725xdfEGLrrlwmPWTDHkH7WYE6CMJzWWzAuYLHEWIsbd7p+wUcwdp6c2X6ZfPIF7X6ZPAbD/RO9uXAVJdndxDEz1HpkJs+uo/ULDPYLXPeLi1Kah8USYy3unhDtPxCXPRV0b4/Js+to3gMwfhq9mevl7jy5oF0vd/0Ccr9YLJmHxRJjLSafRnUWX3mD0r2Zy/wCHU+FbGPi4NhohWF31bFtPRCXUh5Ct1+yvINOvyjnycVWb3Z7vbyah4mq6uvNQ/3QeGyRU70dqmFS8VaK11FnN2z83IjOQw7DmYfFEmMt0fo2+mECqqfCq8N3Y5ELol6/IG2/Ulf9Dim3i932rmNLpV9126mEkFL1K9XTeTJbXvQr+TwEg/MQiOca5ihXC3d7nhxtHoLnc0MKaR1bsefJpR5D93Ojri3cgev8XP09GHewWGKspaIi/U2vvtcGtG5Esp20pbNIlZdLW3piyY0tXWGmM4Z1beku9Dr9kuOuM4axT9my8KhKFeno3KCJ22i/9IWI7tyQR6SYnIc6c0OOoZdzI9oGtP/+cSu9PE9ObW6E6thSn4fV1ShW0gvOZPcovb/J6OfCMZS7b9mzZA4WS4y1VFbKm7n+DbawUO/JV9pK/WQZTmIreZtEJQVU+lXfVjhtvxIhbRUX52jfmPUXev3FV46h7uJbVZX+eiWzlep6pe5X8jGUOST1xxCUr3G8LXUPTGUlpLVVdx6ip0KKCp25Eb1eYa0DcaWo0JuH+rbk3wn1vqFzrEpZWS3JVvR6qd+jYsUS2pJnw3HpAHOwWGKsRT6N6tzA5A1WV1RQbMmnbBO2pKeioABIngodgSDHUNeW7JdOgU45hjq2cKGnjCFFLMV6KmjzELREhazIrDcP9W3FLr6UMdS5XqWlUVHh9fWKPejX6/sG3Zb+33KsLax0H/Usqdtl3MFiibEWkyEkKSp0nhApCyISXei9DX/EigraUzZNVHjtqYgNf+jYioZo1W3VfaLPpIczlajwegxjF1/KnKeE7qiiQufvS44heu10js+h2JL9wsN3dQrgUsZQ9gvP5EOhFM1ZYteSKVgsMdYSXehzCN4edTssKrInKqK5PTrJ07Twh1tPBSWExKIiXlTonMnnZgxRpOpU1Y/mLOmH4fQ9y/r3jbqeLy4dYB4WS4yVoKiors7xJB/Aj6IiGzkV1LCOngjUz4+ih5AoCc3R8//y8iAwokKOoa6okHPDhKigzMNomNC8gDEhbmW/uHSAeVgsMVbi3lMBgfRUUEMtFE8FJUxgUlTgocKU8AfFlh88FbS8NN2F3ryo0BnD2HAVxRYlNE69XrSQv/QIOv+WD3mM97BYYqwkPqdCfyeXmWRXuqcCwx8UUUFJCqXmVFBEBS6+FFFB8ZhRvQcUUZGfb6+nIppYT/dUmBC3Jq+Xvi2T/dIXZnXva/LewWE4c7BYYqyEPRXxsKci0e4v9lRkylOhbstcv9yNoZYprZpO0c/nTtzq/S2HE+YscRjOHCyWGCuhiopo/oZ3nopoIUvQujFjO1OiApPWdUVFtFCk+s08ejRFrfWLrwlvT90ipypzo27RTN15qCMqZBFGXVFRv3ijzudzN4ZuRIWdpUNAe27UvW9Ew3BaphkXsFhirCSaqJn6blBXSFESvP3gqVARFckK2aXrF6XIYd02qlvl67dL36+615jaLy/H0G+eCvdjGPL1PKSMYab6Rbte8fc1DsOZxzdiqUuXLhAKheK+7r333sjv169fX+/3+PXJJ5+kfN8NGzbAWWedBcXFxdCuXTu45ZZboBq3RzFZhZpT4aYwoklPhc05Fe7yUsD6MaR4D6gFOm3zVGR3HtpflNZk8VaaxyxegHEYzhwa2SDZZ9q0aTBmzJjIv5s2bVrvNfPnz4fevXtH/t26deuk71dTUyOEUocOHWDhwoWwZcsWGDVqFOTn58P06dM96AGjir7rPkTKc0A3t3vXvXqbhpJToRtqUVkQ64arvBS31BBS1Jb5EJIbT4UJW172ix5epNiijWH9Oa/2GRONocyt5ONOzOErsYTiCIVNKlAcpXuN5O2334aVK1cKgdW+fXvo27cv3H333XDrrbfC1KlToUD3kYHJGO6TXc2FkEy67k16Kkzu5PK7qKCE/Op/PlBa6OuHq/TnIV20mxdmJuYh5RxKys5bVVvJ7lFyLOTZcByGM4dvwnAIht1QDPXr1w9mzpyZMFx2zjnniHDaiSeeCK+++mrK91u0aBEceeSRQihJhg0bBnv37oUVK1YkbVdRUSFeE/vFZBY/JWqyqKAviJQdT26PmQnaGAZVVLgbQ5O2zP8tcxjOPL7xLI0bNw769+8PrVq1EiGzyZMni7DZrFmzxO+bNGkCDz74IJxwwgmQk5MDL774Ipx77rnwyiuvCAGViK1bt8YJJUT+G3+XjBkzZsBdd92V0f4xmT4hnpKX4r0wM7kgmhxDaiI0xRbl6JdYWybHUG9uuMvt8fqonmxdL5Pz0Mzc0D+Yua4tGYZjz1IDEUuTJk2C++67L+VrVq1aBT179oQJEyZEftanTx8RIvvlL38phEthYSG0adMm7jXHHHMMbN68WXigkoklKijUYm2hZ6lTp04ZtdHQMXmUQDY8FZzsmj1RQRtDmz0VOa7qfdk7N9yLCvWzIeXRSvrHHenYqqrCY5zce8yiYTj192B8LJYmTpwIo0ePTvmabt26Jfz5oEGDRBgOd8H16NEj6WvmzZuX9L0xt2nJkiVxP9u2bVvkd8lAcYZfjHdQb+ZunkY5/BH08If+WYNmk//debEoBzNTRQXtDEXzokL9fEIzHjPnb1L/etWd87KcBofhGohYatu2rfiisHTpUhFuw/ykVK/p2LFj0t8fd9xxcM8998D27dsj74PiqlmzZtCrVy/S52Iyg8knepPhKmr4g0VFrC27rxeKCukVoQgYXVFRU8OiItpO31b80Uo6Y0iZuxg3o3jM4j16soI3h+HM4YucJUzEXrx4MQwZMkTsiMN/jx8/Hq644gpo2bKleM1TTz0lQnOY/I289NJL8OSTT8Jf/vKXyPu8/PLLIoS2evVq8e+hQ4cKUTRy5Ei4//77RZ7S7bffDmPHjmXPUZYxm+cAxIXenKgwmVNRVaU/hioFBP0oKii23IoKnblhUlRQD7emCeLMiArdfunUZ6PMjeh5jWHIz9e/R8ldvjIMx6UDzOELsYTCZe7cuWI7P+5E69q1qxBLsXlDCG77//777yEvL0/kOT333HNw4YUXRn6/Z88eWLNmTeTfubm58Prrr8P1118vvEyNGzeGK6+8UtRzYrKL263NFE+F18muThhDzxbeDCnhD6d+lJ4tfErVDX/UrzkDDVpUOMfM6ImK+sfM6BZv9V5UxNYjc9p5Nzdix9CtqNCtqo/RCl1btAKdaDNX+5gZOYYchjOPL8QS7oJLV4kbRQ5+pQLzo+rmSHXu3BnefPPNjHxOJnOo15wJJ/RU6CRqUm56sZ4KvTIF+rZiRYXOMROU+lGxoiLVGNY/gkTfVuziq3d8hpogjm2nKiqS2dJJTo7tV0GBt8nk0hZ6GiiiIv3fVyhBVf3UoqL+GILSGCaaG/n50fmoMg8ptapUq5lTa58l6pfbqvochjOPr+osMQ0HireHHibQ91TIhYMeQrIzpyK2X3q7xvTDH7qeiqgt+fn0baGnIi/PpKfC29w5+rFAfqkIr6cGaHlEtNC4m3lIr+nm9C/3f04p3g1nDhZLjJXIHBjVmwp6lWLFkupCj6EC2q42fVuItKXjqXCbU0HJ39D1VFBsOXkp0lOhYis+JKE6hniNZb8cT4Vam/h5qGYr/vN5X7dL9cDpZLYoc4MqzEzY0r1esXND1RZ1bjj3msycyceeJfOwWGKsRN6IdESFE66S7dRd96q2Yt3p0lZOTmpPRbKT1NPbCtWzlZen56lwM4aqokJSVaUv5ior3dnS6ZccC11b0THUETBq/crkPMzPV2/jdb+ye71CxvoVtaXehnq9on9fzncWS+ZhscRYidyRpXeDjYZaZIVbNVtAtmVm4VC7wWbClmxj84Io54aOp0KOoe4TvZt5qNsveXoT5Xrp9suNLer1MjHnZb90RDu1XyavV3QMne95/8s2ZrFkDhZLjJVEF1Iw+OQbLK8IpV/Zecq2x9tjh1cEfO0VqUtdr4ja5wNiGM5cv6QtvdB4Zuah9DyxWDIHiyXGStwsUuhZotz09ISZO1smF0SK4NTtF+XpnCKI423ZOjfkGIIB0Q6urpdJEaiXA+d2Hup8PtnGnC39uRHvWZKec7kjl/EeFkuMlZj0HmQjtye4XhHbvVhapgLvFbF/HoLFc0Pfs5SpuRHdDaf1NowLWCwxVuKXXBG784g4VyTTuSIqBD9nSctUpMgpJfmf2i8dW/Lzmc1nA1f9kgneXMHbHCyWGCvxS6jFpFfEZFiH2i+dsaf2y41XxGRYh9ov2jwEa0UgpV9uw1W2h02pDz6yX1IscQVvc7BYYqwkO6EW9dpMlJsettP1LMXa0nnyddrpjaFTB0a3HlHIRekAID7Ry3ZgID9KzyvijLtu3Z6QsXkYrRFEmRvSlnob83PDnBeL5lnKzDzkMJx5WCwxVhJ1O6vXI3EfajGxnd+7XJFktVl06vao3szr21Ibw0TXS9eWalgn3pbagkjtVyYWREq4ym04OP0YhrUFTDbnBmXOq3qjMjMPMyMCZYI3V/A2B4slxkr8koBqwivih1wRk94DmtcRjHgdnc9nXrTr5/aEfDIP7U26duPFoj9kOf/mopTmYbHEWIlfckWoORUmKl1zrkjmc0Xsm4dgMGfJ5E5Jmq1shMZoZQp0bUGd0gHOvzlnyRwslhgrMZV7EJtHZPJp1MyCCNY+ZdNye2gLIj596y5SdW2Z8YrQr5eZbe/uvD1eCpj6c0N9HurmOlLnRjgcJpUpwXMvq6tzEuYscZ0lc7BYYqzEyxssNfcg/vPRbKnnimQrrGOyJIK+cHR7vbwSgZTrlWwe6oyh6rb3bOZiUUQgZT5R5waljEJNTTgiVLyYh7HXS36+WFvyPEoOw5mDxRJjJUHNFcnmDho1W5wr4qfrlZ2Ciu68Il7Zqq4ORxKevbYl5xPVFiVcHWuLw3DmYbHEWIlfckVM5Cy5L0ppLrcn6LkiXtlCUeHmelG9Ijq2KPMw1ivi9TyMFRV6tuj5dvq2ICO25H2Hw3DmYLHEWIlfckXM1oEB6wUMbfcizVaQvCLoIZD1lmz3ilBqn5kIw1FtUf6W6bYoOzmjtqRIYs+SeVgsMVZiMqzjLldEy1SknUmviNcLYpByRRJ9PhO2qAKGMp/cigoTtmjlPGjeHje2cnLCkfwhr23l59dCTk7dnCX2LJmCxRJjJZwr4k7A4I4dzhXxz0LfkLwiXtvCI21k0UY1W+YO0s6ULfYsmYfFEmMlNueKxB8zoW4Lb2y6XhHc7ULJFaE8ZceWUeBcEZot6tyg2QppL76xJRuwOreqV8T5OwHtLfbSVl5e1Cui1k7PVmbO/9MPjXt91mDsWMSKTfYsmYfFEmMdOrkiibds25kr4t57kPp1sYuRjq3YIy0ox0Xo2XK3xZ5uS81TkcyWSa+IqqhwbHnrFaH8fSWahyriwO081EkKdz833NlKd4xTLHIMY/9OcnPD9ULFjLewWGKsw0+5IlRbJr0iJkNjQc8V0bGll5dGC+vIvxWKV8TksUB0W7b2K5zVfrFnyTwslhjroIZaKItUtsI6lFwRqi2KV4RiC592KbkiOp+PGmpxF9YBY6JCv18UL5ZJW9TcHvo8pIfGdB58ZBuTxzhxzlI2YbHEWAdFVMTG9qmhMa/r20hbJr0iOrkiVFuUBZFyzExsDgzVll5uD7hM4g1ZmTBML9Bpr7eHer2cdvo5i7Q5H3IpOKM/Y8+SeVgsMdYRG9bReapX3UGXKM9BZQdNrOig5FToPMHG5m/QFkRpS71N7GeknUZvc1hHP1dEp0p7/HWmzEP1xVeeOK9TfiHxfLL/epkQgXIMTRSKVb9e9W3FXi8plrgopTlYLDHWEX2S0vOKuAm1mMg9cBsmMLu12YRXxGRYx1y/TIoKN+Eqs9dLy1SM11Hn89FEoMl+RRO83c1DGYaTtccY72GxxFiHyVwReg6MXxYpzhWJt2Uuj8hkfhQlid+EaHcvAs09jNAKxZqzFTs3YselqorFkglYLDHWYTJXxL0t/TYmvFhehwkyuSDa78UKllfE/aHC9uUsObbAlbfHzNxwU6YkmWdJ7zMwNFgsMdahkyuSuTwHE6LCbWItWCkqgpQrksgWfR56LyrciFuzOUveH59DvW9Q5iGldEgmc7FiN4hgBX3Ge1gsMdbhp1wR+20FyyuS7VwRW70itHCwvec1mp3zbuaGri3nO3uW/IdvxFKXLl0gFArFfd17772R30+dOrXe7/GrcePGKd83UZu5c+ca6BEThFwRWxOG3ecsca4IpQ5UtsJVtHPyaF4RW/++TPaLfr0otpIfd4KwZ8kMmlM4u0ybNg3GjBkT+XfTpk0j/3/zzTfDddddF/f60047DY455pi07zt79mwYPnx45N8tWrTI2Gdm9LE9V4RaL4Xy5OvUCKIsvtnIWQp+rogX/XLq9ribGzq1qijCkVYXK0QKZTrtzHmW3BT29HoextePS+xZ4iNPzOArsYTiqEOHDgl/16RJE/ElWbZsGaxcuRIee+yxtO+L4ijZ+zLmMZkrIneSmMxZ8ipXJHHdHiDVCNI7d41Wj0g1VyS+TcjT2kexpSqykYuln29Dz4ExUz8KSPNQNWcp/vPJfuna8nYeus3Fit6j4ucpFrfFopTsWTKDb8JwCIbdWrduDf369YOZM2dCdQpJ/Ze//AUOO+wwOOmkk9K+79ixY6FNmzYwcOBAePLJJyGMcj4FFRUVsHfv3rgvJnOYDVeBwRwYaYsmAim2zOQRNZxcETVb5r0itHlov3fOxJx3c7102mTaFoolhHOWzOAbz9K4ceOgf//+0KpVK1i4cCFMnjwZtmzZArNmzar32vLycnj22Wdh0qRJSqG9U089FYqLi+Htt9+GG264Afbv3y/sJWPGjBlw1113ue4TY0OuiPkcGOoiZSbfxvnOuSLZylnStWV+Hnp9hqIfrhc9FytzY4ihOPQXsGepAYglFDP33XdfytesWrUKevbsCRMmTIj8rE+fPlBQUAC//OUvhXAprJOk8vLLL8O+ffvgyiuvTPsZ7rjjjsj/o8eqpKREeK1SiSUUarGfBz1LnTp1SmuLUcPtGU8mb7AmbFHqEZkVMKDdprZW/3rF5vbojCEl78vN2XBmRTvdU6GfkE8Xt1TRrjM3aPMwTJgbIaKt6PEkmZgb8tgb9iw1ALE0ceJEGD16dMrXdOvWLeHPBw0aJMJw69evhx49etQLwf3sZz+D9u3ba38mfN+7775bhNrqijAJ/jzZ7xj3yBi97g1W3jTS3YgS5Tmo5VSEE+Qs6OQ5qHtFYtvJfuncmKUt/TEMGbQF2gtH9PPpLfSURSp6vWg5MOnESOJzA/VsRcdDZwzVbbkfQ7ttochC8aNrKzqG6vMwttK23n1D2op/TW6u836c4N0AxFLbtm3FF4WlS5dCTk4OtGvXLu7n69atg/feew9effVV8vu2bNmSxVAWiS42uu1ChMN3pS3dxRfItmJ3sqjZoiSug6vkZL1FSl9guRUw+nMjfoHRmxt6ttwIGOrc0LFFFTCqDwhu5yF6YNwIGJ2/Zfn5qGNI+funtqvbJiqWOAxnAl/kLC1atAgWL14MQ4YMETvi8N/jx4+HK664QgibWDBBu2PHjjBixIh674PhOQyhrV69Wvz7tddeg23btsGxxx4LRUVFMG/ePJg+fbooQ8Bkj+jNnCZgdG7McrGhLog0r4ieLcqN2W2/9BYOWp0lNwuOmetlzhZFwGAIyY2A0ekX7rqS6M1D/Taxi7/XIlBeKxMikGor2X1DCmsOw5nBF2IJvTxYKBILT2J4rGvXrkIsxeYNIbW1tTBnzhwR2stN8Ii2Z88eWLNmTeTf+fn58Mgjj4j3wh1w3bt3FwnjsbWcGPNEvQDeL/TUkB9toaeJCnf9om1tNukx83rxjbXltfcAwzpRT5vXAib6/16PYWwIiTaG3nt7KGMY2y+vH0bcjmHdvy+Zs8SeJTP4QizhLrhPPvkk7eswLLdx48akv0cRFZsjhYUoY4tRMnbgNtSi9xQLxgQMVQRSBAxdcLoZQzsFjNPOjICJfcr33gMDxgSMe1tAsuW1gHHbL52/r1hbUujotEuWs8SeJTP4qs4S0zCg7tahLIjUXBGKgKF7RfTbBdUDQ9lRSF183Yol2uIbNmbLhAh0I/Sp4lbnbznWi6UjYGhhuOh9Lbb4KfV6yX5ygrcZWCwx1iEXbBNhHVr4A3NFzOXbmAzr0EJ+NFsSr71YVFERFdLehpCoR5BQEoZjbVGTk20VMLScpcwKGLWx0CuJkjwMx54lk7BYYqxDJ48o8ZZtO0NIVFEhk2v1SiKARpmCUL0nVNrWZvWSCDq2YhcxHQGTyFa666WyZduLHU9ud1fpeZbUHyrkeEhbWD4j9hDXVG0cW/LzgfY8zMurTStgqH//deeGynxKPA+9sRVLsjGU/eScJTOwWGKsw2RtFuqhoqoCxu0uP5OhFvfhKv1xN7HjKdaW1zvU6DkwIbIt9DDk5pqZG5la6L3Z8QguHmDs7VfUVny/uCilWVgsMdZBybdB8SIFjF6oRT5l6wiYkOdP9HXbUNvpCJhYW5Qx1Mu3oY6hbAMkW3oJufTrRRUwlM9nQsBQxiL+b9nb+UTP+6KF/JMJGBVbmdqhygneZmGxxFiHyd06lKc9qgfGrbfH64Rht7ao3h7VhQoLFbopbaAnYNCW3ufLhAfGTAhZtvN2PlHbUcY9NrfHjGfJTYmNzMwNOT6xJQkY72CxxFiH1wImU3kOKjfm2DwHnUWAYiuTISSKQKBcLzMeGO8FTN3rpZtvRwkhUfNtTAmY2HZelzZwX2LDLnGbaG7UbccJ3mZhscRYh8ndOm7rpZjMI7JVwLjZ8aS7SLmZG/TDXG33wIQDJWAy7YFRsWWyppt+vxKPofw3iyUzsFhirIOSR5CtRGiKgDGZxGvCA2OyDhQtV8Rdv0wIGHnyPWVu6ItAuz0wbucGxVamBEymP1+qdpzgbRYWS4x1+EXA4A2WUpuF5iEykcQrbWmZirQrKKDYslfAuNmhRl8QvfdiRUN++mNIPdeQNob2Chg3FdczlZAfLUrJOUsmYLHEWIfbxZciYMzczOm26Lki+m3oB+KaCFfJkg1gcKH3PlxFOQTaD8IsG0f1UMpDmPxb1p+HiXf5RnfDqfeXocNiiQmIZ4m63Vg/5OfWFm3LNnWR0i8dQF8Qw55vRact9LR+0bwH7rai08pDmBAwtH7REtep/aJ4HanzUL9MSabnIXuWzMJiibEOypOl27yU4D3RS1thK/vl9nrR8lLA4I4n3SMtzHhgsPyCm513+v2Sn9HEPKTUWdP/fLHtvM7Fih1DzlnKLiyWGOvQcVfLG4b7XS1273iiH/0S8uQ4hkRHq1COz9Apo+C0C5FtqSz0VFuZCiGZ2aFmch6qCxg8SkV3N5zbMiCUuUudh/S5kXgM5XVnsWQGFkuMdZgMtVDa0UMt5lz3JkMtbmzR86P0bQU1hGTzPHQTyqR6loI6N5KF4VgsmYHFEmMdlBuz21CLySd6r8M67hNQvQ9lUreHUxap2JPlvRfStHkYLR1gd3IytUxBUOeGCa9jMlvSqx67E5jxDhZLjHXYL2DMe3tsfsrOxvZwe6tP07wHZpPJzc1Ds+FF82FTk3WW6u+Gk7/nBG8TsFhirIPiqYjmEJgrBmiy5owfBIxO2FSOO7VfOtvDo9dYLznZbPK/LIkQMugJtFXA6M+N2OtFmxt6tkzNw/icpfify/GRB4gz3sJiibEOyg1W50lP5dylVO10dtAkPv8rva36n4/qqaDsDAKDO4Ns3g2nk5xc9/OFjc1DatK1iTF0FxoDg9XCaQLGqzFUSZKXn5k9S2ZgscRYRzZCY7TaR2Cw9hHVFqUNzTtnMoSUzcRaNVtBTU4GA2fDUa+XX+YhZLTOUm2t3vsxNFgsMdZhMgHVnQfGZG0Wez0w2dj2biZXxC8eGO9FhT/moZskebD2zLtk/ZLjE3uIOOMdmpeNoVJbWwuVlZXZ/hi+oE2bSujcOQTFxZVQXp76jtmsWQV07pwH7dpVQlVVGA46qALKy1Pf0CsqaqFzZ+c5AdtVVoahUSNsl/rZIS+vNmveAzM5MLScCjfeOerRD/Z7YOxN/qflYlFtuZmHYK0nkCbMMuvhlLvh2LNkBhZLBkCRtG7dOiGYmPRMnBgWrvg2bWph3brUAmbYsFo4/vgc4eXBGxgu9OvWpb6BhcNheOyxaNgO27Vtm97WuefWwt69rWD+/Fb/axu0XX76bfzgxTKZl2LSU+F2K7oJDwylWKzb69VQSgdEd8PpvR9jSCyVl5fDww8/DO+99x5s3769ngD44osviB8lmODCvGXLFsjNzYVOnTpBjnwcYJJSVYVeuBzo1KkGmjdPfWcpLKyBwsJc4fWprs6BoqJa6No19RjX1oahtFTegJx2nTrVQrNmOSmvY27ufrj00h3QtGkNPPTQQVZ7D2zP34gKEROJtdQxBIM7uczlwJg6h85tv0zk6cnPZ2ZTg/7nSzWGnLNkuVi65ppr4O2334YLL7wQBg4cCKHYtH2mHtXV1VBaWgoHHHAAFBcXZ/vj+IKcHPzrz4HCwlooKkotfPLz8a6Fdw2nTW5u+jYolgDkvFW3VVRUAC1a5MDpp2+DP/+5xkW9FP02+jtoQGMnl9xVA8oLYk5OiHjMRJjQhjaGdY+Z0N8paW47P2UrOr10gLqAqVv4UG0ehkkCgXK9YuehTnix7jzUmU+6c6Nuv/TKFISS2pLjw54lS8XS66+/Dm+++SaccMIJ3nyigFHzv7/ggoKCbH8U34BPU4ieDqeK9pCmrWJxs2vTpspInoM/PDB2e7Hc7vKjXS8tU6Tr7N6Wt22ytaPQa+8c1WNGucaxXqPkRSmV345xgXZM6MADD4SmTZu6sdkgYQ+ct2KJJrAo7aLiisNw8e1MJkKb3bKtf14bXcCYCFf5JRFazwMjizN6PQ9lG31b9HFP1E7uxuUwnKVi6cEHH4Rbb70Vvv/+e28+EdPgcSeW9BZfqsgyX7yRZksnrBMNY4QN2vJewLjdsm2isCcl+d9tv7y+XriISwHj9TyMPUzW6zGMtUXzzul/vsSeJeff7FmyNAx39NFHiyTvbt26iRyc/Dp/Pbt27crk52MaMCY8S3UZPXo0/PTTT/DKK6+kfa0fwnAmQ0h6Bx+b88BQk3hpAsbu0FisgPE+hETzwLgZC2o7ynyi9ovyd5LIFnuWLBdLl156KWzatAmmT58O7du35/ASk3HQpW7OFkWY2R9Coh046y4vxeSOJxN5KXKx9zpcZTKERF3o3YR19dtR2rjrF+XvRNeWLKNAqW+V6G9Fjk+s94mxSCwtXLgQFi1aBEcddZQ3n4hp0MnwKL6lGKEIGP2cJVo7N2dyqdyY5S6fbCS7mqmcbD4XS88Do7cgRnc8qQuYuteYbgu026i2y5RYonlgvLflpqCq/njkkK9XTg6WLgkl2anIDgsrc5Z69uwJZWVlkA3eeOMNGDRoEDRq1AhatmwJ5557btzvN2zYAGeddZYID7Zr1w5uueUWsXU/FRg2vPzyy6FZs2bQokULURph//79HvfEH7z11ltw4okninFp3bo1/OxnP4PvvvtO/O74448XuWux/PjjjyIs+8EHH4h/V1RUwM033yw2BTRu3FhcuwULFkReP2fOHPHer776KvTq1QsKCwvFNVy+/FMYO/YM6Ny5HTRv3hxOOeWUevW7Vq9eLT7boYc2hl/8ohcsXjwfjjkmBPPn/yvymo0bN8IvfvELYaNVq1bw85//HNavXx8nzn7/+wkwZEgL6NSpLfzmN78R9ZRU0V3oJTr5GxJdAUNZOKj9koLThC03Y6ibHxV0W5TrZWIeRj23NFuUdpQxxIee2NIFXn6+ROKbPUuWi6V7770XJk6cKBa9nTt3wt69e+O+vOLFF1+EkSNHwlVXXQXLli2Djz/+GC677LK4hQ+FElbLRu/XU089JRbj3/72tynfF4XSihUrYN68eaIsAi701157rWf9wLW4pCQ7Xxo6QFBSUgITJkyAzz77DN555x1RUPO8884ThUhx3ObOnRsnLp577jlRT+qkk04S/77xxhuFFxJf9+WXX8JFF10Ew4cPh2+++SbSBmtQ3XffffCXv/xFXAcUuSUl++Css66E+fM/gE8++QQOPfRQOPPMM2Hfvn2Ra41CGUXxv/61EG677Ql49NEpcU9kVVVVMGzYMLFz88MPPxTzpUmTJsK+PHbm2WcfhNdfnwN33PEkvPPOB0I4v/zyy8rjQ72ZmxQVJm3RFgGT/aKdzs5j6N4WRWSZFDCUz6d7NqSbMUz0+aRnicWSGbQvGy42yGmnnRb3c1w0MYQi6wplEvQO3XTTTTBz5kzh+ZGgN0KChTJXrlwJ8+fPF7lUffv2hbvvvlt4P6ZOnZqwztGqVauE9+TTTz8ViesIVifHhfmBBx4QC3+mKS0FaNIEsgI6zBo3Vn/9BRdcEPfvJ598Etq2bSvGGT02v/71r+Gjjz6KiKO///3vIqcN5wF6iGbPni2+y3FELxOON/4cc96kqPnTn/4UF9Y95phTxdNlz55OocgnnnhCeIfef/994d1CYYseLhTsVVVtoXXrXLj++nvgxhvPiBNuKOpQhMm8OrSL74Pt2rQZBv/4xx9g9OjJcOqp58Phh9fCY489Bv/5z3+sXKTo3gMzbaheERYw2fP2UNpRysXhNaYIGKpYotRcy5SA8apfqTxLvBvODNpTBI85MQ2GYDCpHD0b/fr1g61btwoxhOLpiCOOEK9BD8aRRx4phJIEPQvXX3+98Fhgu7pgG1w8pVBCTj/9dGFn8eLFwouSCAwv4ZfES49aNkEPEHrmcCx27NgROdoGBRCO+9ChQ+HZZ58VYgnPvsPxfPzxx8VrvvrqKyGcDzvssLj3xHHDkJ4ERWyfPn3iXrNjxzZ49NE7YPnyBfDjj9vF+6AHCu0ia9asEUfHdOjQATZudMR5794D494DvY/ffvttvZpguJMThVZR0R7YsWML9O49SPwcBVVeXp6YC6qhuOAuvuYEDFWY2T+GNFuU05Coi6+pEBJVwNC8PZBVAaPWLjN/k3JesmfJDNpTH/NHVLjhhhtg2rRp0KZNG3DL2rVrxXf0EM2aNQu6dOki6j0NHjwYvv76a5GPggIqVigh8t/4u0TgzzHsEwsumPL9kjFjxgy46667SH3BE0+ylRKle9rK2WefDZ07d4Y///nPwjuEYglFkgxjYShu3LhxwhuHXiUUq/iFYN4Xnof3+eefi++xYDhMgvlnsTsqUahMnToa9uzZCQ8++Afo3r2LyGU67rjjInZTId8K7Q8YMECIubq0bt0Gli1L3M7PAiZRH3QShqNtgGRLN+Gd2obaL90jYyQNWcBQxjCxLTAyD1UFTP12lLGg2gpn5BpL+yyWzODZqa7PPPNMWo/LpEmTxEKZ6gsTeaVHY8qUKSI0hIsghlTw9y+88AKYZvLkybBnz57IFyYSq4J/OBgKy8aXjiDAfDT04Nx+++0i5Hr44YfD7t27416DCdPoqcHQGoolFE8S9OShRwgPW+7evXvcF3qEkoFOnS+//BguuWScCIf27t1biCX0bEl69Oghxnzbtm2Rn61c+WlkfJH+/fsLzxiK4br2MWm8SZPm0KZNR1ixYnGkHYZ7Udypwh6YeNgDE9tO3xZ1PpnMt6GNIWTVA6NmKzMCxqxnKf5YHsZbiJc7PSqhDEwUxyKAqcDil1u2bKmXo4QLKP5OhmZwAV6yZElcW7mYJluc8ee4mMeCCyYm+qZa0NE2fgUZ3G2I4TLMF+rYsaMYZxS3seAON0y0vuOOO0T+F+YrSTD8huJp1KhRwguI4gl3y2GiOIbdMBk/EThtOnU6FN58829w3nkDoLR0n9jViB4oyRlnnAGHHHIIXHnllTBhwgzYuLEUHnvsdvE76aVC2ximRUGHHs6DDjpIVJ1/6aWX4OabbwGATnDJJTfBU0/dK+w1atQDHnro96IgpSosYKJg5fS6W5u93BlkmwemfjuqLX2CKmAo7fzQr0zlR8m/bc5Z8rlnSQVMFsZSBKm+MKcFPUkoTtDTIcHEYNwGjmEiBMM0mCcTK34wERhLAsSKrFiwDS6Osd6Ed999V3iycJt7QwbztnAXG44Nht7Gjx8vxEddUJRgfhDmLR188MFxv0PvH4olFMXoDUJhhcn0dV9XVyzdccdfYe/e3TBw4ACxAxJDfbHhUgzrYYVtDLWdffax8Lvf/R9cdZWzG66oyBGxuFMOdzairfPPxwTuw8XmAPSE4ZxwPvtEGDFiJEydeiWceOLxIr8pWZ6aH7dsmxQwZhd6k0nh9gsYk3lplHZmy174YR5S2nDpgMB6ljIJLm7XXXcd3HnnnSKxFwWSXLhxOzqCycYoinBxvf/++0XOEYaQxo4dG/ECoecJF2/0bmDtH1xAcXffmDFjxE4oFGC43f2SSy7xZCec38Bkd9z5lspjOGLEiKReRKy5hLldyfK70KtY17OIb9WjRz94+ulPoX//qAfhwgsvjHsdCmnciYcJ3tu25cKyZR+Ln3fp0j3yGvQOYgmJutTWhiP5aRMn/kF8DRjg7Ob0enFLVFzO25u5GVtmhSMv9PHtwJgtWh0oc6LCpLfH5AaPRPNQvg+H4czgC7GEoDjCxQ3FEBbFRM8PeoEwXCS9DVgnCXe/occIQ0QYpsEQjAR3VKF3CkWRBBOAUSBhXg56UzAn6o9//GNW+sjE14JKpV2wHhImijdu3A3++9918OCDN8FRR50AXbseQrFKOraHHmoxFa4CEixgsiNggrvQB7VfkFUvlnwfDsOZQXmKLF++PLJNPxuglwJrH+FXMtDj9Oabbyb9Pe6eq+sFwZ1vmJzM2IFzfUJpBQwWqMQaWphL1bx5GzjmmNPh179+kGSTeryhV7u/nHZhnwkY+8MfXi70mdjlpz433NtiAWN36YC6OXmJc5ac7xyGM4PydMSk3GOOOQb+7//+T4Sp6tavqcsVV1wRyQ1hmEwfbIvhVPySYThJKFRjTCyxgAl+Yi17YNy384eQNreTM1NhU3n/4TCcZQneWD0Zt3Fjsi7ujsIQFx4jkYxHH300IzWWmIaFqlhKBrUdBRYwftuyrd+GBYzf5iHVFqVNdnfDcYK3pWIJdzvhcRe4jR+LEOJONCxQiVvE8WyvVEUcGcYUFLFE9yzpt2EBU7cde5aCL2DsT1w3G/LLTO4cJ3hbXjoAE6fxMFv0NGH1bNyN9sgjj4gt2uecc443nzIA6Jxm35Bx61mioGerVnxGfJqj7GrD3XAUTB79ENx+mSl+aXrxpV0vqi0zbajtgtqvRG3kzkT2LPlgNxxWQ77ttttEYjVWtX7jjTcy98kCAiamY6IyFmTEulKUXVcNifJyrNaeI8RleXn6saquxjtFbty/y8tT342c0gHxR6yks4Wvqawsh/LynbBjRw5s3VoAubllYPfCwQImW14Rymc0u9Cbmxt+EDBmi21mZgyjB+nymmK1WMKCfxiWe/HFF8WWezyFHov+MfFgSQOsHv3DDz+I0CWTmoqKMOzYERIL/bp16W8Cu3bVwr590TtJTU0t7N+f+u6MnqGY01OEraKi9LZ+/LEW5s9vAo89djBUV+dYt3Co7KDx6gw11X7VfVgweSaXinikjqHfFl8vxW2m5qG3c0P/M1LPycvM+XqpxJL++zEei6XNmzfDnDlzxBee6H788ceLmkQolDA8xyQG6wEdeuihcfWdmMT8978VcN11hdC6dRV8/HH6ZIznniuBOXOic2/KlBIYOTL1XKyqCsOZZ0bvYO3aVcEHH6S39eST5fDgg80hHA4F+onerAfGXJ0lSr/YOxdPQxaBto2hDMOxZ8kysYSVmufPny92uOGW7auvvlocYcGoe5jwi0kNPiV9/30RVFbmQlFRegGzd2+1eL2ksrIGioqi/0524/n+++gNpqYmB4qKCtLaqqiojggl533SNklgW78N3Zb9hSJpAoZmy/brle3FV62dmTb+GEOarUx7ljhnyTKxhLk3//znP+FnP/sZL/qMZ8g/fH6ij4cThv3lnbN9HvpjztsuYLI7D6MH6bJnyQTKt+BXX33V20/CMOIPPxzwmzknDLu3RTLFCcMNQgQ2nHnIx52YhfgnwzBee5Zo7TnfJvgLhx/mhu1jyPPQ/x4z6VmqqWHPkglYLDFWiiUv822ou1Pq3hwpu3VUBZZXO2i8atfQBYzZHYXmdo3VheehmX6pzKeoZ4nFkglYLDGWiqWg5tuYs9XQBUwm2gVl8c2mreCOoclz6JKfDcdhODOwWGKszFkKar5NUIWZHxZf2/vF8zATtuw/SDdTu02ju+HYs2QCFktMwMJwZtqYtmW7t8cPi6/tY8jzMBO2wAdzPjPeb1lnCcuZyIdMxjtYLDEBC8Ppt+FwVfZs8Rg2hHAV2/LCVuyBvFhol/EWFkuMr3fDUZJdg7r4UhOG62LyCJJMJbt6ZauhC5jMJJPrfDJTcyOctXmY6d1wCOcteQ+LJQYaep0l9h40jDG0vV/ZThi2rVwG/32p7YZDKivZs+Q1LJYYq6itleeucb6Ne1s8hg0j38buel8NScBkYzccwmE472GxxFiFnzxLDTnklylbQV0Q/ZgwrGbLTBvTtuyfh6GEP5OePhZL3sNiibEKP1Xwtn3h4Cf6htGvoI5hUK9XJu9R8ucchvMeFksMNPTdcCxggrFw+D3fxg+iwv55aH/eVybnhqy1xAne3sNiiWlwdZYydcyEbTu5/Lhw2H6+ntkjSOybh3Wxfx5mNzSmAu2YpGTvJcNwpI/CaMBiibEKP3mWOGHYXwnDtnsdeR66bxfU8L30ICX7DJyz5D0slhiryE7OUjAXX04YjofDVe69IrYLmGSiwu/zMLlnyfnOYTjvYbHEWEVNTdB3wwVTmPlhDIN6vWz3LJkUMCaFGdUWpV2yMZRhOE7w9h4WS4xVyEMhOd/GfTs/iAr7BYz989B2IR1UzxLFFt4zcnIyJ8zknGHPkvewWGJ87VmiHrsR3wYCUaCPmsRb9+Zt2zET9T+f6tEqYauP6jCZMJzNxHVVUVH3M6nNw7DrfuF7qAiYuq9RtxV29YCVagxlFW/OWfIeFkuMlZ4lzrfJni3bwzpBzbexIWHYljFUFTCZ6Bf978ScrXSeJd4N5z0slhgrK3gHNVHTD7ZsTxgOar6NHzyclOtsv4ChhuHNtEmds+R85zCc97BYYgJVOoAFTPA9S7Z7RfycMGyPqPCDgDGZH5nsM3DpAFP4Siy98cYbMGjQIGjUqBG0bNkSzj333Mjvli1bBpdeeil06tRJ/P7www+Hhx56KO17dunSBUKhUNzXvffe63FPmGTU1vpHVNjuFeGEYX8JMxsShtPZohBUoU8Zj0zPXTlnOAznPcRbgXlefPFFGDNmDEyfPh1OPfVUqK6uhuXLl0d+//nnn0O7du3gmWeeEYJp4cKFcO2110Jubi7ceOONKd972rRp4r0lTZs29bQvTHKkO9kPN0v7PUv2JQw3BM8SNd+GLmBsD41RxsK/AsakMJPXhMNw3uMLsYTC6KabboKZM2fCNddcE/l5r169Iv9/9dVXx7Xp1q0bLFq0CF566aW0YgnFUYcOHTz45Azds2TyKZYThuPbQeAEjGPLdlFhzpZZz5LdO1TpfyfZ71d+viwdwGE4r/FFGO6LL76ATZs2QU5ODvTr1w86duwII0aMiPMsJWLPnj3QqlWrtO+PYbfWrVuL90ZBhuIsFRUVFbB37964LybTniVz5y6pb0XXt1XXw8AJw9kSMN7mwMTODVVRkYkzClXbZGIe0r2i5jxLJgWMl/1SvUfJz15Zqf1RmCB6ltauXSu+T506FWbNmiXyjB588EEYPHgwfP311wkFEYbhnnvuOZHnlIpx48ZB//79xXtgm8mTJ8OWLVuEnWTMmDED7rrrrgz0jLHDswSB9Cz5I2HY7nCV7SLVD0nXQREw9W2ZaeO0S+dZor0v4xPP0qRJk+olV9f9Wr16NdT+bwWdMmUKXHDBBTBgwACYPXu2+P0LL7xQ733R4/Tzn/8c7rzzThg6dGjKzzBhwgQhuvr06QPXXXedEGEPP/yw8B4lAwUVeq3k18aNGzMwGky2cpaCmm/DCcPu2iCcbxOFBYz7dpnuF5cOaCCepYkTJ8Lo0aNTvgZzj9DTUzdHqbCwUPxuw4YNca9fuXIlnHbaaSK5+/bbb9f+TLjbDsNw69evhx49eiR8DdrGL8Y7z5LJQpG259twwnBdW8EM69iQMJy6DclUgxMwmW6Tqp38u+MwXMDFUtu2bcVXOtCThOJkzZo1cOKJJ4qfVVVVCUHTuXPnyOtWrFghdspdeeWVcM8995A+09KlS0VuFO6sY7JXZ4l6REIw823UXkc9ZiL2OAaqLZO5PZQcM/rxOQ1bmMWPIfV6eZeLVReKLfrc0G+XaU9gQYHznUsHeI8vcpaaNWsmQmQYVsOyACiQMBEbueiiiyKhNxRKw4YNE6G1rVu3ip9j6QApyJYsWQKjRo2Cd955Bw488ECxW27x4sUwZMgQsSMO/z1+/Hi44oorRB0nxn/HnXC+jVtbQIIThmPbkEwFuF+UNua8PWY9Zpm9XgUFzs/Zs+Q9vhBLCIqjvLw8GDlyJJSVlYlw2bvvvhsRNf/85z/hxx9/FHWW8EuCwgo9UEhpaanwTqFXCkFv1dy5c0XiOOYode3aVYglFFuMPzxL2c234YRhCScM+y2sE9R+Udpk9nDb1LYyneDtfK+s5NIBXuMbsZSfnw8PPPCA+EoECh78SgUmcofD0UmFu+A++eSTjH9Wxr1Y4nybKJwwXLcdH5YcdAHjBw+nSc9tss8ow3DsWfIeX9RZYhoObjxLXKAvHk4YbghhHXO2/FBQNahnw7FYyj4slpjA7Ibzw9NoUPNSbFg4Mt0myMLMdiHN81CtXTRniVbEl1GHxRITIM8S59s0BGHG4arYNvZfL7OlHsy0obbzajcce5a8h8USE6CcpaDm2/hh4Qhqv/TbBNfDSbVlpg21nZ/7xWLJHCyWGEs9S9650+vumPMy3yYTtVnYA+O+nddCmlKPqP489K5uD3Ue+i28GJTdpqrXi8WSOVgsMZbWWbI7TMALh/t2nG/jr3loNrxIs9XQxpDFkjlYLDGB8SwFNd/GD8KMBUwU9s41bAFjNmfJ+TlX8PYeFkuMlbvhvDzSIqj5NpkJ+dFCSCaPIFEPjYWyFK7SbxOk8KLJMaw/D82FMinz0DvPEu+G8xoWS4yVnqWgCJhMtOOE4bq2gumds30e+mPOm9ysAdbUWWLPkvewWGKszFnim7m/CvTZsHBkuo1pW7aHq4IrAv07D9mzZA4WS4ylnqWgChi78238vHD4fW7YPoY8D+2bh4WFznf2LHkPiyXGypwlszdYuwUMhxfj4cU3Co9hww75yQRv9ix5D4slxlLPku2Vrqm2zLShtuPFt2EvvrbYCu4YhjPar/x85zt7lryHxRJjac6S7QKGc0X8ZCu4Y8jz0DYBk9oWyVTSz1hYKEsHsGfJa1gsMYHJWQqqpyKouSJ+WHxtH0Oeh5mwBT6Y8+nOhmOx5DUslhhL6yyBdTc9k7VZYt+fF1/7BUwm6kfZOA/9NjeCItpV50bUs6T/WRg9WCwxVhH03XBBXTh4DBtCvg3NVlD7ZcMYRusssWfJa1gsMVZRW+v80fMNNgovvsH0HmTGlslwlf3lMmwQMF7YSu9ZYrHkNSyWGKvwS84SL74NYwyDm29je7kMc7b8LMxYLJmDxRLj6wremTkbzkwbrxffzJwNp99Gpx2lDf1MLve2bBe3mU4Y9iI/iudh2MM6S853Fkvew2KJCUyCN+fbuG/HT/QNo19BHcOgXi/2LGUfFkuMlWG4oN70WMC4t8X5Nu5tsYBxb8uGhywpljDXs7qa9t6MGiyWmAAdpMv5Nu5tccJwLJxvky1b9s9DWr9CnniWkIoKFktewmKJsQqb6yxlwhYnDPtLwPA89Ns8zL6AyYZnCWGx5C0slhir8E+dpWAuvl4nDGfGlpk2CIer3IsK+/+Wwz6us8RiyRQslhirCHqdpaD2K6hjGNTrZbtnKS8vmGNIFYHJ2qGAzctzrguLJW9hscRAQ6+zFNR8G9sXDj/YCuo8tF1Im/QsmfRwUkQg3jNycpL3Kz+fxZIJWCwxDdKzFF/7RL+OkckaQRxetF/AUGrpZKYekf588kPiuknPEsUWXu9UAsbtGMa+d7oHLCmWKiu1Pw6jAYslxkrPEuXGTHdx69/06i4+6rbMtDFty2TOEq1foYCOIdXDaU7cUmzR/75CDe5vUoql8nL2LHkJiyXGSs+S/Z4Kmi0OV7m3xeEqf4WrKO0o3h56aJzSxp75VFjIYskELJYYqwiH/bFw2Cgq6j5VexmuooZ1Yj+j98e4xIbG9D8f0tDDVbFjr2qrbghJ1dvj9mgVHQET+/60+aRsqs4YZt57WFDg/L6sjMWSl/hKLL3xxhswaNAgaNSoEbRs2RLOPffcuN+HQqF6X3Pnzk35nrt27YLLL78cmjVrBi1atIBrrrkG9u/f73FPmHR1lvzuGk8Gh6vch1o4XBX8cJXJhyWz4x7O+OcrKpKeJdpnYtQgPpeY58UXX4QxY8bA9OnT4dRTT4Xq6mpYvnx5vdfNnj0bhg8fHvk3CqBUoFDasmULzJs3D6qqquCqq66Ca6+9Fv7+97970g9GtSil7aICfODyZ1GRHWEGVo+hc43N5Ok53hgztvyQK0YbQ7UwHHuWvMUXYgmF0U033QQzZ84Unh9Jr1696r0WxVGHDh2U3nfVqlXw1ltvwaeffgpHH320+NnDDz8MZ555JjzwwANwwAEHZLAXjArhcMiIgJF2/LAgBtfbQ7MVVGHG3h537WLDZNn29pgUZtKzVFZG+0xMgMJwX3zxBWzatAlycnKgX79+0LFjRxgxYkRCz9LYsWOhTZs2MHDgQHjyySchLJNgErBo0SIhrqRQQk4//XRhZ/HixUnbVVRUwN69e+O+mEyfDWf34sveHve2WJi5X+jp3h4ztvwQrvbC22NS3BYWOt/Zs+QtvhBLa9euFd+nTp0Kt99+O7z++usiZ2nw4MEi50gybdo0eP7550VI7YILLoAbbrhBeIqSsXXrVmjXrl3cz/Ly8qBVq1bid8mYMWMGNG/ePPLVqVOnjPSzoVNbS0ugjLbhs6tiaejJydkqK2FSpNJ2jVFtmRT65rw9thelTS+WOGcp8GJp0qRJCZOyY79Wr14Ntf9LZJkyZYoQQQMGDBC5Sfj7F154IfJ+d9xxB5xwwgnC+3TrrbfCb37zGxG6yzSTJ0+GPXv2RL42btyYcRsNOV/JD+Eqm9zwydsF07NEuc7UftkeQjLrFfF3uCqo/Soqcr6zWApwztLEiRNh9OjRKV/TrVs3kYBdN0epsLBQ/G7Dhg1J2+LOubvvvluEzfD1dcHcpu3bt9fLj0JvVaq8J3yvRO/HZE4s2S4qOI/IfTuTAoY6hsE8wNgPwsxMmyAUpeUE7wYgltq2bSu+0oGeJBQna9asgRNPPFH8DHeurV+/Hjp37py03dKlS0W4LpmwOe644+Cnn36Czz//XNhA3n33XeHJQqHFmKWmJrpzxkZvT+z7qy44dW+qlPoxQfX2UK+X2bw0/RpBqmNIPdKGUlsoE8fnBNXbYzJn0Yvr1aiR872igvSRmCDthsMaSNdddx3ceeedIj8IBZIMr1100UXi+2uvvQbbtm2DY489FoqKikTeEpYZuPnmmyPvs2TJEhg1ahS88847cOCBB8Lhhx8uygxgSYLHHntMCLAbb7wRLrnkEt4Jl8WjThD29kRhb0/wvT3+CMOZaeO0MzeGfu+X3A1XWkr7TEyAxBKC4giTr0eOHAllZWXC84NeIPQcIfn5+fDII4/A+PHjxQ647t27w6xZs4QQkpSWlgrvFIoiybPPPisE0mmnnSZ2wWFO1B//+Mes9LGh43iW6AuOySMtODnZPdQxtNGz5HYeNtTk5IZ2zIw3x50439mz5C2+EUsohrD2EX4lAj1EscUoE4G75+qWEsCdb1yA0sacJfAs/JEZTwDNFqUd9RR7VdweM6FnK+wyXEULjale40yEq0xusfdawLgfw7CV4UW315neL4ottTBceblBV20DxBelA5iGgdsEb5O5PX5IJqVgMgxnNiSpLyrMim8OwzWMMJwXFbyd77wbzltYLDFWhuFM5hF56e3JBCZDYyaFGU3AmCyo6IdwFSddB9+WWukADsN5C4slJkAJ3jS77O2JtWWuY1wR2r0t+/9OGqa3x+Q8LC523pPDcN7CYomxtCiluYrQQUxOpkJJ/jVZOZ0uliheEZP9CjfI5ORMtgtqkny6sYgWpWSx5CUslhjrwnDUG5FJb49Zz5Ld3h6zB5hSbdldssGmsE5mbQWn9lF8G3s2kzRq5LyAw3DewmKJsc6zRF18g5pHRF0EKHC4im0FNVzl33moetwJe5a8hMUSY51nyeRNjwp7e2Lb2F+ywWw1c7tt2bTQZ7JdUOdhujbRBG8WS17CYomxLsHb5M2cCnt73LUxfeCs7bZMhsaC6u0xK2DsCWVGw3AslryExRJjYRjOTm8PpQAm9QiWbG2x563otDahmAlBKezpdUHF2Hnoh+tl/0HaJFOkuZHuXiN3w7FY8hYWS4w11NaGjd/MqVB20FAx+URv+xlqJndX+WMnl8l+2T0P/XC9vOgXe5bMwGKJsYba2pD2DYVyHEMmMOnt8dpTEftaL558M+kV0RlDt8e4mPTOmSyo6rUXKzPHnXjXpi4075y5e1S6MZRiiRO8vYXFEhOY3XBmc5bs3oreUPM37LBlriSC35OTG1oulhdj2KSJ8/nLynIi3nkm87BYYqyhutrdbjiTYThOGHbXxrQt25OT/bFDzUwbf9iyZwybNs2JeObLy1kseQWLJcY6z5LJ4xio2H8zD6YtulfE7oN0+XrF09ATvHXGUIolZN++mGMQmIzCYomxrs4S/QZLaRMOaAKqyeMzqMeCgMFjJszZsj1h2KbkZL/asmkM8/NDUFDgiCQWS97BYomxzrNk8tyl4NbtIZkKbLjKfm9PUOeG/f0Kwhg2auTcPPfv5zCcV7BYYhp0GM4PN1j7k5Nptjg5mW1lsl1DDpsWFzt/t/v2sVjyChZLjHUVvHlB9NdWdD94zOzfUUizxd6ebNmyawwbNXI+D3uWvIPFEmOhZ8n+ox/MhuHs3ooe3EUqmPPQD4LT/nlo1xgWF3MYzmtYLDGBCcN5nZwce9OiVPCmFtukJSfrt6G2C2piLbXwoOrciC9WSLOl2i4TxRttnxtB2qyhe40bN3b6XlJC+1xMelgsMdbthvPHE6LdW9FNeiqo2B+uotni5P9YW/b3KwgeM5mzxJ4l72CxxPjasxT7Wvtze2i2vD6qw+QxE+6PIAESNtpy28aEraDODduPVolvE1YWS+xZ8g4WS4x1Cd5mT0U3mdsTzKdsHsPs2eIxDL7XUWWXb3Gx8509S97BYokJTM6S/cdMsC22lZigerGC2i/bHhCaNGHPktewWGICI5YoSde2JgxnyxaPYWwbamVyb5P/3bbzgy3aGAbzeqnM+caNne8slryDxRITmONObN8ebtvTaOJ2EMiwjv2hloabnJypdtSzIU1eL0oiv9puOOd7SYm58zEbGiyWmAZdZymoCyLbct8uuKKdZCrADwj+39kqxVJpKeFDMUqwWGIsPBuO1p49Ff6yZb/HLKhjSLMVVG8P5TPado9q3NjpA3uWvIPFEtOgjzsxe5AuyRTbctmGbTUMb09wvY7pX9OkifOdxZJ3sFhiAlTB2/anbPvziOwfQwjkGJpdfIPp7bFNwJj8+2rWzHnf/ftZLHkFiyUmMBW87d9dBYHcrWPymAl6roh+m+DODXPenuDuvLOrXy1aOH3Yu5eXdK/w1ci+8cYbMGjQIGjUqBG0bNkSzj333Mjv5syZA6FQKOHX9u3bk75nly5d6r3+3nvvNdQjJpbw/+7FfICp+2rBwfX2gJUes9hwrmq7WO+J17YyUZncfo+Z/bZUx1D3Grds6bzvvn2+WtJ9RR74hBdffBHGjBkD06dPh1NPPRWqq6th+fLlkd9ffPHFMHz48Lg2o0ePhvLycmjXrl3K9542bZp4b0nTpk096AGTjtrakJXJk5laOKhQP6MpW0Hdim5WVNAeECjtgiQq/GBLPgTqtou2SX+NW7Z03pjFUgMXSyiMbrrpJpg5cyZcc801kZ/36tUr8v/obcIvyY8//gjvvvsu/PWvf037/iiOOnTo4MEnZ3Sortavs+TeA2N/HhHFe+C1F4vqFYl/D8rnUx9DymfM3vlfISu9PbafDZe9eWhSLKW/YK1bO0+YFRU5UF5eC0VFLJoyjS9G9IsvvoBNmzZBTk4O9OvXDzp27AgjRoyI8yzV5emnn4bi4mK48MIL074/ht1at24t3hsFGYqzVFRUVMDevXvjvhj3BD/B235bQQ21mJwbNG+P/SUR2NtDu15yl6+XOwqbN492Yvfu/91ImYYnltauXSu+T506FW6//XZ4/fXXRc7S4MGDYdeuXQnboEfpsssui/M2JWLcuHEwd+5ceO+99+CXv/ylCPP95je/SdlmxowZ0Lx588hXp06dXPSOyZxYCmYSr+1J1yYTa+nXK2z18RnUfgUhOTmRgPF6zscKGK/HUKYX6LaLtkn/+bAPjRs7ndq1i8VS4MTSpEmTkiZly6/Vq1dD7f9W0SlTpsAFF1wAAwYMgNmzZ4vfv/DCC/Xed9GiRbBq1aq4kF0yJkyYIERXnz594LrrroMHH3wQHn74YeE9SsbkyZNhz549ka+NGze6HAkmexW87U8mt99jZr9XhBLmMrnFPqh5ejq25N+/brtom5BBzxKtX17WqmrWzDHEnqUA5ixNnDhRJGGnolu3brBly5Z6OUqFhYXidxs2bKjX5i9/+Qv07dtXiCpdcLcdhuHWr18PPXr0SPgatI1fjF2epaCGxoIqzOxPTg5qnSU7w1WmRIVpYebWlurcaNq0FnCp3L2bNm8Zi8VS27ZtxVc6UPSgOFmzZg2ceOKJ4mdVVVVC0HTu3Dnutfv374fnn39ehMooLF26VORGpdtBx2Qe6RoP7lO2Hzww5mzZ7zGz3xZ7e2iC00/CTPV+yJ4lb/HFbrhmzZqJENmdd94p8oNQIGEiNnLRRRfFvfa5554TnqErrrii3vssWbIERo0aBe+88w4ceOCBIly3ePFiGDJkiNgRh/8eP368aIs5UYxZ5E2Fj+rwl7fHDwfOBkmYxebABCE5OZEtr0OZNTUhHwkztdc1a+aM9U8/sWepwYolBMVRXl4ejBw5EsrKykS4DEsD1BU1mNh9/vnnQ4sWLeq9R2lpqfBOoVcKQW8VJndj4jjmKHXt2lWIJcxjYvwXhjOZ7Go2sdbu5GR/jKHX4aqQwYRhcGmLFkLyKjk5kS2vk+Td2srTWDndjqGuWNqzR98GEyCxlJ+fDw888ID4SsXChQuT/g4TucMxvt7+/fvDJ598ktHPydCprQ0HOjmZ7oEJjlckuOEq/aradFu0dvbnEbnz9lAFp/eepZCre4Bqv5o3d77v3q1vgwlI6QCmYSBvKv5IrLU9OTmYuVg6uBUw1AXR9jwinX6ZzSMK+6jOEvV6eXePatXK6dSuXXyYrhewWGKsq+Bta4J3fAVfb4VZ7OfyWlQks2vjzjtq3R4bd43Fn9cWJtYjUj1rLDs7uaj1iEzmEVH+lqleLAqqY9G2rdOPHTvc2WMSw2KJsfAg3aB6e7z1mPnh6Ae3trz29lD75TY5WWfBdm/L2zAcdR5ShFns9fJawFDnYay4paDaL7mxfOdOXta9gEeVsQa5uPmhRpD9FbxptuxPTqaGdcDyflE9S+Z23nlvK7ad16FMd6EqaoI3BdV+tW/vvJDFkjfwqDLWUFNjdxjOX+dk0RZfr8fQvVfEzi32JvOI3G7npwpOL5OTM+GBoQozCtSQHwXVa9yunfO6XbuIN1AmJSyWmAZdZ8nW3XAmiwG6XXxNJgybPWbCztwes0nXsYIzZLmoMGfLpBdL9R7VoYMzAD/9lBt58GQyB4slxhrkoh1cb4+dx0yYFTD+2TVmdos9kGxRHixMemBs9fa4zyOiCWkv+9W+fW6k4OaOHTFPQExGYLHEWIO8qdgahvOXV8RcNWM9W+FAhvzc2qKG4bzeyRVriwK1qjbNFs2bSoEqpL3sV1FRDjRt6nRs2zY+8iTTsFhiArMbzuuqv24Ta3WSeONDYxRbtLwU75Ou3SUM25pMTtnOT08YdhvWCWYekc7flykBY7pfrVo5N46tW9mzlGlYLDG+DsNlKznZ9jCc2fyoYB5gamsIyU+5PTaGq0wLTvehTPXP2ratc5PavJlzljINiyXG12fDmd1dlR1b3ufAhAI5hvGCk5OTs9Evau6c7cKMeowLzZb6aw84wOnYDz9wGC7TsFhiLBRL3lYz9sPRD2ZFYDgr3h7qrkdzeSnqrw1uaMxdv4IqzHTEt8nrdeCBzvcffnBnk6kPiyXGGuTiZvJATJ0brMkwnNt29O3hXtsyl5xscpGi2KKKRbe2qCURghWGA6vDcNQq6Acc4EyOTZv4fLhMw2KJ8XWCt0kPjFnPUna22Kt+RpOLL/UIEreLFNUTSIE652m2wgavl7fhqvjjToIzD2PRsXXwwc6H3LyZC1NmGhZLjDXImyXVxc1HdVBtufX2mMxLMbdImTzSgrqj0PaQn9ldY+bG0FZbBx/svHjLFhZLmYbFEmMNUiDYuuMpe0d1mMsjokCtFk6zZWe+jb+22JtMhA5O2JRqy+QYHnKII5K2bcuDsjJO8s4kLJYYXx930hCO6qBgMi/FZGJtkPJS/LGTy60t9dcG1ZbZBO88KC6uEQ8K33xT7c4wEweLJcbXCd5m6yy59fZAIBfEoG6xN3vWmK2C00/1iIJpS0dI432pS5cq8f+rVrFYyiQslhgLc5bU21RXZ2eLvf1JvHaKCj/1i5qQ770t8NGxIObGMLi29O47Xbs6F+3rrzkMl0lYLDG+LkrptvCg2URNk8cxBPUEdh1brkxpJfH7yZbJ8gtBtaVzvUyG4ZDu3R2D33zD5QMyCYslxtcH6fpp8TWbRwSBtBXU0JitFaH9NTeCmfelm4vZs6fz+tWreXnPJDyajK8TvE2Gxvy0+JrMS7H3qA4/VZ9mIe0nAWPrRgPk6KOdmhcrVxZATQ2fEZcpWCwxvj5I1/1TNq2Ct/15KeYEp8kt9mbr9tgpYPx03IneGJoUt+b6FQ6b8wQiRx1VAIWFtVBSkgurVzvJ3ox7WCwxPg/DubNp9ugHCKRnKajeAw6NmQ0vmhTSQa2zhOTnh6BHj0rx/598wmIpU7BYYnx93ImfQmO23mDdHv3gtbiNteW1F4tqy/bjMxqCLZPz0FZbkoEDHdf0u+/qt2USw2KJsbDOUjDDH0GtR2Rr+COoYTg/ebHsHUOTtszNecnw4U6bBQsKXIfZGQcWS4yFnqVgHtVhcpdfUPOIbF0Q/XRUh8k8IltFoMk8ItOlA5ChQ4sgP78WNm/OhxUrOBSXCVgsMdYgi7eZ3Wli6w41d7ZsDWX6K48oqMeC2Bl69lOY29YHBEnTpjlwzDEV4v9feonFUiZgscRYg3QXm7wRmazSbLKCt8mq2rZusXdffToUyLlhclemrVXr/XSgM0UsIRdc4PyxPf10PofiMgCLJcYa5E1Fp9K125tenlOSRAm3NxwdW37aHs7Vp81WhA7q9TLZL7dhOFvPKIzlqquKoFGjWli7tgDmzi1z9yEYFkuMjcedmNsCHNQih0GtZsyhMdOhMZP1iIKZz2a6grekZctcuPbaUvH/U6bkQVkZnxUXeLG0YMECCIVCCb8+/fTTyOu+/PJLOOmkk6CoqAg6deoE999/f9r33rBhA5x11llQXFwM7dq1g1tuuQWqY09nZaw+G85fNz1ztuytZuw2JGFnrkhQK0KzLfe2TBeljOXOOxtB69bVsH59AVx5ZRlUV3M4LtBi6fjjj4ctW7bEff3f//0fdO3aFY4++mjxmr1798LQoUOhc+fO8Pnnn8PMmTNh6tSp8MQTTyR935qaGiGUKisrYeHChfDUU0/BnDlz4Le//a3B3jHZFEtB3WLPu+H8tZPL3jEMpi2THrNsJHjHepcef7xSPDy98EJjOO20clixwilYyeihkUWRPQoKCqBDhw6Rf1dVVcG//vUv+NWvfiW8S8izzz4rRM+TTz4pXt+7d29YunQpzJo1C6699tqE7/v222/DypUrYf78+dC+fXvo27cv3H333XDrrbcKoYXvo8N331VCkyY8EamUloaML1JBfaK39Wbup91Vto6hn0SgrR6YoF6vRFxwQTHMnl0CY8Y0gg8+aARHHIFHopTDwIHVcOihAB06hKBVqxxo1CgERUUAxcWhlHM/lKY76X8f9sSzTP1c+/dXBkcs1eXVV1+FnTt3wlVXXRX52aJFi+Dkk0+OEzjDhg2D++67D3bv3g0tW7as9z7Y5sgjjxRCKbbN9ddfDytWrIB+/foltF9RUSG+JOjVQvr3R9t6Aotxd3MoLna3Iuro4eJiV6YgP1/9tY0bu+uXTpJ8kybmEtebNnXbL/XXNmtWayyU2aKFW1vqr23ZskbUzzEhAlu3roEdO/KMPIy0alUDe/fmGulXmzbVsGlTgZHr1a5dFWzfnp81sYSMGtUYjjiiAm65pQbefbcYli0rgmXL3L9vMCgIrlj661//KkTNQQcdFPnZ1q1bRVguFimC8HeJxBL+PFYo1W2TjBkzZsBdd91V7+cFBbUQCnESnRvwJjZkiPq0HD8+Fz76qAouugjFaxPldhdfXAIff5wPV1yhfsO85ZYcWLKkCi67TM/WhReWwOLF+XDppeq2Jk/OgaVLq2DUKD1b551XAp9/ng8XXVSo3GbKlBxYvrwKrr5a3RYuTGefXQpffpkHP/+5er/uuANg5MgquPZadVtFRTlw5pmlsHJlHpx1lnq/pk4FuPLKKrj+enVb+FQ9dGgpfPNNHgwbpm7r7rvDcPXVVfCrX6nbat48B047rRTWrcuD005Tt/W739XCtddWwfjx+ETcWKlNmza5MHhwKfzwQy6ceKL69Zo+vQZ++ctquOWWcuV+tW+fCyedVAZbt+bAoEHqtu6/vxpuuCEHJk2qUO7XgQfmwXHHlcGuXTlw9NHqth54oBp+9ascmDJF3VaXLvkwaFAZ7NmT878HY1VblTBhQgh++1t1W4cckg9HH10GZWUh6Ns3Mw/g/fsXwjvvAKxfXwVvvlkJ//0v/n8IduzIgZKSEFRUOF9lZfrqLBw29zuqBzLZ+9XW1kKlgnMpFA67dVbTmTRpkvD8pGLVqlXQs2fPyL9/+OEHkZf0/PPPwwUXXBD5OeYroVh6/PHHIz/DEBuG4/D74YcfXu+9MTz3/fffw3/+85/Iz0pLS6Fx48bw5ptvwogRI5Q9S5hQvmfPHmjWrJnGCDAMwzAMky1w/W7evHna9TurnqWJEyfC6NGjU76mW7ducf+ePXs2tG7dGs4555y4n2NO07Zt2+J+Jv8dm+9Ut82SJUu02iCFhYXii2EYhmGY4JNVsdS2bVvxpQo6wVAsjRo1CvLrJIAcd9xxMGXKFJH8LX83b9486NGjR8IQnGxzzz33wPbt20XZANkG1WWvXr1c9Y1hGIZhmGDgi9IBknfffRfWrVsnygbU5bLLLhPJ3ddcc41Izn7uuefgoYceggkTJkRe8/LLL8eF9DB0h6Jo5MiRsGzZMhGOu/3222Hs2LHsOWIYhmEYxn9iCRO7seZSrOCRYMwRSwGgmBowYIAI8WG9pNiyARiTXLNmTeTfubm58Prrr4vv6GW64oorhNdq2rRpxvrEMAzDMIzdZDXBu6EliDEMwzAM47/121eeJYZhGIZhGNOwWGIYhmEYhkkBiyWGYRiGYZgUsFhiGIZhGIZJAYslhmEYhmGYFLBYYhiGYRiGSQGLJYZhGIZhmBSwWGIYhmEYhkkBiyWGYRiGYRhbD9INCrIIOlYCZRiGYRjGH8h1O91hJiyWMsC+ffvE906dOmX7ozAMwzAMQ1jH8diTZPDZcBmgtrYWNm/eDE2bNoVQKJTtj+NrhY+Cc+PGjXzGnkt4LDMHj2Vm4HHMHDyWmQMlEAqlAw44AHJykmcmsWcpA+AAH3TQQdn+GIEB//j5BpAZeCwzB49lZuBxzBw8lpkhlUdJwgneDMMwDMMwKWCxxDAMwzAMkwIWS4w1FBYWwp133im+M+7gscwcPJaZgccxc/BYmocTvBmGYRiGYVLAniWGYRiGYZgUsFhiGIZhGIZJAYslhmEYhmGYFLBYYhiGYRiGSQGLJcZTpk6dKqqax3717Nkz8vvy8nIYO3YstG7dGpo0aQIXXHABbNu2Le49NmzYAGeddRYUFxdDu3bt4JZbboHq6moIOh988AGcffbZorIsjtsrr7wS93vcm/Hb3/4WOnbsCI0aNYLTTz8dvvnmm7jX7Nq1Cy6//HJRuK5FixZwzTXXwP79++Ne8+WXX8JJJ50ERUVFoirw/fffDw1tLEePHl1vng4fPjzuNTyWADNmzIBjjjlGnFaAf4vnnnsurFmzJu41mfqbXrBgAfTv31/s+OrevTvMmTMHGtI4Dh48uN6cvO666+Je09DH0Si4G45hvOLOO+8M9+7dO7xly5bI148//hj5/XXXXRfu1KlT+J133gl/9tln4WOPPTZ8/PHHR35fXV0dPuKII8Knn356+L///W/4zTffDLdp0yY8efLkcNDBvk6ZMiX80ksv4Y7V8Msvvxz3+3vvvTfcvHnz8CuvvBJetmxZ+Jxzzgl37do1XFZWFnnN8OHDw0cddVT4k08+CX/44Yfh7t27hy+99NLI7/fs2RNu3759+PLLLw8vX748/I9//CPcqFGj8OOPPx5uSGN55ZVXirGKnae7du2Kew2PZTg8bNiw8OzZs0X/li5dGj7zzDPDBx98cHj//v0Z/Zteu3ZtuLi4ODxhwoTwypUrww8//HA4Nzc3/NZbb4Ubyjiecsop4TFjxsTNSZxjEh5Hs7BYYjwXS7jAJOKnn34K5+fnh1944YXIz1atWiUWs0WLFol/4w0gJycnvHXr1shrHn300XCzZs3CFRUV4YZC3QW+trY23KFDh/DMmTPjxrOwsFAs0gjeHLHdp59+GnnNv//973AoFApv2rRJ/PtPf/pTuGXLlnFjeeutt4Z79OgRDirJxNLPf/7zpG14LBOzfft2MS7vv/9+Rv+mf/Ob34iHrFguvvhiITIawjhKsXTTTTclbcPjaBYOwzGeg6EhDH9069ZNhDHQdYx8/vnnUFVVJcJHEgzRHXzwwbBo0SLxb/x+5JFHQvv27SOvGTZsmDhIcsWKFdBQWbduHWzdujVu7PB8o0GDBsWNHYaLjj766Mhr8PV4luHixYsjrzn55JOhoKAgbnwxJLB7925oSGC4AkMZPXr0gOuvvx527twZ+R2PZWL27Nkjvrdq1Sqjf9P4mtj3kK+R7xH0cZQ8++yz0KZNGzjiiCNg8uTJUFpaGvkdj6NZ+CBdxlNw8cYYOS5AW7ZsgbvuukvkdCxfvlws9riw4CIUC/7x4+8Q/B57M5C/l79rqMi+Jxqb2LHDxT+WvLw8cUOOfU3Xrl3rvYf8XcuWLaEhgPlJ559/vhiL7777Dm677TYYMWKEWFRyc3N5LBNQW1sLv/71r+GEE04QizmSqb/pZK9BIVBWViZy9II8jshll10GnTt3Fg+amAt36623CuH90ksvid/zOJqFxRLjKbjgSPr06SPEE94Ann/+ef5DZazhkksuifw/Pq3jXD3kkEOEt+m0007L6mezFUzixoeejz76KNsfJZDjeO2118bNSdzIgXMRxTzOTcYsHIZjjIJPnIcddhh8++230KFDB6isrISffvop7jW4cwZ/h+D3ujtp5L/laxoisu+JxiZ27LZv3x73e9wpg7u6eHxTgyFjDH/gPEV4LOO58cYb4fXXX4f33nsPDjrooMjPM/U3new1uBMxSA9ZycYxEfigicTOSR5Hc7BYYoyCW63xyQifkgYMGAD5+fnwzjvvRH6PbmbMaTruuOPEv/H7V199FbdQzZs3T/yx9+rVCxoqGO7BG2Hs2KFrHfNnYscOFy3MI5G8++67wu0vb7z4GtxWj3kmseOLYdOghY10+OGHH0TOEs5ThMfSAfPjcYF/+eWXRf/rhh0z9TeNr4l9D/ka+R5BH8dELF26VHyPnZMNfRyNYjihnGlgTJw4MbxgwYLwunXrwh9//LHY5orbW3H3h9xmjFtm3333XbHN+LjjjhNfdbfHDh06VGyxxS2vbdu2bRClA/bt2ye2BOMX/qnOmjVL/P/3338fKR3QokWL8L/+9a/wl19+KXZzJSod0K9fv/DixYvDH330UfjQQw+N2+6Ou5dwu/vIkSPFNua5c+eKrcZB2u6ebizxdzfffLPYrYXzdP78+eH+/fuLsSovL4+8B49lOHz99deLchX4Nx27pb20tDTymkz8Tcst77fccovYTffII48East7unH89ttvw9OmTRPjh3MS/8a7desWPvnkkyPvweNoFhZLjKfgNtWOHTuGCwoKwgceeKD4N94IJLiw33DDDWLLNf5Rn3feeeKmEcv69evDI0aMEDVrUGihAKuqqgoHnffee08s7HW/cJu7LB9wxx13iAUaSwacdtpp4TVr1sS9x86dO8WC3qRJE7Gl+KqrrhLiIBas0XTiiSeK98BrhCKsIY0lLlC44OBCg9veO3fuLOrbxG7JRngsnbILib6wZlCm/6bxmvXt21fcO1AoxNoI+jhu2LBBCKNWrVqJuYQ1vVDwxNZZQhr6OJokhP8x68tiGIZhGIbxD5yzxDAMwzAMkwIWSwzDMAzDMClgscQwDMMwDJMCFksMwzAMwzApYLHEMAzDMAyTAhZLDMMwDMMwKWCxxDAMwzAMkwIWSwzDMAzDMClgscQwjO9YsGABhEKhege2mgLP2zr88MOhpqbGMxvHHnssvPjii569P8Mw6nAFb4ZhrGbw4MHQt29f+MMf/hD5GZ5sv2vXLmjfvr0QTabBA2MnTJgAl19+uWc28DT68ePHi4Noc3L4uZZhsgn/BTIM4zsKCgqgQ4cOWRFKH330EXz33XdwwQUXeGpnxIgRsG/fPvj3v//tqR2GYdLDYolhGGsZPXo0vP/++/DQQw8JYYRf69evrxeGmzNnDrRo0UJ4Y3r06AHFxcVw4YUXQmlpKTz11FPQpUsXaNmyJYwbNy4udFZRUQE333wzHHjggdC4cWMYNGiQeO9UzJ07F8444wwoKiqK/Gzq1KnC+/Xkk0/CwQcfDE2aNIEbbrhB2Lr//vuFsGvXrh3cc889kTbo1Md2+PrCwkI44IADxOeT5ObmwplnninsMQyTXfKybJ9hGCYpKJK+/vprOOKII2DatGniZ23bthWCqS4ojP74xz8KcYEemfPPPx/OO+88IaLefPNNWLt2rfAGnXDCCXDxxReLNjfeeCOsXLlStEGx8vLLL8Pw4cPhq6++gkMPPTThZ/rwww/hsssuq/dz9DahF+itt94S/49iDW0edthhQvAtXLgQrr76ajj99NOFKMN8pN///vfCdu/evWHr1q2wbNmyuPccOHAg3HvvvRkaTYZhqLBYYhjGWpo3by5CbugpQu9MKqqqquDRRx+FQw45RPwbxcrf/vY32LZtm/D09OrVC4YMGQLvvfeeEEsbNmyA2bNni+8olBD0MqHYwZ9Pnz49oZ3vv/8+8vpYamtrhWepadOmEVuYb4RCDXOO0ON13333CfsoltAu9gnFU35+vvAwoTiKBe1s3LhRvDfnLTFM9uC/PoZhAgEKKimUEEz+xvAbCqXYn23fvl38P3qPMEyGnh98jfxCLxB6hpJRVlYWF4KToC0USrG2UDTFipxY+xdddJF4r27dusGYMWOEV6u6ujruPRs1aiSEEoYLGYbJHuxZYhgmEKB3JhbMaUr0MxQfyP79+0Ve0Oeffy6+xxIrsOrSpk0b2L17t2v7nTp1Ep6n+fPnw7x580SO08yZM4VYk+1wxx/mUqFoYhgme7BYYhjGajAM50U9o379+on3RU/PSSedpNUO85wyAYqgs88+W3yNHTsWevbsKTxe/fv3F79fvny5sMcwTHZhscQwjNVgeGvx4sUiqRs9Pq1atcrI+2L4DeskjRo1Ch588EEhSn788UdRcLJPnz5w1llnJWw3bNgwscPOLbiDD8Ua5i9hCPGZZ54R4qlz585xyeRDhw51bYthGHdwzhLDMFaDSdcYJsP8H9wJh4nRmQITuVEsTZw4USRgn3vuufDpp5+KZOtkoMBasWKFCKG5AXfp/fnPfxa781CcYTjutddeg9atW4vfb9q0Seygu+qqq1zZYRjGPVzBm2EYRpNbbrkF9u7dC48//rhnNm699VaRG/XEE094ZoNhGDXYs8QwDKPJlClTRLhMJmt7ARaxvPvuuz17f4Zh1GHPEsMwDMMwTArYs8QwDMMwDJMCFksMwzAMwzApYLHEMAzDMAyTAhZLDMMwDMMwKWCxxDAMwzAMkwIWSwzDMAzDMClgscQwDMMwDJMCFksMwzAMwzApYLHEMAzDMAwDyfl/M4gGOqhaf/kAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Re-run complete\n" - ] - } - ], + "outputs": [], "source": [ "updated_params = dict(pop._parameters[\"nest_params\"])\n", "updated_params.update({\"V_th\": -50.0, \"tau_m\": 15.0})\n", @@ -902,175 +388,10 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "id": "9277ff71-914c-4594-a420-296586fceda8", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: IClamp\n", - "Executing node: Population\n", - "Executing node: SimConfig\n", - "[NW_SimConfig] network unchanged, reusing ./results/run3/network\n", - "2026-09-07 08:48:32,919 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 08:48:32,928 [INFO] Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for v1/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 08:48:32,930 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 08:48:32,932 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 08:48:32,935 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 08:48:32,936 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 08:48:32,965 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 08:48:33,930 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-07 08:48:34,195 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: Analysis\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Re-run complete\n" - ] - } - ], + "outputs": [], "source": [ "pop.configure(N=80)\n", "cfg.configure(config_file=\"config_pop.json\")\n", diff --git a/notebooks/generated_multiobjective_example.ipynb b/notebooks/generated_multiobjective_example.ipynb index 494902b7..8f9c592b 100644 --- a/notebooks/generated_multiobjective_example.ipynb +++ b/notebooks/generated_multiobjective_example.ipynb @@ -2,20 +2,9 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\"\\nGenerated workflow for project: Network and probe, two objectives\\n\\nSame shape as generated_optimization_example.py, with two differences that matter:\\n\\n * a second population, `probe`: a SINGLE inhibitory neuron that fires from its own\\n injected current and presses down on the network. It receives nothing from the\\n network - it is a tonic source of inhibition, not a read-out.\\n\\n clamp --> exc --> exc drive and recurrent excitation, both fixed\\n ^\\n +---- probe inhibition, negative weight\\n\\n * TWO objectives, so there is no single best answer. NSGA-II returns a Pareto front:\\n the set of configurations where improving one objective costs the other.\\n\\n 1. the network's firing rate ana.firing_rate_hz.exc\\n 2. the probe's mean inter-spike interval ana.isi_stats.probe.mean_ms\\n\\nWhy these two compete: the probe's own I_e and tau_m decide how fast it fires, which\\ndecides how much inhibition the network receives, which decides the network's rate.\\nTwo knobs, two targets, one causal path between them.\\n\\nFour dimensions: the drive, the recurrent excitatory weight, and the probe's I_e and\\ntau_m. The probe's two are read at simulation time, but the recurrent weight is written\\ninto the SONATA edge files - so every trial rebuilds the network.\\n\\nThe probe's inhibition of the network is fixed at -60 pA, so what the search controls\\nis how hard the network is driven and how fast the probe fires against it.\\n\\nRun it directly:\\n\\n python generated_multiobjective_example.py\\n\\nNeeds Optuna: pip install optuna cmaes\\n\"" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "#!/usr/bin/env python3\n", "\"\"\"\n", @@ -58,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -83,7 +72,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -289,10966 +278,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Workflow: Network_and_probe\n", - "Nodes:\n", - " clamp\n", - " exc\n", - " probe\n", - " conn\n", - " sim\n", - " ana\n", - "Connections:\n", - " clamp.iclamp -> exc.iclamp\n", - " exc.population -> conn.populations\n", - " probe.population -> conn.populations\n", - " conn.network -> sim.populations\n", - " sim.results -> ana.results\n", - "\n", - "Optimizing workflow...\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing ./results/multiobjective_example/network\n", - "\n", - " -- N E S T --\n", - " Copyright (C) 2004 The NEST Initiative\n", - "\n", - " Version: 3.7.0\n", - " Built: Mar 4 2025 17:27:39\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", - "2026-09-06 23:33:30,676 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:30,684 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:30,688 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:30,695 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:30,696 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:30,698 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:30,702 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:30,711 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:30,757 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:30,780 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - "[opt_20260906_233330] nsga2: 4 dimensions, 2 objective(s), up to 6 generations x 12 candidates\n", - " algorithm : nsga2 (pop_size=12, max_generations=6)\n", - " dimensions: 4\n", - " clamp.amp_na [100.0, 1000.0] nA\n", - " probe.nest_params.I_e [0.0, 600.0]\n", - " probe.nest_params.tau_m [5.0, 50.0]\n", - " conn.syn_weight [1.0, 100.0] pA\n", - " objectives: 2\n", - " network_rate in [40.0, 50.0] Hz <- ana.firing_rate_hz.exc\n", - " probe_isi in [20.0, 40.0] ms <- ana.isi_stats.probe.mean_ms\n", - " skipped : 2\n", - " exc.mean_firing_rate measures 'Analysis.firing_rate_hz.v1' did not resolve to a number in the baseline run\n", - " probe.mean_firing_rate measures 'Analysis.firing_rate_hz.v1' did not resolve to a number in the baseline run\n", - " each objective reports how far it missed, in its own unit. To compare objectives measured in different units, that miss is also given as a multiple of the target range asked for: '1.4x its target range' means the miss is 1.4 times as wide as the range. 0 = the target was met.\n", - " reusing network from ./results/multiobjective_example\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0001/network\n", - "2026-09-06 23:33:31,020 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,027 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,032 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,073 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,075 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,077 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,113 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,122 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,170 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,199 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 1/12 (#1): clamp.amp_na=475.3 nA probe.nest_params.I_e=432.2 probe.nest_params.tau_m=5.005 conn.syn_weight=30.93 pA -> network_rate=134 Hz (off 84 Hz), probe_isi=10.8 ms (off 9.2 ms) <- best so far\n", - " furthest from target: network_rate, 8.4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0002/network\n", - "2026-09-06 23:33:31,227 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,230 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,234 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,240 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,241 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,243 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,247 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,255 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,302 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,325 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 2/12 (#2): clamp.amp_na=232.1 nA probe.nest_params.I_e=55.4 probe.nest_params.tau_m=13.38 conn.syn_weight=35.21 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=51.3 ms (off 11.3 ms) <- best so far\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0003/network\n", - "2026-09-06 23:33:31,351 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,355 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,358 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,364 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,365 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,366 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,370 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,379 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,426 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,457 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 3/12 (#3): clamp.amp_na=457.1 nA probe.nest_params.I_e=323.3 probe.nest_params.tau_m=23.86 conn.syn_weight=68.84 pA -> network_rate=236 Hz (off 186 Hz), probe_isi=7.721 ms (off 12.28 ms)\n", - " furthest from target: network_rate, 18.6x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0004/network\n", - "2026-09-06 23:33:31,485 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,488 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,491 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,497 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,498 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,500 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,503 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,511 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,559 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,581 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 4/12 (#4): clamp.amp_na=284 nA probe.nest_params.I_e=526.9 probe.nest_params.tau_m=6.232 conn.syn_weight=67.38 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=10.5 ms (off 9.5 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0005/network\n", - "2026-09-06 23:33:31,611 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,614 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,618 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,623 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,624 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,628 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,631 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,640 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,688 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,714 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 5/12 (#5): clamp.amp_na=475.6 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=11.32 conn.syn_weight=20.61 pA -> network_rate=86 Hz (off 36 Hz), probe_isi=8 ms (off 12 ms) <- best so far\n", - " furthest from target: network_rate, 3.6x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0006/network\n", - "2026-09-06 23:33:31,742 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,746 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,748 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,754 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,755 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,757 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,760 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,768 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,815 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,847 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 6/12 (#6): clamp.amp_na=820.7 nA probe.nest_params.I_e=581 probe.nest_params.tau_m=19.1 conn.syn_weight=69.54 pA -> network_rate=260 Hz (off 210 Hz), probe_isi=5.112 ms (off 14.89 ms)\n", - " furthest from target: network_rate, 21x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0007/network\n", - "2026-09-06 23:33:31,875 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,879 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,881 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,887 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,888 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,890 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,893 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,903 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,951 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:31,978 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 7/12 (#7): clamp.amp_na=888.8 nA probe.nest_params.I_e=536.8 probe.nest_params.tau_m=8.827 conn.syn_weight=4.866 pA -> network_rate=122 Hz (off 72 Hz), probe_isi=5.457 ms (off 14.54 ms)\n", - " furthest from target: network_rate, 7.2x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0008/network\n", - "2026-09-06 23:33:32,008 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,012 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,016 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,022 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,023 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,025 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,028 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,037 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,083 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,107 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 8/12 (#8): clamp.amp_na=252.8 nA probe.nest_params.I_e=526.9 probe.nest_params.tau_m=9.426 conn.syn_weight=42.69 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=9.075 ms (off 10.92 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0009/network\n", - "2026-09-06 23:33:32,138 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,141 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,145 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,153 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,154 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,157 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,161 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,170 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,217 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,247 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 9/12 (#9): clamp.amp_na=962.1 nA probe.nest_params.I_e=319.9 probe.nest_params.tau_m=36.13 conn.syn_weight=32.24 pA -> network_rate=202 Hz (off 152 Hz), probe_isi=5.359 ms (off 14.64 ms)\n", - " furthest from target: network_rate, 15.2x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0010/network\n", - "2026-09-06 23:33:32,278 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,281 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,285 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,291 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,292 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,294 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,297 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,306 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,354 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,384 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 10/12 (#10): clamp.amp_na=717.9 nA probe.nest_params.I_e=500.8 probe.nest_params.tau_m=5.823 conn.syn_weight=75.26 pA -> network_rate=268 Hz (off 218 Hz), probe_isi=6.4 ms (off 13.6 ms)\n", - " furthest from target: network_rate, 21.8x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0011/network\n", - "2026-09-06 23:33:32,413 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,417 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,420 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,426 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,427 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,429 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,431 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,440 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,487 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,520 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 11/12 (#11): clamp.amp_na=990 nA probe.nest_params.I_e=448.9 probe.nest_params.tau_m=17.62 conn.syn_weight=79.14 pA -> network_rate=286 Hz (off 236 Hz), probe_isi=5.159 ms (off 14.84 ms)\n", - " furthest from target: network_rate, 23.6x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0012/network\n", - "2026-09-06 23:33:32,552 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,555 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,559 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,565 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,566 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,568 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,571 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,580 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,627 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,650 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 12/12 (#12): clamp.amp_na=192.9 nA probe.nest_params.I_e=268.7 probe.nest_params.tau_m=45.89 conn.syn_weight=30.07 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=11.32 ms (off 8.681 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - " gen 1/6: best clamp.amp_na=475.6 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=11.32 conn.syn_weight=20.61 pA -> network_rate=86 Hz [target 40.0-50.0 Hz, off 36 Hz]; probe_isi=8 ms [target 20.0-40.0 ms, off 12 ms] — its furthest objective from target: network_rate, 3.6x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0013/network\n", - "2026-09-06 23:33:32,680 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,684 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,687 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,695 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,696 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,698 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,702 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,711 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,759 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,791 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 1/12 (#13): clamp.amp_na=717.9 nA probe.nest_params.I_e=500.8 probe.nest_params.tau_m=17.95 conn.syn_weight=75.26 pA -> network_rate=268 Hz (off 218 Hz), probe_isi=5.643 ms (off 14.36 ms)\n", - " furthest from target: network_rate, 21.8x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0014/network\n", - "2026-09-06 23:33:32,821 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,825 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,829 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,835 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,836 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,838 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,840 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,849 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,897 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,930 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 2/12 (#14): clamp.amp_na=962.1 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=36.13 conn.syn_weight=20.61 pA -> network_rate=172 Hz (off 122 Hz), probe_isi=5.361 ms (off 14.64 ms)\n", - " furthest from target: network_rate, 12.2x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0015/network\n", - "2026-09-06 23:33:32,960 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,964 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,968 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,974 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,975 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,977 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,980 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:32,989 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,038 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,061 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 3/12 (#15): clamp.amp_na=192.9 nA probe.nest_params.I_e=319.9 probe.nest_params.tau_m=45.89 conn.syn_weight=32.24 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=10.27 ms (off 9.734 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0016/network\n", - "2026-09-06 23:33:33,088 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,092 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,096 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,101 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,102 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,104 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,107 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,115 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,162 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,192 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 4/12 (#16): clamp.amp_na=475.3 nA probe.nest_params.I_e=432.2 probe.nest_params.tau_m=6.232 conn.syn_weight=67.38 pA -> network_rate=238 Hz (off 188 Hz), probe_isi=8.8 ms (off 11.2 ms)\n", - " furthest from target: network_rate, 18.8x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0017/network\n", - "2026-09-06 23:33:33,222 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,225 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,229 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,235 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,236 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,238 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,240 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,248 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,296 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,324 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 5/12 (#17): clamp.amp_na=717.9 nA probe.nest_params.I_e=500.8 probe.nest_params.tau_m=5.823 conn.syn_weight=13.87 pA -> network_rate=120 Hz (off 70 Hz), probe_isi=6.4 ms (off 13.6 ms)\n", - " furthest from target: network_rate, 7x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0018/network\n", - "2026-09-06 23:33:33,353 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,357 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,361 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,366 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,367 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,369 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,372 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,380 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,428 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,450 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 6/12 (#18): clamp.amp_na=284 nA probe.nest_params.I_e=526.9 probe.nest_params.tau_m=9.426 conn.syn_weight=2.917 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=8.677 ms (off 11.32 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0019/network\n", - "2026-09-06 23:33:33,479 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,484 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,487 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,492 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,494 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,496 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,498 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,507 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,555 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,584 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 7/12 (#19): clamp.amp_na=475.6 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=36.13 conn.syn_weight=32.24 pA -> network_rate=136 Hz (off 86 Hz), probe_isi=7.289 ms (off 12.71 ms)\n", - " furthest from target: network_rate, 8.6x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0020/network\n", - "2026-09-06 23:33:33,613 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,617 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,621 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,627 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,628 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,630 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,633 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,641 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,689 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,718 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 8/12 (#20): clamp.amp_na=711 nA probe.nest_params.I_e=432.2 probe.nest_params.tau_m=23.86 conn.syn_weight=30.93 pA -> network_rate=170 Hz (off 120 Hz), probe_isi=5.86 ms (off 14.14 ms)\n", - " furthest from target: network_rate, 12x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0021/network\n", - "2026-09-06 23:33:33,747 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,751 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,754 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,760 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,761 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,763 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,766 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,774 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,822 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,846 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 9/12 (#21): clamp.amp_na=252.8 nA probe.nest_params.I_e=526.9 probe.nest_params.tau_m=14.52 conn.syn_weight=30.93 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=8.112 ms (off 11.89 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0022/network\n", - "2026-09-06 23:33:33,876 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,880 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,886 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,893 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,894 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,896 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,899 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,907 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,955 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:33,982 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 10/12 (#22): clamp.amp_na=717.9 nA probe.nest_params.I_e=500.8 probe.nest_params.tau_m=5.823 conn.syn_weight=27.29 pA -> network_rate=162 Hz (off 112 Hz), probe_isi=6.4 ms (off 13.6 ms)\n", - " furthest from target: network_rate, 11.2x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0023/network\n", - "2026-09-06 23:33:34,007 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,011 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,014 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,019 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,020 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,022 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,025 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,034 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,081 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,107 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 11/12 (#23): clamp.amp_na=542.4 nA probe.nest_params.I_e=32.02 probe.nest_params.tau_m=30.84 conn.syn_weight=15.53 pA -> network_rate=92 Hz (off 42 Hz), probe_isi=9.4 ms (off 10.6 ms)\n", - " furthest from target: network_rate, 4.2x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0024/network\n", - "2026-09-06 23:33:34,135 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,139 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,141 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,147 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,149 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,151 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,154 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,163 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,211 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,234 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 12/12 (#24): clamp.amp_na=252.8 nA probe.nest_params.I_e=526.9 probe.nest_params.tau_m=9.426 conn.syn_weight=30.07 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=9.075 ms (off 10.92 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - " gen 2/6: best clamp.amp_na=475.6 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=11.32 conn.syn_weight=20.61 pA -> network_rate=86 Hz [target 40.0-50.0 Hz, off 36 Hz]; probe_isi=8 ms [target 20.0-40.0 ms, off 12 ms] — its furthest objective from target: network_rate, 3.6x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0025/network\n", - "2026-09-06 23:33:34,268 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,272 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,275 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,280 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,281 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,283 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,287 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,295 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,343 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,370 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 1/12 (#25): clamp.amp_na=475.6 nA probe.nest_params.I_e=353.6 probe.nest_params.tau_m=6.232 conn.syn_weight=20.61 pA -> network_rate=90 Hz (off 40 Hz), probe_isi=10.1 ms (off 9.9 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0026/network\n", - "2026-09-06 23:33:34,401 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,405 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,408 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,414 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,415 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,417 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,422 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,431 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,478 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,507 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 2/12 (#26): clamp.amp_na=475.6 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=11.32 conn.syn_weight=70.28 pA -> network_rate=240 Hz (off 190 Hz), probe_isi=8 ms (off 12 ms)\n", - " furthest from target: network_rate, 19x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0027/network\n", - "2026-09-06 23:33:34,538 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,542 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,545 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,551 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,552 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,554 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,556 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,565 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,613 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,641 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 3/12 (#27): clamp.amp_na=475.6 nA probe.nest_params.I_e=61.4 probe.nest_params.tau_m=11.32 conn.syn_weight=41.99 pA -> network_rate=174 Hz (off 124 Hz), probe_isi=12.9 ms (off 7.1 ms)\n", - " furthest from target: network_rate, 12.4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0028/network\n", - "2026-09-06 23:33:34,670 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,674 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,678 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,684 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,685 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,687 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,690 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,698 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,746 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,770 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 4/12 (#28): clamp.amp_na=252.8 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=9.426 conn.syn_weight=69.75 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=12.7 ms (off 7.3 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0029/network\n", - "2026-09-06 23:33:34,801 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,805 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,809 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,815 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,817 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,819 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,822 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,831 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,878 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,906 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 5/12 (#29): clamp.amp_na=475.6 nA probe.nest_params.I_e=319.9 probe.nest_params.tau_m=23.64 conn.syn_weight=32.24 pA -> network_rate=136 Hz (off 86 Hz), probe_isi=7.617 ms (off 12.38 ms)\n", - " furthest from target: network_rate, 8.6x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0030/network\n", - "2026-09-06 23:33:34,941 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,945 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,948 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,955 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,956 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,958 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,961 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:34,970 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,018 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,043 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 6/12 (#30): clamp.amp_na=192.9 nA probe.nest_params.I_e=319.9 probe.nest_params.tau_m=45.89 conn.syn_weight=32.24 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=10.27 ms (off 9.734 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0031/network\n", - "2026-09-06 23:33:35,074 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,078 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,081 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,090 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,091 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,093 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,096 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,105 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,152 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,182 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 7/12 (#31): clamp.amp_na=475.3 nA probe.nest_params.I_e=432.2 probe.nest_params.tau_m=7.248 conn.syn_weight=54.05 pA -> network_rate=206 Hz (off 156 Hz), probe_isi=8.2 ms (off 11.8 ms)\n", - " furthest from target: network_rate, 15.6x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0032/network\n", - "2026-09-06 23:33:35,212 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,216 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,220 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,226 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,228 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,230 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,233 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,241 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,289 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,312 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 8/12 (#32): clamp.amp_na=192.9 nA probe.nest_params.I_e=268.7 probe.nest_params.tau_m=9.426 conn.syn_weight=30.07 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=20.7 ms (in target)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0033/network\n", - "2026-09-06 23:33:35,343 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,347 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,350 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,356 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,358 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,360 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,363 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,371 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,419 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,443 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 9/12 (#33): clamp.amp_na=252.8 nA probe.nest_params.I_e=526.9 probe.nest_params.tau_m=6.232 conn.syn_weight=66.72 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=11.3 ms (off 8.7 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0034/network\n", - "2026-09-06 23:33:35,472 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,477 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,480 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,486 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,487 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,489 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,493 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,502 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,550 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,580 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 10/12 (#34): clamp.amp_na=563.4 nA probe.nest_params.I_e=32.02 probe.nest_params.tau_m=30.84 conn.syn_weight=30.07 pA -> network_rate=148 Hz (off 98 Hz), probe_isi=9.1 ms (off 10.9 ms)\n", - " furthest from target: network_rate, 9.8x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0035/network\n", - "2026-09-06 23:33:35,612 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,616 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,620 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,626 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,627 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,629 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,632 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,641 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,689 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,713 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 11/12 (#35): clamp.amp_na=284 nA probe.nest_params.I_e=526.9 probe.nest_params.tau_m=6.232 conn.syn_weight=67.38 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=10.5 ms (off 9.5 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0036/network\n", - "2026-09-06 23:33:35,745 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,749 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,753 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,758 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,759 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,761 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,764 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,773 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,821 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,845 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 12/12 (#36): clamp.amp_na=192.9 nA probe.nest_params.I_e=319.9 probe.nest_params.tau_m=45.89 conn.syn_weight=30.93 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=10.27 ms (off 9.734 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - " gen 3/6: best clamp.amp_na=475.6 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=11.32 conn.syn_weight=20.61 pA -> network_rate=86 Hz [target 40.0-50.0 Hz, off 36 Hz]; probe_isi=8 ms [target 20.0-40.0 ms, off 12 ms] — its furthest objective from target: network_rate, 3.6x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0037/network\n", - "2026-09-06 23:33:35,879 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,883 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,887 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,893 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,894 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,897 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,899 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,908 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,956 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:35,978 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 1/12 (#37): clamp.amp_na=252.8 nA probe.nest_params.I_e=319.9 probe.nest_params.tau_m=45.89 conn.syn_weight=66.72 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=9.384 ms (off 10.62 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0038/network\n", - "2026-09-06 23:33:36,005 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,009 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,013 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,019 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,020 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,021 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,025 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,033 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,081 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,105 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 2/12 (#38): clamp.amp_na=192.9 nA probe.nest_params.I_e=319.9 probe.nest_params.tau_m=47.51 conn.syn_weight=32.24 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=10.26 ms (off 9.736 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0039/network\n", - "2026-09-06 23:33:36,135 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,139 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,143 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,149 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,150 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,152 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,155 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,164 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,212 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,241 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 3/12 (#39): clamp.amp_na=627.9 nA probe.nest_params.I_e=268.7 probe.nest_params.tau_m=45.65 conn.syn_weight=30.07 pA -> network_rate=156 Hz (off 106 Hz), probe_isi=6.7 ms (off 13.3 ms)\n", - " furthest from target: network_rate, 10.6x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0040/network\n", - "2026-09-06 23:33:36,275 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,279 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,286 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,292 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,294 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,295 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,298 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,307 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,355 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,376 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 4/12 (#40): clamp.amp_na=252.8 nA probe.nest_params.I_e=82.48 probe.nest_params.tau_m=11.27 conn.syn_weight=66.72 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=57.2 ms (off 17.2 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0041/network\n", - "2026-09-06 23:33:36,402 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,406 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,409 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,415 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,417 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,419 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,422 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,430 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,478 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,506 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 5/12 (#41): clamp.amp_na=826.7 nA probe.nest_params.I_e=238.6 probe.nest_params.tau_m=9.426 conn.syn_weight=32.24 pA -> network_rate=190 Hz (off 140 Hz), probe_isi=6.5 ms (off 13.5 ms)\n", - " furthest from target: network_rate, 14x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0042/network\n", - "2026-09-06 23:33:36,539 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,543 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,546 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,552 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,553 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,555 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,557 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,567 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,614 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,636 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 6/12 (#42): clamp.amp_na=248.8 nA probe.nest_params.I_e=432.2 probe.nest_params.tau_m=5.005 conn.syn_weight=30.93 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=0 ms (off 20 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0043/network\n", - "2026-09-06 23:33:36,667 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,671 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,674 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,680 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,681 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,684 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,687 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,696 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,743 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,773 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 7/12 (#43): clamp.amp_na=934.8 nA probe.nest_params.I_e=61.4 probe.nest_params.tau_m=11.32 conn.syn_weight=41.99 pA -> network_rate=222 Hz (off 172 Hz), probe_isi=6.6 ms (off 13.4 ms)\n", - " furthest from target: network_rate, 17.2x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0044/network\n", - "2026-09-06 23:33:36,804 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,808 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,812 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,818 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,819 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,821 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,824 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,833 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,880 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,904 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 8/12 (#44): clamp.amp_na=252.8 nA probe.nest_params.I_e=61.4 probe.nest_params.tau_m=6.232 conn.syn_weight=41.99 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=0 ms (off 20 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0045/network\n", - "2026-09-06 23:33:36,933 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,937 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,940 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,947 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,948 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,950 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,953 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:36,961 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,009 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,032 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 9/12 (#45): clamp.amp_na=252.8 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=9.426 conn.syn_weight=69.75 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=12.7 ms (off 7.3 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0046/network\n", - "2026-09-06 23:33:37,064 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,068 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,071 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,077 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,078 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,080 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,083 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,092 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,141 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,165 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 10/12 (#46): clamp.amp_na=192.9 nA probe.nest_params.I_e=319.9 probe.nest_params.tau_m=45.89 conn.syn_weight=32.24 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=10.27 ms (off 9.734 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0047/network\n", - "2026-09-06 23:33:37,197 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,201 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,204 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,211 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,213 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,215 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,218 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,227 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,275 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,299 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 11/12 (#47): clamp.amp_na=192.9 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=9.426 conn.syn_weight=69.75 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=15.2 ms (off 4.8 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0048/network\n", - "2026-09-06 23:33:37,332 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,337 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,340 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,346 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,348 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,350 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,353 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,362 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,410 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,434 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 12/12 (#48): clamp.amp_na=192.9 nA probe.nest_params.I_e=319.9 probe.nest_params.tau_m=20.65 conn.syn_weight=69.75 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=11.42 ms (off 8.583 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - " gen 4/6: best clamp.amp_na=475.6 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=11.32 conn.syn_weight=20.61 pA -> network_rate=86 Hz [target 40.0-50.0 Hz, off 36 Hz]; probe_isi=8 ms [target 20.0-40.0 ms, off 12 ms] — its furthest objective from target: network_rate, 3.6x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0049/network\n", - "2026-09-06 23:33:37,473 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,478 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,481 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,486 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,488 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,490 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,493 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,502 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,550 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,579 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 1/12 (#49): clamp.amp_na=475.6 nA probe.nest_params.I_e=61.4 probe.nest_params.tau_m=38.79 conn.syn_weight=41.99 pA -> network_rate=174 Hz (off 124 Hz), probe_isi=9.7 ms (off 10.3 ms)\n", - " furthest from target: network_rate, 12.4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0050/network\n", - "2026-09-06 23:33:37,610 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,615 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,618 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,623 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,625 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,627 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,630 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,639 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,687 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,714 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 2/12 (#50): clamp.amp_na=475.6 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=11.32 conn.syn_weight=20.61 pA -> network_rate=86 Hz (off 36 Hz), probe_isi=8 ms (off 12 ms)\n", - " furthest from target: network_rate, 3.6x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0051/network\n", - "2026-09-06 23:33:37,745 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,750 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,753 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,759 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,760 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,762 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,765 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,774 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,831 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,861 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 3/12 (#51): clamp.amp_na=475.6 nA probe.nest_params.I_e=61.4 probe.nest_params.tau_m=11.32 conn.syn_weight=41.99 pA -> network_rate=174 Hz (off 124 Hz), probe_isi=12.9 ms (off 7.1 ms)\n", - " furthest from target: network_rate, 12.4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0052/network\n", - "2026-09-06 23:33:37,894 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,898 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,902 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,907 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,909 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,911 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,914 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,924 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:37,973 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,006 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 4/12 (#52): clamp.amp_na=753.4 nA probe.nest_params.I_e=530 probe.nest_params.tau_m=9.426 conn.syn_weight=69.75 pA -> network_rate=260 Hz (off 210 Hz), probe_isi=5.767 ms (off 14.23 ms)\n", - " furthest from target: network_rate, 21x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0053/network\n", - "2026-09-06 23:33:38,040 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,044 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,048 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,055 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,056 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,059 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,063 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,072 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,120 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,147 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 5/12 (#53): clamp.amp_na=475.6 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=9.426 conn.syn_weight=20.61 pA -> network_rate=88 Hz (off 38 Hz), probe_isi=8.4 ms (off 11.6 ms)\n", - " furthest from target: network_rate, 3.8x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0054/network\n", - "2026-09-06 23:33:38,179 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,182 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,186 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,193 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,195 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,197 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,200 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,210 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,257 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,282 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 6/12 (#54): clamp.amp_na=192.9 nA probe.nest_params.I_e=268.7 probe.nest_params.tau_m=9.426 conn.syn_weight=30.07 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=20.7 ms (in target)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0055/network\n", - "2026-09-06 23:33:38,315 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,320 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,323 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,329 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,330 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,332 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,336 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,344 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,392 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,415 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 7/12 (#55): clamp.amp_na=192.9 nA probe.nest_params.I_e=374.2 probe.nest_params.tau_m=9.426 conn.syn_weight=67.38 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=13.4 ms (off 6.6 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0056/network\n", - "2026-09-06 23:33:38,449 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,454 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,457 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,464 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,465 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,468 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,471 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,480 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,527 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,548 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 8/12 (#56): clamp.amp_na=192.9 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=5.005 conn.syn_weight=30.93 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=0 ms (off 20 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0057/network\n", - "2026-09-06 23:33:38,581 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,585 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,589 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,595 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,597 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,598 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,602 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,611 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,657 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,688 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 9/12 (#57): clamp.amp_na=775.8 nA probe.nest_params.I_e=268.7 probe.nest_params.tau_m=20.65 conn.syn_weight=69.75 pA -> network_rate=260 Hz (off 210 Hz), probe_isi=6.254 ms (off 13.75 ms)\n", - " furthest from target: network_rate, 21x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0058/network\n", - "2026-09-06 23:33:38,719 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,726 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,730 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,736 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,737 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,739 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,742 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,750 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,798 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,822 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 10/12 (#58): clamp.amp_na=284 nA probe.nest_params.I_e=268.7 probe.nest_params.tau_m=20.7 conn.syn_weight=27.72 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=10.64 ms (off 9.359 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0059/network\n", - "2026-09-06 23:33:38,853 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,857 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,861 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,867 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,868 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,870 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,873 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,882 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,930 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,961 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 11/12 (#59): clamp.amp_na=906.3 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=24.26 conn.syn_weight=69.75 pA -> network_rate=270 Hz (off 220 Hz), probe_isi=5.569 ms (off 14.43 ms)\n", - " furthest from target: network_rate, 22x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0060/network\n", - "2026-09-06 23:33:38,991 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,995 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:38,999 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,005 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,006 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,009 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,012 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,020 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,067 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,090 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 12/12 (#60): clamp.amp_na=192.9 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=9.426 conn.syn_weight=69.75 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=15.2 ms (off 4.8 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - " gen 5/6: best clamp.amp_na=475.6 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=11.32 conn.syn_weight=20.61 pA -> network_rate=86 Hz [target 40.0-50.0 Hz, off 36 Hz]; probe_isi=8 ms [target 20.0-40.0 ms, off 12 ms] — its furthest objective from target: network_rate, 3.6x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0061/network\n", - "2026-09-06 23:33:39,125 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,129 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,132 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,138 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,140 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,142 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,145 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,153 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,200 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,223 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 1/12 (#61): clamp.amp_na=192.9 nA probe.nest_params.I_e=268.7 probe.nest_params.tau_m=9.426 conn.syn_weight=30.07 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=20.7 ms (in target)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0062/network\n", - "2026-09-06 23:33:39,251 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,255 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,258 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,267 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,269 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,271 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,274 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,282 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,331 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,359 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 2/12 (#62): clamp.amp_na=968.4 nA probe.nest_params.I_e=268.7 probe.nest_params.tau_m=11.32 conn.syn_weight=30.07 pA -> network_rate=198 Hz (off 148 Hz), probe_isi=5.6 ms (off 14.4 ms)\n", - " furthest from target: network_rate, 14.8x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0063/network\n", - "2026-09-06 23:33:39,389 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,392 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,396 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,402 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,404 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,406 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,409 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,417 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,464 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,488 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 3/12 (#63): clamp.amp_na=192.9 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=9.426 conn.syn_weight=67.38 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=15.2 ms (off 4.8 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0064/network\n", - "2026-09-06 23:33:39,519 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,522 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,526 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,532 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,534 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,536 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,539 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,547 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,594 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,622 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 4/12 (#64): clamp.amp_na=475.6 nA probe.nest_params.I_e=61.4 probe.nest_params.tau_m=9.426 conn.syn_weight=41.99 pA -> network_rate=176 Hz (off 126 Hz), probe_isi=14.8 ms (off 5.2 ms)\n", - " furthest from target: network_rate, 12.6x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0065/network\n", - "2026-09-06 23:33:39,651 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,655 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,659 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,664 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,666 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,668 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,671 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,680 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,727 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,754 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 5/12 (#65): clamp.amp_na=475.6 nA probe.nest_params.I_e=61.4 probe.nest_params.tau_m=34.85 conn.syn_weight=20.61 pA -> network_rate=90 Hz (off 40 Hz), probe_isi=9.8 ms (off 10.2 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0066/network\n", - "2026-09-06 23:33:39,787 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,791 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,796 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,804 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,805 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,808 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,811 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,820 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,869 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,900 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 6/12 (#66): clamp.amp_na=475.6 nA probe.nest_params.I_e=373 probe.nest_params.tau_m=9.426 conn.syn_weight=69.75 pA -> network_rate=240 Hz (off 190 Hz), probe_isi=8 ms (off 12 ms)\n", - " furthest from target: network_rate, 19x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0067/network\n", - "2026-09-06 23:33:39,935 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,941 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,946 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,952 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,954 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,956 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,959 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:39,968 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,015 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,039 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 7/12 (#67): clamp.amp_na=203.3 nA probe.nest_params.I_e=569.7 probe.nest_params.tau_m=9.426 conn.syn_weight=45.54 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=9.14 ms (off 10.86 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0068/network\n", - "2026-09-06 23:33:40,069 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,073 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,076 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,082 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,083 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,085 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,088 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,097 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,145 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,167 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 8/12 (#68): clamp.amp_na=192.9 nA probe.nest_params.I_e=268.7 probe.nest_params.tau_m=11.32 conn.syn_weight=58.26 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=16.4 ms (off 3.6 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0069/network\n", - "2026-09-06 23:33:40,200 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,204 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,208 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,214 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,216 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,218 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,221 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,230 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,278 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,303 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 9/12 (#69): clamp.amp_na=192.9 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=23.37 conn.syn_weight=30.07 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=10.81 ms (off 9.191 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0070/network\n", - "2026-09-06 23:33:40,334 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,338 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,342 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,348 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,350 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,353 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,356 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,364 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,414 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,440 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 10/12 (#70): clamp.amp_na=313.3 nA probe.nest_params.I_e=61.4 probe.nest_params.tau_m=11.32 conn.syn_weight=41.99 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=26.5 ms (in target)\n", - " furthest from target: network_rate, 4x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0071/network\n", - "2026-09-06 23:33:40,473 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,477 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,480 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,488 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,489 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,492 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,495 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,504 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,552 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,585 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 11/12 (#71): clamp.amp_na=913 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=9.426 conn.syn_weight=69.75 pA -> network_rate=270 Hz (off 220 Hz), probe_isi=5.7 ms (off 14.3 ms)\n", - " furthest from target: network_rate, 22x its target range\n", - "Executing node: probe\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/multiobjective_example/optimization/opt_20260906_233330/trials/0072/network\n", - "2026-09-06 23:33:40,621 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,625 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,630 [INFO] Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for probe/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,637 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,638 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,641 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,644 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,653 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,701 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:33:40,727 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 12/12 (#72): clamp.amp_na=252.8 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=11.32 conn.syn_weight=41.99 pA -> network_rate=0 Hz (off 40 Hz), probe_isi=11.4 ms (off 8.6 ms)\n", - " furthest from target: network_rate, 4x its target range\n", - " gen 6/6: best clamp.amp_na=475.6 nA probe.nest_params.I_e=335.2 probe.nest_params.tau_m=11.32 conn.syn_weight=20.61 pA -> network_rate=86 Hz [target 40.0-50.0 Hz, off 36 Hz]; probe_isi=8 ms [target 20.0-40.0 ms, off 12 ms] — its furthest objective from target: network_rate, 3.6x its target range\n", - "[opt_20260906_233330] stopped: generation budget exhausted\n", - " network_rate = 86 Hz (target 40.0-50.0 Hz, off 36 Hz)\n", - " probe_isi = 8 ms (target 20.0-40.0 ms, off 12 ms)\n", - " furthest from target: network_rate, 3.6x its target range\n", - "Optimization finished: generation budget exhausted\n", - "\n", - "Pareto front: 7 configuration(s)\n", - " trial 5: network_rate=86 Hz, probe_isi=8 ms <- amp_na=475.6, nest_params.I_e=335.2, nest_params.tau_m=11.32, syn_weight=20.61 [worst objective off by 3.6x its target range]\n", - " trial 32: network_rate=0 Hz, probe_isi=20.7 ms <- amp_na=192.9, nest_params.I_e=268.7, nest_params.tau_m=9.426, syn_weight=30.07 [worst objective off by 4x its target range]\n", - " trial 50: network_rate=86 Hz, probe_isi=8 ms <- amp_na=475.6, nest_params.I_e=335.2, nest_params.tau_m=11.32, syn_weight=20.61 [worst objective off by 3.6x its target range]\n", - " trial 53: network_rate=88 Hz, probe_isi=8.4 ms <- amp_na=475.6, nest_params.I_e=335.2, nest_params.tau_m=9.426, syn_weight=20.61 [worst objective off by 3.8x its target range]\n", - " trial 54: network_rate=0 Hz, probe_isi=20.7 ms <- amp_na=192.9, nest_params.I_e=268.7, nest_params.tau_m=9.426, syn_weight=30.07 [worst objective off by 4x its target range]\n", - " trial 61: network_rate=0 Hz, probe_isi=20.7 ms <- amp_na=192.9, nest_params.I_e=268.7, nest_params.tau_m=9.426, syn_weight=30.07 [worst objective off by 4x its target range]\n", - " trial 70: network_rate=0 Hz, probe_isi=26.5 ms <- amp_na=313.3, nest_params.I_e=61.4, nest_params.tau_m=11.32, syn_weight=41.99 [worst objective off by 4x its target range]\n", - "\n", - "Applied one configuration of the 7 on the front - trial 5, which misses by 3.6x its target range on its worst objective:\n", - " it gives network_rate=86 Hz (target 40.0-50.0), probe_isi=8 ms (target 20.0-40.0)\n", - "\n", - "clamp.configure(amp_na=475.57432213041426)\n", - "conn.configure(syn_weight=20.612047419403)\n", - "probe.configure(nest_params={**probe._parameters[\"nest_params\"], \"I_e\": 335.213897067451, \"tau_m\": 11.317412236785518})\n", - "\n", - "Results for this configuration: results/multiobjective_example/optimization/opt_20260906_233330/trials/0005\n" - ] - } - ], + "outputs": [], "source": [ "if __name__ == \"__main__\":\n", " main()\n" diff --git a/notebooks/generated_optimization_example.ipynb b/notebooks/generated_optimization_example.ipynb index 483ef9fa..d5c524e8 100644 --- a/notebooks/generated_optimization_example.ipynb +++ b/notebooks/generated_optimization_example.ipynb @@ -2,20 +2,9 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'\\nGenerated workflow for project: Clamp and weight optimization\\n\\nEXAMPLE of what the code generator should emit when an NW_Optimization node is present\\non the canvas. Everything above `workflow_builder.build()` is what the generator already\\nproduces today — node creation, configure() with the edited parameters, add_node, connect.\\nOnly the tail differs: instead of a single `workflow.execute()`, it declares what to\\nexplore and what to hit, then runs the search.\\n\\nRun it directly:\\n\\n python generated_optimization_example.py\\n\\nNeeds Optuna for the default algorithm: pip install optuna cmaes\\n'" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "#!/usr/bin/env python3\n", "\"\"\"\n", @@ -37,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -63,7 +52,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -215,15099 +204,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Workflow: Clamp_and_weight\n", - "Nodes:\n", - " clamp\n", - " exc\n", - " conn\n", - " sim\n", - " ana\n", - "Connections:\n", - " clamp.iclamp -> exc.iclamp\n", - " exc.population -> conn.populations\n", - " conn.network -> sim.populations\n", - " sim.results -> ana.results\n", - "\n", - "Optimizing workflow...\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network unchanged, reusing ./results/generated_example/network\n", - "\n", - " -- N E S T --\n", - " Copyright (C) 2004 The NEST Initiative\n", - "\n", - " Version: 3.7.0\n", - " Built: Mar 4 2025 17:27:39\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", - "2026-09-06 23:34:59,224 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,232 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,236 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,237 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,238 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,240 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,250 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,295 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,314 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - "[opt_20260906_233459] cmaes: 2 dimensions, 1 objective(s), up to 12 generations x 16 candidates\n", - " algorithm : cmaes (pop_size=16, max_generations=12)\n", - " dimensions: 2\n", - " clamp.amp_na [100.0, 1000.0] nA\n", - " conn.syn_weight [1.0, 100.0] pA\n", - " objectives: 1\n", - " exc_firing_rate in [40.0, 50.0] Hz <- ana.firing_rate_hz.exc\n", - " skipped : 1\n", - " exc.mean_firing_rate measures 'Analysis.firing_rate_hz.v1' did not resolve to a number in the baseline run\n", - " reusing network from ./results/generated_example\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0001/network\n", - "2026-09-06 23:34:59,526 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,529 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,533 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,534 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,535 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,537 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,545 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,589 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,616 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 1/16 (#1): clamp.amp_na=475.3 nA conn.syn_weight=72.31 pA -> exc_firing_rate=248 Hz (off 198 Hz) <- best so far\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0002/network\n", - "2026-09-06 23:34:59,636 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,639 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,644 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,645 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,646 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,648 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,655 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,700 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,719 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 2/16 (#2): clamp.amp_na=100.1 nA conn.syn_weight=30.93 pA -> exc_firing_rate=0 Hz (off 40 Hz) <- best so far\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0003/network\n", - "2026-09-06 23:34:59,739 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,742 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,746 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,747 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,748 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,750 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,758 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,804 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,824 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 3/16 (#3): clamp.amp_na=232.1 nA conn.syn_weight=10.14 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0004/network\n", - "2026-09-06 23:34:59,845 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,849 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,854 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,855 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,856 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,858 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,866 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,912 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,932 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 4/16 (#4): clamp.amp_na=267.6 nA conn.syn_weight=35.21 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0005/network\n", - "2026-09-06 23:34:59,953 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,993 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,997 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,998 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:34:59,999 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,002 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,010 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,055 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,080 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 5/16 (#5): clamp.amp_na=457.1 nA conn.syn_weight=54.34 pA -> exc_firing_rate=212 Hz (off 162 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0006/network\n", - "2026-09-06 23:35:00,099 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,103 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,107 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,108 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,109 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,112 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,119 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,164 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,190 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 6/16 (#6): clamp.amp_na=477.3 nA conn.syn_weight=68.84 pA -> exc_firing_rate=242 Hz (off 192 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0007/network\n", - "2026-09-06 23:35:00,211 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,215 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,219 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,220 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,221 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,223 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,231 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,276 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,296 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 7/16 (#7): clamp.amp_na=284 nA conn.syn_weight=87.93 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0008/network\n", - "2026-09-06 23:35:00,316 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,319 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,323 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,324 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,326 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,328 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,335 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,381 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,402 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 8/16 (#8): clamp.amp_na=124.6 nA conn.syn_weight=67.38 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0009/network\n", - "2026-09-06 23:35:00,421 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,425 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,429 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,430 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,431 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,433 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,440 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,485 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,513 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 9/16 (#9): clamp.amp_na=475.6 nA conn.syn_weight=56.31 pA -> exc_firing_rate=218 Hz (off 168 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0010/network\n", - "2026-09-06 23:35:00,535 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,539 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,542 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,544 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,545 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,547 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,555 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,599 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,620 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 10/16 (#10): clamp.amp_na=226.3 nA conn.syn_weight=20.61 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0011/network\n", - "2026-09-06 23:35:00,642 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,646 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,651 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,652 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,653 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,655 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,663 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,708 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,735 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 11/16 (#11): clamp.amp_na=820.7 nA conn.syn_weight=96.86 pA -> exc_firing_rate=296 Hz (off 246 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0012/network\n", - "2026-09-06 23:35:00,757 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,762 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,766 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,767 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,769 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,770 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,778 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,823 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,850 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 12/16 (#12): clamp.amp_na=382.1 nA conn.syn_weight=69.54 pA -> exc_firing_rate=222 Hz (off 172 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0013/network\n", - "2026-09-06 23:35:00,871 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,875 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,879 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,880 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,881 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,883 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,891 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,937 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,964 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 13/16 (#13): clamp.amp_na=888.8 nA conn.syn_weight=89.57 pA -> exc_firing_rate=296 Hz (off 246 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0014/network\n", - "2026-09-06 23:35:00,986 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,989 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,993 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,994 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,996 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:00,998 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,006 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,050 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,070 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 14/16 (#14): clamp.amp_na=176.5 nA conn.syn_weight=4.866 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0015/network\n", - "2026-09-06 23:35:01,088 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,091 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,096 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,097 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,098 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,100 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,107 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,153 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,173 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 15/16 (#15): clamp.amp_na=252.8 nA conn.syn_weight=87.94 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0016/network\n", - "2026-09-06 23:35:01,193 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,197 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,201 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,202 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,204 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,205 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,213 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,258 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,277 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 1, trial 16/16 (#16): clamp.amp_na=188.5 nA conn.syn_weight=42.69 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - " gen 1/12: best clamp.amp_na=100.1 nA conn.syn_weight=30.93 pA -> exc_firing_rate=0 Hz [target 40.0-50.0 Hz, off 40 Hz]\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0017/network\n", - "2026-09-06 23:35:01,312 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,316 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,320 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,321 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,323 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,324 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,332 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,377 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,403 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 1/16 (#17): clamp.amp_na=592.1 nA conn.syn_weight=50.25 pA -> exc_firing_rate=214 Hz (off 164 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0018/network\n", - "2026-09-06 23:35:01,422 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,426 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,430 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,431 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,432 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,434 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,441 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,500 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,526 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 2/16 (#18): clamp.amp_na=618.5 nA conn.syn_weight=52.59 pA -> exc_firing_rate=220 Hz (off 170 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0019/network\n", - "2026-09-06 23:35:01,548 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,552 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,556 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,557 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,558 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,561 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,569 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,615 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,642 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 3/16 (#19): clamp.amp_na=607.9 nA conn.syn_weight=56.44 pA -> exc_firing_rate=232 Hz (off 182 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0020/network\n", - "2026-09-06 23:35:01,664 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,668 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,672 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,673 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,675 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,677 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,685 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,730 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,757 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 4/16 (#20): clamp.amp_na=622.1 nA conn.syn_weight=47.46 pA -> exc_firing_rate=210 Hz (off 160 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0021/network\n", - "2026-09-06 23:35:01,781 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,785 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,789 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,790 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,791 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,794 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,802 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,848 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,873 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 5/16 (#21): clamp.amp_na=550.2 nA conn.syn_weight=59.21 pA -> exc_firing_rate=230 Hz (off 180 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0022/network\n", - "2026-09-06 23:35:01,895 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,900 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,906 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,907 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,909 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,912 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,920 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,966 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:01,990 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 6/16 (#22): clamp.amp_na=492.6 nA conn.syn_weight=26.1 pA -> exc_firing_rate=126 Hz (off 76 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0023/network\n", - "2026-09-06 23:35:02,012 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,015 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,022 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,023 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,025 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,028 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,037 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,082 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,107 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 7/16 (#23): clamp.amp_na=381.5 nA conn.syn_weight=49.19 pA -> exc_firing_rate=178 Hz (off 128 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0024/network\n", - "2026-09-06 23:35:02,128 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,131 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,136 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,137 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,138 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,140 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,148 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,194 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,221 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 8/16 (#24): clamp.amp_na=418.9 nA conn.syn_weight=52.43 pA -> exc_firing_rate=198 Hz (off 148 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0025/network\n", - "2026-09-06 23:35:02,242 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,246 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,250 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,251 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,253 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,255 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,263 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,308 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,336 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 9/16 (#25): clamp.amp_na=558.1 nA conn.syn_weight=52.88 pA -> exc_firing_rate=220 Hz (off 170 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0026/network\n", - "2026-09-06 23:35:02,356 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,360 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,364 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,366 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,367 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,370 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,378 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,423 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,449 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 10/16 (#26): clamp.amp_na=675 nA conn.syn_weight=32.03 pA -> exc_firing_rate=178 Hz (off 128 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0027/network\n", - "2026-09-06 23:35:02,470 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,474 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,479 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,480 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,482 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,484 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,491 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,538 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,565 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 11/16 (#27): clamp.amp_na=483.3 nA conn.syn_weight=75.69 pA -> exc_firing_rate=256 Hz (off 206 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0028/network\n", - "2026-09-06 23:35:02,586 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,590 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,594 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,595 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,597 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,598 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,606 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,651 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,678 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 12/16 (#28): clamp.amp_na=479.7 nA conn.syn_weight=73.5 pA -> exc_firing_rate=248 Hz (off 198 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0029/network\n", - "2026-09-06 23:35:02,701 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,705 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,709 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,710 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,712 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,713 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,721 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,767 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,795 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 13/16 (#29): clamp.amp_na=771.7 nA conn.syn_weight=55.15 pA -> exc_firing_rate=240 Hz (off 190 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0030/network\n", - "2026-09-06 23:35:02,816 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,820 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,824 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,825 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,827 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,829 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,837 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,883 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,909 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 14/16 (#30): clamp.amp_na=668.8 nA conn.syn_weight=36.46 pA -> exc_firing_rate=188 Hz (off 138 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0031/network\n", - "2026-09-06 23:35:02,930 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,934 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,938 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,940 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,941 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,943 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,951 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:02,997 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,023 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 15/16 (#31): clamp.amp_na=465.4 nA conn.syn_weight=44.71 pA -> exc_firing_rate=184 Hz (off 134 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0032/network\n", - "2026-09-06 23:35:03,046 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,050 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,054 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,055 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,056 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,059 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,066 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,113 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,139 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 2, trial 16/16 (#32): clamp.amp_na=763.7 nA conn.syn_weight=25.39 pA -> exc_firing_rate=168 Hz (off 118 Hz)\n", - " gen 2/12: best clamp.amp_na=100.1 nA conn.syn_weight=30.93 pA -> exc_firing_rate=0 Hz [target 40.0-50.0 Hz, off 40 Hz]\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0033/network\n", - "2026-09-06 23:35:03,169 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,173 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,176 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,177 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,179 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,181 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,188 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,234 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,259 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 1/16 (#33): clamp.amp_na=409 nA conn.syn_weight=21.41 pA -> exc_firing_rate=78 Hz (off 28 Hz) <- best so far\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0034/network\n", - "2026-09-06 23:35:03,280 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,285 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,289 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,290 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,291 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,293 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,301 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,347 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,374 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 2/16 (#34): clamp.amp_na=544.4 nA conn.syn_weight=55.08 pA -> exc_firing_rate=220 Hz (off 170 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0035/network\n", - "2026-09-06 23:35:03,397 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,401 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,406 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,408 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,409 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,412 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,420 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,466 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,493 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 3/16 (#35): clamp.amp_na=630.9 nA conn.syn_weight=42.66 pA -> exc_firing_rate=200 Hz (off 150 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0036/network\n", - "2026-09-06 23:35:03,514 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,518 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,525 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,526 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,528 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,530 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,539 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,584 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,610 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 4/16 (#36): clamp.amp_na=514.7 nA conn.syn_weight=35.82 pA -> exc_firing_rate=166 Hz (off 116 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0037/network\n", - "2026-09-06 23:35:03,631 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,636 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,640 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,641 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,643 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,645 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,653 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,698 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,726 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 5/16 (#37): clamp.amp_na=699.4 nA conn.syn_weight=67.33 pA -> exc_firing_rate=252 Hz (off 202 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0038/network\n", - "2026-09-06 23:35:03,748 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,752 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,757 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,758 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,760 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,762 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,771 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,816 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,844 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 6/16 (#38): clamp.amp_na=447.2 nA conn.syn_weight=42.73 pA -> exc_firing_rate=176 Hz (off 126 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0039/network\n", - "2026-09-06 23:35:03,866 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,871 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,875 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,876 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,878 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,880 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,888 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,934 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,963 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 7/16 (#39): clamp.amp_na=385.5 nA conn.syn_weight=54.42 pA -> exc_firing_rate=192 Hz (off 142 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0040/network\n", - "2026-09-06 23:35:03,986 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,989 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,994 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,995 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,996 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:03,998 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,006 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,052 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,079 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 8/16 (#40): clamp.amp_na=851.3 nA conn.syn_weight=41.22 pA -> exc_firing_rate=218 Hz (off 168 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0041/network\n", - "2026-09-06 23:35:04,101 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,105 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,109 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,110 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,112 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,114 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,122 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,167 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,188 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 9/16 (#41): clamp.amp_na=336.4 nA conn.syn_weight=42.97 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0042/network\n", - "2026-09-06 23:35:04,211 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,216 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,220 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,221 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,223 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,225 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,234 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,280 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,305 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 10/16 (#42): clamp.amp_na=413.4 nA conn.syn_weight=25.54 pA -> exc_firing_rate=102 Hz (off 52 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0043/network\n", - "2026-09-06 23:35:04,329 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,333 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,338 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,339 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,340 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,343 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,351 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,397 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,417 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 11/16 (#43): clamp.amp_na=240 nA conn.syn_weight=16.49 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0044/network\n", - "2026-09-06 23:35:04,443 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,447 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,452 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,453 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,455 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,457 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,465 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,510 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,536 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 12/16 (#44): clamp.amp_na=542.5 nA conn.syn_weight=43.88 pA -> exc_firing_rate=190 Hz (off 140 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0045/network\n", - "2026-09-06 23:35:04,556 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,560 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,564 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,566 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,567 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,570 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,578 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,624 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,651 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 13/16 (#45): clamp.amp_na=500.4 nA conn.syn_weight=41.24 pA -> exc_firing_rate=178 Hz (off 128 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0046/network\n", - "2026-09-06 23:35:04,673 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,677 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,681 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,683 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,685 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,687 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,694 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,740 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,764 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 14/16 (#46): clamp.amp_na=609.5 nA conn.syn_weight=3.193 pA -> exc_firing_rate=82 Hz (off 32 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0047/network\n", - "2026-09-06 23:35:04,786 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,790 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,795 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,797 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,798 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,801 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,811 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,856 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,882 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 15/16 (#47): clamp.amp_na=510.9 nA conn.syn_weight=45.03 pA -> exc_firing_rate=190 Hz (off 140 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0048/network\n", - "2026-09-06 23:35:04,905 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,910 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,915 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,916 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,918 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,920 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,928 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,975 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:04,999 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 3, trial 16/16 (#48): clamp.amp_na=521.7 nA conn.syn_weight=30.36 pA -> exc_firing_rate=146 Hz (off 96 Hz)\n", - " gen 3/12: best clamp.amp_na=409 nA conn.syn_weight=21.41 pA -> exc_firing_rate=78 Hz [target 40.0-50.0 Hz, off 28 Hz]\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0049/network\n", - "2026-09-06 23:35:05,029 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,032 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,037 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,038 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,039 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,041 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,049 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,095 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,121 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 1/16 (#49): clamp.amp_na=631.6 nA conn.syn_weight=25.52 pA -> exc_firing_rate=150 Hz (off 100 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0050/network\n", - "2026-09-06 23:35:05,142 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,146 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,151 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,152 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,154 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,156 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,164 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,210 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,233 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 2/16 (#50): clamp.amp_na=526.9 nA conn.syn_weight=1.751 pA -> exc_firing_rate=64 Hz (off 14 Hz) <- best so far\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0051/network\n", - "2026-09-06 23:35:05,256 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,260 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,267 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,268 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,270 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,272 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,280 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,326 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,347 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 3/16 (#51): clamp.amp_na=287.9 nA conn.syn_weight=19.64 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0052/network\n", - "2026-09-06 23:35:05,368 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,372 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,376 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,378 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,379 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,381 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,389 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,435 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,459 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 4/16 (#52): clamp.amp_na=486.3 nA conn.syn_weight=49.47 pA -> exc_firing_rate=202 Hz (off 152 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0053/network\n", - "2026-09-06 23:35:05,482 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,486 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,490 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,491 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,493 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,495 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,503 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,550 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,575 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 5/16 (#53): clamp.amp_na=421.5 nA conn.syn_weight=25.65 pA -> exc_firing_rate=106 Hz (off 56 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0054/network\n", - "2026-09-06 23:35:05,597 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,602 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,606 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,607 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,609 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,612 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,619 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,665 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,690 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 6/16 (#54): clamp.amp_na=392.4 nA conn.syn_weight=36.35 pA -> exc_firing_rate=140 Hz (off 90 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0055/network\n", - "2026-09-06 23:35:05,711 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,715 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,719 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,721 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,722 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,724 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,732 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,778 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,804 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 7/16 (#55): clamp.amp_na=549.9 nA conn.syn_weight=23.75 pA -> exc_firing_rate=130 Hz (off 80 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0056/network\n", - "2026-09-06 23:35:05,826 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,830 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,834 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,835 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,837 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,839 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,847 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,893 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,918 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 8/16 (#56): clamp.amp_na=469.8 nA conn.syn_weight=27.65 pA -> exc_firing_rate=126 Hz (off 76 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0057/network\n", - "2026-09-06 23:35:05,941 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,945 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,949 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,950 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,952 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,955 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:05,963 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,010 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,035 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 9/16 (#57): clamp.amp_na=525.9 nA conn.syn_weight=22.61 pA -> exc_firing_rate=120 Hz (off 70 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0058/network\n", - "2026-09-06 23:35:06,058 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,063 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,067 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,069 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,070 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,073 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,081 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,127 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,149 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 10/16 (#58): clamp.amp_na=243.3 nA conn.syn_weight=41 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0059/network\n", - "2026-09-06 23:35:06,173 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,177 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,183 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,185 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,187 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,189 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,196 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,242 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,268 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 11/16 (#59): clamp.amp_na=505 nA conn.syn_weight=34.16 pA -> exc_firing_rate=156 Hz (off 106 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0060/network\n", - "2026-09-06 23:35:06,289 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,294 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,298 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,299 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,301 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,304 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,311 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,358 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,383 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 12/16 (#60): clamp.amp_na=613.9 nA conn.syn_weight=42.78 pA -> exc_firing_rate=196 Hz (off 146 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0061/network\n", - "2026-09-06 23:35:06,405 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,411 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,415 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,416 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,418 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,421 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,430 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,476 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,501 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 13/16 (#61): clamp.amp_na=502.5 nA conn.syn_weight=17.62 pA -> exc_firing_rate=96 Hz (off 46 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0062/network\n", - "2026-09-06 23:35:06,524 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,528 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,532 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,533 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,535 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,538 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,546 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,592 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,612 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 14/16 (#62): clamp.amp_na=329.2 nA conn.syn_weight=19.48 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0063/network\n", - "2026-09-06 23:35:06,634 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,638 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,643 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,645 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,646 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,648 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,656 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,701 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,725 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 15/16 (#63): clamp.amp_na=501.2 nA conn.syn_weight=27.86 pA -> exc_firing_rate=134 Hz (off 84 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0064/network\n", - "2026-09-06 23:35:06,748 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,753 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,757 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,758 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,760 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,763 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,771 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,817 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,844 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 4, trial 16/16 (#64): clamp.amp_na=753 nA conn.syn_weight=39.8 pA -> exc_firing_rate=206 Hz (off 156 Hz)\n", - " gen 4/12: best clamp.amp_na=526.9 nA conn.syn_weight=1.751 pA -> exc_firing_rate=64 Hz [target 40.0-50.0 Hz, off 14 Hz]\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0065/network\n", - "2026-09-06 23:35:06,876 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,880 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,884 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,886 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,888 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,890 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,899 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,944 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,966 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 1/16 (#65): clamp.amp_na=163.5 nA conn.syn_weight=18.77 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0066/network\n", - "2026-09-06 23:35:06,989 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,993 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:06,998 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,000 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,002 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,004 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,012 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,059 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,083 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 2/16 (#66): clamp.amp_na=293.7 nA conn.syn_weight=27.28 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0067/network\n", - "2026-09-06 23:35:07,104 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,108 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,113 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,115 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,117 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,120 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,128 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,175 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,202 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 3/16 (#67): clamp.amp_na=556.7 nA conn.syn_weight=48.37 pA -> exc_firing_rate=204 Hz (off 154 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0068/network\n", - "2026-09-06 23:35:07,226 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,231 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,235 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,237 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,238 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,241 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,250 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,296 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,318 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 4/16 (#68): clamp.amp_na=259.5 nA conn.syn_weight=20.57 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0069/network\n", - "2026-09-06 23:35:07,343 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,348 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,352 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,354 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,355 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,357 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,367 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,414 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,439 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 5/16 (#69): clamp.amp_na=568 nA conn.syn_weight=9.926 pA -> exc_firing_rate=90 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0070/network\n", - "2026-09-06 23:35:07,462 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,467 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,471 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,472 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,474 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,477 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,485 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,531 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,557 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 6/16 (#70): clamp.amp_na=597.1 nA conn.syn_weight=5.157 pA -> exc_firing_rate=84 Hz (off 34 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0071/network\n", - "2026-09-06 23:35:07,578 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,582 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,587 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,588 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,590 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,592 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,600 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,646 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,673 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 7/16 (#71): clamp.amp_na=764.7 nA conn.syn_weight=27.67 pA -> exc_firing_rate=174 Hz (off 124 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0072/network\n", - "2026-09-06 23:35:07,696 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,701 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,705 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,707 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,708 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,711 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,720 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,766 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,792 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 8/16 (#72): clamp.amp_na=651.3 nA conn.syn_weight=14.52 pA -> exc_firing_rate=118 Hz (off 68 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0073/network\n", - "2026-09-06 23:35:07,816 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,821 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,825 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,827 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,829 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,831 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,840 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,887 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,915 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 9/16 (#73): clamp.amp_na=465.8 nA conn.syn_weight=18.95 pA -> exc_firing_rate=90 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0074/network\n", - "2026-09-06 23:35:07,937 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,941 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,948 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,950 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,952 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,955 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:07,964 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,025 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,047 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 10/16 (#74): clamp.amp_na=329.3 nA conn.syn_weight=3.723 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0075/network\n", - "2026-09-06 23:35:08,070 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,075 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,081 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,082 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,084 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,087 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,096 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,141 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,164 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 11/16 (#75): clamp.amp_na=264 nA conn.syn_weight=9.507 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0076/network\n", - "2026-09-06 23:35:08,186 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,190 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,195 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,197 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,199 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,202 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,211 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,257 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,286 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 12/16 (#76): clamp.amp_na=639.5 nA conn.syn_weight=21.28 pA -> exc_firing_rate=138 Hz (off 88 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0077/network\n", - "2026-09-06 23:35:08,311 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,315 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,320 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,322 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,323 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,326 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,335 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,381 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,403 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 13/16 (#77): clamp.amp_na=267.7 nA conn.syn_weight=13.01 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0078/network\n", - "2026-09-06 23:35:08,427 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,432 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,437 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,439 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,440 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,443 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,452 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,498 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,524 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 14/16 (#78): clamp.amp_na=577.5 nA conn.syn_weight=29.82 pA -> exc_firing_rate=154 Hz (off 104 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0079/network\n", - "2026-09-06 23:35:08,547 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,551 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,556 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,557 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,559 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,562 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,571 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,618 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,638 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 15/16 (#79): clamp.amp_na=169.7 nA conn.syn_weight=20.96 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0080/network\n", - "2026-09-06 23:35:08,660 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,664 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,668 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,670 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,672 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,674 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,682 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,729 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,754 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 5, trial 16/16 (#80): clamp.amp_na=461.6 nA conn.syn_weight=10.21 pA -> exc_firing_rate=62 Hz (off 12 Hz) <- best so far\n", - " gen 5/12: best clamp.amp_na=461.6 nA conn.syn_weight=10.21 pA -> exc_firing_rate=62 Hz [target 40.0-50.0 Hz, off 12 Hz]\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0081/network\n", - "2026-09-06 23:35:08,788 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,793 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,798 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,799 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,802 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,807 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,815 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,862 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,888 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 1/16 (#81): clamp.amp_na=455.4 nA conn.syn_weight=8.074 pA -> exc_firing_rate=56 Hz (off 6 Hz) <- best so far\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0082/network\n", - "2026-09-06 23:35:08,910 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,914 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,918 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,920 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,922 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,924 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,934 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:08,981 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,008 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 2/16 (#82): clamp.amp_na=581.2 nA conn.syn_weight=13.88 pA -> exc_firing_rate=104 Hz (off 54 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0083/network\n", - "2026-09-06 23:35:09,033 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,037 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,042 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,044 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,046 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,048 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,056 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,103 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,125 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 3/16 (#83): clamp.amp_na=119.5 nA conn.syn_weight=9.999 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0084/network\n", - "2026-09-06 23:35:09,149 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,153 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,157 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,159 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,161 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,164 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,172 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,219 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,246 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 4/16 (#84): clamp.amp_na=540.1 nA conn.syn_weight=31.73 pA -> exc_firing_rate=154 Hz (off 104 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0085/network\n", - "2026-09-06 23:35:09,270 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,275 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,280 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,281 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,283 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,286 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,294 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,341 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,363 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 5/16 (#85): clamp.amp_na=342.2 nA conn.syn_weight=10.72 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0086/network\n", - "2026-09-06 23:35:09,385 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,390 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,395 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,396 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,399 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,402 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,410 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,457 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,483 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 6/16 (#86): clamp.amp_na=459.9 nA conn.syn_weight=29.74 pA -> exc_firing_rate=132 Hz (off 82 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0087/network\n", - "2026-09-06 23:35:09,506 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,511 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,516 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,518 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,520 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,522 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,531 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,578 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,604 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 7/16 (#87): clamp.amp_na=772.8 nA conn.syn_weight=5.593 pA -> exc_firing_rate=116 Hz (off 66 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0088/network\n", - "2026-09-06 23:35:09,629 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,634 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,638 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,640 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,642 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,645 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,654 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,699 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,722 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 8/16 (#88): clamp.amp_na=219 nA conn.syn_weight=11 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0089/network\n", - "2026-09-06 23:35:09,744 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,749 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,757 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,759 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,761 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,764 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,773 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,818 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,846 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 9/16 (#89): clamp.amp_na=601.9 nA conn.syn_weight=34.39 pA -> exc_firing_rate=174 Hz (off 124 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0090/network\n", - "2026-09-06 23:35:09,871 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,876 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,880 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,881 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,883 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,886 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,895 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,943 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,968 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 10/16 (#90): clamp.amp_na=574.8 nA conn.syn_weight=21.2 pA -> exc_firing_rate=126 Hz (off 76 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0091/network\n", - "2026-09-06 23:35:09,992 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:09,996 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,001 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,003 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,004 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,007 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,016 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,063 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,089 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 11/16 (#91): clamp.amp_na=419.6 nA conn.syn_weight=23.57 pA -> exc_firing_rate=94 Hz (off 44 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0092/network\n", - "2026-09-06 23:35:10,109 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,114 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,119 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,120 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,122 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,124 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,134 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,182 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,209 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 12/16 (#92): clamp.amp_na=617.7 nA conn.syn_weight=6.605 pA -> exc_firing_rate=92 Hz (off 42 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0093/network\n", - "2026-09-06 23:35:10,234 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,239 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,244 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,245 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,247 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,250 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,259 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,305 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,333 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 13/16 (#93): clamp.amp_na=407.3 nA conn.syn_weight=53.99 pA -> exc_firing_rate=198 Hz (off 148 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0094/network\n", - "2026-09-06 23:35:10,356 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,361 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,366 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,368 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,370 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,373 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,382 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,428 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,451 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 14/16 (#94): clamp.amp_na=325.5 nA conn.syn_weight=18.94 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0095/network\n", - "2026-09-06 23:35:10,473 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,478 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,482 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,484 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,486 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,489 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,497 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,543 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,567 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 15/16 (#95): clamp.amp_na=380.2 nA conn.syn_weight=18.98 pA -> exc_firing_rate=32 Hz (off 8 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0096/network\n", - "2026-09-06 23:35:10,590 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,595 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,599 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,602 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,604 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,606 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,614 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,660 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,688 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 6, trial 16/16 (#96): clamp.amp_na=491 nA conn.syn_weight=27.28 pA -> exc_firing_rate=130 Hz (off 80 Hz)\n", - " gen 6/12: best clamp.amp_na=455.4 nA conn.syn_weight=8.074 pA -> exc_firing_rate=56 Hz [target 40.0-50.0 Hz, off 6 Hz]\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0097/network\n", - "2026-09-06 23:35:10,719 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,727 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,732 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,734 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,736 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,739 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,748 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,795 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,818 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 7, trial 1/16 (#97): clamp.amp_na=430.7 nA conn.syn_weight=7.843 pA -> exc_firing_rate=46 Hz (in target) <- best so far\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0098/network\n", - "2026-09-06 23:35:10,840 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,845 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,851 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,853 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,855 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,857 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,867 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,913 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,939 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 7, trial 2/16 (#98): clamp.amp_na=400.7 nA conn.syn_weight=19.04 pA -> exc_firing_rate=60 Hz (off 10 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0099/network\n", - "2026-09-06 23:35:10,962 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,967 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,972 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,973 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,975 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,979 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:10,988 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,034 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,059 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 7, trial 3/16 (#99): clamp.amp_na=384.3 nA conn.syn_weight=16.38 pA -> exc_firing_rate=32 Hz (off 8 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0100/network\n", - "2026-09-06 23:35:11,082 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,086 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,091 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,092 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,095 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,097 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,106 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,152 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,175 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 7, trial 4/16 (#100): clamp.amp_na=273.4 nA conn.syn_weight=9.226 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0101/network\n", - "2026-09-06 23:35:11,200 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,205 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,210 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,212 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,214 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,216 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,226 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,273 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,294 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 7, trial 5/16 (#101): clamp.amp_na=257.2 nA conn.syn_weight=15.03 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0102/network\n", - "2026-09-06 23:35:11,317 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,321 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,326 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,328 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,330 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,333 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,342 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,389 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,419 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 7, trial 6/16 (#102): clamp.amp_na=381.6 nA conn.syn_weight=47.06 pA -> exc_firing_rate=170 Hz (off 120 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0103/network\n", - "2026-09-06 23:35:11,442 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,447 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,452 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,454 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,455 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,458 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,468 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,514 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,535 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 7, trial 7/16 (#103): clamp.amp_na=321.6 nA conn.syn_weight=7.252 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0104/network\n", - "2026-09-06 23:35:11,557 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,563 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,568 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,570 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,572 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,577 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,586 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,632 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,654 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 7, trial 8/16 (#104): clamp.amp_na=262.5 nA conn.syn_weight=9.975 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0105/network\n", - "2026-09-06 23:35:11,678 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,682 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,687 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,689 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,691 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,693 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,703 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,750 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,777 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 7, trial 9/16 (#105): clamp.amp_na=508.6 nA conn.syn_weight=3.275 pA -> exc_firing_rate=62 Hz (off 12 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0106/network\n", - "2026-09-06 23:35:11,801 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,806 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,811 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,813 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,815 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,817 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,827 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,873 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,895 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 7, trial 10/16 (#106): clamp.amp_na=198.6 nA conn.syn_weight=2.816 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0107/network\n", - "2026-09-06 23:35:11,919 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,924 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,929 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,931 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,933 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,936 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,945 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:11,991 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,017 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 7, trial 11/16 (#107): clamp.amp_na=445.4 nA conn.syn_weight=7.913 pA -> exc_firing_rate=52 Hz (off 2 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0108/network\n", - "2026-09-06 23:35:12,042 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,047 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,051 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,053 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,055 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,057 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,066 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,113 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,136 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 7, trial 12/16 (#108): clamp.amp_na=190.5 nA conn.syn_weight=10.25 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0109/network\n", - "2026-09-06 23:35:12,160 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,164 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,169 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,171 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,173 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,175 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,184 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,231 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,254 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 7, trial 13/16 (#109): clamp.amp_na=355.9 nA conn.syn_weight=21.68 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0110/network\n", - "2026-09-06 23:35:12,278 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,283 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,288 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,290 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,292 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,295 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,304 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,351 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,380 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 7, trial 14/16 (#110): clamp.amp_na=616.9 nA conn.syn_weight=4.625 pA -> exc_firing_rate=88 Hz (off 38 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0111/network\n", - "2026-09-06 23:35:12,406 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,412 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,416 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,419 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,421 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,424 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,434 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,480 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,508 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 7, trial 15/16 (#111): clamp.amp_na=768.6 nA conn.syn_weight=31.46 pA -> exc_firing_rate=186 Hz (off 136 Hz)\n", - "Executing node: clamp\n", - "Executing node: exc\n", - "Executing node: conn\n", - "Executing node: sim\n", - "[NW_SimConfig] network built in results/generated_example/optimization/opt_20260906_233459/trials/0112/network\n", - "2026-09-06 23:35:12,533 [INFO] Created log file\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Created log file\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,539 [INFO] Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Batch processing nodes for exc/0.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,547 [INFO] Setting up output directory\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Setting up output directory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,549 [INFO] Building cells.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building cells.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,551 [INFO] Building recurrent connections\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Building recurrent connections\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,554 [INFO] Network created.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Network created.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,563 [INFO] Starting Simulation\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Starting Simulation\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,609 [INFO] Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Simulation finished, finalizing results.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2026-09-06 23:35:12,631 [INFO] Done.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:NestIOUtils:Done.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Executing node: ana\n", - " gen 7, trial 16/16 (#112): clamp.amp_na=356.5 nA conn.syn_weight=11.08 pA -> exc_firing_rate=0 Hz (off 40 Hz)\n", - " gen 7/12: best clamp.amp_na=430.7 nA conn.syn_weight=7.843 pA -> exc_firing_rate=46 Hz [target 40.0-50.0 Hz, in target] — all targets met\n", - "[opt_20260906_233459] stopped: a candidate is inside every target band\n", - " exc_firing_rate = 46 Hz (target 40.0-50.0 Hz, in target)\n", - "Optimization finished: a candidate is inside every target band\n", - "\n", - "Applied the following parameters to the workflow:\n", - "clamp.configure(amp_na=430.6735051488371)\n", - "conn.configure(syn_weight=7.8434448541675374)\n", - "\n", - "Results for this configuration: results/generated_example/optimization/opt_20260906_233459/trials/0097\n" - ] - } - ], + "outputs": [], "source": [ "if __name__ == \"__main__\":\n", " main()\n" diff --git a/notebooks/vneumod_simulation.ipynb b/notebooks/vneumod_simulation.ipynb index 70d813c1..ed929444 100644 --- a/notebooks/vneumod_simulation.ipynb +++ b/notebooks/vneumod_simulation.ipynb @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "318873c3-acdc-463c-8859-04fa2021f7dc", "metadata": {}, "outputs": [], @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "26e82f32-4fb7-4104-a84f-bdd62d6137ca", "metadata": {}, "outputs": [], @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "9873001b-fee6-43ef-975b-d76a21b22d69", "metadata": {}, "outputs": [], @@ -43,7 +43,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "6f5f5aaf-7fb1-4e23-8d7e-8b169f5cbc03", "metadata": {}, "outputs": [], @@ -68,7 +68,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "7723e743-3584-4422-b64a-097e63ba0dde", "metadata": {}, "outputs": [], @@ -85,7 +85,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "ee53ad4b-9408-4fbf-9c98-2866bc72c076", "metadata": {}, "outputs": [], @@ -95,21 +95,10 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "87a68e7a-7c5d-4931-b7d0-4918a126ed43", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Create nodes\n", "load_subject = VNMLoadSubjectTimeSeriesNode(\"VNMLoadSubject\")\n", @@ -155,7 +144,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "746b7acc-2e66-4266-97c9-0db57676ac5a", "metadata": {}, "outputs": [], @@ -183,7 +172,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "5aa67d3f-f488-4a42-857d-e2d75609d495", "metadata": { "editable": true, @@ -192,151 +181,7 @@ }, "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Workflow: vnm_simulation_analysis\n", - "Nodes:\n", - " VNMLoadSubject\n", - " VNMLoadModel\n", - " VNMSimulation\n", - " VNMGlmAnalysis\n", - " NiftiViewer\n", - "Connections:\n", - " VNMLoadSubject.CX -> VNMSimulation.CX\n", - " VNMLoadSubject.atlasV -> VNMSimulation.atlasV\n", - " VNMLoadModel.model -> VNMSimulation.model\n", - " VNMSimulation.simulation_name -> VNMGlmAnalysis.simulation_name\n", - " VNMSimulation.trials -> VNMGlmAnalysis.trials\n", - " VNMSimulation.Chrf -> VNMGlmAnalysis.Chrf\n", - " VNMGlmAnalysis.nifti_files -> NiftiViewer.nifti_files\n", - "\n", - "Executing workflow...\n", - "Executing node: VNMLoadModel\n", - "Loading Group Surrogate model : ../data/vnm_data/model/ppmi81CXAllenCube2s34gmacomp_gsm_var.mat\n", - "Executing node: VNMLoadSubject\n", - "Loading Subject multivariate time-series : ../data/vnm_data/subjects/ppmi81CXAllenCube2s34gmacomp.mat\n", - "Loading Cube ROI atlas : ../data/vnm_data/atlas/allenCube2atlas.nii.gz\n", - "Executing node: VNMSimulation\n", - "Loading target ROI nifti file: ../data/vnm_data/target_roi/allenCube2atlasStn3.nii.gz\n", - "generate modulation (add & mul) time-series, target roi=4525, srframes=160.0, dbsoffsec=28.0, dbsonsec=22.0, dbspw=0.15\n", - "convolution params tr=1.0, res=16, sp=8\n", - "loading subject permutation : ../data/vnm_data/perm/perm1_ppmi81CXAllenCube2s34gmacomp.mat\n", - "calc virtual neuromodulation surrogate. roi=4525, n_surr=40\n", - "surrogate sample : 1\n", - "done t=4.118064880371094 sec\n", - "surrogate sample : 1\n", - "done t=3.5874860286712646 sec\n", - "surrogate sample : 1\n", - "done t=3.572761297225952 sec\n", - "surrogate sample : 1\n", - "done t=3.5038158893585205 sec\n", - "surrogate sample : 1\n", - "done t=3.6658527851104736 sec\n", - "surrogate sample : 1\n", - "done t=3.5049540996551514 sec\n", - "surrogate sample : 1\n", - "done t=3.5228941440582275 sec\n", - "surrogate sample : 1\n", - "done t=3.623715877532959 sec\n", - "surrogate sample : 1\n", - "done t=3.4989869594573975 sec\n", - "surrogate sample : 1\n", - "done t=3.510793924331665 sec\n", - "surrogate sample : 1\n", - "done t=3.540580987930298 sec\n", - "surrogate sample : 1\n", - "done t=3.530258893966675 sec\n", - "surrogate sample : 1\n", - "done t=3.5360162258148193 sec\n", - "surrogate sample : 1\n", - "done t=3.575166940689087 sec\n", - "surrogate sample : 1\n", - "done t=3.5215256214141846 sec\n", - "surrogate sample : 1\n", - "done t=3.531266927719116 sec\n", - "surrogate sample : 1\n", - "done t=3.598142147064209 sec\n", - "surrogate sample : 1\n", - "done t=3.535773992538452 sec\n", - "surrogate sample : 1\n", - "done t=3.5200798511505127 sec\n", - "surrogate sample : 1\n", - "done t=3.6254501342773438 sec\n", - "surrogate sample : 1\n", - "done t=3.520939826965332 sec\n", - "surrogate sample : 1\n", - "done t=3.5723648071289062 sec\n", - "surrogate sample : 1\n", - "done t=3.627847909927368 sec\n", - "surrogate sample : 1\n", - "done t=3.493666648864746 sec\n", - "surrogate sample : 1\n", - "done t=3.5441091060638428 sec\n", - "surrogate sample : 1\n", - "done t=3.5957560539245605 sec\n", - "surrogate sample : 1\n", - "done t=3.5077037811279297 sec\n", - "surrogate sample : 1\n", - "done t=3.490839958190918 sec\n", - "surrogate sample : 1\n", - "done t=3.6117448806762695 sec\n", - "surrogate sample : 1\n", - "done t=3.5150139331817627 sec\n", - "surrogate sample : 1\n", - "done t=3.522123098373413 sec\n", - "surrogate sample : 1\n", - "done t=3.569626808166504 sec\n", - "surrogate sample : 1\n", - "done t=3.519718885421753 sec\n", - "surrogate sample : 1\n", - "done t=3.5144567489624023 sec\n", - "surrogate sample : 1\n", - "done t=3.5078439712524414 sec\n", - "surrogate sample : 1\n", - "done t=3.530895948410034 sec\n", - "surrogate sample : 1\n", - "done t=3.5383191108703613 sec\n", - "surrogate sample : 1\n", - "done t=3.507965087890625 sec\n", - "surrogate sample : 1\n", - "done t=3.556326150894165 sec\n", - "surrogate sample : 1\n", - "done t=3.6212308406829834 sec\n", - "Executing node: VNMGlmAnalysis\n", - "Loading Cube ROI atlas : ../data/vnm_data/atlas/allenCube2atlas.nii.gz\n", - "output file already exists, skipping: ../data/vnm_data/output/ppmi81CXAllenCube2s34gmacomp_4525sr40pr1_2nd-Tukey8.nii.gz\n", - "Executing node: NiftiViewer\n", - "[NiftiViewer] Using nifti_files input port (1 file(s))\n", - "[NiftiViewer] Loading background image: ../data/vnm_data/atlas/allenCube2atlas.nii.gz\n", - "[NiftiViewer] Loading overlay: ../data/vnm_data/output/ppmi81CXAllenCube2s34gmacomp_4525sr40pr1_2nd-Tukey8.nii.gz\n", - "[NiftiViewer] Displaying interactive viewer...\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "bc1ea0595217450085afa4a2fb1231ec", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(HBox(children=(VBox(children=(Dropdown(description='Axis:', options=('axial', 'sagittal', 'coro…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Workflow execution completed successfully!\n" - ] - } - ], + "outputs": [], "source": [ "# Print workflow information\n", "print(workflow)\n", @@ -353,7 +198,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "b7453761-934d-4cc5-a130-19eaf42c7e87", "metadata": {}, "outputs": [], @@ -371,7 +216,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "c3a35222-b4f7-4083-a2e1-948675326d7c", "metadata": {}, "outputs": [], @@ -382,7 +227,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "2a66a780-7d3b-45b9-9bed-820dbe714374", "metadata": {}, "outputs": [], @@ -392,7 +237,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "0462108b-9f59-49ec-9ffb-648907cac218", "metadata": {}, "outputs": [], diff --git a/pyproject.toml b/pyproject.toml index 5b703ac6..d0d67528 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -38,6 +38,10 @@ pointnet = [ "h5py>=3.10", "matplotlib>=3.6.0", ] +optimization = [ + "optuna>=3.0", + "cmaes", +] [project.scripts] neuroworkflow = "neuroworkflow.cli.commands:main" diff --git a/src/neuroworkflow/nodes/network/NW_Connectivity.py b/src/neuroworkflow/nodes/network/NW_Connectivity.py index f5e5dc9b..8f69dafd 100644 --- a/src/neuroworkflow/nodes/network/NW_Connectivity.py +++ b/src/neuroworkflow/nodes/network/NW_Connectivity.py @@ -211,13 +211,14 @@ def _coerce_connection_rule(value): - an int (e.g. 1, 3) -> passed through - a real callable (notebook lambda) -> passed through - a numeric string ("3") -> int - - a lambda string ("lambda src, tgt: ...") -> eval'd to a callable + - a lambda string ("lambda src, tgt: ...") -> compiled to a callable The last case is the GUI path: a lambda cannot be JSON-encoded, and the code generator only un-quotes a lambda at the TOP LEVEL of configure(), not one nested inside the `connections` list. So a per-connection rule - reaches here as a string and must be evaluated. numpy is available as - `np` for rules that use np.random / np.exp etc. + reaches here as a string. Only a single lambda expression is accepted — + not an arbitrary statement or ``eval`` payload. numpy is available as + ``np`` for rules that use np.random / np.exp etc. """ if callable(value) or isinstance(value, (int, bool)): return value @@ -225,8 +226,36 @@ def _coerce_connection_rule(value): s = value.strip() if s.lstrip("+-").isdigit(): return int(s) + import ast import numpy as np - fn = eval(s, {"np": np, "__builtins__": __builtins__}) + try: + tree = ast.parse(s, mode="eval") + except SyntaxError as exc: + raise ValueError( + f"connection_rule string is not valid Python: {value!r}" + ) from exc + if not isinstance(tree.body, ast.Lambda): + raise ValueError( + "connection_rule strings must be a lambda expression " + f"(e.g. 'lambda src, tgt: 1'); got {value!r}" + ) + safe_builtins = { + "True": True, + "False": False, + "None": None, + "abs": abs, + "min": min, + "max": max, + "round": round, + "int": int, + "float": float, + "len": len, + "range": range, + } + fn = eval( + compile(tree, "", "eval"), + {"__builtins__": safe_builtins, "np": np}, + ) if not callable(fn): raise ValueError( f"connection_rule string did not evaluate to a callable: {value!r}" diff --git a/src/neuroworkflow/nodes/optimization/NW_Optimization.py b/src/neuroworkflow/nodes/optimization/NW_Optimization.py index 39ba4ac4..af9df082 100644 --- a/src/neuroworkflow/nodes/optimization/NW_Optimization.py +++ b/src/neuroworkflow/nodes/optimization/NW_Optimization.py @@ -25,7 +25,7 @@ class NW_Optimization(Node): Typical use, once the workflow is built:: opt = NW_Optimization("opt") - opt.configure(algorithm="cmaes", pop_size=16, max_generations=12) + opt.configure(algorithm="random", pop_size=16, max_generations=12) spec = build_spec(workflow, opt.algorithm_config()) result = optimize(workflow, spec=spec, results_path=opt.results_path()) @@ -44,13 +44,15 @@ class NW_Optimization(Node): ), parameters={ "algorithm": ParameterDefinition( - default_value="cmaes", + default_value="random", description=( - "Search algorithm. 'cmaes' is the default for a single objective and " - "continuous parameters; 'tpe' when each trial is expensive; 'nsga2' or " - "'nsga3' for several objectives, returning a Pareto front; 'random' as " - "a dependency-free baseline. Everything except 'random' needs Optuna " - "(pip install optuna cmaes)." + "Search algorithm. 'random' is the default and needs no extra " + "packages. 'cmaes' is a good default for a single objective and " + "continuous parameters once Optuna is installed; 'tpe' when each " + "trial is expensive; 'nsga2' or 'nsga3' for several objectives, " + "returning a Pareto front. Everything except 'random' needs " + "pip install -e \".[optimization]\" (optuna + cmaes). The nest " + "kernel image does not yet include those packages." ), constraints={"allowed_values": ["random", "cmaes", "tpe", "nsga2", "nsga3", "optuna_random"]}, @@ -67,8 +69,9 @@ class NW_Optimization(Node): default_value=20, description=( "Generation budget. At most pop_size x max_generations runs, plus one " - "baseline; the search stops earlier once a candidate lands inside every " - "target band." + "baseline. For a single in_range objective the search also stops once a " + "candidate lands inside the target band; with several objectives it keeps " + "going to develop the Pareto front (stop_when_reached defaults to False)." ), constraints={"min": 1}, ), diff --git a/src/neuroworkflow/nodes/simulation/NW_SimConfig.py b/src/neuroworkflow/nodes/simulation/NW_SimConfig.py index ad6c892e..33913cb5 100644 --- a/src/neuroworkflow/nodes/simulation/NW_SimConfig.py +++ b/src/neuroworkflow/nodes/simulation/NW_SimConfig.py @@ -97,7 +97,13 @@ class NW_SimConfig(Node): ), "overwrite": ParameterDefinition( default_value=True, - description="Overwrite existing config files and network files.", + description=( + "Overwrite existing config files. SONATA network files follow " + "rebuild_network: with 'auto' (the default), an unchanged signature " + "reuses the network on disk, so a random connection_rule is frozen " + "after the first build. Use rebuild_network='always' to draw a " + "new realisation each run." + ), ), "rebuild_network": ParameterDefinition( default_value="auto", @@ -106,8 +112,9 @@ class NW_SimConfig(Node): "a structural parameter changed (population size, neuron model, " "connectivity, synaptic weights) or the files are missing — values that " "are read at simulation time (nest_params, synapse dynamics_params_dict) " - "never trigger a rebuild. 'always' rebuilds every run. 'never' reuses " - "whatever is on disk." + "never trigger a rebuild. A random connection_rule is therefore frozen " + "after the first successful build. 'always' rebuilds every run. " + "'never' reuses whatever is on disk." ), constraints={"allowed_values": ["auto", "always", "never"]}, ), @@ -169,25 +176,43 @@ def _stable(value): """ if callable(value): import inspect + if hasattr(value, "func") and hasattr(value, "args"): + # functools.partial and similar wrappers have no __code__. + return ( + "partial:" + f"{NW_SimConfig._stable(value.func)}:" + f"{NW_SimConfig._stable(getattr(value, 'args', ()))}:" + f"{NW_SimConfig._stable(getattr(value, 'keywords', {}) or {})}" + ) + code = getattr(value, "__code__", None) try: text = inspect.getsource(value).strip() except (OSError, TypeError): - text = value.__code__.co_code.hex() + repr(value.__code__.co_consts) + if code is not None: + text = code.co_code.hex() + repr(code.co_consts) + else: + text = repr(value) # Values the rule reads but does not show in its source. A lambda written # in a notebook usually reads them as globals (`eps`), not as closure # cells, so both are captured — otherwise changing eps would leave the # signature identical and silently reuse a network built with the old value. referenced = [] - for cell in (value.__closure__ or []): + for cell in (getattr(value, "__closure__", None) or []): try: referenced.append(repr(cell.cell_contents)) except ValueError: referenced.append("") - simple = (int, float, str, bool, type(None)) - for name in sorted(value.__code__.co_names): - if name in value.__globals__: - referenced_value = value.__globals__[name] - if isinstance(referenced_value, simple): + if code is not None: + globs = getattr(value, "__globals__", {}) or {} + for name in sorted(code.co_names): + if name not in globs: + continue + referenced_value = globs[name] + if isinstance( + referenced_value, (int, float, str, bool, type(None), dict, list, tuple) + ): + referenced.append(f"{name}={referenced_value!r}") + elif hasattr(referenced_value, "tolist"): referenced.append(f"{name}={referenced_value!r}") return f"callable:{text}:{referenced}" if isinstance(value, dict): diff --git a/src/neuroworkflow/optimization/__init__.py b/src/neuroworkflow/optimization/__init__.py index 17c7fb55..ad9828fa 100644 --- a/src/neuroworkflow/optimization/__init__.py +++ b/src/neuroworkflow/optimization/__init__.py @@ -11,8 +11,7 @@ """ from .addressing import discover_measurables, read_output, set_parameter -from .engine import (OptimizationResult, objective_fitness, optimize, - reusable_paths) +from .engine import OptimizationResult, objective_fitness, optimize, reusable_paths from .ledger import Ledger from .optimizers import Optimizer, available, register_optimizer from .spec import ( diff --git a/src/neuroworkflow/optimization/addressing.py b/src/neuroworkflow/optimization/addressing.py index 91f7e177..513e12c3 100644 --- a/src/neuroworkflow/optimization/addressing.py +++ b/src/neuroworkflow/optimization/addressing.py @@ -9,6 +9,7 @@ port name. Any further segments index into a nested dict. """ +import math from copy import deepcopy from typing import Any, Dict, List, Tuple @@ -75,6 +76,39 @@ def set_parameter(workflow, address: str, value: Any) -> None: node.configure(**{param: current}) +def get_parameter(workflow, address: str) -> Any: + """Read a parameter by dotted address (current configured value).""" + node_name, param, keys = split_address(address) + node = _get_node(workflow, node_name) + + if param not in node._parameters: + raise KeyError( + f"Node {node_name!r} has no parameter {param!r} " + f"(have: {', '.join(sorted(node._parameters))})" + ) + + value = node._parameters[param] + for k in keys: + if not isinstance(value, dict): + raise TypeError( + f"Address {address!r}: cannot index {type(value).__name__} with {k!r}" + ) + if k not in value: + raise KeyError( + f"Address {address!r}: key {k!r} not in " + f"{', '.join(map(str, list(value)[:8]))}" + ) + value = value[k] + return value + + +def clear_output_ports(workflow) -> None: + """Drop every output-port value so a trial cannot be scored on stale data.""" + for node in workflow.nodes.values(): + for port in node._output_ports.values(): + port.value = None + + def read_output(workflow, address: str) -> Any: """Read a value from an output port by dotted address.""" node_name, port, keys = split_address(address) @@ -102,8 +136,16 @@ def read_output(workflow, address: str) -> Any: def _is_number(value: Any) -> bool: - # bool is an int subclass but is never a measured quantity. - return isinstance(value, (int, float)) and not isinstance(value, bool) + """True for a finite scalar (Python or numpy). bool and NaN are not numbers.""" + if isinstance(value, bool) or value is None: + return False + if hasattr(value, "ndim") and getattr(value, "ndim", 0) != 0: + return False + try: + number = float(value) + except (TypeError, ValueError): + return False + return math.isfinite(number) def discover_measurables(workflow) -> Dict[str, float]: diff --git a/src/neuroworkflow/optimization/engine.py b/src/neuroworkflow/optimization/engine.py index 093fb201..cb155791 100644 --- a/src/neuroworkflow/optimization/engine.py +++ b/src/neuroworkflow/optimization/engine.py @@ -14,6 +14,7 @@ ledger and writing ``control.json`` — nothing here requires that to happen. """ +import math import os import shutil import time @@ -21,7 +22,13 @@ from datetime import datetime from typing import Any, Callable, Dict, List, Optional, Sequence -from .addressing import read_output, set_parameter +from .addressing import ( + _is_number, + clear_output_ports, + get_parameter, + read_output, + set_parameter, +) from .ledger import Ledger from .optimizers import create_optimizer from .spec import AlgorithmConfig, Objective, OptimizationSpec, build_spec @@ -85,9 +92,7 @@ def configure_snippet(self) -> str: args = [f"{k}={v!r}" for k, v in scalars.get(node, {}).items()] for param, keys in nested.get(node, {}).items(): updates = ", ".join(f'"{k}": {v!r}' for k, v in keys.items()) - args.append( - f'{param}={{**{node}._parameters["{param}"], {updates}}}' - ) + args.append(f'{param}={{**{node}._parameters["{param}"], {updates}}}') lines.append(f"{node}.configure({', '.join(args)})") return "\n".join(lines) @@ -96,21 +101,26 @@ def configure_snippet(self) -> str: # Fitness # --------------------------------------------------------------------------- + def objective_fitness(objective: Objective, value: float) -> float: """Distance from the target, always minimized. ``in_range`` is zero anywhere inside the band and grows with the distance outside it — a band, not a point, so seed-to-seed noise is absorbed rather - than chased. + than chased. Non-finite values are not a distance of zero; the caller + must treat them as a failed trial. """ + number = float(value) + if not math.isfinite(number): + raise ValueError(f"non-finite measurement {value!r} cannot be scored") if objective.goal == "minimize": - return float(value) + return number if objective.goal == "maximize": - return -float(value) - if value < objective.low: - return float(objective.low - value) - if value > objective.high: - return float(value - objective.high) + return -number + if number < objective.low: + return float(objective.low - number) + if number > objective.high: + return float(number - objective.high) return 0.0 @@ -130,7 +140,11 @@ def objective_scales(spec) -> List[float]: scales = [] for objective in spec.objectives: scale = None - if objective.goal == "in_range" and objective.low is not None and objective.high is not None: + if ( + objective.goal == "in_range" + and objective.low is not None + and objective.high is not None + ): width = float(objective.high) - float(objective.low) if width > 0: scale = width @@ -138,7 +152,7 @@ def objective_scales(spec) -> List[float]: scale = abs(float(objective.high)) or None else: baseline = (spec.baseline.get("measured") or {}).get(objective.name) - if isinstance(baseline, (int, float)) and baseline: + if _is_number(baseline) and baseline: scale = abs(float(baseline)) scales.append(scale or 1.0) return scales @@ -173,8 +187,7 @@ def worst_objective(spec, fitness: Optional[Sequence[float]]): if fitness is None: return None scales = objective_scales(spec) - ranked = [(o.name, abs(f) / s) - for o, f, s in zip(spec.objectives, fitness, scales)] + ranked = [(o.name, abs(f) / s) for o, f, s in zip(spec.objectives, fitness, scales)] return max(ranked, key=lambda pair: pair[1], default=None) @@ -201,9 +214,13 @@ class MyBuilder(Node): return sorted(names) -def _point_at_trial_dir(workflow, run_dir: str, trial_no: int, - seed_root: Optional[str] = None, - seed_names: Sequence[str] = ()) -> str: +def _point_at_trial_dir( + workflow, + run_dir: str, + trial_no: int, + seed_root: Optional[str] = None, + seed_names: Sequence[str] = (), +) -> str: """Give a trial its own results directory and return it. Nodes that write files — a network builder, a simulator config — otherwise @@ -241,9 +258,9 @@ def _dominates(a: List[float], b: List[float]) -> bool: def _pareto_front(rows: List[Dict[str, Any]]) -> List[Dict[str, Any]]: scored = [r for r in rows if r.get("fitness")] return [ - r for r in scored - if not any(_dominates(o["fitness"], r["fitness"]) - for o in scored if o is not r) + r + for r in scored + if not any(_dominates(o["fitness"], r["fitness"]) for o in scored if o is not r) ] @@ -251,15 +268,18 @@ def _pareto_front(rows: List[Dict[str, Any]]) -> List[Dict[str, Any]]: # The loop # --------------------------------------------------------------------------- -def optimize(workflow, - spec: Optional[OptimizationSpec] = None, - results_path: str = "results/optimization", - algorithm: Optional[AlgorithmConfig] = None, - reject_fn: Optional[RejectFn] = None, - run_id: Optional[str] = None, - per_trial_results: bool = True, - stop_when_reached: Optional[bool] = None, - verbose: bool = True) -> OptimizationResult: + +def optimize( + workflow, + spec: Optional[OptimizationSpec] = None, + results_path: str = "results/optimization", + algorithm: Optional[AlgorithmConfig] = None, + reject_fn: Optional[RejectFn] = None, + run_id: Optional[str] = None, + per_trial_results: bool = True, + stop_when_reached: Optional[bool] = None, + verbose: bool = True, +) -> OptimizationResult: """Optimize a built workflow against the targets declared in its schemas. Args: @@ -307,10 +327,13 @@ def optimize(workflow, attempt += 1 ledger = Ledger(os.path.join(results_path, run_id), run_id) - ledger.write_manifest(spec, extra={ - "created_at": datetime.now().isoformat(timespec="seconds"), - "workflow_name": getattr(workflow, "name", ""), - }) + ledger.write_manifest( + spec, + extra={ + "created_at": datetime.now().isoformat(timespec="seconds"), + "workflow_name": getattr(workflow, "name", ""), + }, + ) optimizer = create_optimizer(spec.dimensions, len(spec.objectives), spec.algorithm) @@ -318,21 +341,25 @@ def say(message: str) -> None: if verbose: print(message, flush=True) - say(f"[{run_id}] {spec.algorithm.name}: " + say( + f"[{run_id}] {spec.algorithm.name}: " f"{len(spec.dimensions)} dimensions, {len(spec.objectives)} objective(s), " f"up to {spec.algorithm.max_generations} generations " - f"x {spec.algorithm.pop_size} candidates") + f"x {spec.algorithm.pop_size} candidates" + ) for line in spec.summary().splitlines(): say(" " + line) if len(spec.objectives) > 1: - say(" each objective reports how far it missed, in its own unit. To compare " + say( + " each objective reports how far it missed, in its own unit. To compare " "objectives measured in different units, that miss is also given as a " "multiple of the target range asked for: '1.4x its target range' means the " - "miss is 1.4 times as wide as the range. 0 = the target was met.") + "miss is 1.4 times as wide as the range. 0 = the target was met." + ) # Captured before the first rotation: where the baseline ran, and whatever the # nodes declared as reusable from it. - seed_root = workflow.context.get("results_path") if per_trial_results else None + seed_root = workflow.context.get("results_path") if per_trial_results else None seed_names = reusable_paths(workflow) if per_trial_results else [] if seed_root and seed_names: say(f" reusing {', '.join(seed_names)} from {seed_root}") @@ -347,25 +374,48 @@ def say(message: str) -> None: for generation in range(1, spec.algorithm.max_generations + 1): candidates = optimizer.ask() + sources = list(getattr(optimizer, "last_ask_sources", []) or []) fitnesses: List[Optional[List[float]]] = [] for index, candidate in enumerate(candidates): trial_no += 1 - trial_dir = (_point_at_trial_dir(workflow, str(ledger.run_dir), trial_no, - seed_root, seed_names) - if per_trial_results else None) - row = _evaluate(workflow, spec, candidate, reject_fn, - trial_no, generation, index, trial_dir) + trial_dir = ( + _point_at_trial_dir( + workflow, str(ledger.run_dir), trial_no, seed_root, seed_names + ) + if per_trial_results + else None + ) + row = _evaluate( + workflow, + spec, + candidate, + reject_fn, + trial_no, + generation, + index, + trial_dir, + source=sources[index] if index < len(sources) else "ask", + ) fitnesses.append(row["fitness"]) trials.append(row) ledger.append_trial(row) previous = [t for t in trials[:-1] if t["target_ranges_off"] is not None] is_best = row["target_ranges_off"] is not None and ( - not previous or row["target_ranges_off"] < min(t["target_ranges_off"] for t in previous) + not previous + or row["target_ranges_off"] + < min(t["target_ranges_off"] for t in previous) ) - say(" " + _narrate_trial(spec, row, generation, index, - spec.algorithm.pop_size, is_best)) + try: + say( + " " + + _narrate_trial( + spec, row, generation, index, spec.algorithm.pop_size, is_best + ) + ) + except Exception as exc: + say(f" (could not narrate trial #{row['trial']}: {exc})") optimizer.tell(candidates, fitnesses) @@ -377,7 +427,9 @@ def say(message: str) -> None: # minimize or maximize goal has no value that counts as arrival. bands = [i for i, o in enumerate(spec.objectives) if o.goal == "in_range"] in_range = bool( - best and bands and len(bands) == len(spec.objectives) + best + and bands + and len(bands) == len(spec.objectives) and all(best["fitness"][i] == 0.0 for i in bands) ) n_failed = sum(1 for t in trials if t["status"] == "failed") @@ -389,37 +441,55 @@ def say(message: str) -> None: stop_reason = "a candidate is inside every target band" elif in_range and not reported_reached: reported_reached = True - say(" a candidate satisfies every target; continuing to develop " - "the Pareto front") + say( + " a candidate satisfies every target; continuing to develop " + "the Pareto front" + ) command = ledger.read_control() if command: control_ack, stop_reason, paused = _apply_control( - command, optimizer, say, stop_reason, paused) + command, + optimizer, + say, + stop_reason, + paused, + workflow=workflow, + spec=spec, + ) - ledger.write_status({ - "state": "done" if stop_reason else ("paused" if paused else "running"), - "updated_at": datetime.now().isoformat(timespec="seconds"), - "generation": generation, - "max_generations": spec.algorithm.max_generations, - "n_evals": len(trials), - "n_ok": len(scored), - "n_failed": n_failed, - "n_rejected": n_rejected, - "best": best, - "pareto_front": _pareto_front(trials) if len(spec.objectives) > 1 else [], - "progress": { - "best_target_ranges_off_by_gen": best_by_generation, - "gens_since_improvement": _gens_since_improvement(best_by_generation), - }, - "control_ack": control_ack, - "stop_reason": stop_reason or None, - "message": _narrate(generation, spec, best, in_range, - n_failed, n_rejected), - }) + ledger.write_status( + { + "state": "done" if stop_reason else ("paused" if paused else "running"), + "updated_at": datetime.now().isoformat(timespec="seconds"), + "generation": generation, + "max_generations": spec.algorithm.max_generations, + "n_evals": len(trials), + "n_ok": len(scored), + "n_failed": n_failed, + "n_rejected": n_rejected, + "best": best, + "pareto_front": ( + _pareto_front(trials) if len(spec.objectives) > 1 else [] + ), + "progress": { + "best_target_ranges_off_by_gen": best_by_generation, + "gens_since_improvement": _gens_since_improvement( + best_by_generation + ), + }, + "control_ack": control_ack, + "stop_reason": stop_reason or None, + "message": _narrate( + generation, spec, best, in_range, n_failed, n_rejected + ), + } + ) - say(f" gen {generation}/{spec.algorithm.max_generations}: " - + _narrate(generation, spec, best, in_range, n_failed, n_rejected)) + say( + f" gen {generation}/{spec.algorithm.max_generations}: " + + _narrate(generation, spec, best, in_range, n_failed, n_rejected) + ) if stop_reason: break @@ -428,7 +498,14 @@ def say(message: str) -> None: command = ledger.read_control() if command: control_ack, stop_reason, paused = _apply_control( - command, optimizer, say, stop_reason, paused) + command, + optimizer, + say, + stop_reason, + paused, + workflow=workflow, + spec=spec, + ) if stop_reason: break if stop_reason: @@ -444,40 +521,49 @@ def say(message: str) -> None: # happens before the loop decides to stop, and the budget-exhausted case is # decided after the loop entirely — without this, status.json would sit at # "running" forever. - ledger.write_status({ - "state": "done", - "updated_at": datetime.now().isoformat(timespec="seconds"), - "generation": generation, - "max_generations": spec.algorithm.max_generations, - "n_evals": len(trials), - "n_ok": len(scored), - "n_failed": sum(1 for t in trials if t["status"] == "failed"), - "n_rejected": sum(1 for t in trials if t["status"] == "rejected"), - "best": best, - "pareto_front": front, - "progress": { - "best_target_ranges_off_by_gen": best_by_generation, - "gens_since_improvement": _gens_since_improvement(best_by_generation), - }, - "control_ack": control_ack, - "stop_reason": stop_reason, - "message": f"finished after {len(trials)} evaluations: {stop_reason}", - }) + ledger.write_status( + { + "state": "done", + "updated_at": datetime.now().isoformat(timespec="seconds"), + "generation": generation, + "max_generations": spec.algorithm.max_generations, + "n_evals": len(trials), + "n_ok": len(scored), + "n_failed": sum(1 for t in trials if t["status"] == "failed"), + "n_rejected": sum(1 for t in trials if t["status"] == "rejected"), + "best": best, + "pareto_front": front, + "progress": { + "best_target_ranges_off_by_gen": best_by_generation, + "gens_since_improvement": _gens_since_improvement(best_by_generation), + }, + "control_ack": control_ack, + "stop_reason": stop_reason, + "message": f"finished after {len(trials)} evaluations: {stop_reason}", + } + ) say(f"[{run_id}] stopped: {stop_reason}") if best: for objective, distance in zip(spec.objectives, best["fitness"]): unit = f" {objective.unit}" if objective.unit else "" - band = (f"target {objective.low}-{objective.high}{unit}" - if objective.goal == "in_range" else objective.goal) + band = ( + f"target {objective.low}-{objective.high}{unit}" + if objective.goal == "in_range" + else objective.goal + ) state = "in target" if distance == 0.0 else f"off {distance:.4g}{unit}" - say(f" {objective.name} = {best['measured'][objective.name]:.4g}{unit}" - f" ({band}, {state})") + say( + f" {objective.name} = {best['measured'][objective.name]:.4g}{unit}" + f" ({band}, {state})" + ) if len(spec.objectives) > 1: furthest = worst_objective(spec, best["fitness"]) if furthest and furthest[1] > 0: - say(f" furthest from target: {furthest[0]}, " - f"{furthest[1]:.3g}x its target range") + say( + f" furthest from target: {furthest[0]}, " + f"{furthest[1]:.3g}x its target range" + ) return OptimizationResult( run_id=run_id, @@ -490,9 +576,17 @@ def say(message: str) -> None: ) -def _evaluate(workflow, spec, candidate, reject_fn, - trial_no: int, generation: int, index: int, - trial_dir: Optional[str] = None) -> Dict[str, Any]: +def _evaluate( + workflow, + spec, + candidate, + reject_fn, + trial_no: int, + generation: int, + index: int, + trial_dir: Optional[str] = None, + source: str = "ask", +) -> Dict[str, Any]: """Run one candidate and produce its ledger row.""" started = time.time() row: Dict[str, Any] = { @@ -500,7 +594,7 @@ def _evaluate(workflow, spec, candidate, reject_fn, "generation": generation, "candidate": index, "started_at": datetime.now().isoformat(timespec="seconds"), - "source": "ask", + "source": source, "params": dict(candidate), "results_path": trial_dir, "measured": {}, @@ -514,6 +608,8 @@ def _evaluate(workflow, spec, candidate, reject_fn, for address, value in candidate.items(): set_parameter(workflow, address, value) + clear_output_ports(workflow) + if not workflow.execute(): row.update(status="failed", error="workflow.execute() returned False") return _finish(row, started) @@ -521,9 +617,11 @@ def _evaluate(workflow, spec, candidate, reject_fn, measured = {} for objective in spec.objectives: value = read_output(workflow, objective.measures) - if not isinstance(value, (int, float)) or isinstance(value, bool): - row.update(status="failed", - error=f"{objective.measures} is not numeric: {value!r}") + if not _is_number(value): + row.update( + status="failed", + error=f"{objective.measures} is not numeric: {value!r}", + ) return _finish(row, started) measured[objective.name] = float(value) row["measured"] = measured @@ -534,8 +632,9 @@ def _evaluate(workflow, spec, candidate, reject_fn, row.update(status="rejected", reject_reason=reason) return _finish(row, started) - row["fitness"] = [objective_fitness(o, measured[o.name]) - for o in spec.objectives] + row["fitness"] = [ + objective_fitness(o, measured[o.name]) for o in spec.objectives + ] except Exception as exc: # a bad candidate must not kill the run row.update(status="failed", error=f"{type(exc).__name__}: {exc}") @@ -552,7 +651,20 @@ def _finish(row: Dict[str, Any], started: float) -> Dict[str, Any]: return row -def _apply_control(command, optimizer, say, stop_reason: str, paused: bool): +def _complete_candidate(workflow, spec, params: Dict[str, Any]) -> Dict[str, float]: + """Fill missing dimension keys from the workflow's current parameter values.""" + complete: Dict[str, float] = {} + for dimension in spec.dimensions: + if dimension.address in params: + complete[dimension.address] = params[dimension.address] + else: + complete[dimension.address] = get_parameter(workflow, dimension.address) + return complete + + +def _apply_control( + command, optimizer, say, stop_reason: str, paused: bool, workflow=None, spec=None +): """Apply a control command and build the acknowledgement for status.json.""" name = command.get("command", "") args = command.get("args", {}) or {} @@ -567,14 +679,25 @@ def _apply_control(command, optimizer, say, stop_reason: str, paused: bool): paused, result = False, "resumed" elif name == "inject": accepted = 0 + errors = [] for params in args.get("candidates", []): try: - optimizer.enqueue(params) + complete = ( + _complete_candidate(workflow, spec, params) + if workflow is not None and spec is not None + else dict(params) + ) + optimizer.enqueue(complete) accepted += 1 except NotImplementedError: result = f"{type(optimizer).__name__} cannot inject candidates" break - result = result or f"{accepted} candidate(s) injected" + except Exception as exc: + errors.append(f"{type(exc).__name__}: {exc}") + if not result: + result = f"{accepted} candidate(s) injected" + if errors: + result += f" ({len(errors)} rejected: {errors[0]})" else: result = f"unknown command {name!r}" @@ -614,8 +737,12 @@ def _narrate_trial(spec, row, generation, index, pop_size, is_best) -> str: label = f"gen {generation}, trial {index + 1}/{pop_size} (#{row['trial']})" tried = " ".join( - f"{d.address}={row['params'][d.address]:.4g}" - f"{' ' + d.unit if d.unit else ''}" + ( + f"{d.address}={row['params'][d.address]:.4g}" + f"{' ' + d.unit if d.unit else ''}" + if d.address in row["params"] + else f"{d.address}=?" + ) for d in spec.dimensions ) @@ -629,8 +756,10 @@ def _narrate_trial(spec, row, generation, index, pop_size, is_best) -> str: for objective, distance in zip(spec.objectives, row["fitness"]): unit = f" {objective.unit}" if objective.unit else "" state = "in target" if distance == 0.0 else f"off {distance:.4g}{unit}" - got.append(f"{objective.name.split('.')[-1]}=" - f"{row['measured'][objective.name]:.4g}{unit} ({state})") + got.append( + f"{objective.name.split('.')[-1]}=" + f"{row['measured'][objective.name]:.4g}{unit} ({state})" + ) # With one objective the miss above says everything. With several, name the one # doing worst and size its miss against its own target range, the only way to @@ -639,8 +768,10 @@ def _narrate_trial(spec, row, generation, index, pop_size, is_best) -> str: if len(spec.objectives) > 1: furthest = worst_objective(spec, row["fitness"]) if furthest and furthest[1] > 0: - worst = (f"\n furthest from target: {furthest[0]}, " - f"{furthest[1]:.3g}x its target range") + worst = ( + f"\n furthest from target: {furthest[0]}, " + f"{furthest[1]:.3g}x its target range" + ) elif furthest: worst = "\n every target met" @@ -671,8 +802,11 @@ def _narrate(generation, spec, best, in_range, n_failed, n_rejected) -> str: parts = [] for objective, distance in zip(spec.objectives, best["fitness"]): unit = f" {objective.unit}" if objective.unit else "" - goal = (f"target {objective.low}-{objective.high}{unit}" - if objective.goal == "in_range" else objective.goal) + goal = ( + f"target {objective.low}-{objective.high}{unit}" + if objective.goal == "in_range" + else objective.goal + ) state = "in target" if distance == 0.0 else f"off {distance:.4g}{unit}" parts.append( f"{objective.name.split('.')[-1]}=" @@ -685,8 +819,14 @@ def _narrate(generation, spec, best, in_range, n_failed, n_rejected) -> str: # "its" on purpose: this line is about the best trial, and the objective named # is the weakest one inside that trial — not a comparison against other trials. furthest = worst_objective(spec, best["fitness"]) - state = (f" — its furthest objective from target: {furthest[0]}, " - f"{furthest[1]:.3g}x its target range") if furthest else "" + state = ( + ( + f" — its furthest objective from target: {furthest[0]}, " + f"{furthest[1]:.3g}x its target range" + ) + if furthest + else "" + ) else: state = "" extra = "" diff --git a/src/neuroworkflow/optimization/ledger.py b/src/neuroworkflow/optimization/ledger.py index 9148830f..06e25ba3 100644 --- a/src/neuroworkflow/optimization/ledger.py +++ b/src/neuroworkflow/optimization/ledger.py @@ -54,16 +54,21 @@ def write_manifest(self, spec, extra: Optional[Dict[str, Any]] = None) -> None: def append_trial(self, trial: Dict[str, Any]) -> None: with open(self.trials_path, "a") as fh: - fh.write(json.dumps({"schema_version": SCHEMA_VERSION, **trial}, - default=str) + "\n") + fh.write( + json.dumps({"schema_version": SCHEMA_VERSION, **trial}, default=str) + + "\n" + ) fh.flush() def write_status(self, status: Dict[str, Any]) -> None: - _write_atomic(self.status_path, { - "schema_version": SCHEMA_VERSION, - "run_id": self.run_id, - **status, - }) + _write_atomic( + self.status_path, + { + "schema_version": SCHEMA_VERSION, + "run_id": self.run_id, + **status, + }, + ) # -- reads ----------------------------------------------------------- def read_trials(self) -> List[Dict[str, Any]]: diff --git a/src/neuroworkflow/optimization/optimizers.py b/src/neuroworkflow/optimization/optimizers.py index b81649b3..1db97b26 100644 --- a/src/neuroworkflow/optimization/optimizers.py +++ b/src/neuroworkflow/optimization/optimizers.py @@ -28,8 +28,12 @@ class Optimizer(ABC): #: Can this backend handle more than one objective at a time? supports_multi_objective: bool = False - def __init__(self, dimensions: Sequence[Dimension], n_objectives: int, - config: AlgorithmConfig): + def __init__( + self, + dimensions: Sequence[Dimension], + n_objectives: int, + config: AlgorithmConfig, + ): if n_objectives > 1 and not self.supports_multi_objective: raise ValueError( f"{type(self).__name__} is single-objective but the spec declares " @@ -40,14 +44,16 @@ def __init__(self, dimensions: Sequence[Dimension], n_objectives: int, self.dimensions = list(dimensions) self.n_objectives = n_objectives self.config = config + self.last_ask_sources: List[str] = [] @abstractmethod def ask(self) -> List[Dict[str, float]]: """Propose the next generation as a list of {address: value} dicts.""" @abstractmethod - def tell(self, candidates: List[Dict[str, float]], - fitnesses: List[List[float]]) -> None: + def tell( + self, candidates: List[Dict[str, float]], fitnesses: List[List[float]] + ) -> None: """Report the measured fitness of each candidate from the last ``ask``.""" def enqueue(self, params: Dict[str, float]) -> None: @@ -76,8 +82,9 @@ def available() -> List[str]: return sorted(_REGISTRY) -def create_optimizer(dimensions: Sequence[Dimension], n_objectives: int, - config: AlgorithmConfig) -> Optimizer: +def create_optimizer( + dimensions: Sequence[Dimension], n_objectives: int, config: AlgorithmConfig +) -> Optimizer: if config.name not in _REGISTRY: raise ValueError( f"Unknown algorithm {config.name!r}. Available: {', '.join(available())}" @@ -89,6 +96,7 @@ def create_optimizer(dimensions: Sequence[Dimension], n_objectives: int, # RandomSearch — no dependencies, so the engine is always runnable # --------------------------------------------------------------------------- + class RandomSearch(Optimizer): """Uniform sampling inside the bounds. A baseline, and the smoke test.""" @@ -101,11 +109,16 @@ def __init__(self, dimensions, n_objectives, config): def ask(self) -> List[Dict[str, float]]: out: List[Dict[str, float]] = [] + sources: List[str] = [] while self._queued and len(out) < self.config.pop_size: out.append(self._queued.pop(0)) + sources.append("inject") while len(out) < self.config.pop_size: - out.append({d.address: self._rng.uniform(d.low, d.high) - for d in self.dimensions}) + out.append( + {d.address: self._rng.uniform(d.low, d.high) for d in self.dimensions} + ) + sources.append("ask") + self.last_ask_sources = sources return out def tell(self, candidates, fitnesses) -> None: @@ -132,6 +145,28 @@ def enqueue(self, params: Dict[str, float]) -> None: } +def sampler_init_kwargs( + sampler_name: str, + config: AlgorithmConfig, + sampler_kwargs: Optional[Dict[str, Any]] = None, +) -> Dict[str, Any]: + """Keyword arguments passed to the Optuna sampler constructor. + + NSGA-II/III take ``population_size``; CMA-ES takes ``popsize``. Passing the + wrong name is silently ignored, so CMA-ES would otherwise run at Optuna's + default population (~4+3*ln(n)) and throw away the rest of each generation. + """ + kwargs = dict(sampler_kwargs or {}) + kwargs.update(config.options) + if config.seed is not None: + kwargs.setdefault("seed", config.seed) + if sampler_name.startswith("NSGA"): + kwargs.setdefault("population_size", config.pop_size) + elif sampler_name == "CmaEsSampler": + kwargs.setdefault("popsize", config.pop_size) + return kwargs + + class OptunaOptimizer(Optimizer): """Adapter over Optuna's ask/tell API. @@ -140,8 +175,15 @@ class OptunaOptimizer(Optimizer): generations internally, so this stays correct for them too. """ - def __init__(self, dimensions, n_objectives, config, sampler_name: str, - multi_objective: bool, sampler_kwargs: Dict[str, Any]): + def __init__( + self, + dimensions, + n_objectives, + config, + sampler_name: str, + multi_objective: bool, + sampler_kwargs: Dict[str, Any], + ): self.supports_multi_objective = multi_objective super().__init__(dimensions, n_objectives, config) @@ -151,7 +193,7 @@ def __init__(self, dimensions, n_objectives, config, sampler_name: str, except ImportError as exc: # pragma: no cover - depends on environment raise ImportError( f"The {config.name!r} algorithm needs Optuna. " - f"Install it with: pip install optuna cmaes" + f'Install it with: pip install -e ".[optimization]"' ) from exc optuna.logging.set_verbosity(optuna.logging.WARNING) @@ -163,12 +205,7 @@ def __init__(self, dimensions, n_objectives, config, sampler_name: str, f"(needed for algorithm {config.name!r})" ) - kwargs = dict(sampler_kwargs) - kwargs.update(config.options) - if config.seed is not None: - kwargs.setdefault("seed", config.seed) - if sampler_name.startswith("NSGA"): - kwargs.setdefault("population_size", config.pop_size) + kwargs = sampler_init_kwargs(sampler_name, config, sampler_kwargs) self._optuna = optuna self._distributions = { @@ -179,10 +216,20 @@ def __init__(self, dimensions, n_objectives, config, sampler_name: str, sampler=sampler_cls(**kwargs), ) self._pending: List[Any] = [] + self._inject_remaining = 0 def ask(self) -> List[Dict[str, float]]: - self._pending = [self._study.ask(self._distributions) - for _ in range(self.config.pop_size)] + self._pending = [ + self._study.ask(self._distributions) for _ in range(self.config.pop_size) + ] + sources = [] + for _ in self._pending: + if self._inject_remaining > 0: + sources.append("inject") + self._inject_remaining -= 1 + else: + sources.append("ask") + self.last_ask_sources = sources return [dict(t.params) for t in self._pending] def tell(self, candidates, fitnesses) -> None: @@ -195,12 +242,15 @@ def tell(self, candidates, fitnesses) -> None: def enqueue(self, params: Dict[str, float]) -> None: self._study.enqueue_trial(dict(params), skip_if_exists=False) + self._inject_remaining += 1 def _make_optuna_factory(sampler_name: str, multi: bool, kwargs: Dict[str, Any]): def factory(dimensions, n_objectives, config): - return OptunaOptimizer(dimensions, n_objectives, config, - sampler_name, multi, kwargs) + return OptunaOptimizer( + dimensions, n_objectives, config, sampler_name, multi, kwargs + ) + return factory diff --git a/src/neuroworkflow/optimization/spec.py b/src/neuroworkflow/optimization/spec.py index 4ca54860..4e124bb1 100644 --- a/src/neuroworkflow/optimization/spec.py +++ b/src/neuroworkflow/optimization/spec.py @@ -6,7 +6,7 @@ the algorithm, widen a range or retarget a band without touching code. """ -from dataclasses import dataclass, field, asdict +from dataclasses import asdict, dataclass, field from typing import Any, Dict, List, Optional from neuroworkflow.core.schema import ParameterDefinition @@ -18,24 +18,24 @@ class Dimension: """One axis of the search space.""" - address: str # "Model.nest_params.C_m" + address: str # "Model.nest_params.C_m" low: float high: float unit: str = "" description: str = "" - source: str = "" # where the range came from - note: str = "" # e.g. why it was clipped + source: str = "" # where the range came from + note: str = "" # e.g. why it was clipped @dataclass class Objective: """One target the search is steering toward.""" - name: str # "Population_exc.target_rate_hz" - measures: str # "Analysis.firing_rate_hz.exc" + name: str # "Population_exc.target_rate_hz" + measures: str # "Analysis.firing_rate_hz.exc" low: Optional[float] = None # target band, for goal="in_range" high: Optional[float] = None - goal: str = "in_range" # in_range | minimize | maximize + goal: str = "in_range" # in_range | minimize | maximize unit: str = "" description: str = "" source: str = "" @@ -45,7 +45,7 @@ class Objective: class AlgorithmConfig: """Which optimizer to run and how. Editable by a human or an agent.""" - name: str = "random" # see optimizers.available() + name: str = "random" # see optimizers.available() pop_size: int = 16 max_generations: int = 20 seed: Optional[int] = None @@ -102,10 +102,16 @@ def validate(self) -> None: f"(set objective_range on the parameter)" ) - def add_objective(self, name: str, measures: str, - low: Optional[float] = None, high: Optional[float] = None, - goal: str = "in_range", unit: str = "", - description: str = "") -> "OptimizationSpec": + def add_objective( + self, + name: str, + measures: str, + low: Optional[float] = None, + high: Optional[float] = None, + goal: str = "in_range", + unit: str = "", + description: str = "", + ) -> "OptimizationSpec": """Declare a target that no node parameter carries. An objective is a label, a measurement address and a band — nothing about it @@ -134,10 +140,18 @@ def add_objective(self, name: str, measures: str, f"On {node!r}: {', '.join(near)}" ) - self.objectives.append(Objective( - name=name, measures=measures, low=low, high=high, - goal=goal, unit=unit, description=description, source="study", - )) + self.objectives.append( + Objective( + name=name, + measures=measures, + low=low, + high=high, + goal=goal, + unit=unit, + description=description, + source="study", + ) + ) return self def summary(self) -> str: @@ -153,9 +167,7 @@ def summary(self) -> str: lines.append(f" {d.address:<40} [{d.low}, {d.high}]{unit}{note}") lines.append(f"objectives: {len(self.objectives)}") for o in self.objectives: - band = ( - f"in [{o.low}, {o.high}]" if o.goal == "in_range" else o.goal - ) + band = f"in [{o.low}, {o.high}]" if o.goal == "in_range" else o.goal unit = f" {o.unit}" if o.unit else "" lines.append(f" {o.name:<40} {band}{unit} <- {o.measures}") if self.skipped: @@ -169,6 +181,7 @@ def summary(self) -> str: # Building a spec from the node schemas # --------------------------------------------------------------------------- + def _numeric_pair(value: Any) -> Optional[List[float]]: if isinstance(value, (list, tuple)) and len(value) == 2: if all(isinstance(v, (int, float)) and not isinstance(v, bool) for v in value): @@ -209,31 +222,42 @@ def collect_dimensions(workflow) -> tuple: key_address = f"{address}.{key}" rng = _numeric_pair(pair) if rng is None: - skipped.append({ - "address": key_address, - "reason": f"range is not [min, max]: {pair}", - }) + skipped.append( + { + "address": key_address, + "reason": f"range is not [min, max]: {pair}", + } + ) continue if isinstance(value, dict) and key not in value: - skipped.append({ - "address": key_address, - "reason": "key is not present in the parameter's " - "current value — configure() it first", - }) + skipped.append( + { + "address": key_address, + "reason": "key is not present in the parameter's " + "current value — configure() it first", + } + ) continue - dimensions.append(Dimension( - address=key_address, low=rng[0], high=rng[1], - unit=pdef.unit, description=pdef.description, - source="schema.optimization_range", - )) + dimensions.append( + Dimension( + address=key_address, + low=rng[0], + high=rng[1], + unit=pdef.unit, + description=pdef.description, + source="schema.optimization_range", + ) + ) continue if isinstance(value, dict): - skipped.append({ - "address": address, - "reason": "dict parameter with no per-key optimization_range — " - 'declare one, e.g. {"V_th": [-60.0, -45.0]}', - }) + skipped.append( + { + "address": address, + "reason": "dict parameter with no per-key optimization_range — " + 'declare one, e.g. {"V_th": [-60.0, -45.0]}', + } + ) continue c_min = pdef.constraints.get("min") @@ -245,11 +269,13 @@ def collect_dimensions(workflow) -> tuple: if isinstance(c_min, (int, float)) and isinstance(c_max, (int, float)): rng, source = [float(c_min), float(c_max)], "schema.constraints" else: - skipped.append({ - "address": address, - "reason": "optimizable but no optimization_range and no " - "min/max constraints to fall back on", - }) + skipped.append( + { + "address": address, + "reason": "optimizable but no optimization_range and no " + "min/max constraints to fall back on", + } + ) continue # Constraints are the authority: a range reaching past them describes @@ -266,17 +292,25 @@ def collect_dimensions(workflow) -> tuple: source, note = "clipped", "; ".join(clipped) + " (constraints)" if low >= high: - skipped.append({ - "address": address, - "reason": f"empty range after clipping to constraints: [{low}, {high}]", - }) + skipped.append( + { + "address": address, + "reason": f"empty range after clipping to constraints: [{low}, {high}]", + } + ) continue - dimensions.append(Dimension( - address=address, low=low, high=high, - unit=pdef.unit, description=pdef.description, - source=source, note=note, - )) + dimensions.append( + Dimension( + address=address, + low=low, + high=high, + unit=pdef.unit, + description=pdef.description, + source=source, + note=note, + ) + ) return dimensions, skipped @@ -302,50 +336,64 @@ def collect_objectives(workflow, measurables: Dict[str, float]) -> tuple: name = f"{node_name}.{pname}" if not pdef.measures: - skipped.append({ - "address": name, - "reason": "is_objective=True but no measures address — set it to " - "the output that holds the measured value", - }) + skipped.append( + { + "address": name, + "reason": "is_objective=True but no measures address — set it to " + "the output that holds the measured value", + } + ) continue if pdef.measures not in measurables: - near = [m for m in measurables if m.startswith(pdef.measures.split(".")[0])] - skipped.append({ - "address": name, - "reason": f"measures {pdef.measures!r} did not resolve to a number " - f"in the baseline run" - + (f" (available on that node: {', '.join(sorted(near)[:6])})" - if near else ""), - }) + near = [ + m for m in measurables if m.startswith(pdef.measures.split(".")[0]) + ] + skipped.append( + { + "address": name, + "reason": f"measures {pdef.measures!r} did not resolve to a number " + f"in the baseline run" + + ( + f" (available on that node: {', '.join(sorted(near)[:6])})" + if near + else "" + ), + } + ) continue band = _numeric_pair(pdef.objective_range) if band is None: - skipped.append({ - "address": name, - "reason": "is_objective=True but objective_range is not [min, max]", - }) + skipped.append( + { + "address": name, + "reason": "is_objective=True but objective_range is not [min, max]", + } + ) continue # The schema can only express a target band. minimize/maximize are set # by editing the spec, which is also where an agent would change them. - objectives.append(Objective( - name=name, - measures=pdef.measures, - low=band[0], - high=band[1], - goal="in_range", - unit=pdef.unit, - description=pdef.description, - source="schema.objective_range", - )) + objectives.append( + Objective( + name=name, + measures=pdef.measures, + low=band[0], + high=band[1], + goal="in_range", + unit=pdef.unit, + description=pdef.description, + source="schema.objective_range", + ) + ) return objectives, skipped -def build_spec(workflow, algorithm: Optional[AlgorithmConfig] = None, - run_baseline: bool = True) -> OptimizationSpec: +def build_spec( + workflow, algorithm: Optional[AlgorithmConfig] = None, run_baseline: bool = True +) -> OptimizationSpec: """Introspect a built workflow and produce a spec ready for review. With ``run_baseline=True`` the workflow is executed once at its current @@ -373,10 +421,10 @@ def build_spec(workflow, algorithm: Optional[AlgorithmConfig] = None, objectives, skipped_objs = collect_objectives(workflow, measurables) if baseline: - baseline["params"] = {d.address: _read_param(workflow, d.address) - for d in dimensions} - baseline["measured"] = {o.name: measurables.get(o.measures) - for o in objectives} + baseline["params"] = { + d.address: _read_param(workflow, d.address) for d in dimensions + } + baseline["measured"] = {o.name: measurables.get(o.measures) for o in objectives} return OptimizationSpec( dimensions=dimensions, @@ -389,6 +437,7 @@ def build_spec(workflow, algorithm: Optional[AlgorithmConfig] = None, def _read_param(workflow, address: str) -> Any: from .addressing import split_address + node_name, param, keys = split_address(address) value = workflow.nodes[node_name]._parameters[param] for k in keys: diff --git a/tests/test_optimization_engine.py b/tests/test_optimization_engine.py new file mode 100644 index 00000000..bf3e2f96 --- /dev/null +++ b/tests/test_optimization_engine.py @@ -0,0 +1,230 @@ +"""Toy-node tests for the outer-loop optimization engine (no NEST).""" + +import functools +import math +import sys +import types + +import pytest + +from neuroworkflow.core.node import Node +from neuroworkflow.core.port import PortType +from neuroworkflow.core.schema import ( + MethodDefinition, + NodeDefinitionSchema, + ParameterDefinition, + PortDefinition, +) +from neuroworkflow.core.workflow import Workflow +from neuroworkflow.nodes.network.NW_Connectivity import NW_Connectivity +from neuroworkflow.optimization.addressing import _is_number +from neuroworkflow.optimization.engine import ( + _apply_control, + _evaluate, + objective_fitness, + optimize, +) +from neuroworkflow.optimization.optimizers import RandomSearch, sampler_init_kwargs +from neuroworkflow.optimization.spec import ( + AlgorithmConfig, + Dimension, + Objective, + OptimizationSpec, +) + + +class Probe(Node): + """Scalar probe: output y = 2 * x (or NaN / skip, for failure cases).""" + + NODE_DEFINITION = NodeDefinitionSchema( + type="probe", + description="Toy probe for optimization engine tests", + parameters={ + "x": ParameterDefinition( + default_value=1.0, + optimizable=True, + optimization_range=[0.0, 10.0], + ), + "z": ParameterDefinition( + default_value=4.0, + optimizable=True, + optimization_range=[0.0, 10.0], + ), + }, + outputs={ + "y": PortDefinition(type=PortType.FLOAT, description="2x"), + }, + methods={ + "run": MethodDefinition(description="emit y", outputs=["y"]), + }, + ) + + def __init__(self, name: str): + super().__init__(name) + self.add_process_step("run", self.run, outputs=["y"]) + self.skip_emit = False + self.emit_nan = False + + def run(self): + if self.skip_emit: + return {} + value = float(self._parameters["x"]) * 2.0 + if self.emit_nan: + value = float("nan") + return {"y": value} + + +def _spec(): + return OptimizationSpec( + dimensions=[ + Dimension(address="Probe.x", low=0.0, high=10.0), + Dimension(address="Probe.z", low=0.0, high=10.0), + ], + objectives=[ + Objective( + name="y", + measures="Probe.y", + low=0.0, + high=20.0, + goal="in_range", + ) + ], + algorithm=AlgorithmConfig(name="random", pop_size=2, max_generations=2, seed=0), + ) + + +def _workflow(): + probe = Probe("Probe") + return Workflow("toy", {"Probe": probe}, []), probe + + +def test_random_optimize_round_trip(tmp_path): + workflow, _ = _workflow() + result = optimize( + workflow, + spec=_spec(), + results_path=str(tmp_path), + per_trial_results=False, + stop_when_reached=False, + verbose=False, + run_id="roundtrip", + ) + assert result.stop_reason + assert len(result.trials) == 4 + assert all(t["status"] == "ok" for t in result.trials) + assert result.best is not None + + +def test_nan_measurement_is_failed_trial(): + workflow, probe = _workflow() + probe.emit_nan = True + row = _evaluate(workflow, _spec(), {"Probe.x": 1.0, "Probe.z": 4.0}, None, 1, 1, 0) + assert row["status"] == "failed" + assert row["fitness"] is None + with pytest.raises(ValueError, match="non-finite"): + objective_fitness(_spec().objectives[0], float("nan")) + + +def test_partial_inject_completes_dims_and_continues(): + workflow, probe = _workflow() + spec = _spec() + optimizer = RandomSearch(spec.dimensions, 1, spec.algorithm) + probe.configure(x=1.0, z=4.0) + + ack, stop, paused = _apply_control( + { + "command": "inject", + "seq": 1, + "args": {"candidates": [{"Probe.x": 3.0}]}, + }, + optimizer, + lambda _m: None, + "", + False, + workflow=workflow, + spec=spec, + ) + assert stop == "" + assert "injected" in ack["result"] + + candidates = optimizer.ask() + assert optimizer.last_ask_sources[0] == "inject" + assert candidates[0]["Probe.x"] == 3.0 + assert candidates[0]["Probe.z"] == 4.0 + + row = _evaluate(workflow, spec, candidates[0], None, 1, 1, 0, source="inject") + assert row["source"] == "inject" + assert row["status"] == "ok" + assert row["params"]["Probe.z"] == 4.0 + + +def test_stale_output_does_not_leak_between_trials(): + workflow, probe = _workflow() + spec = _spec() + first = _evaluate(workflow, spec, {"Probe.x": 2.0, "Probe.z": 4.0}, None, 1, 1, 0) + assert first["status"] == "ok" + assert first["measured"]["y"] == 4.0 + + probe.skip_emit = True + second = _evaluate(workflow, spec, {"Probe.x": 5.0, "Probe.z": 4.0}, None, 2, 1, 1) + assert second["status"] == "failed" + assert second["measured"] == {} + assert "not numeric" in (second["error"] or "") + + +def test_is_number_numpy_bool_nan(): + assert _is_number(1) is True + assert _is_number(1.5) is True + assert _is_number(True) is False + assert _is_number(float("nan")) is False + numpy = pytest.importorskip("numpy") + assert _is_number(numpy.float32(1.25)) is True + assert _is_number(numpy.int64(3)) is True + assert _is_number(numpy.array([1.0, 2.0])) is False + + +def _import_simconfig(): + if "pandas" not in sys.modules: + fake = types.ModuleType("pandas") + fake.set_option = lambda *args, **kwargs: None + sys.modules["pandas"] = fake + from neuroworkflow.nodes.simulation.NW_SimConfig import NW_SimConfig + + return NW_SimConfig + + +def test_stable_partial_does_not_raise(): + NW_SimConfig = _import_simconfig() + + def times(n, x): + return n * x + + wrapped = functools.partial(times, 2) + assert NW_SimConfig._stable(wrapped) + + +def test_instance_node_definition_is_isolated(): + a = Probe("a") + b = Probe("b") + a.NODE_DEFINITION.parameters["x"].optimizable = False + assert b.NODE_DEFINITION.parameters["x"].optimizable is True + assert Probe.NODE_DEFINITION.parameters["x"].optimizable is True + + +def test_cmaes_sampler_kwargs_include_popsize(): + config = AlgorithmConfig(name="cmaes", pop_size=16, seed=1) + cma = sampler_init_kwargs("CmaEsSampler", config) + assert cma["popsize"] == 16 + nsga = sampler_init_kwargs("NSGAIISampler", config) + assert nsga["population_size"] == 16 + assert "popsize" not in nsga + + +def test_connection_rule_lambda_only(): + fn = NW_Connectivity._coerce_connection_rule("lambda src, tgt: 1") + assert fn(0, 1) == 1 + assert NW_Connectivity._coerce_connection_rule(3) == 3 + with pytest.raises(ValueError, match="lambda"): + NW_Connectivity._coerce_connection_rule("__import__('os').system('x')") + with pytest.raises(ValueError, match="lambda"): + NW_Connectivity._coerce_connection_rule("src + tgt") From 8859ab332c1c780c7add055716bb2433a4b97106 Mon Sep 17 00:00:00 2001 From: nw-kirill Date: Wed, 9 Sep 2026 22:12:03 +0900 Subject: [PATCH 8/8] Record PR #95 optimization audit close-out --- .../pr95-optimization-audit-progress.log | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/deployment/pr95-optimization-audit-progress.log b/deployment/pr95-optimization-audit-progress.log index 15426f62..51c2d73b 100644 --- a/deployment/pr95-optimization-audit-progress.log +++ b/deployment/pr95-optimization-audit-progress.log @@ -172,3 +172,33 @@ Live https://neuro-workflow.dbrain.jp/: No test failures to fix (Probe NODE_DEFINITION.description added during this pass). ================================================================================ + +## Step 7 — Commit, push, PR comment, close-out + +Done. No merge, no deploy, no force-push. + +Commit: 1f9ab635 Harden the outer-loop optimization engine for first-use correctness +Pushed: origin/feat/schema-improvements (54614ba1..1f9ab635) +PR: still https://github.com/oist/neuro-workflow/pull/95 +Comment: https://github.com/oist/neuro-workflow/pull/95#issuecomment-5602412542 + (kirillmitrofanov; study-home question for Carlos) + +Verify commands +--------------- + PYTHONPATH=src python -m pytest tests/test_optimization_engine.py -q + → 9 passed + black --check --line-length 88 src/neuroworkflow/optimization tests/test_optimization_engine.py + isort --check --profile black (same paths) + +Live dbrain.jp: old bundle; palette search "Optimization" does not list NW_Optimization +(only older nodes whose descriptions mention optimization metadata). + +Remaining risk +-------------- +- Not deployed; GUI generate-code still does not emit optimize(). +- Nest kernel image still lacks optuna/cmaes; default is now random. +- Study home unset until Carlos answers; do not merge until then. +- Merge with #92 will need a hand merge on schema.py / node.py. +- JointOptimizationNode remains deleted; saved flows that used it will not find it. + +================================================================================