示例#1
0
	L,n = rft1d.geom.bwlabel(b)
	return n




#(0) Simulation:
np.random.seed(0)
nNodes      = 101
FWHM        = [5, 10, 25]
nIterations = 100   #increase this to 1000 to reproduce the results from the paper
heights     = np.linspace(0, 4, 21)
### simulate random fields and compute their EC:
EC          = []
for W in FWHM:
	y       = rft1d.randn1d(nIterations, nNodes, W, pad=True)
	ec      = np.array([[here_ec(yy>u)  for u in heights]   for yy in y]).mean(axis=0)
	EC.append(ec)
EC          = np.array(EC)


#(1) Expected EC:
E0,E1 = [],[]
for W in FWHM:
	e0    = np.array([here_expected_ec_0d(u)  for u in heights])
	e1    = np.array([here_expected_ec_1d(nNodes, W, u)  for u in heights])
	E0.append(e0)
	E1.append(e1)


#(2) Plot results:
from matplotlib import pyplot
from spm1d import rft1d

eps        = np.finfo(float).eps   #smallest float


#(0) Set parameters:
np.random.seed(0)
nResponses   = 2000
nNodes       = 101
FWHM         = 10.0
interp       = True
wrap         = True
heights      = [2.2, 2.4, 2.6, 2.8]
### generate data:
y            = rft1d.randn1d(nResponses, nNodes, FWHM)
calc         = rft1d.geom.ClusterMetricCalculator()
rftcalc      = rft1d.prob.RFTCalculator(STAT='Z', nodes=nNodes, FWHM=FWHM)




#(1) Maximum region size:
K0      = np.linspace(eps, 15, 21)
K       = np.array([[calc.max_cluster_extent(yy, h, interp, wrap)   for yy in y]  for h in heights])
P       = np.array([(K>=k0).mean(axis=1)  for k0 in K0]).T
P0      = np.array([[rftcalc.p.cluster(k0, h)  for k0 in K0/FWHM]  for h in heights])



示例#3
0
nNodes       = 101
FWHM         = [5.0, 10.0, 25.0]
nResponses   = 20
heights      = np.linspace(1.0, 3.0, 11)
### generate mask:
nodes        = np.array([True]*nNodes)
nodes[20:35] = False
nodes[60:80] = False
### assemble the field's geometric characteristics:
nSegments    = rft1d.geom.bwlabel(nodes)[1]  #number of unbroken field segments (here: 3)
nNodesTotal  = nodes.sum() #number of nodes in the unbroken field segments
fieldSize    = nNodesTotal - nSegments


#(1) Generate broken random fields:
y0           = rft1d.randn1d(nResponses, nodes, FWHM[0], pad=True)
y1           = rft1d.randn1d(nResponses, nodes, FWHM[1], pad=True)
y2           = rft1d.randn1d(nResponses, nodes, FWHM[2], pad=True)





#(2) Plot results:
pyplot.close('all')
axx         = np.linspace(0.04, 0.695, 3)
AX          = [pyplot.axes([xx,0.18,0.29,0.8])   for xx in axx]
ax0,ax1,ax2 = AX
### plot fields:
colors      = scalar2color(range(nResponses+3), cmap=cm.RdPu)
[ax0.plot(yy, color=color)  for yy,color in zip(y0,colors)]
示例#4
0
    tri_c = np.sum(((marker2[frame]) - (marker1[frame]))**2)**0.5
    cos = (tri_a**2 + tri_b**2 - tri_c**2) / (2 * tri_a * tri_b)
    ang = np.degrees(np.arccos(cos))
    return ang


def get_weights(Q, rate=4):
    x = np.linspace(0, 10, Q)
    w0 = 1.0 / (1 + np.exp(5 - rate * x))
    w1 = w0[::-1]
    return (w0 + w1) - 1


# Create a random trajectory:
np.random.seed(1234567)
y0 = rft1d.randn1d(1, 41, 15)
w = get_weights(41, rate=8)
y = y0 * w

#t = range(40)
xi = 161.35
xf = 96.85

#t=DPhalanx[:,0]
t = np.linspace(0, 40,
                41)  #Create an array of linear values from 0 to 2 (101 values)
x = trajectory(t, xi, xf)  #Create an array of minimum jerk trajectory
x_noise = rft1d.randn1d(1, 41, 5)
x_noise_clean = x_noise * w
amp = 2
xnew = x + amp * x_noise_clean
示例#5
0
from matplotlib import pyplot
from spm1d import rft1d

eps = np.finfo(float).eps  #smallest float

