def test_design():
# Check that you get the design matrix we expect
t1 = F.Term("x")
t2 = F.Term('y')
n = F.make_recarray([2,4,5], 'x')
yield assert_almost_equal, t1.formula.design(n)['x'], n['x']
f = t1.formula + t2.formula
n = F.make_recarray([(2,3),(4,5),(5,6)], 'xy')
yield assert_almost_equal, f.design(n)['x'], n['x']
yield assert_almost_equal, f.design(n)['y'], n['y']
f = t1.formula + t2.formula + F.I + t1.formula * t2.formula
yield assert_almost_equal, f.design(n)['x'], n['x']
yield assert_almost_equal, f.design(n)['y'], n['y']
yield assert_almost_equal, f.design(n)['1'], 1
yield assert_almost_equal, f.design(n)['x*y'], n['x']*n['y']
ny = ML.rec_drop_fields(n, 'y')
yield assert_raises, ValueError, f.design, ny
n = np.array([(2,3,'a'),(4,5,'b'),(5,6,'a')], np.dtype([('x', np.float),
('y', np.float),
('f', 'S1')]))
f = F.Factor('f', ['a','b'])
ff = t1.formula * f + F.I
yield assert_almost_equal, ff.design(n)['f_a*x'], n['x']*[1,0,1]
yield assert_almost_equal, ff.design(n)['f_b*x'], n['x']*[0,1,0]
yield assert_almost_equal, ff.design(n)['1'], 1
def test_nonlin1():
# Fit an exponential curve, with the exponent stratified by a factor
# with a common intercept and multiplicative factor in front of the
# exponential
x = F.Term('x')
fac = F.Factor('f', 'ab')
f = F.Formula([sympy.exp(fac.stratify(x).mean)]) + F.I
params = F.getparams(f.mean)
yield assert_equal, set([str(p) for p in params]), set(['_x0', '_x1', '_b0', '_b1'])
test1 = set(['1',
'exp(_x0*f_a + _x1*f_b)',
'_b0*f_a*exp(_x0*f_a + _x1*f_b)',
'_b0*f_b*exp(_x0*f_a + _x1*f_b)'])
test2 = set(['1',
'exp(_x0*f_a + _x1*f_b)',
'_b1*f_a*exp(_x0*f_a + _x1*f_b)',
'_b1*f_b*exp(_x0*f_a + _x1*f_b)'])
yield assert_true, test1 or test2
n = F.make_recarray([(2,3,'a'),(4,5,'b'),(5,6,'a')], 'xyf', ['d','d','S1'])
p = F.make_recarray([1,2,3,4], ['_x0', '_x1', '_b0', '_b1'])
A = f.design(n, p)
print A, A.dtype
def test_make_recarray():
m = F.make_recarray([[3, 4], [4, 6], [7, 9]], "wv", [np.float, np.int])
yield assert_equal, m.dtype.names, ["w", "v"]
m2 = F.make_recarray(m, "xy")
yield assert_equal, m2.dtype.names, ["x", "y"]
def test_contrast1():
x = F.Term('x')
yield assert_equal, x, x+x
y = F.Term('y')
z = F.Term('z')
f = F.Formula([x,y])
arr = F.make_recarray([[3,5,4],[8,21,-1],[4,6,-2]], 'xyz')
D, C = f.design(arr, contrasts={'x':x.formula,
'diff':F.Formula([x-y]),
'sum':F.Formula([x+y]),
'both':F.Formula([x-y,x+y])})
yield assert_almost_equal, C['x'], np.array([1,0])
yield assert_almost_equal, C['diff'], np.array([1,-1])
yield assert_almost_equal, C['sum'], np.array([1,1])
yield assert_almost_equal, C['both'], np.array([[1,-1],[1,1]])
f = F.Formula([x,y,z])
arr = F.make_recarray([[3,5,4],[8,21,-1],[4,6,-2]], 'xyz')
D, C = f.design(arr, contrasts={'x':x.formula,
'diff':F.Formula([x-y]),
'sum':F.Formula([x+y]),
'both':F.Formula([x-y,x+y])})
yield assert_almost_equal, C['x'], np.array([1,0,0])
yield assert_almost_equal, C['diff'], np.array([1,-1,0])
yield assert_almost_equal, C['sum'], np.array([1,1,0])
yield assert_almost_equal, C['both'], np.array([[1,-1,0],[1,1,0]])
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 test_nonlin2():
dz = F.make_recarray([2, 3, 4], "z")
z = F.Term("z")
t = sympy.Symbol("th")
p = F.make_recarray([3], ["tt"])
f = F.Formula([sympy.exp(t * z)])
yield assert_raises, ValueError, f.design, dz, p
def test_design():
# Check that you get the design matrix we expect
t1 = F.Term("x")
t2 = F.Term("y")
n = F.make_recarray([2, 4, 5], "x")
yield assert_almost_equal, t1.formula.design(n)["x"], n["x"]
f = t1.formula + t2.formula
n = F.make_recarray([(2, 3), (4, 5), (5, 6)], "xy")
yield assert_almost_equal, f.design(n)["x"], n["x"]
yield assert_almost_equal, f.design(n)["y"], n["y"]
f = t1.formula + t2.formula + F.I + t1.formula * t2.formula
yield assert_almost_equal, f.design(n)["x"], n["x"]
yield assert_almost_equal, f.design(n)["y"], n["y"]
yield assert_almost_equal, f.design(n)["1"], 1
yield assert_almost_equal, f.design(n)["x*y"], n["x"] * n["y"]
# drop x field, check that design raises error
ny = np.recarray(n.shape, dtype=[("x", n.dtype["x"])])
ny["x"] = n["x"]
yield assert_raises, ValueError, f.design, ny
n = np.array([(2, 3, "a"), (4, 5, "b"), (5, 6, "a")], np.dtype([("x", np.float), ("y", np.float), ("f", "S1")]))
f = F.Factor("f", ["a", "b"])
ff = t1.formula * f + F.I
yield assert_almost_equal, ff.design(n)["f_a*x"], n["x"] * [1, 0, 1]
yield assert_almost_equal, ff.design(n)["f_b*x"], n["x"] * [0, 1, 0]
yield assert_almost_equal, ff.design(n)["1"], 1
def test_make_recarray():
m = F.make_recarray([[3,4],[4,6],[7,9]], 'wv', [np.float, np.int])
yield assert_equal, m.dtype.names, ['w', 'v']
m2 = F.make_recarray(m, 'xy')
yield assert_equal, m2.dtype.names, ['x', 'y']
def test_nonlin2():
dz = F.make_recarray([2,3,4],'z')
z = F.Term('z')
t = sympy.Symbol('th')
p = F.make_recarray([3], ['tt'])
f = F.Formula([sympy.exp(t*z)])
yield assert_raises, ValueError, f.design, dz, p
def test_nonlin1():
# Fit an exponential curve, with the exponent stratified by a factor
# with a common intercept and multiplicative factor in front of the
# exponential
x = F.Term("x")
fac = F.Factor("f", "ab")
f = F.Formula([sympy.exp(fac.stratify(x).mean)]) + F.I
params = F.getparams(f.mean)
yield assert_equal, set([str(p) for p in params]), set(["_x0", "_x1", "_b0", "_b1"])
test1 = set(["1", "exp(_x0*f_a + _x1*f_b)", "_b0*f_a*exp(_x0*f_a + _x1*f_b)", "_b0*f_b*exp(_x0*f_a + _x1*f_b)"])
test2 = set(["1", "exp(_x0*f_a + _x1*f_b)", "_b1*f_a*exp(_x0*f_a + _x1*f_b)", "_b1*f_b*exp(_x0*f_a + _x1*f_b)"])
yield assert_true, test1 or test2
n = F.make_recarray([(2, 3, "a"), (4, 5, "b"), (5, 6, "a")], "xyf", ["d", "d", "S1"])
p = F.make_recarray([1, 2, 3, 4], ["_x0", "_x1", "_b0", "_b1"])
A = f.design(n, p)
print A, A.dtype
def build_dmtx(form, frametimes):
"""
This is a work arount to control the order of the regressor
in the design matrix construction
Parameters
----------
form: formula.Formula instance,
the formula that describes the design matrix
frametimes: array of shape (nb_time_samples),
the time sampling grid
Returns
-------
X: array of shape (nrows,nb_time_samples)
the resulting matrix
"""
# fixme : workaround to control matrix columns order
t = formula.make_recarray(frametimes, 't')
X = []
for ft in form.terms:
lf = formula.Formula([ft])
X.append(lf.design(t, return_float=True))
X = np.array(X)
return X
def test_alias():
x = F.Term('x')
f = F.aliased_function('f', lambda x: 2*x)
g = F.aliased_function('g', lambda x: np.sqrt(x))
ff = F.Formula([f(x), g(x)**2])
n = F.make_recarray([2,4,5], 'x')
yield assert_almost_equal(ff.design(n)['f(x)'], n['x']*2)
yield assert_almost_equal(ff.design(n)['g(x)**2'], n['x'])
def test_return_float():
x = F.Term("x")
f = F.Formula([x, x ** 2])
xx = F.make_recarray(np.linspace(0, 10, 11), "x")
dtype = f.design(xx).dtype
yield assert_equal, set(dtype.names), set(["x", "x**2"])
dtype = f.design(xx, return_float=True).dtype
yield assert_equal, dtype, np.float
def test_alias():
x = F.Term("x")
f = F.aliased_function("f", lambda x: 2 * x)
g = F.aliased_function("g", lambda x: np.sqrt(x))
ff = F.Formula([f(x), g(x) ** 2])
n = F.make_recarray([2, 4, 5], "x")
yield assert_almost_equal(ff.design(n)["f(x)"], n["x"] * 2)
yield assert_almost_equal(ff.design(n)["g(x)**2"], n["x"])
def test_random_effects():
subj = F.make_recarray([2, 2, 2, 3, 3], "s")
subj_factor = F.Factor("s", [2, 3])
c = F.RandomEffects(subj_factor.terms, sigma=np.array([[4, 1], [1, 6]]))
C = c.cov(subj)
yield assert_almost_equal, C, [[4, 4, 4, 1, 1], [4, 4, 4, 1, 1], [4, 4, 4, 1, 1], [1, 1, 1, 6, 6], [1, 1, 1, 6, 6]]
a = sympy.Symbol("a")
b = sympy.Symbol("b")
c = F.RandomEffects(subj_factor.terms, sigma=np.array([[a, 0], [0, b]]))
C = c.cov(subj)
t = np.equal(C, [[a, a, a, 0, 0], [a, a, a, 0, 0], [a, a, a, 0, 0], [0, 0, 0, b, b], [0, 0, 0, b, b]])
yield assert_true, np.alltrue(t)
def test_contrast1():
x = F.Term("x")
yield assert_equal, x, x + x
y = F.Term("y")
z = F.Term("z")
f = F.Formula([x, y])
arr = F.make_recarray([[3, 5, 4], [8, 21, -1], [4, 6, -2]], "xyz")
D, C = f.design(
arr,
contrasts={
"x": x.formula,
"diff": F.Formula([x - y]),
"sum": F.Formula([x + y]),
"both": F.Formula([x - y, x + y]),
},
)
yield assert_almost_equal, C["x"], np.array([1, 0])
yield assert_almost_equal, C["diff"], np.array([1, -1])
yield assert_almost_equal, C["sum"], np.array([1, 1])
yield assert_almost_equal, C["both"], np.array([[1, -1], [1, 1]])
f = F.Formula([x, y, z])
arr = F.make_recarray([[3, 5, 4], [8, 21, -1], [4, 6, -2]], "xyz")
D, C = f.design(
arr,
contrasts={
"x": x.formula,
"diff": F.Formula([x - y]),
"sum": F.Formula([x + y]),
"both": F.Formula([x - y, x + y]),
},
)
yield assert_almost_equal, C["x"], np.array([1, 0, 0])
yield assert_almost_equal, C["diff"], np.array([1, -1, 0])
yield assert_almost_equal, C["sum"], np.array([1, 1, 0])
yield assert_almost_equal, C["both"], np.array([[1, -1, 0], [1, 1, 0]])
import numpy as np
import nipy.testing as niptest
import sympy
from nipy.modalities.fmri import formula, utils, hrf
from nipy.modalities.fmri.fmristat import hrf as delay
c1 = utils.events([3,7,10], f=hrf.glover) # Symbolic function of time
c2 = utils.events([1,3,9], f=hrf.glover) # Symbolic function of time
c3 = utils.events([3,4,6], f=delay.spectral[0])
d = utils.fourier_basis([3,5,7]) # Formula
f = formula.Formula([c1,c2,c3]) + d
contrast = formula.Formula([c1-c2, c1-c3])
t = formula.make_recarray(np.linspace(0,20,50), 't')
X, c = f.design(t, return_float=True, contrasts={'C':contrast})
preC = contrast.design(t, return_float=True)
C = np.dot(np.linalg.pinv(X), preC).T
niptest.assert_almost_equal(C, c['C'])
print C
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
# block and event protocols
block, bTcons, bFcons = protocol(descriptions['block'], 'block', *delay.spectral)
event, eTcons, eFcons = protocol(descriptions['event'], 'event', *delay.spectral)
# Now create the design matrices and contrasts
# The 0 indicates that it will be these columns
# convolved with the first HRF
t = formula.make_recarray(time_vector, 't')
X = {}
c = {}
D = {}
for f, cons, design_type in [(block, bTcons, 'block'), (event, eTcons, 'event')]:
X[design_type], c[design_type] = f.design(t, contrasts=cons)
D[design_type] = f.design(t, return_float=False)
def test_altprotocol():
block, bT, bF = protocol(descriptions['block'], 'block', *delay.spectral)
event, eT, eF = protocol(descriptions['event'], 'event', *delay.spectral)
blocka, baT, baF = altprotocol(altdescr['block'], 'block', *delay.spectral)
eventa, eaT, eaF = altprotocol(altdescr['event'], 'event', *delay.spectral)
from nipy.modalities.fmri import utils, formula, hrf
dt = np.random.uniform(low=0, high=2.5, size=(50,))
t = np.cumsum(dt)
a = sympy.Symbol('a')
linear = formula.define('linear', utils.events(t, dt, f=hrf.glover))
quadratic = formula.define('quad', utils.events(t, dt, f=hrf.glover, g=a**2))
cubic = formula.define('cubic', utils.events(t, dt, f=hrf.glover, g=a**3))
f1 = formula.Formula([linear, quadratic, cubic])
# Evaluate them
tval = formula.make_recarray(np.linspace(0,100, 1001), 't')
X1 = f1.design(tval, return_float=True)
# Let's make it exponential with a time constant tau
l = sympy.Symbol('l')
exponential = utils.events(t, dt, f=hrf.glover, g=sympy.exp(-l*a))
f3 = formula.Formula([exponential])
params = formula.make_recarray([(4.5,3.5)], ('l', '_b0'))
X3 = f3.design(tval, params, return_float=True)
# the columns or d/d_b0 and d/dl
tt = tval.view(np.float)
v1 = np.sum([hrf.glovert(tt - s)*np.exp(-4.5*a) for s,a in zip(t, dt)], 0)
from nipy.modalities.fmri import utils, formula, hrf
dt = np.random.uniform(low=0, high=2.5, size=(50,))
t = np.cumsum(dt)
a = sympy.Symbol("a")
linear = formula.define("linear", utils.events(t, dt, f=hrf.glover))
quadratic = formula.define("quad", utils.events(t, dt, f=hrf.glover, g=a ** 2))
cubic = formula.define("cubic", utils.events(t, dt, f=hrf.glover, g=a ** 3))
f1 = formula.Formula([linear, quadratic, cubic])
# Evaluate them
tval = formula.make_recarray(np.linspace(0, 100, 1001), "t")
X1 = f1.design(tval, return_float=True)
# Let's make it exponential with a time constant tau
l = sympy.Symbol("l")
exponential = utils.events(t, dt, f=hrf.glover, g=sympy.exp(-l * a))
f3 = formula.Formula([exponential])
params = formula.make_recarray([(4.5, 3.5)], ("l", "_b0"))
X3 = f3.design(tval, params, return_float=True)
# the columns or d/d_b0 and d/dl
tt = tval.view(np.float)
v1 = np.sum([hrf.glovert(tt - s) * np.exp(-4.5 * a) for s, a in zip(t, dt)], 0)
def run_model(subj, run):
"""
Single subject fitting of FIAC model
"""
#----------------------------------------------------------------------
# Set initial parameters of the FIAC dataset
#----------------------------------------------------------------------
# Number of volumes in the fMRI data
nvol = 191
# The TR of the experiment
TR = 2.5
# The time of the first volume
Tstart = 0.0
# The array of times corresponding to each
# volume in the fMRI data
volume_times = np.arange(nvol)*TR + Tstart
# This recarray of times has one column named 't'
# It is used in the function design.event_design
# to create the design matrices.
volume_times_rec = formula.make_recarray(volume_times, 't')
# Get a path description dictionary that contains all the path data
# relevant to this subject/run
path_info = futil.path_info(subj,run)
#----------------------------------------------------------------------
# Experimental design
#----------------------------------------------------------------------
# Load the experimental description from disk. We have utilities in futil
# that reformat the original FIAC-supplied format into something where the
# factorial structure of the design is more explicit. This has already
# been run once, and get_experiment_initial() will simply load the
# newly-formatted design description files (.csv) into record arrays.
experiment, initial = futil.get_experiment_initial(path_info)
# Create design matrices for the "initial" and "experiment" factors,
# saving the default contrasts.
# The function event_design will create
# design matrices, which in the case of "experiment"
# will have num_columns =
# (# levels of speaker) * (# levels of sentence) * len(delay.spectral) =
# 2 * 2 * 2 = 8
# For "initial", there will be
# (# levels of initial) * len([hrf.glover]) = 1 * 1 = 1
# Here, delay.spectral is a sequence of 2 symbolic HRFs that
# are described in
#
# Liao, C.H., Worsley, K.J., Poline, J-B., Aston, J.A.D., Duncan, G.H.,
# Evans, A.C. (2002). \'Estimating the delay of the response in fMRI
# data.\' NeuroImage, 16:593-606.
# The contrasts, cons_exper,
# is a dictionary with keys: ['constant_0', 'constant_1', 'speaker_0',
# 'speaker_1',
# 'sentence_0', 'sentence_1', 'sentence:speaker_0', 'sentence:speaker_1']
# representing the four default contrasts: constant, main effects +
# interactions,
# each convolved with 2 HRFs in delay.spectral. Its values
# are matrices with 8 columns.
# XXX use the hrf __repr__ for naming contrasts
X_exper, cons_exper = design.event_design(experiment, volume_times_rec,
hrfs=delay.spectral)
# The contrasts for 'initial' are ignored
# as they are "uninteresting" and are included
# in the model as confounds.
X_initial, _ = design.event_design(initial, volume_times_rec,
hrfs=[hrf.glover])
# In addition to factors, there is typically a "drift" term
# In this case, the drift is a natural cubic spline with
# a not at the midpoint (volume_times.mean())
vt = volume_times # shorthand
drift = np.array( [vt**i for i in range(4)] +
[(vt-vt.mean())**3 * (np.greater(vt, vt.mean()))] )
for i in range(drift.shape[0]):
drift[i] /= drift[i].max()
# We transpose the drift so that its shape is (nvol,5) so that it will have
# the same number of rows as X_initial and X_exper.
drift = drift.T
# There are helper functions to create these drifts: design.fourier_basis,
# design.natural_spline. Therefore, the above is equivalent (except for
# the normalization by max for numerical stability) to
#
# >>> drift = design.natural_spline(t, [volume_times.mean()])
# Stack all the designs, keeping the new contrasts which has the same keys
# as cons_exper, but its values are arrays with 15 columns, with the
# non-zero entries matching the columns of X corresponding to X_exper
X, cons = design.stack_designs((X_exper, cons_exper),
(X_initial, {}),
(drift, {}))
# Sanity check: delete any non-estimable contrasts
# XXX - this seems to be broken right now, it's producing bogus warnings.
## for k in cons.keys():
## if not isestimable(X, cons[k]):
## del(cons[k])
## warnings.warn("contrast %s not estimable for this run" % k)
# The default contrasts are all t-statistics. We may want to output
# F-statistics for 'speaker', 'sentence', 'speaker:sentence' based on the
# two coefficients, one for each HRF in delay.spectral
cons['speaker'] = np.vstack([cons['speaker_0'], cons['speaker_1']])
cons['sentence'] = np.vstack([cons['sentence_0'], cons['sentence_1']])
cons['sentence:speaker'] = np.vstack([cons['sentence:speaker_0'],
cons['sentence:speaker_1']])
#----------------------------------------------------------------------
# Data loading
#----------------------------------------------------------------------
# Load in the fMRI data, saving it as an array
# It is transposed to have time as the first dimension,
# i.e. fmri[t] gives the t-th volume.
fmri, anat = futil.get_fmri_anat(path_info)
fmri = np.transpose(fmri, [3,0,1,2])
nvol, volshape = fmri.shape[0], fmri.shape[1:]
nslice, sliceshape = volshape[0], volshape[1:]
#----------------------------------------------------------------------
# Model fit
#----------------------------------------------------------------------
# The model is a two-stage model, the first stage being an OLS (ordinary
# least squares) fit, whose residuals are used to estimate an AR(1)
# parameter for each voxel.
m = OLSModel(X)
ar1 = np.zeros(volshape)
# Fit the model, storing an estimate of an AR(1) parameter at each voxel
for s in range(nslice):
d = np.array(fmri[:,s])
flatd = d.reshape((d.shape[0], -1))
result = m.fit(flatd)
ar1[s] = ((result.resid[1:] * result.resid[:-1]).sum(0) /
(result.resid**2).sum(0)).reshape(sliceshape)
# We round ar1 to nearest one-hundredth
# and group voxels by their rounded ar1 value,
# fitting an AR(1) model to each batch of voxels.
# XXX smooth here?
# ar1 = smooth(ar1, 8.0)
ar1 *= 100
ar1 = ar1.astype(np.int) / 100.
# We split the contrasts into F-tests and t-tests.
# XXX helper function should do this
fcons = {}; tcons = {}
for n, v in cons.items():
v = np.squeeze(v)
if v.ndim == 1:
tcons[n] = v
else:
fcons[n] = v
# Setup a dictionary to hold all the output
# XXX ideally these would be memmap'ed Image instances
output = {}
for n in tcons:
tempdict = {}
for v in ['sd', 't', 'effect']:
tempdict[v] = np.memmap(NamedTemporaryFile(prefix='%s%s.nii' \
% (n,v)), dtype=np.float,
shape=volshape, mode='w+')
output[n] = tempdict
for n in fcons:
output[n] = np.memmap(NamedTemporaryFile(prefix='%s%s.nii' \
% (n,v)), dtype=np.float,
shape=volshape, mode='w+')
# Loop over the unique values of ar1
for val in np.unique(ar1):
armask = np.equal(ar1, val)
m = ARModel(X, val)
d = fmri[:,armask]
results = m.fit(d)
# Output the results for each contrast
for n in tcons:
resT = results.Tcontrast(tcons[n])
output[n]['sd'][armask] = resT.sd
output[n]['t'][armask] = resT.t
output[n]['effect'][armask] = resT.effect
for n in fcons:
output[n][armask] = results.Fcontrast(fcons[n]).F
# Dump output to disk
odir = futil.output_dir(path_info,tcons,fcons)
for n in tcons:
for v in ['t', 'sd', 'effect']:
im = api.Image(output[n][v], anat.coordmap.copy())
save_image(im, pjoin(odir, n, '%s.nii' % v))
for n in fcons:
im = api.Image(output[n], anat.coordmap.copy())
save_image(im, pjoin(odir, n, "F.nii"))
# is an example from
# "Applied Linear Statistical Models" that can be found
# The number of Days in a hospital stay are recorded
# based on the Duration of dialysis treatment
# and the Weight of the patient. These
# two variables are described categorically
# as Duration (1 or 2), Weight (1, 2 or 3)
#
# You can find another copy of the data at
#
# http://www-stat.stanford.edu/~jtaylo/courses/stats191/data/kidney.table
D = []
for row in StringIO(data):
D.append(map(float, row.split()))
D = F.make_recarray(D, ["Days", "Duration", "Weight", "ID"])
# Create the categorical regressors, known as Factors
f1 = F.Factor("Duration", [1, 2])
f2 = F.Factor("Weight", [1, 2, 3])
twoway = f1 * f2
# The columns of X are 0-1 indicator columns,
# return_float = False yields a recarray
# with interpretable names
def test_names():
# Check that the design column names are what we expect
def test_intercept():
dz = F.make_recarray([2,3,4],'z')
v = F.I.design(dz, return_float=False)
yield assert_equal, v.dtype.names, ['intercept']
# is an example from
# "Applied Linear Statistical Models" that can be found
# The number of Days in a hospital stay are recorded
# based on the Duration of dialysis treatment
# and the Weight of the patient. These
# two variables are described categorically
# as Duration (1 or 2), Weight (1, 2 or 3)
#
# You can find another copy of the data at
#
# http://www-stat.stanford.edu/~jtaylo/courses/stats191/data/kidney.table
D = []
for row in StringIO(data):
D.append(map(float, row.split()))
D = F.make_recarray(D, ['Days', 'Duration', 'Weight', 'ID'])
# Create the categorical regressors, known as Factors
f1 = F.Factor('Duration', [1,2])
f2 = F.Factor('Weight', [1,2,3])
twoway = f1 * f2
# The columns of X are 0-1 indicator columns,
# return_float = False yields a recarray
# with interpretable names
def test_names():
# Check that the design column names are what we expect
X = twoway.design(D, return_float=False)
Fcontrasts["overall2"] = (
Fcontrasts["averageF"] + Fcontrasts["speakerF"] + Fcontrasts["sentenceF"] + Fcontrasts["interactionF"]
)
return f, Tcontrasts, Fcontrasts
# block and event protocols
block, bTcons, bFcons = protocol(StringIO(descriptions["block"]), "block", *delay.spectral)
event, eTcons, eFcons = protocol(StringIO(descriptions["event"]), "event", *delay.spectral)
# Now create the design matrices and contrasts
# The 0 indicates that it will be these columns
# convolved with the first HRF
t = formula.make_recarray(np.arange(191) * 2.5 + 1.25, "t")
X = {}
c = {}
fmristat = {}
D = {}
for f, cons, design_type in [(block, bTcons, "block"), (event, eTcons, "event")]:
X[design_type], c[design_type] = f.design(t, contrasts=cons)
D[design_type] = f.design(t, return_float=False)
fstat = np.array([float(x) for x in designs[design_type].strip().split("\t")])
fmristat[design_type] = fstat.reshape((191, fstat.shape[0] / 191)).T
def test_altprotocol():
block, bT, bF = protocol(StringIO(descriptions["block"]), "block", *delay.spectral)
event, eT, eF = protocol(StringIO(descriptions["event"]), "event", *delay.spectral)
