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 the excitatory neurons of a Blox.

Get the inhibitory neurons of a Blox.

nameof(blox)

Return the un-namespaced name of blox. See also namespaceof and namespaced_nameof.

namespaced_nameof(blox)

Return the name of the blox, prefaced by its entire inner namespace (all levels of the namespace EXCEPT for the highest level). See also inner_namespaceof.

meanfield(blox, sol)

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

Note: this function requires Makie to be loaded.

See also meanfield!, meanfield_timeseries.

meanfield!(ax::Axis, blox, sol)

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

Note: this function requires Makie to be loaded.

See also meanfield!, meanfield_timeseries.

rasterplot(blox, sol; threshold = nothing, kwargs...)

Create a scatterplot of neuron firing events, where the x-axis is time (in ms) and the y-axis is the neuron's index. Internally calls detect_spikes, and the threshold kwarg is propagated to detect_spikes, while the rest of the kwargs are Makie kwargs.

Note: this function requires Makie to be loaded.

See also rasterplot!, detect_spikes.

rasterplot!(ax::Axis, blox, sol; threshold = nothing, kwargs...)

Update an existing plot to show a scatterplot of neuron firing events, where the x-axis is time (in ms) and the y-axis is the neuron's index. Internally calls detect_spikes. The threshold kwarg is the voltage threshold for detect_spikes, while the rest of the kwargs are Makie kwargs.

Note: this function requires Makie to be loaded.

See also rasterplot!, detect_spikes.

stackplot(blox, sol)

Plot the voltage timeseries of the neurons in a Blox, stacked on top of each other.

Note: this function requires Makie to be loaded.

See also stackplot!.

stackplot!(ax::Axis, blox, sol)

Update an existing plot to show the voltage timeseries of the neurons in a Blox, stacked on top of each other.

Note: this function requires Makie to be loaded.

See also stackplot.

frplot(blox, sol; win_size = 10, overlap = 0, transient = 0, threshold = nothing, kwargs...)

Plot the firing frequency (either individual firing frequency for a neuron or mean firing frequency for a population) of a blox as a function of time (in s). The named keyword arguments are propagated to firing_rate, while the rest of the kwargs are propagated to Makie for plotting.

Note: this function requires Makie to be loaded.

See also frplot!, firing_rate.

frplot!(ax::Axis, blox, sol; win_size = 10, overlap = 0, transient = 0, threshold = nothing, kwargs...)

Update an existing plot with the firing frequency (either individual firing frequency for a neuron or mean firing frequency for a population) of a blox as a function of time (in s). The named keyword arguments are propagated to firing_rate, while the rest of the kwargs are propagated to Makie for plotting.

Note: this function requires Makie to be loaded.

See also frplot, firing_rate.

voltage_stack(blox, sol; kwargs...)

Create and display a stackplot of the voltage timeseries.

Note: this function requires Makie to be loaded.

powerspectrumplot(blox, sol; sampling_rate = nothing, method = nothing, window = nothing, kwargs...)

Plot the power spectrum of the solution (intensity as a function of frequency). The named keyword arguments are propagated to the internal powerspectrum call, while the rest of the keyword arguments are propagated to Makie for plotting.

Note: this function requires Makie to be loaded.

See also powerspectrumplot!, powerspectrum.

powerspectrumplot!(ax::Axis, blox, sol; sampling_rate = nothing, method = nothing, window = nothing, kwargs...)

Update an existing plot with the power spectrum of the solution (intensity as a function of frequency). The named keyword arguments are propagated to the internal powerspectrum call, while the rest of the keyword arguments are propagated to Makie for plotting.

Note: this function requires Makie to be loaded.

See also powerspectrumplot, powerspectrum.

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

Find the spikes of a timeseries, where spikes are defined to have voltage greater than the threshold. Return a SparseVector that is equal to 1 at the time indices of the spikes.

Keyword arguments: - threshold: threshold voltage for a spike - tolerance: the range around the threshold value in which a maxima counts as a spike - ts: time - scheduler:

firing_rate(blox, sol;
            transient = 0, win_size = last(sol.t) - transient,
            overlap = 0, threshold = nothing,
            scheduler = :serial, kwargs...)

Keyword arguments: - transient: - win_size - overlap - threshold - scheduler

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, sol; sampling_rate = nothing, method = periodogram, window = nothing)

Plot the powerspectrum of the voltage timeseries for a set of Blox.

voltage_timeseries(cb, sol; ts)

Return the voltage timeseries of a Blox or collection of Blox.

meanfield_timeseries(cb, sol, state; ts)

Return the timeseries of the average value of state variable state over a collection of neurons or a composite. Provide the optional kwarg ts to return the variable's value at specific times ts.

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

Return the timeseries for the state variable named state as a vector. Provide the optional kwarg ts to return the variable's value at specific times ts.

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

Return the state_timeseries of the state variable state for each Blox in a composite or vector of Blox. The resulting collection of timeseries are stacked as rows of a matrix. Provide the optional kwarg ts to return the variable's value at specific times ts.

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[], competitor_params = Symbol[])

A policy that performs classification by picking the state with the highest value among competitor_states. 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 learning rule. Every trial of the RL experiment, update the weight according to the following:

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

where feedback indicates the correctness of the agent's action during the trial, and the x indicate the activities of the pre- and post-synaptic neurons.

Arguments: - K: the learning rate of the connection - W_lim: the maximum weight for the connection

See also HebbianModulationPlasticity.

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

Hebbian learning rule, but 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 Kx_\text{pre}x_\text{post}ϵ(ϵ + θₘ) dσ(α(ϵ + θₘ)) - \text{decay} × w, -w)\]

where feedback indicates the correctness of the agent's action during the trial, DA_b is the baseline dopamine level and DA is the modulator's dopamine release, and dσ is the derivative of the logistic function. 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

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.