Neuroblox API

create_adjacency_edges!(g::MetaDiGraph, adj_matrix::Matrix{T}; 
                        kwargs...)

Given an adjacency matrix, populate the graph g with the edges whose weights are stored in the adjacency matrix. Any additional keyword arguments in kwargs... will be forwarded to add_connection!

get_exci_neurons(n::Union{GraphSystem, AbstractBlox})

Returns all excitatory neurons within a blox or graph.

• If n <: Union{GraphSystem, AbstractComposite}, returns all excitatory neurons within the graph or composite blox.
• If n::AbstractExciNeuron, returns a single-element vector [n].

get_inh_neurons(n::Union{GraphSystem, AbstractBlox})

Returns all inhibitory neurons within a blox or graph.

• If n <: Union{GraphSystem, AbstractComposite}, returns all excitatory neurons within the graph or composite blox.
• If n::AbstractExciNeuron, returns a single-element vector [n].

nameof(blox)

Returns the name of blox without the namespace prefix.

See also namespaced_nameof and full_namespaced_nameof.

namespaced_nameof(blox)

Returns the name of the blox, prefaced by its entire inner namespace (all levels of the namespace EXCEPT for the highest level). Namespaces represent the parent composite blox or graph that blox belongs to. E.g. the name cort1.wta2.neuron4 comes from a neuron neuron4 which belongs to wta2 (possibly a WinnerTakeAll blox) which in turn is part of cort1 (possibly a Cortical blox).

See also nameof and full_namespaced_nameof.

full_namespaced_nameof(blox)

Return the name of the blox, prefaced by its entire inner namespace (all levels of the namespace INCLUDING for the highest level). Namespaces represent the parent composite blox or graph that blox belongs to. E.g. the name mdl.cort1.wta2.neuron4 comes from a neuron neuron4 which belongs to wta2 (possibly a WinnerTakeAll blox), which in turn is part of cort1 (possibly a Cortical blox), which finally is part of a circuit mdl.

See also nameof and namespaced_nameof.

meanfield(blox::Union{AbstractComposite, Vector{AbstractNeuron}}, sol::AbstractSolution)

Plot the mean-field voltage (in mV) as a function of time (in ms) for a blox.

Arguments:

• blox : a composite blox, e.g. a brain region or microcircuit, containing multiple neurons or a vector of neurons.
• sol : a solution object after running a simulation (i.e. the output of solve)

Note: this function requires Makie to be loaded.

See also meanfield!, meanfield_timeseries.

meanfield!(ax::Axis, blox::Union{AbstractComposite, Vector{AbstractNeuron}}, sol)

Update an existing plot Axis to show the mean-field voltage (in mV) as a function of time (in ms) for a blox.

Arguments:

• ax : an Axis object attached to a Figure from Makie.
• blox : a composite blox, e.g. a brain region or microcircuit, containing multiple neurons or a vector of neurons.
• sol : a solution object after running a simulation (i.e. the output of solve)

Note: this function requires Makie to be loaded.

See also meanfield, meanfield_timeseries.

rasterplot(blox::Union{AbstractComposite, Vector{AbstractNeuron}}, sol::AbstractSolution; threshold = nothing, kwargs...)

Create a scatterplot of spikes, where the x-axis is time (in ms) and the y-axis represents neurons organized in separate rows.

Arguments:

• blox : a composite blox, e.g. a brain region or microcircuit, containing multiple neurons or a vector of neurons.
• sol : a solution object after running a simulation (i.e. the output of solve)

Keyword arguments:

• threshold : [mV] Spiking threshold. Internally used in detect_spikes to calculate all spiking events. Note that neurons like NeurobloxPharma.HHNeuronExci and NeurobloxPharma.HHNeuronInhib do not inherently contain a threshold and so require this threshold argument to be passed in order to determine spiking events.
• kwargs... : All other keyword arguments are passed to Makie to control figure properties.

Note: this function requires Makie to be loaded.

See also rasterplot!, detect_spikes.

rasterplot!(ax::Axis, blox::Union{AbstractComposite, Vector{AbstractNeuron}}, sol::AbstractSolution; threshold = nothing, kwargs...)

Update an existing plot Axis to show a scatterplot of spikes, where the x-axis is time (in ms) and the y-axis represents neurons organized in separate rows.

Arguments:

• ax : an Axis object attached to a Figure from Makie.
• blox : a composite blox, e.g. a brain region or microcircuit, containing multiple neurons or a vector of neurons.
• sol : a solution object after running a simulation (i.e. the output of solve)

Keyword arguments:

• threshold : [mV] Spiking threshold. Internally used in detect_spikes to calculate all spiking events. Note that neurons like NeurobloxPharma.HHNeuronExci and NeurobloxPharma.HHNeuronInhib do not inherently contain a threshold and so require this threshold argument to be passed in order to determine spiking events.
• kwargs... : All other keyword arguments are passed to Makie to control figure properties.

