def fisk_rvs(fisk_params, size): num_falseLoop = int(fisk_params[0] * size) num_trueLoop = int((1 - fisk_params[0]) * size) falseEntries = np.array([]) trueEntries = np.array([]) if ~np.isnan(fisk_params[1][1]) and (fisk_params[1][1] != 0.0): falseEntries = np.zeros((0, )) falseEntries = truncfiskprior_rvs(fisk_params[1][0], fisk_params[1][1], fisk_params[1][2], size=num_falseLoop) if ~np.isnan(fisk_params[2][0]) and (fisk_params[2][0] != 0): trueEntries = invgauss.rvs(fisk_params[2][0], fisk_params[2][1], fisk_params[2][2], size=num_trueLoop) print trueEntries.shape if (~np.isnan(fisk_params[1][1])) and (~np.isnan(fisk_params[2][0])): entries = np.concatenate((falseEntries, -trueEntries), axis=0) elif ~np.isnan(fisk_params[1][1]): entries = falseEntries elif ~np.isnan(fisk_params[2][0]): entries = -trueEntries else: entries = np.array([1.0] * size) print entries.shape[0] return entries
def simulate_trial(parameters, values, gaze, boundary=1, error_weight=0.05, error_range=(0, 5000)): v, gamma, s, tau, t0 = parameters n_items = len(values) if np.random.uniform(0, 1) < error_weight: rt = int(np.random.uniform(*error_range)) choice = np.random.choice(n_items) else: drifts = expdrift(v, tau, gamma, values, gaze) FPTs = np.zeros(n_items) * np.nan for i in range(n_items): mu = boundary / drifts[i] lam = (boundary / s)**2 FPTs[i] = invgauss.rvs(mu=mu / lam, scale=lam) choice = np.argmin(FPTs) rt = int(np.round(np.min(FPTs) + t0)) return choice, rt
def isIG(d, v, sigma, no_sim=100000, n_bins=20): # check the distribution is IG or not simData = np.empty([ no_sim, ]) for i in range(1, no_sim): simData[i] = brownian(d, v, sigma) fig = plt.figure() plt.hist(simData, normed=True, bins=n_bins, range=(0, 5 * (d / v))) plt.ylabel('Prob') mu = d / v lamda = d**2 / sigma**2 igData = invgauss.rvs(mu / lamda, scale=lamda, size=no_sim) plt.hist(igData, normed=True, histtype='step', range=(0, 5 * (d / v)), bins=n_bins, color='r') filename = 'plot_' + str(d) + '_' + str(v) + '_' + str(sigma) + '.png' plt.savefig(filename)
def simulate_trial(parameters, values, gaze, boundary=1, error_weight=0.05, error_range=(0, 5000), drift='multiplicative'): if drift == 'multiplicative': driftfun = drift_multiplicative elif drift == 'additive': driftfun = drift_additive else: raise ValueError('Drift function "{}" not recognized.'.format(drift)) v, gamma, s, tau, t0 = parameters n_items = len(values) if np.random.uniform(0, 1) < error_weight: rt = int(np.random.uniform(*error_range)) choice = np.random.choice(n_items) else: drifts = driftfun(v, tau, gamma, values, gaze) FPTs = np.zeros(n_items) * np.nan for i in range(n_items): mu = boundary / drifts[i] lam = (boundary / s)**2 FPTs[i] = invgauss.rvs(mu=mu / lam, scale=lam) rt = np.min(FPTs) if rt < 1 or not np.isfinite(rt): rt = np.nan choice = np.nan else: choice = np.argmin(FPTs) rt = int(rt + t0) return choice, rt
def inverseGaussian(numRounds): mu = np.random.random_sample() sigma = math.sqrt(invgauss.var(mu)) # use inverse Gaussian distribution for arm dist = invgauss.rvs(mu, size=numRounds) return dist, (mu, sigma)
def check_invgaussian(): data = invgauss.rvs(0.5, scale=1.0, size=1000) data[data > 1.0] = 1.0 print "Orig Frac=" + str(np.sum(data == 1.0) / float(data.shape[0])) rv = TruncatedInvGaussian_Prior(data) res = rv.fit() print res.params print "================================" x = truncinvgauss_rvs(res.params[0], res.params[1], res.params[2], size=1000) print min(x), max(x) print "Frac=" + str(np.sum(x == 1.0) / float((x.shape[0])))
def simulate(self, n=1, paramvec=None): """ simulating n random variables from prior """ #invGaussian scale like # tX \sim IG(t \mu, t, \lambda) # scipy uses # X \sim IG( \mu, 1) delta, mu, nu, sigma = self._paramvec(paramvec) V = nu * invgauss.rvs(1. / nu, size=(n, 1)) Z = npr.randn(n, 1) X = (delta - mu) + mu * V + sigma * np.sqrt(V) * Z X = X.flatten() return X
def gibbs_invgauss(self, itr, XT_X, XT_Y): self.rng = np.random.RandomState( self.trl + itr) #itr includes recv_time, so didn't pass/use that explicitly tauinv_vec = 1 / self.rng.rand(self.n) #1/np.random.rand(self.n) for i in range(itr): Sig = np.linalg.inv(XT_X + self.sigma2 * np.diag(tauinv_vec)) beta = self.rng.multivariate_normal( np.squeeze(np.matmul(Sig, XT_Y)), self.sigma2 * Sig) for j in range(self.n): tauinv_vec[j] = invgauss.rvs( np.sqrt(self.sigma2) * (self.lmbd**(1 / 3)) / np.abs(beta[j])) * (self.lmbd**(2 / 3)) return np.reshape(beta, (self.n, 1))
def gibbs_invgauss(self, itr, XT_X, XT_Y): self.rng = np.random.RandomState(self.trl + itr - 1000) tauinv_vec = 1 / np.random.rand(self.n) for i in range(itr): Sig = np.linalg.inv(XT_X + self.sigma2 * np.diag(tauinv_vec) + 1e-3 * np.eye(self.n)) beta = self.rng.multivariate_normal( np.squeeze(np.matmul(Sig, XT_Y)), self.sigma2 * Sig) for j in range(self.n): tauinv_vec[j] = invgauss.rvs( np.sqrt(self.sigma2) * (self.lmbd**(1 / 3)) / np.abs(beta[j])) * (self.lmbd**(2 / 3)) return np.reshape(beta, (self.n, 1))
def truncinvgauss_rvs(prob, mu, sigma, size): prob = max(1e-10, prob) falseEntries = np.zeros((0, )) failure_ctr = 5 while falseEntries.shape[0] < size and failure_ctr > 0: s = invgauss.rvs(sigma, scale=mu, loc=0.0, size=size) accepted = s[(s <= 1.0)] if len(accepted) == 0: failure_ctr -= 1 falseEntries = np.concatenate((falseEntries, accepted), axis=0) falseEntries = falseEntries[:size] if failure_ctr <= 0: falseEntries = np.zeros(size) if size > 0: indexes = np.random.choice(range(size), size=int(prob * size), replace=False) falseEntries[indexes] = 1.0 return falseEntries
def run_Parametric(story_id, data): print "[" + str(story_id) + "]Fitting Fisk" fisk_params = fisk.fit(data, floc=0) fisk_nll = fisk.nnlf(fisk_params, data) fisk_rvs = fisk.rvs(*fisk_params, size=data.shape[0]) ks_fisk = ks_2samp(data, fisk_rvs) bic_fisk = compute_BIC(data, len(fisk_params), fisk_nll) print "[" + str(story_id) + "]Fitting IG" ig_params = invgauss.fit(data, floc=0) ig_nll = invgauss.nnlf(ig_params, data) ig_rvs = invgauss.rvs(*ig_params, size=data.shape[0]) ks_ig = ks_2samp(data, ig_rvs) bic_ig = compute_BIC(data, len(ig_params), ig_nll) print "[" + str(story_id) + "]Fitting LN" ln_params = lognorm.fit(data, floc=0) ln_nll = lognorm.nnlf(ln_params, data) ln_rvs = lognorm.rvs(*ln_params, size=data.shape[0]) ks_ln = ks_2samp(data, ln_rvs) bic_ln = compute_BIC(data, len(ln_params), ln_nll) print "[" + str(story_id) + "]Fitting Weibull" weib_params = weibull_min.fit(data, floc=0) weib_nll = weibull_min.nnlf(weib_params, data) weib_rvs = weibull_min.rvs(*weib_params, size=data.shape[0]) ks_weib = ks_2samp(data, weib_rvs) bic_weib = compute_BIC(data, len(weib_params), weib_nll) print "[" + str(story_id) + "]Fitting Gamma" gamma_params = gamma.fit(data, floc=0) gamma_nll = gamma.nnlf(gamma_params, data) gamma_rvs = gamma.rvs(*gamma_params, size=data.shape[0]) ks_gamma = ks_2samp(data, gamma_rvs) bic_gamma = compute_BIC(data, len(gamma_params), gamma_nll) return [ fisk_nll, ig_nll, ln_nll, weib_nll, gamma_nll, ks_fisk, ks_ig, ks_ln, ks_weib, ks_gamma, bic_fisk, bic_ig, bic_ln, bic_weib, bic_gamma, fisk_params, ig_params, ln_params, weib_params, gamma_params ]
def sample(self): X = np.asarray(self.X) y = np.asarray(self.y).flatten() if len(y) == 0: beta_tilde = np.random.laplace(scale=1 / self.lmbd, size=self.n) return beta_tilde XT_X = X.T @ X XT_Y = X.T @ y tauinv_vec = 1 / np.random.rand(self.n) score = 0 for i in range(self.itr): Sig = np.linalg.inv(XT_X + (self.sigma**2) * np.diag(tauinv_vec) + 1e-3 * np.eye(self.n)) beta = np.random.multivariate_normal( np.squeeze(np.matmul(Sig, XT_Y)), (self.sigma**2) * Sig) for j in range(self.n): tauinv_vec[j] = invgauss.rvs( np.sqrt((self.sigma**2)) * (self.lmbd**(1 / 3)) / np.abs(beta[j])) * (self.lmbd**(2 / 3)) return beta
from scipy.stats import uniform, invgauss # Data np.random.seed(1056) # set seed to replicate example nobs = 1000 # number of obs in model x1 = uniform.rvs(size=nobs) # random uniform variable beta0 = 1.0 beta1 = 0.5 l1 = 20 xb = beta0 + beta1 * x1 # linear predictor, xb exb = np.exp(xb) y = invgauss.rvs(exb / l1, scale=l1) # create response variable # Fit stan_data = {} # build data dictionary stan_data['Y'] = y # response variable stan_data['x1'] = x1 # explanatory variable stan_data['N'] = nobs # sample size # Stan code stan_code = """ data{ int<lower=0> N; vector[N] Y; vector[N] x1; } parameters{
from scipy.stats import uniform, invgauss # Data np.random.seed(1056) # set seed to replicate example nobs= 1000 # number of obs in model x1 = uniform.rvs(size=nobs) # random uniform variable beta0 = 1.0 beta1 = 0.5 l1 = 20 xb = beta0 + beta1 * x1 # linear predictor, xb exb = np.exp(xb) y = invgauss.rvs(exb/l1, scale=l1) # create response variable # Fit stan_data = {} # build data dictionary stan_data['Y'] = y # response variable stan_data['x1'] = x1 # explanatory variable stan_data['N'] = nobs # sample size # Stan code stan_code = """ data{ int<lower=0> N; vector[N] Y; vector[N] x1; } parameters{
# Display the probability density function (``pdf``): x = np.linspace(invgauss.ppf(0.01, mu), invgauss.ppf(0.99, mu), 100) ax.plot(x, invgauss.pdf(x, mu), 'r-', lw=5, alpha=0.6, label='invgauss pdf') # Alternatively, the distribution object can be called (as a function) # to fix the shape, location and scale parameters. This returns a "frozen" # RV object holding the given parameters fixed. # Freeze the distribution and display the frozen ``pdf``: rv = invgauss(mu) ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf') # Check accuracy of ``cdf`` and ``ppf``: vals = invgauss.ppf([0.001, 0.5, 0.999], mu) np.allclose([0.001, 0.5, 0.999], invgauss.cdf(vals, mu)) # True # Generate random numbers: r = invgauss.rvs(mu, size=1000) # And compare the histogram: ax.hist(r, density=True, histtype='stepfilled', alpha=0.2) ax.legend(loc='best', frameon=False) plt.show()
from scipy.stats import invgauss import matplotlib.pyplot as plt import numpy as np #invgauss.pdf(x, mu) = 1 / sqrt(2*pi*x**3) * exp(-(x-mu)**2/(2*x*mu**2)) fig, ax = plt.subplots(1, 1) mu = 1 x = np.linspace(invgauss.pdf(0.01, mu),invgauss.pdf(0.99, mu), 100) ax.plot(x, invgauss.pdf(x, mu),'r-', lw=5, alpha=0.6, label='invgauss pdf') rv = invgauss(mu) ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf') r = invgauss.rvs(mu, size=1000) ax.hist(r, normed=True, histtype='stepfilled', alpha=0.2) ax.legend(loc='best', frameon=False) plt.show()
def simulate_trial(parameters, values, gaze, boundary=1, error_weight=0.05, error_range=(0, 5)): """ Predict choice and resonse time with the GLAM for a trial, ǵiven a set of parameter estimates, trial values, and gazes Input --- parameters : array_like set of parameter estimates to use values : array_like value of each choice alternative gaze : array_like gaze of each choice alternative boundary : float decision boundary in linear stochastic race, defaults to 1 error_weight : float, optional probability that choice and RT are simulated according to an errornous response model, which makes a random choice at a random time point, defaults to 0.05 (5%) error_range : tuple, optional time range (in seconds) for errornous response model, defaults to (0,5) Returns --- choice and RT """ v, gamma, s, tau, t0 = parameters n_items = len(values) if np.random.uniform(0, 1) < error_weight: rt = np.random.uniform(*error_range) choice = np.random.choice(n_items) else: rt = np.nan while np.isnan(rt): R = make_R(v, tau, gamma, values, gaze) FPTs = np.zeros(n_items) * np.nan for i in range(n_items): mu = boundary / R[i] lam = (boundary / s)**2 FPTs[i] = invgauss.rvs(mu=mu / lam, scale=lam) rt = np.min(FPTs) if rt < 0 or not np.isfinite(rt): rt = np.nan choice = np.nan else: choice = np.argmin(FPTs) rt = rt + t0 return choice, rt
def initialSpikeGeneration(self, numberOfSpikesPerNeuron, meanTime, synchronny, typeOfDraw, a, b, exciteExciteAmplitude, exciteInhibAmplitude): ''' Generates the intital excitation spikes aka fake neurons Also will write the spike times to a file. This is accomplished here instead of the write function because the master list of spike times gets destroyed in the run process (Note: as of the latest update, we are now keeping a dead copy of the initial spike time list, because it proves better to do so for the synchronny trials, however, because the current write function works perfectly, I have not changed it to use the dead copy). This method is now also responsible for the amplitudes of the fake neurons Note: Fake neurons are essentially the ones created in the initial spike generation they aren't really modelable neurons. The are quite literally a list of when to send currents to the 'real' neurons of the entire system ''' self.fakeExciteAmplitude = exciteExciteAmplitude self.fakeInhibAmplitude = exciteInhibAmplitude # Cleans out pre-existing fake neuron data for file in self.os.listdir(self.networkID + '/FakeNeuronSpikes/'): self.os.remove("FakeNeuronSpikes/" + file) # for type of draw: # 1 = Gaussian # 2 = Exponential # 3 = Uniform # 4 = Inverse Gauss if meanTime > self.duration: print( "\nError: Your mean time is greater than the duration, \nand you can ignore the next error statement" ) return self.arrayOfInitialSpikeTimes = [] self.deadCopyOfArrayOfInitialSpikeTimes = [] # Essentially the "for loop's" job is to iterate once for every single # neuron in the list of all Neurons # The "while loop" will loop the amount of times as spikes desired per neuron # for every "for" iteration, one temporary list will store the spike times # and the id number for the neuron to recieve those spikes. At then end # of the single for iteration, the temporary list will be appended to the # master list of spike times. for x in range(len(self.listOfNeurons) - 1): # Fist Write is used to help keep a csv format self.firstWrite = True excitationSpikesdataFile = open( "FakeNeuronSpikes/excitationSpike" + str(x + 1) + ".txt", "w") numberOfSpikesGenerated = 0 individualNeuronSpikeTimeList = [] while (numberOfSpikesGenerated != numberOfSpikesPerNeuron): # Drawing excitation spikes from the chosen distribution if typeOfDraw == 1: spikeTime = random.gauss(meanTime, synchronny) elif typeOfDraw == 2: spikeTime = random.expovariate(meanTime) elif typeOfDraw == 3: spikeTime = random.uniform(a, b) elif typeOfDraw == 4: spikeTime = invgauss.rvs(meanTime) else: raise ValueError( "Initial Spike Gen Error: your requested draw type does not exist" ) # Makes sure the spike time is not out of bounds if (spikeTime > 0 and spikeTime < self.duration): individualNeuronSpikeTimeList.append(spikeTime) # This if else structure is meant to help keep the csv format # the first time a number is written to a file, on the number # char is written. Spaces and commas are only added from the # second write and on. if self.firstWrite == True: excitationSpikesdataFile.write(str(spikeTime)) self.firstWrite = False else: excitationSpikesdataFile.write(", " + str(spikeTime)) individualNeuronSpikeTimeList.append(x) self.arrayOfInitialSpikeTimes.append( individualNeuronSpikeTimeList) numberOfSpikesGenerated += 1 individualNeuronSpikeTimeList = [] excitationSpikesdataFile.close() # Creating the dead copy, so we can still use the information even after the loss of the original spike time list # I am taking the copy before sorting because that way, its easier to process for the required data because it's # ordered for the neurons and not the spike times. self.deadCopyOfArrayOfInitialSpikeTimes = list( self.arrayOfInitialSpikeTimes) # Sorts the array, but because the addresses have been appended to the # spike times, the user specified distribution is still preserved. self.arrayOfInitialSpikeTimes.sort()
def bootstrap(a, f=None, b=100, method="balanced", family=None, strata=None, smooth=False, random_state=None): """ Calculate function values from bootstrap samples or optionally return bootstrap samples themselves Parameters ---------- a : array-like Original sample f : callable or None Function to be bootstrapped b : int Number of bootstrap samples method : string * 'ordinary' * 'balanced' * 'parametric' family : string or None * 'gaussian' * 't' * 'laplace' * 'logistic' * 'F' * 'gamma' * 'log-normal' * 'inverse-gaussian' * 'pareto' * 'beta' * 'poisson' strata : array-like or None Stratification labels, ignored when method is parametric smooth : boolean Whether or not to add noise to bootstrap samples, ignored when method is parametric random_state : int or None Random number seed Returns ------- y | X : np.array Function applied to each bootstrap sample or bootstrap samples if f is None """ np.random.seed(random_state) a = np.asarray(a) n = len(a) # stratification not meaningful for parametric sampling if strata is not None and (method != "parametric"): strata = np.asarray(strata) if len(strata) != len(a): raise ValueError("a and strata must have" " the same length") # recursively call bootstrap without stratification # on the different strata masks = [strata == x for x in np.unique(strata)] boot_strata = [ bootstrap(a=a[m], f=None, b=b, method=method, strata=None, random_state=random_state) for m in masks ] # concatenate resampled strata along first column axis X = np.concatenate(boot_strata, axis=1) else: if method == "ordinary": # i.i.d. sampling from ecdf of a X = np.reshape(a[np.random.choice(range(a.shape[0]), a.shape[0] * b)], newshape=(b, ) + a.shape) elif method == "balanced": # permute b concatenated copies of a r = np.reshape([a] * b, newshape=(b * a.shape[0], ) + a.shape[1:]) X = np.reshape(r[np.random.permutation(range(r.shape[0]))], newshape=(b, ) + a.shape) elif method == "parametric": if len(a.shape) > 1: raise ValueError("a must be one-dimensional") # fit parameters by maximum likelihood and sample if family == "gaussian": theta = norm.fit(a) arr = norm.rvs(size=n * b, loc=theta[0], scale=theta[1], random_state=random_state) elif family == "t": theta = t.fit(a, fscale=1) arr = t.rvs(size=n * b, df=theta[0], loc=theta[1], scale=theta[2], random_state=random_state) elif family == "laplace": theta = laplace.fit(a) arr = laplace.rvs(size=n * b, loc=theta[0], scale=theta[1], random_state=random_state) elif family == "logistic": theta = logistic.fit(a) arr = logistic.rvs(size=n * b, loc=theta[0], scale=theta[1], random_state=random_state) elif family == "F": theta = F.fit(a, floc=0, fscale=1) arr = F.rvs(size=n * b, dfn=theta[0], dfd=theta[1], loc=theta[2], scale=theta[3], random_state=random_state) elif family == "gamma": theta = gamma.fit(a, floc=0) arr = gamma.rvs(size=n * b, a=theta[0], loc=theta[1], scale=theta[2], random_state=random_state) elif family == "log-normal": theta = lognorm.fit(a, floc=0) arr = lognorm.rvs(size=n * b, s=theta[0], loc=theta[1], scale=theta[2], random_state=random_state) elif family == "inverse-gaussian": theta = invgauss.fit(a, floc=0) arr = invgauss.rvs(size=n * b, mu=theta[0], loc=theta[1], scale=theta[2], random_state=random_state) elif family == "pareto": theta = pareto.fit(a, floc=0) arr = pareto.rvs(size=n * b, b=theta[0], loc=theta[1], scale=theta[2], random_state=random_state) elif family == "beta": theta = beta.fit(a) arr = beta.rvs(size=n * b, a=theta[0], b=theta[1], loc=theta[2], scale=theta[3], random_state=random_state) elif family == "poisson": theta = np.mean(a) arr = poisson.rvs(size=n * b, mu=theta, random_state=random_state) else: raise ValueError("Invalid family") X = np.reshape(arr, newshape=(b, n)) else: raise ValueError("method must be either 'ordinary'" " , 'balanced', or 'parametric'," " '{method}' was supplied".format(method=method)) # samples are already smooth in the parametric case if smooth and (method != "parametric"): X += np.random.normal(size=X.shape, scale=1 / np.sqrt(n)) if f is None: return X else: return np.asarray([f(x) for x in X])
# Python import numpy as np from scipy.stats import invgauss, norm, binom from scipy.optimize import minimize from numpy import log, exp, apply_along_axis, mean, median, std, quantile from math import pi, isnan np.random.seed(111) n = 100 t0 = 0.35 t = invgauss.rvs(mu=0.5, scale=1, size=n) + t0 def minus_loglik(parms): z = parms[0] v = parms[1] t0 = parms[2] return -sum( log(z * (2 * pi * (t - t0)**3)**(-0.5) * exp(-(v * (t - t0) - z)**2 / 2 / (t - t0)))) init = [.5, 1.2, .3] fit = minimize(minus_loglik, init, method="nelder-mead") print(fit.x)
from scipy.stats import pearsonr from scipy.stats import invgauss from scipy.stats import norm vector = [1, 23, 4, 13, 9, 7, 7, 13, 4, 23, 1, 23, 1, 23, 3, 23] print('Vector {}'.format(vector)) print('Average of the vector is {}'.format(statistics.mean(vector))) print('Mode of the vector is {}'.format(statistics.mode(vector))) print('Median of the vector is {}'.format(statistics.median(vector))) print('Standard deviation (sigma) of the vector is {}'.format(statistics.stdev(vector))) vector_one = [1, 2, 3] vector_two = [4, 5, 6] vector_three = [9, 8, 7] print('Positive correlation with pearson between {} and {} is {}'.format(vector_one, vector_two, pearsonr(vector_one, vector_two))) print('Negative correlation with pearson between {} and {} is {}'.format(vector_one, vector_three, pearsonr(vector_one, vector_three))) print('Random number {}'.format(random.random())) invgauss_mu = 10 invgauss_loc = 10 print('Gaussian random number {}'.format(invgauss.rvs(invgauss_mu, invgauss_loc))) norm_loc = 10 print('Normal distribution random variates {}'.format(norm.rvs(norm_loc)))
def rvs(self, shape): return invgauss.rvs(mu=shape)
def inv_norm_dist(x, mean): np.random.seed(42) y = invgauss.rvs(mean, size=len(x)) y = np.array(sorted(y)) y = np.clip(y, 0, 1) return y