Utilities

Utilities#

Utility functions for spiking neural networks.

This module provides utility functions for loading rate models, generating connectivity parameters, and validating inputs for spiking neural network simulations.

Model Loading#

load_rate_model(model_path)#

Load a trained rate RNN model from MATLAB .mat file.

Only .mat files are supported as they contain all necessary parameters for accurate rate-to-spike conversion, including connectivity masks, neuron types, and time constants.

Parameters:

model_path (str) – Path to the .mat model file

Returns:

Dictionary containing model parameters

Return type:

dict

Raises:

  • FileNotFoundError – If model file doesn’t exist

  • ValueError – If file is not .mat format or corrupted

Network Configuration#

spiking.utils.create_connectivity_masks(N: int, P_inh: float = 0.2, som_N: int = 0, apply_dale: bool = True, seed: int | None = None) → Tuple[ndarray, ndarray, ndarray, ndarray][source]#

Create connectivity masks for spiking network simulation.

Parameters:

  • N (int) – Number of neurons.

  • P_inh (float) – Proportion of inhibitory neurons.

  • som_N (int) – Number of somatostatin neurons.

  • apply_dale (bool) – Whether to apply Dale’s principle.

  • seed (int, optional) – Random seed for reproducibility.

Returns:

  • inh: Boolean array for inhibitory neurons

  • exc: Boolean array for excitatory neurons

  • m: Sign mask matrix for Dale’s principle

  • som_m: SOM connectivity mask

Return type:

Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]

spiking.utils.generate_lif_params(dt: float = 5e-05, downsample: int = 1) → Dict[str, float][source]#

Generate default LIF neuron parameters.

Parameters:

  • dt (float) – Integration time step.

  • downsample (int) – Downsampling factor.

Returns:

Dictionary of LIF parameters.

Return type:

Dict[str, float]

Validation Functions#

spiking.utils.validate_stimulus(u: ndarray, task_type: str = 'go-nogo') → bool[source]#

Validate input stimulus format for different tasks.

Parameters:

  • u (np.ndarray) – Input stimulus array.

  • task_type (str) – Type of task (‘go-nogo’, ‘xor’, ‘mante’).

Returns:

True if stimulus is valid.

Return type:

bool

Raises:

ValueError – If stimulus format is invalid.

spiking.utils.validate_scaling_factor(scaling_factor: float, valid_range: Tuple[float, float] = (1.0, 1000.0)) → bool[source]#

Validate scaling factor for rate-to-spike conversion.

Parameters:

  • scaling_factor (float) – Scaling factor value.

  • valid_range (Tuple[float, float]) – Valid range for scaling factor.

Returns:

True if scaling factor is valid.

Return type:

bool

Raises:

ValueError – If scaling factor is invalid.

Analysis and Formatting#

spiking.utils.format_spike_data(spikes: ndarray, dt: float) → Dict[str, ndarray][source]#

Format spike data for analysis and visualization.

Parameters:

  • spikes (np.ndarray) – Binary spike matrix (N_neurons, N_timesteps).

  • dt (float) – Time step size.

Returns:

Dictionary containing formatted spike data.

Return type:

Dict[str, np.ndarray]

spiking.utils.check_gpu_availability() → Tuple[bool, str][source]#

Check GPU availability and return device information.

Returns:

(is_available, device_name)

Return type:

Tuple[bool, str]

spiking.utils.set_random_seed(seed: int) → None[source]#

Set random seeds for reproducibility.

Parameters:

seed (int) – Random seed value.

Example Usage#

Loading Models:

from spiking.utils import load_rate_model

# Load .mat model file
model_data = load_rate_model('trained_model.mat')

Creating Network Connectivity:

from spiking.utils import create_connectivity_masks

N = 200  # Number of neurons
P_inh = 0.2  # Proportion of inhibitory neurons

inh, exc, m, som_m = create_connectivity_masks(
    N, P_inh, som_N=10, apply_dale=True, seed=42
)

Generating LIF Parameters:

from spiking.utils import generate_lif_params

# Default parameters
lif_params = generate_lif_params()

# Custom parameters
lif_params = generate_lif_params(dt=0.0001, downsample=2)

Validating Input:

from spiking.utils import validate_stimulus, validate_scaling_factor
import numpy as np

# Validate Go-NoGo stimulus
u = np.zeros((1, 201))  # 1 input, 201 timesteps
validate_stimulus(u, task_type='go-nogo')

# Validate scaling factor
validate_scaling_factor(50.0, valid_range=(20.0, 100.0))

Analyzing Spikes:

from spiking.utils import format_spike_data

# Format spike data for analysis
spike_data = format_spike_data(spikes, dt=0.00005)

print(f"Total spikes: {spike_data['total_spikes']}")
print(f"Mean firing rate: {np.mean(spike_data['firing_rates']):.2f} Hz")

GPU and Random Seed Management:

from spiking.utils import check_gpu_availability, set_random_seed

# Check GPU availability
gpu_available, device_name = check_gpu_availability()
print(f"GPU: {device_name}")

# Set random seed for reproducibility
set_random_seed(42)

Function Details#

load_rate_model(model_path)

Load a trained rate RNN model from MATLAB .mat file.

create_connectivity_masks(N, P_inh, som_N, apply_dale, seed)

Generate connectivity masks for inhibitory/excitatory neurons and SOM types.

generate_lif_params(dt, downsample)

Create default LIF neuron parameters with customizable time constants.

validate_stimulus(u, task_type)

Ensure input stimulus matches requirements for specific cognitive tasks.

format_spike_data(spikes, dt)

Convert binary spike matrix to analysis-ready format with timing information.

Contents