def log_likelihood(self):
# mu = np.dot(self.Z, self.W.T)
# return -0.5 * np.sum(((self.X - mu) * self.mask) ** 2 / self.sigmasq)
# Compute the marginal likelihood, integrating out z
mu_x = self.mean
Sigma_x = self.W.dot(self.W.T) + np.diag(self.sigmasq)
from scipy.stats import multivariate_normal
if not np.all(self.mask):
# Find the patterns of missing dta
missing_patterns = np.unique(self.mask, axis=0)
# Evaluate the likelihood for each missing pattern
lls = np.zeros(self.N)
for pat in missing_patterns:
inds = np.all(self.mask == pat, axis=1)
lls[inds] = \
multivariate_normal(mu_x[pat], Sigma_x[np.ix_(pat, pat)])\
.logpdf(self.X[np.ix_(inds, pat)])
else:
lls = multivariate_normal(mu_x, Sigma_x).logpdf(self.X)
return lls
def cov_check():
count_yes = 0
count_no = 0
cov_total = numpy.zeros((3,3))
vector_total = []
for i in xrange(10000):
#vector = numpy.random.uniform(-1, 1, size=6)
fi = numpy.zeros((3,3))
fi[numpy.diag_indices(3)] = numpy.random.uniform(-10, 10, size=3)
fi[numpy.tril_indices(3, -1)] += numpy.random.uniform(-10, 10, size=3)
cov_mat = numpy.dot(fi, fi.T)
try:
multivariate_normal([1,1,1], cov=cov_mat)
count_yes += 1
cov_total += cov_mat
vec = []
vec.append(cov_total[0][0])
vec.append(cov_total[1][1])
vec.append(cov_total[2][2])
vec.append(cov_total[0][1])
vec.append(cov_total[0][2])
vec.append(cov_total[1][2])
vector_total.append(vec)
except:
print "nope"
print cov_mat
count_no += 1
print count_yes, count_no
return cov_total, numpy.array(vector_total)
def Gibbs_sample_slow_scipy_version(param_dict, non_inf=False):
'''Draw a sample from the Normal-Wishart model using the buit-in scipy distributions( significantly slower).
Based on Gelman et al.(2013, 3 ed., chapter 4).
Parameters
---------
param_dict: python-dict
dictionary with sufficient statistics and parameters from a multivariate data-set,
obtained through the functions 'make_param_dict' and 'update_param_dict'.
non_inf: Boolean.
This models tends weight heavily the distance from the prior to the empirical mean.
If a non-informative prior is used, it's advisable to use this option. The parametrization
will correspond to the multivariate Jeffreys prior density.
Output
--------
Returns a d-dimensional draw from the Normal-Wishart model. For multiple samples,
use the function 'Gibbs_sampler' with one of the options:
('slow'): non_inf = False
('nonInfSlow'): non_inf = True
'''
if non_inf:
Prec_m = sts.wishart(df = param_dict['n']-1., scale=param_dict['invS_m']).rvs()
Sigma_m = np.linalg.inv(Prec_m)
mu = sts.multivariate_normal(mean= param_dict['E_mu'], cov=(1./param_dict['n'])*Sigma_m).rvs()
return sts.multivariate_normal(mean=mu, cov = Sigma_m).rvs()
else:
Prec_m = sts.wishart(df = param_dict['up_v_0'], scale=param_dict['up_Prec_0']).rvs()
Sigma_m = np.linalg.inv(Prec_m)
mu = sts.multivariate_normal(mean= param_dict['up_mu_0'], cov=(1./param_dict['up_k_0'])*Sigma_m).rvs()
return sts.multivariate_normal(mean=mu, cov = Sigma_m).rvs()
def gaussian_PSFs():
'''Provide a simple set of PSFs and image for testing and example.
Returns
-------
psfbase : np.array
Three Gaussians with different width and covariance as PSF base
functions.
image, image2 : np.array
Two images generated from the Gaussian PSFs with some added noise.
'''
x, y = np.mgrid[-1:1:.05, -1:1:.05]
pos = np.empty(x.shape + (2,))
pos[:, :, 0] = x
pos[:, :, 1] = y
psf1 = multivariate_normal([0, 0.], [[2.0, 0.3], [0.3, 0.5]]).pdf(pos)
psf2 = multivariate_normal([0, 0.], [[1.0, 0.3], [0.3, 0.7]]).pdf(pos)
psf3 = multivariate_normal([0, 0.], [[1.0, 0], [0, 1.]]).pdf(pos)
psfbase = np.ma.dstack((psf1, psf2, psf3))
# Make an image as a linear combination of PSFs plus some noise
image = 1 * psf1 + 2 * psf2 + 3 * psf3
image += 0.3 * np.random.rand(*image.shape)
# Add a faint companion
image += 0.1 * multivariate_normal([0, 0.05], [[0.2, 0.], [0., 0.05]]).pdf(pos)
image2 = 2. * psf1 + 2.3 * psf2 + 2.6 * psf3
image2 += 0.3 * np.random.rand(*image.shape)
return psfbase, image, image2
def shock_create(self, h, shock_type, shock_index, shock_value, shock_dir, irf_intervals):
""" Function creates shocks based on desired specification
Parameters
----------
h : int
How many steps ahead to forecast
shock_type : None or str
Type of shock; options include None, 'Cov' (simulate from covariance matrix), 'IRF' (impulse response shock)
shock_index : int
Which parameter to apply the shock to if using an IRF.
shock_value : None or float
If specified, applies a custom-sized impulse response shock.
shock_dir : str
Direction of the IRF shock. One of 'positive' or 'negative'.
irf_intervals : Boolean
Whether to have intervals for the IRF plot or not
Returns
----------
A h-length list which contains np.ndarrays containing shocks for each variable
"""
# Loop over the forecast period
if shock_type is None:
random = [np.zeros(self.ylen) for i in range(h)]
elif shock_type == 'IRF':
cov = self.create_cov(self.params)
post = ss.multivariate_normal(np.zeros(self.ylen),cov)
if irf_intervals is False:
random = [np.zeros(self.ylen) for i in range(h)]
else:
random = [post.rvs() for i in range(h)]
random[0] = np.zeros(self.ylen)
if shock_value is None:
if shock_dir=='positive':
random[0][shock_index] = cov[shock_index,shock_index]**0.5
elif shock_dir=='negative':
random[0][shock_index] = -cov[shock_index,shock_index]**0.5
else:
raise ValueError("Unknown shock direction!")
else:
random[0][shock_index] = shock_value
elif shock_type == 'Cov':
cov = self.create_cov(self.params)
post = ss.multivariate_normal(np.zeros(self.ylen),cov)
random = [post.rvs() for i in range(h)]
return random
def importance_pool_sampling(args):
# args = [i_particle, theta_t_1, w_t_1, sig_t_1, eps_t]
i_particle = args[0]
theta_t_1 = args[1]
w_t_1 = args[2]
sig_t_1 = args[3]
eps_t = args[4]
theta_star = weighted_sampling(theta_t_1, w_t_1)
np.random.seed()
# perturbed theta (Double check)
theta_starstar = multivariate_normal(theta_star, sig_t_1).rvs(size=1)
model_starstar = simz(theta_starstar)
rho = distance(data, model_starstar)
while rho > eps_t:
theta_star = weighted_sampling(theta_t_1, w_t_1)
theta_starstar = multivariate_normal(theta_star, sig_t_1).rvs(size=1)
model_starstar = simz(theta_starstar)
rho = distance(data, model_starstar)
p_theta = pi_priors(theta_starstar)
w_starstar = p_theta / np.sum(w_t_1 * better_multinorm(theta_starstar, theta_t_1, sig_t_1))
pool_list = [np.int(i_particle)]
for i_p in xrange(n_params):
pool_list.append(theta_starstar[i_p])
pool_list.append(w_starstar)
pool_list.append(rho)
return pool_list
def fit_gaussians(x_train_boxcox, y_train):
""" Fit class-dependent multivariate gaussians on the training set.
Parameters
----------
x_train_boxcox : np.array [n_samples, n_features_trans]
Transformed training features.
y_train : np.array [n_samples]
Training labels.
Returns
-------
rv_pos : multivariate normal
multivariate normal for melody class
rv_neg : multivariate normal
multivariate normal for non-melody class
"""
pos_idx = np.where(y_train == 1)[0]
mu_pos = np.mean(x_train_boxcox[pos_idx, :], axis=0)
cov_pos = np.cov(x_train_boxcox[pos_idx, :], rowvar=0)
neg_idx = np.where(y_train == 0)[0]
mu_neg = np.mean(x_train_boxcox[neg_idx, :], axis=0)
cov_neg = np.cov(x_train_boxcox[neg_idx, :], rowvar=0)
rv_pos = multivariate_normal(mean=mu_pos, cov=cov_pos, allow_singular=True)
rv_neg = multivariate_normal(mean=mu_neg, cov=cov_neg, allow_singular=True)
return rv_pos, rv_neg
def _init_params(self, X):
init = self.init
n_samples, n_features = X.shape
n_components = self.n_components
if (init == 'kmeans'):
km = Kmeans(n_components)
clusters, mean, cov = km.cluster(X)
coef = sp.array([c.shape[0] / n_samples for c in clusters])
comps = [multivariate_normal(mean[i], cov[i], allow_singular=True)
for i in range(n_components)]
elif (init == 'rand'):
coef = sp.absolute(sprand.randn(n_components))
coef = coef / coef.sum()
means = X[sprand.permutation(n_samples)[0: n_components]]
clusters = [[] for i in range(n_components)]
for x in X:
idx = sp.argmin([spla.norm(x - mean) for mean in means])
clusters[idx].append(x)
comps = []
for k in range(n_components):
mean = means[k]
cov = sp.cov(clusters[k], rowvar=0, ddof=0)
comps.append(multivariate_normal(mean, cov, allow_singular=True))
self.coef = coef
self.comps = comps
def make_joint_pdf(dataset):
dataset_fours = dataset[dataset[:, -1] == 4]
dataset_fours = dataset_fours[:, :-1]
dataset_not_fours = dataset[dataset[:, -1] != 4]
dataset_not_fours = dataset_not_fours[:, :-1]
mean_fours = numpy.mean(dataset_fours, axis=0)
cov_fours = numpy.cov(dataset_fours.T)
mean_not_fours = numpy.mean(dataset_not_fours, axis=0)
cov_not_fours = numpy.cov(dataset_not_fours.T)
try:
fours_mv = multivariate_normal(mean=mean_fours, cov=cov_fours)
except Exception as e:
print mean_fours, cov_fours
print 'fours'
raise e
try:
not_fours_mv = multivariate_normal(
mean=mean_not_fours, cov=cov_not_fours)
except Exception as e:
print mean_not_fours, cov_not_fours
print 'not fours'
raise e
return fours_mv, not_fours_mv
def find_optimal_weights(N, cov_reduction, mean_spread, n):
""" Solve quadratic program to find optimal weights for N gaussians to miminize
integral squared difference bewteen the mixture and a zero-mean unity gaussian,
given target covariance reduction cov_reduction and distance between means
mean_spread. Also optionally returns the value of the integral squared
difference for the optimal weights."""
cov_i = np.eye(n)
cov_i[0,0] = cov_reduction
means = np.zeros((n,N))
for i in range(N):
means[0,i] = (i - (N-1)/2)*mean_spread
H = np.zeros((N,N))
for i in range(N):
for j in range(N):
H[i,j] = stats.multivariate_normal(means[:,j], 2*cov_i).pdf(means[:,i])
f = np.zeros((N,1))
for i in range(N):
f[i,0] = stats.multivariate_normal(means[:,i], np.eye(n)+cov_i).pdf(np.zeros(n))
c = -f.T
b = np.zeros((N,1))
A = np.eye(N)
# J_ISD = J_11 - 2*f.T*w + w^T*H*w
def loss(w, sign=1.):
return sign * (np.dot(w.T, np.dot(H, w)) + 2*np.dot(c, w) + J11)
def jac(w, sign=1.):
return sign * (2*np.dot(w.T, H) + 2*c)
one_array = np.ones((N,1))
cons = ({'type':'eq',
'fun': lambda w: np.dot(one_array.T, w) - 1.,
'jac': lambda w: one_array.T },)
'''{'type':'ineq',
'fun':lambda w: (np.dot(A,w) - b)[:,0],
'jac':lambda w: A}'''
bounds = [(0,1) for _ in range(N)]
opt = {'disp': False}
res = optimize.minimize(loss, x0=np.ones(N)/N, jac=jac, bounds=bounds,
constraints=cons, method='SLSQP', options=opt)
w = res.x
# Check results
assert res.success, "quadratic program optimization failed"
assert np.allclose(np.sum(w), 1.0), "Weights don't add to one"
assert np.all(w >= 0) and np.all(w <= 1), "Weights are't 0 < w < 1, " + str(w)
assert loss(w).shape[0] == 1, "Weird things are happening"
return w, loss(w)[0]
def __init__(self,mean0,cov0,mean1,cov1): """ construct a mixture of two gaussians. mean0 is 2x1 vector of means for class 0, cov0 is 2x2 covariance matrix for class 0. Similarly for class 1""" self.mean0 = mean0 self.mean1 = mean1 self.cov0 = cov0 self.cov1 = cov1 self.rv0 = multivariate_normal(mean0, cov0) self.rv1 = multivariate_normal(mean1, cov1)
def target(p_i,p_f,t,size):
prior = multivariate_normal(mu,sigma_1)
likelihood = prior.logpdf(p_i.T) + prior.logpdf(p_f.T)
q_i = projection(p_i)
q_f = projection(p_f)
for i in range(size):
f = multivariate_normal(get_qs(q_i,q_f,t[i]),sigma)
likelihood = likelihood + f.logpdf(r[i,:])
return likelihood
def animate(h):
"""
Performs a step of EM, and returns the graphed result.
"""
means = gmm.means_
weights = gmm.weights_
covars = gmm.covars_
### E-step
# for each cluster
for j in range(k):
mvn = multivariate_normal(means[j], covars[j])
l[:,j] = weights[j]*mvn.pdf(X)
# normalize likelihoods to create "responsibility"
res = l / np.sum(l, axis=1)[:,None]
### M-step
for j in range(k):
jsum = np.sum(res[:,j])
weights[j] = jsum / np.sum(res)
rn = res[:,j]
prod = np.dot(rn, X)
means[j] = prod/jsum
numer = np.zeros((d,d))
for i in range(n):
whitemean = X[i,:]-means[j]
whitemean = whitemean[:,None]
numer += res[i,j]*(whitemean*np.transpose(whitemean))
covars[j] = numer / jsum
### Compute data log likelihood and EM bound
Lnew = 0.0
B = 0.0
for i in range(n):
lsum = 0.0
bsum = 0.0
for j in range(k):
wpdf = weights[j]*multivariate_normal(means[j],covars[j]).pdf(X[i,:])
lsum += wpdf
bsum += res[i,j]*np.log(wpdf/res[i,j])
B += bsum
Lnew += np.log(lsum)
gmm.means_ = means
gmm.weights_ = weights
gmm.covars_ = covars
return vis_gmm_2d(gmm, k, X, ax, rmin, rmax, my_colors)
def getUniformTestData(self,n):
"""
Params: Given a LinearDataGenerator object, this creates another
Output: n datapoints from the same distribution.
"""
data_dist = stats.multivariate_normal(np.zeros(self.p),self.width*np.eye(self.p))
noise_dist = stats.multivariate_normal(np.zeros(self.n),self.var*np.eye(self.n))
X = np.array([data_dist.rvs() for i in range(self.n)])
y = np.array([[X[i,:].dot(self.bg)[0] for i in range(self.n)]]).T \
+ np.array([noise_dist.rvs()]).T
return X, y
def marginal(self, i1=None, i2=None, x=None):
warn("Warning: The value of the marginal likelihood provided corresponds to "+
"marginalising over an infinite parameter space. Notice that the prior may "+
"only be defined positive in a smaller region.")
if i1 is None and i2 is None:
return float(self.n_modes)
elif i2 is None:
m_gaussians = [multivariate_normal(g.mean[i1], [[g.cov[i1,i1]]]) for g in self.gaussians]
else:
m_gaussians = [multivariate_normal(
g.mean[[i1,i2]], [[g.cov[i1,i1],g.cov[i1,i2]],[g.cov[i2,i1],g.cov[i2,i2]]])
for g in self.gaussians]
assert x is not None, "You must provide a point where to evaluate the marginal."
return sum([g.pdf(x) for g in m_gaussians])
def calc_posterior(means, data):
prior = calc_prior(data)
posterior = [[], []]
mvn_pdf = [multivariate_normal(mean=means[0], cov=np.eye(2)), multivariate_normal(mean=means[1], cov=np.eye(2))]
for i, mean in enumerate(means):
posterior[i] = 0
for point in data[i]:
#for mean
point_coordinates = point[:-1]
likelihood = mvn_pdf[i].pdf(point_coordinates)
numerator = likelihood * prior[i]
normalizer = mvn_pdf[0].pdf(point_coordinates) * prior[0] + mvn_pdf[1].pdf(point_coordinates) * prior[1]
posterior[i] *= (numerator / normalizer)
return posterior
def __init__(self, landmark, gmm, classifier_loss, relation_name):
super(TransferModel, self).__init__()
self.gmm = gmm
self.landmark = landmark
self.classifier_loss = classifier_loss
self.positive = multivariate_normal(gmm.means_[1], gmm.covars_[1])#, allow_singular=True)
self.negative = multivariate_normal(gmm.means_[0], gmm.covars_[0])#, allow_singular=True)
if relation_name == 'near':
self.scoring_function = support_functions.distance_pose_xy
elif relation_name == 'relative_angle':
self.scoring_function = support_functions.unit_circle_position_pose_xy
else:
raise rospy.ROSException("Unknown relation_name %s"%relation_name)
def gaussian_mix(query):
# Assign multivariate gaussians to be present in the space.
gaussians = [multivariate_normal(mean=[0.9, 0.1], cov=[[0.05, 0], [0, 0.05]])]
gaussians.append(multivariate_normal(mean=[0.9, 0.9], cov=[[0.07, 0.01], [0.01, 0.07]]))
gaussians.append(multivariate_normal(mean=[0.15, 0.7], cov=[[0.03, 0], [0, 0.03]]))
# Initialize initial value.
value = 0.0
# Iterate through each gaussian in the space.
for j in xrange(len(gaussians)):
value += gaussians[j].pdf(query)
# Take the average.
gaussian_function = value / len(gaussians)
return vec(gaussian_function) # vec(np.array([query.ravel(), gaussian_function]).ravel())
def gmm(k, xs, tol=1e-6, max_iter=200):
"""Vectorized version of GMM. Faster than above but still rough."""
n, p = xs.shape
mus, z = initialization.kmeanspp(k, xs, ret='both')
pis = np.array([len(np.where(z==i)[0])/n for i in np.unique(z)])
sigmas = np.array([np.eye(p)]*k)
ll_old = 0
for i in range(max_iter):
exp_A = []
exp_B = []
ll_new = 0
# E-step, ws are responsabilities
ws = np.zeros((k, n))
for j in range(k):
ws[j, :] = pis[j]*multivariate_normal(mus[j], sigmas[j]).pdf(xs)
ws /= ws.sum(0)
# M-step
pis = ws.sum(axis=1)
pis /= n
mus = np.dot(ws, xs)
mus /= ws.sum(1)[:, None]
sigmas = np.zeros((k, p, p))
for j in range(k):
ys = xs - mus[j, :]
sigmas[j] = (ws[j,:,None,None]*\
matrix_multiply(ys[:,:,None], ys[:,None,:])).sum(axis=0)
sigmas /= ws.sum(axis=1)[:,None,None]
# update complete log likelihoood
ll_new = 0
for pi, mu, sigma in zip(pis, mus, sigmas):
ll_new += pi*multivariate_normal(mu, sigma).pdf(xs)
ll_new = np.log(ll_new).sum()
# convergence test
if np.abs(ll_new - ll_old) < tol:
break
ll_old = ll_new
z = ws.T
labels = np.argmax(z, axis=1)
return labels
def prob4():
"""Approximate the probability that a random draw from the
multivariate standard normal distribution will be less than -1 in
the x-direction and greater than 1 in the y-direction.
Returns: your estimated probability"""
N = 500000
h = lambda x: x[0] < -1 and x[1] > 1
f = lambda x: stats.multivariate_normal(mean = [0, 0]).pdf(x)
g = lambda x: stats.multivariate_normal(mean = [-1, 1]).pdf(x)
X = np.random.multivariate_normal(mean = [-1, 1], cov = [[1, 0], [0, 1]], size = N)
tot = 0
for i in range(N):
tot += (h(X[i])*f(X[i])/g(X[i]))
return 1./N * tot
def __init__(self, mean, cov):
self.mean = mean
self.cov = np.matrix(cov)
self.dim = len(self.mean)
assert self.cov.shape[0] == self.cov.shape[1]
domain = ProductDomain([IntervalDomain(-np.inf, +np.inf) for i in range(len(self.mean))])
super().__init__(stats.multivariate_normal(self.mean, self.cov), domain)
def learn(self, sequence, zeta=None, init=False, only_final_ll=False):
''' Runs Baum-Welch to train HMM '''
K = self.num_states
epsilon = 0.1
old_ll = float("-inf")
iterations = 0
if init:
means, covs = self.get_kmeans_emission_init(sequence)
self.emission_density_objs = [multivariate_normal(mean=means[k], cov=covs[k], allow_singular=True) for k in range(K)]
start_probs, transition_probs = self.get_random_start_and_trans_probs()
self.start_probs = start_probs
self.trans_probs = transition_probs
while True:
iterations += 1
self.forward(sequence)
self.backward(sequence)
self.compute_gamma_table(sequence)
self.compute_xi_table(sequence)
if not only_final_ll:
print "Log Likelihood:", self.log_likelihood
if abs(self.log_likelihood - old_ll) < epsilon or iterations > MAX_ITER:
print "Final Log Likelihood:", self.log_likelihood
return
else:
old_ll = self.log_likelihood
self.update_start_probs()
self.trans_update_method(sequence, zeta)
self.update_emission_parameters(sequence)
def predict_log_probs(self, test_data):
num_points = test_data["coordinates"].shape[0]
topic_log_prob_vector = np.zeros((self.num_topics, num_points))
# topic_prob_vector = np.ones((self.num_topics, num_points))
for z in range(self.num_topics):
try:
rv = stats.multivariate_normal(mean=self.topic_centers[z, :],
cov=self.topic_covar[z, :, :], allow_singular=True)
loc_log_prob = rv.logpdf(test_data["coordinates"]).reshape((num_points, 1)) # Nx1
# loc_prob = rv.pdf(test_data["coordinates"]).reshape((num_points, 1)) # Nx1
except:
print("Error while computing geo log probabilities for test, dumping data.", "\n",
self.topic_centers[z, :], "\n", self.topic_covar[z, :, :], file=sys.stderr)
traceback.print_stack(file=sys.stderr)
sys.exit(1)
feature_log_prob = np.zeros((num_points, 1))
# feature_prob = np.ones((num_points, 1))
for feature in self.beta_arrays.keys():
beta = self.beta_arrays[feature][z]
num_words = beta.shape[0]
feature_log_prob += test_data[feature] * np.log(beta.reshape((num_words, 1))) # (NxV * Vx1) = Nx1
# feature_prob *= np.prod(np.power(beta.reshape((num_words, 1)).T, test_data[feature].todense()), axis=1)
topic_log_prob_vector[z] = (loc_log_prob +
feature_log_prob +
np.tile(np.log(self.theta[0, z]), (num_points, 1))).flatten()
# topic_prob_vector[z] = np.multiply(np.multiply(loc_prob, feature_prob),
# np.tile(self.theta[0, z], (num_points, 1))).flatten()
# print("direct")
# print(np.sum(np.log(np.sum(topic_prob_vector, axis=0))))
return np.sum(utils.log_sum(topic_log_prob_vector, axis=0))
def _do_plot_test():
from numpy.random import multivariate_normal
p = np.array([[32, 15],[15., 40.]])
x,y = multivariate_normal(mean=(0,0), cov=p, size=5000).T
sd = 2
a,w,h = covariance_ellipse(p,sd)
print (np.degrees(a), w, h)
count = 0
color=[]
for i in range(len(x)):
if _is_inside_ellipse(x[i], y[i], 0, 0, a, w, h):
color.append('b')
count += 1
else:
color.append('r')
plt.scatter(x,y,alpha=0.2, c=color)
plt.axis('equal')
plot_covariance_ellipse(mean=(0., 0.),
cov = p,
std=sd,
facecolor='none')
print (count / len(x))
def random_algorithm(cmd, world): randx = world.xdim*np.random.random_sample() randy = world.ydim*np.random.random_sample() mv_dist = multivariate_normal(np.array([randx, randy]), np.array([[1, 0], [0, 1]])) return mv_dist
def prob4():
"""Approximate the probability that a random draw from the
multivariate standard normal distribution will be less than -1 in
the x-direction and greater than 1 in the y-direction."""
h = lambda y: y[0] < -1 and y[1] > 1
f = lambda y: stats.multivariate_normal(np.zeros(2), np.eye(2)).pdf(y)
g = lambda y: stats.multivariate_normal(np.array([-1, 1]), np.eye(2)).pdf(y)
n = 10 ** 4
Y = np.random.multivariate_normal(np.array([-1, 1]), np.eye(2), size=n)
hh = np.apply_along_axis(h, 1, Y)
ff = np.apply_along_axis(f, 1, Y)
gg = np.apply_along_axis(g, 1, Y)
approx = 1.0 / n * np.sum(hh * ff / gg)
return approx
def __init__(self, cov=None, random_state=None):
super(GaussianProposal, self).__init__(random_state=random_state)
self._cov = cov
# TODO: Use the given random state instead!
self._norm = stat.multivariate_normal(cov=cov)
def objects_walls_algorithm(cmd, world, k1=4.2, k2=4.4):
x, y = np.mgrid[0:world.xdim:.1, 0:world.ydim:.1]
# Calculate naive distribution
naive_dist = naive_algorithm(cmd, world)
naive_vals = naive_dist.pdf(np.dstack((x, y)))
# Find Distance to closest object
ref_dists = {ref : np.sqrt((x - ref.center[0])**2 + (y - ref.center[1])**2) for ref in world.references}
min_ref_dists = np.min(np.dstack(ref_dists[ref] for ref in ref_dists), axis=2)
# Difference between distance to closest object and object reference in command
ref_distance_diff = ref_dists[cmd.reference] - min_ref_dists
ref_distance_vals = expon.pdf(ref_distance_diff, scale=k1)
# Find distance to nearest wall
min_wall_dists = np.min(np.dstack((x, y, world.xdim - x, world.ydim - y)), axis=2)
# Difference between distance to closest wall and object reference in command
wall_distance_diff = ref_dists[cmd.reference] - min_wall_dists
wall_distance_diff[wall_distance_diff < 0] = 0
wall_distance_vals = expon.pdf(wall_distance_diff, scale=k2)
mean_prob = naive_vals*ref_distance_vals*wall_distance_vals
loc = np.where(mean_prob == mean_prob.max())
mean = 0.1*np.array([loc[0][0], loc[1][0]])
mv_dist = multivariate_normal(mean, naive_dist.cov)
return mv_dist
def generate_2d_shower_model(centroid, width, length, psi):
"""Create a statistical model (2D gaussian) for a shower image in a
camera. The model's PDF (`model.pdf`) can be passed to
`make_toymodel_shower_image`.
Parameters
----------
centroid : (float,float)
position of the centroid of the shower in camera coordinates
width : float
width of shower (minor axis)
length : float
length of shower (major axis)
psi : convertable to `astropy.coordinates.Angle`
rotation angle about the centroid (0=x-axis)
Returns
-------
a `scipy.stats` object
"""
aligned_covariance = np.array([[length**2, 0], [0, width**2]])
# rotate by psi angle: C' = R C R+
rotation = linalg.rotation_matrix_2d(psi)
rotated_covariance = rotation.dot(aligned_covariance).dot(rotation.T)
return multivariate_normal(mean=centroid, cov=rotated_covariance)
def cheating_algorithm(pts): mean = np.mean(pts, axis=0) covariance = np.cov(pts.T) mv_dist = multivariate_normal(mean, covariance) return mv_dist
# methods to generate the three-dimensional distribution, as follows, mean = [-100, 50, 0.15] # given as [isotropic chemical shift in ppm, zeta in ppm, eta]. covariance = [[3.25, 0, 0], [0, 26.2, 0], [0, 0, 0.002]] # same order as the mean. # range of coordinates along the three dimensions iso_range = np.arange(100) * 0.3055 - 115 # in ppm zeta_range = np.arange(30) * 2.5 + 10 # in ppm eta_range = np.arange(21) / 20 # The coordinates grid iso, zeta, eta = np.meshgrid(iso_range, zeta_range, eta_range, indexing="ij") pos = np.asarray([iso, zeta, eta]).T # Three-dimensional probability distribution function. pdf = multivariate_normal(mean=mean, cov=covariance).pdf(pos).T # %% # Here, ``iso``, ``zeta``, and ``eta`` are the isotropic chemical shift, nuclear # shielding anisotropy, and nuclear shielding asymmetry coordinates of the 3D-grid # system over which the multivariate normal probability distribution is evaluated. The # mean of the distribution is given by the variable ``mean`` and holds a value of -100 # ppm, 50 ppm, and 0.15 for the isotropic chemical shift, nuclear shielding anisotropy, # and nuclear shielding asymmetry parameter, respectively. Similarly, the variable # ``covariance`` holds the covariance matrix of the multivariate normal distribution. # The two-dimensional projections from this three-dimensional distribution are shown # below. _, ax = plt.subplots(1, 3, figsize=(9, 3)) # isotropic shift v.s. shielding anisotropy ax[0].contourf(zeta_range, iso_range, pdf.sum(axis=2))
log_data = g.read().strip().split("\n")
g.close()
# If last line starts with Best, get line before
flag = True
i = -1
while flag:
if log_data[i].startswith("Best"):
variance = float(log_data[i - 1].strip().split()[4]) / 100
flag = False
else:
i -= 1
seed = row["seed"]
random_variable = multivariate_normal(
mean=mean_array, cov=np.identity(len(mean_array)) * variance)
team = random_variable.rvs(2, seed)
agent_1 = NNAgent(fitness_calculator.get_observation_size(),
fitness_calculator.get_action_size(),
parameter_filename, team[0])
agent_2 = NNAgent(fitness_calculator.get_observation_size(),
fitness_calculator.get_action_size(),
parameter_filename, team[1])
results = fitness_calculator.calculate_fitness(
agent_list=[agent_1, agent_2],
render=False,
time_delay=0,
measure_specialisation=True,
logging=False,
logfilename=None,
def MCMC_multivariate_ssm(test_data,
causal_period,
nseasons=12,
iterloop=1000,
burnin=100,
stationary=True,
graph=False,
graph_structure=None,
seed=3):
############## load functions ###############
if stationary:
from stationaryRestrict import stationaryRestrict
############### organize dataset #################
length, d = test_data.shape
# seperate causal period dataset
causal_period = causal_period
causal_period_len = causal_period.shape[0]
length_non_causal = length - causal_period_len
############### initialize parameters #################
# initialize z
circle = np.min((nseasons, length))
n = (circle + 1) * d
z = np.zeros((n, d))
z[:d, :] = np.eye(d)
z[2 * d:3 * d, :] = np.eye(d)
# initialize mu: intercept of hidden equation
mu_ss = np.zeros(n)
# initialize alpha: (see Durbin and Koopman, 2002)
alpha = np.zeros(n, dtype=np.int32)
aStar = np.zeros(n, dtype=np.int32)
# initialize variance of alpha
P = np.zeros((n, n), dtype=np.int32)
P[:3 * d, :3 * d] = np.eye(3 * d) * 1e6
if stationary:
P[d:2 * d, d:2 * d] = np.eye(d)
# initialize sigma
delta = d + 1 # prior for sigma
B = np.eye(d) # prior for sigma
# give right parameters t0 wishart
sigma_hat_inv = wishart(
df=d + 1, scale=np.eye(d) / .1**2 / d).rvs() * graph_structure
# what's happening here
sigma_hat = chol2inv(sigma_hat_inv)
# initialize transition matrix
trans = np.zeros((n, n))
linear = np.eye(2 * d)
linear[:d, d:2 * d] = np.eye(d)
trans[:2 * d, :2 * d] = linear
# take initial variance of tau from the data
if stationary:
# find python library with autoregressive models
var = VAR(test_data[causal_period, :])
data_phi = var.fit(maxlags=1, ic=None, trend="nc").params
trans[d:2 * d, d:2 * d] = data_phi
else:
trans[d:2 * d, d:2 * d] = np.eye(d)
seasonal = np.zeros((circle - 1, circle - 1))
seasonal[0, :] = -1
seasonal[1:circle - 1, :circle - 2] = np.eye(circle - 2)
for dims in range(d):
trans[2 * d + dims:n:d, 2 * d + dims:n:d] = seasonal
# initialize R
R = np.zeros((n, d * 3))
R[:3 * d, :3 * d] = np.eye(3 * d)
# initialize covariance matrix Q = bdiag(sigmaU, sigmaV, sigmaW)
k1, k2, k3 = 0.1, 0.1, 0.1
# what's happening here
if not graph:
sigmaU = chol2inv(wishart(d, k1**2 * d * np.eye(d)).rvs())
sigmaV_inv = wishart(d, k2**2 * d * np.eye(d)).rvs()
sigmaV = chol2inv(sigmaV_inv)
sigmaW = chol2inv(wishart(d, k3**2 * d * np.eye(d)).rvs())
else:
sigmaU = chol2inv(
wishart(df=d + 1, scale=np.eye(d) / k1**2 / d).rvs() *
graph_structure)
sigmaV_inv = wishart(
df=d + 1, scale=np.eye(d) / k1**2 / d).rvs() * graph_structure
sigmaV = chol2inv(sigmaV_inv)
sigmaW = chol2inv(
wishart(df=d + 1, scale=np.eye(d) / k1**2 / d).rvs() *
graph_structure)
Q = sla.block_diag(sigmaU, sigmaV, sigmaW)
################### Prepare for MCMC Sampling ##################
# create matrix to store parameter draws
mu_sample = np.empty((length, d, iterloop))
a_last_sample = np.empty((n, iterloop))
P_last_sample = np.empty((n, n, iterloop))
prediction_sample = np.empty((length, d, iterloop))
sigma_sample = np.empty((d, d, iterloop))
sigma_U_sample = np.empty((d, d, iterloop))
sigma_V_sample = np.empty((d, d, iterloop))
sigma_W_sample = np.empty((d, d, iterloop))
if stationary:
Theta_sample = np.empty((d, d, iterloop))
D_sample = np.zeros((d, iterloop))
# pb = txtProgressBar(1, iterloop, style=3) # report progress
# print("\nStarting MCMC sampling: \n") # report progress
##################### Begin MCMC Sampling #######################
# ptm = proc.time()
for itery in tqdm(range(iterloop), desc="MCMC sampling"):
## --------------------------------------- ##
## Step 1. obtain draws of alpha, apply Koopman's filter (2002)
# simulate w.hat, y.hat, alpha.hat for Koopman's filter (2002)
alpha_plus = np.zeros((length, n))
for t in range(length):
eta = multivariate_normal(mean=np.zeros(3 * d), cov=Q,
seed=seed).rvs()
if t == 0:
alpha_plus[t, :] = mu_ss + trans.dot(alpha) + R.dot(eta)
else:
alpha_plus[t, :] = mu_ss + trans.dot(
alpha_plus[t - 1, :]) + R.dot(eta)
test_est_plus = alpha_plus.dot(z) + multivariate_normal(
mean=np.zeros(d), cov=sigma_hat, seed=seed).rvs(size=length)
test_est_star = test_data - test_est_plus
# Estimate alpha parameters
sample_alpha_draws = koopmanfilter(n, test_est_star, trans, z, aStar,
2 * P, 2 * sigma_hat, 2 * Q, R,
causal_period)
alpha_star_hat = sample_alpha_draws["alpha sample"]
alpha_draws = alpha_star_hat + alpha_plus
# collect a.last and P.last,
# use them for starting point of koopman filter for causal period dataset
# print(a_last_sample.shape, sample_alpha_draws["a last"].shape)
a_last_sample[:, itery] = sample_alpha_draws["a last"]
P_last_sample[:, :, itery] = sample_alpha_draws["P last"]
## ---------------------------------------- ##
## Step 2: make stationary restriction
if stationary:
alpha_draws_tau = alpha_draws[:length_non_causal, d:d * 2]
if itery == 0:
alpha_draws_tau_demean = alpha_draws_tau
Theta_draw = stationaryRestrict(alpha_draws_tau_demean, sigmaV,
sigmaV_inv)
else:
alpha_draws_tau_demean = (alpha_draws_tau.T -
D_draw.reshape(-1, 1)).T
Theta_draw = stationaryRestrict(alpha_draws_tau_demean,
sigmaV_draws, sigmaV_inv)
trans[d:2 * d, d:2 * d] = Theta_draw
## ---------------------------------------- ##
## Step 3: sample intercept mu.D, denote N(0, I) prior for D
tau_part_A = alpha_draws_tau[1:length_non_causal, :] \
- alpha_draws_tau[:length_non_causal-1, :].dot(Theta_draw.T)
tau_part_B = np.eye(d) - Theta_draw
D_var = la.inv((length_non_causal - 1) *
tau_part_B.T.dot(sigmaV_inv).dot(tau_part_B) +
np.eye(d))
D_var = check_positive(D_var)
D_mean = D_var.dot((tau_part_B.T.dot(sigmaV_inv)).dot(
tau_part_A.sum(axis=0))) #.reshape(-1, 1))) #it's wrong
D_draw = multivariate_normal(mean=D_mean, cov=D_var,
seed=seed).rvs()
# update the mean: D - theta * D
D_mu = tau_part_B.dot(D_draw)
# print(D_mu.shape, mu_ss.shape)
mu_ss[d:2 * d] = D_mu
# update alpha_draws_tau_demean
alpha_draws_tau_demean = (alpha_draws_tau.T -
D_draw.reshape(-1, 1)).T
## ---------------------------------------- ##
## Step 4: update sigmaU, sigmaV, sigmaW
# parameter in sigmaU
PhiU_value = alpha_draws[1:length_non_causal, :d] \
- alpha_draws[:length_non_causal-1, :d] \
- alpha_draws[:length_non_causal-1, d:d*2]
PhiU = PhiU_value.T.dot(PhiU_value)
# parameter in sigmaV
if stationary:
PhiV_value = alpha_draws_tau_demean[1:length_non_causal, :] \
- alpha_draws_tau_demean[:length_non_causal-1, :].dot(Theta_draw.T)
PhiV = PhiV_value.T.dot(PhiV_value)
else:
PhiV_value = alpha_draws[1:length_non_causal, d:2*d] \
- alpha_draws[:length_non_causal-1, d:2*d]
PhiV = PhiV_value.T.dot(PhiV_value)
# parameter in sigmaW
bind_W = np.zeros((causal_period[0] - 1, 0))
for dims in range(d):
bind_W_tmp = np.hstack(
(alpha_draws[1:length_non_causal, d * 2 + dims:n:d],
alpha_draws[:length_non_causal - 1, n - d + dims, None]))
bind_W = np.hstack((bind_W, bind_W_tmp.sum(axis=1).reshape(-1, 1)))
PhiW = bind_W.T.dot(bind_W)
scale_U = PhiU + (d + 1) * k1**2 * np.eye(d)
scale_V = PhiV + (d + 1) * k2**2 * np.eye(d)
scale_W = PhiW + (d + 1) * k3**2 * np.eye(d)
# start from here
# sample sigmaU, sigmaV, sigma W from their posteriors
if not graph:
sigmaU_draws = la.inv(
wishart(length_non_causal + d - 1, scale_U).rvs())
sigmaV_inv = wishart(length_non_causal + d - 1, scale_V).rvs()
sigmaV_draws = la.inv(sigmaV_inv)
sigmaW_draws = la.inv(
wishart(length_non_causal + d - 1, scale_W).rvs())
else:
sigmaU_inv = wishart(length_non_causal + d - 1,
la.inv(scale_U)).rvs() * graph_structure
sigmaU_draws = la.inv(check_positive(sigmaU_inv))
sigmaV_inv = wishart(length_non_causal + d - 1,
la.inv(scale_V)).rvs() * graph_structure
sigmaV_draws = la.inv(check_positive(sigmaV_inv))
sigmaW_inv = wishart(length_non_causal + d - 1,
la.inv(scale_W)).rvs() * graph_structure
sigmaW_draws = la.inv(check_positive(sigmaW_inv))
Q = sla.block_diag(sigmaU_draws, sigmaV_draws, sigmaW_draws)
## ---------------------------------------- ##
## Step 5: update sigma_hat
res = (test_data - alpha_draws.dot(z))[:length_non_causal, :]
if not graph:
D_sigma = res.T.dot(res) + B
sigma_hat_inv = wishart(delta + length_non_causal, D_sigma).rvs()
sigma_hat = la.inv(check_positive(sigma_hat_inv))
else:
D_sigma = res.T.dot(res) + B
sigma_hat_inv = wishart(delta + length_non_causal,
la.inv(D_sigma)).rvs() * graph_structure
sigma_hat = la.inv(check_positive(sigma_hat_inv))
## ---------------------------------------- ##
## Step 6: estimating dataset using predicted value
prediction_sample[:, :,
itery] = alpha_draws.dot(z) + multivariate_normal(
mean=np.zeros(d), cov=sigma_hat, seed=seed).rvs(
alpha_draws.shape[0])
## ---------------------------------------- ##
## Step 7: collect sample draws
mu_sample[:, :, itery] = alpha_draws[:length, :d]
if stationary:
Theta_sample[:, :, itery] = Theta_draw
D_sample[:, itery] = D_draw
sigma_sample[:, :, itery] = sigma_hat
sigma_U_sample[:, :, itery] = sigmaU_draws
sigma_V_sample[:, :, itery] = sigmaV_draws
sigma_W_sample[:, :, itery] = sigmaW_draws
# return result
if stationary:
return_dict = {
"prediction sample": prediction_sample,
"mu sample": mu_sample,
"Theta sample": Theta_sample,
"D sample": D_sample,
"sigma sample": sigma_sample,
"sigma U sample": sigma_U_sample,
"sigma V sample": sigma_V_sample,
"sigma W sample": sigma_W_sample,
"a last sample": a_last_sample,
"P last sample": P_last_sample,
"z": z,
"R": R,
"trans": trans
}
else:
return_dict = {
"prediction sample": prediction_sample,
"mu sample": mu_sample,
"sigma sample": sigma_sample,
"sigma U sample": sigma_U_sample,
"sigma V sample": sigma_V_sample,
"sigma W sample": sigma_W_sample,
"a last sample": a_last_sample,
"P last sample": P_last_sample,
"z": z,
"R": R,
"trans": trans
}
return return_dict
# ---------------------------------
# The range of isotropic chemical shifts, the quadrupolar coupling constant, and
# asymmetry parameters used in generating a 3D grid.
iso_r = np.arange(101) / 1.5 + 30 # in ppm
Cq_r = np.arange(100) / 4 # in MHz
eta_r = np.arange(10) / 9
# The 3D mesh grid over which the distribution amplitudes are evaluated.
iso, Cq, eta = np.meshgrid(iso_r, Cq_r, eta_r, indexing="ij")
# The 2D amplitude grid of Cq and eta is sampled from the Czjzek distribution model.
Cq_dist, e_dist, amp = CzjzekDistribution(sigma=1).pdf(pos=[Cq_r, eta_r])
# The 1D amplitude grid of isotropic chemical shifts is sampled from a Gaussian model.
iso_amp = multivariate_normal(mean=58, cov=[4]).pdf(iso_r)
# The 3D amplitude grid is generated as an uncorrelated distribution of the above two
# distribution, which is the product of the two distributions.
pdf = np.repeat(amp, iso_r.size).reshape(eta_r.size, Cq_r.size, iso_r.size)
pdf *= iso_amp
pdf = pdf.T
# %%
# The two-dimensional projections from this three-dimensional distribution are shown
# below.
_, ax = plt.subplots(1, 3, figsize=(9, 3))
# isotropic shift v.s. quadrupolar coupling constant
ax[0].contourf(Cq_r, iso_r, pdf.sum(axis=2))
ax[0].set_xlabel("Cq / MHz")
return np.random.multivariate_normal([0.8, 0.8],
[[0.1, -0.1], [-0.1, 0.12]])
random_pair = generate_random_number_pair()
print(random_pair)
# Exercise 3.1.3
x, y = np.mgrid[-0.25:2.25:.01, -1:2:.01]
pos = np.empty(x.shape + (2, ))
pos[:, :, 0] = x
pos[:, :, 1] = y
mu_p = [0.8, 0.8]
cov_p = [[0.1, -0.1], [-0.1, 0.12]]
z = multivariate_normal(mu_p, cov_p).pdf(pos)
fig = plt.figure(figsize=(10, 10), dpi=300)
ax = fig.gca(projection='3d')
ax.plot_surface(x, y, z)
plt.xlabel('$x_1$')
plt.ylabel('$x_2$')
ax.set_zlabel('$p(x_1, x_2 | x_3=0, x_4=0)$')
plt.savefig('3_1_3.png', bbox_inches='tight', dpi=300)
plt.show()
# Exercise 3.2.1
number_of_datapoints = 1000
covariance_3_2 = np.array([[2.0, 0.8], [0.8, 4.0]])
def d_prior(self, x_old, x_new):
""" X_t | X_t-1 """
return stats.multivariate_normal(self.model_mu,self.model_sigma).pdf(x_new-x_old)
default=False)
ap.add_argument("--chi2bins", dest="NCHI2BINS", type=int, default=50)
ap.add_argument("--databins", dest="NDATABINS", type=int, default=20)
ap.add_argument("--resample-data",
dest="RESAMPLE_DATA",
action="store_true",
default=False)
args = ap.parse_args()
## Make perfect pseudodata and correlations
xedges, xmids, datavals, dataerrs, datacov = mkData(args.NDATABINS,
args.CORRMODE)
np.random.seed(12345)
## Smear once, from the perfect distribution and with the true covariance
mn1 = st.multivariate_normal(datavals, datacov)
if args.RESAMPLE_DATA:
datavals_smear1 = mn1.rvs(size=args.NITERS)
else:
datavals_smear1 = np.tile(mn1.rvs(size=1), (args.NITERS, 1))
#print(datavals_smear1)
## Fit nominal
chi2s, chi2s_fit, fitdata = [], [], []
invcov = np.linalg.inv(datacov) if args.CORRCHI2 else np.diag(
np.reciprocal(dataerrs**2))
chi2s.append(chi2(datavals, datavals_smear1[0], invcov))
optres1 = opt.minimize(
lambda ps: chi2FromParams(datavals_smear1[0], xmids, ps, invcov),
[5., 10.])
chi2s_fit.append(optres1.fun)
S = 0.05
# genere des donnes
sigma = 500
M = 200 # nombre de donnees
def gen_mean():
x = np.random.randint(XMIN, XMAX)
y = np.random.randint(YMIN, YMAX)
return (x, y)
mean = gen_mean()
cov = np.eye(2) * sigma
Gaussian = multivariate_normal(mean=mean, cov=cov)
X, Y = np.meshgrid(np.linspace(XMIN, XMAX, M), np.linspace(YMIN, YMAX, M))
pos = np.dstack([X, Y])
temperature_fictive = Gaussian.pdf(pos) * 1000000
# define function
def f(x, y):
return -1 * temperature_fictive[y, x]
# init
x0 = np.random.randint(XMIN, XMAX)
y0 = np.random.randint(YMIN, YMAX)
T = T_init
import scipy.stats as ss
import scipy.linalg as sl
import scipy.optimize as so
import matplotlib.pyplot as plt
np.random.seed(0)
# generate data
mu_0 = [-5, 1] # 分类0的数据
cov_0 = 1.5**2 * np.eye(2)
mu_1 = [1, 5] # 分类1的数据
cov_1 = np.eye(2)
N = 30 # 每个分类的样本点数
rv0 = ss.multivariate_normal(mean=mu_0, cov=cov_0)
rv1 = ss.multivariate_normal(mean=mu_1, cov=cov_1)
X = np.vstack((rv0.rvs(N), rv1.rvs(N)))
y = np.concatenate((np.zeros(N), np.ones(N)))
isZero = y == 0
points_0 = X[isZero]
points_1 = X[~isZero]
# plot the points
fig = plt.figure(figsize=(11, 10))
fig.canvas.set_window_title('logregLaplaceGirolamiDemo_Part_1')
plt.subplot(221)
plt.axis([-10, 5, -8, 8])
def kernDist(index, center):
distr = ss.multivariate_normal([0, 0], [[15, 0], [0, 15]])
return distr.pdf([index[0] - center[0], index[1] - center[1]])
def r_prop(self, size, x_old, y):
r = stats.multivariate_normal(x_old + self.filter_mu, self.filter_sigma).rvs(size)
return(r)
def d_prop(self, x_old, x_new, y):
return stats.multivariate_normal(self.filter_mu, self.filter_sigma).pdf(x_new-x_old)
def r_init_prop(self, size, y):
return stats.multivariate_normal(self.filter_mu, self.filter_sigma).rvs(size).reshape(self.N, self.x_dim)
def detect_keypoints(imagename, threshold):
# SIFT Detector
#--------------
original = ndimage.imread(imagename, flatten=True)
# SIFT Parameters
s = 3
k = 2 ** (1.0 / s)
# threshold variable is the contrast threshold. Set to at least 1
# Standard deviations for Gaussian smoothing
kvec1 = np.array([1.3, 1.6, 1.6 * k, 1.6 * (k ** 2), 1.6 * (k ** 3), 1.6 * (k ** 4)])
kvec2 = np.array([1.6 * (k ** 2), 1.6 * (k ** 3), 1.6 * (k ** 4), 1.6 * (k ** 5), 1.6 * (k ** 6), 1.6 * (k ** 7)])
kvec3 = np.array([1.6 * (k ** 5), 1.6 * (k ** 6), 1.6 * (k ** 7), 1.6 * (k ** 8), 1.6 * (k ** 9), 1.6 * (k ** 10)])
kvec4 = np.array([1.6 * (k ** 8), 1.6 * (k ** 9), 1.6 * (k ** 10), 1.6 * (k ** 11), 1.6 * (k ** 12), 1.6 * (k ** 13)])
kvectotal = np.array([1.6, 1.6 * k, 1.6 * (k ** 2), 1.6 * (k ** 3), 1.6 * (k ** 4), 1.6 * (k ** 5), 1.6 * (k ** 6), 1.6 * (k ** 7), 1.6 * (k ** 8), 1.6 * (k ** 9), 1.6 * (k ** 10), 1.6 * (k ** 11)])
# Downsampling images
doubled = misc.imresize(original, 200, 'bilinear').astype(int)
normal = misc.imresize(doubled, 50, 'bilinear').astype(int)
halved = misc.imresize(normal, 50, 'bilinear').astype(int)
quartered = misc.imresize(halved, 50, 'bilinear').astype(int)
# Initialize Gaussian pyramids
pyrlvl1 = np.zeros((doubled.shape[0], doubled.shape[1], 6))
pyrlvl2 = np.zeros((normal.shape[0], normal.shape[1], 6))
pyrlvl3 = np.zeros((halved.shape[0], halved.shape[1], 6))
pyrlvl4 = np.zeros((quartered.shape[0], quartered.shape[1], 6))
print("Constructing pyramids...")
# Construct Gaussian pyramids
for i in range(0, 6):
pyrlvl1[:,:,i] = ndimage.filters.gaussian_filter(doubled, kvec1[i])
pyrlvl2[:,:,i] = misc.imresize(ndimage.filters.gaussian_filter(doubled, kvec2[i]), 50, 'bilinear')
pyrlvl3[:,:,i] = misc.imresize(ndimage.filters.gaussian_filter(doubled, kvec3[i]), 25, 'bilinear')
pyrlvl4[:,:,i] = misc.imresize(ndimage.filters.gaussian_filter(doubled, kvec4[i]), 1.0 / 8.0, 'bilinear')
# Initialize Difference-of-Gaussians (DoG) pyramids
diffpyrlvl1 = np.zeros((doubled.shape[0], doubled.shape[1], 5))
diffpyrlvl2 = np.zeros((normal.shape[0], normal.shape[1], 5))
diffpyrlvl3 = np.zeros((halved.shape[0], halved.shape[1], 5))
diffpyrlvl4 = np.zeros((quartered.shape[0], quartered.shape[1], 5))
# Construct DoG pyramids
for i in range(0, 5):
diffpyrlvl1[:,:,i] = pyrlvl1[:,:,i+1] - pyrlvl1[:,:,i]
diffpyrlvl2[:,:,i] = pyrlvl2[:,:,i+1] - pyrlvl2[:,:,i]
diffpyrlvl3[:,:,i] = pyrlvl3[:,:,i+1] - pyrlvl3[:,:,i]
diffpyrlvl4[:,:,i] = pyrlvl4[:,:,i+1] - pyrlvl4[:,:,i]
# Initialize pyramids to store extrema locations
extrpyrlvl1 = np.zeros((doubled.shape[0], doubled.shape[1], 3))
extrpyrlvl2 = np.zeros((normal.shape[0], normal.shape[1], 3))
extrpyrlvl3 = np.zeros((halved.shape[0], halved.shape[1], 3))
extrpyrlvl4 = np.zeros((quartered.shape[0], quartered.shape[1], 3))
print("Starting extrema detection...")
print("First octave")
# In each of the following for loops, elements of each pyramids that are larger or smaller than its 26 immediate neighbors in space and scale are labeled as extrema. As explained in section 4 of Lowe's paper, these initial extrema are pruned by checking that their contrast and curvature are above certain thresholds. The thresholds used here are those suggested by Lowe.
for i in range(1, 4):
for j in range(80, doubled.shape[0] - 80):
for k in range(80, doubled.shape[1] - 80):
if np.absolute(diffpyrlvl1[j, k, i]) < threshold:
continue
maxbool = (diffpyrlvl1[j, k, i] > 0)
minbool = (diffpyrlvl1[j, k, i] < 0)
for di in range(-1, 2):
for dj in range(-1, 2):
for dk in range(-1, 2):
if di == 0 and dj == 0 and dk == 0:
continue
maxbool = maxbool and (diffpyrlvl1[j, k, i] > diffpyrlvl1[j + dj, k + dk, i + di])
minbool = minbool and (diffpyrlvl1[j, k, i] < diffpyrlvl1[j + dj, k + dk, i + di])
if not maxbool and not minbool:
break
if not maxbool and not minbool:
break
if not maxbool and not minbool:
break
if maxbool or minbool:
dx = (diffpyrlvl1[j, k+1, i] - diffpyrlvl1[j, k-1, i]) * 0.5 / 255
dy = (diffpyrlvl1[j+1, k, i] - diffpyrlvl1[j-1, k, i]) * 0.5 / 255
ds = (diffpyrlvl1[j, k, i+1] - diffpyrlvl1[j, k, i-1]) * 0.5 / 255
dxx = (diffpyrlvl1[j, k+1, i] + diffpyrlvl1[j, k-1, i] - 2 * diffpyrlvl1[j, k, i]) * 1.0 / 255
dyy = (diffpyrlvl1[j+1, k, i] + diffpyrlvl1[j-1, k, i] - 2 * diffpyrlvl1[j, k, i]) * 1.0 / 255
dss = (diffpyrlvl1[j, k, i+1] + diffpyrlvl1[j, k, i-1] - 2 * diffpyrlvl1[j, k, i]) * 1.0 / 255
dxy = (diffpyrlvl1[j+1, k+1, i] - diffpyrlvl1[j+1, k-1, i] - diffpyrlvl1[j-1, k+1, i] + diffpyrlvl1[j-1, k-1, i]) * 0.25 / 255
dxs = (diffpyrlvl1[j, k+1, i+1] - diffpyrlvl1[j, k-1, i+1] - diffpyrlvl1[j, k+1, i-1] + diffpyrlvl1[j, k-1, i-1]) * 0.25 / 255
dys = (diffpyrlvl1[j+1, k, i+1] - diffpyrlvl1[j-1, k, i+1] - diffpyrlvl1[j+1, k, i-1] + diffpyrlvl1[j-1, k, i-1]) * 0.25 / 255
dD = np.matrix([[dx], [dy], [ds]])
H = np.matrix([[dxx, dxy, dxs], [dxy, dyy, dys], [dxs, dys, dss]])
x_hat = numpy.linalg.lstsq(H, dD)[0]
D_x_hat = diffpyrlvl1[j, k, i] + 0.5 * np.dot(dD.transpose(), x_hat)
r = 10.0
if ((((dxx + dyy) ** 2) * r) < (dxx * dyy - (dxy ** 2)) * (((r + 1) ** 2))) and (np.absolute(x_hat[0]) < 0.5) and (np.absolute(x_hat[1]) < 0.5) and (np.absolute(x_hat[2]) < 0.5) and (np.absolute(D_x_hat) > 0.03):
extrpyrlvl1[j, k, i - 1] = 1
print("Second octave")
for i in range(1, 4):
for j in range(40, normal.shape[0] - 40):
for k in range(40, normal.shape[1] - 40):
if np.absolute(diffpyrlvl2[j, k, i]) < threshold:
continue
maxbool = (diffpyrlvl2[j, k, i] > 0)
minbool = (diffpyrlvl2[j, k, i] < 0)
for di in range(-1, 2):
for dj in range(-1, 2):
for dk in range(-1, 2):
if di == 0 and dj == 0 and dk == 0:
continue
maxbool = maxbool and (diffpyrlvl2[j, k, i] > diffpyrlvl2[j + dj, k + dk, i + di])
minbool = minbool and (diffpyrlvl2[j, k, i] < diffpyrlvl2[j + dj, k + dk, i + di])
if not maxbool and not minbool:
break
if not maxbool and not minbool:
break
if not maxbool and not minbool:
break
if maxbool or minbool:
dx = (diffpyrlvl2[j, k+1, i] - diffpyrlvl2[j, k-1, i]) * 0.5 / 255
dy = (diffpyrlvl2[j+1, k, i] - diffpyrlvl2[j-1, k, i]) * 0.5 / 255
ds = (diffpyrlvl2[j, k, i+1] - diffpyrlvl2[j, k, i-1]) * 0.5 / 255
dxx = (diffpyrlvl2[j, k+1, i] + diffpyrlvl2[j, k-1, i] - 2 * diffpyrlvl2[j, k, i]) * 1.0 / 255
dyy = (diffpyrlvl2[j+1, k, i] + diffpyrlvl2[j-1, k, i] - 2 * diffpyrlvl2[j, k, i]) * 1.0 / 255
dss = (diffpyrlvl2[j, k, i+1] + diffpyrlvl2[j, k, i-1] - 2 * diffpyrlvl2[j, k, i]) * 1.0 / 255
dxy = (diffpyrlvl2[j+1, k+1, i] - diffpyrlvl2[j+1, k-1, i] - diffpyrlvl2[j-1, k+1, i] + diffpyrlvl2[j-1, k-1, i]) * 0.25 / 255
dxs = (diffpyrlvl2[j, k+1, i+1] - diffpyrlvl2[j, k-1, i+1] - diffpyrlvl2[j, k+1, i-1] + diffpyrlvl2[j, k-1, i-1]) * 0.25 / 255
dys = (diffpyrlvl2[j+1, k, i+1] - diffpyrlvl2[j-1, k, i+1] - diffpyrlvl2[j+1, k, i-1] + diffpyrlvl2[j-1, k, i-1]) * 0.25 / 255
dD = np.matrix([[dx], [dy], [ds]])
H = np.matrix([[dxx, dxy, dxs], [dxy, dyy, dys], [dxs, dys, dss]])
x_hat = numpy.linalg.lstsq(H, dD)[0]
D_x_hat = diffpyrlvl2[j, k, i] + 0.5 * np.dot(dD.transpose(), x_hat)
r = 10.0
if (((dxx + dyy) ** 2) * r) < (dxx * dyy - (dxy ** 2)) * (((r + 1) ** 2)) and np.absolute(x_hat[0]) < 0.5 and np.absolute(x_hat[1]) < 0.5 and np.absolute(x_hat[2]) < 0.5 and np.absolute(D_x_hat) > 0.03:
extrpyrlvl2[j, k, i - 1] = 1
print("Third octave")
for i in range(1, 4):
for j in range(20, halved.shape[0] - 20):
for k in range(20, halved.shape[1] - 20):
if np.absolute(diffpyrlvl3[j, k, i]) < threshold:
continue
maxbool = (diffpyrlvl3[j, k, i] > 0)
minbool = (diffpyrlvl3[j, k, i] < 0)
for di in range(-1, 2):
for dj in range(-1, 2):
for dk in range(-1, 2):
if di == 0 and dj == 0 and dk == 0:
continue
maxbool = maxbool and (diffpyrlvl3[j, k, i] > diffpyrlvl3[j + dj, k + dk, i + di])
minbool = minbool and (diffpyrlvl3[j, k, i] < diffpyrlvl3[j + dj, k + dk, i + di])
if not maxbool and not minbool:
break
if not maxbool and not minbool:
break
if not maxbool and not minbool:
break
if maxbool or minbool:
dx = (diffpyrlvl3[j, k+1, i] - diffpyrlvl3[j, k-1, i]) * 0.5 / 255
dy = (diffpyrlvl3[j+1, k, i] - diffpyrlvl3[j-1, k, i]) * 0.5 / 255
ds = (diffpyrlvl3[j, k, i+1] - diffpyrlvl3[j, k, i-1]) * 0.5 / 255
dxx = (diffpyrlvl3[j, k+1, i] + diffpyrlvl3[j, k-1, i] - 2 * diffpyrlvl3[j, k, i]) * 1.0 / 255
dyy = (diffpyrlvl3[j+1, k, i] + diffpyrlvl3[j-1, k, i] - 2 * diffpyrlvl3[j, k, i]) * 1.0 / 255
dss = (diffpyrlvl3[j, k, i+1] + diffpyrlvl3[j, k, i-1] - 2 * diffpyrlvl3[j, k, i]) * 1.0 / 255
dxy = (diffpyrlvl3[j+1, k+1, i] - diffpyrlvl3[j+1, k-1, i] - diffpyrlvl3[j-1, k+1, i] + diffpyrlvl3[j-1, k-1, i]) * 0.25 / 255
dxs = (diffpyrlvl3[j, k+1, i+1] - diffpyrlvl3[j, k-1, i+1] - diffpyrlvl3[j, k+1, i-1] + diffpyrlvl3[j, k-1, i-1]) * 0.25 / 255
dys = (diffpyrlvl3[j+1, k, i+1] - diffpyrlvl3[j-1, k, i+1] - diffpyrlvl3[j+1, k, i-1] + diffpyrlvl3[j-1, k, i-1]) * 0.25 / 255
dD = np.matrix([[dx], [dy], [ds]])
H = np.matrix([[dxx, dxy, dxs], [dxy, dyy, dys], [dxs, dys, dss]])
x_hat = numpy.linalg.lstsq(H, dD)[0]
D_x_hat = diffpyrlvl3[j, k, i] + 0.5 * np.dot(dD.transpose(), x_hat)
r = 10.0
if (((dxx + dyy) ** 2) * r) < (dxx * dyy - (dxy ** 2)) * (((r + 1) ** 2)) and np.absolute(x_hat[0]) < 0.5 and np.absolute(x_hat[1]) < 0.5 and np.absolute(x_hat[2]) < 0.5 and np.absolute(D_x_hat) > 0.03:
extrpyrlvl3[j, k, i - 1] = 1
print("Fourth octave")
for i in range(1, 4):
for j in range(10, quartered.shape[0] - 10):
for k in range(10, quartered.shape[1] - 10):
if np.absolute(diffpyrlvl4[j, k, i]) < threshold:
continue
maxbool = (diffpyrlvl4[j, k, i] > 0)
minbool = (diffpyrlvl4[j, k, i] < 0)
for di in range(-1, 2):
for dj in range(-1, 2):
for dk in range(-1, 2):
if di == 0 and dj == 0 and dk == 0:
continue
maxbool = maxbool and (diffpyrlvl4[j, k, i] > diffpyrlvl4[j + dj, k + dk, i + di])
minbool = minbool and (diffpyrlvl4[j, k, i] < diffpyrlvl4[j + dj, k + dk, i + di])
if not maxbool and not minbool:
break
if not maxbool and not minbool:
break
if not maxbool and not minbool:
break
if maxbool or minbool:
dx = (diffpyrlvl4[j, k+1, i] - diffpyrlvl4[j, k-1, i]) * 0.5 / 255
dy = (diffpyrlvl4[j+1, k, i] - diffpyrlvl4[j-1, k, i]) * 0.5 / 255
ds = (diffpyrlvl4[j, k, i+1] - diffpyrlvl4[j, k, i-1]) * 0.5 / 255
dxx = (diffpyrlvl4[j, k+1, i] + diffpyrlvl4[j, k-1, i] - 2 * diffpyrlvl4[j, k, i]) * 1.0 / 255
dyy = (diffpyrlvl4[j+1, k, i] + diffpyrlvl4[j-1, k, i] - 2 * diffpyrlvl4[j, k, i]) * 1.0 / 255
dss = (diffpyrlvl4[j, k, i+1] + diffpyrlvl4[j, k, i-1] - 2 * diffpyrlvl4[j, k, i]) * 1.0 / 255
dxy = (diffpyrlvl4[j+1, k+1, i] - diffpyrlvl4[j+1, k-1, i] - diffpyrlvl4[j-1, k+1, i] + diffpyrlvl4[j-1, k-1, i]) * 0.25 / 255
dxs = (diffpyrlvl4[j, k+1, i+1] - diffpyrlvl4[j, k-1, i+1] - diffpyrlvl4[j, k+1, i-1] + diffpyrlvl4[j, k-1, i-1]) * 0.25 / 255
dys = (diffpyrlvl4[j+1, k, i+1] - diffpyrlvl4[j-1, k, i+1] - diffpyrlvl4[j+1, k, i-1] + diffpyrlvl4[j-1, k, i-1]) * 0.25 / 255
dD = np.matrix([[dx], [dy], [ds]])
H = np.matrix([[dxx, dxy, dxs], [dxy, dyy, dys], [dxs, dys, dss]])
x_hat = numpy.linalg.lstsq(H, dD)[0]
D_x_hat = diffpyrlvl4[j, k, i] + 0.5 * np.dot(dD.transpose(), x_hat)
r = 10.0
if (((dxx + dyy) ** 2) * r) < (dxx * dyy - (dxy ** 2)) * (((r + 1) ** 2)) and np.absolute(x_hat[0]) < 0.5 and np.absolute(x_hat[1]) < 0.5 and np.absolute(x_hat[2]) < 0.5 and np.absolute(D_x_hat) > 0.03:
extrpyrlvl4[j, k, i - 1] = 1
print("Number of extrema in first octave: %d" % np.sum(extrpyrlvl1))
print("Number of extrema in second octave: %d" % np.sum(extrpyrlvl2))
print("Number of extrema in third octave: %d" % np.sum(extrpyrlvl3))
print("Number of extrema in fourth octave: %d" % np.sum(extrpyrlvl4))
# Gradient magnitude and orientation for each image sample point at each scale
magpyrlvl1 = np.zeros((doubled.shape[0], doubled.shape[1], 3))
magpyrlvl2 = np.zeros((normal.shape[0], normal.shape[1], 3))
magpyrlvl3 = np.zeros((halved.shape[0], halved.shape[1], 3))
magpyrlvl4 = np.zeros((quartered.shape[0], quartered.shape[1], 3))
oripyrlvl1 = np.zeros((doubled.shape[0], doubled.shape[1], 3))
oripyrlvl2 = np.zeros((normal.shape[0], normal.shape[1], 3))
oripyrlvl3 = np.zeros((halved.shape[0], halved.shape[1], 3))
oripyrlvl4 = np.zeros((quartered.shape[0], quartered.shape[1], 3))
for i in range(0, 3):
for j in range(1, doubled.shape[0] - 1):
for k in range(1, doubled.shape[1] - 1):
magpyrlvl1[j, k, i] = ( ((doubled[j+1, k] - doubled[j-1, k]) ** 2) + ((doubled[j, k+1] - doubled[j, k-1]) ** 2) ) ** 0.5
oripyrlvl1[j, k, i] = (36 / (2 * np.pi)) * (np.pi + np.arctan2((doubled[j, k+1] - doubled[j, k-1]), (doubled[j+1, k] - doubled[j-1, k])))
for i in range(0, 3):
for j in range(1, normal.shape[0] - 1):
for k in range(1, normal.shape[1] - 1):
magpyrlvl2[j, k, i] = ( ((normal[j+1, k] - normal[j-1, k]) ** 2) + ((normal[j, k+1] - normal[j, k-1]) ** 2) ) ** 0.5
oripyrlvl2[j, k, i] = (36 / (2 * np.pi)) * (np.pi + np.arctan2((normal[j, k+1] - normal[j, k-1]), (normal[j+1, k] - normal[j-1, k])))
for i in range(0, 3):
for j in range(1, halved.shape[0] - 1):
for k in range(1, halved.shape[1] - 1):
magpyrlvl3[j, k, i] = ( ((halved[j+1, k] - halved[j-1, k]) ** 2) + ((halved[j, k+1] - halved[j, k-1]) ** 2) ) ** 0.5
oripyrlvl3[j, k, i] = (36 / (2 * np.pi)) * (np.pi + np.arctan2((halved[j, k+1] - halved[j, k-1]), (halved[j+1, k] - halved[j-1, k])))
for i in range(0, 3):
for j in range(1, quartered.shape[0] - 1):
for k in range(1, quartered.shape[1] - 1):
magpyrlvl4[j, k, i] = ( ((quartered[j+1, k] - quartered[j-1, k]) ** 2) + ((quartered[j, k+1] - quartered[j, k-1]) ** 2) ) ** 0.5
oripyrlvl4[j, k, i] = (36 / (2 * np.pi)) * (np.pi + np.arctan2((quartered[j, k+1] - quartered[j, k-1]), (quartered[j+1, k] - quartered[j-1, k])))
extr_sum = np.sum(extrpyrlvl1) + np.sum(extrpyrlvl2) + np.sum(extrpyrlvl3) + np.sum(extrpyrlvl4)
keypoints = np.zeros((extr_sum, 4))
print("Calculating keypoint orientations...")
count = 0
for i in range(0, 3):
for j in range(80, doubled.shape[0] - 80):
for k in range(80, doubled.shape[1] - 80):
if extrpyrlvl1[j, k, i] == 1:
gaussian_window = multivariate_normal(mean=[j, k], cov=((1.5 * kvectotal[i]) ** 2))
two_sd = np.floor(2 * 1.5 * kvectotal[i])
orient_hist = np.zeros([36,1])
for x in range(int(-1 * two_sd * 2), int(two_sd * 2) + 1):
ylim = int((((two_sd * 2) ** 2) - (np.absolute(x) ** 2)) ** 0.5)
for y in range(-1 * ylim, ylim + 1):
if j + x < 0 or j + x > doubled.shape[0] - 1 or k + y < 0 or k + y > doubled.shape[1] - 1:
continue
weight = magpyrlvl1[j + x, k + y, i] * gaussian_window.pdf([j + x, k + y])
bin_idx = np.clip(np.floor(oripyrlvl1[j + x, k + y, i]), 0, 35)
orient_hist[np.floor(bin_idx)] += weight
maxval = np.amax(orient_hist)
maxidx = np.argmax(orient_hist)
keypoints[count, :] = np.array([int(j * 0.5), int(k * 0.5), kvectotal[i], maxidx])
count += 1
orient_hist[maxidx] = 0
newmaxval = np.amax(orient_hist)
while newmaxval > 0.8 * maxval:
newmaxidx = np.argmax(orient_hist)
np.append(keypoints, np.array([[int(j * 0.5), int(k * 0.5), kvectotal[i], newmaxidx]]), axis=0)
orient_hist[newmaxidx] = 0
newmaxval = np.amax(orient_hist)
for i in range(0, 3):
for j in range(40, normal.shape[0] - 40):
for k in range(40, normal.shape[1] - 40):
if extrpyrlvl2[j, k, i] == 1:
gaussian_window = multivariate_normal(mean=[j, k], cov=((1.5 * kvectotal[i + 3]) ** 2))
two_sd = np.floor(2 * 1.5 * kvectotal[i + 3])
orient_hist = np.zeros([36,1])
for x in range(int(-1 * two_sd), int(two_sd + 1)):
ylim = int(((two_sd ** 2) - (np.absolute(x) ** 2)) ** 0.5)
for y in range(-1 * ylim, ylim + 1):
if j + x < 0 or j + x > normal.shape[0] - 1 or k + y < 0 or k + y > normal.shape[1] - 1:
continue
weight = magpyrlvl2[j + x, k + y, i] * gaussian_window.pdf([j + x, k + y])
bin_idx = np.clip(np.floor(oripyrlvl2[j + x, k + y, i]), 0, 35)
orient_hist[np.floor(bin_idx)] += weight
maxval = np.amax(orient_hist)
maxidx = np.argmax(orient_hist)
keypoints[count, :] = np.array([j, k, kvectotal[i + 3], maxidx])
count += 1
orient_hist[maxidx] = 0
newmaxval = np.amax(orient_hist)
while newmaxval > 0.8 * maxval:
newmaxidx = np.argmax(orient_hist)
np.append(keypoints, np.array([[j, k, kvectotal[i + 3], newmaxidx]]), axis=0)
orient_hist[newmaxidx] = 0
newmaxval = np.amax(orient_hist)
for i in range(0, 3):
for j in range(20, halved.shape[0] - 20):
for k in range(20, halved.shape[1] - 20):
if extrpyrlvl3[j, k, i] == 1:
gaussian_window = multivariate_normal(mean=[j, k], cov=((1.5 * kvectotal[i + 6]) ** 2))
two_sd = np.floor(2 * 1.5 * kvectotal[i + 6])
orient_hist = np.zeros([36,1])
for x in range(int(-1 * two_sd * 0.5), int(two_sd * 0.5) + 1):
ylim = int((((two_sd * 0.5) ** 2) - (np.absolute(x) ** 2)) ** 0.5)
for y in range(-1 * ylim, ylim + 1):
if j + x < 0 or j + x > halved.shape[0] - 1 or k + y < 0 or k + y > halved.shape[1] - 1:
continue
weight = magpyrlvl3[j + x, k + y, i] * gaussian_window.pdf([j + x, k + y])
bin_idx = np.clip(np.floor(oripyrlvl3[j + x, k + y, i]), 0, 35)
orient_hist[np.floor(bin_idx)] += weight
maxval = np.amax(orient_hist)
maxidx = np.argmax(orient_hist)
keypoints[count, :] = np.array([j * 2, k * 2, kvectotal[i + 6], maxidx])
count += 1
orient_hist[maxidx] = 0
newmaxval = np.amax(orient_hist)
while newmaxval > 0.8 * maxval:
newmaxidx = np.argmax(orient_hist)
np.append(keypoints, np.array([[j * 2, k * 2, kvectotal[i + 6], newmaxidx]]), axis=0)
orient_hist[newmaxidx] = 0
newmaxval = np.amax(orient_hist)
for i in range(0, 3):
for j in range(10, quartered.shape[0] - 10):
for k in range(10, quartered.shape[1] - 10):
if extrpyrlvl4[j, k, i] == 1:
gaussian_window = multivariate_normal(mean=[j, k], cov=((1.5 * kvectotal[i + 9]) ** 2))
two_sd = np.floor(2 * 1.5 * kvectotal[i + 9])
orient_hist = np.zeros([36,1])
for x in range(int(-1 * two_sd * 0.25), int(two_sd * 0.25) + 1):
ylim = int((((two_sd * 0.25) ** 2) - (np.absolute(x) ** 2)) ** 0.5)
for y in range(-1 * ylim, ylim + 1):
if j + x < 0 or j + x > quartered.shape[0] - 1 or k + y < 0 or k + y > quartered.shape[1] - 1:
continue
weight = magpyrlvl4[j + x, k + y, i] * gaussian_window.pdf([j + x, k + y])
bin_idx = np.clip(np.floor(oripyrlvl4[j + x, k + y, i]), 0, 35)
orient_hist[np.floor(bin_idx)] += weight
maxval = np.amax(orient_hist)
maxidx = np.argmax(orient_hist)
keypoints[count, :] = np.array([j * 4, k * 4, kvectotal[i + 9], maxidx])
count += 1
orient_hist[maxidx] = 0
newmaxval = np.amax(orient_hist)
while newmaxval > 0.8 * maxval:
newmaxidx = np.argmax(orient_hist)
np.append(keypoints, np.array([[j * 4, k * 4, kvectotal[i + 9], newmaxidx]]), axis=0)
orient_hist[newmaxidx] = 0
newmaxval = np.amax(orient_hist)
print("Calculating descriptor...")
magpyr = np.zeros((normal.shape[0], normal.shape[1], 12))
oripyr = np.zeros((normal.shape[0], normal.shape[1], 12))
for i in range(0, 3):
magmax = np.amax(magpyrlvl1[:, :, i])
magpyr[:, :, i] = misc.imresize(magpyrlvl1[:, :, i], (normal.shape[0], normal.shape[1]), "bilinear").astype(float)
magpyr[:, :, i] = (magmax / np.amax(magpyr[:, :, i])) * magpyr[:, :, i]
oripyr[:, :, i] = misc.imresize(oripyrlvl1[:, :, i], (normal.shape[0], normal.shape[1]), "bilinear").astype(int)
oripyr[:, :, i] = ((36.0 / np.amax(oripyr[:, :, i])) * oripyr[:, :, i]).astype(int)
for i in range(0, 3):
magpyr[:, :, i+3] = (magpyrlvl2[:, :, i]).astype(float)
oripyr[:, :, i+3] = (oripyrlvl2[:, :, i]).astype(int)
for i in range(0, 3):
magpyr[:, :, i+6] = misc.imresize(magpyrlvl3[:, :, i], (normal.shape[0], normal.shape[1]), "bilinear").astype(int)
oripyr[:, :, i+6] = misc.imresize(oripyrlvl3[:, :, i], (normal.shape[0], normal.shape[1]), "bilinear").astype(int)
for i in range(0, 3):
magpyr[:, :, i+9] = misc.imresize(magpyrlvl4[:, :, i], (normal.shape[0], normal.shape[1]), "bilinear").astype(int)
oripyr[:, :, i+9] = misc.imresize(oripyrlvl4[:, :, i], (normal.shape[0], normal.shape[1]), "bilinear").astype(int)
descriptors = np.zeros([keypoints.shape[0], 128])
for i in range(0, keypoints.shape[0]):
for x in range(-8, 8):
for y in range(-8, 8):
theta = 10 * keypoints[i,3] * np.pi / 180.0
xrot = np.round((np.cos(theta) * x) - (np.sin(theta) * y))
yrot = np.round((np.sin(theta) * x) + (np.cos(theta) * y))
scale_idx = np.argwhere(kvectotal == keypoints[i,2])[0][0]
x0 = keypoints[i,0]
y0 = keypoints[i,1]
gaussian_window = multivariate_normal(mean=[x0,y0], cov=8)
weight = magpyr[int(x0 + xrot), int(y0 + yrot), scale_idx] * gaussian_window.pdf([x0 + xrot, y0 + yrot])
angle = oripyr[int(x0 + xrot), int(y0 + yrot), scale_idx] - keypoints[i,3]
if angle < 0:
angle = 36 + angle
bin_idx = np.clip(np.floor((8.0 / 36) * angle), 0, 7).astype(int)
descriptors[i, 32 * int((x + 8)/4) + 8 * int((y + 8)/4) + bin_idx] += weight
descriptors[i, :] = descriptors[i, :] / norm(descriptors[i, :])
descriptors[i, :] = np.clip(descriptors[i, :], 0, 0.2)
descriptors[i, :] = descriptors[i, :] / norm(descriptors[i, :])
return [keypoints, descriptors]
def __call__(self, theta):
kernel = stats.multivariate_normal(theta, self.sigma).pdf
w = self.prior(theta) / np.sum(self.ws * kernel(self.samples))
return w
def d_lik(self, x, y):
""" Y_t | X_t """
return stats.multivariate_normal(self.model_nu, self.model_tau).pdf(y-x)
mprior = Nonparametric(CSI.T)
# KDE-based proposal
def kde_proposal(CSI):
return mprior.sample(n_samples=nsamples)
from utils import alltimes, history
timesteps = [1812, 2421, 3029] # chosen timesteps for Bayesian inference
# history-based uncertainty mitigation
for i, t in enumerate(timesteps, 1):
dobs = history[alltimes == t, :].flatten()
dprior = multivariate_normal(mean=dobs, cov=.1)
# likelihood under perfect forwarding assumption
def lnlike(csi):
m = kpca.predict(csi).clip(0, 1)
return dprior.logpdf(G(m, [t]))
# posterior sigma_m(m) ~ rho_d(G(m)) * rho_m(m)
def lnprob(csi):
m = kpca.predict(csi).clip(0, 1)
return mprior.logpdf(csi) + dprior.logpdf(G(m, [t]))
if pool.is_master():
### There are two possible configurations:
# a) (symmetric) stretch move
def tidalsite():
MinDist = 20
dx = MinDist * 4
dy = dx / 4
pos = []
for i in range(5):
for j in range(5):
if not (i) % 2:
temp = [i * dx, j * dy - dy / 2]
else:
temp = [i * dx, j * dy]
pos.append(temp)
pos = [item for item in pos if item[1] >= 0]
# #x,y coordinate of the statistical analysis
# # Statistical analysis generation
# # --------------------------------
x = np.linspace(0., 1000., 100)
y = np.linspace(0., 300., 30)
# Lease Area
leaseAreaVertexUTM = np.array(
[[50., 50.], [950., 50.], [950., 250.], [50., 250.]], dtype=float)
# Nogo areas
Nogoareas_wave = []
nx = len(x)
ny = len(y)
# Tidal time series
time_points = 1
rv = norm()
time_pdf = rv.pdf(np.linspace(-2, 2, time_points))
time_scaled = time_pdf * (1. / np.amax(time_pdf))
xgrid, ygrid = np.meshgrid(x, y)
pos = np.dstack((xgrid, ygrid))
rv = multivariate_normal(
[x.mean(), y.mean()],
[[max(x) * 5., max(y) * 2.], [max(y) * 2., max(x) * 5.]])
#u_max = 10.
u_max = 5.
v_max = 1.
ssh_max = 1.
grid_pdf = rv.pdf(pos)
u_scaled = grid_pdf * (u_max / np.amax(grid_pdf))
v_scaled = np.ones((ny, nx)) * v_max
ssh_scaled = grid_pdf * (ssh_max / np.amax(grid_pdf))
u_arrays = []
v_arrays = []
ssh_arrays = []
for multiplier in time_scaled:
u_arrays.append(u_scaled * multiplier)
v_arrays.append(v_scaled * multiplier)
ssh_arrays.append(ssh_scaled * multiplier)
U = np.dstack(u_arrays)
V = np.dstack(v_arrays)
SSH = np.dstack(ssh_arrays)
U = U * 0 + 2
V = V * 0 + 0
TI = np.array([0.1])
p = np.ones(U.shape[-1])
# END of Statistical analysis generation
# ---------------------------------------
Meteocean = {'V': V, 'U': U, 'p': p, 'TI': TI, 'x': x, 'y': y, 'SSH': SSH}
VelocityShear = np.array([7.])
MainDirection = None #np.array([1.,1.])
#ang = np.pi*0.25
#MainDirection = np.array([np.cos(ang),np.sin(ang)])
#Temp check nogo areas
#xb = np.linspace(0,100,10)
#yb = np.linspace(0,50,5)
Bathymetry = np.array([-60.])
Geophysics = np.array([0.3])
BR = 1.
electrical_connection_point = (-1000.0, -4000.0)
out = [
leaseAreaVertexUTM, Nogoareas_wave, Meteocean, VelocityShear,
MainDirection, Bathymetry, Geophysics, BR, electrical_connection_point
]
return out
else:
#myself
n_iteration = 100
n, d = data.shape
mu1 = np.random.standard_normal(d)
print(mu1)
mu2 = np.random.standard_normal(d)
print(mu2)
sigma1 = np.identity(
d
) #The identity array is a square array with ones on the main diagonal.
sigma2 = np.identity(d)
pi = 0.5
for i in range(n_iteration):
norm1 = multivariate_normal(mu1, sigma1)
norm2 = multivariate_normal(mu2, sigma2)
tau1 = pi * norm1.pdf(data)
tau2 = (1 - pi) * norm2.pdf(data)
gamma = tau1 / (tau1 + tau2)
#m-step
mu1 = np.dot(gamma, data) / np.sum(gamma)
mu2 = np.dot((1 - gamma), data) / np.sum(1 - gamma)
sigma1 = np.dot(gamma * (data - mu1).T, data) / np.sum(gamma)
sigma2 = np.dot(
(1 - gamma) * (data - mu2).T, data) / np.sum(1 - gamma)
pi = np.sum(gamma) / n
print(i, ":\t", mu1, mu2)
print('类别概率:\t', pi)
print('均值:\t', mu1, mu2)
def d_init(self, x):
""" X_0 """
return stats.multivariate_normal(self.model_mu,self.model_sigma).pdf(x)
if((cache[j] != crude_data[i]) and \ (output[i, j, 0] > LRU_before)): output[i, j, 0] -= 1; factor = np.zeros((2)); for j in range(num_bucket): f_value[j] = output[i, j, 1]; if(f_value[j] > 100): f_value[j] = 100; factor[0] = np.mean(f_value); factor[1] = np.var(f_value); # Update distances (in this case, possibility) for label in range(num_label): if(mu[label][0] != 0): rv = multivariate_normal(mean = mu[label], cov = sigma[label]); distance[label] = np.log(pi[label]) +rv.logpdf(factor); else: distance[label] = -99999; """ for j in range(num_bucket): #print(j); # print(mu[j]); # print(sigma[j]); if(mu[j][0] != 0): distance[j] = rv.logpdf( constant = 1 / (pow(2 * math.pi, 2) * pow(np.linalg.det(sigma[j]), 1/2)); exp = -1/2 * np.dot(inv(sigma[j]), (factor - mu[j])); exp = np.dot((factor - mu[j]).transpose(), exp); distance[j] = constant * np.exp(exp); else:
def gen_gaussian(mean_in, cov_in, class_label, num):
nv = multivariate_normal(mean=mean_in, cov=cov_in)
X = nv.rvs(num)
y = np.ones(num, dtype=float) * class_label
return nv, X, y
def update(self, agents, t, sleeping=False):
if len(
self.replay_buffer
) < self.max_replay_buffer_len: # replay buffer is not large enough
return
if not t % 100 == 0: # update every 100 steps
return
smallest_batch_index = 0
smallest_batch_size = -1
for i in range(self.n):
if (smallest_batch_size == -1
or len(agents[i].replay_buffer) < smallest_batch_size):
smallest_batch_size = len(agents[i].replay_buffer)
smallest_batch_index = i
# Different agents have different amounts of experience, need to use the smallest to get list of experience from memory
self.replay_sample_index = agents[
smallest_batch_index].replay_buffer.make_index(
self.args.batch_size)
obs_n = []
obs_next_n = []
act_n = []
index = self.replay_sample_index
for i in range(self.n):
obs, act, mask, rew, obs_next, done = agents[
i].replay_buffer.sample_index(index)
obs_n.append(obs)
obs_next_n.append(obs_next)
act_n.append(act)
obs, act, masks, rew, obs_next, done = self.replay_buffer.sample_index(
index)
rew = rew.flatten()
signal = False
mir_penalty = 0
if (self.mic > 0 and (not self.args.sleep_regimen or
(self.args.sleep_regimen and sleeping))
): # If sleep regimen is on, only use mic when sleeping
try:
multivar = multivariate_normal(self.multivariate_mean,
self.multivariate_cov,
allow_singular=True)
logp_phi = multivar.logpdf(act)
logp_phi = logp_phi.reshape(self.args.batch_size, )
p_phi = multivar.pdf(act)
p_phi = p_phi.reshape(self.args.batch_size, )
action_mean = np.mean(act, axis=0)
action_mean = action_mean + 1e-6 # add small value so probabilities close to zero arent problematic
action_mean = action_mean / np.sum(action_mean) # normalize
action_std = np.std(act / np.sum(act), axis=0)
action_cov = np.diag(action_std)
policy_multivar = multivariate_normal(action_mean,
action_cov,
allow_singular=True)
#policy_multivar = multivariate_normal(action_mean, self.multivariate_cov, allow_singular=True)
logp_pi = policy_multivar.logpdf(act)
logp_pi = logp_pi.reshape(self.args.batch_size, )
p_pi = policy_multivar.pdf(act)
p_pi = p_pi.reshape(self.args.batch_size, )
phi_entropy = -1 * np.sum(logp_phi) # * p_phi)
pi_entropy = -1 * np.sum(logp_pi) # * p_pi)
mir_penalty = self.mic * (phi_entropy - pi_entropy)
except:
mir_penalty = 0
num_sample = 1
target_q = 0.0
for i in range(num_sample):
target_act_next_n = [
agents[i].p_debug['target_act'](obs_next_n[i])
for i in range(self.n)
]
target_q_next = self.q_debug['target_q_values'](
*(obs_next_n + target_act_next_n))
target_q += (rew - mir_penalty
) + self.args.gamma * (1.0 - done) * target_q_next
target_q /= num_sample
q_loss = self.q_train(*(obs_n + act_n + [target_q]))
# train p network
p_loss = self.p_train(*(obs_n + act_n))
self.p_update()
self.q_update()
return [
q_loss, p_loss,
np.mean(target_q),
np.mean(rew),
np.mean(target_q_next),
np.std(target_q)
]
def GetData(img_size, max_path_width, show=False):
num_per_edge = random.randint(1, 2)
w, h = img_size
ww, hh = int(w / 8.0), int(h / 8.0)
pad_w = math.ceil(1.0 / num_per_edge * w / 4)
pad_h = math.ceil(1.0 / num_per_edge * h / 4)
l = [(0,
random.randint(
int(1.0 / num_per_edge * h * i) + pad_h,
int(1.0 / num_per_edge * h * (i + 1)) - pad_h))
for i in range(num_per_edge)]
u = [(random.randint(
int(1.0 / num_per_edge * w * i) + pad_w,
int(1.0 / num_per_edge * w * (i + 1)) - pad_w), 0)
for i in range(num_per_edge)]
r = [(w,
random.randint(
int(1.0 / num_per_edge * h * i) + pad_h,
int(1.0 / num_per_edge * h * (i + 1)) - pad_h))
for i in range(num_per_edge)]
d = [(random.randint(
int(1.0 / num_per_edge * w * i) + pad_w,
int(1.0 / num_per_edge * w * (i + 1)) - pad_w), h)
for i in range(num_per_edge)]
p = l + u + r + d
while True:
random.shuffle(p)
segs = []
for x, y in zip(p[:num_per_edge * 2], p[num_per_edge * 2:]):
if x[0] == 0 and y[0] == 0 or x[0] == w and y[0] == w or x[
1] == 0 and y[1] == 0 or x[1] == h and y[1] == h:
continue
segs.append([x, y])
if segs:
break
img = Image.new('RGB', img_size, color=(255, 255, 255))
road_color = (random.randint(0, 255), random.randint(0, 255),
random.randint(0, 255))
draw = ImageDraw.Draw(img)
dirfld = np.zeros((h, w, 2), np.float32)
pts = []
for seg in segs:
seg_w = random.randint(int(max_path_width * 0.6), max_path_width)
seg1, seg2 = direction(seg, seg_w)
dirfld += dir_field(seg1, w, h, seg_w)
dirfld += dir_field(seg2, w, h, seg_w)
draw.line(extend_seg(seg), fill=road_color, width=seg_w)
# draw.ellipse(make_ellipse(seg[0]), fill = (128, 128, 128), outline = (0, 0, 0))
# draw.ellipse(make_ellipse(seg[1]), fill = (128, 128, 128), outline = (0, 0, 0))
pts.append(seg[0])
pts.append(seg[1])
for i in range(len(segs)):
for j in range(i, len(segs)):
inter = get_crossing(segs[i], segs[j])
if inter:
pts.append(inter)
# draw.ellipse(make_ellipse(inter), fill = (128, 128, 128), outline = (0, 0, 0))
img = pepper(np.array(img))
if show:
plt.figure()
plt.imshow(img)
plt.show()
Y, X = np.mgrid[0:ww, 0:hh]
U = cv2.resize(dirfld[..., 0],
dsize=(ww, hh),
interpolation=cv2.INTER_LINEAR)
V = cv2.resize(dirfld[..., 1],
dsize=(ww, hh),
interpolation=cv2.INTER_LINEAR)
N = np.sqrt(U**2 + V**2)
N[N < 1e-6] = np.inf
U, V = U / N, V / N
if show:
plt.figure()
Q = plt.quiver(X, 32 - Y, U, -V)
plt.axis('equal')
plt.show()
pos = np.empty((hh, ww, 2))
pos[..., 1], pos[..., 0] = np.mgrid[0:ww, 0:hh]
heatmap = np.zeros((hh, ww))
for pt in pts:
rv = multivariate_normal(
np.array(pt) / 8 - np.array([0.5, 0.5]), [[1, 0], [0, 1]])
heatmap = np.maximum(heatmap, rv.pdf(pos))
heatmap = (heatmap - heatmap.min()) / (heatmap.max() - heatmap.min())
if show:
plt.figure()
plt.imshow(heatmap)
plt.axis('equal')
plt.show()
gt = np.zeros((hh, ww, 3))
gt[..., 0], gt[..., 1], gt[..., 2] = heatmap, U, V
mask = U**2 + V**2
mask[mask < 0.5] = 0
mask[mask >= 0.5] = 1
if show:
plt.figure()
plt.imshow(mask)
plt.axis('equal')
plt.show()
return img, gt, mask
def class_multivariate_normal(mu, cov_matrix):
N = multivariate_normal(mu, cov_matrix)
return N
def calculate_gmm(
header, face_dict
): #return a set of GMM models corresponding to a range of number of clusters
#also return BIC score as an estimator of the best number of clusters
plt.figure(figsize=(5, 5))
features = [' AU06_r', ' AU12_r']
outfile = 'clusters.csv'
#df = pd.read_csv('example/interrogator.csv')
df = pd.read_csv('example/all_frames.csv')
X = df.loc[:, features].dropna().values
#gmm_list = []
lowest_bic = np.infty
bic = []
n_components_range = range(1, 11) #initially 1-12
#n_components_range = range(5, 6)
cv_types = ['spherical', 'tied', 'diag', 'full']
cv_types = ['full']
for cv_type in cv_types:
for n_components in n_components_range:
# Fit a Gaussian mixture with EM
gmm = mixture.GaussianMixture(
n_components=n_components,
covariance_type=cv_type,
tol=1e-8,
#tol=1e-6,
max_iter=1000,
#max_iter=100,
n_init=3,
reg_covar=2e-3)
gmm.fit(X)
#gmm_list.append(gmm)
print('n_components:', n_components, ', n-iter:', gmm.n_iter_)
bic.append(gmm.bic(X))
plot_gmm(gmm, X, features, 'clusterContour', bic[-1], False)
if bic[-1] < lowest_bic:
lowest_bic = bic[-1]
best_gmm = gmm
#analyze_face_result(header, face_dict, gmm)
analyze_face_soft_result(header, face_dict, gmm)
print(gmm.means_)
sigmas = np.empty(gmm.covariances_.shape[0], dtype=object)
for i in range(sigmas.shape[0]):
sigmas[i] = gmm.covariances_[i]
local_cluster_data = np.concatenate(
(gmm.means_, sigmas[:, np.newaxis]), axis=1)
df_clusters = pd.DataFrame(data=local_cluster_data,
columns=features + ['sigmas'])
currentCluster = 'cluster_' + str(n_components) + '.csv'
df_clusters.to_csv(currentCluster, index=False)
bic = np.array(bic)
color_iter = itertools.cycle(
['navy', 'turquoise', 'cornflowerblue', 'darkorange'])
clf = best_gmm
bars = []
# Plot the BIC scores
#spl = plt.subplot(2, 1, 1)
for i, (cv_type, color) in enumerate(zip(cv_types, color_iter)):
xpos = np.array(n_components_range) + .2 * (i - 2)
bars.append(
plt.bar(xpos,
bic[i * len(n_components_range):(i + 1) *
len(n_components_range)],
width=.2,
color=color))
plt.xticks(n_components_range)
plt.ylim([bic.min() * 1.01 - .01 * bic.max(), bic.max()])
plt.title('BIC score per model')
xpos = np.mod(bic.argmin(), len(n_components_range)) + .65 +\
.2 * np.floor(bic.argmin() / len(n_components_range))
plt.text(xpos, bic.min() * 0.97 + .03 * bic.max(), '*', fontsize=14)
#spl.set_xlabel('Number of components')
#spl.legend([b[0] for b in bars], cv_types)
plt.xlabel('Number of components')
plt.legend([b[0] for b in bars], cv_types)
plt.savefig('BIC scores')
# Plot the winner
plt.figure(figsize=(8, 8))
splot = plt.subplot(1, 1, 1)
Y_ = clf.predict(X)
for i, (mean, cov,
color) in enumerate(zip(clf.means_, clf.covariances_, color_iter)):
#cov = cov * np.eye(2)
v, w = linalg.eigh(cov)
if not np.any(Y_ == i):
continue
plt.scatter(X[Y_ == i, 0], X[Y_ == i, 1], .8, color=color, alpha=.5)
'''
# Plot an ellipse to show the Gaussian component
angle = np.arctan2(w[0][1], w[0][0])
angle = 180. * angle / np.pi # convert to degrees
v = 2. * np.sqrt(2.) * np.sqrt(v)
ell = mpl.patches.Ellipse(mean, v[0], v[1], 180. + angle, color=color)
ell.set_clip_box(splot.bbox)
ell.set_alpha(.75)
splot.add_artist(ell)
'''
x_vals = np.linspace(X[:, 0].min(), X[:, 0].max(), 50)
y_vals = np.linspace(X[:, 1].min(), X[:, 1].max(), 50)
x, y = np.meshgrid(x_vals, y_vals)
pos = np.empty(x.shape + (2, ))
pos[:, :, 0] = x
pos[:, :, 1] = y
rv = multivariate_normal(mean, cov)
try: # not sure why, was running into ValueErrors
plt.contour(x, y, rv.pdf(pos))
except ValueError:
pass
print(clf.means_)
sigmas = np.empty(clf.covariances_.shape[0], dtype=object)
for i in range(sigmas.shape[0]):
sigmas[i] = clf.covariances_[i]
cluster_data = np.concatenate((clf.means_, sigmas[:, np.newaxis]), axis=1)
df_clusters = pd.DataFrame(data=cluster_data,
columns=features + ['sigmas'])
df_clusters.to_csv(outfile, index=False)
#plt.xticks(())
#plt.yticks(())
plt.title('best GMM')
plt.xlabel(features[0])
plt.ylabel(features[1])
#plt.subplots_adjust(hspace=.35, bottom=.02)
plt.savefig('clusterContours.png')
def multivariateGaussian(dataset, mu, sigma):
p = multivariate_normal(mean=mu, cov=sigma)
return p.pdf(dataset)
def generate_gaussian_response(shape, cov):
mvn = multivariate_normal(mean=np.zeros(2), cov=cov)
grid = build_grid(shape)
return mvn.pdf(grid)[None]
def d_init_prop(self, x,y):
return stats.multivariate_normal(self.filter_mu, self.filter_sigma).pdf(x)
def sim_func(child_emb,
parent_emb,
method='cosine',
sigma=1.0,
kde_c=None,
kde_p=None,
kde_c_prob=None,
kde_p_prob=None):
if method == 'cosine':
return np.mean(cosine_similarity(child_emb, parent_emb))
if method == 'euc':
return -np.mean(euclidean_distances(child_emb, parent_emb))
if method == 'expeuc':
dist = np.expand_dims(child_emb, 1) - np.expand_dims(parent_emb, 0)
dist = np.sum(dist * dist, -1)
dist_min = np.min(dist, -1)
sim = np.exp(-dist + np.expand_dims(dist_min, -1))
sim = np.mean(np.log(np.mean(sim, -1)) - dist_min)
return sim
if method == 'mixgau':
emb_dim = child_emb.shape[1]
num_occ_child = child_emb.shape[0]
num_occ_parent = parent_emb.shape[0]
rv = multivariate_normal(np.zeros(emb_dim),
np.diag(np.ones(emb_dim)) * sigma)
dist = np.expand_dims(child_emb, 1) - np.expand_dims(parent_emb, 0)
sim = rv.pdf(dist)
sim = np.sum(np.log(np.sum(sim / num_occ_parent, axis=-1)))
return sim
if method == 'mixgau_fast':
emb_dim = child_emb.shape[1]
num_occ_child = child_emb.shape[0]
num_occ_parent = parent_emb.shape[0]
var = np.array([sigma] * emb_dim)
# SHAPE: (num_occ_child, num_occ_parent, emb_dim)
dist = np.expand_dims(child_emb, 1) - np.expand_dims(parent_emb, 0)
dist = np.reshape(dist, (-1, emb_dim))
denominator = -0.5 * (emb_dim *
(np.log(2 * np.pi)) + np.sum(np.log(var)))
numerator = -0.5 * np.sum(dist**2 / np.expand_dims(var, 0), -1)
log_prob = np.reshape(denominator + numerator,
(num_occ_child, num_occ_parent))
log_prob_max = np.max(log_prob, -1, keepdims=True)
sim = np.sum(
np.log(
np.sum(np.exp(log_prob - log_prob_max) / num_occ_parent,
axis=-1)) + log_prob_max)
return sim
if method == 'avg':
child_emb = np.mean(child_emb, 0)
parent_emb = np.mean(parent_emb, 0)
return np.mean(cosine_similarity([child_emb], [parent_emb]))
if method == 'avg_euc':
child_emb = np.mean(child_emb, 0)
parent_emb = np.mean(parent_emb, 0)
return -np.mean(euclidean_distances([child_emb], [parent_emb]))
if method == 'avg_dot':
child_emb = np.mean(child_emb, 0)
parent_emb = np.mean(parent_emb, 0)
sim = (child_emb * parent_emb).sum()
return sim
if method == 'kde':
if kde_c is None:
kde_c = KernelDensity(kernel='gaussian',
bandwidth=sigma).fit(child_emb)
if kde_p is None:
kde_p = KernelDensity(kernel='gaussian',
bandwidth=sigma).fit(parent_emb)
if kde_c_prob is None:
kde_c_prob = kde_c.score_samples(child_emb)
parent_prob = kde_p.score_samples(child_emb)
kl = np.sum(np.exp(kde_c_prob) * (kde_c_prob - parent_prob))
return -kl
raise NotImplementedError
