def natural_spline(tvals, knots=None, order=3, intercept=True): """ Create a design matrix with columns given by a natural spline of a given order and a specified set of knots. Parameters ---------- tvals : np.array Time values knots : None or sequence, optional Sequence of float. Default None (same as empty list) order : int, optional Order of the spline. Defaults to a cubic (==3) intercept : bool, optional If True, include a constant function in the natural spline. Default is False Returns ------- X : np.ndarray Examples -------- >>> tvals = np.linspace(0,50,101) >>> drift = natural_spline(tvals, knots=[10,20,30,40]) >>> drift.shape (101, 8) """ tvals = make_recarray(tvals, ['t']) t = Term('t') f = formulae.natural_spline(t, knots=knots, order=order, intercept=intercept) return f.design(tvals, return_float=True)
def natural_spline(tvals, knots=None, order=3, intercept=True): """ Create a design matrix with columns given by a natural spline of a given order and a specified set of knots. Parameters ---------- tvals : np.array Time values knots : None or sequence, optional Sequence of float. Default None (same as empty list) order : int, optional Order of the spline. Defaults to a cubic (==3) intercept : bool, optional If True, include a constant function in the natural spline. Default is False Returns ------- X : np.ndarray Examples -------- >>> tvals = np.linspace(0,50,101) >>> drift = natural_spline(tvals, knots=[10,20,30,40]) >>> drift.shape (101, 8) """ tvals = make_recarray(tvals, ['t']) t = Term('t') f = formulae.natural_spline(t, knots=knots, order=order, intercept=intercept) return f.design(tvals, return_float=True)
def protocol(recarr, design_type, *hrfs): """ Create an object that can evaluate the FIAC Subclass of formulae.Formula, but not necessary. Parameters ---------- recarr : (N,) structured array with fields 'time' and 'event' design_type : str one of ['event', 'block']. Handles how the 'begin' term is handled. For 'block', the first event of each block is put in this group. For the 'event', only the first event is put in this group. The 'begin' events are convolved with hrf.glover. hrfs: symoblic HRFs Each event type ('SSt_SSp','SSt_DSp','DSt_SSp','DSt_DSp') is convolved with each of these HRFs in order. Returns ------- f: Formula Formula for constructing design matrices. contrasts : dict Dictionary of the contrasts of the experiment. """ event_types = np.unique(recarr['event']) N = recarr.size if design_type == 'block': keep = np.not_equal((np.arange(N)) % 6, 0) else: keep = np.greater(np.arange(N), 0) # This first frame was used to model out a potentially # 'bad' first frame.... _begin = recarr['time'][~keep] termdict = {} termdict['begin'] = utils.define('begin', utils.events(_begin, f=hrf.glover)) drift = formulae.natural_spline(utils.T, knots=[N_ROWS/2.+1.25], intercept=True) for i, t in enumerate(drift.terms): termdict['drift%d' % i] = t # After removing the first frame, keep the remaining # events and times times = recarr['time'][keep] events = recarr['event'][keep] # Now, specify the experimental conditions. This creates expressions named # SSt_SSp0, SSt_SSp1, etc. with one expression for each (eventtype, hrf) # pair for v in event_types: k = np.array([events[i] == v for i in range(times.shape[0])]) for l, h in enumerate(hrfs): # Make sure event type is a string (not byte string) term_name = '%s%d' % (to_str(v), l) termdict[term_name] = utils.define(term_name, utils.events(times[k], f=h)) f = formulae.Formula(list(termdict.values())) Tcontrasts = {} Tcontrasts['average'] = (termdict['SSt_SSp0'] + termdict['SSt_DSp0'] + termdict['DSt_SSp0'] + termdict['DSt_DSp0']) / 4. Tcontrasts['speaker'] = (termdict['SSt_DSp0'] - termdict['SSt_SSp0'] + termdict['DSt_DSp0'] - termdict['DSt_SSp0']) * 0.5 Tcontrasts['sentence'] = (termdict['DSt_DSp0'] + termdict['DSt_SSp0'] - termdict['SSt_DSp0'] - termdict['SSt_SSp0']) * 0.5 Tcontrasts['interaction'] = (termdict['SSt_SSp0'] - termdict['SSt_DSp0'] - termdict['DSt_SSp0'] + termdict['DSt_DSp0']) # Ftest Fcontrasts = {} Fcontrasts['overall1'] = formulae.Formula(list(Tcontrasts.values())) return f, Tcontrasts, Fcontrasts
def altprotocol(d, design_type, *hrfs): """ Create an object that can evaluate the FIAC. Subclass of formulae.Formula, but not necessary. Parameters ---------- d : np.recarray recarray defining design in terms of time, sentence speaker design_type : str in ['event', 'block'] Handles how the 'begin' term is handled. For 'block', the first event of each block is put in this group. For the 'event', only the first event is put in this group. The 'begin' events are convolved with hrf.glover. hrfs: symoblic HRFs Each event type ('SSt_SSp','SSt_DSp','DSt_SSp','DSt_DSp') is convolved with each of these HRFs in order. """ if design_type == 'block': keep = np.not_equal((np.arange(d.time.shape[0])) % 6, 0) else: keep = np.greater(np.arange(d.time.shape[0]), 0) # This first frame was used to model out a potentially # 'bad' first frame.... _begin = d.time[~keep] d = d[keep] termdict = {} termdict['begin'] = utils.define('begin', utils.events(_begin, f=hrf.glover)) drift = formulae.natural_spline(utils.T, knots=[N_ROWS/2.+1.25], intercept=True) for i, t in enumerate(drift.terms): termdict['drift%d' % i] = t # Now, specify the experimental conditions # The elements of termdict are DiracDeltas, rather than HRFs st = formulae.Factor('sentence', ['DSt', 'SSt']) sp = formulae.Factor('speaker', ['DSp', 'SSp']) indic = {} indic['sentence'] = st.main_effect indic['speaker'] = sp.main_effect indic['interaction'] = st.main_effect * sp.main_effect indic['average'] = formulae.I for key in indic.keys(): # The matrix signs will be populated with +- 1's # d is the recarray having fields ('time', 'sentence', 'speaker') signs = indic[key].design(d, return_float=True) for l, h in enumerate(hrfs): # symb is a sympy expression representing a sum # of [h(t-_t) for _t in d.time] symb = utils.events(d.time, amplitudes=signs, f=h) # the values of termdict will have keys like # 'average0', 'speaker1' # and values that are sympy expressions like average0(t), # speaker1(t) termdict['%s%d' % (key, l)] = utils.define("%s%d" % (key, l), symb) f = formulae.Formula(list(termdict.values())) Tcontrasts = {} Tcontrasts['average'] = termdict['average0'] Tcontrasts['speaker'] = termdict['speaker0'] Tcontrasts['sentence'] = termdict['sentence0'] Tcontrasts['interaction'] = termdict['interaction0'] # F tests Fcontrasts = {} Fcontrasts['overall1'] = formulae.Formula(list(Tcontrasts.values())) nhrf = len(hrfs) Fcontrasts['averageF'] = formulae.Formula([termdict['average%d' % j] for j in range(nhrf)]) Fcontrasts['speakerF'] = formulae.Formula([termdict['speaker%d' % j] for j in range(nhrf)]) Fcontrasts['sentenceF'] = formulae.Formula([termdict['sentence%d' % j] for j in range(nhrf)]) Fcontrasts['interactionF'] = formulae.Formula([termdict['interaction%d' % j] for j in range(nhrf)]) Fcontrasts['overall2'] = Fcontrasts['averageF'] + Fcontrasts['speakerF'] + Fcontrasts['sentenceF'] + Fcontrasts['interactionF'] return f, Tcontrasts, Fcontrasts
def protocol(recarr, design_type, *hrfs): """ Create an object that can evaluate the FIAC Subclass of formulae.Formula, but not necessary. Parameters ---------- recarr : (N,) structured array with fields 'time' and 'event' design_type : str one of ['event', 'block']. Handles how the 'begin' term is handled. For 'block', the first event of each block is put in this group. For the 'event', only the first event is put in this group. The 'begin' events are convolved with hrf.glover. hrfs: symoblic HRFs Each event type ('SSt_SSp','SSt_DSp','DSt_SSp','DSt_DSp') is convolved with each of these HRFs in order. Returns ------- f: Formula Formula for constructing design matrices. contrasts : dict Dictionary of the contrasts of the experiment. """ event_types = np.unique(recarr['event']) N = recarr.size if design_type == 'block': keep = np.not_equal((np.arange(N)) % 6, 0) else: keep = np.greater(np.arange(N), 0) # This first frame was used to model out a potentially # 'bad' first frame.... _begin = recarr['time'][~keep] termdict = {} termdict['begin'] = utils.define('begin', utils.events(_begin, f=hrf.glover)) drift = formulae.natural_spline(utils.T, knots=[N_ROWS / 2. + 1.25], intercept=True) for i, t in enumerate(drift.terms): termdict['drift%d' % i] = t # After removing the first frame, keep the remaining # events and times times = recarr['time'][keep] events = recarr['event'][keep] # Now, specify the experimental conditions. This creates expressions named # SSt_SSp0, SSt_SSp1, etc. with one expression for each (eventtype, hrf) # pair for v in event_types: k = np.array([events[i] == v for i in range(times.shape[0])]) for l, h in enumerate(hrfs): # Make sure event type is a string (not byte string) term_name = '%s%d' % (to_str(v), l) termdict[term_name] = utils.define(term_name, utils.events(times[k], f=h)) f = formulae.Formula(list(termdict.values())) Tcontrasts = {} Tcontrasts['average'] = (termdict['SSt_SSp0'] + termdict['SSt_DSp0'] + termdict['DSt_SSp0'] + termdict['DSt_DSp0']) / 4. Tcontrasts['speaker'] = (termdict['SSt_DSp0'] - termdict['SSt_SSp0'] + termdict['DSt_DSp0'] - termdict['DSt_SSp0']) * 0.5 Tcontrasts['sentence'] = (termdict['DSt_DSp0'] + termdict['DSt_SSp0'] - termdict['SSt_DSp0'] - termdict['SSt_SSp0']) * 0.5 Tcontrasts['interaction'] = (termdict['SSt_SSp0'] - termdict['SSt_DSp0'] - termdict['DSt_SSp0'] + termdict['DSt_DSp0']) # Ftest Fcontrasts = {} Fcontrasts['overall1'] = formulae.Formula(list(Tcontrasts.values())) return f, Tcontrasts, Fcontrasts
def altprotocol(d, design_type, *hrfs): """ Create an object that can evaluate the FIAC. Subclass of formulae.Formula, but not necessary. Parameters ---------- d : np.recarray recarray defining design in terms of time, sentence speaker design_type : str in ['event', 'block'] Handles how the 'begin' term is handled. For 'block', the first event of each block is put in this group. For the 'event', only the first event is put in this group. The 'begin' events are convolved with hrf.glover. hrfs: symoblic HRFs Each event type ('SSt_SSp','SSt_DSp','DSt_SSp','DSt_DSp') is convolved with each of these HRFs in order. """ if design_type == 'block': keep = np.not_equal((np.arange(d.time.shape[0])) % 6, 0) else: keep = np.greater(np.arange(d.time.shape[0]), 0) # This first frame was used to model out a potentially # 'bad' first frame.... _begin = d.time[~keep] d = d[keep] termdict = {} termdict['begin'] = utils.define('begin', utils.events(_begin, f=hrf.glover)) drift = formulae.natural_spline(utils.T, knots=[N_ROWS / 2. + 1.25], intercept=True) for i, t in enumerate(drift.terms): termdict['drift%d' % i] = t # Now, specify the experimental conditions # The elements of termdict are DiracDeltas, rather than HRFs st = formulae.Factor('sentence', ['DSt', 'SSt']) sp = formulae.Factor('speaker', ['DSp', 'SSp']) indic = {} indic['sentence'] = st.main_effect indic['speaker'] = sp.main_effect indic['interaction'] = st.main_effect * sp.main_effect indic['average'] = formulae.I for key in indic.keys(): # The matrix signs will be populated with +- 1's # d is the recarray having fields ('time', 'sentence', 'speaker') signs = indic[key].design(d, return_float=True) for l, h in enumerate(hrfs): # symb is a sympy expression representing a sum # of [h(t-_t) for _t in d.time] symb = utils.events(d.time, amplitudes=signs, f=h) # the values of termdict will have keys like # 'average0', 'speaker1' # and values that are sympy expressions like average0(t), # speaker1(t) termdict['%s%d' % (key, l)] = utils.define("%s%d" % (key, l), symb) f = formulae.Formula(list(termdict.values())) Tcontrasts = {} Tcontrasts['average'] = termdict['average0'] Tcontrasts['speaker'] = termdict['speaker0'] Tcontrasts['sentence'] = termdict['sentence0'] Tcontrasts['interaction'] = termdict['interaction0'] # F tests Fcontrasts = {} Fcontrasts['overall1'] = formulae.Formula(list(Tcontrasts.values())) nhrf = len(hrfs) Fcontrasts['averageF'] = formulae.Formula( [termdict['average%d' % j] for j in range(nhrf)]) Fcontrasts['speakerF'] = formulae.Formula( [termdict['speaker%d' % j] for j in range(nhrf)]) Fcontrasts['sentenceF'] = formulae.Formula( [termdict['sentence%d' % j] for j in range(nhrf)]) Fcontrasts['interactionF'] = formulae.Formula( [termdict['interaction%d' % j] for j in range(nhrf)]) Fcontrasts['overall2'] = Fcontrasts['averageF'] + Fcontrasts[ 'speakerF'] + Fcontrasts['sentenceF'] + Fcontrasts['interactionF'] return f, Tcontrasts, Fcontrasts