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 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