def ar1(N, alpha=0.2, sigma=1, prng=None): """ Create AR1 noise. Parameters --------- N : numeric Length of 1d noise array to return alpha : float Degree of autocorrelation sigma : numeric Standard deviation of white noise prng : np.random.RandomState, None A RandomState instance, or None Alpha of 0.2 was taken from the 'temporalnoise.R' function in the R neuRosim package (ver 02-10) """ if (alpha > 1) or (alpha < 0): raise ValueError("alpha must be between 0-1.") prng = process_prng(prng) noise, prng = white(N=N, sigma=sigma, prng=prng) arnoise = [noise[0], ] [arnoise.append( noise[ii] + (alpha * noise[ii-1]) ) for ii in range(1, len(noise))] return arnoise, prng
def learn(N, k, loc=3, prng=None): """Simulate learning behavior""" prng = process_prng(prng) trials, prng = tlib.random(N, k, prng=prng) trials, prng = tlib.jitter(trials, prng=prng) l = trials.shape[0] acc = np.zeros(l) p = np.zeros(l) conds = np.unique(trials) for n in conds: ## Skip null trials if (n == 0) | (n == '0'): continue p_n, prng = probability.learn(k, loc, prng=prng) acc_n, prng = acclib.accuracy(p_n, prng=prng) for t in enumerate(trials): acc[trials == n] = acc_n p[trials == n] = p_n return trials, acc, p, prng
def learn(N, loc=3, prng=None): """Simulate learning moving p(correct) from random to a sigmoid Note ---- * Transition from random to learn is itself random, sampled from uniform(1, N). * loc of 3 gives 'realistic' learning curves """ prng = process_prng(prng) np.random.set_state(prng.get_state()) # Random and learn are divided by T T = int(prng.randint(0, N, 1)) # Random p p_1, prng = random(T, prng) # Learn p trials = np.arange(.01, 10, (10/float(N - T))) trials = trials + stats.norm.rvs(size=trials.shape[0]) p_2 = stats.norm.cdf(trials,loc) p_2[p_2 < 0.5] = prng.rand(np.sum(p_2 < 0.5)) ## Remove p vals les than 0.5 otherwise ## p drops badly as learning is suppose ## to start prng.set_state(np.random.get_state()) return np.concatenate([p_1, p_2]), prng
def random(N, k, prng=None): """Creates a randomly list of trials (int) of N cond with k trials / cond. """ prng = process_prng(prng) trials = [] [trials.extend([n, ] * k) for n in range(1, N+1)] trials = np.asarray(trials) prng.shuffle(trials) return trials, prng
def white(N, sigma=1, prng=None): """ Create white noise. Parameters --------- N : numeric Length of 1d noise array to return sigma : numeric Standard deviation prng : np.random.RandomState, None A RandomState instance, or None """ prng = process_prng(prng) return prng.normal(loc=0, scale=sigma, size=N), prng
def jitter(trials, code=0, fraction=.5, jit=(1,7), prng=None): """Introduce random (uniform) jitter to trials""" prng = process_prng(prng) jittimes = np.arange(*jit, dtype=np.int) jittered = [] for t in trials: if fraction >= prng.rand(1): prng.shuffle(jittimes) jt = [t, ] + [code, ] * jittimes[0] jittered.extend(jt) else: jittered.append(t) return np.asarray(jittered), prng
def rescorla_wagner(trials, acc, p, alpha=None, prng=None): """Create a RW learning dataset Parameters ---------- trials : list([int, ]) Trials coded by condition acc : list([int((0,1)), ]) Accuracy data p : list([float]) p(correct) alpha : float, None The learning rate (None fits by ML) """ prng = process_prng(prng) l = trials.shape[0] # fit RW models? if alpha is None: best_rl_pars, best_logL = rl.fit.ml_delta(acc, trials, 0.05) v_dict, rpe_dict = rl.reinforce.b_delta(acc, trials, best_rl_pars[0]) else: best_rl_pars, best_logL = None, None v_dict, rpe_dict = rl.reinforce.b_delta(acc, trials, alpha) values = rl.misc.unpack(v_dict, trials) ## Reformat from dict to array rpes = rl.misc.unpack(rpe_dict, trials) # Store sim data box = np.zeros_like(trials) box[trials > 0] = 1 rand = prng.rand(l) df = pd.DataFrame(data={ 'trials' : trials, 'box' : box, 'acc' : acc, 'p' : p, 'value' : np.asarray(values), 'rpe' : np.asarray(rpes), 'rand' : rand }) return df, {'best_rl_pars' : best_rl_pars, 'best_logL' : best_logL}
def _preturb(weight, width=32, TR=1, a1=6.0, a2=12., b1=0.9, b2=0.9, c=0.35, prng=None): prng = process_prng(prng) np.random.set_state(prng.get_state()) # Parameters to preturb params = {a1:6.0, a2:12.0, b1:0.9, b2:0.9, c:0.35} # Preturb it keys = params.keys() prng.shuffle(keys) par = params[keys[0]] params[keys[0]] = prng.normal(loc=par, scale=par / (1. * weight)) # Add unpreturbed params params['width'] = width params['TR'] = TR return params, prng
def lowfreqdrift(N, TR=1, sigma=1, prng=None): """ Create noise with a low frequency drift (0.002-0.015 Hz) Parameters --------- N : numeric Length of 1d noise array to return TR : float The repetition rate (BOLD signal) prng : np.random.RandomState, None A RandomState instance, or None Note ---- Smith et al (1999), Investigation of the Low Frequency Drift in fMRI Signal, NeuroImage 9, 526-533. This function was ported form a similar function ('lowfreqdrift.R') in the R 'neuRosim' package (ver 02-10): http://cran.r-project.org/web/packages/neuRosim/index.html """ prng = process_prng(prng) freq = prng.randint(66, 500) ## i.e. 0.002-0.015 Hz nbasis = int(np.floor(2 * (N * TR) / freq + 1)) noise = _gen_drifts(N, nbasis) noise = noise[:,1:] ## Drop the first col noise = noise.sum(1) ## Sum the rows, creating ## creating the final noise # Now add white noise whiten, prng = white(N, sigma=sigma, prng=prng) noise += whiten return noise, prng
def random(N, k, prng=None): """Simulate random behavior Parameters ---------- N : int Number of conditions k : int Number of trials / condition prng : RandomState object, None Explicit passing of random state. None create a new state """ prng = process_prng(prng) trials, prng = tlib.random(N, k, prng=prng) trials, prng = tlib.jitter(trials, prng=prng) l = trials.shape[0] acc = np.zeros(l) p = np.zeros(l) conds = np.unique(trials) for n in conds: ## Skip null trials if (n == 0) | (n == '0'): continue p_n, prng = probability.random(k, prng=prng) acc_n, prng = acclib.accuracy(p_n, prng=prng) for t in enumerate(trials): acc[trials == n] = acc_n p[trials == n] = p_n return trials, acc, p, prng
def random(N, prng=None): """Create N p(correct) sampled from a uniform distribution (0-1)""" prng = process_prng(prng) return prng.rand(N), prng
def accuracy(p, prng=None): prng = process_prng(prng) N = len(p) return prng.binomial(1, p, N), prng