def set_inv_cov(self): """ Set the inverse correlation matrix. The correlation matrix is a sum of a constant and a noise matrix. The noise matrix is built from dot products of random unit vectors u_1,...,u_N each in R^M, entries ~ Uniform, s.t. |u| = 1. The noise matrix is dot(u, u)*epsilon for non-diag entries; 0 on the diag. The constant matrix has rho in the off-diag elements and 1 on the diag. """ self.cov = sp.ones((self.nD, self.nD))*self.rho sp.fill_diagonal(self.cov, 1) sp.random.seed(self.seed) u_vecs = sp.random.uniform(-1, 1, size=(self.nD, self.noiseD)) u_norms = sp.sqrt(sp.sum(u_vecs**2.0, axis=1)) u_vecs = (u_vecs.T/u_norms).T noise_matrix = sp.dot(u_vecs, u_vecs.T)*self.epsilon sp.fill_diagonal(noise_matrix, 0) self.cov += noise_matrix self.inv_cov = LA.inv(self.cov) self._diag = sp.diag(self.inv_cov)
def print_verbose_message(self):
"""Method to print training statistics if Verbose is TRUE"""
# Memory usage (does not work in Windows)
# print('Peak memory usage: %.2f MB' % (resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / infer_platform() ))
# Variance explained
r2 = s.asarray(self.calculate_variance_explained(total=True)).mean(axis=0)
r2[r2<0] = 0.
print("- Variance explained: " + " ".join([ "View %s: %.2f%%" % (m,100*r2[m]) for m in range(self.dim["M"])]))
# Sparsity levels of the weights
W = self.nodes["W"].getExpectation()
foo = [s.mean(s.absolute(W[m])<1e-3) for m in range(self.dim["M"])]
print("- Fraction of zero weights: " + " ".join([ "View %s: %.0f%%" % (m,100*foo[m]) for m in range(self.dim["M"])]))
# Correlation between factors
Z = self.nodes["Z"].getExpectation()
Z += s.random.normal(s.zeros(Z.shape),1e-10)
r = s.absolute(corr(Z.T,Z.T)); s.fill_diagonal(r,0)
print("- Maximum correlation between factors: %.2f" % (s.nanmax(r)))
# Factor norm
bar = s.mean(s.square(Z),axis=0)
print("- Factor norms: " + " ".join([ "%.2f" % bar[k] for k in range(Z.shape[1])]))
# Tau
tau = self.nodes["Tau"].getExpectation()
print("- Tau per view (average): " + " ".join([ "View %s: %.2f" % (m,tau[m].mean()) for m in range(self.dim["M"])]))
print("\n")
def setup_A(self):
"""Initializes the state to full rank with norm 1.
"""
for n in xrange(1, self.N + 1):
self.A[n].fill(0)
f = sp.sqrt(1. / self.q[n])
if self.D[n-1] == self.D[n]:
for s in xrange(self.q[n]):
sp.fill_diagonal(self.A[n][s], f)
else:
x = 0
y = 0
s = 0
if self.D[n] > self.D[n - 1]:
f = 1.
for i in xrange(max((self.D[n], self.D[n - 1]))):
self.A[n][s, x, y] = f
x += 1
y += 1
if x >= self.A[n][s].shape[0]:
x = 0
s += 1
elif y >= self.A[n][s].shape[1]:
y = 0
s += 1
def coulomb_mat_eigvals(atoms, at_idx, r_cut, do_calc_connect=True, n_eigs=20):
if do_calc_connect:
atoms.set_cutoff(8.0)
atoms.calc_connect()
pos = sp.vstack((sp.asarray([sp.asarray(a.diff) for a in atoms.neighbours[at_idx]]), sp.zeros(3)))
Z = sp.hstack((sp.asarray([atoms.z[a.j] for a in atoms.neighbours[at_idx]]), atoms.z[at_idx]))
M = sp.outer(Z, Z) / (sp.spatial.distance_matrix(pos, pos) + np.eye(pos.shape[0]))
sp.fill_diagonal(M, 0.5 * Z ** 2.4)
# data = [[atoms.z[a.j], sp.asarray(a.diff)] for a in atoms.neighbours[at_idx]]
# data.append([atoms.z[at_idx], sp.array([0,0,0])]) # central atom
# M = sp.zeros((len(data), len(data)))
# for i, atom1 in enumerate(data):
# M[i,i] = 0.5 * atom1[0] ** 2.4
# for j, atom2 in enumerate(data[i+1:]):
# j += i+1
# M[i,j] = atom1[0] * atom2[0] / LA.norm(atom1[1] - atom2[1])
# M = 0.5 * (M + M.T)
eigs = (LA.eigh(M, eigvals_only=True))[::-1]
if n_eigs == None:
return eigs # all
elif eigs.size >= n_eigs:
return eigs[:n_eigs] # only first few eigenvectors
else:
return sp.hstack((eigs, sp.zeros(n_eigs - eigs.size))) # zero-padded extra fields
def initialize_state(self):
"""Initializes the state to a hard-coded full rank state with norm 1.
"""
for n in xrange(1, self.N + 1):
self.A[n].fill(0)
f = sp.sqrt(1. / self.q[n])
if self.D[n - 1] == self.D[n]:
for s in xrange(self.q[n]):
sp.fill_diagonal(self.A[n][s], f)
else:
x = 0
y = 0
s = 0
if self.D[n] > self.D[n - 1]:
f = 1.
for i in xrange(max((self.D[n], self.D[n - 1]))):
self.A[n][s, x, y] = f
x += 1
y += 1
if x >= self.A[n][s].shape[0]:
x = 0
s += 1
elif y >= self.A[n][s].shape[1]:
y = 0
s += 1
def _normalize_wls(solution, corr_mtx, n_factors):
"""
Weighted least squares normalization for loadings
estimated using MINRES.
Parameters
----------
solution : np.array
The solution from the L-BFGS-B optimization.
corr_mtx : np.array
The correlation matrix.
n_factors : int
The number of factors to select.
Returns
-------
loadings : pd.DataFrame
The factor loading matrix
"""
sp.fill_diagonal(corr_mtx, 1 - solution)
# get the eigenvalues and vectors for n_factors
values, vectors = sp.linalg.eigh(corr_mtx)
# sort the values and vectors in ascending order
values = values[::-1][:n_factors]
vectors = vectors[:, ::-1][:, :n_factors]
# calculate loadings
# if values are smaller than 0, set them to zero
loadings = sp.dot(vectors, sp.diag(sp.sqrt(np.maximum(values, 0))))
return loadings
def Gaussian(R, kernel_para, p): ## computes matrix K
def f(x):
return sp.exp(-(x ** p) / (2 * kernel_para ** 2))
res = map(f, R)
ds = squareform(res)
n = ds.shape[0]
I = sp.zeros(shape=(n, n))
sp.fill_diagonal(I, f(0))
return ds + I
def TCA(X_S, X_T, m=40, mu=0.1, kernel_para=1, p=2, random_sample_T=0.01):
X_S = sp.mat(X_S)
X_T = sp.mat(X_T)
n_S = X_S.shape[0]
n_T = X_T.shape[0]
if random_sample_T != 1:
print str(int(n_T * random_sample_T)) + " samples taken from the task domain"
index_sample = sp.random.choice([i for i in range(n_T)], size=int(n_T * random_sample_T))
X_T = X_T[index_sample, :]
n_T = X_T.shape[0]
n = n_S + n_T
if m > (n):
print ("m is larger then n_S+n_T, so it has been changed")
m = n
L = sp.zeros(shape=(n, n))
L_SS = sp.ones(shape=(n_S, n_S)) / (n_S ** 2)
L_TT = sp.ones(shape=(n_T, n_T)) / (n_T ** 2)
L_ST = -sp.ones(shape=(n_S, n_T)) / (n_S * n_T)
L_TS = -sp.ones(shape=(n_T, n_S)) / (n_S * n_T)
L[0:n_S, 0:n_S] = L_SS
L[n_S : n_S + n_T, n_S : n_S + n_T] = L_TT
L[n_S : n_S + n_T, 0:n_S] = L_TS
L[0:n_S, n_S : n_S + n_T] = L_ST
R = pdist(sp.vstack([X_S, X_T]), metric="euclidean", p=p, w=None, V=None, VI=None)
K = Gaussian(R, kernel_para, p)
Id = sp.zeros(shape=(n, n))
H = sp.zeros(shape=(n, n))
sp.fill_diagonal(Id, 1)
sp.fill_diagonal(H, 1)
H -= 1.0 / n
Id = sp.mat(Id)
H = sp.mat(H)
K = sp.mat(K)
L = sp.mat(L)
matrix = sp.linalg.inv(K * L * K + mu * Id) * sp.mat(K * H * K)
eigen_values = sp.linalg.eig(matrix)
eigen_val = eigen_values[0][0:m]
eigen_vect = eigen_values[1][:, 0:m]
return (eigen_val, eigen_vect, K, sp.vstack([X_S, X_T]))
def Laplace(R, p, sigma):
def f(x):
return sp.exp(-(x ** p) / (2 * sigma ** 2))
res = map(f, R)
ds = squareform(res)
n = ds.shape[0]
I = sp.zeros(shape=(n, n))
sp.fill_diagonal(I, f(0))
M = ds + I
d = sp.sum(M, axis=0)
D = sp.diag(d)
return D - M
def H_effective(N, Omega, Sigma): #N should be k dimension of Krylov space
Eta = (N - 2) * 0.5 * Omega
beta = []
for i in range(N - 1):
beta.append(sp.sqrt(i + 1) * Sigma)
diag = [beta, beta]
M = sp.sparse.diags(diag, [-1, 1]).toarray()
sp.fill_diagonal(M, -Eta)
M[1, 0] = 0
M[0, 1] = 0
M[0, 0] = -1 * Eta - Omega
return M
def _init_arrays(self):
self.A = sp.empty((self.N + 1), dtype=sp.ndarray) #Elements 1..N
self.r = sp.empty((self.N + 1), dtype=sp.ndarray) #Elements 0..N
self.l = sp.empty((self.N + 1), dtype=sp.ndarray)
self.r[0] = sp.zeros((self.D[0], self.D[0]), dtype=self.typ, order=self.odr)
self.l[0] = m.eyemat(self.D[0], dtype=self.typ)
for n in xrange(1, self.N + 1):
self.r[n] = sp.zeros((self.D[n], self.D[n]), dtype=self.typ, order=self.odr)
self.l[n] = sp.zeros((self.D[n], self.D[n]), dtype=self.typ, order=self.odr)
self.A[n] = sp.zeros((self.q[n], self.D[n - 1], self.D[n]), dtype=self.typ, order=self.odr)
sp.fill_diagonal(self.r[self.N], 1.)
def _init_arrays(self):
self.A = sp.empty((self.N + 1), dtype=sp.ndarray) #Elements 1..N
self.r = sp.empty((self.N + 1), dtype=sp.ndarray) #Elements 0..N
self.l = sp.empty((self.N + 1), dtype=sp.ndarray)
self.r[0] = sp.zeros((self.D[0], self.D[0]), dtype=self.typ, order=self.odr)
self.l[0] = m.eyemat(self.D[0], dtype=self.typ)
for n in range(1, self.N + 1):
self.r[n] = sp.zeros((self.D[n], self.D[n]), dtype=self.typ, order=self.odr)
self.l[n] = sp.zeros((self.D[n], self.D[n]), dtype=self.typ, order=self.odr)
self.A[n] = sp.zeros((self.q[n], self.D[n - 1], self.D[n]), dtype=self.typ, order=self.odr)
sp.fill_diagonal(self.r[self.N], 1.)
def H_effective(k, Omega, Sigma, N):
Eta = (N - 2) * 0.5 * Omega
beta = []
for i in range(k - 1):
beta.append(sp.sqrt(i + 1) * Sigma)
diag = [beta, beta]
M = sp.sparse.diags(diag, [-1, 1]).toarray()
sp.fill_diagonal(M, -Eta)
M[1, 0] = 0
M[0, 1] = 0
M[0, 0] = -1 * Eta - Omega
return M
def _init_arrays(self):
self.A = sp.empty((self.N + 1), dtype=sp.ndarray) #Elements 1..N
self.r = sp.empty((self.N + 1), dtype=sp.ndarray) #Elements 0..N
self.l = sp.empty((self.N + 1), dtype=sp.ndarray)
self.r[0] = sp.zeros((self.D[0], self.D[0]), dtype=self.typ, order=self.odr)
self.l[0] = sp.eye(self.D[0], self.D[0], dtype=self.typ).copy(order=self.odr) #Already set the 0th element (not a dummy)
for n in xrange(1, self.N + 1):
self.r[n] = sp.zeros((self.D[n], self.D[n]), dtype=self.typ, order=self.odr)
self.l[n] = sp.zeros((self.D[n], self.D[n]), dtype=self.typ, order=self.odr)
self.A[n] = sp.empty((self.q[n], self.D[n - 1], self.D[n]), dtype=self.typ, order=self.odr)
sp.fill_diagonal(self.r[self.N], 1.)
def print_verbose_message(self, i):
"""Method to print training statistics if Verbose is TRUE"""
# Memory usage (does not work in Windows)
# print('Peak memory usage: %.2f MB' % (resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / infer_platform() ))
# Variance explained
r2 = s.asarray(
self.calculate_variance_explained(total=True)).mean(axis=0)
r2[r2 < 0] = 0.
print("- Variance explained: " + " ".join([
"View %s: %.2f%%" % (m, 100 * r2[m]) for m in range(self.dim["M"])
]))
# Sparsity levels of the weights
W = self.nodes["W"].getExpectation()
foo = [s.mean(s.absolute(W[m]) < 1e-3) for m in range(self.dim["M"])]
print("- Fraction of zero weights: " + " ".join([
"View %s: %.0f%%" % (m, 100 * foo[m]) for m in range(self.dim["M"])
]))
# Correlation between factors
Z = self.nodes["Z"].getExpectation()
Z += s.random.normal(s.zeros(Z.shape), 1e-10)
r = s.absolute(corr(Z.T, Z.T))
s.fill_diagonal(r, 0)
print("- Maximum correlation between factors: %.2f" % (s.nanmax(r)))
# Factor norm
bar = s.mean(s.square(Z), axis=0)
print("- Factor norms: " +
" ".join(["%.2f" % bar[k] for k in range(Z.shape[1])]))
# Tau
tau = self.nodes["Tau"].getExpectation()
print("- Tau per view (average): " + " ".join([
"View %s: %.2f" % (m, tau[m].mean()) for m in range(self.dim["M"])
]))
#Sigma:
if 'Sigma' in self.nodes.keys():
sigma = self.nodes["Sigma"]
if i >= sigma.start_opt and i % sigma.opt_freq == 0:
print('Sigma node has been optimised:\n- Lengthscales = %s \n- Scale = %s' % \
(np.array2string(sigma.get_ls(), precision=2, separator=", "), np.array2string(1-sigma.get_zeta(), precision=2, separator=", ")))
print("\n")
def get_covariances(self, hyperparams):
"""
Return the Cholesky decompositions L and alpha::
K
L = chol(K)
alpha = solve(L,t)
return [covar_struct] = get_covariances(hyperparam)
**Parameters:**
hyperparams: dict
The hyperparameters for cholesky decomposition
x, y: [double]
input x and output y for cholesky decomposition.
If one/both is/are set, there will be no chaching allowed
"""
if self._is_cached(hyperparams) and not self._active_set_indices_changed:
pass
else:
Knoise = 0
#1. use likelihood object to perform the inference
if self.likelihood is not None:
Knoise = self.likelihood.K(hyperparams['lik'], self._get_x())
K = self.covar.K(hyperparams['covar'], self._get_x())
K+= Knoise
L = jitChol(K)[0].T # lower triangular
alpha = solve_chol(L, self._get_y(hyperparams)) # TODO: not sure about this one
# DPOTRI computes the inverse of a real symmetric positive definite
# matrix A using the Cholesky factorization
Linv = scipy.lib.lapack.flapack.dpotri(L)[0]
# Copy the matrix and kill the diagonal (we don't want to have 2*var)
Kinv = Linv.copy()
SP.fill_diagonal(Linv, 0)
# build the full inverse covariance matrix. This is correct: verified
# by doing SP.allclose(Kinv, linalg.inv(K))
Kinv += Linv.T
self._covar_cache = {'K': K, 'L':L, 'alpha':alpha, 'Kinv': Kinv}
#store hyperparameters for cachine
self._covar_cache['hyperparams'] = copy.deepcopy(hyperparams)
self._active_set_indices_changed = False
return self._covar_cache
def _construct_eqns_rls(self, data):
"""Construct VAR equation system with RLS constraint.
"""
(l, m, t) = sp.shape(data)
n = (l - self.p) * t # number of linear relations
# Construct matrix x (predictor variables)
x = sp.zeros((n + m * self.p, m * self.p))
for i in range(m):
for k in range(1, self.p + 1):
x[:n, i * self.p + k - 1] = sp.reshape(data[self.p - k:-k, i, :], n)
sp.fill_diagonal(x[n:, :], self.delta)
# Construct vectors yi (response variables for each channel i)
y = sp.zeros((n + m * self.p, m))
for i in range(m):
y[:n, i] = sp.reshape(data[self.p:, i, :], n)
return x, y
def _construct_var_eqns_rls(data, p, delta):
"""Construct VAR equation system with RLS constraint.
"""
(l, m, t) = sp.shape(data)
n = (l - p) * t # number of linear relations
# Construct matrix x (predictor variables)
x = sp.zeros((n + m * p, m * p))
for i in range(m):
for k in range(1, p + 1):
x[:n, i * p + k - 1] = sp.reshape(data[p - k:-k, i, :], n)
sp.fill_diagonal(x[n:, :], delta)
# Construct vectors yi (response variables for each channel i)
y = sp.zeros((n + m * p, m))
for i in range(m):
y[:n, i] = sp.reshape(data[p:, i, :], n)
return x, y
def find_angles(markers: Sequence[Marker],
weight_x: float = 1.0,
weight_y: float = 1.0) -> Generator[float, None, None]:
"""Computes the angles of the given markers and returns them."""
# Compute distance matrix.
positions = scipy.array(list(
(m.position.x, m.position.y) for m in markers))
weights = scipy.array([weight_x, weight_y])
distance_matrix = scipy.spatial.distance.pdist(positions / weights)
distance_matrix = scipy.spatial.distance.squareform(distance_matrix)
assert distance_matrix.shape[0] == distance_matrix.shape[1]
num_markers = distance_matrix.shape[0]
# Find nearest neighbors.
scipy.fill_diagonal(distance_matrix, scipy.inf)
nearest_neighbors = scipy.argmin(distance_matrix, axis=1)
# Use direction to nearest neighbor as angle.
for i in range(num_markers):
n = nearest_neighbors[i]
v = positions[n] - positions[i]
yield scipy.math.atan2(v[1], v[0])
def nLLeval(ldelta,X,Y,K):
"""evaluate the negative LL of a LMM with kernel USU.T"""
delta=SP.exp(ldelta)
H = K + delta*SP.eye(X.shape[0])
#the slow way: compute all terms needed
L = jitChol(H)[0].T # lower triangular
Linv = scipy.lib.lapack.flapack.dpotri(L)[0]
Kinv = Linv.copy()
SP.fill_diagonal(Linv, 0)
Kinv += Linv.T
n = X.shape[0]
#1. get max likelihood weight beta
pinv = SP.dot(SP.linalg.inv(SP.dot(SP.dot(X.T,Kinv),X)),X.T)
y_ = SP.dot(Kinv,Y)
beta = SP.dot(pinv,y_)
#2. get max likelihood sigma
yres = (Y-SP.dot(X,beta))
R = SP.dot(SP.dot(yres.T,Kinv),yres)
sigma2 = R/n
nLL = 0.5*(-n*SP.log(2*SP.pi*sigma2) - 2*SP.log(L.diagonal()).sum() - 1./sigma2*R)
return (-nLL);
def _LML_Xm(self, hyperparams):
if 'Xm' not in hyperparams.keys():
return {}
Q, determinant = self._compute_sparsified_covariance(hyperparams)
# get correction term:
correction_term = (1./(2.*scipy.power(self.jitter,2))) * scipy.sum(self.covar.Kdiag(hyperparams['covar'], self._get_x()) - scipy.diag(Q, 0))
# add jitter
n = self._get_x().shape[0]
jit_mat = scipy.zeros((n,n))
scipy.fill_diagonal(jit_mat, self.jitter)
Q += jit_mat
y = self._get_y()
import pdb;pdb.set_trace()
rv = -.5*y.shape[0]*scipy.log(2*scipy.pi)
rv -= determinant
rv -= .5*scipy.dot(y.T, linalg.solve(Q, y))
return rv - correction_term
def nLLeval(ldelta, X, Y, K):
"""evaluate the negative LL of a LMM with kernel USU.T"""
delta = SP.exp(ldelta)
H = K + delta * SP.eye(X.shape[0])
#the slow way: compute all terms needed
L = jitChol(H)[0].T # lower triangular
Linv = scipy.lib.lapack.flapack.dpotri(L)[0]
Kinv = Linv.copy()
SP.fill_diagonal(Linv, 0)
Kinv += Linv.T
n = X.shape[0]
#1. get max likelihood weight beta
pinv = SP.dot(SP.linalg.inv(SP.dot(SP.dot(X.T, Kinv), X)), X.T)
y_ = SP.dot(Kinv, Y)
beta = SP.dot(pinv, y_)
#2. get max likelihood sigma
yres = (Y - SP.dot(X, beta))
R = SP.dot(SP.dot(yres.T, Kinv), yres)
sigma2 = R / n
nLL = 0.5 * (-n * SP.log(2 * SP.pi * sigma2) -
2 * SP.log(L.diagonal()).sum() - 1. / sigma2 * R)
return (-nLL)
def _init_arrays(self):
self.A = sp.empty((self.N + 1), dtype=sp.ndarray) #Elements 1..N
self.r = sp.empty((self.N + 1), dtype=sp.ndarray) #Elements 0..N
self.l = sp.empty((self.N + 1), dtype=sp.ndarray)
self.r[0] = sp.zeros((self.D[0], self.D[0]),
dtype=self.typ,
order=self.odr)
self.l[0] = sp.eye(self.D[0], self.D[0], dtype=self.typ).copy(
order=self.odr) #Already set the 0th element (not a dummy)
for n in xrange(1, self.N + 1):
self.r[n] = sp.zeros((self.D[n], self.D[n]),
dtype=self.typ,
order=self.odr)
self.l[n] = sp.zeros((self.D[n], self.D[n]),
dtype=self.typ,
order=self.odr)
self.A[n] = sp.empty((self.q[n], self.D[n - 1], self.D[n]),
dtype=self.typ,
order=self.odr)
sp.fill_diagonal(self.r[self.N], 1.)
def __init__(self, numsites, D, q):
"""Creates a new TDVP_MPS object.
The TDVP_MPS class implements the time-dependent variational principle
for matrix product states for systems with open boundary conditions and
a hamiltonian consisting of a nearest-neighbour interaction term and a
single-site term (external field).
Bond dimensions will be adjusted where they are too high to be useful.
FIXME: Add reference.
Parameters
----------
numsites : int
The number of lattice sites.
D : ndarray
A 1-d array, length numsites, of integers indicating the desired bond dimensions.
q : ndarray
A 1-d array, also length numsites, of integers indicating the
dimension of the hilbert space for each site.
Returns
-------
sqrt_A : ndarray
An array of the same shape and type as A containing the matrix square root of A.
"""
self.eps = sp.finfo(self.typ).eps
self.N = numsites
self.D = sp.array(D)
self.q = sp.array(q)
#Make indicies correspond to the thesis
self.K = sp.empty((self.N + 1), dtype=sp.ndarray) #Elements 1..N
self.C = sp.empty((self.N), dtype=sp.ndarray) #Elements 1..N-1
self.A = sp.empty((self.N + 1), dtype=sp.ndarray) #Elements 1..N
self.r = sp.empty((self.N + 1), dtype=sp.ndarray) #Elements 0..N
self.l = sp.empty((self.N + 1), dtype=sp.ndarray)
if (self.D.ndim != 1) or (self.q.ndim != 1):
raise NameError('D and q must be 1-dimensional!')
#TODO: Check for integer type.
#Don't do anything pointless
self.D[0] = 1
self.D[self.N] = 1
qacc = 1
for n in reversed(xrange(self.N)):
if qacc < self.D.max(): #Avoid overflow!
qacc *= self.q[n + 1]
if self.D[n] > qacc:
self.D[n] = qacc
qacc = 1
for n in xrange(1, self.N + 1):
if qacc < self.D.max(): #Avoid overflow!
qacc *= q[n - 1]
if self.D[n] > qacc:
self.D[n] = qacc
self.r[0] = sp.zeros((self.D[0], self.D[0]), dtype=self.typ, order=self.odr)
self.l[0] = sp.eye(self.D[0], self.D[0], dtype=self.typ).copy(order=self.odr) #Already set the 0th element (not a dummy)
for n in xrange(1, self.N + 1):
self.K[n] = sp.zeros((self.D[n-1], self.D[n-1]), dtype=self.typ, order=self.odr)
self.r[n] = sp.zeros((self.D[n], self.D[n]), dtype=self.typ, order=self.odr)
self.l[n] = sp.zeros((self.D[n], self.D[n]), dtype=self.typ, order=self.odr)
self.A[n] = sp.empty((self.q[n], self.D[n-1], self.D[n]), dtype=self.typ, order=self.odr)
if n < self.N:
self.C[n] = sp.empty((self.q[n], self.q[n+1], self.D[n-1], self.D[n+1]), dtype=self.typ, order=self.odr)
sp.fill_diagonal(self.r[self.N], 1.)
self.setup_A()
self.eta = sp.zeros((self.N + 1), dtype=self.typ)
scale = 9
sd = 1.323
#petsc4py.init(sys.argv)
#diag = PETSc.Vec().create(PETSc.COMM_WORLD)
diag = PETSc.Vec().create()
diag.setSizes(n)
diag.setType('mpi')
diag.set(scale * sd)
hvals = scipy.ones(n**2) * scale
H = PETSc.Mat().createDense([n, n])
H.setValues(range(n), range(n), hvals)
H.setDiagonal(diag)
H.assemblyBegin()
H.assemblyEnd()
# Do matrix exponential with PETSc
R = expm(H, k)
print("PETSc expm")
print(R.getValues(range(n), range(n)))
# Test against SciPy solver
#T = scipy.identity(n)*scale
T = scipy.ones((n, n)) * scale
scipy.fill_diagonal(T, scale * sd)
print("SciPy expm")
print(scipy.linalg.expm(T))
def parameters(cmdargs):
"""
cmdargs:
-q, qubits
-k, lrule
-f, nmems
"""
# The Hopfield parameters
hparams = {
'numNeurons': cmdargs['qubits'],
'inputState': [ 2*sp.random.random_integers(0,1)-1
for k in xrange(cmdargs['qubits']) ],
'learningRule': cmdargs['simtype'],
'numMemories': int(cmdargs['farg'])
}
# Construct memories
memories = [ [ 2*sp.random.random_integers(0,1)-1
for k in xrange(hparams['numNeurons']) ]
for j in xrange(hparams['numMemories']) ]
# At least one pattern must be one Hamming unit away from the input
memories[0] = list(hparams['inputState'])
memories[0][sp.random.random_integers(0,hparams['numNeurons']-1)] *= -1
# Make sure all other patterns are not the input state
def hamdist(a,b):
""" Calculate Hamming distance. """
return sp.sum(abs(sp.array(a)-sp.array(b))/2.0)
# Loop over additional memories, if there are any
for imem, mem in enumerate(memories[1:]):
while hamdist(mem, hparams['inputState']) < 1.0:
# Flip a random spin
rndbit = sp.random.random_integers(0,hparams['numNeurons']-1)
memories[imem+1][rndbit] *= -1
# Basic simulation params
nQubits = hparams['numNeurons']
T = 1000.0 # sp.arange(0.1, 15, 0.5)
# T = sp.array([10.0, 20.0, 50.0, 100.0, 500.0,
# 1000.0, 5000.0, 10000.0, 50000.0])
dt = 0.005*T
# Define states for which to track probabilities in time
# import statelabels
# label_list = statelabels.GenerateLabels(nQubits)
# stateoverlap = []
# for mem in memories:
# # Convert spins to bits
# bitstr = ''.join([ '0' if k == 1 else '1' for k in mem ])
# # Get the index of the current (converted) memory and add it to list
# stateoverlap.append([ label_list.index(bitstr), bitstr ])
stateoverlap = None
# Output parameters
binary = 1 # Save output files as binary Numpy format
progressout = 0 # Output simulation progress over anneal timesteps
eigspecdat = 1 # Output data for eigspec
eigspecplot = 0 # Plot eigspec
eigspecnum = 2**nQubits # Number of eigenvalues to output
fidelplot = 0 # Plot fidelity
fideldat = 0 # Output fidelity data
fidelnumstates = 2**nQubits # Check fidelity with this number of eigenstates
overlapdat = 0 # Output overlap data
overlapplot = 0 # Plot overlap
solveMethod = 'ExpPert' # 'ExpPert', 'SuzTrot', 'ForRuth', 'BCM'
# Output directory stuff
probdir = 'data/hopfield_exp3_nodiag/n'+str(nQubits)+'p'+\
str(hparams['numMemories'])+hparams['learningRule']
if isinstance(T, collections.Iterable):
probdir += 'MultiT'
if os.path.isdir(probdir):
outlist = sorted([ int(name) for name in os.listdir(probdir)
if name.isdigit() ])
else:
outlist = []
outnum = outlist[-1] + 1 if outlist else 0
outputdir = probdir + '/' + str(outnum) + '/'
probshow = 0 # Print final state probabilities to screen
probout = 1 # Output probabilities to file
mingap = 0 # Record the minimum spectral gap
errchk = 0 # Error-checking on/off (for simulation accuracy)
eps = 0.01 # Numerical error in normalization condition (1 - norm < eps)
# Specify a QUBO (convert to Ising = True), or alpha, beta directly
# (convert = False), and also specify the signs on the Ising Hamiltonian
# terms (you can specify coefficients too for some problems if needed)
isingConvert = 0
isingSigns = {'hx': -1, 'hz': -1, 'hzz': -1}
# Construct network Ising parameters
neurons = nQubits
# This is gamma, the appropriate weighting on the input vector
# isingSigns['hz'] *= 1 - (len(hparams['inputState']) -
# hparams['inputState'].count(0))/(2*neurons)
# isingSigns['hz'] *= 1.0/(5*neurons)
# isingSigns['hz'] *= 0.2
alpha = sp.array(hparams['inputState'])
beta = sp.zeros((neurons,neurons))
delta = sp.array([])
# Construct the memory matrix according to a learning rule
if hparams['learningRule'] == 'hebb':
# Hebb rule
isingSigns['hz'] *= 0.5
memMat = sp.matrix(memories).T
beta = sp.triu(memMat*memMat.T)/float(neurons)
elif hparams['learningRule'] == 'stork':
# Storkey rule
isingSigns['hz'] *= 0.15
Wm = sp.zeros((neurons,neurons))
for m, mem in enumerate(memories):
Am = sp.outer(mem,mem) - sp.eye(neurons)
Wm += (Am - Am*Wm - Wm*Am)/float(neurons)
beta = sp.triu(Wm)
elif hparams['learningRule'] == 'proj':
isingSigns['hz'] *= 0.15
# Moore-Penrose pseudoinverse rule
memMat = sp.matrix(memories).T
beta = sp.triu(memMat * sp.linalg.pinv(memMat))
sp.fill_diagonal(beta, 0.0)
# Some outputs
outputs = {
'nQubits': nQubits,
'learningRule': hparams['learningRule'],
'outdir': probdir,
'inputState': hparams['inputState'],
'memories': memories,
'answer': memories[0],
'annealTime': list(T) if isinstance(T, collections.Iterable) else T
}
############################################################################
######## All variables must be specified here, do NOT change the keys ######
############################################################################
return {
'nQubits': nQubits,
'Q': None,
'T': T,
'dt': dt,
'outputdir': outputdir,
'errchk': errchk,
'eps': eps,
'isingConvert': isingConvert,
'isingSigns': isingSigns,
'outputs': outputs,
'alpha': alpha,
'beta': beta,
'delta': delta,
'eigdat': eigspecdat,
'eigplot': eigspecplot,
'eignum': eigspecnum,
'fiddat': fideldat,
'fidplot': fidelplot,
'fidnumstates': fidelnumstates,
'overlapdat': overlapdat,
'overlapplot': overlapplot,
'outdir': outputdir,
'binary': binary,
'progressout': progressout,
'probshow': probshow,
'probout': probout,
'mingap': mingap,
'stateoverlap': stateoverlap,
'hzscale': None,
'hzzscale': None,
'hxscale': None,
'solveMethod': solveMethod
}
scale = 9
sd = 1.323
#petsc4py.init(sys.argv)
#diag = PETSc.Vec().create(PETSc.COMM_WORLD)
diag = PETSc.Vec().create()
diag.setSizes(n)
diag.setType('mpi')
diag.set(scale*sd)
hvals = scipy.ones(n**2)*scale
H = PETSc.Mat().createDense([n, n])
H.setValues(range(n), range(n), hvals)
H.setDiagonal(diag)
H.assemblyBegin()
H.assemblyEnd()
# Do matrix exponential with PETSc
R = expm(H, k)
print ("PETSc expm")
print(R.getValues(range(n), range(n)))
# Test against SciPy solver
#T = scipy.identity(n)*scale
T = scipy.ones((n,n))*scale
scipy.fill_diagonal(T, scale*sd)
print ("SciPy expm")
print (scipy.linalg.expm(T))
def SSTCA(X_S, y_S, X_T, m=40, mu=0.1, lamb=0.0001, kernel_para=1, p=2, sigma=1, gamma=0.5, random_sample_T=0.01):
X_S = sp.mat(X_S)
X_T = sp.mat(X_T)
y_S = sp.array(y_S)
n_S = X_S.shape[0]
n_T = X_T.shape[0]
if random_sample_T != 1:
print str(int(n_T * random_sample_T)) + " samples taken from the task domain"
index_sample = sp.random.choice([i for i in range(n_T)], size=int(n_T * random_sample_T))
X_T = X_T[index_sample, :]
n_T = X_T.shape[0]
n = n_S + n_T
if m > (n):
print ("m is larger then n_S+n_T, so it has been changed")
m = n
L = sp.zeros(shape=(n, n))
L_SS = sp.ones(shape=(n_S, n_S)) / (n_S ** 2)
L_TT = sp.ones(shape=(n_T, n_T)) / (n_T ** 2)
L_ST = -sp.ones(shape=(n_S, n_T)) / (n_S * n_T)
L_TS = -sp.ones(shape=(n_T, n_S)) / (n_S * n_T)
L[0:n_S, 0:n_S] = L_SS
L[n_S : n_S + n_T, n_S : n_S + n_T] = L_TT
L[n_S : n_S + n_T, 0:n_S] = L_TS
L[0:n_S, n_S : n_S + n_T] = L_ST
R = pdist(sp.vstack([X_S, X_T]), metric="euclidean", p=p, w=None, V=None, VI=None)
K = Gaussian(R, kernel_para, p)
Id = sp.zeros(shape=(n, n))
H = sp.zeros(shape=(n, n))
sp.fill_diagonal(Id, 1)
sp.fill_diagonal(H, 1)
H -= 1.0 / n
LA = Laplace(R, p, sigma)
K_hat_y = sp.zeros(shape=(n, n))
K_hat_y[0, 0] = 1
for i in range(1, n_S):
K_hat_y[i, i] = 1
for j in range(i):
if y_S[i] == y_S[j]:
K_hat_y[i, j] = 1
K_hat_y[j, i] = 1
K_hat_y = gamma * K_hat_y + (1 - gamma) * Id
Id = sp.mat(Id)
H = sp.mat(H)
K = sp.mat(K)
L = sp.mat(L)
LA = sp.mat(LA)
matrix = sp.linalg.inv(K * (L + lamb * LA) * K + mu * Id) * sp.mat(K * H * K_hat_y * H * K)
eigen_values = sp.linalg.eig(matrix)
eigen_val = eigen_values[0][0:m]
eigen_vect = eigen_values[1][:, 0:m]
return (eigen_val, eigen_vect, K, LA, K_hat_y, sp.vstack([X_S, X_T]))
tau_sol_vec_Mon = []
avg = {}
num_infeasible = sp.zeros(len(range_num_d2d_pairs))
for prin in range_num_d2d_pairs:
num_d2d_pairs = prin
# rmin = sp.multiply(0.2, sp.log(2))
time_sol_vec = []
EE_sol_vec = []
tau_sol_vec = []
for Mon in xrange(max_chan_realizaion):
try:
max_d2d_to_d2d_gains_diff = sp.copy(max_d2d_to_d2d_gains[:, :,
Mon])
sp.fill_diagonal(max_d2d_to_d2d_gains_diff, 0)
max_d2d_to_d2d_gains_diag = sp.subtract(
max_d2d_to_d2d_gains[:, :, Mon], max_d2d_to_d2d_gains_diff)
uav_to_d2d_gains = max_uav_to_d2d_gains[:num_d2d_pairs, Mon]
d2d_to_d2d_gains = max_d2d_to_d2d_gains[:num_d2d_pairs, :
num_d2d_pairs, Mon]
d2d_to_d2d_gains_diff = max_d2d_to_d2d_gains_diff[:num_d2d_pairs, :
num_d2d_pairs]
d2d_to_d2d_gains_diag = sp.subtract(d2d_to_d2d_gains,
d2d_to_d2d_gains_diff)
# ############################################################
# This code is used to find the initial point for EEmax algorithm
# ############################################################
def get_avg_sep():
real = tau_class.TauClass('../../data/delta-2.fits.gz')
real.get_data(skewers_perc=1., ylabel='DELTA')
avg_r = real.pixel_data[:, 2].mean()
print("Average distance is {}".format(avg_r))
ra, dec = real.q_loc[:, 0], real.q_loc[:, 1]
delta_ra = sp.abs(ra - ra[:, None])
delta_dec = sp.abs(dec - dec[:, None])
angle = 2 * sp.arcsin(
sp.sqrt(
sp.sin(delta_dec / 2.)**2 +
sp.cos(dec) * sp.cos(dec[:, None]) * sp.sin(delta_ra / 2.)**2))
# remove self-distances
sp.fill_diagonal(angle, sp.inf)
min_angle = angle.min(0) * 180 / sp.pi
avg_angle = min_angle.mean()
p_cmd = "Average distance is {} h^-1 Mpc \n".format(avg_r)
p_cmd += "Average angle is {} degree \n".format(avg_angle)
avg_sep = avg_angle * avg_r * sp.pi / 180
p_cmd += "Average transverse separation is {} h^-1 Mpc \n".format(avg_sep)
print(p_cmd)
# *************************************************************************
simul = tau_class.TauClass('../../data/simulations/'
'v6.0.1_delta_transmission_RMplate.fits')
simul.get_data(skewers_perc=1.)
avg_r = simul.pixel_data[:, 2].mean()
print("Average distance is {}".format(avg_r))
ra, dec = sp.deg2rad(simul.q_loc[:, 0]), sp.deg2rad(simul.q_loc[:, 1])
delta_ra = sp.abs(ra - ra[:, None])
delta_dec = sp.abs(dec - dec[:, None])
angle = 2 * sp.arcsin(
sp.sqrt(
sp.sin(delta_dec / 2.)**2 +
sp.cos(dec) * sp.cos(dec[:, None]) * sp.sin(delta_ra / 2.)**2))
# remove self-distances
sp.fill_diagonal(angle, sp.inf)
min_angle = angle.min(0) * 180 / sp.pi
avg_angle = min_angle.mean()
p_cmd = "Average distance is {} h^-1 Mpc \n".format(avg_r)
p_cmd += "Average angle is {} degree \n".format(avg_angle)
avg_sep = avg_angle * avg_r * sp.pi / 180
p_cmd += "Average transverse separation is {} h^-1 Mpc \n".format(avg_sep)
print(p_cmd)
# extract all properties in a list of floats
properties = [float(p) for i,p in enumerate(f.readline().split()) if i > 0]
# construct molecule from species x y z charge
molecule = []
try:
for j in range(natoms):
# molecule.append([float(x) for i, x in enumerate(f.readline().split()) if i > 0])
molecule.append([x for i, x in enumerate(f.readline().split())])
molecule = sp.array(molecule)
nuc_charge = species_to_nuc_charge(molecule[:,0])
molecule = sp.array(molecule[:,1:], dtype='float64')
pos = molecule[:,:-1]
# construct Coulomb matrix
X = sp.outer(nuc_charge, nuc_charge) / (dist.squareform(dist.pdist(pos)) + sp.eye(natoms))
sp.fill_diagonal(X, 0.5*sp.absolute(nuc_charge)**2.4)
# add all properties of current molecule to dataset
[dataset[k].append(properties[ordering[i]]) for i, k in enumerate(dataset.keys())]
dataset['idx'][-1] = int(dataset['idx'][-1]) # index is an integer
X_all.append(X)
charge.append(molecule[:,-1])
except Exception as err:
print "Molecule %s skipped, malformed file" % file
print err
pass
dataset['X'] = X_all
dataset['charge'] = charge
for k,w in dataset.iteritems():
# construct molecule from species x y z charge
molecule = []
try:
for j in range(natoms):
# molecule.append([float(x) for i, x in enumerate(f.readline().split()) if i > 0])
molecule.append(
[x for i, x in enumerate(f.readline().split())])
molecule = sp.array(molecule)
nuc_charge = species_to_nuc_charge(molecule[:, 0])
molecule = sp.array(molecule[:, 1:], dtype='float64')
pos = molecule[:, :-1]
# construct Coulomb matrix
X = sp.outer(nuc_charge, nuc_charge) / (
dist.squareform(dist.pdist(pos)) + sp.eye(natoms))
sp.fill_diagonal(X, 0.5 * sp.absolute(nuc_charge)**2.4)
# add all properties of current molecule to dataset
[
dataset[k].append(properties[ordering[i]])
for i, k in enumerate(dataset.keys())
]
dataset['idx'][-1] = int(dataset['idx'][-1]) # index is an integer
X_all.append(X)
charge.append(molecule[:, -1])
except Exception as err:
print "Molecule %s skipped, malformed file" % file
print err
pass
dataset['X'] = X_all
def main():
# Data structure: train_sigs contains all signatures from the folder enrollment
# train_sigs[writerID] contains the five signatures of person writerID
# train_sigs[writerID][n] contains the nth signature of person writerID
train_sigs = read_signature_files(train_directory, "enrollment")
test_sigs = read_signature_files(test_directory, "validation")
n_test_files = 0
for writerID in train_sigs:
for i in train_sigs[writerID]:
train_sigs[writerID][i] = compute_features(train_sigs[writerID][i])
for i in test_sigs[writerID]:
test_sigs[writerID][i] = compute_features(test_sigs[writerID][i])
n_test_files += 1
# Compute relevant DTW distances on test set
try:
import multiprocessing as mp
n_threads = mp.cpu_count()
n_threads = min([n_threads, 16])
n_threads = max([n_threads, 2])
distance_dict = {}
with mp.Pool(n_threads) as pool:
for writerID in test_sigs:
distance_dict[writerID] = pool.apply_async(
compare_test_train_set, (test_sigs, train_sigs, writerID))
pool.close()
pool.join()
for writerID in distance_dict:
distance_dict[writerID] = distance_dict[writerID].get()
except:
print("Multiprocessing not supported, falling back to single thread.")
distance_dict = {}
for writerID in test_sigs:
distance_dict[writerID] = compare_test_train_set(
test_sigs, train_sigs, writerID)
# Compute statistics to be fed to classifier
stats = pd.DataFrame(columns=[
"writer", "signature", "min_dist", "mean_dist", "max_dist", "rms_dist",
"min_mean_internal", "max_mean_internal", "verdict", "rms_internal",
"mean_internal"
],
index=range(n_test_files))
stats.loc[:]["min_dist"] = pd.to_numeric(stats.loc[:]["min_dist"])
stats.loc[:]["max_dist"] = pd.to_numeric(stats.loc[:]["max_dist"])
stats.loc[:]["min_mean_internal"] = pd.to_numeric(
stats.loc[:]["min_mean_internal"])
stats.loc[:]["max_mean_internal"] = pd.to_numeric(
stats.loc[:]["max_mean_internal"])
stats.loc[:]["mean_dist"] = pd.to_numeric(stats.loc[:]["mean_dist"])
stats.loc[:]["rms_dist"] = pd.to_numeric(stats.loc[:]["mean_dist"])
stats.loc[:]["rms_internal"] = pd.to_numeric(stats.loc[:]["rms_internal"])
stats.loc[:]["mean_internal"] = pd.to_numeric(
stats.loc[:]["mean_internal"])
index = 0
for writerID in test_sigs:
for i in test_sigs[writerID]:
dissimilarities = distance_dict[writerID][i]
stats.loc[index, [
'writer', 'signature', 'min_dist', 'mean_dist', 'max_dist',
'rms_dist'
]] = writerID, i, dissimilarities.min(), dissimilarities.mean(
), dissimilarities.max(), sc.sqrt((dissimilarities**2).mean())
index += 1
# Compute characteristics of training signatures
for writerID in train_sigs:
names = list(train_sigs[writerID].keys())
distance_matrix = sc.zeros([len(names), len(names)])
root_mean_square = 0.
mean = 0.
for i in range(len(names) - 1):
for j in range(i + 1, len(names)):
distance_matrix[j, i] = distance_matrix[i, j] = \
(DTWDistance(train_sigs[writerID][names[i]], train_sigs[writerID][names[j]]))
root_mean_square += distance_matrix[i, j]**2
mean += distance_matrix[i, j]
root_mean_square /= sc.math.factorial(len(names) - 1)
mean /= sc.math.factorial(len(names) - 1)
stats.loc[stats["writer"] == writerID,
"rms_internal"] = sc.sqrt(root_mean_square)
stats.loc[stats["writer"] == writerID, "mean_internal"] = mean
stats.loc[stats["writer"] == writerID, "max_mean_internal"] = \
(distance_matrix.max(1)).mean()
sc.fill_diagonal(distance_matrix, sc.inf)
stats.loc[stats["writer"] == writerID, "min_mean_internal"] = \
(distance_matrix.min(1)).mean()
#stats["diff_min"] = stats["min_dist"] / stats["min_mean_internal"];
#stats["diff_max"] = stats["max_dist"] / stats["max_mean_internal"];
#stats["diff_mean"] = stats["mean_dist"] / stats["mean_internal"];
stats["diff_rms"] = stats["rms_dist"] / stats["rms_internal"]
stats.sort_values(by=["writer", "signature"])
outputFile = open(os.path.join(".", "sig_ver_prediction.txt"), 'w')
for writerID in test_sigs.keys():
outputFile.write(writerID + ', ')
for sigID in test_sigs[writerID].keys():
outputFile.write(sigID + ', {}, '.format(
float(stats.loc[(stats['writer'] == writerID)
& (stats['signature'] == sigID)]['diff_rms'])))
outputFile.write('\n')
def parameters(cmdargs):
"""
cmdargs:
-q, qubits
-k, lrule
-f, nmems
"""
# The Hopfield parameters
hparams = {
'numNeurons':
cmdargs['qubits'],
'inputState': [
2 * sp.random.random_integers(0, 1) - 1
for k in xrange(cmdargs['qubits'])
],
'learningRule':
cmdargs['simtype'],
'numMemories':
int(cmdargs['farg'])
}
# Construct memories
memories = [[
2 * sp.random.random_integers(0, 1) - 1
for k in xrange(hparams['numNeurons'])
] for j in xrange(hparams['numMemories'])]
# At least one pattern must be one Hamming unit away from the input
memories[0] = list(hparams['inputState'])
memories[0][sp.random.random_integers(0, hparams['numNeurons'] - 1)] *= -1
# Make sure all other patterns are not the input state
def hamdist(a, b):
""" Calculate Hamming distance. """
return sp.sum(abs(sp.array(a) - sp.array(b)) / 2.0)
# Loop over additional memories, if there are any
for imem, mem in enumerate(memories[1:]):
while hamdist(mem, hparams['inputState']) < 1.0:
# Flip a random spin
rndbit = sp.random.random_integers(0, hparams['numNeurons'] - 1)
memories[imem + 1][rndbit] *= -1
# Basic simulation params
nQubits = hparams['numNeurons']
T = 1000.0 # sp.arange(0.1, 15, 0.5)
# T = sp.array([10.0, 20.0, 50.0, 100.0, 500.0,
# 1000.0, 5000.0, 10000.0, 50000.0])
dt = 0.005 * T
# Define states for which to track probabilities in time
# import statelabels
# label_list = statelabels.GenerateLabels(nQubits)
# stateoverlap = []
# for mem in memories:
# # Convert spins to bits
# bitstr = ''.join([ '0' if k == 1 else '1' for k in mem ])
# # Get the index of the current (converted) memory and add it to list
# stateoverlap.append([ label_list.index(bitstr), bitstr ])
stateoverlap = None
# Output parameters
binary = 1 # Save output files as binary Numpy format
progressout = 0 # Output simulation progress over anneal timesteps
eigspecdat = 1 # Output data for eigspec
eigspecplot = 0 # Plot eigspec
eigspecnum = 2**nQubits # Number of eigenvalues to output
fidelplot = 0 # Plot fidelity
fideldat = 0 # Output fidelity data
fidelnumstates = 2**nQubits # Check fidelity with this number of eigenstates
overlapdat = 0 # Output overlap data
overlapplot = 0 # Plot overlap
solveMethod = 'ExpPert' # 'ExpPert', 'SuzTrot', 'ForRuth', 'BCM'
# Output directory stuff
probdir = 'data/hopfield_exp3_nodiag/n'+str(nQubits)+'p'+\
str(hparams['numMemories'])+hparams['learningRule']
if isinstance(T, collections.Iterable):
probdir += 'MultiT'
if os.path.isdir(probdir):
outlist = sorted(
[int(name) for name in os.listdir(probdir) if name.isdigit()])
else:
outlist = []
outnum = outlist[-1] + 1 if outlist else 0
outputdir = probdir + '/' + str(outnum) + '/'
probshow = 0 # Print final state probabilities to screen
probout = 1 # Output probabilities to file
mingap = 0 # Record the minimum spectral gap
errchk = 0 # Error-checking on/off (for simulation accuracy)
eps = 0.01 # Numerical error in normalization condition (1 - norm < eps)
# Specify a QUBO (convert to Ising = True), or alpha, beta directly
# (convert = False), and also specify the signs on the Ising Hamiltonian
# terms (you can specify coefficients too for some problems if needed)
isingConvert = 0
isingSigns = {'hx': -1, 'hz': -1, 'hzz': -1}
# Construct network Ising parameters
neurons = nQubits
# This is gamma, the appropriate weighting on the input vector
# isingSigns['hz'] *= 1 - (len(hparams['inputState']) -
# hparams['inputState'].count(0))/(2*neurons)
# isingSigns['hz'] *= 1.0/(5*neurons)
# isingSigns['hz'] *= 0.2
alpha = sp.array(hparams['inputState'])
beta = sp.zeros((neurons, neurons))
delta = sp.array([])
# Construct the memory matrix according to a learning rule
if hparams['learningRule'] == 'hebb':
# Hebb rule
isingSigns['hz'] *= 0.5
memMat = sp.matrix(memories).T
beta = sp.triu(memMat * memMat.T) / float(neurons)
elif hparams['learningRule'] == 'stork':
# Storkey rule
isingSigns['hz'] *= 0.15
Wm = sp.zeros((neurons, neurons))
for m, mem in enumerate(memories):
Am = sp.outer(mem, mem) - sp.eye(neurons)
Wm += (Am - Am * Wm - Wm * Am) / float(neurons)
beta = sp.triu(Wm)
elif hparams['learningRule'] == 'proj':
isingSigns['hz'] *= 0.15
# Moore-Penrose pseudoinverse rule
memMat = sp.matrix(memories).T
beta = sp.triu(memMat * sp.linalg.pinv(memMat))
sp.fill_diagonal(beta, 0.0)
# Some outputs
outputs = {
'nQubits': nQubits,
'learningRule': hparams['learningRule'],
'outdir': probdir,
'inputState': hparams['inputState'],
'memories': memories,
'answer': memories[0],
'annealTime': list(T) if isinstance(T, collections.Iterable) else T
}
############################################################################
######## All variables must be specified here, do NOT change the keys ######
############################################################################
return {
'nQubits': nQubits,
'Q': None,
'T': T,
'dt': dt,
'outputdir': outputdir,
'errchk': errchk,
'eps': eps,
'isingConvert': isingConvert,
'isingSigns': isingSigns,
'outputs': outputs,
'alpha': alpha,
'beta': beta,
'delta': delta,
'eigdat': eigspecdat,
'eigplot': eigspecplot,
'eignum': eigspecnum,
'fiddat': fideldat,
'fidplot': fidelplot,
'fidnumstates': fidelnumstates,
'overlapdat': overlapdat,
'overlapplot': overlapplot,
'outdir': outputdir,
'binary': binary,
'progressout': progressout,
'probshow': probshow,
'probout': probout,
'mingap': mingap,
'stateoverlap': stateoverlap,
'hzscale': None,
'hzzscale': None,
'hxscale': None,
'solveMethod': solveMethod
}