def test_fit_drift(self):
"""A simple one-parameter fit"""
m = ddm.Model(name="DDM", drift=ddm.DriftConstant(drift=2))
s = m.solve()
sample = s.resample(10000)
mfit = ddm.Model(
name="DDM",
drift=ddm.DriftConstant(drift=ddm.Fittable(minval=0, maxval=10)))
ddm.fit_adjust_model(model=mfit, sample=sample)
# Within 10%
if SHOW_PLOTS:
mfit.name = "Fitted solution"
sfit = mfit.solve()
plot_compare_solutions(s, sfit)
plt.show()
_verify_param_match("drift", "drift", m, mfit)
def setUp(self):
self.basic = ddm.Model(dx=.005,
dt=.01,
T_dur=2,
drift=ddm.DriftConstant(drift=.4),
noise=ddm.NoiseConstant(noise=1),
bound=ddm.BoundConstant(B=1))
class NoiseCond(ddm.Noise):
name = "Noise with a condition"
required_conditions = ['cond']
required_parameters = []
def get_noise(self, conditions, **kwargs):
return conditions["cond"]
self.withcond = ddm.Model(noise=NoiseCond())
class FancyBounds(ddm.Bound):
name = "Increasing/decreasing bounds"
required_conditions = []
required_parameters = []
def get_bound(self, conditions, t, **kwargs):
if t <= 1:
return 1 + t
if t > 1:
return 2 / t
self.bound = ddm.Model(bound=FancyBounds())
def test_ICPoint_collapsing_bounds(self):
m = ddm.Model(name='ICPoint_BCollapsingLin_test',
drift=ddm.DriftConstant(drift=2),
noise=ddm.NoiseConstant(noise=1.5),
bound=ddm.BoundCollapsingLinear(B=1, t=0.5),
IC=ddm.ICPoint(x0=-.25))
_modeltest_numerical_vs_analytical(m,
method="implicit",
max_diff=.3,
mean_diff=.2,
prob_diff=.05)
def test_get_set_parameters_functions(self):
"""Test get_parameters, set_parameters, and get_parameter_names"""
p1 = ddm.Fittable(minval=0, maxval=1)
p2 = ddm.Fittable(minval=.3, maxval=.9, default=.4)
m = ddm.Model(drift=ddm.DriftConstant(drift=p1), noise=ddm.NoiseLinear(noise=p2, x=.2, t=p1))
print(m.get_model_parameters())
assert all(id(a) == id(b) for a,b in zip(m.get_model_parameters(), [p1, p2]))
assert all(a == b for a,b in zip(m.get_model_parameter_names(), ["drift/t", "noise"]))
m.set_model_parameters(m.get_model_parameters())
assert all(id(a) == id(b) for a,b in zip(m.get_model_parameters(), [p1, p2]))
m.set_model_parameters([.5, .5])
assert all(a == b for a,b in zip(m.get_model_parameters(), [.5, .5]))
def test_ICPoint(self):
"""Arbitrary pointwise initial condition"""
m = ddm.Model(name='ICPoint_test',
drift=ddm.DriftConstant(drift=2),
noise=ddm.NoiseConstant(noise=1.5),
bound=ddm.BoundConstant(B=1),
IC=ddm.ICPoint(x0=-.25))
_modeltest_numerical_vs_analytical(m,
method="implicit",
max_diff=.3,
mean_diff=.2,
prob_diff=.05)
def test_overlay_chain_distribution_integrates_to_1(self):
"""Overlays integrate to 1"""
m = ddm.Model(name="Overlay_test",
drift=ddm.DriftConstant(drift=2),
T_dur=5,
overlay=ddm.OverlayChain(overlays=[
ddm.OverlayPoissonMixture(pmixturecoef=.2, rate=2),
ddm.OverlayUniformMixture(umixturecoef=.2),
ddm.OverlayNonDecision(nondectime=.2)
]))
s = m.solve()
distsum = s.prob_correct() + s.prob_error()
assert .99 < distsum < 1.0001, "Distribution doesn't sum to 1"
def test_double_fit(self):
"""Fit different parameters in the same (or a different) model using a single Fittable object"""
class NoiseDouble(ddm.Noise):
name = "time-varying noise"
required_parameters = ["noise1", "noise2"]
def get_noise(self, **kwargs):
if np.random.rand() > .5:
return self.noise1
else:
return self.noise2
class NoiseConstantButNot(ddm.Noise
): # To avoid the numerical simulations
name = "almost noise constant"
required_parameters = ["noise"]
def get_noise(self, **kwargs):
return self.noise
# Generate data
m = ddm.Model(name="DDM",
drift=ddm.DriftConstant(drift=1),
noise=ddm.NoiseConstant(noise=1.7))
s = m.solve_numerical(
) # Solving analytical and then fitting numerical may give a bias
sample = s.resample(10000)
mone = ddm.fit_model(
sample,
drift=ddm.DriftConstant(drift=1),
noise=NoiseConstantButNot(noise=ddm.Fittable(minval=.5, maxval=3)))
sigs = ddm.Fittable(minval=.5, maxval=3)
msam = ddm.fit_model(sample,
drift=ddm.DriftConstant(drift=1),
noise=NoiseDouble(noise1=sigs, noise2=sigs))
assert msam._noisedep.noise1 == msam._noisedep.noise2, "Fitting to be the same failed"
assert abs(msam._noisedep.noise1 -
mone._noisedep.noise) < 0.1 * mone._noisedep.noise
def setUp(self):
self.basic = ddm.Model(dx=.005,
dt=.01,
T_dur=2,
drift=ddm.DriftConstant(drift=.4),
noise=ddm.NoiseConstant(noise=1),
bound=ddm.BoundConstant(B=1))
class NoiseCond(ddm.Noise):
name = "Noise with a condition"
required_conditions = ['cond']
required_parameters = []
def get_noise(self, conditions, **kwargs):
return conditions["cond"]
self.withcond = ddm.Model(noise=NoiseCond())
)
c.ax(axname).axis("off")
c.ax(axname + "_top").axis("off")
c.ax(axname + "_bot").axis("off")
# End top bottom axes
# Begin finalize hist
def finalize_hists(axname):
c.ax(axname + "_bot").set_ylim(c.ax(axname + "_top").get_ylim())
c.ax(axname + "_bot").invert_yaxis()
# End finalize hist
# Begin model
T_dur = 2
model = Model(drift=ddm.DriftConstant(drift=0.8), dt=0.01, dx=0.01)
# End model
# Begin create trajectories
def draw_trials(model, axname, N=1, seedstart=7, alpha=1):
# Create three-rowed figure
add_hists(axname)
# Draw DDM axes
ax = c.ax(axname)
ax.plot([0, T_dur], [0, 0], c="gray", clip_on=False, lw=0.5)
ax.plot([0, T_dur], [1.04, 1.04], c="red", clip_on=False, lw=2)
ax.plot([0, T_dur], [-1.04, -1.04], c="red", clip_on=False, lw=2)
# sns.despine(bottom=True, ax=ax_main)
ax.get_xaxis().set_ticks([])
ax.get_yaxis().set_ticks([])