Note: this function requires Makie to be loaded.

See also rasterplot, detect_spikes.

stackplot(blox::Union{AbstractComposite, Vector{AbstractNeuron}}, sol::AbstractSolution)

Plot the voltage timeseries of all neurons contained in blox, stacked on top of each other. The x-axis is time (in ms) and on the y-axis voltage timeseries are plotted on separate rows for each neuron in blox.

Arguments:

• blox : a composite blox, e.g. a brain region or microcircuit, containing multiple neurons or a vector of neurons.
• sol : a solution object after running a simulation (i.e. the output of solve)

Note: this function requires Makie to be loaded.

See also stackplot!.

stackplot!(ax::Axis, blox::Union{AbstractComposite, Vector{AbstractNeuron}}, sol::AbstractSolution)

Update an existing plot Axis to show the voltage timeseries of all neurons contained in blox, stacked on top of each other. The x-axis is time (in ms) and on the y-axis voltage timeseries are plotted on separate rows for each neuron in blox.

Arguments:

• ax : an Axis object attached to a Figure from Makie.
• blox : a composite blox, e.g. a brain region or microcircuit, containing multiple neurons or a vector of neurons.
• sol : a solution object after running a simulation (i.e. the output of solve)

Note: this function requires Makie to be loaded.

See also stackplot.

frplot(blox::Union{AbstractComposite, Vector{AbstractNeuron}}, sol::AbstractSolution; win_size = 10, overlap = 0, transient = 0, threshold = nothing, kwargs...)

Plot the firing rate of blox as a function of time (in s).

Arguments:

• blox : a composite blox, e.g. a brain region or microcircuit, containing multiple neurons or a vector of neurons. If blox contains more than one neurons, then the average firing rate across all neurons is plotted.
• sol : a solution object after running a simulation (i.e. the output of solve)

Keyword arguments:

• win_size : [ms] Sliding window size.
• overlap : in range [0,1]. Overlap between two consecutive sliding windows.
• transient : [ms] Transient period in the beginning of the timeseries that is ignored during firing rate calculation.
• threshold : [mV] Spiking threshold.
• kwargs... : All other keyword arguments are passed to Makie to control figure properties.

win_size, overlap, transient and threshold are internally used in firing_rate to calculate the firing rate timeseries.

Note: this function requires Makie to be loaded.

See also frplot!, firing_rate.

frplot!(ax::Axis, blox::Union{AbstractComposite, Vector{AbstractNeuron}}, sol::AbstractSolution; win_size = 10, overlap = 0, transient = 0, threshold = nothing, kwargs...)

Update an existing plot Axis to show the firing rate of blox as a function of time (in s).

Arguments:

• ax : an Axis object attached to a Figure from Makie.
• blox : a composite blox, e.g. a brain region or microcircuit, containing multiple neurons or a vector of neurons. If blox contains more than one neurons, then the average firing rate across all neurons is plotted.
• sol : a solution object after running a simulation (i.e. the output of solve)

Keyword arguments:

• win_size : [ms] Sliding window size.
• overlap : in range [0,1]. Overlap between two consecutive sliding windows.
• transient : [ms] Transient period in the beginning of the timeseries that is ignored during firing rate calculation.
• threshold : [mV] Spiking threshold.
• kwargs... : All other keyword arguments are passed to Makie to control figure properties.

win_size, overlap, transient and threshold are internally used in firing_rate to calculate the firing rate timeseries.

Note: this function requires Makie to be loaded.

See also frplot, firing_rate.

