Ejemplo n.º 1
0
 def _estimate_maximal_stats(self, ts, ppos, pneg, dp):
     n = int(1.0/dp)
     nt, nf = ts.shape[1:]
     max_t = np.empty((n, nt, nf))
     min_t = np.empty((n, nt, nf))
     for t in xrange(nt):
         for f in xrange(nf):
             edges, _ = su.map_t(ts[:,t,f], pneg[:,t,f], dp)
             min_t[:,t,f] = edges
             edges, _ = su.map_t(-ts[:,t,f], ppos[:,t,f], dp)
             max_t[:,t,f] = -edges
     return min_t, max_t
Ejemplo n.º 2
0
def test_map_t():
    n = 2000
    
    p = np.sort(np.random.randint(1, high=n, size=100)).astype('d')
    # want to find some sampling of p scores with large
    # gaps between values
    while(np.diff(p).max() < 5):
        p = np.sort(np.random.randint(1, high=n, size=100)).astype('d')
    p /= float(n)
    # unsort p
    np.random.shuffle(p)
    # test the neg tail, so reverse the sign of the isf function
    t = -st.norm.isf(p)
    edges, pvals = su.map_t(t, p, 1.0/n)
    # choose an alpha that is not exactly on a bin edge
    alpha = p[5] + .25/n
    k = int( alpha * n )
    thresh = edges[k]
    m = t <= thresh

    yield assert_true, p[m].max() < alpha, 'alpha mapped incorrectly'

    t *= -1
    edges *= -1
    k = int( alpha*n + .5)
    thresh = edges[k]
    m = t >= thresh

    yield assert_true, p[m].max() < alpha, 'alpha mapped incorrectly'
Ejemplo n.º 3
0
def test_map_t_real_data():
    import os
    pth = os.path.join(os.path.dirname(__file__), 's_beamtf1_avg.mat')
    if not os.path.exists(pth):
        assert False, 'did not find data file'
        return
    mdict, mbeam, dof = su.split_combo_tfstats_matfile(pth)
    p_corr_pos = mdict['p val pos (corr)']
    p_corr_neg = mdict['p val neg (corr)']
    tt = mdict['T test']
    n = 2048
    nt, nf = tt.s.shape[1:]
    max_t_maps = np.empty((n, nt, nf))
    min_t_maps = np.empty((n, nt, nf))
    for t in xrange(nt):
        for f in xrange(nf):
            edges, _ = su.map_t(tt.s[:,t,f], p_corr_neg.s[:,t,f], 1.0/n)
            min_t_maps[:,t,f] = edges
            edges, _ = su.map_t(-tt.s[:,t,f], p_corr_pos.s[:,t,f], 1.0/n)
            max_t_maps[:,t,f] = -edges


    min_t_maps = np.sort(min_t_maps, axis=0)
    alpha = 0.05
    while not (p_corr_neg.s <= alpha).any():
        alpha += 0.05
    print 'testing negative tail at significance level', alpha
    # highest k index satisfying t <= tc
    k_mn = int(alpha * n)
    tc = min_t_maps[k_mn]
    m = tt.s <= tc
    yield assert_false, (p_corr_neg.s[m] > alpha).any()

    max_t_maps = np.sort(max_t_maps, axis=0)
    alpha = 0.05
    while not (p_corr_pos.s <= alpha).any():
        alpha += 0.05
    print 'testing positive tail at significance level', alpha        
    # lowest k index in max_t_maps satisfying significant t >= tc
    k_mx = int((1-alpha) * n + 0.5)
    tc = max_t_maps[k_mx]
    m = tt.s >= tc
    print m.sum()
    yield assert_false, (p_corr_pos.s[m] > alpha).any()
Ejemplo n.º 4
0
null = np.sort(np.random.normal(size=(100,), loc=4, scale=1.2))
# create test scores from our experiment
# (but for ease of demonstration, clip the values to be within the null dist)
t_scores = np.clip(
    np.random.normal(size=(20,), loc=5, scale=0.8),
    null.min(), null.max()*.99
    )

# Score the t_scores based on the empirical null distribution
index = su.index(t_scores, null)
p_table = np.linspace(1,0,len(null)+1,endpoint=True)
p_scores = np.take(p_table, index)

# Now, try to recover the null distribution, based on these few
# T-score and P-score pairs -- use the negative edges
edges, pbins = su.map_t(-t_scores, p_scores, 1/100.)

edges = -edges[::-1]

p_recovered = np.array(
    [ ( edges > t_scores[i] ).sum() for i in xrange(len(t_scores))]
    )
assert (np.round(p_scores*100) == p_recovered).all()

probability = np.arange(100)/100.

si = np.argsort(p_scores)
print np.round(p_scores[si]*100), t_scores[si]
pp.plot(probability, null)
pp.plot(probability, edges, 'r')