# brainpy.neurons.HindmarshRose#

class brainpy.neurons.HindmarshRose(size, a=1.0, b=3.0, c=1.0, d=5.0, r=0.01, s=4.0, V_rest=-1.6, V_th=1.0, V_initializer=ZeroInit, y_initializer=OneInit(value=-10.0), z_initializer=ZeroInit, noise=None, method='exp_auto', keep_size=False, input_var=True, name=None, mode=None, spike_fun=<brainpy._src.math.surrogate._utils.VJPCustom object>)[source]#

Hindmarsh-Rose neuron model.

Model Descriptions

The Hindmarsh–Rose model [1] [2] of neuronal activity is aimed to study the spiking-bursting behavior of the membrane potential observed in experiments made with a single neuron.

The model has the mathematical form of a system of three nonlinear ordinary differential equations on the dimensionless dynamical variables $$x(t)$$, $$y(t)$$, and $$z(t)$$. They read:

\begin{split}\begin{aligned} \frac{d V}{d t} &= y - a V^3 + b V^2 - z + I \\ \frac{d y}{d t} &= c - d V^2 - y \\ \frac{d z}{d t} &= r (s (V - V_{rest}) - z) \end{aligned}\end{split}

where $$a, b, c, d$$ model the working of the fast ion channels, $$I$$ models the slow ion channels.

Model Examples

>>> import brainpy.math as bm
>>> import brainpy as bp
>>> import matplotlib.pyplot as plt
>>>
>>> bp.math.set_dt(dt=0.01)
>>> bp.ode.set_default_odeint('rk4')
>>>
>>> types = ['quiescence', 'spiking', 'bursting', 'irregular_spiking', 'irregular_bursting']
>>> bs = bm.array([1.0, 3.5, 2.5, 2.95, 2.8])
>>> Is = bm.array([2.0, 5.0, 3.0, 3.3, 3.7])
>>>
>>> # define neuron type
>>> group = bp.neurons.HindmarshRose(len(types), b=bs)
>>> runner = bp.DSRunner(group, monitors=['V'], inputs=['input', Is],)
>>> runner.run(1e3)
>>>
>>> fig, gs = bp.visualize.get_figure(row_num=3, col_num=2, row_len=3, col_len=5)
>>> for i, mode in enumerate(types):
>>>     fig.add_subplot(gs[i // 2, i % 2])
>>>     plt.plot(runner.mon.ts, runner.mon.V[:, i])
>>>     plt.title(mode)
>>>     plt.xlabel('Time [ms]')
>>> plt.show()


Model Parameters

 Parameter Init Value Unit Explanation a 1 Model parameter. Fixed to a value best fit neuron activity. b 3 Model parameter. Allows the model to switch between bursting and spiking, controls the spiking frequency. c 1 Model parameter. Fixed to a value best fit neuron activity. d 5 Model parameter. Fixed to a value best fit neuron activity. r 0.01 Model parameter. Controls slow variable z’s variation speed. Governs spiking frequency when spiking, and affects the number of spikes per burst when bursting. s 4 Model parameter. Governs adaption.

Model Variables

 Member name Initial Value Explanation V -1.6 Membrane potential. y -10 Gating variable. z 0 Gating variable. spike False Whether generate the spikes. input 0 External and synaptic input current. t_last_spike -1e7 Last spike time stamp.

References

__init__(size, a=1.0, b=3.0, c=1.0, d=5.0, r=0.01, s=4.0, V_rest=-1.6, V_th=1.0, V_initializer=ZeroInit, y_initializer=OneInit(value=-10.0), z_initializer=ZeroInit, noise=None, method='exp_auto', keep_size=False, input_var=True, name=None, mode=None, spike_fun=<brainpy._src.math.surrogate._utils.VJPCustom object>)[source]#

Methods

 __init__(size[, a, b, c, d, r, s, V_rest, ...]) add_aft_update(key, fun) Add the after update into this node add_bef_update(key, fun) Add the before update into this node add_inp_fun(key, fun[, label, category]) Add an input function. clear_input() Empty function of clearing inputs. cpu() Move all variable into the CPU device. cuda() Move all variables into the GPU device. dV(V, t, y, z, I_ext) dy(y, t, V) dz(z, t, V) get_aft_update(key) Get the after update of this node by the given key. get_batch_shape([batch_size]) get_bef_update(key) Get the before update of this node by the given key. get_delay_data(identifier, delay_pos, *indices) Get delay data according to the provided delay steps. get_delay_var(name) get_inp_fun(key) Get the input function. get_local_delay(var_name, delay_name) Get the delay at the given identifier (name). has_aft_update(key) Whether this node has the after update of the given key. has_bef_update(key) Whether this node has the before update of the given key. init_param(param[, shape, sharding]) Initialize parameters. init_variable(var_data, batch_or_mode[, ...]) Initialize variables. jit_step_run(i, *args, **kwargs) The jitted step function for running. load_state(state_dict, **kwargs) Load states from a dictionary. load_state_dict(state_dict[, warn, compatible]) Copy parameters and buffers from state_dict into this module and its descendants. nodes([method, level, include_self]) Collect all children nodes. register_delay(identifier, delay_step, ...) Register delay variable. register_implicit_nodes(*nodes[, node_cls]) register_implicit_vars(*variables[, var_cls]) register_local_delay(var_name, delay_name[, ...]) Register local relay at the given delay time. reset(*args, **kwargs) Reset function which reset the whole variables in the model (including its children models). reset_local_delays([nodes]) Reset local delay variables. reset_state([batch_size]) return_info() rtype: Union[Variable, ReturnInfo] save_state(**kwargs) Save states as a dictionary. setattr(key, value) rtype: None state_dict(**kwargs) Returns a dictionary containing a whole state of the module. step_run(i, *args, **kwargs) The step run function. sum_current_inputs(*args[, init, label]) Summarize all current inputs by the defined input functions .current_inputs. sum_delta_inputs(*args[, init, label]) Summarize all delta inputs by the defined input functions .delta_inputs. sum_inputs(*args, **kwargs) to(device) Moves all variables into the given device. tpu() Move all variables into the TPU device. tracing_variable(name, init, shape[, ...]) Initialize the variable which can be traced during computations and transformations. train_vars([method, level, include_self]) The shortcut for retrieving all trainable variables. tree_flatten() Flattens the object as a PyTree. tree_unflatten(aux, dynamic_values) Unflatten the data to construct an object of this class. unique_name([name, type_]) Get the unique name for this object. update([x]) The function to specify the updating rule. update_local_delays([nodes]) Update local delay variables. vars([method, level, include_self, ...]) Collect all variables in this node and the children nodes.

Attributes

 after_updates before_updates cur_inputs current_inputs delta_inputs derivative implicit_nodes implicit_vars mode Mode of the model, which is useful to control the multiple behaviors of the model. name Name of the model. supported_modes Supported computing modes. varshape The shape of variables in the neuron group.