#(0) Set parameters:
np.random.seed(0)
nResponses = 2000
nNodes = 101
FWHM = 8.5
interp = True
wrap = True
heights = [2.0, 2.2, 2.4]
c = 2
### generate data:
y = rft1d.randn1d(nResponses, nNodes, FWHM)
calc = rft1d.geom.ClusterMetricCalculator()
rftcalc = rft1d.prob.RFTCalculator(STAT='Z', nodes=nNodes, FWHM=FWHM)

#(1) Maximum region size:
K0 = np.linspace(eps, 8, 21)
K = [[calc.cluster_extents(yy, h, interp, wrap) for yy in y] for h in heights]
### compute number of upcrossings above a threshold:
C = np.array([[[sum([kkk >= k0 for kkk in kk]) for kk in k] for k in K]
              for k0 in K0])
P = np.mean(C >= c, axis=2).T
P0 = np.array([[rftcalc.p.set(c, k0, h) for h in heights]
               for k0 in K0 / FWHM]).T

#(2) Plot results:
pyplot.close('all')
示例#6
0
nNodes = 101
FWHM = [5.0, 10.0, 25.0]
nResponses = 20
heights = np.linspace(1.0, 3.0, 11)
### generate mask:
nodes = np.array([True] * nNodes)
nodes[20:35] = False
nodes[60:80] = False
### assemble the field's geometric characteristics:
nSegments = rft1d.geom.bwlabel(nodes)[
    1]  #number of unbroken field segments (here: 3)
nNodesTotal = nodes.sum()  #number of nodes in the unbroken field segments
fieldSize = nNodesTotal - nSegments

#(1) Generate broken random fields:
y0 = rft1d.randn1d(nResponses, nodes, FWHM[0], pad=True)
y1 = rft1d.randn1d(nResponses, nodes, FWHM[1], pad=True)
y2 = rft1d.randn1d(nResponses, nodes, FWHM[2], pad=True)

#(2) Plot results:
pyplot.close('all')
axx = np.linspace(0.04, 0.695, 3)
AX = [pyplot.axes([xx, 0.18, 0.29, 0.8]) for xx in axx]
ax0, ax1, ax2 = AX
### plot fields:
colors = scalar2color(range(nResponses + 3), cmap=cm.RdPu)
[ax0.plot(yy, color=color) for yy, color in zip(y0, colors)]
[ax1.plot(yy, color=color) for yy, color in zip(y1, colors)]
[ax2.plot(yy, color=color) for yy, color in zip(y2, colors)]
### adjust axes:
pyplot.setp(AX, xlim=(0, 100), ylim=(-3.8, 3.8))
示例#7
0
from matplotlib import pyplot
from spm1d import rft1d

#(0) Set parameters:
np.random.seed(0)
nResponses = 10000
nNodes = 101
FWHM = 13.1877
### generate a field mask:
nodes_full = np.array([True] * nNodes)  #nothing masked out
nodes = nodes_full.copy()
nodes[20:45] = False  #this region will be masked out
nodes[60:80] = False

#(1) Generate Gaussian 1D fields and extract maxima::
y_full = rft1d.randn1d(nResponses, nNodes, FWHM)
np.random.seed(0)
y_broken = rft1d.randn1d(nResponses, nodes, FWHM)
ymax_full = y_full.max(axis=1)
ymax_broken = np.nanmax(y_broken, axis=1)

#(2) Survival functions for field maximum:
heights = np.linspace(2.0, 4, 21)
sf_full = np.array([(ymax_full >= h).mean() for h in heights])
sf_broken = np.array([(ymax_broken >= h).mean() for h in heights])
### expected:
sfE_full = rft1d.norm.sf(heights, nNodes, FWHM)  #theoretical
sfE_broken = rft1d.norm.sf(heights, nodes, FWHM)  #theoretical

#(3) Plot results:
pyplot.close('all')
示例#8
0
### actual EC:
def here_ec(b):
    L, n = rft1d.geom.bwlabel(b)
    return n


### simulate:
np.random.seed(0)
nNodes = 101
FWHM = [5, 10, 25]
nIterations = 100  #increase this to 1000 to reproduce the results from the paper
heights = np.linspace(0, 4, 21)
### simulate random fields and compute their EC:
EC = []
for W in FWHM:
    y = rft1d.randn1d(nIterations, nNodes, W, pad=True)
    ec = np.array([[here_ec(yy > u) for u in heights]
                   for yy in y]).mean(axis=0)
    EC.append(ec)
