def getCanoHRF(duration=25,
dt=.6,
hrf_from_spm=True,
delay_of_response=6.,
delay_of_undershoot=16.,
dispersion_of_response=1.,
dispersion_of_undershoot=1.,
ratio_resp_under=6.,
delay=0.):
"""Compute the canonical HRF.
Parameters
----------
duration : int or float, optional
time lenght of the HRF in seconds
dt : float, optional
time resolution of the HRF in seconds
hrf_from_spm : bool, optional
if True, use the SPM formula to compute the HRF, if False, use the hard
coded values and resample if necessary. It is strongly advised to use
True.
delay_of_response : float, optional
delay of the first peak response in seconds
delay_of_undershoot : float, optional
delay of the second undershoot peak in seconds
dispersion_of_response : float, optional
dispersion_of_undershoot : float, optional
ratio_resp_under : float, optional
ratio between the response peak and the undershoot peak
delay : float, optional
delay of the HRF
Returns
-------
time_axis : ndarray, shape (round(duration/dt)+1,)
time axis of the HRF in seconds
HRF : ndarray, shape (round(duration/dt)+1,)
"""
time_axis = np.arange(0, duration + dt, dt)
axis = np.arange(len(time_axis))
if hrf_from_spm:
hrf_cano = (scipy.stats.gamma.pdf(
axis - delay / dt, delay_of_response / dispersion_of_response, 0,
dispersion_of_response / dt) - scipy.stats.gamma.pdf(
axis - delay / dt, delay_of_undershoot /
dispersion_of_undershoot, 0, dispersion_of_undershoot / dt) /
ratio_resp_under)
hrf_cano[-1] = 0
hrf_cano /= np.linalg.norm(hrf_cano)
else:
hrf_cano = resampleToGrid(time_axisHCano, hCano.copy(), time_axis)
hrf_cano[-1] = 0.
assert len(hrf_cano) == len(time_axis)
hrf_cano /= (hrf_cano**2).sum()**.5
return time_axis, hrf_cano
def getCanoHRF(duration=25, dt=.6):
tAxis = np.arange(0, duration+dt, dt)
h = resampleToGrid(tAxisHCano, hCano.copy(), tAxis)
h[-1] = 0.
assert len(h) == len(tAxis)
h /= (h**2).sum()**.5
return tAxis, h
def testLargerTargetGrid(self):
import numpy
size = 10
x = numpy.concatenate(
([0.], numpy.sort(numpy.random.rand(size)), [1.]))
y = numpy.concatenate(
([0.], numpy.sort(numpy.random.rand(size)), [1.]))
grid = numpy.arange(-0.2, 1.1, 0.01)
ny = resampleToGrid(x, y, grid)
def testLargerTargetGrid(self):
import numpy
size = 10
x = numpy.concatenate(
([0.], numpy.sort(numpy.random.rand(size)), [1.]))
y = numpy.concatenate(
([0.], numpy.sort(numpy.random.rand(size)), [1.]))
grid = numpy.arange(-0.2, 1.1, 0.01)
ny = resampleToGrid(x, y, grid)
def compute_roc_labels(mlabels, true_labels, dthres=0.005, lab_ca=1, lab_ci=0,
false_pos=2, false_neg=3):
thresholds = np.arange(0,1/dthres) * dthres
nconds = true_labels.shape[0]
oneMinusSpecificity = np.zeros((nconds, len(thresholds)))
sensitivity = np.zeros((nconds, len(thresholds)))
for it,thres in enumerate(thresholds):
#print 'thres:',thres
labs = threshold_labels(mlabels,thres)
tlabels = labs.copy()
labs = mark_wrong_labels(labs,true_labels,lab_ca, lab_ci, false_pos, false_neg)
for cond in xrange(nconds):
if 0 and cond == 1:
print "**cond %d **" %cond
print 'thresh:', thres
print 'mlabels (activ class):'
print mlabels[1,cond,:80]
print 'thresholded labels:'
print tlabels[cond,:80]
print 'simulated labels:'
print true_labels[cond,:80]
print 'marked labels:'
print labs[cond,:80]
counts = np.bincount(labs[cond,:])
nbTrueNeg = counts[0]
nbTruePos = counts[1] if len(counts)>1 else 0
fp = false_pos
nbFalsePos = counts[fp] if len(counts)>fp else 0
fn = false_neg
nbFalseNeg = counts[fn] if len(counts)>fn else 0
#if cond == 1 or cond == 2:
#print 'cond ', cond
#print 'nbTrueNeg=',nbTrueNeg
#print 'nbTruePos=',nbTruePos
#print 'nbFalsePos=',nbFalsePos
#print 'nbFalseNeg=',nbFalseNeg
if 0 and cond == 1:
print 'TN :', nbTrueNeg
print 'TP :', nbTruePos
print 'FP :', nbFalsePos
print 'FN :', nbFalseNeg
if nbTruePos == 0:
sensitivity[cond,it] = 0
else:
sensitivity[cond,it] = nbTruePos / \
(nbTruePos+nbFalseNeg+0.0)
spec = nbTrueNeg/(nbTrueNeg+nbFalsePos+0.0)
oneMinusSpecificity[cond,it] = 1-spec
if 0 and cond == 1:
print '-> se = ', sensitivity[cond, it]
print '-> 1-sp = ', oneMinusSpecificity[cond,it]
if 1:
spGrid = np.arange(0.,1.,0.0005)
omspec = np.zeros((nconds, len(spGrid)))
sens = np.zeros((nconds, len(spGrid)))
for cond in xrange(nconds):
order = np.argsort(oneMinusSpecificity[cond,:])
if oneMinusSpecificity[cond,order][0] != 0.:
osp = np.concatenate(([0.],oneMinusSpecificity[cond,order]))
se = np.concatenate(([0.],sensitivity[cond,order]))
else:
osp = oneMinusSpecificity[cond,order]
se = sensitivity[cond,order]
if osp[-1] != 1.:
osp = np.concatenate((osp,[1.]))
se = np.concatenate((se,[1.]))
sens[cond,:] = resampleToGrid(osp, se, spGrid)
omspec[cond, :] = spGrid
if 0 and cond == 1:
print '-> (se,1-spec) :'
print zip(se,osp)
print '-> se resampled :'
print sens[cond,:]
print 'spec grid :'
print spGrid
else:
sens = sensitivity
omspec = oneMinusSpecificity
auc = np.array([trapz(sens[j,:], omspec[j,:])
for j in xrange(nconds)])
#Computing the area under ROC curve (with John Walkenbach formula) (SAME AS auc)
#area_under_ROC_curve = np.zeros(nconds, dtype=float)
#for cond in xrange(nconds):
#for i in xrange(len(spGrid)-1):
#if sens[cond,i]*sens[cond,i+1] >= 0.:
#area_under_ROC_curve[cond] += ((sens[cond,i+1] + sens[cond,i])/2.) * (omspec[cond,i+1] - omspec[cond,i])
#else:
#area_under_ROC_curve[cond] += ((sens[cond,i+1]**2 + sens[cond,i]**2)/((sens[cond,i+1] - sens[cond,i])/2.)) * (omspec[cond,i+1] - omspec[cond,i])
return sens, omspec, auc #, area_under_ROC_curve
