def generation(Fk,Q,U,H,R,x_initial,n_iters): N = Fk.shape[0] states = sp.zeros((N,n_iters)) states[:,0] = x_initial observations = sp.zeros((H.shape[0],n_iters)) observations[:,0] = x_initial[0:2] mean = sp.zeros(H.shape[0]) for i in xrange(n_iters-1): states[:,i+1] = sp.dot(Fk,states[:,i]) + U + rand.multivariate_normal(sp.zeros(N),Q,1) observations[:,i+1] = sp.dot(H,states[:,i+1]) + rand.multivariate_normal(mean,R,1) return states,observations
def reconstruct(self, X):
n_features = sp.atleast_2d(X).shape[1]
latent = sp.dot(self.inv_M, sp.dot(self.weight.T, (X - self.predict_mean).T))
eps = sprd.multivariate_normal(sp.zeros(n_features), self.sigma2 * sp.eye(n_features))
recons = sp.dot(self.weight, latent) + self.predict_mean + eps
return recons
def _sample(self, n=1):
"""sampling"""
rval = sp_rd.multivariate_normal(sp.zeros(self._nc),
self._sample_vars[1], n)
for k in xrange(self._sample_vars[0].shape[2]):
rval[k] += sp.dot(self._sample_coef, self._sample_mem)
self._sample_mem.extendleft(rval[k, ::-1])
return rval
def plotCurves(self, showSamples=False, force2D=True):
from pylab import clf, hold, plot, fill, title, gcf, pcolor, gray
if not self.calculated:
self._calculate()
if self.indim == 1:
clf()
hold(True)
if showSamples:
# plot samples (gray)
for _ in range(5):
plot(
self.testx,
self.pred_mean + random.multivariate_normal(zeros(len(self.testx)), self.pred_cov),
color="gray",
)
# plot training set
plot(self.trainx, self.trainy, "bx")
# plot mean (blue)
plot(self.testx, self.pred_mean, "b", linewidth=1)
# plot variance (as "polygon" going from left to right for upper half and back for lower half)
fillx = r_[ravel(self.testx), ravel(self.testx[::-1])]
filly = r_[self.pred_mean + 2 * diag(self.pred_cov), self.pred_mean[::-1] - 2 * diag(self.pred_cov)[::-1]]
fill(fillx, filly, facecolor="gray", edgecolor="white", alpha=0.3)
title("1D Gaussian Process with mean and variance")
elif self.indim == 2 and not force2D:
from matplotlib import axes3d as a3
fig = gcf()
fig.clear()
ax = a3.Axes3D(fig) # @UndefinedVariable
# plot training set
ax.plot3D(ravel(self.trainx[:, 0]), ravel(self.trainx[:, 1]), ravel(self.trainy), "ro")
# plot mean
(x, y, z) = map(
lambda m: m.reshape(sqrt(len(m)), sqrt(len(m))), (self.testx[:, 0], self.testx[:, 1], self.pred_mean)
)
ax.plot_wireframe(x, y, z, colors="gray")
return ax
elif self.indim == 2 and force2D:
# plot mean on pcolor map
gray()
# (x, y, z) = map(lambda m: m.reshape(sqrt(len(m)), sqrt(len(m))), (self.testx[:,0], self.testx[:,1], self.pred_mean))
m = floor(sqrt(len(self.pred_mean)))
pcolor(self.pred_mean.reshape(m, m)[::-1, :])
else:
print("plotting only supported for indim=1 or indim=2.")
def _nobj_PI(self,mu,sigma):
cov = diag(array(sigma)**2)
rands = random.multivariate_normal(mu,cov,self.n)
num = 0 #number of cases that dominate the current Pareto set
for random_sample in rands:
for par_point in self.y_star:
#par_point = [p[2] for p in par_point.outputs]
if self._dom(par_point,random_sample):
num = num+1
break
pi = (self.n-num)/float(self.n)
return pi
def query(self, size=1):
"""return noise samples
:Parameters:
size : int
Number of samples to produce.
Default=1
"""
return NR.multivariate_normal(
self.mu,
self.sigma,
size
)
def _ar_model_sim(A, C, n=1, n_discard=0, mean=None, check=False):
"""simulates data for a VARMA model
:Parameters:
A : ndarray
AR Coeffitient matrix
C : ndarray
Noise covariance matrix
n : int
Number od datapoints to simulate with the process
n_discard : int
Number od datapoints to discard befor taking datapoints for the
simulation.
mean : ndarray
Mean vector for the process
"""
# inits and checks
if mean is None:
mean = N.zeros(A.shape[0])
else:
if mean.size != A.shape[0]:
raise ValueError('mean vector has wrong shape!')
m = C.shape[0]
p = A.shape[1] / m
if p != round(p):
raise ValueError('Bad arguments, p not an integer! %s' % p)
# check for stable model
if check is True:
ar_model_check_stable(A)
# generate data
err = NR.multivariate_normal(mean, C, n_discard + n)
x = N.zeros((p, m))
rval = N.zeros((p + n_discard + n, m))
for k in xrange(p, p + n_discard + n):
for j in xrange(p):
x[j, :] = N.dot(rval[k - j - 1, :], A[:, j * m:(j + 1) * m])
rval[k, :] = x.sum(axis=0) + err[k - p, :]
# return
return rval[p + n_discard:, :]
def _filt_run(self,dat,filt,do_sim=False,vplot=True,nrange=1):
if self.doplot and vplot:
errorbar(dat[0],dat[1],dat[2],fmt="o")
new = True
if new:
mymodel = Model(self.fitfunc_small_te,extra_args=[dat[1],dat[2],False])
else:
mymodel = Model(self.fitfunc_te) #,extra_args=[dat[1],dat[2],False])
# get some good guesses
try:
scale = trim_mean(dat[1],0.3)
except:
scale = mean(dat[1])
offset = 1.0 #trim_mean(dat[1],0.3)
t0 = median(dat[0])
umin = 1.0
b = 0.0 ## trending slope
mydata = RealData(dat[0],dat[1],sx=1.0/(60*24),sy=dat[2])
trange = list(linspace(min(dat[0]),max(dat[0]),nrange))
maxi = (dat[1] == max(dat[1])).nonzero()[0]
trange.extend(list(dat[0][maxi]))
trange.extend([t0, max(dat[0]) + 10, max(dat[0]) + 100])
final_output = None
for t0i in trange:
for te in 10**linspace(log10(2),log10(200),nrange):
if new:
pinit = [te,umin,t0i] # ,scale,offset,b]
else:
pinit = [te,umin,t0i ,scale,offset,b]
myodr = ODR(mydata,mymodel,beta0=pinit)
myoutput = myodr.run()
if final_output is None:
final_output = myoutput
old_sd_beta = final_output.sd_beta
continue
if trim_mean(log10(myoutput.sd_beta / final_output.sd_beta),0.0) < 0.0 and \
myoutput.res_var <= final_output.res_var and (myoutput.sd_beta == 0.0).sum() <= (final_output.sd_beta == 0.0).sum():
final_output = myoutput
if 1:
t = linspace(min(dat[0]),max([max(dat[0]),final_output.beta[2] + 6*final_output.beta[0]]),1500)
if new:
tmp = self.fitfunc_small_te(final_output.beta,dat[0],dat[1],dat[2],True)
#print tmp, "***"
p = list(final_output.beta)
p.extend([tmp[0],tmp[1],tmp[2]])
y = array(self.modelfunc_small_te(p,t))
else:
p = final_output.beta
y = self.fitfunc_te(final_output.beta,t)
#print final_output.beta
if self.doplot:
plot(t,y)
xlabel('Time [days]')
ylabel('Relative Flux Density')
if do_sim:
for i in range(10):
tmp = r.multivariate_normal(myoutput.beta, myoutput.cov_beta)
if self.doplot:
plot(t, self.a_te(tmp[0],tmp[1],tmp[2],tmp[3],tmp[4],tmp[5],t),"-")
return (final_output, p, new)
def draw(self):
if not self.calculated:
self._calculate()
return self.pred_mean + random.multivariate_normal(zeros(len(self.testx)), self.pred_cov)
def draw(self):
if not self.calculated:
self._calculate()
return self.pred_mean + random.multivariate_normal(
zeros(len(self.testx)), self.pred_cov)
m = np.array([[0, 0, 0], [1, 0, 0], [1, 0, 1], [0, 0, 1]]).T
# eigenvalues gaussian covariance matrices
lam = np.array([.12, .11, .17, .14])
# sampling and labeling
X = np.zeros((n, N))
rnd = random.rand(N)
temp = np.insert(np.cumsum(class_prior), 0, 0)
y = np.zeros(N)
for i in range(NC):
ind = (rnd >= temp[i]) & (rnd < temp[i + 1])
y[ind] = i + 1
X[:, ind] = random.multivariate_normal(m[:, i],
np.eye(n) * lam[i], np.sum(ind)).T
#-------------------------------------------------------------------------
# Part A: minimum probability of error classification (MAP classification)
#-------------------------------------------------------------------------
decisionMAP = np.zeros(N)
for i in range(N):
conditional = np.zeros(NC)
for j in range(NC):
conditional[j] = multivariate_normal.pdf(X[:, i],
mean=m[:, j],
cov=(np.eye(n) * lam[j]))
decisionMAP[i] = np.argmax(conditional * class_prior) + 1
def _filt_run(self, dat, filt, do_sim=False, vplot=True, nrange=1):
if self.doplot and vplot:
errorbar(dat[0], dat[1], dat[2], fmt="o")
new = True
if new:
mymodel = Model(self.fitfunc_small_te,
extra_args=[dat[1], dat[2], False])
else:
mymodel = Model(
self.fitfunc_te) #,extra_args=[dat[1],dat[2],False])
# get some good guesses
try:
scale = trim_mean(dat[1], 0.3)
except:
scale = mean(dat[1])
offset = 1.0 #trim_mean(dat[1],0.3)
t0 = median(dat[0])
umin = 1.0
b = 0.0 ## trending slope
mydata = RealData(dat[0], dat[1], sx=1.0 / (60 * 24), sy=dat[2])
trange = list(linspace(min(dat[0]), max(dat[0]), nrange))
maxi = (dat[1] == max(dat[1])).nonzero()[0]
trange.extend(list(dat[0][maxi]))
trange.extend([t0, max(dat[0]) + 10, max(dat[0]) + 100])
final_output = None
for t0i in trange:
for te in 10**linspace(log10(2), log10(200), nrange):
if new:
pinit = [te, umin, t0i] # ,scale,offset,b]
else:
pinit = [te, umin, t0i, scale, offset, b]
myodr = ODR(mydata, mymodel, beta0=pinit)
myoutput = myodr.run()
if final_output is None:
final_output = myoutput
old_sd_beta = final_output.sd_beta
continue
if trim_mean(log10(myoutput.sd_beta / final_output.sd_beta),0.0) < 0.0 and \
myoutput.res_var <= final_output.res_var and (myoutput.sd_beta == 0.0).sum() <= (final_output.sd_beta == 0.0).sum():
final_output = myoutput
if 1:
t = linspace(
min(dat[0]),
max([
max(dat[0]),
final_output.beta[2] + 6 * final_output.beta[0]
]), 1500)
if new:
tmp = self.fitfunc_small_te(final_output.beta, dat[0], dat[1],
dat[2], True)
#print tmp, "***"
p = list(final_output.beta)
p.extend([tmp[0], tmp[1], tmp[2]])
y = array(self.modelfunc_small_te(p, t))
else:
p = final_output.beta
y = self.fitfunc_te(final_output.beta, t)
#print final_output.beta
if self.doplot:
plot(t, y)
xlabel('Time [days]')
ylabel('Relative Flux Density')
if do_sim:
for i in range(10):
tmp = r.multivariate_normal(myoutput.beta,
myoutput.cov_beta)
if self.doplot:
plot(
t,
self.a_te(tmp[0], tmp[1], tmp[2], tmp[3], tmp[4],
tmp[5], t), "-")
return (final_output, p, new)
mu2 = np.array([5, 3])
cov2 = np.eye(2) * 2
mu3 = np.array([8, 12])
cov3 = np.array([3.4, 0, 0, 5.1]).reshape(2, 2)
# multinom params
p1 = 0.4
p2 = 0
p3 = 1 - p2 - p1
# random draws
rnd.seed(1)
knum = rnd.multinomial(draws, (p1, p2, p3))
gaus1 = rnd.multivariate_normal(mu1, cov1, knum[0])
gaus2 = rnd.multivariate_normal(mu2, cov2, knum[1])
gaus3 = rnd.multivariate_normal(mu3, cov3, knum[2])
# join columns into dataframe
x1 = pd.Series(np.r_[gaus1[:, 0], gaus2[:, 0], gaus3[:, 0]])
x2 = pd.Series(np.r_[gaus1[:, 1], gaus2[:, 1], gaus3[:, 1]])
c = pd.Series(np.r_[np.zeros(knum[0]), np.ones(knum[1]), np.ones(knum[2]) * 2])
dat = {"x1": x1, "x2": x2, "c": c}
clustData = pd.DataFrame(dat)
# plot clusters
#plt.scatter(clustData["x1"], clustData["x2"], c = clustData["c"])
#plt.show()
### Set Clustering Prior Paramteres ###
def multinormal(n, Mu, Sigma):
return random.multivariate_normal(Mu, Sigma, n)
