def test_constant(self):
"""Test creating a constant.
"""
# Scalar constant.
size = (1, 1)
mat = create_const(1.0, size)
self.assertEqual(mat.size, size)
self.assertEqual(len(mat.args), 0)
self.assertEqual(mat.type, SCALAR_CONST)
assert mat.data == 1.0
# Dense matrix constant.
size = (5, 4)
mat = create_const(np.ones(size), size)
self.assertEqual(mat.size, size)
self.assertEqual(len(mat.args), 0)
self.assertEqual(mat.type, DENSE_CONST)
assert (mat.data == np.ones(size)).all()
# Sparse matrix constant.
size = (5, 5)
mat = create_const(sp.eye(5), size, sparse=True)
self.assertEqual(mat.size, size)
self.assertEqual(len(mat.args), 0)
self.assertEqual(mat.type, SPARSE_CONST)
assert (mat.data.todense() == sp.eye(5).todense()).all()
def _K(self, g, beta, ifix=None):
""" Returns the discretised integral operator
"""
if ifix is None:
ifix = self.ifix
g = g.reshape(self.dim.R, self.dim.N).T # set g as g_{nr}, n=1..N, r=1..R
g = np.column_stack((np.ones(self.dim.N), g)) # append a col. of 1s to g
# matrices A[r] = sum(b_rd * Ld
struct_mats = np.array([sum(brd*Ld for brd, Ld in zip(br, self.basis_mats))
for br in beta])
# Add an axis for n=0,...,N-1
At = struct_mats[None, :, :, :] * g[..., None, None]
At = At.sum(1)
W = weight_matrix(self.ttc, ifix) #self._weight_matrix
K = sum(sparse.kron(sparse.kron(W[:, i][:, None],
sparse.eye(1, self.dim.N, i)),
At[i, ...])
for i in range(self.dim.N))
I = sparse.eye(self.dim.K)
# because x[ifix] is fixed by the integral transform
# we need to add a column of identity matrices to K
# - could do this by assignment
eifix = sparse.eye(1, self.dim.N, ifix)
K += sum(sparse.kron(sparse.kron(sparse.eye(1, self.dim.N, i).transpose(),
eifix),
I)
for i in range(self.dim.N))
return K
def pauli_x(n, N):
'''compute the pauli_x operator acting on the n^th spin of N'''
px = Pauli['x']
e1, e2 = sp.eye(2**(n-1)), sp.eye(2**(N-n))
return sp.kron(e1, sp.kron(px, e2))
def solve_system(self, rhs, factor, u0, t):
"""
Simple linear solver for (I-dtA)u = rhs
Args:
rhs: right-hand side for the nonlinear system
factor: abbrev. for the node-to-node stepsize (or any other factor required)
u0: initial guess for the iterative solver (not used here so far)
t: current time (e.g. for time-dependent BCs)
Returns:
solution as mesh
"""
M1 = sp.hstack((sp.eye(self.nvars[1]), -factor * self.A))
M2 = sp.hstack((-factor * self.A, sp.eye(self.nvars[1])))
M = sp.vstack((M1, M2))
b = np.concatenate((rhs.values[0, :], rhs.values[1, :]))
sol = LA.spsolve(M, b)
me = mesh(self.nvars)
me.values[0, :], me.values[1, :] = np.split(sol, 2)
return me
def construct_hams(hs, Js, Jxs):
'''Construct static Hamiltonians'''
Nz = len(hs) # number of zones
H0s = [construct_H0(hs[i], Js[i]) for i in xrange(Nz)]
Gammas = [gen_gamma(len(hs[i])) for i in xrange(Nz)]
M = [H.size for H in H0s] # number of states per zone
C = [1]+list(np.cumprod(M)) # cumprod of H0 sizes
# pad single zone Hamiltonians
for i in xrange(Nz):
H0s[i] = np.tile(np.repeat(H0s[i], C[-1]/C[i+1]), [1, C[i]])
Gammas[i] = sp.kron(sp.eye(C[i]), sp.kron(Gammas[i], sp.eye(C[-1]/C[i+1])))
# only need sum of H0s
H0 = np.sum(np.array(H0s), axis=0)
# add zone-zone interactions to H0
for i,j in Jxs:
Jx = Jxs[(i,j)]
Hx = np.zeros([1, M[i]*M[j]], dtype=float)
for n,m in zip(*Jx.nonzero()):
Hx += Jx[n, m]*np.kron(pauli_z(n+1, Jx.shape[0]),
pauli_z(m+1, Jx.shape[1]))
if np.any(Hx):
H0 += np.tile(np.repeat(Hx, C[i]), [1, C[-1]/C[j+1]])
H0 = sp.diags(H0, [0])
return H0, Gammas
def multi_kron_sum(*mats):
'''Compute the Kronecker sum of multiple matrices. Special case if all
diagonal'''
N = len(mats)
diag = all(mat.ndim==1 for mat in mats)
# determine size of each matrix
Cm = [1]
for mat in mats:
Cm.append(Cm[-1]*mat.shape[0])
if diag:
S = np.zeros(Cm[-1])
for i, mat in enumerate(mats):
S += np.tile(np.repeat(mat, Cm[N]/Cm[i+1]), Cm[i])
else:
S = sp.coo_matrix((Cm[-1],Cm[-1]))
for i, mat in enumerate(mats):
e1, e2 = sp.eye(Cm[i]), sp.eye(Cm[N]/Cm[i+1])
S += multi_kron_prod(e1, mat, e2)
return S
def test_reshape8(self): t1 = expr.sparse_diagonal((137, 113)) t2 = expr.sparse_diagonal((113, 137)) a = expr.reshape(t1, (113, 137)) b = expr.reshape(t2, (137, 113)) Assert.all_eq(a.glom().todense(), sp.eye(137, 113).tolil().reshape((113, 137)).todense()) Assert.all_eq(b.glom().todense(), sp.eye(113, 137).tolil().reshape((137, 113)).todense())
def connected_components(adj):
"""Find the connected components in an undirected graph
Parameters :
adj : array-like, shape = [n_nodes, n_nodes] :
A dense matrix or rank-2 ndarray.
Returns :
cluster : np.ndarray, shape = [n_cc, ] :
The connected components in the graph.
Raises :
None
Notes :
cluster = connected_components(adj)
"""
A = sparse.csr_matrix(adj)
n_node = A.shape[0]
A = A + A.transpose()
newA = A + sparse.eye(n_node, n_node)
connected = A + sparse.eye(n_node, n_node)
cl = 0
cluster = np.zeros(n_node, dtype=int)
for i in range(n_node - 1):
connected = np.dot(connected, newA)
for i in range(n_node):
vars, redun = connected[:, i].nonzero()
if vars.size != 0:
cl += 1
cluster[vars] = cl
for var1 in vars:
for var2 in vars:
connected[var1, var2] = 0
return cluster
def test_transpose3(self): t1 = expr.sparse_diagonal((107, 401)).evaluate() t2 = expr.sparse_diagonal((401, 107)).evaluate() a = expr.transpose(t1) b = expr.transpose(t2) Assert.all_eq(a.glom().todense(), sp.eye(107, 401).transpose().todense()) Assert.all_eq(b.glom().todense(), sp.eye(401, 107).transpose().todense())
def leslie(self,A):
incidence_class = [sp.csr_matrix((self.size,self.size)) for ii in range(self.memory+1)]
incidence_class[0] = sp.eye(self.size,self.size,format='csr')
cumulative = sp.eye(self.size,self.size,format='csr')
prevalence = sp.eye(self.size,self.size,format='csr')
mean_cumulative = np.zeros((1,self.runtime))[0]
mean_prevalence = np.zeros((1,self.runtime))[0]
#=======================================================================
# Die zeitabhaengige Zugangsmatrix wird berechnet
#=======================================================================
sparse_add = sp.compressed._cs_matrix.__add__
memory = self.memory
for jj in range(0,self.runtime):
incidence = A[jj].dot(prevalence)
for ii in xrange(memory,0,-1):
incidence_class[ii] = incidence_class[ii-1]
incidence_class[0] = incidence
prevalence = reduce(sparse_add, incidence_class)
cumulative = cumulative + incidence
cumulative.data = np.ones_like(cumulative.data)
mean_cumulative[jj] = cumulative.nnz
mean_prevalence[jj] = prevalence.nnz
self.mean_cumulative = mean_cumulative.astype(float)/self.size**2
self.mean_prevalence = mean_prevalence.astype(float)/self.size**2
return
def sparse_orth(d):
""" Constructs a sparse orthogonal matrix.
The method is described in:
Gi-Sang Cheon et al., Constructions for the sparsest orthogonal matrices,
Bull. Korean Math. Soc 36 (1999) No.1 pp.199-129
"""
from scipy.sparse import eye
from scipy import r_, pi, sin, cos
if d % 2 == 0:
seq = r_[0:d:2, 1:d - 1:2]
else:
seq = r_[0:d - 1:2, 1:d:2]
Q = eye(d, d).tocsc()
for i in seq:
theta = random() * 2 * pi
flip = (random() - 0.5) > 0;
Qi = eye(d, d).tocsc()
Qi[i, i] = cos(theta)
Qi[(i + 1), i] = sin(theta)
if flip > 0:
Qi[i, (i + 1)] = -sin(theta)
Qi[(i + 1), (i + 1)] = cos(theta)
else:
Qi[i, (i + 1)] = sin(theta)
Qi[(i + 1), (i + 1)] = -cos(theta)
Q = Q * Qi;
return Q
def iteration(self, user, fixed_vecs):
num_solve = self.num_users if user else self.num_items
num_fixed = fixed_vecs.shape[0]
YTY = fixed_vecs.T.dot(fixed_vecs)
eye = sparse.eye(num_fixed)
lambda_eye = self.reg_param * sparse.eye(self.num_factors)
solve_vecs = np.zeros((num_solve, self.num_factors))
if DETAIL_MODE:
t = time.time()
for i in xrange(num_solve):
if user:
counts_i = self.counts[i].toarray()
else:
counts_i = self.counts[:, i].T.toarray()
CuI = sparse.diags(counts_i, [0])
pu = counts_i.copy()
pu[np.where(pu != 0)] = 1.0
YTCuIY = fixed_vecs.T.dot(CuI).dot(fixed_vecs)
YTCupu = fixed_vecs.T.dot(CuI + eye).dot(sparse.csr_matrix(pu).T)
xu = spsolve(YTY + YTCuIY + lambda_eye, YTCupu)
solve_vecs[i] = xu
if DETAIL_MODE and i % 1000 == 0:
print 'Solved %i vecs in %d seconds' % (i, time.time() - t)
t = time.time()
return solve_vecs
def sparse_cH(terms, ldim=2):
"""Construct a sparse cyclic nearest-neighbour Hamiltonian
:param terms: List of nearst-neighbour terms (square array or MPO,
see return value of :func:`cXY_local_terms`)
:param ldim: Local dimension
:returns: The Hamiltonian as sparse matrix
"""
H = 0
N = len(terms)
for pos, term in enumerate(terms[:-1]):
if hasattr(term, 'lt'):
# Convert MPO to regular matrix
term = term.to_array_global().reshape((ldim**2, ldim**2))
left = sp.eye(ldim**pos)
right = sp.eye(ldim**(N - pos - 2))
H += sp.kron(left, sp.kron(term, right))
# The last term acts on the first and last site.
cyc = terms[-1]
middle = sp.eye(ldim**pos)
for i in range(cyc.ranks[0]):
H += sp.kron(cyc.lt[0][0, ..., i], sp.kron(middle, cyc.lt[1][i, ..., 0]))
return H
def heat_do_implicit_step(ux, u0, k, h):
"""
Does one timestep for given initial conditions at u0 = u^(j) with spatial meshwidth h and temporal meshwidth k for
the 1D heat equation. For notation an theory see
"Karpfinger, Hoehere Mathematik in Rezepten, 2.Auflage, p.894 ff."
Since we are using an implicit time stepping scheme, there is no stability criterion. We use
scipy.linalg.solve_banded for solving the implicit equation. Theferfore we need to convert our implicit equation
into ordered diagonal format:
u1 = u0 + A_h * u1
-> (Id - A_h) * u1 = u0
This is a system of linear equations: A * x = b with
A = Id - A_h
x = u1
b = u0
:param u0: solution u(x,t=t)
:param k: temporal meshwidth
:param h: spatial meshwidth
:return: u1: solution u(x,t=t+k)
"""
n = u0.shape[0]
r = (c_heat ** 2) * k / (h ** 2)
iteration_matrix = (r * sp.eye(n, n, -1) - 2 * r * sp.eye(n, n) + r * sp.eye(n, n, 1)).tocsr()
iteration_matrix[0, 0] = 0 # enforcing dirichlet BC -> no change!
iteration_matrix[0, 1] = 0
iteration_matrix[n - 1, n - 1] = 0
iteration_matrix[n - 1, n - 2] = 0
iteration_matrix = -iteration_matrix
iteration_matrix += sp.eye(n, n)
u1 = lin.spsolve(iteration_matrix, u0)
return u1
def wave_do_explicit_step(u0, u1, k, h):
"""
Does one timestep for given initial conditions at u0 = u^(j-1) and u1 = u^(j) with spatial meshwidth h and temporal
meshwidth k for the 1D wave equation. For notation an theory see
"Karpfinger, Hoehere Mathematik in Rezepten, 2.Auflage, p.904 ff."
Stability criterion:
r = (k / h)**2 <= 1
:param u0: solution u(x,t=t-k)
:param u1: solution u(x,t=t)
:param k: temporal meshwidth
:param h: spatial meshwidth
:return: u2: solution u(x,t=t+k)
"""
n = u0.shape[0]
r = (c_wave * k / h) ** 2
a_h = (-2 * r * sp.eye(n, n) + r * sp.eye(n, n, -1) + r * sp.eye(n, n, 1)).tocsr()
iteration_matrix1 = 2 * sp.eye(n, n) + a_h
iteration_matrix1[0, 0] = 1
iteration_matrix1[0, 1] = 0
iteration_matrix1[n - 1, n - 1] = 1
iteration_matrix1[n - 1, n - 2] = 0
iteration_matrix0 = - 1 * sp.eye(n, n).tocsr()
iteration_matrix0[0, 0] = 0
iteration_matrix0[n - 1, n - 1] = 0
u2 = iteration_matrix1.dot(u1) + iteration_matrix0.dot(u0)
return u2
def test_3sum(self):
nP = 90
alpha1 = 0.3
alpha2 = 0.6
alpha3inv = 9
phi1 = ObjectiveFunction.L2ObjectiveFunction(W=sp.eye(nP))
phi2 = ObjectiveFunction.L2ObjectiveFunction(W=sp.eye(nP))
phi3 = ObjectiveFunction.L2ObjectiveFunction(W=sp.eye(nP))
phi = alpha1 * phi1 + alpha2 * phi2 + phi3 / alpha3inv
m = np.random.rand(nP)
self.assertTrue(
np.all(phi.multipliers == np.r_[alpha1, alpha2, 1./alpha3inv])
)
self.assertTrue(
np.allclose((alpha1*phi1(m) + alpha2*phi2(m) + phi3(m)/alpha3inv), phi(m))
)
self.assertTrue(len(phi.objfcts) == 3)
self.assertTrue(phi.test())
def _pade(A, m):
n = np.shape(A)[0]
c = _padecoeff(m)
if m != 13:
apows = [[] for jj in range(int(np.ceil((m + 1) / 2)))]
apows[0] = sp.eye(n, n, format='csc')
apows[1] = A * A
for jj in range(2, int(np.ceil((m + 1) / 2))):
apows[jj] = apows[jj - 1] * apows[1]
U = sp.lil_matrix((n, n)).tocsc()
V = sp.lil_matrix((n, n)).tocsc()
for jj in range(m, 0, -2):
U = U + c[jj] * apows[jj // 2]
U = A * U
for jj in range(m - 1, -1, -2):
V = V + c[jj] * apows[(jj + 1) // 2]
F = spla.spsolve((-U + V), (U + V))
return F.tocsr()
elif m == 13:
A2 = A * A
A4 = A2 * A2
A6 = A2 * A4
U = A * (A6 * (c[13] * A6 + c[11] * A4 + c[9] * A2) +
c[7] * A6 + c[5] * A4 + c[3] * A2 +
c[1] * sp.eye(n, n).tocsc())
V = A6 * (c[12] * A6 + c[10] * A4 + c[8] * A2) + c[6] * A6 + c[4] * \
A4 + c[2] * A2 + c[0] * sp.eye(n, n).tocsc()
F = spla.spsolve((-U + V), (U + V))
return F.tocsr()
def check(self,A):
cumulative_SI = A[0].copy() + sp.eye(self.size, self.size, 0, format='csr')
cumulative_SI.data = np.ones_like(cumulative_SI.data)
incidence_class = [sp.csr_matrix((self.size,self.size)) for ii in range(self.runtime)]
incidence_class[0] = A[0]
incidence_class[1] = sp.eye(self.size,self.size,format='csr')
cumulative_SIR = incidence_class[0] + incidence_class[1]
prevalence = incidence_class[0] + incidence_class[1]
check = np.empty(shape=(self.runtime,),dtype=bool)
check[0] = (cumulative_SI != cumulative_SIR).nnz > 0 # check == 1 wenn wenigsten ein Element verschieden ist
for ii in range(1,self.runtime):
try:
cumulative_SI = cumulative_SI + A[ii]*cumulative_SI
cumulative_SI.data = np.ones_like(cumulative_SI.data)
incidence = A[ii].dot(prevalence)
incidence.data = np.ones_like(incidence.data)
incidence = incidence - incidence.multiply(cumulative_SIR)
prevalence = prevalence - incidence_class[-1]
prevalence = prevalence + incidence
cumulative_SIR = cumulative_SIR + incidence
for jj in xrange(self.runtime-1,0,-1):
incidence_class[jj] = incidence_class[jj-1]
incidence_class[0] = incidence
check[ii] = (cumulative_SI != cumulative_SIR).nnz > 0
print ii, check[ii]
except:
print 'Break at t = ', ii
break
return check
def solve_qp_constrained(P,q,nlabel,x0,**kwargs):
import solver_qp_constrained as solver
reload(solver)
## constrained solver
nvar = q.size
npixel = nvar/nlabel
F = sparse.bmat([
[sparse.bmat([[-sparse.eye(npixel,npixel) for i in range(nlabel-1)]])],
[sparse.eye(npixel*(nlabel-1),npixel*(nlabel-1))],
])
## quadratic objective
objective = solver.ObjectiveAPI(P, q, G=1, h=0, F=F,**kwargs)
## log barrier solver
t0 = kwargs.pop('logbarrier_initial_t',1.0)
mu = kwargs.pop('logbarrier_mu',20.0)
epsilon = kwargs.pop('logbarrier_epsilon',1e-3)
solver = solver.ConstrainedSolver(
objective,
t0=t0,
mu=mu,
epsilon=epsilon,
)
## remove zero entries in initial guess
xinit = x0.reshape((-1,nlabel),order='F')
xinit[xinit<1e-10] = 1e-3
xinit = (xinit/np.c_[np.sum(xinit, axis=1)]).reshape((-1,1),order='F')
x = solver.solve(xinit, **kwargs)
return x
def roughening_matrix(num_cols):
''' Return any size of roughening matrix.
'''
A = eye(num_cols-2, num_cols, k=0, dtype='float')
B = -2. * eye(num_cols-2, num_cols, k=1, dtype='float')
C = eye(num_cols-2, num_cols, k=2, dtype='float')
return A+B+C
def get_irt_learner(train_df, test_df=None, is_two_po=True,
single_concept=True, template_precision=None, item_precision=None):
""" Make a 1PO or 2PO learner.
:param pd.DataFrame train_df: Train data
:param pd.DataFrame test_df: Optional test data
:param bool is_two_po: Whether to make a 2PO learner
:param bool single_concept: Should we train with a single theta per user (True)
or a single theta per user per concept (False)
:param float template_precision: The hierarchical IRT model has a model
item_difficulty ~ N(template_difficulty, 1.0/item_precision) and
template_difficulty ~ N(0, 1.0/template_precision). None just ignores
templates.
:param float|None item_precision: The precision of the Gaussian prior around items in a
non-templated model. Or see `template_precision` for the templated case. If None, uses 1.0.
:return: The learner
:rtype: BayesNetLearner
"""
correct = train_df[CORRECT_KEY].values.astype(bool)
item_idx = train_df[ITEM_IDX_KEY].values
is_held_out = np.zeros(len(train_df), dtype=bool)
if test_df is not None:
correct = np.concatenate((correct, test_df[CORRECT_KEY].values.astype(bool)))
item_idx = np.concatenate((item_idx, test_df[ITEM_IDX_KEY].values))
is_held_out = np.concatenate((is_held_out, np.ones(len(test_df), dtype=bool)))
student_idx = compute_theta_idx(train_df, test_df=test_df, single_concept=single_concept)
if not template_precision:
learner_class = TwoPOLearner if is_two_po else OnePOLearner
learner = learner_class(correct, student_idx=student_idx, item_idx=item_idx,
is_held_out=is_held_out, max_iterations=1000,
callback=ConvergenceCallback())
for node in learner.nodes.itervalues():
node.solver_pars.updater.step_size = 0.5
if item_precision is not None:
learner.nodes[OFFSET_COEFFS_KEY].cpd.precision = \
item_precision * sp.eye(learner.nodes[OFFSET_COEFFS_KEY].data.size)
LOGGER.info("Made a 1PO IRT learner with item precision %f", item_precision)
else:
LOGGER.info("Made a 1PO IRT learner with default item precision")
else:
template_idx = train_df[TEMPLATE_IDX_KEY]
if test_df is not None:
template_idx = np.concatenate((template_idx, test_df[TEMPLATE_IDX_KEY].values))
problem_to_template = {item: template for item, template in zip(item_idx, template_idx)}
problem_to_template = sorted(problem_to_template.items())
template_idx = np.array([x for _, x in problem_to_template])
learner = OnePOHighRT(correct, student_idx, item_idx, template_idx,
is_held_out=is_held_out, max_iterations=1000,
higher_precision=item_precision,
callback=ConvergenceCallback())
if item_precision is not None:
learner.nodes[HIGHER_OFFSET_KEY].cpd.precision = \
template_precision * sp.eye(learner.nodes[HIGHER_OFFSET_KEY].data.size)
for node in learner.nodes.itervalues():
node.solver_pars.updater.step_size = 0.5
LOGGER.info("Made a hierarchical IRT learner with item precision %f and template "
"precision %f", item_precision, template_precision)
return learner
def mult_by_monomial( alpha ):
#produces multiplication operator for monomial
global DIM, degree_max
out = sparse.eye( degree_max, k=alpha[0], format='dia')
for d in range(1,DIM):
store = sparse.eye( degree_max, k=alpha[d], format='dia')
out = sparse.kron( store , out )
return out
def BuildLaPoisson():
"""
pour l'etape de projection
matrice de Laplacien phi
avec CL Neumann pour phi
BUT condition de Neumann pour phi
==> non unicite de la solution
besoin de fixer la pression en un point
pour lever la degenerescence: ici [0][1]
==> need to build a correction matrix
"""
### ne pas prendre en compte les points fantome (-2)
NXi = nx
NYi = ny
###### Definition of the 1D Lalace operator
###### AXE X
### Diagonal terms
dataNXi = [numpy.ones(NXi), -2*numpy.ones(NXi), numpy.ones(NXi)]
### Conditions aux limites : Neumann à gauche, rien à droite
dataNXi[2][1] = 2. # SF left
# dataNXi[0][NXi-2] = 2. # SF right
###### AXE Y
### Diagonal terms
dataNYi = [numpy.ones(NYi), -2*numpy.ones(NYi), numpy.ones(NYi)]
### Conditions aux limites : Neumann
dataNYi[2][1] = 2. # SF low
dataNYi[0][NYi-2] = 2. # SF top
###### Their positions
offsets = numpy.array([-1,0,1])
DXX = sp.dia_matrix((dataNXi,offsets), shape=(NXi,NXi)) * dx_2
DYY = sp.dia_matrix((dataNYi,offsets), shape=(NYi,NYi)) * dy_2
####### 2D Laplace operator
LAP = sp.kron(sp.eye(NYi,NYi), DXX) + sp.kron(DYY, sp.eye(NXi,NXi))
####### BUILD CORRECTION MATRIX
### Upper Diagonal terms
dataNYNXi = [numpy.zeros(NYi*NXi)]
offset = numpy.array([1])
### Fix coef: 2+(-1) = 1 ==> Dirichlet en un point (redonne Laplacien)
### ATTENTION COEF MULTIPLICATIF : dx_2 si M(j,i) j-NY i-NX
dataNYNXi[0][1] = -1 * dx_2
LAP0 = sp.dia_matrix((dataNYNXi,offset), shape=(NYi*NXi,NYi*NXi))
return LAP + LAP0
def create_iFFT2mtx(nx, ny):
"""
Take advantage of the use of scipy.sparse library.
Creates the Matrixoperator for an array x.
:param x: Array to calculate the Operator for
:type x: array-like
returns
:param sparse_iFFT2mtx: 2D iFFT operator for matrix of shape of x.
:type sparse_iFFT2mtx: scipy.sparse.csr.csr_matrix
"""
N = nx * ny
iDFT1 = np.fft.fft(sparse.eye(nx).toarray().transpose()).conj().transpose()
iDFT2 = np.fft.fft(sparse.eye(ny).toarray().transpose()).conj().transpose()
# Create Sparse matrix, with iDFT1 ny-times repeatet on the diagonal.
# Initialze lil_matrix, to write diagonals in correct way.
tmp = sparse.lil_matrix((N,N), dtype='complex')
row = 0
for i in range(ny):
for j in range(nx):
tmp[row, (i)*nx:(i+1)*nx] = iDFT1[j,:]
row += 1
#Screen feedback.
prcnt = 50*(i+1) / float(ny) -1
if prcnt >=0 : print("%i %% done" % prcnt, end="\r")
sys.stdout.flush()
# Export tmp to a diagonal sparse matrix.
sparse_iDFT1 = tmp.tocsc()
# Initialze lil_matrix for iDFT2 and export it to sparse.
tmp = sparse.lil_matrix((N,N), dtype='complex')
row = 0
for i in range(ny):
for j in range(nx):
indx = np.arange(j,N,nx)
tmp[row,indx] = iDFT2[i,:]
row += 1
prcnt = (50*(i+1) / float(ny)) + 49
print("%i %% done" % prcnt, end="\r")
sys.stdout.flush()
sparse_iDFT2 = tmp.tocsc()
print("\n")
print("100 %% done \n")
# Calculate matrix dot-product iDFT2 * iDFT1 and divide it
# by the number of all samples (nx * ny)
sparse_iFFT2mtx = sparse_iDFT2.dot(sparse_iDFT1)/float(N)
return sparse_iFFT2mtx
def testSub(self):
N = 1000
a = random(N)
b = random(N)
c = a - b
self.assertEqual(0, (c.diff(a, 'tangent') - sp.eye(N,N)).nnz)
self.assertEqual(0, (c.diff(a, 'adjoint') - sp.eye(N,N)).nnz)
self.assertEqual(0, (c.diff(b, 'tangent') + sp.eye(N,N)).nnz)
self.assertEqual(0, (c.diff(b, 'adjoint') + sp.eye(N,N)).nnz)
def SI_load(self,A):
zm = [sp.csr_matrix((self.size,self.size),dtype=np.int8) for ii in range(self.runtime+1)]
zm[0] = sp.eye(self.size,self.size,dtype=np.int8,format='csr')
C = A[0] + sp.eye(self.size, self.size, 0, format='csr')
for ii in range(1,self.runtime+1):
C.data = np.int8(C.data>0)
zm[ii] = C
C = (A[ii-1] + sp.eye(self.size, self.size, 0, format='csr'))*C
return zm
def LaplacianSmooth(self, reference_mesh):
# placing this down here for now in case people are having numpy/scipy problems
import numpy
import scipy.sparse as sparse
import scipy.sparse.linalg
num_vertices = len(self.vertices)
num_boundary_vertices = len(self.boundary_vertices)
num_non_boundary_vertices = num_vertices - num_boundary_vertices
L = sparse.lil_matrix((num_vertices, num_vertices))
C = sparse.lil_matrix((num_boundary_vertices, num_vertices))
Cbar = sparse.lil_matrix((num_non_boundary_vertices, num_vertices))
non_boundary_vertices_seen = 0
boundary_vertices_seen = 0
for i in xrange(num_vertices):
if i in self.boundary_vertices:
C[boundary_vertices_seen, i] = 1.0
boundary_vertices_seen += 1
else:
Cbar[non_boundary_vertices_seen, i] = 1.0
non_boundary_vertices_seen += 1
assert (num_boundary_vertices == boundary_vertices_seen)
assert (num_non_boundary_vertices == non_boundary_vertices_seen)
C = sparse.kron(C, sparse.eye(3, 3)).tocsr()
Cbar = sparse.kron(Cbar, sparse.eye(3, 3)).tocsr()
edge_boundary_vertices = 0
edge_non_boundary_vertices = 0
for v0, v1 in self.edges:
if v0 in self.boundary_vertices:
edge_boundary_vertices += 1
else:
edge_non_boundary_vertices += 1
if v1 in self.boundary_vertices:
edge_boundary_vertices += 1
else:
edge_non_boundary_vertices += 1
weight = 1.0
L[v0,v0] -= weight
L[v0,v1] += weight
L[v1,v1] -= weight
L[v1,v0] += weight
L = sparse.kron(L, sparse.eye(3, 3)).tocsr()
xtilde = numpy.array(self.vertices).flatten()
y = numpy.array(reference_mesh.vertices).flatten()
CbarLTL = Cbar * (L.T * L)
b = CbarLTL * (y - C.T * (C * xtilde))
xbar, info = sparse.linalg.cg(CbarLTL * Cbar.T, b)
x = Cbar.T * xbar + C.T * (C * xtilde)
self.vertices = x.reshape(numpy.array(self.vertices).shape)
def AlphaCoeffs(n, a):
# Construct alpha operator
Z = sps.csr_matrix([[1,0],[0,-1]])
I = sps.eye(2)
alpha = sps.eye(2**n)
# Form alpha and beta operators
for q1 in xrange(n):
alpha = alpha + a[q1]*_formZi(n,q1,Z)
return alpha
def lap(shape, spacing):
"""
This function generates the laplacian operator
:param shape:
:param spacing:
:return:
"""
n = shape[0]*shape[1]
return ( -4.*sparse.eye(n, n, 0) + sparse.eye(n, n, 1) + sparse.eye(n, n, -1) + sparse.eye(n, n, shape[1]) + sparse.eye(n, n, -shape[1]) )/spacing**2
def factor(X,rho):
m,n = X.shape
if m>=n:
L = cholesky(X.T.dot(X)+rho*sparse.eye(n))
else:
L = cholesky(sparse.eye(m)+1./rho*(X.dot(X.T)))
L = sparse.csc_matrix(L)
U = sparse.csc_matrix(L.T)
return L,U
def minimize_svrg(
f_deriv,
A,
b,
x0,
step_size,
alpha=0,
prox=None,
max_iter=500,
tol=1e-6,
verbose=False,
callback=None,
):
r"""Stochastic average gradient augmented (SAGA) algorithm.
The SAGA algorithm can solve optimization problems of the form
argmin_{x \in R^p} \sum_{i}^n_samples f(A_i^T x, b_i) + alpha *
||x||_2^2 +
+ beta * ||x||_1
Args:
f_deriv
derivative of f
x0: np.ndarray or None, optional
Starting point for optimization.
step_size: float or None, optional
Step size for the optimization. If None is given, this will be
estimated from the function f.
n_jobs: int
Number of threads to use in the optimization. A number higher than 1
will use the Asynchronous SAGA optimization method described in
[Pedregosa et al., 2017]
max_iter: int
Maximum number of passes through the data in the optimization.
tol: float
Tolerance criterion. The algorithm will stop whenever the norm of the
gradient mapping (generalization of the gradient for nonsmooth
optimization)
is below tol.
verbose: bool
Verbosity level. True might print some messages.
trace: bool
Whether to trace convergence of the function, useful for plotting
and/or debugging. If ye, the result will have extra members
trace_func, trace_time.
Returns:
opt: OptimizeResult
The optimization result represented as a
``scipy.optimize.OptimizeResult`` object. Important attributes are:
``x`` the solution array, ``success`` a Boolean flag indicating if
the optimizer exited successfully and ``message`` which describes
the cause of the termination. See `scipy.optimize.OptimizeResult`
for a description of other attributes.
References:
The SAGA algorithm was originally described in
Aaron Defazio, Francis Bach, and Simon Lacoste-Julien. `SAGA: A fast
incremental gradient method with support for non-strongly convex composite
objectives. <https://arxiv.org/abs/1407.0202>`_ Advances in Neural
Information Processing Systems. 2014.
The implemented has some improvements with respect to the original,
like support for sparse datasets and is described in
Fabian Pedregosa, Remi Leblond, and Simon Lacoste-Julien.
"Breaking the Nonsmooth Barrier: A Scalable Parallel Method
for Composite Optimization." Advances in Neural Information
Processing Systems (NIPS) 2017.
"""
x = np.ascontiguousarray(x0).copy()
n_samples, n_features = A.shape
A = sparse.csr_matrix(A)
if step_size is None:
# then need to use line search
raise ValueError
if hasattr(prox, "__len__") and len(prox) == 2:
blocks = prox[1]
prox = prox[0]
else:
blocks = sparse.eye(n_features, n_features, format="csr")
if prox is None:
@utils.njit
def prox(x, i, indices, indptr, d, step_size):
pass
A_data = A.data
A_indices = A.indices
A_indptr = A.indptr
n_samples, n_features = A.shape
rblocks_indices = blocks.T.tocsr().indices
blocks_indptr = blocks.indptr
bs_data, bs_indices, bs_indptr = _support_matrix(A_indices, A_indptr,
rblocks_indices,
blocks.shape[0])
csr_blocks_1 = sparse.csr_matrix((bs_data, bs_indices, bs_indptr))
# .. diagonal reweighting ..
d = np.array(csr_blocks_1.sum(0), dtype=np.float).ravel()
idx = d != 0
d[idx] = n_samples / d[idx]
d[~idx] = 1
@utils.njit
def full_grad(x):
grad = np.zeros(x.size)
for i in range(n_samples):
p = 0.0
for j in range(A_indptr[i], A_indptr[i + 1]):
j_idx = A_indices[j]
p += x[j_idx] * A_data[j]
grad_i = f_deriv(np.array([p]), np.array([b[i]]))[0]
# .. gradient estimate (XXX difference) ..
for j in range(A_indptr[i], A_indptr[i + 1]):
j_idx = A_indices[j]
grad[j_idx] += grad_i * A_data[j] / n_samples
return grad
@utils.njit(nogil=True)
def _svrg_epoch(x, x_snapshot, idx, gradient_average, grad_tmp, step_size):
# .. inner iteration ..
for i in idx:
p = 0.0
p_old = 0.0
for j in range(A_indptr[i], A_indptr[i + 1]):
j_idx = A_indices[j]
p += x[j_idx] * A_data[j]
p_old += x_snapshot[j_idx] * A_data[j]
grad_i = f_deriv(np.array([p]), np.array([b[i]]))[0]
old_grad_i = f_deriv(np.array([p_old]), np.array([b[i]]))[0]
for j in range(A_indptr[i], A_indptr[i + 1]):
j_idx = A_indices[j]
grad_tmp[j_idx] = (grad_i - old_grad_i) * A_data[j]
# .. update coefficients ..
# .. first iterate on blocks ..
for h_j in range(bs_indptr[i], bs_indptr[i + 1]):
h = bs_indices[h_j]
# .. then iterate on features inside block ..
for b_j in range(blocks_indptr[h], blocks_indptr[h + 1]):
bias_term = d[h] * (gradient_average[b_j] + alpha * x[b_j])
x[b_j] -= step_size * (grad_tmp[b_j] + bias_term)
prox(x, i, bs_indices, bs_indptr, d, step_size)
idx = np.arange(n_samples)
grad_tmp = np.zeros(n_features)
success = False
if callback is not None:
callback(locals())
for it in range(max_iter):
x_snapshot = x.copy()
gradient_average = full_grad(x_snapshot)
np.random.shuffle(idx)
_svrg_epoch(x, x_snapshot, idx, gradient_average, grad_tmp, step_size)
if callback is not None:
callback(locals())
if np.abs(x - x_snapshot).sum() < tol:
success = True
break
message = ""
return optimize.OptimizeResult(x=x,
success=success,
nit=it,
message=message)
def identity(self, size):
"""Return an identity matrix.
"""
return sp.eye(size, size, format="csc")
def solve(self, problem):
"""
Solves optimization problem.
Parameters
----------
problem : Object
"""
# Local vars
norm2 = self.norm2
norminf = self.norminf
parameters = self.parameters
# Parameters
tol = parameters['tol']
maxiter = parameters['maxiter']
quiet = parameters['quiet']
sigma = parameters['sigma']
eps = parameters['eps']
eps_cold = parameters['eps_cold']
# Problem
if not isinstance(problem, QuadProblem):
problem = cast_problem(problem)
quad_problem = QuadProblem(None,
None,
None,
None,
None,
None,
problem=problem)
else:
quad_problem = problem
self.problem = problem
self.quad_problem = quad_problem
# Linsolver
self.linsolver = new_linsolver(parameters['linsolver'], 'symmetric')
# Reset
self.reset()
# Checks
if not np.all(problem.l <= problem.u):
raise OptSolverError_NoInterior(self)
# Data
self.H = quad_problem.H
self.g = quad_problem.g
self.A = quad_problem.A
self.AT = quad_problem.A.T
self.b = quad_problem.b
self.l = quad_problem.l
self.u = quad_problem.u
self.n = quad_problem.H.shape[0]
self.m = quad_problem.A.shape[0]
self.e = np.ones(self.n)
self.I = eye(self.n, format='coo')
self.Onm = coo_matrix((self.n, self.m))
self.Omm = coo_matrix((self.m, self.m))
# Make interior
d = np.abs(self.u - self.l)
self.l = self.l - 1e-2 * tol * d - 1e-8
self.u = self.u + 1e-2 * tol * d + 1e-8
# Initial primal
if quad_problem.x is None:
self.x = (self.u + self.l) / 2.
else:
dul = eps * (self.u - self.l)
self.x = np.maximum(np.minimum(quad_problem.x, self.u - dul),
self.l + dul)
# Initial duals
if quad_problem.lam is None:
self.lam = np.zeros(self.m)
else:
self.lam = quad_problem.lam.copy()
if quad_problem.mu is None:
self.mu = np.ones(self.x.size) * eps_cold
else:
self.mu = np.maximum(quad_problem.mu, eps)
if quad_problem.pi is None:
self.pi = np.ones(self.x.size) * eps_cold
else:
self.pi = np.maximum(quad_problem.pi, eps)
# Check interior
try:
assert (np.all(self.l < self.x))
assert (np.all(self.x < self.u))
assert (np.all(self.mu > 0))
assert (np.all(self.pi > 0))
except AssertionError:
raise OptSolverError_Infeasibility(self)
# Init vector
self.y = np.hstack((self.x, self.lam, self.mu, self.pi))
# Complementarity measures
self.eta_mu = np.dot(self.mu, self.u - self.x) / self.x.size
self.eta_pi = np.dot(self.pi, self.x - self.l) / self.x.size
# Objective scaling
fdata = self.func(self.y)
self.obj_sca = np.maximum(norminf(self.g + self.H * self.x) / 10., 1.)
self.H = self.H / self.obj_sca
self.g = self.g / self.obj_sca
fdata = self.func(self.y)
# Header
if not quiet:
print('\nSolver: IQP')
print('-----------')
# Outer
s = 0.
self.k = 0
while True:
# Complementarity measures
self.eta_mu = np.dot(self.mu, self.u - self.x) / self.x.size
self.eta_pi = np.dot(self.pi, self.x - self.l) / self.x.size
# Init eval
fdata = self.func(self.y)
fmax = norminf(fdata.f)
gmax = norminf(fdata.GradF)
# Done
if fmax < tol and sigma * np.maximum(self.eta_mu,
self.eta_pi) < tol:
self.set_status(self.STATUS_SOLVED)
self.set_error_msg('')
return
# Target
tau = sigma * norminf(fdata.GradF)
# Header
if not quiet:
if self.k > 0:
print('')
print('{0:^3s}'.format('iter'), end=' ')
print('{0:^9s}'.format('phi'), end=' ')
print('{0:^9s}'.format('fmax'), end=' ')
print('{0:^9s}'.format('gmax'), end=' ')
print('{0:^8s}'.format('cu'), end=' ')
print('{0:^8s}'.format('cl'), end=' ')
print('{0:^8s}'.format('s'))
# Inner
while True:
# Eval
fdata = self.func(self.y)
fmax = norminf(fdata.f)
gmax = norminf(fdata.GradF)
compu = norminf(self.mu * (self.u - self.x))
compl = norminf(self.pi * (self.x - self.l))
phi = (0.5 * np.dot(self.x, self.H * self.x) +
np.dot(self.g, self.x)) * self.obj_sca
# Show progress
if not quiet:
print('{0:^3d}'.format(self.k), end=' ')
print('{0:^9.2e}'.format(phi), end=' ')
print('{0:^9.2e}'.format(fmax), end=' ')
print('{0:^9.2e}'.format(gmax), end=' ')
print('{0:^8.1e}'.format(compu), end=' ')
print('{0:^8.1e}'.format(compl), end=' ')
print('{0:^8.1e}'.format(s))
# Done
if gmax < tau:
break
# Done
if fmax < tol and np.maximum(compu, compl) < tol:
break
# Maxiters
if self.k >= maxiter:
raise OptSolverError_MaxIters(self)
# Search direction
ux = self.u - self.x
xl = self.x - self.l
D1 = spdiags(self.mu / ux, 0, self.n, self.n, format='coo')
D2 = spdiags(self.pi / xl, 0, self.n, self.n, format='coo')
fbar = np.hstack(
(-fdata.rd + fdata.ru / ux - fdata.rl / xl, fdata.rp))
if self.A.shape[0] > 0:
Jbar = bmat(
[[tril(self.H) + D1 + D2, None], [-self.A, self.Omm]],
format='coo')
else:
Jbar = bmat([[tril(self.H) + D1 + D2]], format='coo')
try:
if not self.linsolver.is_analyzed():
self.linsolver.analyze(Jbar)
pbar = self.linsolver.factorize_and_solve(Jbar, fbar)
except RuntimeError:
raise OptSolverError_BadLinSystem(self)
px = pbar[:self.n]
pmu = (-fdata.ru + self.mu * px) / ux
ppi = (-fdata.rl - self.pi * px) / xl
p = np.hstack((pbar, pmu, ppi))
# Steplength bounds
indices = px > 0
s1 = np.min(
np.hstack(
((1. - eps) * (self.u - self.x)[indices] / px[indices],
np.inf)))
indices = px < 0
s2 = np.min(
np.hstack(
((eps - 1.) * (self.x - self.l)[indices] / px[indices],
np.inf)))
indices = pmu < 0
s3 = np.min(
np.hstack(((eps - 1.) * self.mu[indices] / pmu[indices],
np.inf)))
indices = ppi < 0
s4 = np.min(
np.hstack(((eps - 1.) * self.pi[indices] / ppi[indices],
np.inf)))
smax = np.min([s1, s2, s3, s4])
# Line search
s, fdata = self.line_search(self.y, p, fdata.F, fdata.GradF,
self.func, smax)
# Update x
self.y += s * p
self.k += 1
self.x, self.lam, self.mu, self.pi = self.extract_components(
self.y)
# Check
try:
assert (np.all(self.x < self.u))
assert (np.all(self.x > self.l))
assert (np.all(self.mu > 0))
assert (np.all(self.pi > 0))
except AssertionError:
raise OptSolverError_Infeasibility(self)
def minimize_saga(
f_deriv,
A,
b,
x0,
step_size,
prox=None,
alpha=0,
max_iter=500,
tol=1e-6,
verbose=1,
callback=None,
):
r"""Stochastic average gradient augmented (SAGA) algorithm.
This algorithm can solve linearly-parametrized loss functions of the form
minimize_x \sum_{i}^n_samples f(A_i^T x, b_i) + alpha ||x||_2^2 + g(x)
where g is a function for which we have access to its proximal operator.
.. warning::
This function is experimental, API is likely to change.
Args:
f
loss functions.
x0: np.ndarray or None, optional
Starting point for optimization.
step_size: float or None, optional
Step size for the optimization. If None is given, this will be
estimated from the function f.
max_iter: int
Maximum number of passes through the data in the optimization.
tol: float
Tolerance criterion. The algorithm will stop whenever the norm of the
gradient mapping (generalization of the gradient for nonsmooth
optimization) is below tol.
verbose: bool
Verbosity level. True might print some messages.
trace: bool
Whether to trace convergence of the function, useful for plotting
and/or debugging. If ye, the result will have extra members trace_func,
trace_time.
Returns:
opt: OptimizeResult
The optimization result represented as a
``scipy.optimize.OptimizeResult`` object. Important attributes are:
``x`` the solution array, ``success`` a Boolean flag indicating if
the optimizer exited successfully and ``message`` which describes
the cause of the termination. See `scipy.optimize.OptimizeResult`
for a description of other attributes.
References:
This variant of the SAGA algorithm is described in:
`"Breaking the Nonsmooth Barrier: A Scalable Parallel Method for Composite
Optimization."
<https://arxiv.org/pdf/1707.06468.pdf>`_, Fabian Pedregosa, Remi Leblond,
and Simon Lacoste-Julien. Advances in Neural Information Processing Systems
(NIPS) 2017.
"""
# convert any input to CSR sparse matrix representation. In the future we
# might want to implement also a version for dense data (numpy arrays) to
# better exploit data locality
x = np.ascontiguousarray(x0).copy()
n_samples, n_features = A.shape
A = sparse.csr_matrix(A)
if step_size is None:
# then need to use line search
raise ValueError
if hasattr(prox, "__len__") and len(prox) == 2:
blocks = prox[1]
prox = prox[0]
else:
blocks = sparse.eye(n_features, n_features, format="csr")
if prox is None:
@utils.njit
def prox(x, i, indices, indptr, d, step_size):
pass
A_data = A.data
A_indices = A.indices
A_indptr = A.indptr
n_samples, n_features = A.shape
rblocks_indices = blocks.T.tocsr().indices
blocks_indptr = blocks.indptr
bs_data, bs_indices, bs_indptr = _support_matrix(A_indices, A_indptr,
rblocks_indices,
blocks.shape[0])
csr_blocks_1 = sparse.csr_matrix((bs_data, bs_indices, bs_indptr))
# .. diagonal reweighting ..
d = np.array(csr_blocks_1.sum(0), dtype=np.float).ravel()
idx = d != 0
d[idx] = n_samples / d[idx]
d[~idx] = 1
@utils.njit(nogil=True)
def _saga_epoch(x, idx, memory_gradient, gradient_average, grad_tmp,
step_size):
# .. inner iteration of the SAGA algorithm..
for i in idx:
# .. gradient estimate ..
p = 0.0
for j in range(A_indptr[i], A_indptr[i + 1]):
j_idx = A_indices[j]
p += x[j_idx] * A_data[j]
grad_i = f_deriv(np.array([p]), np.array([b[i]]))[0]
for j in range(A_indptr[i], A_indptr[i + 1]):
j_idx = A_indices[j]
grad_tmp[j_idx] = (grad_i - memory_gradient[i]) * A_data[j]
# .. update coefficients ..
# .. first iterate on blocks ..
for h_j in range(bs_indptr[i], bs_indptr[i + 1]):
h = bs_indices[h_j]
# .. then iterate on features inside block ..
for b_j in range(blocks_indptr[h], blocks_indptr[h + 1]):
bias_term = d[h] * (gradient_average[b_j] + alpha * x[b_j])
x[b_j] -= step_size * (grad_tmp[b_j] + bias_term)
prox(x, i, bs_indices, bs_indptr, d, step_size)
# .. update memory terms ..
for j in range(A_indptr[i], A_indptr[i + 1]):
j_idx = A_indices[j]
tmp = (grad_i - memory_gradient[i]) * A_data[j]
tmp /= n_samples
gradient_average[j_idx] += tmp
grad_tmp[j_idx] = 0
memory_gradient[i] = grad_i
# .. initialize memory terms ..
memory_gradient = np.zeros(n_samples)
gradient_average = np.zeros(n_features)
grad_tmp = np.zeros(n_features)
idx = np.arange(n_samples)
success = False
if callback is not None:
callback(locals())
for it in range(max_iter):
x_old = x.copy()
np.random.shuffle(idx)
_saga_epoch(x, idx, memory_gradient, gradient_average, grad_tmp,
step_size)
if callback is not None:
callback(locals())
diff_norm = np.abs(x - x_old).sum()
if diff_norm < tol:
success = True
break
return optimize.OptimizeResult(x=x, success=success, nit=it)
def my_graph_multiresolution(G, levels, r=0.5, sparsify=True, sparsify_eps=None,
downsampling_method='largest_eigenvector',
reduction_method='kron', compute_full_eigen=False,
reg_eps=0.005):
r"""Compute a pyramid of graphs (by Kron reduction).
'graph_multiresolution(G,levels)' computes a multiresolution of
graph by repeatedly downsampling and performing graph reduction. The
default downsampling method is the largest eigenvector method based on
the polarity of the components of the eigenvector associated with the
largest graph Laplacian eigenvalue. The default graph reduction method
is Kron reduction followed by a graph sparsification step.
*param* is a structure of optional parameters.
Parameters
----------
G : Graph structure
The graph to reduce.
levels : int
Number of level of decomposition
lambd : float
Stability parameter. It adds self loop to the graph to give the
algorithm some stability (default = 0.025). [UNUSED?!]
sparsify : bool
To perform a spectral sparsification step immediately after
the graph reduction (default is True).
sparsify_eps : float
Parameter epsilon used in the spectral sparsification
(default is min(10/sqrt(G.N),.3)).
downsampling_method: string
The graph downsampling method (default is 'largest_eigenvector').
reduction_method : string
The graph reduction method (default is 'kron')
compute_full_eigen : bool
To also compute the graph Laplacian eigenvalues and eigenvectors
for every graph in the multiresolution sequence (default is False).
reg_eps : float
The regularized graph Laplacian is :math:`\bar{L}=L+\epsilon I`.
A smaller epsilon may lead to better regularization, but will also
require a higher order Chebyshev approximation. (default is 0.005)
Returns
-------
Gs : list
A list of graph layers.
Examples
--------
>>> from pygsp import reduction
>>> levels = 5
>>> G = graphs.Sensor(N=512)
>>> G.compute_fourier_basis()
>>> Gs = reduction.graph_multiresolution(G, levels, sparsify=False)
>>> for idx in range(levels):
... Gs[idx].plotting['plot_name'] = 'Reduction level: {}'.format(idx)
... Gs[idx].plot()
"""
if sparsify_eps is None:
sparsify_eps = min(10. / np.sqrt(G.N), 0.3)
if compute_full_eigen:
G.compute_fourier_basis()
else:
G.estimate_lmax()
Gs = [G]
Gs[0].mr = {'idx': np.arange(G.N), 'orig_idx': np.arange(G.N)}
n_target = int(np.floor(G.N * (1-r)))
for i in range(levels):
if downsampling_method == 'largest_eigenvector':
if hasattr(Gs[i], '_U'):
V = Gs[i].U[:, -1]
else:
V = sp.sparse.linalg.eigs(Gs[i].L, 1)[1][:, 0]
V *= np.sign(V[0])
n = max(int(Gs[i].N/2), n_target)
ind = np.argsort(V) # np.nonzero(V >= 0)[0]
ind = np.flip(ind,0)
ind = ind[:n]
else:
raise NotImplementedError('Unknown graph downsampling method.')
if reduction_method == 'kron':
Gs.append(reduction.kron_reduction(Gs[i], ind))
else:
raise NotImplementedError('Unknown graph reduction method.')
if sparsify and Gs[i+1].N > 2:
Gs[i+1] = reduction.graph_sparsify(Gs[i+1], min(max(sparsify_eps, 2. / np.sqrt(Gs[i+1].N)), 1.))
if Gs[i+1].is_directed():
W = (Gs[i+1].W + Gs[i+1].W.T)/2
Gs[i+1] = graphs.Graph(W, coords=Gs[i+1].coords)
if compute_full_eigen:
Gs[i+1].compute_fourier_basis()
else:
Gs[i+1].estimate_lmax()
Gs[i+1].mr = {'idx': ind, 'orig_idx': Gs[i].mr['orig_idx'][ind], 'level': i}
L_reg = Gs[i].L + reg_eps * sparse.eye(Gs[i].N)
Gs[i].mr['K_reg'] = reduction.kron_reduction(L_reg, ind)
Gs[i].mr['green_kernel'] = filters.Filter(Gs[i], lambda x: 1./(reg_eps + x))
return Gs
def fit(self, biadjacency):
"""Embedding of bipartite graphs from a clustering obtained with Louvain.
Parameters
----------
biadjacency:
Biadjacency matrix of the graph.
Returns
-------
self: :class:`BiLouvainEmbedding`
"""
bilouvain = BiLouvain(resolution=self.resolution,
modularity=self.modularity,
tol_optimization=self.tol_optimization,
tol_aggregation=self.tol_aggregation,
n_aggregations=self.n_aggregations,
shuffle_nodes=self.shuffle_nodes,
sort_clusters=True,
return_membership=True,
return_aggregate=True,
random_state=self.random_state)
bilouvain.fit(biadjacency)
self.labels_ = bilouvain.labels_
embedding_row = bilouvain.membership_row_
embedding_col = bilouvain.membership_col_
if self.merge_isolated:
_, counts_row = np.unique(bilouvain.labels_row_,
return_counts=True)
n_clusters_row = embedding_row.shape[1]
n_isolated_nodes_row = (counts_row == 1).sum()
if n_isolated_nodes_row:
n_remaining_row = n_clusters_row - n_isolated_nodes_row
indptr_row = np.zeros(n_remaining_row + 2, dtype=int)
indptr_row[-1] = n_isolated_nodes_row
combiner_row = sparse.vstack([
sparse.eye(n_remaining_row,
n_remaining_row + 1,
format='csr'),
sparse.csr_matrix((np.ones(n_isolated_nodes_row,
dtype=int),
np.full(n_isolated_nodes_row,
n_remaining_row,
dtype=int),
np.arange(n_isolated_nodes_row + 1,
dtype=int)))
])
embedding_row = embedding_row.dot(combiner_row)
self.labels_[n_remaining_row +
1:] = self.labels_[n_remaining_row + 1]
_, counts_col = np.unique(bilouvain.labels_col_,
return_counts=True)
n_clusters_col = embedding_col.shape[1]
n_isolated_nodes_col = (counts_col == 1).sum()
if n_isolated_nodes_col:
n_remaining_col = n_clusters_col - n_isolated_nodes_col
indptr_col = np.zeros(n_remaining_col + 2, dtype=int)
indptr_col[-1] = n_isolated_nodes_col
combiner_col = sparse.vstack([
sparse.eye(n_remaining_col,
n_remaining_col + 1,
format='csr'),
sparse.csr_matrix((np.ones(n_isolated_nodes_col,
dtype=int),
np.full(n_isolated_nodes_col,
n_remaining_col,
dtype=int),
np.arange(n_isolated_nodes_col + 1,
dtype=int)))
])
embedding_col = embedding_col.dot(combiner_col)
self.embedding_row_ = embedding_row
self.embedding_col_ = embedding_col
self.embedding_ = self.embedding_row_
return self
def fit(self,
train,
userGraph=None,
itemGraph=None,
method="random",
U0=None,
V0=None):
"""
Learn factors from training set.
User and item factors are fitted alternately.
train : array-like of three columns
contains row index, column index, value of not null entries
rowGraph : array-like of three columns
contains the first two columns are the index of the linked rows,
the third is the weight of the link
colGraph : same as rowGraph for the column links
method : string
factor initialisation. Can be random, svd or given in U0 and V0
U0, V0: array-like
initial value for U and V. If not None, method is ignored
"""
if self.seed is not None:
np.random.seed(self.seed)
self.userGraph = False
self.itemGraph = False
self.train = sparse_matrix(train, n=self.num_users, p=self.num_items)
self.n_u = list(
map(lambda u: self.train[u, :].nnz, range(self.num_users)))
self.n_i = list(
map(lambda i: self.train[:, i].nnz, range(self.num_items)))
if userGraph is not None:
self.userGraph = True
self.A_user = sparse.csgraph.laplacian(
sparse_matrix(userGraph,
n=self.num_users,
p=self.num_users,
w=(1 - self.mu) / self.mu))
if self.reg == "weighted":
self.A_user += sparse.diags(self.n_u)
elif self.reg == "default":
self.A_user += sparse.eye(self.num_users)
#self.A_user_sqrt = kron(sqrtm(self.A_user.todense()).real,sparse.eye(self.d))
self.A_user = kron(self.A_user, sparse.eye(self.d))
else:
if self.reg == "weighted":
self.A_user = sparse.diags(self.n_u)
elif self.reg == "default":
self.A_user = sparse.eye(self.num_users)
self.A_user = kron(self.A_user, sparse.eye(self.d))
if itemGraph is not None:
self.itemGraph = True
self.A_item = sparse.csgraph.laplacian(
sparse_matrix(itemGraph,
n=self.num_items,
p=self.num_items,
w=(1 - self.mu) / self.mu))
if self.reg == "weighted":
self.A_item += sparse.diags(self.n_i)
elif self.reg == "default":
self.A_item += sparse.eye(self.num_items)
#self.A_item_sqrt = kron(sqrtm(self.A_item.todense()).real,sparse.eye(self.d))
self.A_item = kron(self.A_item, sparse.eye(self.d))
else:
if self.reg == "weighted":
self.A_item = sparse.diags(self.n_i)
elif self.reg == "default":
self.A_item = sparse.eye(self.num_items)
self.A_item = kron(self.A_item, sparse.eye(self.d))
self.U = np.random.normal(size=(self.num_users, self.d))
self.V = np.random.normal(size=(self.num_items, self.d))
for it in range(self.num_iters):
if self.userGraph:
self.U = self.user_iteration()
else:
for u in range(self.num_users):
indices = self.train[u].nonzero()[1]
if indices.size:
R_u = self.train[u, indices]
self.U[u, :] = self.update(indices, self.V,
R_u.toarray().T)
else:
self.U[u, :] = np.zeros(self.d)
if self.itemGraph:
self.V = self.item_iteration()
else:
for i in range(self.num_items):
indices = self.train[:, i].nonzero()[0]
if indices.size:
R_i = self.train[indices, i]
self.V[i, :] = self.update(indices, self.U,
R_i.toarray())
else:
self.V[i, :] = np.zeros(self.d)
if self.verbose:
print("end iteration " + str(it + 1))
# Simple case
test_solve_KKT_n = 3
test_solve_KKT_m = 4
test_solve_KKT_P = sparse.random(test_solve_KKT_n, test_solve_KKT_n,
density=0.4, format='csc')
test_solve_KKT_P = test_solve_KKT_P.dot(test_solve_KKT_P.T).tocsc()
test_solve_KKT_A = sparse.random(test_solve_KKT_m, test_solve_KKT_n,
density=0.4, format='csc')
test_solve_KKT_Pu = sparse.triu(test_solve_KKT_P, format='csc')
test_solve_KKT_rho = 4.0
test_solve_KKT_sigma = 1.0
test_solve_KKT_KKT = sparse.vstack([
sparse.hstack([test_solve_KKT_P + test_solve_KKT_sigma *
sparse.eye(test_solve_KKT_n), test_solve_KKT_A.T]),
sparse.hstack([test_solve_KKT_A,
-1./test_solve_KKT_rho * sparse.eye(test_solve_KKT_m)])
], format='csc')
test_solve_KKT_rhs = np.random.randn(test_solve_KKT_m + test_solve_KKT_n)
test_solve_KKT_x = spla.splu(test_solve_KKT_KKT).solve(test_solve_KKT_rhs)
test_solve_KKT_x[test_solve_KKT_n:] = test_solve_KKT_rhs[test_solve_KKT_n:] + \
test_solve_KKT_x[test_solve_KKT_n:] / test_solve_KKT_rho
# Generate test data and solutions
data = {'test_solve_KKT_n': test_solve_KKT_n,
'test_solve_KKT_m': test_solve_KKT_m,
'test_solve_KKT_A': test_solve_KKT_A,
'test_solve_KKT_Pu': test_solve_KKT_Pu,
'test_solve_KKT_rho': test_solve_KKT_rho,
def _map_variables(self, x: np.ndarray) -> None:
"""
Map variables from old to new grids in d[pp.STATE] and d[pp.STATE][pp.ITERATE].
Also call update of self.assembler.update_dof_count and update the current
solution vector accordingly.
Newly created DOFs are assigned values by _initialize_new_variable_values,
which for now returns zeros, but can be tailored for specific variables
etc.
Parameters
------
x: np.ndarray
Solution vector, or other vector to be mapped.
Raises
------
NotImplementedError
DESCRIPTION.
Returns
-------
None.
"""
# Obtain old solution vector. The values are extracted in the first two loops
# and mapped and updated in the last two, after update_dof_count has been called.
for g, d in self.gb:
# First check if cells and faces have been updated, by checking if index maps are
# available. If this is not the case, there is no need to map variables.
if not ("cell_index_map" in d and "face_index_map" in d):
continue
cell_map: sps.spmatrix = d["cell_index_map"]
d[pp.STATE]["old_solution"] = {}
for var, dofs in d[pp.PRIMARY_VARIABLES].items():
# Copy old solution vector values
d[pp.STATE]["old_solution"][var] = x[self.assembler.dof_ind(
g, var)]
# Only cell-based dofs have been considered so far.
# It should not be difficult to handle other types of variables,
# but the need has not been there.
face_dof: int = dofs.get("faces", 0)
node_dof: int = dofs.get("nodes", 0)
if face_dof != 0 or node_dof != 0:
raise NotImplementedError(
"Have only implemented variable mapping for face dofs")
cell_dof: int = dofs.get("cells")
# Map old solution
mapping = sps.kron(cell_map, sps.eye(cell_dof))
d[pp.STATE][var] = mapping * d[pp.STATE][var]
# Initialize new values
new_ind = self._new_dof_inds(mapping)
new_vals = self._initialize_new_variable_values(
g, d, var, dofs)
d[pp.STATE][var][new_ind] = new_vals
# Repeat for iterate:
if var in d[pp.STATE][pp.ITERATE].keys():
d[pp.STATE][pp.ITERATE][var] = (
mapping * d[pp.STATE][pp.ITERATE][var])
d[pp.STATE][pp.ITERATE][var][new_ind] = new_vals
for e, d in self.gb.edges():
# Check if the mortar grid geometry has been updated.
if "cell_index_map" not in d:
# No need to do anything
continue
d[pp.STATE]["old_solution"] = {}
cell_map = d["cell_index_map"]
for var, dofs in d[pp.PRIMARY_VARIABLES].items():
# Copy old solution vector values
d[pp.STATE]["old_solution"][var] = x[self.assembler.dof_ind(
e, var)]
# Only cell-based dofs have been considered so far.
cell_dof = dofs.get("cells")
# Map old solution
mapping = sps.kron(cell_map, sps.eye(cell_dof))
d[pp.STATE][var] = mapping * d[pp.STATE][var]
# Initialize new values
new_ind = self._new_dof_inds(mapping)
new_vals = self._initialize_new_variable_values(
e, d, var, dofs)
d[pp.STATE][var][new_ind] = new_vals
# Repeat for iterate
if var in d[pp.STATE][pp.ITERATE].keys():
d[pp.STATE][pp.ITERATE][var] = (
mapping * d[pp.STATE][pp.ITERATE][var])
d[pp.STATE][pp.ITERATE][var][new_ind] = new_vals
# Update the assembler's counting of dofs
self.assembler.update_dof_count()
x_new = np.zeros(self.assembler.num_dof())
# For each grid-variable pair, map old solution and initialize for new
# DOFs.
for g, d in self.gb:
# Check if there has been updates to this grid.
if not ("cell_index_map" in d and "face_index_map" in d):
continue
cell_map = d["cell_index_map"]
for var, dofs in d[pp.PRIMARY_VARIABLES].items():
# Update consist of two parts: First map the old solution to the new
# grid, second populate newly formed cells.
# Mapping of old variables
cell_dof = dofs.get("cells")
mapping = sps.kron(cell_map, sps.eye(cell_dof))
x_new[self.assembler.dof_ind(
g, var)] = (mapping * d[pp.STATE]["old_solution"][var])
# Index of newly formed variables
new_ind = self._new_dof_inds(mapping)
# Values of newly formed variables
new_vals = self._initialize_new_variable_values(
g, d, var, dofs)
# Update newly formed variables
x_new[self.assembler.dof_ind(g, var)[new_ind]] = new_vals
for e, d in self.gb.edges():
# Same procedure as for nodes, see above for comments
if "cell_index_map" not in d:
continue
cell_map = d["cell_index_map"]
for var, dofs in d[pp.PRIMARY_VARIABLES].items():
cell_dof = dofs.get("cells")
mapping = sps.kron(cell_map, sps.eye(cell_dof))
x_new[self.assembler.dof_ind(
e, var)] = (mapping * d[pp.STATE]["old_solution"][var])
new_ind = self._new_dof_inds(mapping)
new_vals = self._initialize_new_variable_values(
e, d, var, dofs)
x_new[self.assembler.dof_ind(e, var)[new_ind]] = new_vals
# Store the mapped solution vector
return x_new
def normalized_laplacian(A):
d = degree(A).data
e = d ** -0.5
L = sps.eye(len(d)) - e.T * A * e # TODO
return L
features_dim = feat.shape[1]
size_update = int(feat.shape[0] * size_update_ratio)
print("size_update: {}".format(size_update))
# Store original adjacency matrix (without diagonal entries) for later
adj_orig = adj
adj_orig = adj_orig - sp.dia_matrix(
(adj_orig.diagonal()[np.newaxis, :], [0]), shape=adj_orig.shape)
adj_orig.eliminate_zeros()
adj_train, train_edges, val_edges, val_edges_false, test_edges, test_edges_false = mask_test_edges(
adj)
adj = adj_train
adj_label = adj_train + sp.eye(adj_train.shape[0])
adj_norm = torch.from_numpy(preprocess_graph(adj))
adj_label = torch.from_numpy(adj_label.todense().astype(np.float32))
feat = torch.from_numpy(feat.todense().astype(np.float32))
############## init model ##############
gcn_vae = GraphVae(features_dim, hidden_dim, out_dim, bias=False, dropout=0.0)
optimizer_vae = torch.optim.Adam(gcn_vae.parameters(), lr=1e-3)
gcn_step = RecursiveGraphConvolutionStepAddOn(features_dim,
hidden_dim,
out_dim,
dropout=0.0)
optimizer = torch.optim.Adam(gcn_step.parameters(),
lr=1e-3,
u0 = 10.5916
umin = np.array([9.6, 9.6, 9.6, 9.6]) - u0
umax = np.array([13., 13., 13., 13.]) - u0
xmin = np.array([
-np.pi / 6, -np.pi / 6, -np.inf, -np.inf, -np.inf, -1., -np.inf, -np.inf,
-np.inf, -np.inf, -np.inf, -np.inf
])
xmax = np.array([
np.pi / 6, np.pi / 6, np.inf, np.inf, np.inf, np.inf, np.inf, np.inf,
np.inf, np.inf, np.inf, np.inf
])
# Objective function
Q = sparse.diags([0., 0., 10., 10., 10., 10., 0., 0., 0., 5., 5., 5.])
QN = Q
R = 0.1 * sparse.eye(4)
# Initial and reference states
# x0: initial state
x0 = np.zeros(12)
# xr: reference state
xr = np.array([0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
# Prediction horizon
N = 10
# Cast MPC problem to a QP: x = (x(0),x(1),...,x(N),u(0),...,u(N-1))
# - quadratic objective
P = sparse.block_diag(
[sparse.kron(sparse.eye(N), Q), QN,
sparse.kron(sparse.eye(N), R)],
def preprocess_adj(adj):
"""Preprocessing of adjacency matrix for simple GCN model and conversion to tuple representation."""
adj_normalized = normalize_adj(adj + sp.eye(adj.shape[0]))
return sparse_to_tuple(adj_normalized)
def test_hash():
"""Test dictionary hashing and comparison functions."""
# does hashing all of these types work:
# {dict, list, tuple, ndarray, str, float, int, None}
d0 = dict(a=dict(a=0.1, b='fo', c=1),
b=[1, 'b'],
c=(),
d=np.ones(3),
e=None)
d0[1] = None
d0[2.] = b'123'
d1 = deepcopy(d0)
assert len(object_diff(d0, d1)) == 0
assert len(object_diff(d1, d0)) == 0
assert object_hash(d0) == object_hash(d1)
# change values slightly
d1['data'] = np.ones(3, int)
d1['d'][0] = 0
assert object_hash(d0) != object_hash(d1)
d1 = deepcopy(d0)
assert object_hash(d0) == object_hash(d1)
d1['a']['a'] = 0.11
assert (len(object_diff(d0, d1)) > 0)
assert (len(object_diff(d1, d0)) > 0)
assert object_hash(d0) != object_hash(d1)
d1 = deepcopy(d0)
assert object_hash(d0) == object_hash(d1)
d1['a']['d'] = 0 # non-existent key
assert (len(object_diff(d0, d1)) > 0)
assert (len(object_diff(d1, d0)) > 0)
assert object_hash(d0) != object_hash(d1)
d1 = deepcopy(d0)
assert object_hash(d0) == object_hash(d1)
d1['b'].append(0) # different-length lists
assert (len(object_diff(d0, d1)) > 0)
assert (len(object_diff(d1, d0)) > 0)
assert object_hash(d0) != object_hash(d1)
d1 = deepcopy(d0)
assert object_hash(d0) == object_hash(d1)
d1['e'] = 'foo' # non-None
assert (len(object_diff(d0, d1)) > 0)
assert (len(object_diff(d1, d0)) > 0)
assert object_hash(d0) != object_hash(d1)
d1 = deepcopy(d0)
d2 = deepcopy(d0)
d1['e'] = StringIO()
d2['e'] = StringIO()
d2['e'].write('foo')
assert (len(object_diff(d0, d1)) > 0)
assert (len(object_diff(d1, d0)) > 0)
d1 = deepcopy(d0)
d1[1] = 2
assert (len(object_diff(d0, d1)) > 0)
assert (len(object_diff(d1, d0)) > 0)
assert object_hash(d0) != object_hash(d1)
# generators (and other types) not supported
d1 = deepcopy(d0)
d2 = deepcopy(d0)
d1[1] = (x for x in d0)
d2[1] = (x for x in d0)
pytest.raises(RuntimeError, object_diff, d1, d2)
pytest.raises(RuntimeError, object_hash, d1)
x = sparse.eye(2, 2, format='csc')
y = sparse.eye(2, 2, format='csr')
assert ('type mismatch' in object_diff(x, y))
y = sparse.eye(2, 2, format='csc')
assert len(object_diff(x, y)) == 0
y[1, 1] = 2
assert ('elements' in object_diff(x, y))
y = sparse.eye(3, 3, format='csc')
assert ('shape' in object_diff(x, y))
y = 0
assert ('type mismatch' in object_diff(x, y))
# smoke test for gh-4796
assert object_hash(np.int64(1)) != 0
assert object_hash(np.bool_(True)) != 0
def train(self, data):
num_nodes = data.x.shape[0]
features = preprocess_features(data.x.cpu().numpy())
features = torch.FloatTensor(features).unsqueeze(0).to(self.device)
adj = sp.coo_matrix(
(np.ones(data.edge_index.shape[1]), data.edge_index.cpu()),
(num_nodes, num_nodes),
)
adj = normalize_adj(adj + sp.eye(adj.shape[0]))
sp_adj = sparse_mx_to_torch_sparse_tensor(adj)
sp_adj = sp_adj.to(self.device)
best = 1e9
cnt_wait = 0
b_xent = nn.BCEWithLogitsLoss()
optimizer = torch.optim.Adam(self.model.parameters(),
lr=0.001,
weight_decay=0.0)
epoch_iter = tqdm(range(self.epochs))
for epoch in epoch_iter:
self.model.train()
optimizer.zero_grad()
idx = np.random.permutation(num_nodes)
shuf_fts = features[:, idx, :]
lbl_1 = torch.ones(1, num_nodes)
lbl_2 = torch.zeros(1, num_nodes)
lbl = torch.cat((lbl_1, lbl_2), 1)
shuf_fts = shuf_fts.to(self.device)
lbl = lbl.to(self.device)
logits = self.model(features, shuf_fts, sp_adj, True, None, None,
None)
loss = b_xent(logits, lbl)
epoch_iter.set_description(
f"Epoch: {epoch:03d}, Loss: {loss.item()}")
if loss < best:
best = loss
cnt_wait = 0
else:
cnt_wait += 1
if cnt_wait == self.patience:
print("Early stopping!")
break
loss.backward()
optimizer.step()
embeds, _ = self.model.embed(features, sp_adj, True, None)
opt = {
"idx_train": data.train_mask,
"idx_val": data.val_mask,
"idx_test": data.test_mask,
"num_classes": self.nclass,
}
result = LogRegTrainer().train(embeds[0], data.y, opt)
return result
connected_packages = max(nx.connected_components(dependencies.to_undirected()),
key=len)
conn_dependencies = nx.subgraph(dependencies, connected_packages)
package_names = np.array(conn_dependencies.nodes()) # array for multi-indexing
adjacency_matrix = nx.to_scipy_sparse_matrix(conn_dependencies,
dtype=np.float64)
n = len(package_names)
np.seterr(divide='ignore') # ignore division-by-zero errors
from scipy import sparse
degrees = np.ravel(adjacency_matrix.sum(axis=1))
degrees_matrix = sparse.spdiags(1 / degrees, 0, n, n, format='csr')
transition_matrix = (degrees_matrix @ adjacency_matrix).T
from scipy.sparse.linalg.isolve import bicg # biconjugate gradient solver
damping = 0.85
I = sparse.eye(n, format='csc')
pagerank, error = bicg(I - damping * transition_matrix,
(1-damping) / n * np.ones(n),
maxiter=int(1e4))
print('error code: ', error)
top = np.argsort(pagerank)[::-1]
print([package_names[i] for i in top[:40]])
def power(trans, damping=0.85, max_iter=int(1e5)):
n = trans.shape[0]
r0 = np.full(n, 1/n)
r = r0
for _ in range(max_iter):
rnext = damping * trans @ r + (1 - damping) / n
if np.allclose(rnext, r):
print('converged')
def minimize_vrtos(
f_deriv,
A,
b,
x0,
step_size,
prox_1=None,
prox_2=None,
alpha=0,
max_iter=500,
tol=1e-6,
callback=None,
verbose=0,
):
r"""Variance-reduced three operator splitting (VRTOS) algorithm.
The VRTOS algorithm can solve optimization problems of the form
argmin_{x \in R^p} \sum_{i}^n_samples f(A_i^T x, b_i) + alpha *
||x||_2^2 +
+ pen1(x) + pen2(x)
Parameters
----------
f_deriv
derivative of f
x0: np.ndarray or None, optional
Starting point for optimization.
step_size: float or None, optional
Step size for the optimization. If None is given, this will be
estimated from the function f.
n_jobs: int
Number of threads to use in the optimization. A number higher than 1
will use the Asynchronous SAGA optimization method described in
[Pedregosa et al., 2017]
max_iter: int
Maximum number of passes through the data in the optimization.
tol: float
Tolerance criterion. The algorithm will stop whenever the norm of the
gradient mapping (generalization of the gradient for nonsmooth
optimization)
is below tol.
verbose: bool
Verbosity level. True might print some messages.
trace: bool
Whether to trace convergence of the function, useful for plotting and/or
debugging. If ye, the result will have extra members trace_func,
trace_time.
Returns
-------
opt: OptimizeResult
The optimization result represented as a
``scipy.optimize.OptimizeResult`` object. Important attributes are:
``x`` the solution array, ``success`` a Boolean flag indicating if
the optimizer exited successfully and ``message`` which describes
the cause of the termination. See `scipy.optimize.OptimizeResult`
for a description of other attributes.
References
----------
Pedregosa, Fabian, Kilian Fatras, and Mattia Casotto. "Variance Reduced
Three Operator Splitting." arXiv preprint arXiv:1806.07294 (2018).
"""
n_samples, n_features = A.shape
success = False
# FIXME: just a workaround for now
# FIXME: check if prox_1 is a tuple
if hasattr(prox_1, "__len__") and len(prox_1) == 2:
blocks_1 = prox_1[1]
prox_1 = prox_1[0]
else:
blocks_1 = sparse.eye(n_features, n_features, format="csr")
if hasattr(prox_2, "__len__") and len(prox_2) == 2:
blocks_2 = prox_2[1]
prox_2 = prox_2[0]
else:
blocks_2 = sparse.eye(n_features, n_features, format="csr")
Y = np.zeros((2, x0.size))
z = x0.copy()
assert A.shape[0] == b.size
if step_size < 0:
raise ValueError
if prox_1 is None:
@utils.njit
def prox_1(x, i, indices, indptr, d, step_size):
pass
if prox_2 is None:
@utils.njit
def prox_2(x, i, indices, indptr, d, step_size):
pass
A = sparse.csr_matrix(A)
epoch_iteration = _factory_sparse_vrtos(f_deriv, prox_1, prox_2, blocks_1,
blocks_2, A, b, alpha, step_size)
# .. memory terms ..
memory_gradient = np.zeros(n_samples)
gradient_average = np.zeros(n_features)
x1 = x0.copy()
grad_tmp = np.zeros(n_features)
# warm up for the JIT
epoch_iteration(
Y,
x0,
x1,
z,
memory_gradient,
gradient_average,
np.array([0]),
grad_tmp,
step_size,
)
# .. iterate on epochs ..
if callback is not None:
callback(locals())
for it in range(max_iter):
epoch_iteration(
Y,
x0,
x1,
z,
memory_gradient,
gradient_average,
np.random.permutation(n_samples),
grad_tmp,
step_size,
)
certificate = np.linalg.norm(x0 - z) + np.linalg.norm(x1 - z)
if callback is not None:
callback(locals())
return optimize.OptimizeResult(x=z,
success=success,
nit=it,
certificate=certificate)
def preprocess_adj(adj, symmetric=True):
adj = adj + sp.eye(adj.shape[0])
adj = normalize_adj(adj, symmetric)
adj = adj.todense()
return adj
def _rebuild_operators(self):
if self.mesh.x.lbc.type == 'pml' and self.compact:
# build intermediates for the compact operator
raise ValidationFunctionError(
" This solver is in construction and is not yet complete. For variable density and compact PML."
)
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
oc.M = make_diag_mtx(self.model_parameters.C.squeeze()**-2)
# build the static components
if not built:
# build Dxx
oc.Dxx = build_derivative_matrix(
self.mesh,
2,
self.spatial_accuracy_order,
dimension='x',
use_shifted_differences=self.spatial_shifted_differences)
# build Dzz
oc.Dzz = build_derivative_matrix(
self.mesh,
2,
self.spatial_accuracy_order,
dimension='z',
use_shifted_differences=self.spatial_shifted_differences)
# build Dx
oc.Dx = build_derivative_matrix(
self.mesh,
1,
self.spatial_accuracy_order,
dimension='x',
use_shifted_differences=self.spatial_shifted_differences)
# build Dz
oc.Dz = build_derivative_matrix(
self.mesh,
1,
self.spatial_accuracy_order,
dimension='z',
use_shifted_differences=self.spatial_shifted_differences)
# build sigma
oc.sx, oc.sz, oc.sxp, oc.szp = self._sigma_PML(self.mesh)
oc._numpy_components_built = True
else:
# build intermediates for operator with auxiliary fields
dof = self.mesh.dof(include_bc=True)
oc = self.operator_components
built = oc.get('_numpy_components_built', False)
# build the static components
if not built:
# build sigmax
sx = build_sigma(self.mesh, self.mesh.x)
oc.sigmax = make_diag_mtx(sx)
# build sigmaz
sz = build_sigma(self.mesh, self.mesh.z)
oc.sigmaz = make_diag_mtx(sz)
# build Dx
oc.minus_Dx = build_derivative_matrix(
self.mesh,
1,
self.spatial_accuracy_order,
dimension='x',
use_shifted_differences=self.spatial_shifted_differences)
oc.minus_Dx.data *= -1
# build Dz
oc.minus_Dz = build_derivative_matrix(
self.mesh,
1,
self.spatial_accuracy_order,
dimension='z',
use_shifted_differences=self.spatial_shifted_differences)
oc.minus_Dz.data *= -1
# build other useful things
oc.I = spsp.eye(dof, dof)
oc.empty = spsp.csr_matrix((dof, dof))
# useful intermediates
oc.sigma_xz = make_diag_mtx(sx * sz)
oc.sigma_xPz = oc.sigmax + oc.sigmaz
oc.minus_sigma_zMx_Dx = make_diag_mtx((sz - sx)) * oc.minus_Dx
oc.minus_sigma_xMz_Dz = make_diag_mtx((sx - sz)) * oc.minus_Dz
oc._numpy_components_built = True
kappa = self.model_parameters.kappa
rho = self.model_parameters.rho
oc.m1 = make_diag_mtx((kappa**-1).reshape(-1, ))
oc.m2 = make_diag_mtx((rho**-1).reshape(-1, ))
# build heterogenous laplacian
sh = self.mesh.shape(include_bc=True, as_grid=True)
deltas = [self.mesh.x.delta, self.mesh.z.delta]
oc.L = build_derivative_matrix_VDA(self.mesh,
2,
self.spatial_accuracy_order,
alpha=rho**-1)
# oc.L is a heterogenous laplacian operator. It computes div(m2 grad), where m2 = 1/rho.
# Currently the creation of oc.L is slow. This is because we have implemented a cenetered heterogenous laplacian.
# To speed up computation, we could compute a div(m2 grad) operator that is not centered by simply multiplying
# a divergence operator by oc.m2 by a gradient operator.
self.K = spsp.bmat([[
oc.m1 * oc.sigma_xz - oc.L, oc.minus_Dx * oc.m2,
oc.minus_Dz * oc.m2
], [oc.minus_sigma_zMx_Dx, oc.sigmax, oc.empty],
[oc.minus_sigma_xMz_Dz, oc.empty, oc.sigmaz]])
self.C = spsp.bmat([[oc.m1 * oc.sigma_xPz, oc.empty, oc.empty],
[oc.empty, oc.I, oc.empty],
[oc.empty, oc.empty, oc.I]])
self.M = spsp.bmat([[oc.m1, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty],
[oc.empty, oc.empty, oc.empty]])
def load_data(
directory: str,
dataset: str,
verbose: bool = False) -> Tuple['torch.Tensor', # adjacency matrix
'torch.Tensor', # features matrix
'torch.Tensor', # labels
'torch.Tensor', # train index
'torch.Tensor', # validation index
'torch.Tensor', # test index
]:
"""Loads data from a dataset
Args:
directory: directory with all datasets to laod
dataset: dataset to load. (cora, citeseer, pubmed)
verbose: if True, prints loading information. Default is False.
Returns:
Tuple of data information of format (adjacency, features, labels
train_index, validation_index, test_index)
"""
datadir = pathlib.Path(directory)
if not datadir.is_dir():
raise FileNotFoundError(directory)
if verbose:
print(f'Loading {datadir} dataset')
names = ['x', 'y', 'tx', 'ty', 'allx', 'ally', 'graph']
x, y, tx, ty, allx, ally, graph = map(
lambda name: load_file(datadir.joinpath(f'ind.{dataset}.{name}')),
names)
index = [
int(line.strip()) for line in datadir.joinpath(
f'ind.{dataset}.test.index').open().readlines()
]
index_sorted = np.sort(index)
if dataset == 'citeseer':
if verbose:
print('Adding test data for citeseer unlabeled test nodes')
index_range = range(index_sorted[0], index_sorted[-1] + 1)
tx_extended = sp.lil_matrix((len(index_range), x.shape[1]))
tx_extended[index_sorted - index_sorted[0], :] = tx
tx = tx_extended
ty_extended = np.zeros((len(index_range), y.shape[1]))
ty_extended[index_sorted - index_sorted[0], :] = ty
ty = ty_extended
if dataset == 'nell.0.001' or dataset == 'nell.0.01':
index_range = range(allx.shape[0], len(graph))
isolated_node_idx = np.setdiff1d(index_range, index)
tx_extended = sp.lil_matrix((len(index_range), x.shape[1]))
tx_extended[index_sorted - index_sorted[0], :] = tx
tx = tx_extended
ty_extended = np.zeros((len(index_range), y.shape[1]))
ty_extended[index_sorted - allx.shape[0], :] = ty
ty = ty_extended
features = sp.vstack((allx, tx)).tolil()
features[index, :] = features[index_sorted, :]
features_file = dataset + ".features.npz"
features_path = pathlib.Path("data", features_file)
if features_path.is_file():
features = load_csr_matrix(features_path)
else:
if verbose:
print(
"features.npz not found. Creating feature vectors for node relations."
)
features_extended = sp.hstack(
(features,
sp.lil_matrix((features.shape[0], len(isolated_node_idx)))),
dtype=np.int32).todense()
features_extended[isolated_node_idx, features.shape[1]:] = np.eye(
len(isolated_node_idx))
features = sp.csr_matrix(features_extended).astype(np.float16)
if verbose:
print("Saving features.npz")
save_csr_matrix(features_path, features)
features = normalize(features)
features = sparse_mx_to_torch(features)
else:
# Process features
features = sp.vstack((allx, tx)).tolil()
features[index, :] = features[index_sorted, :]
features = normalize(features)
features = torch.FloatTensor(np.array(features.todense()))
# Process labels
labels = np.vstack((ally, ty))
labels[index, :] = labels[index_sorted, :]
labels = torch.argmax(torch.LongTensor(labels), dim=1)
adj = nx.adjacency_matrix(nx.from_dict_of_lists(graph)).tocoo()
# Make the directed graph undirected
adj += adj.T.multiply(adj.T > adj) - adj.multiply(adj.T > adj)
adj = normalize_adj(adj + sp.eye(adj.shape[0]))
adj = sparse_mx_to_torch(adj)
index_train = torch.LongTensor(range(len(y)))
index_val = torch.LongTensor(range(len(y), len(y) + 500))
index_test = torch.LongTensor(index_sorted)
return adj, features, labels, index_train, index_val, index_test
def nontuple_preprocess_adj(adj):
adj_normalized = normalize_adj(sp.eye(adj.shape[0]) + adj)
# adj_normalized = sp.eye(adj.shape[0]) + normalize_adj(adj)
return adj_normalized.tocsr()
RDM_env = np.trace(rho_tensor, axis1=0, axis2=2)
return RDM_sys, RDM_env
### iDMRG Algorithm
while (sysBlock_Length + envBlock_Length) < LatticeLength:
""" Construct a sysBlock_Ham which describes the sysBlock """
# 1. Initialzed the dimension of sysBlock = kron(sysBlock_Ham, eye(Dim))
# 2. Include the interaction of the site inside the sysBlock and the newly added site
# 3. Describe their interactions as kron(sysBlock..., S...), we can understand it as sysBlock \otimes S(new site)
""" Number operator , the meaning of sysBlock operators have not been changed in this step
If we put the Number op after the sysBlock_Ham, then it will gg since sysBlock_Ham dimension changes from 4**(n) to 4**(n+1)
"""
sysBlock_N = kron(sysBlock_N, eye(Dim)) + kron(
eye(sysBlock_Ham.shape[0]),
a_up.conj().T @ a_up + a_down.conj().T @ a_down)
# consider the sysBlock already have two sites
""" Don't know why the on-site spin spin interaction term is not hermition
To force the Hamiltonian becomes Hermitian, we H = 0.5( H + H.conj().T)
Seems even in t is non-zero, the sysBlock_Ham is not hermitian already. But interestingly the envBlock is hermitian......
mu is ok, but t and U terms f**k up......
In the 1st loop: Total Length = 6, such weird thing happens
when t != 0, sysBlock_ham is not hermitian, envBlock_ham is hermitian
when U != 0 , sysBlock_ham is hermitian , envBlock_ham is not hermitian
"""
sysBlock_Ham = kron(sysBlock_Ham, eye(Dim)) \
- t * (kron(sysBlock_a_up.conj().T @ sysBlock_F, a_up) + kron(sysBlock_a_down.conj().T, F @ a_down)) \
def normalized_laplacian(adj, symmetric=True):
adj_normalized = normalize_adj(adj, symmetric)
laplacian = sp.eye(adj.shape[0]) - adj_normalized
return laplacian
def solve(self,
data: np.ndarray,
maxiter: int = 150,
tol: float = 5 * 10**(-4)):
if self.reg_mode is not None:
if len(self.domain_shape) > 2:
grad = Gradient(dims=self.domain_shape,
edge=False,
dtype='float64')
else:
dx = sparse.diags([1, -1], [0, 1],
shape=(self.domain_shape[1],
self.domain_shape[1])).tocsr()
dx[self.domain_shape[1] - 1, :] = 0
dy = sparse.diags([-1, 1], [0, 1],
shape=(self.domain_shape[0],
self.domain_shape[0])).tocsr()
dy[self.domain_shape[0] - 1, :] = 0
grad = sparse.vstack(
(sparse.kron(dx,
sparse.eye(self.domain_shape[0]).tocsr()),
sparse.kron(sparse.eye(self.domain_shape[1]).tocsr(),
dy)))
K = self.alpha * grad
if not self.tau:
if np.prod(self.domain_shape) > 25000:
long = True
else:
long = False
if long:
print("Start evaluate tau. Long runtime.")
if len(self.domain_shape) > 2:
norm = np.abs(np.asscalar(K.eigs(neigs=1, which='LM')))
else:
norm = normest(K)
sigma = 0.99 / norm
print("Calc tau: " + str(sigma))
tau = sigma
else:
tau = self.tau
sigma = tau
if self.reg_mode == 'tv':
F_star = Projection(self.domain_shape, len(self.domain_shape))
else:
F_star = DatatermLinear()
F_star.set_proxdata(0)
else:
tau = 0.99
sigma = tau
F_star = DatatermLinear()
K = 0
G = DatatermRecBregman(self.O)
G.set_proxparam(tau)
G.set_proxdata(data.ravel())
F_star.set_proxparam(sigma)
pk = np.zeros(self.domain_shape)
pk = pk.T.ravel()
plt.Figure()
ulast = np.zeros(self.domain_shape)
u01 = ulast
i = 0
while np.linalg.norm(self.O * u01.ravel() -
data.ravel()) > self.assessment:
print(np.linalg.norm(self.O * u01.ravel() - data.ravel()))
print(self.assessment)
self.solver = PdHgm(K, F_star, G)
self.solver.maxiter = maxiter
self.solver.tol = tol
G.set_proxdata(data.ravel())
G.setP(pk)
self.solver.solve()
u01 = np.reshape(np.real(self.solver.var['x']), self.domain_shape)
pk = pk - (1 / self.alpha) * np.real(
self.O.H * (self.O * u01.ravel() - data.ravel()))
i = i + 1
if self.plot_iteration:
plt.gray()
plt.imshow(u01, vmin=0, vmax=1)
plt.axis('off')
#plt.title('RRE =' + str(round(RRE_breg, 2)), y=-0.1, fontsize=20)
plt.savefig(self.data_output_path +
'Bregman_reconstruction_iter' + str(i) + '.png',
bbox_inches='tight',
pad_inches=0)
plt.close()
return np.reshape(self.solver.var['x'], self.domain_shape)
def ranking_function(self, y, m):
"""Creates ranking function
Parameters
----------
y: ndarray
query vertex vector
m: float
tradeoff
Returns
-------
f: ndarray
ranking vector
"""
#===============================================================================
# RUNS OUT OF MEMORY
#===============================================================================
#===============================================================================
# if not self.rankFunc:
# print('...computing Dv...')
# Dv=self.vertex_degrees().tocsc()
#
# print('...computing H...')
# H=self.incidence_matrix().tocsc()
#
# print('...computing W...')
# W=self.weight_matrix().tocsc()
#
# print('...computing De...')
# De=self.edge_degrees().tocsc()
#
# print('...computing Dv rec inv...')
# Dv_rec_inv=spla.inv(Dv).sqrt()
#
# print('...computing Theta...')
# Theta=Dv_rec_inv*H*W*(spla.inv(De))*(H.transpose())*Dv_rec_inv
#
# print('...deleting unnecessary matrices...')
# del(Dv)
# del(H)
# del(W)
# del(De)
# del(Dv_rec_inv)
# gc.collect()
#
# Theta=Theta.tocsc()
#
# print('...computing rankFunc...')
# self.rankFunc=spla.inv((spsp.eye(*sp.shape(Theta)).tocsc()-(1/(1+m))*Theta).tocsc())
#
# del(Theta)
# gc.collect()
#
# return self.rankFunc*y
#===============================================================================
if self.Theta is None:
self.theta_matrix()
if self.rankFunc is None:
self.rankFunc = spsp.eye(
*sp.shape(self.Theta)) - (1.0 / (1.0 + m)) * self.Theta
f = spla.spsolve(self.rankFunc, y, use_umfpack=True)
return f
def diamond_norm(choi, **kwargs):
r"""Return the diamond norm of the input quantum channel object.
This function computes the completely-bounded trace-norm (often
referred to as the diamond-norm) of the input quantum channel object
using the semidefinite-program from reference [1].
Args:
choi(Choi or QuantumChannel): a quantum channel object or
Choi-matrix array.
kwargs: optional arguments to pass to CVXPY solver.
Returns:
float: The completely-bounded trace norm
:math:`\|\mathcal{E}\|_{\diamond}`.
Raises:
QiskitError: if CVXPY package cannot be found.
Additional Information:
The input to this function is typically *not* a CPTP quantum
channel, but rather the *difference* between two quantum channels
:math:`\|\Delta\mathcal{E}\|_\diamond` where
:math:`\Delta\mathcal{E} = \mathcal{E}_1 - \mathcal{E}_2`.
Reference:
J. Watrous. "Simpler semidefinite programs for completely bounded
norms", arXiv:1207.5726 [quant-ph] (2012).
.. note::
This function requires the optional CVXPY package to be installed.
Any additional kwargs will be passed to the ``cvxpy.solve``
function. See the CVXPY documentation for information on available
SDP solvers.
"""
_cvxpy_check('`diamond_norm`') # Check CVXPY is installed
if not isinstance(choi, Choi):
choi = Choi(choi)
def cvx_bmat(mat_r, mat_i):
"""Block matrix for embedding complex matrix in reals"""
return cvxpy.bmat([[mat_r, -mat_i], [mat_i, mat_r]])
# Dimension of input and output spaces
dim_in = choi._input_dim
dim_out = choi._output_dim
size = dim_in * dim_out
# SDP Variables to convert to real valued problem
r0_r = cvxpy.Variable((dim_in, dim_in))
r0_i = cvxpy.Variable((dim_in, dim_in))
r0 = cvx_bmat(r0_r, r0_i)
r1_r = cvxpy.Variable((dim_in, dim_in))
r1_i = cvxpy.Variable((dim_in, dim_in))
r1 = cvx_bmat(r1_r, r1_i)
x_r = cvxpy.Variable((size, size))
x_i = cvxpy.Variable((size, size))
iden = sparse.eye(dim_out)
# Watrous uses row-vec convention for his Choi matrix while we use
# col-vec. It turns out row-vec convention is requried for CVXPY too
# since the cvxpy.kron function must have a constant as its first argument.
c_r = cvxpy.bmat([[cvxpy.kron(iden, r0_r), x_r],
[x_r.T, cvxpy.kron(iden, r1_r)]])
c_i = cvxpy.bmat([[cvxpy.kron(iden, r0_i), x_i],
[-x_i.T, cvxpy.kron(iden, r1_i)]])
c = cvx_bmat(c_r, c_i)
# Convert col-vec convention Choi-matrix to row-vec convention and
# then take Transpose: Choi_C -> Choi_R.T
choi_rt = np.transpose(
np.reshape(choi.data, (dim_in, dim_out, dim_in, dim_out)),
(3, 2, 1, 0)).reshape(choi.data.shape)
choi_rt_r = choi_rt.real
choi_rt_i = choi_rt.imag
# Constraints
cons = [
r0 >> 0, r0_r == r0_r.T, r0_i == -r0_i.T,
cvxpy.trace(r0_r) == 1, r1 >> 0, r1_r == r1_r.T, r1_i == -r1_i.T,
cvxpy.trace(r1_r) == 1, c >> 0
]
# Objective function
obj = cvxpy.Maximize(
cvxpy.trace(choi_rt_r @ x_r) + cvxpy.trace(choi_rt_i @ x_i))
prob = cvxpy.Problem(obj, cons)
sol = prob.solve(**kwargs)
return sol
rhs = f(Xint, Yint) # evaluate f at interior points for right hand side
# rhs is modified below for boundary
usoln = np.zeros(X.shape)
# rhs[:,0] -= usoln[1:-1,0] / h**2
# rhs[:,-1] -= usoln[1:-1,-1] / h**2
# rhs[0,:] -= usoln[0,1:-1] / h**2
# rhs[-1,:] -= usoln[-1,1:-1] / h**2
# set boundary conditions around edges of usoln array:
# convert the 2d grid function rhs into a column vector for rhs of system:
F = rhs.reshape((m[i] * m[i], 1))
# form matrix A:
I = sp.eye(m[i], m[i])
g = np.ones(m[i])
T = sp.spdiags([g, -4. * g, g], [-1, 0, 1], m[i], m[i])
S = sp.spdiags([g, g], [-1, 1], m[i], m[i])
A = (sp.kron(I, T) + sp.kron(S, I)) / (h[i]**2)
A = A.tocsr()
# Solve the linear system:
uvec = spsolve(A, F)
# usoln[1:-1, 1:-1] = uvec.reshape( (m,m) )
# reshape vector solution uvec as a grid function and
# insert this interior solution into usoln for plotting purposes:
# (recall boundary conditions in usoln are already set)
usoln[1:-1, 1:-1] = uvec.reshape((m[i], m[i]))
umax = usoln.max()
def calcSolution(h,show_matri,show_result):
ax = 0.0
bx = 2.0
ay = 0.0
by = 1.0
mx = 2.0/h-1
my = 1.0/h-1
x = np.linspace(ax,bx,mx+2) # grid points x including boundaries
y = np.linspace(ay,by,my+2) # grid points y including boundaries
X,Y = np.meshgrid(x,y) # 2d arrays of x,y values
X = X.T # transpose so that X(i,j),Y(i,j) are
Y = Y.T # coordinates of (i,j) point
Xint = X[1:-1,1:-1] # interior points
Yint = Y[1:-1,1:-1]
rhs = f(Xint,Yint) # evaluate f at interior points for right hand side
# rhs is modified below for boundary conditions.
# set boundary conditions around edges of usoln array:
usoln = np.zeros(X.shape)
usoln[:,0] = u_exact(x,ay)
usoln[:,-1] = u_exact(x,by)
usoln[0,:] = u_exact(ax,y)
usoln[-1,:] = u_exact(bx,y)
# adjust the rhs to include boundary terms:
rhs[:,0] -= usoln[1:-1,0] / h**2
rhs[:,-1] -= usoln[1:-1,-1] / h**2
rhs[0,:] -= usoln[0,1:-1] / h**2
rhs[-1,:] -= usoln[-1,1:-1] / h**2
# convert the 2d grid function rhs into a column vector for rhs of system:
F = rhs.reshape((mx*my,1))
# form matrix A:
Ix = sp.eye(mx,mx)
Iy = sp.eye(my,my)
ex = np.ones(mx)
ey = np.ones(my)
T = sp.spdiags([ey,-4.*ey,ey],[-1,0,1],my,my)
S = sp.spdiags([ex,ex],[-1,1],mx,mx)
A = (sp.kron(Ix,T) + sp.kron(S,Iy)) / h**2
A = A.tocsr()
show_matrix = True
if (show_matrix):
pylab.figure()
pylab.spy(A,marker='.')
# Solve the linear system:
tic = time.time()
uvec = spsolve(A, F)
toc = time.time()
# reshape vector solution uvec as a grid function and
# insert this interior solution into usoln for plotting purposes:
# (recall boundary conditions in usoln are already set)
usoln[1:-1, 1:-1] = uvec.reshape( (mx,my) )
show_result = True
if show_result:
# plot results:
pylab.figure()
ax = Axes3D(pylab.gcf())
ax.plot_surface(X,Y,usoln, rstride=1, cstride=1, cmap=pylab.cm.jet)
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('u')
#pylab.axis([a, b, a, b])
#pylab.daspect([1 1 1])
pylab.title('Surface plot of computed solution')
pylab.show(block=False)
def bethe_hessian(A, r):
D = degree(A)
H = (r ** 2 - 1) * sps.eye(A.shape[0]) - r * A + D
return H
def fitImplicit(self,
train,
alpha=10.,
c="linear",
eps=1E-8,
userGraph=None,
itemGraph=None,
method="random",
U0=None,
V0=None):
"""
Learn factors from training set with the implicit formula of Koren
"Collaborative Filtering for Implicit Feedback Datasets"
User and item factors are fitted alternately.
train : array-like of three columns
contains row index, column index, value of not null entries
alpha : float
Confidence weight
c : string
if c="linear", C = 1 + alpha*R
if c="log", C = 1 + alpha*log(1 + R/eps)
eps : float
used only if c="log"
rowGraph : array-like of three columns
contains the first two columns are the index of the linked rows,
the third is the weight of the link
colGraph : same as rowGraph for the column links
method : string
factor initialisation. Can be random, svd or given in U0 and V0
U0, V0: array-like
initial value for U and V. If not None, method is ignored
"""
if self.seed is not None:
np.random.seed(self.seed)
# we define a global fonction transfo that is either linear_transfo
# or log_transfo. This prevent to make the if else check for each
# user and for each item at each iteration !
if c == "linear":
self.transfo = self.linear_transfo
elif c == "log":
self.transfo = self.log_transfo
self.alpha = alpha
self.c = c
self.eps = eps
self.userGraph = False
self.itemGraph = False
self.train = sparse_matrix(train, n=self.num_users, p=self.num_items)
self.n_u = list(
map(lambda u: self.train[u, :].nnz, range(self.num_users)))
self.n_i = list(
map(lambda i: self.train[:, i].nnz, range(self.num_items)))
if userGraph is not None:
self.userGraph = True
self.A_user = sparse.csgraph.laplacian(
sparse_matrix(userGraph,
n=self.num_users,
p=self.num_users,
w=(1 - self.mu) / self.mu))
if self.reg == "weighted":
self.A_user += sparse.diags(self.n_u)
elif self.reg == "default":
self.A_user += sparse.eye(self.num_users)
#self.A_user_sqrt = kron(sqrtm(self.A_user.todense()).real,sparse.eye(self.d))
self.A_user = kron(self.A_user, sparse.eye(self.d))
if itemGraph is not None:
self.itemGraph = True
self.A_item = sparse.csgraph.laplacian(
sparse_matrix(itemGraph,
n=self.num_items,
p=self.num_items,
w=(1 - self.mu) / self.mu))
if self.reg == "weighted":
self.A_item += sparse.diags(self.n_i)
elif self.reg == "default":
self.A_item += sparse.eye(self.num_items)
#self.A_item_sqrt = kron(sqrtm(self.A_item.todense()).real,sparse.eye(self.d))
self.A_item = kron(self.A_item, sparse.eye(self.d))
self.U = np.random.normal(size=(self.num_users, self.d))
self.V = np.random.normal(size=(self.num_items, self.d))
for it in range(self.num_iters):
VV = self.V.T.dot(self.V)
if self.userGraph:
self.U = self.implicit_user_iteration(VV)
else:
for u in range(self.num_users):
indices = self.train[u].nonzero()[1]
if indices.size:
R_u = self.train[u, indices]
self.U[u, :] = self.implicit_update(
indices, self.V, VV,
R_u.toarray()[0])
else:
self.U[u, :] = np.zeros(self.d)
UU = self.U.T.dot(self.U)
if self.itemGraph:
self.V = self.implicit_item_iteration(UU)
else:
for i in range(self.num_items):
indices = self.train[:, i].nonzero()[0]
if indices.size:
R_i = self.train[indices, i]
self.V[i, :] = self.implicit_update(
indices, self.U, UU,
R_i.toarray().T[0])
else:
self.V[i, :] = np.zeros(self.d)
if self.verbose:
print("end iteration " + str(it + 1))
