def get_cuts(cuts):
""" Convert `cuts` argument to vector_double type.
Argument can be None, a number or a sequence of numbers. If None, there is
only one cut at 0.5. If `cuts` is a number, function returns a vector_double
with that number as a single element. If its a sequence, that sequence will
be converted to vector_double type.
Parameters
----------
cuts : None, number or sequence of numbers
Cut values
Returns
-------
cuts : vector_double
Cut values.
Raises
------
TypeError
If `cuts` is not None, a number or a sequence of numbers.
"""
if cuts is None:
return sfr.vector_double([0.5])
elif op.isSequenceType(cuts) and np.array(
[op.isNumberType(a) for a in cuts]).all():
return sfr.vector_double(cuts)
elif op.isNumberType(cuts):
return sfr.vector_double([cuts])
else:
raise TypeError("'cuts' must be either None, a number or a " +
"sequence of numbers.")
def get_cuts(cuts):
""" Convert `cuts` argument to vector_double type.
Argument can be None, a number or a sequence of numbers. If None, there is
only one cut at 0.5. If `cuts` is a number, function returns a vector_double
with that number as a single element. If its a sequence, that sequence will
be converted to vector_double type.
Parameters
----------
cuts : None, number or sequence of numbers
Cut values
Returns
-------
cuts : vector_double
Cut values.
Raises
------
TypeError
If `cuts` is not None, a number or a sequence of numbers.
"""
if cuts is None:
return sfr.vector_double([0.5])
elif op.isSequenceType(cuts) and np.array([op.isNumberType(a) for a in cuts]).all():
return sfr.vector_double(cuts)
elif op.isNumberType(cuts):
return sfr.vector_double([cuts])
else:
raise TypeError("'cuts' must be either None, a number or a " + "sequence of numbers.")
def get_params(params, nparams):
"""Convert sequence of parameter values to vector_double type.
Parameters
----------
params : sequence of numbers
Parameter values.
nparams : int
Number of free parameters in the model.
Returns
-------
params : vector_double
Parameter values.
Raises
------
ValueError
If the length of the sequence is not equal to the number of free
parameters.
"""
if len(params) != nparams:
raise ValueError("You specified %d parameters, " % len(params) + "but the model has parameters." % nparams)
else:
return sfr.vector_double(params)
def get_start(start, nparams):
"""Convert sequence of starting values to vector_double type.
Parameters
----------
start : sequence of numbers
Starting values.
nparams : int
Number of free parameters of the model.
Returns
-------
start: vector_double
Starting values.
Raises
------
ValueError
If the length of the sequence is not equal to the number of free
parameters.
"""
if len(start) != nparams:
raise ValueError("You specified %d starting value(s), " % len(start) + "but there are %d parameters." % nparams)
else:
return sfr.vector_double(start)
def get_params(params, nparams):
"""Convert sequence of parameter values to vector_double type.
Parameters
----------
params : sequence of numbers
Parameter values.
nparams : int
Number of free parameters in the model.
Returns
-------
params : vector_double
Parameter values.
Raises
------
ValueError
If the length of the sequence is not equal to the number of free
parameters.
"""
if len(params) != nparams:
raise ValueError("You specified %d parameters, " % len(params) +
"but the model has parameters." % nparams)
else:
return sfr.vector_double(params)
def get_start(start, nparams):
"""Convert sequence of starting values to vector_double type.
Parameters
----------
start : sequence of numbers
Starting values.
nparams : int
Number of free parameters of the model.
Returns
-------
start: vector_double
Starting values.
Raises
------
ValueError
If the length of the sequence is not equal to the number of free
parameters.
"""
if len(start) != nparams:
raise ValueError("You specified %d starting value(s), " % len(start) +
"but there are %d parameters." % nparams)
else:
return sfr.vector_double(start)
def make_dataset(data, nafc):
"""Create a PsiData object from column based input.
Parameters
----------
data : sequence on length 3 sequences
Psychometric data in colum based input,
e.g.[[1, 1, 5], [2, 3, 5] [3, 5, 5]].
nafc : int
Number of alternative choices in forced choice procedure.
Returns
-------
data: PsiData
Dataset object.
"""
data = np.array(data).T
x = sfr.vector_double(map(float, data[0]))
k = sfr.vector_int(map(int, data[1]))
N = sfr.vector_int(map(int, data[2]))
return sfr.PsiData(x, N, k, nafc)
def make_dataset(data, nafc):
"""Create a PsiData object from column based input.
Parameters
----------
data : sequence on length 3 sequences
Psychometric data in colum based input,
e.g.[[1, 1, 5], [2, 3, 5] [3, 5, 5]].
nafc : int
Number of alternative choices in forced choice procedure.
Returns
-------
data: PsiData
Dataset object.
"""
data = np.array(data).T
x = sfr.vector_double(map(float, data[0]))
k = sfr.vector_int(map(int, data[1]))
N = sfr.vector_int(map(int, data[2]))
return sfr.PsiData(x, N, k, nafc)
def mcmc(
data,
start=None,
nsamples=10000,
nafc=2,
sigmoid="logistic",
core="mw0.1",
priors=None,
stepwidths=None,
sampler="MetropolisHastings",
gammaislambda=False,
):
dataset, pmf, nparams = sfu.make_dataset_and_pmf(data, nafc, sigmoid, core, priors, gammaislambda=gammaislambda)
if start is not None:
start = sfu.get_start(start, nparams)
else:
# use mapestimate
opt = sfr.PsiOptimizer(pmf, dataset)
start = opt.optimize(pmf, dataset)
proposal = sfr.GaussRandom()
if sampler not in sfu.sampler_dict.keys():
raise sfu.PsignifitException("The sampler: " + sampler + " is not available.")
else:
sampler = sfu.sampler_dict[sampler](pmf, dataset, proposal)
sampler.setTheta(start)
if stepwidths != None:
stepwidths = np.array(stepwidths)
if len(stepwidths.shape) == 2:
if isinstance(sampler, sfr.GenericMetropolis):
sampler.findOptimalStepwidth(sfu.make_pilotsample(stepwidths))
elif isinstance(sampler, sfr.MetropolisHastings):
sampler.setStepSize(sfr.vector_double(stepwidths.std(0)))
else:
raise sfu.PsignifitException(
"You provided a pilot sample but the selected sampler does not support pilot samples"
)
elif len(stepwidths) != nparams:
raise sfu.PsignifitException(
"You specified '"
+ str(len(stepwidths))
+ "' stepwidth(s), but there are '"
+ str(nparams)
+ "' parameters."
)
else:
if isinstance(sampler, sfr.DefaultMCMC):
for i, p in enumerate(stepwidths):
p = sfu.get_prior(p)
sampler.set_proposal(i, p)
else:
sampler.setStepSize(sfr.vector_double(stepwidths))
post = sampler.sample(nsamples)
nblocks = dataset.getNblocks()
estimates = np.zeros((nsamples, nparams))
deviance = np.zeros(nsamples)
posterior_predictive_data = np.zeros((nsamples, nblocks))
posterior_predictive_deviances = np.zeros(nsamples)
posterior_predictive_Rpd = np.zeros(nsamples)
posterior_predictive_Rkd = np.zeros(nsamples)
logposterior_ratios = np.zeros((nsamples, nblocks))
for i in xrange(nsamples):
for j in xrange(nparams):
estimates[i, j] = post.getEst(i, j)
deviance[i] = post.getdeviance(i)
for j in xrange(nblocks):
posterior_predictive_data[i, j] = post.getppData(i, j)
logposterior_ratios[i, j] = post.getlogratio(i, j)
posterior_predictive_deviances[i] = post.getppDeviance(i)
posterior_predictive_Rpd[i] = post.getppRpd(i)
posterior_predictive_Rkd[i] = post.getppRkd(i)
accept_rate = post.get_accept_rate()
return (
estimates,
deviance,
posterior_predictive_data,
posterior_predictive_deviances,
posterior_predictive_Rpd,
posterior_predictive_Rkd,
logposterior_ratios,
accept_rate,
)
def bootstrap(
data,
start=None,
nsamples=2000,
nafc=2,
sigmoid="logistic",
core="ab",
priors=None,
cuts=None,
parametric=True,
gammaislambda=False,
):
dataset, pmf, nparams = sfu.make_dataset_and_pmf(data, nafc, sigmoid, core, priors, gammaislambda=gammaislambda)
cuts = sfu.get_cuts(cuts)
ncuts = len(cuts)
if start is not None:
start = sfu.get_start(start, nparams)
bs_list = sfr.bootstrap(nsamples, dataset, pmf, cuts, start, True, parametric)
jk_list = sfr.jackknifedata(dataset, pmf)
nblocks = dataset.getNblocks()
# construct the massive tuple of return values
samples = np.zeros((nsamples, nblocks), dtype=np.int32)
estimates = np.zeros((nsamples, nparams))
deviance = np.zeros((nsamples))
thres = np.zeros((nsamples, ncuts))
slope = np.zeros((nsamples, ncuts))
Rpd = np.zeros((nsamples))
Rkd = np.zeros((nsamples))
for row_index in xrange(nsamples):
samples[row_index] = bs_list.getData(row_index)
estimates[row_index] = bs_list.getEst(row_index)
deviance[row_index] = bs_list.getdeviance(row_index)
thres[row_index] = [bs_list.getThres_byPos(row_index, j) for j in xrange(ncuts)]
slope[row_index] = [bs_list.getSlope_byPos(row_index, j) for j in xrange(ncuts)]
Rpd[row_index] = bs_list.getRpd(row_index)
Rkd[row_index] = bs_list.getRkd(row_index)
thacc = np.zeros((ncuts))
thbias = np.zeros((ncuts))
slacc = np.zeros((ncuts))
slbias = np.zeros((ncuts))
for cut in xrange(ncuts):
thacc[cut] = bs_list.getAcc_t(cut)
thbias[cut] = bs_list.getBias_t(cut)
slacc[cut] = bs_list.getAcc_t(cut)
slbias[cut] = bs_list.getBias_t(cut)
ci_lower = sfr.vector_double(nparams)
ci_upper = sfr.vector_double(nparams)
for param in xrange(nparams):
ci_lower[param] = bs_list.getPercentile(0.025, param)
ci_upper[param] = bs_list.getPercentile(0.975, param)
outliers = np.zeros((nblocks), dtype=np.bool)
influential = np.zeros((nblocks))
for block in xrange(nblocks):
outliers[block] = jk_list.outlier(block)
influential[block] = jk_list.influential(block, ci_lower, ci_upper)
return samples, estimates, deviance, thres, thbias, thacc, slope, slbias, slacc, Rpd, Rkd, outliers, influential
