def fast_lzero(penalty: float, dat: np.ndarray, gamma: float,
constraint: bool) -> np.ndarray:
"""runs fast spike inference and returns an array like the input trace
with data substituted by event magnitudes
Parameters
----------
penalty: float
tuning parameter lambda > 0
dat: np.ndarray
fluorescence data
gamma: float
a scalar value for the AR(1) decay parameter; 0 < gamma <= 1
constraint: bool
constrained (true) or unconstrained (false) optimization
Returns
-------
out: np.ndarray
event magnitude array, same shape as dat
Notes
-----
https://github.com/jewellsean/FastLZeroSpikeInference/blob/cdfaade68ceb6aa15ec5003c460de4e0575f1d5f/python/FastLZeroSpikeInference/fast.py#L30 # noqa: E501
"""
ev = fast.estimate_spikes(dat,
gamma,
penalty,
constraint,
estimate_calcium=True)
out = np.zeros(ev['dat'].shape)
out[ev['spikes']] = ev['pos_spike_mag']
return out
def estimate_spikes_by_firing_rate(dat, decay_rate, target_firing_rate, lam_min = 1e-6, lam_max = 1e0, max_iters=50, tolerance=5):
'''
Estimate spikes based on a target firing rate. Estimates spikes with FastLZeroSpikeInference.fast based on tuning
parameter lambda. Uses 1D binary search to find a value of the tuning parameter that results in a number of estimated
spikes that is close to the target_firing_rate
:param dat: data dict, see data_preprocessing
:param decay_rate: AR1 decay rate
:param target_firing_rate: target firing rate in fps
:param lam_min: minimal tuning parameter value for binary search
:param lam_max: maximal tuning parameter value for binary search
:param max_iters: maximum number of binary search iterations
:param tolerance: stop binary search if difference in number of target and estimated spikes is less than tolerance
:return: dict of the FastLZeroSpikeInference.fast on the optimal tuning parameter, the optimal parameter (lam_star)
and details from the binary search
'''
gcamp = dat['calcium']
fps = dat['fps']
# transform target firing rate into a number of spikes
n = gcamp.shape[0]
nbin_spike_target = np.floor(target_firing_rate * n / fps)
bs_search = one_d_binary_search(gcamp, decay_rate, lam_min, lam_max, nbin_spike_target, max_iters, tolerance)
lam_star = bs_search['lam_star']
fit = fast.estimate_spikes(gcamp, decay_rate, lam_star, True, True)
return {'fit':fit, 'lam_star': lam_star, 'minimizer':bs_search}
def l0(self, dff, gamma, l, constraint):
ev = fast.estimate_spikes(dff,
gamma,
l,
constraint,
estimate_calcium=True)
out = np.zeros(ev['dat'].shape)
out[ev['spikes'] - 1] = ev['pos_spike_mag']
return out
def loss_function_n_spikes(lam, gcamp, decay_rate, nbin_spike_target):
'''
Estimate spikes from gcamp with specified decay rate and tuning parameter lambda.
Assess how far the estimated firing rate is from a target firing rate (as measured by the total
number of spikes)
:param gcamp:
:param decay_rate:
:param lam:
:param nbin_spike_target:
:return:
'''
fit = fast.estimate_spikes(gcamp, decay_rate, lam, True)
nbin_estimated_spikes = len(fit['spikes'])
return l2_distance(nbin_spike_target, nbin_estimated_spikes)
from FastLZeroSpikeInference import fast import numpy as np gam = 0.98 y = np.power(gam, np.concatenate([np.arange(100), np.arange(100)])) # Basic fit, no calcium concentration estimated fit = fast.estimate_spikes(y, gam, 1, False) # Determine calcium concentration from fit fit = fast.estimate_calcium(fit) # Estimate both spikes and calcium concentration fit = fast.estimate_spikes(y, gam, 1, False, True)