powerspectrumplot(blox::Union{AbstractComposite, Vector{Union{AbstractNeuron, AbstractNeuralMass}}, sol::AbstractSolution; sampling_rate=nothing, method=periodogram, window=nothing, kwargs...)

Plot the power spectrum (intensity as a function of frequency) of neurons and neural mass objects contained in blox.

Arguments:

• blox : a composite blox, e.g. a brain region or microcircuit, or a vector containing multiple neurons and/or neural masses.
• sol : a solution object after running a simulation (i.e. the output of solve)

Keyword arguments:

• sampling_rate : [Hz] Sampling rate.
• method : Method to calculate the periodogram. Options are [periodogram, welch_pgram]. See the DSP documentation for more information.
• window : An optional window function to be applied to the original signal before computing the Fourier transform. Options are [nothing, hamming, hanning]. See the DSP documentation for more information.
• kwargs... : All other keyword arguments are passed to Makie to control figure properties.

Note: this function requires Makie to be loaded.

See also powerspectrumplot!, powerspectrum.

powerspectrumplot!(ax::Axis, blox::Union{AbstractComposite, Vector{Union{AbstractNeuron, AbstractNeuralMass}}, sol::AbstractSolution; sampling_rate=nothing, method=periodogram, window=nothing, kwargs...)

Update an existing plot Axis to show the power spectrum (intensity as a function of frequency) of neurons and neural mass objects contained in blox.

Arguments:

• ax : an Axis object attached to a Figure from Makie.
• blox : a composite blox, e.g. a brain region or microcircuit, or a vector containing multiple neurons and/or neural masses.
• sol : a solution object after running a simulation (i.e. the output of solve)

Keyword arguments:

• sampling_rate : [Hz] Sampling rate.
• method : Method to calculate the periodogram. Options are [periodogram, welch_pgram]. See the DSP documentation for more information.
• window : An optional window function to be applied to the original signal before computing the Fourier transform. Options are [nothing, hamming, hanning]. See the DSP documentation for more information.
• kwargs... : All other keyword arguments are passed to Makie to control figure properties.

Note: this function requires Makie to be loaded.

See also powerspectrumplot, powerspectrum.

detect_spikes(blox::AbstractNeuron, sol::AbstractSolution;
              threshold=nothing,
              tolerance=1e-3,
              ts=nothing,
              scheduler=:serial)

Find the spike timepoints of blox according to simulation solution sol. Return a SparseVector that is equal to 1 at the timepoints of each spike.

Keyword arguments: - threshold : [mV] Spiking threshold. Note that neurons like NeurobloxPharma.HHNeuronExci and NeurobloxPharma.HHNeuronInhib do not inherently contain a threshold and so require this threshold argument to be passed in order to determine spiking events. - tolerance : [mV] The tolerance around the threshold value in which a maximum counts as a spike. - ts : [ms] Timepoints in simulation solution sol where spikes are detected. It can be a range, a vector or an individual timepoint. If no values are passed (and ts=nothing) then the entire range of the solution sol is used.

firing_rate(blox::Union{AbstractComposite, Vector{AbstractNeuron}}, sol::AbstractSolution;
            transient=0, win_size=last(sol.t) - transient,
            overlap=0, threshold=nothing,
            scheduler=:serial, kwargs...)

Calculates the firing rate of blox. If blox is a composite blox or a vector containing multiple elements, then the average firing rate across all neurons in blox is returned.

Keyword arguments:

• win_size : [ms] Sliding window size.
• overlap : in range [0,1]. Overlap between two consecutive sliding windows.
• transient : [ms] Transient period in the beginning of the timeseries that is ignored during firing rate calculation.
• threshold : [mV] Spiking threshold.

See also frplot.

inter_spike_intervals(blox::AbstractNeuron, sol; threshold, ts)

Return the time intervals between subsequent spikes in the solution of a single neuron.

inter_spike_intervals(blox::AbstractNeuron, sol; threshold, ts)

Return the time intervals between subsequent spikes in the solution of a Blox. Outputs a matrix whose rows are the interspike intervals for a single neuron.

flat_inter_spike_intervals(blox::AbstractNeuron, sol; threshold, ts)

Return the time intervals between subsequent spikes in the solution of a Blox. Concatenates the lists of interspike intervals of all vectors into a single vector.

powerspectrum(cb::Union{AbstractComposite, Vector{AbstractNeuron}}, sol::AbstractSolution; sampling_rate=nothing, method=periodogram, window=nothing)

Calculate the power spectrum of the voltage timeseries for all neurons and/or neural masses contained in blox.

See powerspectrumplot for more information on the keyword arguments.

voltage_timeseries(cb::Union{AbstractComposite, Vector{Union{AbstractNeuron, AbstractNeuralMass}}, sol::AbstractSolution; ts)

Return the voltage timeseries of all neurons and/or neural masses contained in blox. The output is a Matrix where each row is a separate neuron or neural mass and each column is a timepoint.

Keyword arguments:

• ts : [ms] Timepoints at which the voltage values are evaluated in simulation solution sol. It can be a range, a vector or an individual timepoint. If no values are passed (and ts=nothing) then the entire range of the solution sol is used.

meanfield_timeseries(cb::Union{AbstractComposite, Vector{AbstractNeuron}, sol, state; ts)

Return the average timeseries of state variable state over all neurons contained in cb.

Keyword arguments:

• ts : [ms] Timepoints at which the timeseries is evaluated in simulation solution sol. It can be a range, a vector or an individual timepoint. If no values are passed (and ts=nothing) then the entire range of the solution sol is used.

state_timeseries(blox::AbstractBlox, sol::SciMLBase.AbstractSolution, state::String; ts = nothing)

Return the timeseries of the state variable state from blox.

Keyword arguments:

• ts : [ms] Timepoints at which the timeseries is evaluated in simulation solution sol. It can be a range, a vector or an individual timepoint. If no values are passed (and ts=nothing) then the entire range of the solution sol is used.

state_timeseries(cb::Union{AbstractComposite, Vector{<:AbstractBlox}}, 
                 sol::SciMLBase.AbstractSolution, state::String; ts = nothing)

Return the timeseries of the state variable state for each blox contained in cb. The resulting collection of timeseries are stacked in a Matrix where each row is a separate blox in cb.

Keyword arguments:

• ts : [ms] Timepoints at which the timeseries is evaluated in simulation solution sol. It can be a range, a vector or an individual timepoint. If no values are passed (and ts=nothing) then the entire range of the solution sol is used.

ClassificationEnvironment(stim::ImageStimulus, N_trials; name, namespace, t_stimulus, t_pause)

Create an environment for reinforcement learning. A set of images is presented to the agent to be classified. This struct stores the correct class for each image, and the current trial of the experiment.

Arguments:

• stim: The ImageStimulus, created from a set of images
• N_trials: Number of trials. The agent performs one classification each trial.
• t_stimulus: The length of time the stimulus is on (ms)
• t_pause: The length of time the stimulus is off (ms)

GreedyPolicy(; name, t_decision, namespace, competitor_states = Symbol[])

A policy that makes a choice by picking the state with the highest value among competitor_states which represent each available choice. t_decision is the time of the decision.

HebbianPlasticity(; K, W_lim,
                  state_pre = nothing,
                  state_post = nothing,
                  t_pre = nothing,
                  t_post = nothing)

Hebbian plasticity rule. The connection weight is updated according to :

\[ w_{j+1} = w_j + \text{feedback} × K x_\text{pre} x_\text{post} (W_\text{lim} - w)\]

where feedback is a binary indicator of the correctness of the model's action, and x indicates the activity of the pre- and post-synaptic neuron states state_pre and state_post at timepoints t_pre and t_post respectively.

Arguments: - K : the learning rate of the connection - Wlim : the maximum weight for the connection - statepre : state of the presynaptic neuron that is used in the plasticity rule (by default this is state V in neurons). - statepost : statepre : state of the postsynaptic neuron that is used in the plasticity rule (by default this is state V in neurons). - tpre : timepoint at which `statepreis evaluated to be used in the plasticity rule. - t_post : t_pre : timepoint at whichstate_post` is evaluated to be used in the plasticity rule.

See also HebbianModulationPlasticity.

HebbianModulationPlasticity(; K, decay, α, θₘ,
                            state_pre = nothing,
                            state_post = nothing,
                            t_pre = nothing,
                            t_post = nothing,
                            t_mod = nothing,
                            modulator = nothing)

Hebbian plasticity rule, modulated by the dopamine reward prediction error. The weight update is largest when the reward prediction error is far from the modulation threshold θₘ.

\[ ϵ = \text{feedback} - (\text{DA}_b - \text{DA}) w_{j+1} = w_j + \max(\times K x_\text{pre} x_\text{post} ϵ(ϵ + θₘ) dσ(α(ϵ + θₘ)) - \text{decay} × w, -w)\]

where feedback is a binary indicator of the correctness of the model's action, DA_b is the baseline dopamine level, DA is the modulator's dopamine release, dσ is the derivative of the logistic function, and x indicates the activity of the pre- and post-synaptic neuron states state_pre and state_post at timepoints t_pre and t_post respectively. The decay prevents the weights from diverging.

Arguments: - K: the learning rate of the connection - decay: Decay of the weight update - α: the selectivity of the derivative of the logistic function - θₘ: the modulation threshold for the reward prediction error - statepre : state of the presynaptic neuron that is used in the plasticity rule (by default this is state V in neurons). - statepost : statepre : state of the postsynaptic neuron that is used in the plasticity rule (by default this is state V in neurons). - tpre : timepoint at which state_pre is evaluated to be used in the plasticity rule. - tpost : tpre : timepoint at which state_post is evaluated to be used in the plasticity rule.

See also HebbianPlasticity.

weight_gradient(lr::AbstractLearningRule, sol, w, feedback)

Calculate the way that the weight w should change based on the solution of the reinforcement learning experiment.

run_warmup(agent::AbstractAgent, env::AbstractEnvironment, t_warmup; kwargs...)

Run the initial solve of the RL experiment for t_warmup.

run_trial!(agent::AbstractAgent, env::AbstractEnvironment, weights, u0; kwargs...)

Run a single trial of a RL experiment. Update the connection weights according to the learning rules.

run_experiment!(agent::AbstractAgent, env::AbstractEnvironment; verbose=false, t_warmup=0, kwargs...)

Perform a full RL experiment with agent in the environment env. Will run until the maximum number of trials in env is reached.