EC = np.array(EC)
### expected EC:
E0, E1 = [], []
for W in FWHM:
    e0 = np.array([here_expected_ec_0d(u) for u in heights])
    e1 = np.array([here_expected_ec_1d(nNodes, W, u) for u in heights])
    E0.append(e0)
    E1.append(e1)
### plot:
pyplot.figure(3)
ax = pyplot.axes([0.11, 0.14, 0.86, 0.84])
colors = ['b', 'g', 'r']
示例#9
0
### actual EC:
def here_ec(b):
    L, n = rft1d.geom.bwlabel(b)
    return n


#(0) Simulation:
np.random.seed(0)
nNodes = 101
FWHM = [5, 10, 25]
nIterations = 100  #increase this to 1000 to reproduce the results from the paper
heights = np.linspace(0, 4, 21)
### simulate random fields and compute their EC:
EC = []
for W in FWHM:
    y = rft1d.randn1d(nIterations, nNodes, W, pad=True)
    ec = np.array([[here_ec(yy > u) for u in heights]
                   for yy in y]).mean(axis=0)
    EC.append(ec)
EC = np.array(EC)

#(1) Expected EC:
E0, E1 = [], []
for W in FWHM:
    e0 = np.array([here_expected_ec_0d(u) for u in heights])
    e1 = np.array([here_expected_ec_1d(nNodes, W, u) for u in heights])
    E0.append(e0)
    E1.append(e1)

#(2) Plot results:
pyplot.close('all')
示例#10
0
#(0) Set parameters:
np.random.seed(123456789)
nResponsesA = 5
nResponsesB = 5
nNodes = 101
FWHM = 10.0
nIterations = 5000
### derived parameters:
nA, nB = nResponsesA, nResponsesB
nTotal = nA + nB
df = nA + nB - 2

#(1) Generate Gaussian 1D fields, compute test stat, store field maximum:
T = []
for i in range(nIterations):
    y = rft1d.randn1d(nTotal, nNodes, FWHM)
    #compute test stat:
    yA, yB = y[:nA], y[nA:]
    mA, mB = yA.mean(axis=0), yB.mean(axis=0)
    sA, sB = yA.std(ddof=1, axis=0), yB.std(ddof=1, axis=0)
    s = np.sqrt(((nA - 1) * sA * sA + (nB - 1) * sB * sB) / df)
    t = (mA - mB) / (s * np.sqrt(1.0 / nA + 1.0 / nB))
    T.append(t.max())
T = np.asarray(T)

#(2) Survival functions:
heights = np.linspace(2, 5, 21)
sf = np.array([(T > h).mean() for h in heights])
sfE = rft1d.t.sf(heights, df, nNodes, FWHM)  #theoretical
sf0D = rft1d.t.sf0d(heights, df)  #theoretical (0D)
示例#11
0
#(0) Set parameters:
np.random.seed(0)
nResponses    = 10000
nNodes        = 101
FWHM          = 13.1877
### generate a field mask:
nodes_full    = np.array([True]*nNodes) #nothing masked out
nodes         = nodes_full.copy()
nodes[20:45]  = False  #this region will be masked out
nodes[60:80]  = False



#(1) Generate Gaussian 1D fields and extract maxima::
y_full        = rft1d.randn1d(nResponses, nNodes, FWHM)
np.random.seed(0)
y_broken      = rft1d.randn1d(nResponses, nodes, FWHM)
ymax_full     = y_full.max(axis=1)
ymax_broken   = np.nanmax(y_broken, axis=1)


#(2) Survival functions for field maximum:
heights    = np.linspace(2.0, 4, 21)
sf_full    = np.array(  [ (ymax_full>=h).mean()  for h in heights]  )
sf_broken  = np.array(  [ (ymax_broken>=h).mean()  for h in heights]  )
### expected:
sfE_full   = rft1d.norm.sf(heights, nNodes, FWHM)  #theoretical
sfE_broken = rft1d.norm.sf(heights, nodes, FWHM)  #theoretical

示例#12
0
np.random.seed(123456789)
nResponsesA = 5
nResponsesB = 5
nNodes      = 101
FWHM        = 10.0
nIterations = 5000
### derived parameters:
nA,nB       = nResponsesA, nResponsesB
nTotal      = nA + nB
df          = nA + nB - 2


#(1) Generate Gaussian 1D fields, compute test stat, store field maximum:
T         = []
for i in range(nIterations):
	y     = rft1d.randn1d(nTotal, nNodes, FWHM)
	#compute test stat:
	yA,yB = y[:nA], y[nA:]
	mA,mB = yA.mean(axis=0), yB.mean(axis=0)
	sA,sB = yA.std(ddof=1, axis=0), yB.std(ddof=1, axis=0)
	s     = np.sqrt(    ((nA-1)*sA*sA + (nB-1)*sB*sB)  /  df     )
	t     = (mA-mB) / ( s *np.sqrt(1.0/nA + 1.0/nB))
	T.append( t.max() )
