def test_converting_to_factors():
test_data = DataFrame(
{
'colA': Series(randn(1, 5000).flatten() > 0),
'colB': Series(100 * randn(1, 5000).flatten()),
'colC': Series(100 + randn(1, 5000).flatten()),
'colD': Series(randn(1, 5000).flatten() > 0),
},
)
test_data['colA'] = test_data['colA'].map(str)
test_data['colD'] = test_data['colD'].map(str)
factor_cols = [('colA', 'True'),
('colD', 'True')]
rpy_test_df = com.convert_to_r_dataframe(test_data)
rpy_out_df = Rtools.convert_columns_to_factors(rpy_test_df, factor_cols)
test_cols = [('colA', 'factor'),
('colB', 'numeric'),
('colC', 'numeric'),
('colD', 'factor')]
for col, typ in test_cols:
if typ == 'factor':
yield eq_, rpy_out_df.rx2(col).nlevels, 2
elif typ == 'numeric':
yield ok_, (not hasattr(rpy_out_df.rx2(col), 'nlevels'))
def _genBgTerm_fromXX(self,vTot,vCommon,XX,a=None,c=None):
"""
generate background term from SNPs
Args:
vTot: variance of Yc+Yi
vCommon: variance of Yc
XX: kinship matrix
a: common scales, it can be set for debugging purposes
c: indipendent scales, it can be set for debugging purposes
"""
vSpecific = vTot-vCommon
SP.random.seed(0)
if c==None: c = SP.randn(self.P)
XX += 1e-3 * SP.eye(XX.shape[0])
L = LA.cholesky(XX,lower=True)
# common effect
R = self.genWeights(self.N,self.P)
A = self.genTraitEffect()
if a is not None: A[0,:] = a
Yc = SP.dot(L,SP.dot(R,A))
Yc*= SP.sqrt(vCommon)/SP.sqrt(Yc.var(0).mean())
# specific effect
R = SP.randn(self.N,self.P)
Yi = SP.dot(L,SP.dot(R,SP.diag(c)))
Yi*= SP.sqrt(vSpecific)/SP.sqrt(Yi.var(0).mean())
return Yc, Yi
def test_mixed_model():
test_data = DataFrame(
{
'colA': Series(randn(1, 5000).flatten() > 0),
'colB': Series(100 * randn(1, 5000).flatten()),
'colC': Series(100 + randn(1, 5000).flatten()),
'colD': Series(randn(1, 5000).flatten() > 0),
},
)
test_data['colA'] = test_data['colA'].map(str)
test_data['colD'] = test_data['colD'].map(str)
factor_cols = [('colA', 'True'),
('colD', 'True')]
rpy_test_df = com.convert_to_r_dataframe(test_data)
rpy_test_df = Rtools.convert_columns_to_factors(rpy_test_df, factor_cols)
base_formula = Formula('colC ~ as.factor(colA) + colB')
rand_formula = Formula('~1|colD')
results = Rtools.R_linear_mixed_effects_model(rpy_test_df, base_formula, rand_formula)
print results['tTable']
ok_(('tTable' in results), 'Did not have the tTable in the results')
ok_(('as.factor(colA)False' in results['tTable'].index), 'Did not have the factor in the tTable')
ok_(('colB' in results['tTable'].index), 'Did not have the variable in the tTable')
def test_far_apart_clusters_estimate_all(self):
cluster1 = sp.randn(40,1000)
cluster2 = sp.randn(40,1000) * 2
cluster2[0,:] += 10
clusterList1 = [cluster1[:,i]
for i in xrange(sp.size(cluster1,1))]
clusterList2 = [cluster2[:,i]
for i in xrange(sp.size(cluster2,1))]
total, pair = qa.overlap_fp_fn(
{1: clusterList1, 2: clusterList2})
self.assertLess(total[1][0], 1e-4)
self.assertLess(total[1][1], 1e-4)
self.assertLess(total[2][0], 1e-4)
self.assertLess(total[2][1], 1e-4)
self.assertLess(pair[1][2][0], 1e-4)
self.assertLess(pair[1][2][1], 1e-4)
self.assertLess(pair[2][1][0], 1e-4)
self.assertLess(pair[2][1][1], 1e-4)
self.assertGreater(total[1][0], 0.0)
self.assertGreater(total[1][1], 0.0)
self.assertGreater(total[2][0], 0.0)
self.assertGreater(total[2][1], 0.0)
self.assertGreater(pair[1][2][0], 0.0)
self.assertGreater(pair[1][2][1], 0.0)
self.assertGreater(pair[2][1][0], 0.0)
self.assertGreater(pair[2][1][1], 0.0)
def simulate(self,standardize=True):
self._update_cache()
RV = SP.zeros((self.N,self.P))
# region
Z = SP.randn(self.S,self.P)
Sc,Uc = LA.eigh(self.Cr.K())
Sc[Sc<1e-9] = 0
USh_c = Uc*Sc[SP.newaxis,:]**0.5
RV += SP.dot(SP.dot(self.Xr,Z),USh_c.T)
# background
Z = SP.randn(self.N,self.P)
USh_r = self.cache['Lr'].T*self.cache['Srstar'][SP.newaxis,:]**0.5
Sc,Uc = LA.eigh(self.Cg.K())
Sc[Sc<1e-9] = 0
USh_c = Uc*Sc[SP.newaxis,:]**0.5
RV += SP.dot(SP.dot(USh_r,Z),USh_c.T)
# noise
Z = SP.randn(self.N,self.P)
Sc,Uc = LA.eigh(self.Cn.K())
Sc[Sc<1e-9] = 0
USh_c = Uc*Sc[SP.newaxis,:]**0.5
RV += SP.dot(Z,USh_c.T)
# standardize
if standardize:
RV-=RV.mean(0)
RV/=RV.std(0)
return RV
def _generate_null_shift_errors(self):
"""
Returns null shift (constant bias) entries in a 6 entry array:
array([gx_n, gy_n, gz_n, ax_n, ay_n, az_n])
where the subscript 'n' stands for 'null shift'.
Note
-----
The constant bias is constant during the run, but varies from run-to-run.
If, for experimental purposes, you'ld like the SAME constant bias generated
every run, then this function should be modified to use the standard deviation
value (not multiplied by random number).
"""
# If the null-shift value has been generated once, then that value should be used.
# Otherwise, it will be generated and saved for the next call.
try:
return self._constant_bias
except AttributeError:
# Original code used a non-random null-shift. This could be acceptable if
# using a single vehicle, but unrealistic if used for a entire community. So now the null-shift is random.
accel_null = self._sqd['sigma_n_f'] * sp.randn(3)
gyro_null = self._sqd['sigma_n_g'] * sp.randn(3)
self._constant_bias = np.hstack((gyro_null, accel_null))
return self._constant_bias
def getPL(self,r,RSSStd):
""" Get Power Level from a given distance
Parameters
----------
r : range
RSSStd : range standard deviation
Examples
--------
>>> M = PLSmodel(f=0.3,rssnp=2.64,d0=1,sigrss=3,method='mode')
>>> PL = M.getPL(16,1)
"""
if self.method =='OneSlope':
PL=self.OneSlope(r)
elif self.method == 'mode' or self.method == 'median' or self.method == 'mean':
PLmean = self.getPLmean(r)
try:
shPLmean = np.shape(PLmean)
Xrand = RSSStd*sp.randn(shPLmean[0])
except:
Xrand = RSSStd*sp.randn()
PL = PLmean+Xrand
else :
raise NameError('Pathloss method name')
return(PL)
def gendat(TWO_KERNEL,nInd,nSnp,nCovar,minMaf=0.05,maxMaf=0.4,minSigE2=0.5,maxSigE2=1,minSigG2=0.5,maxSigG2=1):
'''
Generate synthetic SNPs and phenotype.
SNPs are iid, and there is no population structure.
Phenotype y is generated from a LMM with SNPs in a PS kernel.
Returns:
covDat
y
psSnps
'''
if TWO_KERNEL:
psSnps=gensnps(nInd,nSnp,minMaf,maxMaf)
psK=psSnps.dot(psSnps.T)
psK+=1e-5*sp.eye(nInd)
psKchol=la.cholesky(psK)
else:
psSnps=None
covDat=sp.random.uniform(0,1,(nInd,nCovar))
covWeights=sp.random.uniform(-0.5,0.5,(nCovar,1))
sigE2=sp.random.uniform(low=minSigE2,high=maxSigE2)
sigG2=sp.random.uniform(low=minSigG2,high=maxSigG2)
##generate the phenotype using the background kernel and covariates
if TWO_KERNEL:
y_pop=sp.sqrt(sigG2)*psKchol.dot(sp.randn(nInd,1))
else:
y_pop=0
y_noise=sp.randn(nInd,1)*sp.sqrt(sigE2)
y=(covDat.dot(covWeights) + y_pop + y_noise).squeeze()
return covDat, y, psSnps
def fitPairwiseModel(Y,XX=None,S_XX=None,U_XX=None,verbose=False):
N,P = Y.shape
""" initilizes parameters """
RV = fitSingleTraitModel(Y,XX=XX,S_XX=S_XX,U_XX=U_XX,verbose=verbose)
Cg = covariance.freeform(2)
Cn = covariance.freeform(2)
gp = gp2kronSum(mean(Y[:,0:2]),Cg,Cn,XX=XX,S_XX=S_XX,U_XX=U_XX)
conv2 = SP.ones((P,P),dtype=bool)
rho_g = SP.ones((P,P))
rho_n = SP.ones((P,P))
for p1 in range(P):
for p2 in range(p1):
if verbose:
print '.. fitting correlation (%d,%d)'%(p1,p2)
gp.setY(Y[:,[p1,p2]])
Cg_params0 = SP.array([SP.sqrt(RV['varST'][p1,0]),1e-6*SP.randn(),SP.sqrt(RV['varST'][p2,0])])
Cn_params0 = SP.array([SP.sqrt(RV['varST'][p1,1]),1e-6*SP.randn(),SP.sqrt(RV['varST'][p2,1])])
params0 = {'Cg':Cg_params0,'Cn':Cn_params0}
conv2[p1,p2],info = OPT.opt_hyper(gp,params0,factr=1e3)
rho_g[p1,p2] = Cg.K()[0,1]/SP.sqrt(Cg.K().diagonal().prod())
rho_n[p1,p2] = Cn.K()[0,1]/SP.sqrt(Cn.K().diagonal().prod())
conv2[p2,p1] = conv2[p1,p2]; rho_g[p2,p1] = rho_g[p1,p2]; rho_n[p2,p1] = rho_n[p1,p2]
RV['Cg0'] = rho_g*SP.dot(SP.sqrt(RV['varST'][:,0:1]),SP.sqrt(RV['varST'][:,0:1].T))
RV['Cn0'] = rho_n*SP.dot(SP.sqrt(RV['varST'][:,1:2]),SP.sqrt(RV['varST'][:,1:2].T))
RV['conv2'] = conv2
#3. regularizes covariance matrices
offset_g = abs(SP.minimum(LA.eigh(RV['Cg0'])[0].min(),0))+1e-4
offset_n = abs(SP.minimum(LA.eigh(RV['Cn0'])[0].min(),0))+1e-4
RV['Cg0_reg'] = RV['Cg0']+offset_g*SP.eye(P)
RV['Cn0_reg'] = RV['Cn0']+offset_n*SP.eye(P)
RV['params0_Cg']=LA.cholesky(RV['Cg0_reg'])[SP.tril_indices(P)]
RV['params0_Cn']=LA.cholesky(RV['Cn0_reg'])[SP.tril_indices(P)]
return RV
def fit_krr_dskl_rks_result(X,Y,Xtest,Ytest,its=100,eta=.1,C=.001,nPredSamples=30,nExpandSamples=10, kernel=(GaussianKernel,(1.))):
# random gaussian for rks
Zrks = sp.randn(len(Y),X.shape[0]) / (kernel[1]**2)
Wrks = sp.randn(len(Y))
for it in range(1,its+1):
Wrks = step_dskl_rks_krr(X,Y,Wrks,Zrks,eta/it,C,nPredSamples,nExpandSamples)
return predict_krr_rks(Xtest,Wrks,Zrks)
def _sim_from(self, set_covar='block', seed=None, qq=False):
##1. region term
if set_covar=='block':
Cr = self.block['Cr']
Cg = self.block['Cg']
Cn = self.block['Cn']
if set_covar=='rank1':
Cr = self.lr['Cr']
Cg = self.lr['Cg']
Cn = self.lr['Cn']
Lc = msqrt(Cr)
U, Sh, V = nla.svd(self.Xr, full_matrices=0)
Lr = sp.zeros((self.Y.shape[0], self.Y.shape[0]))
Lr[:, :Sh.shape[0]] = U * Sh[sp.newaxis, :]
Z = sp.randn(*self.Y.shape)
Yr = sp.dot(Lr, sp.dot(Z, Lc.T))
##2. bg term
Lc = msqrt(Cg)
Lr = self.XXh
Z = sp.randn(*self.Y.shape)
Yg = sp.dot(Lr, sp.dot(Z, Lc.T))
# noise terms
Lc = msqrt(Cn)
Z = sp.randn(*self.Y.shape)
Yn = sp.dot(Z, Lc.T)
# normalize
Y = Yr + Yg + Yn
if qq:
Y = gaussianize(Y)
Y-= Y.mean(0)
Y/= Y.std(0)
return Y
def setUp(self):
np.random.seed(1)
# generate data
N = 400
s_x = 0.05
s_y = 0.1
X = (sp.linspace(0, 2, N) + s_x * sp.randn(N))[:, sp.newaxis]
Y = sp.sin(X) + s_y * sp.randn(N, 1)
Y -= Y.mean(0)
Y /= Y.std(0)
Xstar = sp.linspace(0, 2, 1000)[:, sp.newaxis]
# define mean term
F = 1.0 * (sp.rand(N, 2) < 0.2)
mean = lin_mean(Y, F)
# define covariance matrices
covar1 = SQExpCov(X, Xstar=Xstar)
covar2 = FixedCov(sp.eye(N))
covar = SumCov(covar1, covar2)
# define gp
self._gp = GP(covar=covar, mean=mean)
def writeBackRepsAddNoise(wc1,wc2,y1,y2,geneName,n_reps):
for i in range(n_reps):
c1 = [geneName]
c2 = [geneName]
c1.extend(y1+SP.randn(y1.shape[0])*.1)
c2.extend(y2+SP.randn(y2.shape[0])*.1)
wc1.writerow(c1)
wc2.writerow(c2)
def awgn(sig,snrdb,sigpower=0):
"""Additive white gaussian noise. Assumes signal power is 0 dBW"""
if sp.iscomplexobj(sig):
noise = (sp.randn(*sig.shape) + 1j*sp.randn(*sig.shape))/math.sqrt(2)
else:
noise = sp.randn(*sig.shape)
noisev = 10**((sigpower - snrdb)/20)
return sig + noise*noisev
def ts(self, n):
R = np.empty(n)
X = np.empty(n)
X[0] = 1
for t in range(n-1):
R[t] = np.sqrt(X[t]) * randn(1)
X[t+1] = self.a0 + self.b * X[t] + self.a1 * R[t]**2
R[n-1] = np.sqrt(X[n-1]) * randn(1)
return R
def sim_bivariate(self, N):
R = np.empty(N)
X = np.empty(N)
X[0] = 1
for t in range(N-1):
R[t] = sqrt(X[t]) * randn(1)
X[t+1] = self.a0 + self.b * X[t] + self.a1 * R[t]**2
R[N-1] = sqrt(X[N-1]) * randn(1)
return R, X
def simulate_pheno(self):
Yc = sp.dot(self.mean.F[0], sp.dot(self.mean.B[0], self.mean.A[0].T))
Z = sp.randn(self.covar.G.shape[1], self.covar.Cr.X.shape[1])
Yr = sp.dot(self.covar.G, sp.dot(Z, self.covar.Cr.X.T))
_S, _U = LA.eigh(self.covar.Cn.K()); _S[_S<0] = 0
Cn_h = _U*_S**0.5
Yn = sp.dot(sp.randn(*self.mean.Y.shape), Cn_h.T)
RV = Yc+Yr+Yn
return RV
def _initParams_random(self): """ initialize the gp parameters randomly """ # gp hyper params params = limix.CGPHyperParams() if self.interaction: params['covar'] = SP.concatenate([SP.randn(self.N*self.k+1),SP.ones(1),SP.randn(1)]) else: params['covar'] = SP.randn(self.N*self.k+1) params['lik'] = SP.randn(1) return params
def _additionalInit(self):
phi_size = self.num_actions * self.num_features
if self.randomInit:
self._A = randn(phi_size, phi_size) / 100.
self._b = randn(phi_size) / 100.
else:
self._A = zeros((phi_size, phi_size))
self._b = zeros(phi_size)
self._untouched = ones(phi_size, dtype=bool)
self._count = 0
Pcross = sp.zeros(steps) #
RhoCross = sp.zeros(steps) #
Scross = sp.zeros(steps) #
K0a = sp.zeros(steps) #Tracking isentrope parameters
K1a = sp.zeros(steps)
K2a = sp.zeros(steps)
gamma_a = sp.zeros(steps)
gamma_index = sp.zeros(steps)
qa = sp.zeros(steps)
cvc_mc = sp.zeros(size)
#################################################################
# begin monte carlo, only one, encompasses all calculations.
j = 0
while j < steps:
#Calculate perturbations for everything here.
K0s = K0 + K0e * sp.randn()
K0a[j] = K0s
K1s = K1 + K1e * sp.randn()
K1a[j] = K1s
K2s = K2 + K2e * sp.randn()
K2a[j] = K2s
gamma_i = gamma0 + gamma0e * sp.randn()
gamma_a[j] = gamma_i
rho_gamma = gamma_rho + gamma_rhoe * sp.randn()
q = q0 + q0e * sp.randn()
qa[j] = q
q2_mc = q2 + q2e * sp.randn()
#rho_init_l=rho0l+rho0le*sp.randn()
rho_init_l = rho0l + 11 * sp.randn() #For asimow version
rho_init_s = rho0s + rho0se * sp.randn()
dSm = dS0 + dS0e * sp.randn()
val_obj)
print('Newton-CG: The final relative duality gap: %s \n' % gap)
print('Newton-CG: The rank of the Optimal Solution - tau*I: %s \n' %
rank_x)
print('Newton-CG: computing time for computing preconditioners: %s \n' %
prec_time)
print(
'Newton-CG: computing time for linear system solving (cgs time): %s \n'
% pcg_time)
print(
'Newton-CG: computing time for eigenvalue decompositions: =============== %s \n'
% eig_time)
print(
'Newton-CG: computing time used for equal weight calibration ============ %s \n'
% time_used)
return x_result, y
# end of the main function
# test
n = 3000
data_g_test = scipy.randn(n, n)
data_g_test = (data_g_test + data_g_test.transpose()) / 2.0
data_g_test = data_g_test - np.diag(np.diag(data_g_test)) + np.eye(n)
b = np.ones((n, 1))
tau = 0
tol = 1.0e-6
[x_test_result, y_test_result] = my_correlationmatrix(data_g_test, b, tau, tol)
# Grid of values for wealth over which function will be approximated
gridmax, gridsize = 5, 300
dx=0.01 # Gridcell size for pdf
wgrid=np.arange(0.1,gridmax,dx)
Ws=wgrid
# Lifespan is TT+1, i.e. agent dies in period T+1
TT=T
# auxiliary parameters and functions
theta1=1-theta
rho=beta
# Assume income process is U shaped + log-normal shock with mean 1 and std 0.1
sigman=0.18 # Std of log-income
yt = exp(sigman*randn(N,TT)) # Draws of shock
if yp1=='':
yp = .6-constant*1.5*(np.arange(0,1,1/(TT+2))-.5)**2
else:
yp = 1-constant*(np.arange(0,1,1/(TT+2))-.5)**2
# Parameters of the linear consumption function
agrid=np.arange(0.01,1.5,0.01) # Intercept
bgrid=np.arange(0.01,1,0.01) # MPC: Marginal propensity to consume out of wealth
# Parameters for varying the algorithm
Newt=0 # Flag for using full Hessian
fr=1 # Fractional step size
gain=0 # Gain parameter
) # Can use the Chi^2 CDF/SF to evaluate the scaled Chi^2 by rescaling the input.
pv[i0] = 1.0
return (pv, mixture, scale, dof, i0)
if __name__ == "__main__":
logging.basicConfig(level=logging.INFO)
logging.info("generate chi-2 distributed values")
scale = 3
dof = 2
mixture = 0.5
ntests = 10000
lrt = sp.zeros((ntests))
lrttest = sp.zeros((ntests))
for i in range(dof):
x = sp.randn(ntests)
xtest = sp.randn(ntests)
lrt += scale * (x * x)
lrttest += scale * (xtest * xtest)
lrt[sp.random.permutation(ntests)[0:sp.ceil(ntests * mixture)]] = 0.0
lrttest[sp.random.permutation(ntests)[0:sp.ceil(ntests * mixture)]] = 0.0
qmax = 0.2
logging.info(("create the distribution object, with qmax = %.4f" % qmax))
mix = chi2mixture(lrt=lrt, a2=None, qmax=0.2) #object constructor
logging.info(
"fit the parameter of the object by log-Pvalue quantile regression")
import time
t0 = time.time()
from scipy.optimize import curve_fit import matplotlib.pyplot as plt import time tic = time.time() '''function to optimize''' def func(u, K, tau, y0): sys = signal.lti(K, [tau, 1]) y = sys.output(u, t, y0) return y[1] '''input square signal''' global t t = linspace(0, 20, 1000) Umes = -0.5*(signal.square(2*pi*0.1*t)+ones(len(t)))+ones(len(t))+randn(len(t))/50 '''noisy output signal''' p = [1, 1, 0] Ymes = func(Umes, *p)+randn(len(Umes))/50 '''input and output signals plot''' plt.plot(t, Umes, label = 'Umes') plt.plot(t, Ymes, label = 'Ymes') '''optimization with non-linear least squares method''' popt, cov = curve_fit(func, Umes, Ymes) print(p) print(popt)
Centre,Var = spcv.kmeans(X, Num_of_clusters )
id,dist = spcv.vq(X,Centre)
print id, dist
#Sample data creation
#number of points
n = 50
t = linspace(-5, 5, n)
#parameters
a = 0.8
b = -4
x = nppp.polyval(t,[a, b])
#add some noise
xn= x+randn(n)
(ar,br) = nppp.polyfit(t,xn,1)
xr = nppp.polyval(t,[ar,br])
#compute the mean square error
err = sqrt(sum((xr-xn)**2)/n)
print('Linear regression using polyfit')
print('parameters: a=%.2f b=%.2f \nregression: a=%.2f b=%.2f, ms error= %.3f' % (a,b,ar,br,err))
print('-----------------------------------------------------')
#Linear regression using stats.linregress
(a_s,b_s,r,tt,stderr) = sps.linregress(t,xn)
print('Linear regression using stats.linregress')
print('parameters: a=%.2f b=%.2f \nregression: a=%.2f b=%.2f, std error= %.3f' % (a,b,a_s,b_s,stderr))
#matplotlib ploting
def __init__(self, net, prec=1.):
CNodeWsparse.__init__(self, net, prec=prec)
#variable initialisation in CNodeWsparse
self.sigma2 = (1.0 / prec) * SP.ones((net._D, net.components))
self.E1 = SP.randn(net._D, net.components)
self.E2diag = SP.zeros((net._D, net.components))
import backprop_network as bp
#Create two template matrices with dimensions dim*dim
dim=4
template1=np.array([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]])
template2=np.array([[1,0,0,0],[1,0,0,0],[1,0,0,0],[1,0,0,0]])
#Flatten each template into a 1D array
pattern1 = template1.reshape((1,dim*dim))
pattern2 = template2.reshape((1,dim*dim))
#Create num training instances of each pattern
num_instances = 20
noise_level=.0
pattern1_data = np.repeat(pattern1,num_instances,0)
pattern1_noise = randn(num_instances, dim*dim)
pattern1_data = pattern1_data + noise_level*pattern1_noise
pattern2_data = np.repeat(pattern2,num_instances,0)
pattern2_noise = randn(num_instances, dim*dim)
pattern2_data = pattern2_data + noise_level*pattern2_noise
#Normalise the data so it has a mean of zero. (This is an important prerequisite for PCA!)
mu1 = np.mean(pattern1_data)
pattern1_data = np.subtract(pattern1_data, mu1)
mu2 = np.mean(pattern2_data)
pattern2_data = np.subtract(pattern2_data, mu2)
#Close all currently open figures
plt.close('all')
#train
def show_training_images():
def step(self, niter):
""" xNES """
f = self.f
mu, sigma, bmat = self.mu, self.sigma, self.bmat
eta_mu, eta_sigma, eta_bmat = self.eta_mu, self.eta_sigma, self.eta_bmat
npop = self.npop
dim = self.dim
sigma_old = self.sigma_old
eyemat = eye(dim)
with joblib.Parallel(n_jobs=self.n_jobs) as parallel:
for i in range(niter):
s_try = randn(npop, dim)
z_try = mu + sigma * dot(s_try, bmat) # broadcast
f_try = parallel(joblib.delayed(f)(z) for z in z_try)
f_try = asarray(f_try)
# save if best
fitness = mean(f_try)
if fitness - 1e-8 > self.fitness_best:
self.fitness_best = fitness
self.mu_best = mu.copy()
self.counter = 0
else:
self.counter += 1
if self.counter > self.patience:
self.done = True
return
isort = argsort(f_try)
f_try = f_try[isort]
s_try = s_try[isort]
z_try = z_try[isort]
u_try = self.utilities if self.use_fshape else f_try
if self.use_adasam and sigma_old is not None: # sigma_old must be available
eta_sigma = self.adasam(eta_sigma, mu, sigma, bmat,
sigma_old, z_try)
dj_delta = dot(u_try, s_try)
dj_mmat = dot(s_try.T, s_try *
u_try.reshape(npop, 1)) - sum(u_try) * eyemat
dj_sigma = trace(dj_mmat) * (1.0 / dim)
dj_bmat = dj_mmat - dj_sigma * eyemat
sigma_old = sigma
# update
mu += eta_mu * sigma * dot(bmat, dj_delta)
sigma *= exp(0.5 * eta_sigma * dj_sigma)
bmat = dot(bmat, expm(0.5 * eta_bmat * dj_bmat))
# logging
self.history['fitness'].append(fitness)
self.history['sigma'].append(sigma)
self.history['eta_sigma'].append(eta_sigma)
# keep last results
self.mu, self.sigma, self.bmat = mu, sigma, bmat
self.eta_sigma = eta_sigma
self.sigma_old = sigma_old
def PR_MultiSine_adapt(
f1,
Nperiods,
Nsamples,
Nf=8,
fs_min=0,
fs_max=1e9,
frange=10,
log=True,
phases=None,
sample_inkr=1,
):
"""
Returns an additive normalized Multisine time series. \n
f1 = start frequency (may be adapted) \n
Nperiods = number of periods of f1 (may be increased) \n
Nsamples = Minimum Number of samples \n
Nf = number of frequencies in multi frequency mix \n
fs_min = minimum sample rate of used device (default 0) \n
fs_max = maximum sample rate of used device (default 0) \n
frange = range of frequency as a factor relative to f1 (default 10 = decade) \n
log = boolean for logarithmic (True, default) or linear (False) frequency scale \n
phases = float array of given phases for the frequencies (default=None=random) \n
deg= boolean for return phases in deg (True) or rad (False) \n
sample_inkr = minimum block of samples to add to a waveform
\n
returns: freq,phase,fs,ti,multi \n
freq= array of frequencies \n
phase=used phases in deg or rad \n
fs=sample rate \n
ti=timestamps \n
multi=array of time series values \n
"""
if (Nsamples // sample_inkr * sample_inkr !=
Nsamples): # check multiplicity of sample_inkr
Nsamples = (Nsamples // sample_inkr +
1) * sample_inkr # round to next higher multiple
T0 = Nperiods / f1 # given duration
fs0 = Nsamples / T0 # (implicitly) given sample rate
if False:
print("0 Nperiods: " + str(Nperiods))
print("0 Nsamples: " + str(Nsamples))
print("0 fs: " + str(fs0))
print("0 T0: " + str(T0))
print("0 f1: " + str(f1))
fs = fs0
if fs0 < fs_min: # sample rate too low, then set to minimum
fs = fs_min
print("sample rate increased")
elif fs0 > fs_max: # sample rate too high, set to max-allowed and
fs = fs_max
Nperiods = sp.ceil(
Nperiods * fs0 / fs_max
) # increase number of periods to get at least Nsamples samples
T0 = Nperiods / f1
print("sample rate reduced, Nperiods=" + str(Nperiods))
Nsamples = T0 * fs
if (Nsamples // sample_inkr * sample_inkr !=
Nsamples): # check multiplicity of sample_inkr
Nsamples = (Nsamples // sample_inkr +
1) * sample_inkr # round to next higher multiple
T1 = Nsamples / fs # adapt exact duration
f1 = Nperiods / T1 # adapt f1 for complete cycles
if False:
print("Nperiods: " + str(Nperiods))
print("Nsamples: " + str(Nsamples))
print("fs: " + str(fs))
print("T1: " + str(T1))
print("f1: " + str(f1))
f_res = 1 / T1 # frequency resolution
# determine a series of frequencies (freq[])
if log:
fact = sp.power(frange, 1.0 / (Nf - 1)) # factor for logarithmic scale
freq = f1 * sp.power(fact, sp.arange(Nf))
else:
step = (frange - 1) * f1 / (Nf - 1)
freq = sp.arange(f1, frange * f1 + step, step)
# auxiliary function to find the nearest available frequency
def find_nearest(
x, possible
): # match the theoretical freqs to the possible periodic freqs
idx = (sp.absolute(possible - x)).argmin()
return possible[idx]
fi_pos = sp.arange(f1, frange * f1 + f_res,
f_res) # possible periodic frequencies
f_real = []
for f in freq:
f_real.append(find_nearest(f, fi_pos))
freq = sp.hstack(f_real)
if True:
print("freq: " + str(freq))
if phases is None: # generate random phases
phase = sp.randn(Nf) * 2 * sp.pi # random phase
else: # use given phases
phase = phases
return freq, phase, T1, fs
def main():
'''Define the main function. '''
# Create a sine-wave
t = np.arange(0, 10, 0.1)
x = np.sin(t)
# Save the data in a text-file, in column form
# The formatting is a bit clumsy: data are by default row variables; so to
# get a matrix, you stack the two rows above each other, and then transpose
# the matrix
outFile = 'test.txt'
np.savetxt(outFile, np.vstack([t, x]).T)
# Read the data into a different variable
inData = np.loadtxt(outFile)
t2 = inData[:, 0] # Note that Python starts at "0"!
x2 = inData[:, 1]
# Plot the data, and wait for the user to click
plt.show()
plt.plot(t2, x2)
plt.title('Hit any key to continue')
plt.waitforbuttonpress()
# Generate a noisy line
t = np.arange(-100, 100)
# use a Python "dictionary" for named variables
par = {'offset': 100, 'slope': 0.5, 'noiseAmp': 4}
x = par['offset'] + par['slope'] * t + par['noiseAmp'] * sp.randn(len(t))
# Select "late" values, i.e. with t>10
xHigh = x[t > 10]
tHigh = t[t > 10]
# Plot the "late" data
plt.close()
plt.plot(tHigh, xHigh)
# Determine the best-fit line
# To do so, you have to generate a matrix with "time" in the first
# column, and a column of "1" in the second column:
xMat = np.vstack((tHigh, np.ones(len(tHigh)))).T
slope, intercept = np.linalg.lstsq(xMat, xHigh)[0]
# Show and plot the fit, and save it to a PNG-file with a medium resolution.
# The "modern" way of Python-formatting is used
plt.hold(True)
plt.plot(tHigh, intercept + slope * tHigh, 'r')
plt.title('Hit any key to continue')
plt.savefig('linefit.png', dpi=200)
plt.waitforbuttonpress()
plt.close()
print(('Fit line: intercept = {0:5.3f}, and slope = {1:5.3f}'.format(
intercept, slope)))
#raw_input('Thanks for using programs by Thomas!')
# If you want to know confidence intervals, best switch to "pandas"
# Note that this is an advanced topic, and requires new data structures
# such ad "DataFrames" and "ordinary-least-squares" or "ols-models".
import pandas
myDict = {'x': tHigh, 'y': xHigh}
df = pandas.DataFrame(myDict)
model = pandas.ols(y=df['y'], x=df['x'])
print(model)
#线性代数 x = np.array([[1., 2., 3.], [4., 5., 6.]]) y = np.array([[6., 23.], [-1, 7], [8, 9]]) print x print y print x.dot(y) #等价于np.dot(x,y) print np.dot(x, np.ones(3)) print np.ones(3) print np.random.seed(12345) from numpy.linalg import inv, qr from scipy import randn print 'x = randn(5,5) 随机生成5X5的矩阵' x = randn(5, 5) print x print 'mat = x.T.dot(x) 计算矩阵乘法' mat = x.T.dot(x) print mat print 'inv(mat) inv 计算方正的逆' inv(mat) print inv(mat) print 'mat.dot(inv(mat))' mat.dot(inv(mat)) print mat.dot(inv(mat)) print 'qr(mat) 计算QR分解'
def __init__(self, *args, **kwargs):
MultiModalFunction.__init__(self, *args, **kwargs)
self._signs = sign(randn(self.xdim))
self._diags = generateDiags(10, self.xdim)
self.xopt = self._k2 * self._signs
# -*- encoding:UTF-8 -*- import scipy import scipy.cluster.hierarchy as sch from scipy.cluster.vq import vq, kmeans, whiten import numpy as np import matplotlib.pylab as plt points = scipy.randn(20, 4) print(points) data = whiten(points) # print(data) centroid = kmeans(data, 3)[0] print(centroid) label = vq(np.array([[1, 1, 1, 1]]), centroid) print(label)
var_block = sp.trace(Cr_block) * trRr / float(self.Y.size - 1)
var_rank1 = sp.trace(Cr_rank1) * trRr / float(self.Y.size - 1)
RV['var_r'] = sp.array(
[var_block, var_rank1 - var_block, var_r - var_rank1])
return RV
if __name__ == '__main__':
if 1:
N = 1000
P = 2
S = 20
Xr = 1. * (sp.rand(N, S) < 0.2)
Y = sp.randn(N, P)
X = sp.randn(N, 100)
Rg = sp.dot(X, X.T) / float(X.shape[1])
Rg += 1e-4 * sp.eye(X.shape[0])
Sg, Ug = la.eigh(Rg)
pdb.set_trace()
t0 = time.time()
mvset = MvSetTestFull(Y=Y, Xr=Xr, Sg=Sg, Ug=Ug, factr=1e7)
mvset.assoc()
mvset.gxe()
mvset.gxehet()
print('.. permutations')
mvset.assoc_null(n_nulls=2)
print('.. bootstrap gxe')
def setRandomParams(self):
"""
set random hyperparameters
"""
params = SP.randn(self.getNumberParams())
self.setParams(params)
def init(self,
init_data,
Pi=None,
terms=None,
noise='gauss',
init_factors=None,
unannotated_id="hidden",
covariates=None,
dropFactors=True):
#initialize the model instance"""
#AGAussNode is defined in ExpresisonNet
#expr Y ~ N(\mu= expr, \sigma = 0)
pattern_hidden = re.compile(unannotated_id + '\d')
pattern_hiddenSparse = re.compile(unannotated_id + "\D*parse" + "\d")
Ihidden = SP.array(
[pattern_hidden.match(term) is not None for term in terms])
IhiddenSparse = SP.array(
[pattern_hiddenSparse.match(term) is not None for term in terms])
self.terms = terms
if not isinstance(init_data, AGaussNode):
raise Exception("initialization is only possible from a GaussNode")
self.Z = CNodeZ(node=init_data)
#datanode hold the data
self.dataNode = self.Z
if self.noise == 'poisson':
self.kappa = 1. / 4.0 + 0.17 * self.Z.E1.max(0)
if self.noise == 'hurdle':
self.meanX = self.Z.E1.copy()
self.isExpressed = (self.Z.E1 > 0) * 1.
self.numExpressed = SP.sum(self.Z.E1 > 0, 0)
self.doUpdate = SP.ones((Pi.shape[1], )).astype("int")
self.dropFactors = dropFactors
#known covariates
if init_factors != None and 'Known' in init_factors:
self.nKnown = init_factors['Known'].shape[1]
self.Known = init_factors['Known']
assert self.Known.shape[0] == self.Z.E1.shape[0]
self.nHidden = self.components - self.nKnown
if 'Intr' in init_factors:
self.nKnown = init_factors['Known'].shape[1]
self.Known = init_factors['Known']
assert self.Known.shape[0] == self._N
self.nHidden = self.components - self.nKnown
elif not (covariates is None):
self.nKnown = covariates.shape[1]
#self.iKnown = SP.arange(covariates.shape[1])
self.Known = covariates
assert self.Known.shape[0] == self.Z.E1.shape[0]
self.nHidden = self.components - self.nKnown
#mean term/'bias'
if terms[0] == 'bias':
self.Known = SP.hstack(
SP.ones((self.Z.E1.shape[0], 1), self.Known))
self.nKnown += 1
self.nHidden = self.nHidden - 1
#mean term/'bias'
elif terms[0] == 'bias':
self.Known = SP.ones(
(self.Z.E1.shape[0], 1)) #make sure this was correct?
self.nKnown = 1
self.nHidden = self.components - self.nKnown
else:
self.nHidden = self.components
self.nKnown = 0
#set some attributes that we need frequently for the updates, inculuding
#number and idx of hidden and sparse hidden terms
if init_factors is not None and 'iLatent' in init_factors:
self.iLatent = init_factors['iLatent']
self.nLatent = len(init_factors['iLatent'])
else:
self.iLatent = SP.where(Ihidden == True)[0]
self.nLatent = len(self.iLatent)
if init_factors is not None and 'iLatentSparse' in init_factors:
self.iLatentSparse = init_factors['iLatentSparse']
self.nLatentSparse = len(init_factors['iLatentSparse'])
else:
self.iLatentSparse = SP.where(IhiddenSparse == True)[0]
self.nLatentSparse = len(self.iLatentSparse)
if init_factors != None and 'onF' in init_factors:
self.onF = init_factors['onF']
else:
self.onF = self.Z.E1.shape[0] / 10000. #self.nScale
if init_factors != None and 'initZ' in init_factors:
self.initZ = init_factors['initZ']
else:
self.initZ = Pi.copy()
self.initZ[self.initZ < .2] = 0.01
self.nAnno = self.nHidden - self.nLatentSparse - self.nLatent
#pdb.set_trace()
#Pi is likelihood of link for genes x factors
#self.Pi = Pi
# set dimensionality of the data
[self._N, self._D] = self.Z.E1.shape
self.ZZ = SP.zeros((self._D, ))
for d in range(self._D):
self.ZZ[d] = SP.sum(self.Z.E1[:, d] * self.Z.E1[:, d], 0)
PiPriors = [[1., 1.], self.priors['PiDense']['priors'],
self.priors['PiSparse']['priors'], [1., 1.]]
self.Pi = CNodePi(self, PiPriors, Pi)
self.piInit = Pi.copy()
self.nodes = {
'S': CNodeSsparse(self),
'Pi': self.Pi,
'W': CNodeWsparseVEM(self),
'Alpha': CNodeAlphasparse(self, self.priors['Alpha']['priors']),
'Eps': CNodeEpsSparse(self, self.priors['Eps']['priors'])
}
for n in list(self.nodes.keys()):
setattr(self, n, self.nodes[n])
self.Non = (self.Pi.E1 > .5).sum(0)
if self.Pi is not None:
assert self.Pi.E1.shape == (self._D, self.components)
#pca initialisation
Ion = None
if self.initType == 'pca':
Ion = random.rand(self.Pi.E1.shape[0],
self.Pi.E1.shape[1]) < self.Pi.E1
self.W.C[:, :, 0] = self.Pi.E1.copy()
#self.W.C[:,:,0][self.W.C[:,:,0]<=.2] = .1
#self.W.C[:,:,0][self.W.C[:,:,0]>=.8] = .9
for k in range(self.components):
sv = linalg.svd(self.Z.E1[:, Ion[:, k]], full_matrices=0)
[s0,
w0] = [sv[0][:, 0:1],
S.dot(S.diag(sv[1]), sv[2]).T[:, 0:1]]
v = s0.std(axis=0)
s0 /= v
w0 *= v
self.S.E1[:, k] = s0.ravel()
self.W.E1[Ion[:, k], k] = w0.ravel()
self.W.E1[~Ion[:, k], k] *= self.sigmaOff
self.S.diagSigmaS[:, k] = 1. / 2
if self.initType == 'pcaRand':
random.seed(222)
if self.noise == 'hurdle':
Zstd = self.Z.E1.copy()
self.meanZ = Zstd.mean(0)
Zstd -= Zstd.mean(0)
elif self.noise == 'poisson':
Zstd = SP.log2(self.Z.E1.astype('float64') + 1)
Zstd -= Zstd.mean(0)
else:
Zstd = self.Z.E1
#Zstd -= Zstd.mean(0)
Ion = random.rand(self.Pi.E1.shape[0],
self.Pi.E1.shape[1]) < self.initZ
self.W.C[:, :, 0] = self.initZ
self.W.C[:, :, 0][self.W.C[:, :, 0] <= .1] = .1
self.W.C[:, :, 0][self.W.C[:, :, 0] >= .9] = .9
self.W.C[:, :, 1] = 1. - self.W.C[:, :, 0]
for k in range(self.nHidden):
k += self.nKnown
if Ion[:, k].sum() > 5:
#pdb.set_trace()
if self.S.E1.shape[0] < 500:
pca = PCA(n_components=1)
else:
pca = PCA(n_components=1,
iterated_power=2,
svd_solver='randomized')
s0 = pca.fit_transform(Zstd[:, Ion[:, k]])
self.S.E1[:, k] = (s0[:, 0])
self.S.E1[:, k] = self.S.E1[:, k] / self.S.E1[:, k].std()
else:
self.S.E1[:, k] = random.randn(self._N, )
self.W.E1[:, k] = SP.sqrt(1. / self.components) * SP.randn(
self._D)
self.S.diagSigmaS[:, k] = 1. / 2
if self.nKnown > 0:
for k in SP.arange(self.nKnown):
self.W.E1[:, k] = SP.sqrt(1. / self.components) * SP.randn(
self._D)
self.S.diagSigmaS[:, k] = 1. / 2
self.S.E1[:, SP.arange(self.nKnown)] = self.Known
if self.nLatent > 0:
for iL in self.iLatent:
self.S.E1[:, iL] = random.randn(self._N, )
# if self.nLatentSparse>0:
# for iL in self.iLatentSparse:
# #self.S.E1[:,iL] = random.randn(self._N,)
# pca = RandomizedPCA(n_components=iL-self.nLatent+1)
# s0 = pca.fit_transform(Zstd[:,Ion[:,iL]])
# self.S.E1[:,iL] =(s0[:,iL-self.nLatent])
# self.S.E1[:,iL] = self.S.E1[:,iL]/self.S.E1[:,iL].std()
if self.saveInit == True:
self.initS = self.S.E1.copy()
elif self.initType == 'greedy':
self.S.E1 = random.randn(self._N, self.components)
self.W.E1 = random.randn(self._D, self.components)
Ion = (self.Pi.E1 > 0.5)
self.W.E1[~Ion] *= self.sigmaOff
for k in range(Ion.shape[1]):
self.W.E1[Ion[:, k]] *= self.sigmaOn[k]
elif self.initType == 'prior':
Ion = random.rand(self.Pi.E1.shape[0],
self.Pi.E1.shape[1]) < self.Pi.E1
self.W.E1[~Ion] *= self.sigmaOff
for k in range(Ion.shape[1]):
self.W.E1[Ion[:, k], k] *= self.sigmaOn[k]
elif self.initType == 'on':
for k in range(Ion.shape[1]):
self.W.E1[:, k] *= self.sigmaOn[k]
elif self.initType == 'random':
for k in range(self.Pi.E1.shape[1]):
self.S.diagSigmaS[:, k] = 1. / 2
self.S.E1[:, k] = SP.randn(self._N)
self.W.E1 = SP.randn(self._D, self.Pi.E1.shape[1])
self.W.C[:, :, 0] = self.Pi.E1
self.W.C[:, :, 0][self.W.C[:, :, 0] <= .2] = .1
self.W.C[:, :, 0][self.W.C[:, :, 0] >= .8] = .9
if self.nKnown > 0:
for k in SP.arange(self.nKnown):
self.W.E1[:, k] = SP.sqrt(1. / self.components) * SP.randn(
self._D)
self.S.diagSigmaS[:, k] = 1. / 2
self.S.E1[:, SP.arange(self.nKnown)] = self.Known
if self.saveInit == True:
self.initS = self.S.E1.copy()
elif self.initType == 'data':
assert ('S' in list(init_factors.keys()))
assert ('W' in list(init_factors.keys()))
# Ion = init_factors['Ion']
Sinit = init_factors['S']
Winit = init_factors['W']
self.W.C[:, :, 0] = self.Pi.E1
self.W.C[:, :, 0][self.W.C[:, :, 0] <= .2] = .1
self.W.C[:, :, 0][self.W.C[:, :, 0] >= .8] = .9
for k in range(self.components):
self.S.E1[:, k] = Sinit[:, k]
self.W.E1[:, k] = Winit[:, k]
self.S.diagSigmaS[:, k] = 1. / 2
def perturbParams(self, pertSize=1e-3):
"""
slightly perturbs the values of the parameters
"""
params = self.getParams()
self.setParams(params + pertSize * SP.randn(params.shape[0]))
def compute_initial_figure(self):
self.axes.plot(sp.randn(100))
plt.show()
pass
import matplotlib.pyplot as plt
from mpl_format.axes.axis_utils import new_axes
from numpy import arange
from scipy import randn
from scipy.stats import norm
from probability.distributions.conjugate._inv_gamma_normal_conjugate import \
_InvGammaNormalConjugate
x = arange(0, 20.01, 0.01)
mu, sigma = 2, 3
x_i = mu + sigma * randn(1000)
dist = _InvGammaNormalConjugate(alpha=1, beta=1, x=x_i, mu=2)
def plot_parameters():
ax = new_axes()
dist.prior().plot(x=x, color='r', ax=ax)
dist.posterior().plot(x=x, color='g', ax=ax)
ax.legend()
plt.show()
def plot_predictions():
ax = new_axes()
predicted = dist.rvs(100000)
ax.hist(predicted, bins=100, density=True, label='PPD samples')
x_actual = arange(predicted.min(), predicted.max(), 0.01)
actual = norm(loc=mu, scale=sigma).pdf(x_actual)
def testCoefficientsGenerateCorrectDataset(self):
coeffs = randn(self.model.GetNumberOfPrincipalComponents())
s = self.model.DrawSample(coeffs)
computed_coeffs = self.model.ComputeCoefficientsForDataset(s)
diff = (coeffs - computed_coeffs)[:-1] # we ignore the last coefficient
self.assertTrue((diff < 1e-3).all()) #don't make the threshold too small, as we are dealing with floats
def generate(self):
return scipy.randn() * self.std + self.mean
##################
config.read(os.path.expanduser(laccfg.cfg_fn))
mut_region_start = config.getint('Input', 'mut_region_start')
mut_region_length = config.getint('Input', 'mut_region_length')
seq_start = config.getint('Input', 'seqstart')
seq_end = config.getint('Input', 'seqend')
datab0 = config.get('Input', 'data_fn1')
datab01 = config.get('Input', 'data_fn2')
datab02 = config.get('Input', 'data_fn3')
datab03 = config.get('Input', 'data_fn4')
datab04 = config.get('Input', 'data_fn5')
# initialize random energy matrix
emat_0 = MCMC_utils_mscs.fix_matrix_gauge(
sp.randn(4, mut_region_length + 21)
) #RNAP emat from 0 to mut_region length, CRP emat from mut_region length to mut_region_length + 20, all other parameters in last collumn
emat_0[:, -1] = np.array(
[-5, -3, 2.5, 2.5]
) #interaction energy, Additive constant to CRP matrix, multiplicative constant for CRP, mutliplicative constant for RNAP
# load in the data
numseq = [[] for i in range(0, 4)]
seq_mat = [[] for i in range(0, 4)]
sequences0 = readcollatedremoveoligos.collatedmat(datab0)
sequences1 = readcollatedremoveoligos.collatedmat(datab01)
sequences2 = readcollatedremoveoligos.collatedmat(datab02)
sequences3 = readcollatedremoveoligos.collatedmat(datab03)
sequences4 = readcollatedremoveoligos.collatedmat(datab04)
'http://fond-d-ecran-gratuit.org/photos/plage-mer-petites-vagues.jpg'
).resize(800, 600)
kite_base = Image(
'http://www.winds-up.com/images/annonces/7915_1.jpg').resize(
50, 50).invert()
disp = Display()
i_loop = 0
#pid = PID.PID(1, 1, 0.1)
offset = sp.pi / 3 * 0
kite_model = kiteModel()
dX = 0 * kite_model.X
while disp.isNotDone():
setpoint = sp.pi / 1.7 * sp.sin(2 * sp.pi / 7 * time.time()) + offset
i_loop = i_loop + 1
order = 0 + 0 * sp.randn(
1) / 5 + 2.0 * disp.mouseX / background.width - 1
#error = X[0] -setpoint
#order = sp.randn(1)/100 + pid.computeCorrection(error, dX[0]/dt-0)
#pid.incrementTime(error, dt)
dt = 0.1
kite_model.update(order, dt)
print kite_model.X
kite = kite_base.rotate(sp.rad2deg(kite_model.X[0]),
fixed=False).invert()
#kite.save(disp)d
#background.blit(kite, (799,0)).save(disp)
toDisplay = background.blit(
kite.invert(),
(max(
-kite.width + 1,
def send_pkg(sock, pkg):
"""send one SimPkg"""
sock.sendall(pkg.packed_size)
sock.sendall(pkg())
##---MAIN
if __name__ == '__main__':
print
print 'PACKAGE TEST - constructor with randn(4,4) and arange(10)'
mypkg = SimPkg(SimPkg.T_UKN, 1337, 666, (N.randn(4, 4), N.arange(10)))
print mypkg
print
print 'PACKAGE TEST - from package'
newpkg = SimPkg.from_data(mypkg.payload)
print newpkg
print
print 'mypkg == newpkg :', mypkg == newpkg
print
print ' --- %s \n --- \n equals \n --- %s \n --- \n %s' % (
mypkg(), newpkg(), mypkg() == newpkg())
print
print 'unpack(\'!I\', newpkg.packed_size)[0] == len(newpkg) :', unpack(
'!I', newpkg.packed_size)[0] == len(newpkg)
print
print 'PACKAGE TEST DONE'
upload, perform the operation, and then download again, so for small times the CPU performs better. On mine at n=1000 it's about the same, but for N=4000 the GPU is 10x faster. - I'm not sure how you're supposed to indicate failure and return in a Weave inline function, so that's just ignored for the moment, if one of the functions returns an error the program will probably just crash. ''' from numpy import * from scipy import weave from scipy import randn import time n = 4000 x = array(randn(n, n), order='F') y = array(randn(n, n), order='F') z = array(zeros((n, n)), order='F') code = ''' cublasStatus status; double *d_x = 0; double *d_y = 0; double *d_z = 0; double alpha = 1.0; double beta = 0.0; int n2 = n*n; //fprintf (stderr, "fprintf working\\n"); status = cublasInit();
import sys
sys.path.append(r'./..')
sys.path.append(r'./../../../pygp')
#sys.path.append(r'./../../build/debug.win32/interfaces/python')
import limix
print limix.__file__
import pygp.covar.linear as lin
import pygp.covar.se as se
import pygp.covar.gradcheck as GC
import pygp.covar.combinators as comb
import scipy as SP
import pdb
n_dimensions = 3
X = SP.randn(3, n_dimensions)
params = SP.zeros([0])
if 0:
c1 = limix.CCovLinearISO()
c2 = lin.LinearCFISO(n_dimensions=n_dimensions)
c1.setX(X)
K1 = c1.K()
K2 = c2.K(params, X, X)
dK1 = c1.Kgrad_param(0)
dK2 = c2.Kgrad_theta(params, X, 0)
@cached('Yres')
def Yres(self):
return self.Y - self.predict_in_sample()
@cached('Yres')
def yres(self):
r = vec(self.Yres())
if self._miss:
r = r[~self._veIok]
return r
if __name__ == '__main__':
# define phenotype
N = 1000
P = 4
Y = sp.randn(N, P)
# define fixed effects
F = []
A = []
F.append(sp.randn(N, 3))
F.append(sp.randn(N, 2))
A.append(sp.eye(P))
A.append(sp.ones((1, P)))
pdb.set_trace()
mean = MeanKronSum(Y, F, A)
'''
barcodefn = config.get('Input','barcodefn')
barcode_dict = {}
reverse_dict = {}
csvfile = open(barcodefn,'r')
reader = csv.DictReader(csvfile)
for row in reader:
barcode_dict[row['experiment_name']] = row['fwd_barcode']
reverse_dict[row['experiment_name']] = row['rev_barcode']
'''
seq_mat_temp, batch_vec_temp = MCMC_utils.load_unique_seqs_batches(
data_fn, seq_start + mut_region_start, mut_region_length)
emat_0 = MCMC_utils.fix_matrix_gauge(sp.randn(4, mut_region_length))
# shuffle the elements of seq_mat and batch_vec. This will prevent
# spuriously high mutual information values
index_shuf = range(len(batch_vec_temp))
sp.random.shuffle(index_shuf)
seq_mat = sp.zeros(
[4, len(seq_mat_temp[0, :, 0]),
len(seq_mat_temp[0, 0, :])], dtype='int')
batch_vec = sp.zeros_like(batch_vec_temp)
for i, i_s in enumerate(index_shuf):
seq_mat[:, :, i] = seq_mat_temp[:, :, i_s]
batch_vec[i] = batch_vec_temp[i_s]
def _produceSample(self):
return randn(self.numParameters)
