def __init__(
self,
kb2_0=50.,
# bperk0=1. / 20.,
# kappa0=40.,
bound: Bound = BoundExp,
bias0=0.,
diffusion=1.,
y0=0.,
ssq0=1e-3,
n_ev=2**7 + 1,
max_ev=3,
**kwargs):
"""
:param kappa0:
:param bound0:
:param bound_t_st0:
:param bound_t_half0:
:param bound_asymptote_max:
:param bias0:
:param diffusion:
:param y0:
:param ssq0:
:param n_ev:
:param max_ev:
:param dt:
:param nt: default used for plotting
"""
super().__init__(**kwargs)
assert n_ev % 2 == 1 # for padding in conv1d to work
self.n_ev = n_ev
self.max_ev = max_ev
self.ev_bin = torch.linspace(-self.max_ev, self.max_ev, self.n_ev)
self.dev = self.ev_bin[1] - self.ev_bin[0]
# mean logit when coherence = 1
self.kb2 = ykt.BoundedParameter([kb2_0], 0.01, 100.)
self.bias = ykt.BoundedParameter([bias0], -0.1, 0.1)
bound = bound(**{**kwargs, 'timer': self.timer})
# boundmod: bound module (cannot use _bound or bound
# for backward compatibility)
self.bound = bound
# self.bound = self._bound.bound
self.diffusion = ykt.BoundedParameter([diffusion], 0.99, 1.01)
# y0 / 2B = guess for choice 1 in excess of 0.5 when mu = 0
# therefore, y0 should be parameterized realtive to B
self.bias_t0 = ykt.BoundedParameter([0.], -0.1, 0.1)
self.ssq0 = ykt.BoundedParameter([ssq0], 1e-4, 1e-2)
self.max_ev_kernel = (
# max diffusion + max drift
np.sqrt(diffusion * self.dt) * 3.5 + 0.5 * 50 * self.dt)
self.ev_bin_kernel = self.ev_bin[
torch.abs(self.ev_bin) < self.max_ev_kernel]
def __init__(self, *args, dur_buffer0=0.2, p1st_dim0_0=0.5, **kwargs):
super().__init__(*args, **kwargs)
# dur_buffer: in seconds.
self.dur_buffer = ykt.BoundedParameter([dur_buffer0], 0.001, .5)
# self.dur_buffer = ykt.BoundedParameter([dur_buffer0], 0., 1e-4)
self.p1st_dim0 = ykt.BoundedParameter([p1st_dim0_0], 1e-3, 1 - 1e-3)
def __init__(self,
tnd_loc0=0.2,
tnd_loc_lb=0.1,
tnd_loc_ub=0.5,
tnd_disper0=0.1,
tnd_disper_lb=0.01,
tnd_disper_ub=0.3,
**kwargs):
super().__init__(**kwargs)
self.loc = ykt.BoundedParameter([tnd_loc0], tnd_loc_lb, tnd_loc_ub)
self.disper = ykt.BoundedParameter([tnd_disper0], tnd_disper_lb,
tnd_disper_ub)
def __init__(
self,
*args,
bound_t_st0=0.4,
# t_st_lb was previously 0.05, but 0.1 seems to help distinguish
# it from lower bound height
bound_t_st_lb=0.1,
bound_t_st_ub=0.8,
bound_t_half0=0.5,
bound_t_half_lb=0.05,
# previously 0.25, but seems to have similar effect with t_half
# and t_st combined, so maybe fix to 0
bound_asymptote_max=0.,
**kwargs):
super().__init__(*args, **kwargs)
self.b_t_st = ykt.BoundedParameter([bound_t_st0], bound_t_st_lb,
bound_t_st_ub)
self.b_t_half = ykt.BoundedParameter([bound_t_half0], bound_t_half_lb,
1.0)
self.b_asymptote = ykt.BoundedParameter([bound_asymptote_max / 2],
bound_asymptote_max * 1e-6,
bound_asymptote_max)
def __init__(self,
dtb1ds: Union[sim1d.Dtb1D,
Sequence[sim1d.Dtb1D]] = sim1d.Dtb1D,
to_allow_irr_ixn=False,
**kwargs):
"""
:param dtb1ds:
:param kwargs:
"""
super().__init__(**kwargs)
if type(dtb1ds) is type:
kw = argsutil.kwdef(kwargs, {'timer': self.timer})
dtb1ds = [dtb1ds(**kw) for dim in range(consts.N_DIM)]
self.dtb1ds = nn.ModuleList(dtb1ds) # type: nn.ModuleList[sim1d.Dtb1D]
self.to_allow_irr_ixn = to_allow_irr_ixn
if to_allow_irr_ixn:
self.kappa_rel_odim = ykt.BoundedParameter([0., 0.], -0.1, 0.1)
self.kappa_rel_abs_odim = ykt.BoundedParameter([0., 0.], -0.1, 0.1)
else:
self.kappa_rel_odim = ykt.BoundedParameter([0., 0.], 0., 0.)
self.kappa_rel_abs_odim = ykt.BoundedParameter([0., 0.], 0., 0.)
def __init__(
self,
dtb2d: sim2d.Dtb2DRTDimensionWise = sim2d.Dtb2DRTDimensionWise,
**kwargs):
super().__init__(**kwargs)
if type(dtb2d) is type:
kw = argsutil.kwdef(kwargs, {'timer': self.timer})
dtb2d = dtb2d(**kw)
self.dtb = dtb2d # type: sim2d.Dtb2DRTDimensionWise
self.expand_ev = dtb2d.expand_ev
self.get_out_dtb1ds = dtb2d.get_out_dtb1ds
self.td_offset = ykt.BoundedParameter([0.] * consts.N_DIM, -8 / 75,
0.3)
def __init__(self, lapse_max=0.1, **kwargs):
super().__init__(**kwargs)
self.p_lapse = ykt.BoundedParameter([lapse_max / 2], 1e-6, lapse_max)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.b_scale = ykt.BoundedParameter([0.3], 0.1, 0.5)
self.b_shape = ykt.BoundedParameter([5.], 0., 20.)
self.b_asymptote = ykt.BoundedParameter([0.25], 0., 0.5)
def __init__(self, bound0=1.0, bound0_lb=0.5, **kwargs):
super().__init__(**kwargs)
self.b = ykt.BoundedParameter([bound0], bound0_lb, 2.)