T         = np.asarray(T)


#(2) Survival functions:
heights   = np.linspace(2, 5, 21)
sf        = np.array(  [ (T>h).mean()  for h in heights]  )
sfE       = rft1d.t.sf(heights, df, nNodes, FWHM)  #theoretical
sf0D      = rft1d.t.sf0d(heights, df) #theoretical (0D)
示例#13
0
def here_expected_ec_1d(Q, FWHM, u):
	return (Q-1)/FWHM * sqrt(4*log(2)) / (2*pi) * exp(-0.5*(u*u))
### actual EC:
def here_ec(b):
	L,n = rft1d.geom.bwlabel(b)
	return n
### simulate:
np.random.seed(0)
nNodes      = 101
FWHM        = [5, 10, 25]
nIterations = 100   #increase this to 1000 to reproduce the results from the paper
heights     = np.linspace(0, 4, 21)
### simulate random fields and compute their EC:
EC          = []
for W in FWHM:
	y       = rft1d.randn1d(nIterations, nNodes, W, pad=True)
	ec      = np.array([[here_ec(yy>u)  for u in heights]   for yy in y]).mean(axis=0)
	EC.append(ec)
EC          = np.array(EC)
### expected EC:
E0,E1 = [],[]
for W in FWHM:
	e0    = np.array([here_expected_ec_0d(u)  for u in heights])
	e1    = np.array([here_expected_ec_1d(nNodes, W, u)  for u in heights])
	E0.append(e0)
	E1.append(e1)
### plot:
pyplot.figure(3)
ax      = pyplot.axes([0.11,0.14,0.86,0.84])
colors  = ['b', 'g', 'r']
for color,e0,e1,ec in zip(colors, E0, E1, EC):
示例#14
0
文件: val_uv1d.py 项目: demotu/ci1d
import ci1d

#(0) Initialize parameters:
np.random.seed(0)  #seed the random number generator to replicate results
alpha = 0.05  #Type I error rate
J = 10  #sample size
Q = 101  #number of continuum nodes
fwhm = 20  #smoothness
mu = np.zeros(Q)  #true population mean
niterations = 100  #number of datasets / experiments to simulate
in_ci = []  #list that will hold one True or False value for each iteration
in_pi = []  #list that will hold one True or False value for each iteration

#(1) Simulate:
for i in range(niterations):
    y = mu + rft1d.randn1d(J, Q, fwhm)  #Gaussian data
    ynew = mu + rft1d.randn1d(1, Q, fwhm)  #an additional random observation
    ds = ci1d.UnivariateDataset1D(y)
    ci = ds.get_confidence_region(alpha=alpha)
    pi = ds.get_prediction_region(alpha=alpha)
    in_ci.append(ci.isinside(mu))
    in_pi.append(pi.isinside(ynew))

#(2) Report:
### confidence region:
prop_in = np.mean(
    in_ci)  #proportion of experiments where the true mean lies inside the CI
prop_out = 1 - prop_in  #proportion of experiments where the true mean lies outside the CI
print('Proportion of random datasets with mu inside CI: %.3f' % prop_in)
print('Proportion of random datasets with mu outside CI: %.3f' % prop_out)
### prediction region:
示例#15
0
Note:
When FWHM gets large (2FWHM>nNodes), the data should be padded
using the *pad* keyword.
'''


import numpy as np
from matplotlib import pyplot
from spm1d import rft1d


#(0) Set parameters:
np.random.seed(12345)
nResponses = 5
nNodes     = 101
FWHM       = 20.0


#(1) Generate Gaussian 1D fields:
y          = rft1d.randn1d(nResponses, nNodes, FWHM, pad=False)


#(2) Plot:
pyplot.close('all')
pyplot.plot(y.T)
pyplot.plot([0,100], [0,0], 'k:')
pyplot.xlabel('Field position', size=16)
pyplot.ylabel('z', size=20)
pyplot.title('Random (Gaussian) fields', size=20)
pyplot.show()
示例#16
0
文件: rand.py 项目: 0todd0000/iwtspm
def gauss1dns(J, Q, fwhm=10, s=1):
	'''
	Nonstationary, smooth Gaussian 1D noise
	'''
	e     = rft1d.randn1d(J, Q, FWHM=fwhm, pad=True)
	return s * e