def test_natural_spline():
xt=F.Term('x')
ns=F.natural_spline(xt, knots=[2,6,9])
xx= F.make_recarray(np.linspace(0,10,101), 'x')
dd=ns.design(xx, return_float=True)
xx = xx['x']
yield assert_almost_equal, dd[:,0], xx
yield assert_almost_equal, dd[:,1], xx**2
yield assert_almost_equal, dd[:,2], xx**3
yield assert_almost_equal, dd[:,3], (xx-2)**3*np.greater_equal(xx,2)
yield assert_almost_equal, dd[:,4], (xx-6)**3*np.greater_equal(xx,6)
yield assert_almost_equal, dd[:,5], (xx-9)**3*np.greater_equal(xx,9)
ns=F.natural_spline(xt, knots=[2,9,6], intercept=True)
xx= F.make_recarray(np.linspace(0,10,101), 'x')
dd=ns.design(xx, return_float=True)
xx = xx['x']
yield assert_almost_equal, dd[:,0], 1
yield assert_almost_equal, dd[:,1], xx
yield assert_almost_equal, dd[:,2], xx**2
yield assert_almost_equal, dd[:,3], xx**3
yield assert_almost_equal, dd[:,4], (xx-2)**3*np.greater_equal(xx,2)
yield assert_almost_equal, dd[:,5], (xx-9)**3*np.greater_equal(xx,9)
yield assert_almost_equal, dd[:,6], (xx-6)**3*np.greater_equal(xx,6)
def protocol(recarr, design_type, *hrfs):
""" Create an object that can evaluate the FIAC
Subclass of formula.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 = formula.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:
for l, h in enumerate(hrfs):
k = np.array([events[i] == v for i in
range(times.shape[0])])
termdict['%s%d' % (v,l)] = utils.define("%s%d" % (v, l),
utils.events(times[k], f=h))
f = formula.Formula(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'] = formula.Formula(Tcontrasts.values())
return f, Tcontrasts, Fcontrasts
def altprotocol(d, design_type, *hrfs):
""" Create an object that can evaluate the FIAC.
Subclass of formula.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 = formula.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 = formula.Factor('sentence', ['DSt', 'SSt'])
sp = formula.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'] = formula.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 = formula.Formula(termdict.values())
Tcontrasts = {}
Tcontrasts['average'] = termdict['average0']
Tcontrasts['speaker'] = termdict['speaker0']
Tcontrasts['sentence'] = termdict['sentence0']
Tcontrasts['interaction'] = termdict['interaction0']
# F tests
Fcontrasts = {}
Fcontrasts['overall1'] = formula.Formula(Tcontrasts.values())
nhrf = len(hrfs)
Fcontrasts['averageF'] = formula.Formula([termdict['average%d' % j] for j in range(nhrf)])
Fcontrasts['speakerF'] = formula.Formula([termdict['speaker%d' % j] for j in range(nhrf)])
Fcontrasts['sentenceF'] = formula.Formula([termdict['sentence%d' % j] for j in range(nhrf)])
Fcontrasts['interactionF'] = formula.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(fh, design_type, *hrfs):
"""
Create an object that can evaluate the FIAC.
Subclass of formula.Formula, but not necessary.
Parameters:
-----------
fh : file handler
File-like object that reads in the FIAC design,
i.e. like file('subj1_evt_fonc3.txt')
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.
Outputs:
--------
f: Formula
Formula for constructing design matrices.
contrasts : dict
Dictionary of the contrasts of the experiment.
"""
eventdict = {1: "SSt_SSp", 2: "SSt_DSp", 3: "DSt_SSp", 4: "DSt_DSp"}
fh = fh.read().strip().splitlines()
times = []
events = []
for row in fh:
time, eventtype = map(float, row.split())
times.append(time)
events.append(eventdict[eventtype])
if design_type == "block":
keep = np.not_equal((np.arange(len(times))) % 6, 0)
else:
keep = np.greater(np.arange(len(times)), 0)
# This first frame was used to model out a potentially
# 'bad' first frame....
_begin = np.array(times)[~keep]
termdict = {}
termdict["begin"] = formula.define("begin", utils.events(_begin, f=hrf.glover))
drift = formula.natural_spline(hrf.t, knots=[191 / 2.0 + 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 = np.array(times)[keep]
events = np.array(events)[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 eventdict.values():
for l, h in enumerate(hrfs):
k = np.array([events[i] == v for i in range(times.shape[0])])
termdict["%s%d" % (v, l)] = formula.define("%s%d" % (v, l), utils.events(times[k], f=h))
f = formula.Formula(termdict.values())
Tcontrasts = {}
Tcontrasts["average"] = (
termdict["SSt_SSp0"] + termdict["SSt_DSp0"] + termdict["DSt_SSp0"] + termdict["DSt_DSp0"]
) / 4.0
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"] = formula.Formula(Tcontrasts.values())
return f, Tcontrasts, Fcontrasts
def altprotocol(fh, design_type, *hrfs):
"""
Create an object that can evaluate the FIAC.
Subclass of formula.Formula, but not necessary.
Parameters:
-----------
fh : file handler
File-like object that reads in the FIAC design,
but has a different format (test_FIACdata.altdescr)
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.
"""
d = csv2rec(fh)
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"] = formula.define("begin", utils.events(_begin, f=hrf.glover))
drift = formula.natural_spline(hrf.t, knots=[191 / 2.0 + 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 = formula.Factor("sentence", ["DSt", "SSt"])
sp = formula.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"] = formula.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)] = formula.define("%s%d" % (key, l), symb)
f = formula.Formula(termdict.values())
Tcontrasts = {}
Tcontrasts["average"] = termdict["average0"]
Tcontrasts["speaker"] = termdict["speaker0"]
Tcontrasts["sentence"] = termdict["sentence0"]
Tcontrasts["interaction"] = termdict["interaction0"]
# F tests
Fcontrasts = {}
Fcontrasts["overall1"] = formula.Formula(Tcontrasts.values())
nhrf = len(hrfs)
Fcontrasts["averageF"] = formula.Formula([termdict["average%d" % j] for j in range(nhrf)])
Fcontrasts["speakerF"] = formula.Formula([termdict["speaker%d" % j] for j in range(nhrf)])
Fcontrasts["sentenceF"] = formula.Formula([termdict["sentence%d" % j] for j in range(nhrf)])
Fcontrasts["interactionF"] = formula.Formula([termdict["interaction%d" % j] for j in range(nhrf)])
Fcontrasts["overall2"] = (
Fcontrasts["averageF"] + Fcontrasts["speakerF"] + Fcontrasts["sentenceF"] + Fcontrasts["interactionF"]
)
return f, Tcontrasts, Fcontrasts
