def test_gh_2466():
row = np.array([0, 0])
col = np.array([0, 1])
val = np.array([1, -1])
A = scipy.sparse.coo_matrix((val, (row, col)), shape=(1, 2))
b = np.asarray([4])
lsqr(A, b)
def test_b_shapes():
# Test b being a scalar.
A = np.array([[1.0, 2.0]])
b = 3.0
x = lsqr(A, b)[0]
assert_almost_equal(norm(A.dot(x) - b), 0)
# Test b being a column vector.
A = np.eye(10)
b = np.ones((10, 1))
x = lsqr(A, b)[0]
assert_almost_equal(norm(A.dot(x) - b.ravel()), 0)
def solve_lsqr(self, b, rho=None, v=None, x_init=None, options=None):
"""Solve ||K*x - b||^2_2 + (rho/2)||x-v||_2^2.
"""
# Add additional linear terms for the rho terms
sizev = 0
if rho is not None:
vf = v.flatten() * np.sqrt(rho / 2.0)
sizeb = self.K.input_size
sizev = np.prod(v.shape)
b = np.hstack((b, vf))
input_data = np.zeros(self.K.input_size)
output_data = np.zeros(self.K.output_size + sizev)
def matvec(x, output_data):
if rho is None:
# Traverse compgraph
self.K.forward(x, output_data)
else:
# Compgraph and additional terms
self.K.forward(x, output_data[0:0 + sizeb])
np.copyto(output_data[sizeb:sizeb + sizev], x * np.sqrt(rho / 2.0))
return output_data
def rmatvec(y, input_data):
if rho is None:
self.K.adjoint(y, input_data)
else:
self.K.adjoint(y[0:0 + sizeb], input_data)
input_data += y[sizeb:sizeb + sizev] * np.sqrt(rho / 2.0)
return input_data
# Define linear operator
def matvecComp(x): return matvec(x, output_data)
def rmatvecComp(y): return rmatvec(y, input_data)
K = LinearOperator((self.K.output_size + sizev, self.K.input_size),
matvecComp, rmatvecComp)
# Options
if options is None:
# Default options
return lsqr(K, b)[0]
else:
if not isinstance(options, lsqr_options):
raise Exception("Invalid LSQR options.")
return lsqr(K, b, atol=options.atol, btol=options.btol,
show=options.show, iter_lim=options.iter_lim)[0]
def create_tf_plateaus(k, data, edges, plateau_size, plateau_vals, plateaus=None):
if k == 0:
return create_plateaus(data, edges, plateau_size, plateau_vals, plateaus=plateaus)
D = matrix_from_edges(edges)
Dkminus1 = get_delta(D, k-1)
if k % 2 == 0:
plateaus = create_plateaus(data, edges, plateau_size, plateau_vals)
data[:] = lsqr(Dkminus1, data)[0]
else:
# TODO: not a very principled way of creating odd-k plateaus, but it looks pretty
p = np.zeros(Dkminus1.shape[0])
plateaus = create_plateaus(p, edges, plateau_size, plateau_vals)
data[:] = lsqr(Dkminus1, p)[0]
return plateaus
def _fit(self, X, y):
# For regularisation, we need to solve the equation
# (X^T.X + alpha*I) w == X^T y for w
N, M = X.shape
if self._m == 'svd':
# Using SVD and the Woodbury matrix identity, we get the
# following equation:
U, s, Vh = svd(X, full_matrices=False)
invpart = np.diag(1 / (1 + self.alpha * s**(-2)))
self.w = np.dot(np.eye(M) - np.dot(Vh.T, np.dot(invpart, Vh)),
np.dot(X.T, y)) / self.alpha
elif self._m == 'solve':
# uses the scipy implementation of solve
self.w = solve(np.dot(X.T, X) + self.alpha*np.eye(M),
np.dot(X.T, y), sym_pos=True)
elif self._m == 'inverse':
# very inefficient, for comparison of numerical stability
# solves by direct computation of the inverse of (X^T . X)
self.w = np.dot(inv(np.dot(X.T, X) + self.alpha*np.eye(M)),
np.dot(X.T, y))
# alternatively, there are iterative methods to 'solve'
# X w == y directly
elif self._m == 'lsqr':
self.w, = lsqr(X, y, damp=self.alpha)
else:
error("Method not implemented")
def fit(self, X, y):
"""
Fit linear model.
Parameters
----------
X : numpy array or sparse matrix of shape [n_samples,n_features]
Training data
y : numpy array of shape [n_samples]
Target values
Returns
-------
self : returns an instance of self.
"""
X = safe_asarray(X)
y = np.asarray(y)
X, y, X_mean, y_mean, X_std = self._center_data(
X, y, self.fit_intercept, self.normalize, self.copy_X)
if sp.issparse(X):
if hasattr(sp_linalg, 'lsqr'):
out = sp_linalg.lsqr(X, y)
self.coef_ = out[0]
self.residues_ = out[3]
else:
# DEPENDENCY: scipy 0.7
self.coef_ = sp_linalg.spsolve(X, y)
self.residues_ = y - safe_sparse_dot(X, self.coef_)
else:
self.coef_, self.residues_, self.rank_, self.singular_ = \
linalg.lstsq(X, y)
self._set_intercept(X_mean, y_mean, X_std)
return self
def balance_triangulation(triangulation):
if GRAPH not in triangulation.keys():
refresh_graph(triangulation)
if HULL not in triangulation.keys():
refresh_hull(triangulation)
points = triangulation[VERTICES]
graph = triangulation[GRAPH]
cannot_move = [
triangulation[SRC_POINT_MARKERS][i] or triangulation[HULL][i]
for i in range(len(points))
]
A = np.zeros((2 * len(points), 2 * len(points)))
b = np.zeros(2 * len(points))
for p_idx, p in enumerate(points):
row = 2 * p_idx
n_neighbours = len(graph[p_idx])
A[row][row] = 1
A[row + 1][row + 1] = 1
p_mean = [0, 0]
for neighbour in graph[p_idx]:
A[row][2 * neighbour] = -1. / n_neighbours if not cannot_move[
neighbour] else 0
A[row +
1][2 * neighbour +
1] = -1. / n_neighbours if not cannot_move[neighbour] else 0
p_mean[0] += points[neighbour][0] / n_neighbours
p_mean[1] += points[neighbour][1] / n_neighbours
b[row] = p_mean[0] - p[0]
b[row + 1] = p_mean[1] - p[1]
answer = lsqr(A, b)[0]
points[:] = [
[points[i][0] + answer[2 * i], points[i][1] +
answer[2 * i + 1]] if not cannot_move[i] else points[i]
for i in range(len(points))
]
def test_Fredholm1(par):
"""Dot-test and inversion for Fredholm1 operator"""
np.random.seed(10)
_F = np.arange(par["nsl"] * par["nx"] * par["ny"]).reshape(
par["nsl"], par["nx"], par["ny"]
)
F = _F - par["imag"] * _F
x = np.ones((par["nsl"], par["ny"], par["nz"])) + par["imag"] * np.ones(
(par["nsl"], par["ny"], par["nz"])
)
Fop = Fredholm1(
F,
nz=par["nz"],
saveGt=par["saveGt"],
usematmul=par["usematmul"],
dtype=par["dtype"],
)
assert dottest(
Fop,
par["nsl"] * par["nx"] * par["nz"],
par["nsl"] * par["ny"] * par["nz"],
complexflag=0 if par["imag"] == 0 else 3,
)
xlsqr = lsqr(Fop, Fop * x.ravel(), damp=1e-20, iter_lim=30, show=0)[0]
xlsqr = xlsqr.reshape(par["nsl"], par["ny"], par["nz"])
assert_array_almost_equal(x, xlsqr, decimal=3)
def solve_matrix_free(self, data, sphere, alpha=0.0, scale=True, fista=False, lsqr=True, lsmr=False):
'''
data = [vis_arr, n_freq, n_pol]
'''
logger.info("Solving Visabilities nside={}".format(sphere.nside))
t0 = time.time()
frequencies = [self.frequency]
logger.info("frequencies: {}".format(frequencies))
A = DiSkOOperator(self.u_arr, self.v_arr, self.w_arr, data, frequencies, sphere)
Apre = DirectImagingOperator(self.u_arr, self.v_arr, self.w_arr, data, frequencies, sphere)
d = data.flatten()
#u,s,vt = spalg.svds(A, k=min(A.shape)-2)
#logger.info("t ={}, s={}".format(time.time() - t0, s))
if fista:
sky, niter = pylops.optimization.sparsity.FISTA(A, d, tol=1e-3, niter=2500, alpha=alpha, show=True)
if lsqr:
sky, lstop, itn, r1norm, r2norm, anorm, acond, arnorm, xnorm, var = spalg.lsqr(A, data, damp=alpha)
logger.info("Matrix free solve elapsed={} x={}, stop={}, itn={} r1norm={}".format(time.time() - t0, sky.shape, lstop, itn, r1norm))
if lsmr:
x0 = Apre*d
sky, info = pylops.optimization.leastsquares.NormalEquationsInversion(A, Regs=None, data=d, x0=x0,
epsI = alpha,
returninfo=True)
#logger.info("Matrix free solve elapsed={} x={}, stop={}, itn={} r1norm={}".format(time.time() - t0, sky.shape, lstop, itn, r1norm))
#logger.info("A M={} N={}".format(A.M, A.N))
#sky, lstop, itn, normr, mormar, morma, conda, normx = spalg.lsmr(A, data, damp=alpha)
#logger.info("Matrix free solve elapsed={} x={}, stop={}, itn={} normr={}".format(time.time() - t0, sky.shape, lstop, itn, normr))
#sky = np.abs(sky)
sphere.set_visible_pixels(sky, scale)
return sky.reshape(-1,1)
def adjoint_derivative(dx, dy, ds, **kwargs):
"""Applies adjoint of derivative at (A, b, c) to perturbations dx, dy, ds
Args:
dx: NumPy array representing perturbation in `x`
dy: NumPy array representing perturbation in `y`
ds: NumPy array representing perturbation in `s`
Returns:
(`dA`, `db`, `dc`), the result of applying the adjoint to the
perturbations; the sparsity pattern of `dA` matches that of `A`.
"""
dw = -(x @ dx + y @ dy + s @ ds)
dz = np.concatenate(
[dx, D_proj_dual_cone.rmatvec(dy + ds) - ds,
np.array([dw])])
if np.allclose(dz, 0):
r = np.zeros(dz.shape)
else:
r = splinalg.lsqr(cone_lib.transpose_linear_operator(M), dz,
**kwargs)[0]
# dQ is the outer product of pi_z and r. Instead of materializing this,
# the code below only computes the entries needed to compute dA, db, dc
values = pi_z[cols] * r[rows + n] - pi_z[n + rows] * r[cols]
dA = sparse.csc_matrix((values, (rows, cols)), shape=A.shape)
db = pi_z[n:n + m] * r[-1] - pi_z[-1] * r[n:n + m]
dc = pi_z[:n] * r[-1] - pi_z[-1] * r[:n]
return dA, db, dc
def run_test(data_low, data_high, x_low, x_high):
"""Generates a test problem and solves it using Scipy's LSQR"""
_proc.start_processes()
start_time = time.time()
A, b, x_real = generate_data(data_low, data_high, x_low, x_high)
print("generate_data(...) run time:", time.time() - start_time, "seconds")
_proc.end_processes()
print("Size of A =", A.shape)
print()
start_time = time.time()
lsmr_result = linalg.lsmr(A, b, maxiter=1000)
print("linalg.lsmr(A, b) run time:", time.time() - start_time, "seconds")
print("Number of iterations =", lsmr_result[2])
x_lsmr = numpy.array([lsmr_result[0]]).T
print("sum(|x_real - x_lsmr|) =", numpy.sum(numpy.abs(x_real - x_lsmr)))
print()
start_time = time.time()
lsqr_result = linalg.lsqr(A, b, iter_lim=1000)
print("linalg.lsqr(A, b) run time:", time.time() - start_time, "seconds")
print("Number of iterations =", lsqr_result[2])
x_lsqr = numpy.array([lsqr_result[0]]).T
print("sum(|x_real - x_lsqr|) =", numpy.sum(numpy.abs(x_real - x_lsqr)))
def test_Block(par):
"""Dot-test and inversion for Block operator
"""
np.random.seed(10)
G11 = np.random.normal(0, 10, (par['ny'], par['nx'])).astype(par['dtype'])
G12 = np.random.normal(0, 10, (par['ny'], par['nx'])).astype(par['dtype'])
G21 = np.random.normal(0, 10, (par['ny'], par['nx'])).astype(par['dtype'])
G22 = np.random.normal(0, 10, (par['ny'], par['nx'])).astype(par['dtype'])
x = np.ones(2 * par['nx']) + par['imag'] * np.ones(2 * par['nx'])
Bop = Block([[
MatrixMult(G11, dtype=par['dtype']),
MatrixMult(G12, dtype=par['dtype'])
],
[
MatrixMult(G21, dtype=par['dtype']),
MatrixMult(G22, dtype=par['dtype'])
]],
dtype=par['dtype'])
assert dottest(Bop,
2 * par['ny'],
2 * par['nx'],
complexflag=0 if par['imag'] == 0 else 3)
xlsqr = lsqr(Bop, Bop * x, damp=1e-20, iter_lim=500, show=0)[0]
assert_array_almost_equal(x, xlsqr, decimal=3)
def dcpf(B, Pbus, Va0, ref, pv, pq):
"""Solves a DC power flow.
Solves for the bus voltage angles at all but the reference bus, given the
full system C{B} matrix and the vector of bus real power injections, the
initial vector of bus voltage angles (in radians), and column vectors with
the lists of bus indices for the swing bus, PV buses, and PQ buses,
respectively. Returns a vector of bus voltage angles in radians.
@see: L{rundcpf}, L{runpf}
@author: Carlos E. Murillo-Sanchez (PSERC Cornell & Universidad
Autonoma de Manizales)
@author: Ray Zimmerman (PSERC Cornell)
@author: Richard Lincoln
"""
pvpq = matrix(r_[pv, pq])
## initialize result vector
Va = copy(Va0)
## update angles for non-reference buses
A=B[pvpq.T, pvpq]
d = det(A.todense())
if(math.fabs(d) > 0.2):
Va[pvpq] = spsolve(A, (Pbus[pvpq] - B[pvpq.T, ref] * Va0[ref]).transpose())
else:
Va[pvpq] = lsqr(A, (Pbus[pvpq] - B[pvpq.T, ref] * Va0[ref]).transpose())[0]
return Va
def lsqr_cp(aa, bb, guess=None, **kw):
# implement two speed-ups:
# 1. "column preconditioning": make sure each column of aa has the same
# norm
# 2. allow guesses
# column preconditioning is important (substantial speedup), and has
# been implemented directly in fit_once.
# allow guesses: solving Ax = b is the same as solving A(x-x*) = b-Ax*.
# => A(dx) = b-Ax*. So we can solve for dx instead, then return dx+x*.
# This improves speed if we reduce the tolerance.
from scipy.sparse import linalg
if guess is not None:
bb2 = bb - aa.dot(guess)
if 'btol' in kw:
fac = numpy.sum(bb**2.)**(0.5)/numpy.sum(bb2**2.)**0.5
kw['btol'] = kw['btol']*numpy.clip(fac, 0.1, 10.)
else:
bb2 = bb.copy()
normbb = numpy.sum(bb2**2.)
bb2 /= normbb**(0.5)
par = linalg.lsqr(aa, bb2, **kw)
# for some reason, everything ends up as double precision after this
# or lsmr; lsqr seems to be better
# par[0][:] *= norm**(-0.5)*normbb**(0.5)
par[0][:] *= normbb**0.5
if guess is not None:
par[0][:] += guess
par = list(par)
par[0] = par[0].astype('f4')
par[9] = par[9].astype('f4')
return par
def test_FFT3D(par):
"""Dot-test and inversion for FFTND operator for 3d signal
"""
decimal = 4 if np.real(np.ones(1, par['dtype'])).dtype == np.float32 else 8
dt, dx, dy = 0.005, 5, 2
t = np.arange(par['nt']) * dt
f0 = 10
nfft1 = par['nt'] if par['nfft'] is None else par['nfft']
nfft2 = par['nx'] if par['nfft'] is None else par['nfft']
nfft3 = par['ny'] if par['nfft'] is None else par['nfft']
d = np.outer(np.sin(2 * np.pi * f0 * t), np.arange(par['nx']) + 1)
d = np.tile(d[:, :, np.newaxis], [1, 1, par['ny']])
d = d.astype(par['dtype'])
FFTop = FFTND(dims=(par['nt'], par['nx'], par['ny']),
nffts=(nfft1, nfft2, nfft3),
sampling=(dt, dx, dy))
assert dottest(FFTop, nfft1*nfft2*nfft3,
par['nt']*par['nx']*par['ny'],
complexflag=2, tol=10**(-decimal))
D = FFTop * d.flatten()
dadj = FFTop.H*D # adjoint is inverse for fft
dinv = lsqr(FFTop, D, damp=1e-10, iter_lim=100, show=0)[0]
dadj = np.real(dadj).reshape(par['nt'], par['nx'], par['ny'])
dinv = np.real(dinv).reshape(par['nt'], par['nx'], par['ny'])
assert_array_almost_equal(d, dadj, decimal=decimal)
assert_array_almost_equal(d, dinv, decimal=decimal)
def test_FFT_1dsignal(par):
"""Dot-test and inversion for FFT operator for 1d signal
"""
decimal = 4 if np.real(np.ones(1, par['dtype'])).dtype == np.float32 else 8
dt = 0.005
t = np.arange(par['nt']) * dt
f0 = 10
x = np.sin(2 * np.pi * f0 * t)
x = x.astype(par['dtype'])
nfft = par['nt'] if par['nfft'] is None else par['nfft']
FFTop = FFT(dims=[par['nt']], nfft=nfft, sampling=dt,
real=par['real'], engine=par['engine'], dtype=par['dtype'])
# FFT with real=True cannot pass dot-test neither be inverted correctly,
# see FFT documentation for a detailed explanation. We thus test FFT.H*FFT
if par['real']:
FFTop = FFTop.H * FFTop
assert dottest(FFTop, par['nt'], par['nt'],
complexflag=0, tol=10**(-decimal), verb=True)
else:
assert dottest(FFTop, nfft, par['nt'],
complexflag=2, tol=10**(-decimal), verb=True)
assert dottest(FFTop, nfft, par['nt'],
complexflag=3, tol=10**(-decimal), verb=True)
y = FFTop * x
xadj = FFTop.H * y # adjoint is same as inverse for fft
xinv = lsqr(FFTop, y, damp=1e-10, iter_lim=10, show=0)[0]
assert_array_almost_equal(x, xadj, decimal=decimal)
assert_array_almost_equal(x, xinv, decimal=decimal)
def solve(A, b, method, tol=1e-3):
""" General sparse solver interface.
method can be one of
- spsolve_umfpack_mmd_ata
- spsolve_umfpack_colamd
- spsolve_superlu_mmd_ata
- spsolve_superlu_colamd
- bicg
- bicgstab
- cg
- cgs
- gmres
- lgmres
- minres
- qmr
- lsqr
- lsmr
"""
if method == 'spsolve_umfpack_mmd_ata':
return spla.spsolve(A, b, use_umfpack=True, permc_spec='MMD_ATA')
elif method == 'spsolve_umfpack_colamd':
return spla.spsolve(A, b, use_umfpack=True, permc_spec='COLAMD')
elif method == 'spsolve_superlu_mmd_ata':
return spla.spsolve(A, b, use_umfpack=False, permc_spec='MMD_ATA')
elif method == 'spsolve_superlu_colamd':
return spla.spsolve(A, b, use_umfpack=False, permc_spec='COLAMD')
elif method == 'bicg':
res = spla.bicg(A, b, tol=tol)
return res[0]
elif method == 'bicgstab':
res = spla.bicgstab(A, b, tol=tol)
return res[0]
elif method == 'cg':
res = spla.cg(A, b, tol=tol)
return res[0]
elif method == 'cgs':
res = spla.cgs(A, b, tol=tol)
return res[0]
elif method == 'gmres':
res = spla.gmres(A, b, tol=tol)
return res[0]
elif method == 'lgmres':
res = spla.lgmres(A, b, tol=tol)
return res[0]
elif method == 'minres':
res = spla.minres(A, b, tol=tol)
return res[0]
elif method == 'qmr':
res = spla.qmr(A, b, tol=tol)
return res[0]
elif method == 'lsqr':
res = spla.lsqr(A, b, atol=tol, btol=tol)
return res[0]
elif method == 'lsmr':
res = spla.lsmr(A, b, atol=tol, btol=tol)
return res[0]
else:
raise Exception('UnknownSolverType')
def solve_iteration(self, Xdr):
if self.svd_invA==None:
self.lsqr_result = linalg.lsqr(self.A, Xdr)
self.x = self.lsqr_result[0].reshape((self.NDoF()/3,3))
else:
svd_x = scipy.dot(self.svd_invA, Xdr)
self.x = svd_x.reshape((self.NDoF()/3,3))
def doFlattening(mesh, quadIdx):
n = mesh.VPos.shape[0] # N x 3
k = np.array(quadIdx).shape[0]
I = []
J = []
V = []
anchors = np.array([[0, 0, 0],
[0, 1, 0],
[1, 1, 0],
[1, 0, 0]])
# Build sparse Laplacian Matrix coordinates and values
for i in range(n):
vertex = mesh.vertices[i]
neighbors = mesh.vertices[i].getVertexNeighbors()
indices = map(lambda x: x.ID, neighbors)
if i in quadIdx:
I = I + [i]
J = J + [i]
V = V + [WEIGHT]
else:
z = len(indices)
I = I + ([i] * (z + 1)) # repeated row
J = J + indices + [i] # column indices and this row
V = V + ([-1 / float(z)] * z) + [1] # negative weights divided by degree and row degree
L = sparse.coo_matrix((V, (I, J)), shape=(n, n)).tocsr()
delta = np.zeros((n, 3))
delta[np.array(quadIdx), :] = WEIGHT * anchors
# update mesh vertices with least-squares solution
for i in range(3):
mesh.VPos[:, i] = lsqr(L, delta[:, i])[0]
return mesh
def solve_iteration(self, Xdr):
if self.svd_invA == None:
self.lsqr_result = linalg.lsqr(self.A, Xdr)
self.x = self.lsqr_result[0].reshape((self.NDoF() / 3, 3))
else:
svd_x = scipy.dot(self.svd_invA, Xdr)
self.x = svd_x.reshape((self.NDoF() / 3, 3))
def equivalent_resistance(g,v1,v2):
if v1 == v2:
return 0
vind = g.new_vertex_property('long')
c = 0
for v in g.vertices():
vind[v] = c
c += 1
G = laplacian(g, index=vind)
n1 = vind[v1]
n2 = vind[v2]
r = G[n2]
s = r.shape[1]
diff = csr_matrix((np.append([-1],r.data),np.append([n1],r.indices), np.append(np.full(n2+1,r.indptr[0]),np.full(s-n2,r.indptr[1]+1))),shape=G.shape)
diff += diff.transpose()
diff -= csr_matrix(([G[n2,n2]],([n2],[n2])),shape=G.shape)
Gnn = G - diff
I = np.zeros(s)
I[n2] = 1
ans = lsqr(Gnn,I)[0]
res = -ans[n1]/ans[n2]
if res < 0:
return np.inf
else:
return res
def fit(self, show_max_performance = False, logFile = None, loss_tolerance = 1e-6,
iteration_limit = 50000, damp_coeff=0.0, topK = 300, add_zeros_quota = 0.0, normalize_similarity = False):
self.logFile = logFile
self.normalize_similarity = normalize_similarity
self.add_zeros_quota = add_zeros_quota
self.topK = topK
self._generateTrainData_low_ram()
commonFeatures = self.ICM[self.row_list].multiply(self.ICM[self.col_list])
linalg_result = linalg.lsqr(commonFeatures, self.data_list, show = False, atol=loss_tolerance, btol=loss_tolerance,
iter_lim = iteration_limit, damp=damp_coeff)
# res = linalg.lsmr(commonFeatures, self.data_list, show = False, atol=loss_tolerance, btol=loss_tolerance,
# maxiter = iteration_limit, damp=damp_coeff)
self.D_incremental = linalg_result[0].copy()
self.D_best = linalg_result[0].copy()
self.epochs_best = 0
self.loss = linalg_result[3]
self._compute_W_sparse()
def equivalent_resistances(g,node_pairs):
vind = g.new_vertex_property('long')
c = 0
for v in g.vertices():
vind[v] = c
c += 1
G = laplacian(g, index=vind)
Rmap = {}
for v1,v2 in node_pairs:
n1 = vind[v1]
n2 = vind[v2]
if n1 == n2:
continue
r = G[n2]
s = r.shape[1]
diff = csr_matrix((np.append([-1],r.data),np.append([n1],r.indices), np.append(np.full(n2+1,r.indptr[0]),np.full(s-n2,r.indptr[1]+1))),shape=G.shape)
diff += diff.transpose()
diff -= csr_matrix(([G[n2,n2]],([n2],[n2])),shape=G.shape)
Gnn = G - diff
I = np.zeros(s)
I[n2] = 1
ans = lsqr(Gnn,I)[0]
res = -ans[n1]/ans[n2]
if res < 0:
Rmap[(v1,v2)] = np.inf
else:
Rmap[(v1,v2)] = res
return Rmap
def _solve_lsqr(self, A, B, **kwargs):
"""
Call scipy lsqr
Parameters
----------
A : rectangular sparse matrix
B : vector
Returns
-------
"""
lsqrargs = {}
# lsqrargs['tol'] = 1e-12
if 'iter_lim' in kwargs:
logger.info("Using %i maximum iterations" % kwargs['iter_lim'])
lsqrargs['iter_lim'] = kwargs['iter_lim']
if 'damp' in kwargs:
logger.info("Using damping coefficient")
lsqrargs['damp'] = kwargs['damp']
if 'atol' in kwargs:
logger.info('Using a tolerance of %f' % kwargs['atol'])
lsqrargs['atol'] = kwargs['atol']
if 'btol' in kwargs:
logger.info('Using btol of %f' % kwargs['btol'])
lsqrargs['btol'] = kwargs['btol']
if 'show' in kwargs:
lsqrargs['show'] = kwargs['show']
if 'conlim' in kwargs:
lsqrargs['conlim'] = kwargs['conlim']
return sla.lsqr(A, B, **lsqrargs)[0]
def test_well_conditioned_problems():
# Test that sparse the lsqr solver returns the right solution
# on various problems with different random seeds.
# This is a non-regression test for a potential ZeroDivisionError
# raised when computing the `test2` & `test3` convergence conditions.
n = 10
A_sparse = scipy.sparse.eye(n, n)
A_dense = A_sparse.toarray()
with np.errstate(invalid="raise"):
for seed in range(30):
rng = np.random.RandomState(seed + 10)
beta = rng.rand(n)
beta[beta == 0] = 0.00001 # ensure that all the betas are not null
b = A_sparse * beta[:, np.newaxis]
output = lsqr(A_sparse, b, show=show)
# Check that the termination condition corresponds to an approximate
# solution to Ax = b
assert_equal(output[1], 1)
solution = output[0]
# Check that we recover the ground truth solution
assert_array_almost_equal(solution, beta)
# Sanity check: compare to the dense array solver
reference_solution = np.linalg.solve(A_dense, b).ravel()
assert_array_almost_equal(solution, reference_solution)
def poisson_blend(self, source, mask, tinyt, maximum=False):
"""
Blends the source image into the target using a mask.
Args:
source (2D float np.array): Values of source image at relevant blending pixels;
same size as mask array (may be smaller than source image)
mask (2D bool np.array): Mask with 1 (True) values for source pixels
tinyt (2D float np.array): Values of target image at relevant blending pixels;
same size as mask array (may be smaller than target image)
Returns:
(2D float np.array): Channel of modified target image with section of source image
"""
mask_dilated = self.dilate(mask)
mask_border = mask ^ mask_dilated
A4 = self.construct_A4(source)
t_prime = A4.dot(tinyt.ravel())
s_prime = A4.dot(source.ravel())
b = t_prime.copy()
if maximum:
max_prime = np.maximum(s_prime, t_prime)
b = self.set_b(b, mask.ravel(), max_prime)
else:
b = self.set_b(b, mask.ravel(), s_prime)
tinyt_values = np.concatenate([tinyt.ravel(), tinyt.ravel(), tinyt.ravel(), tinyt.ravel()])
b = self.set_b(b, mask_border.ravel(), tinyt_values)
A4 = self.construct_A4(source, mask_border=mask_border)
imh, imw = source.shape
v = lsqr(A4, b)[0]
return v.reshape((imh, imw)).clip(0, 1)
def test_FFT2D_random_real(par):
shape = par["shape"]
dtype, decimal = par["dtype_precision"]
ifftshift_before = par["ifftshift_before"]
engine = par["engine"]
x = np.random.randn(*shape).astype(dtype)
# Select an axis to apply FFT on. It can be any integer
# in [0,..., ndim-1] but also in [-ndim, ..., -1]
# However, dimensions cannot be repeated
axes = _choose_random_axes(x.ndim, n_choices=2)
FFTop = FFT2D(
dims=x.shape,
dirs=axes,
ifftshift_before=ifftshift_before,
real=True,
dtype=dtype,
engine=engine,
)
x = x.ravel()
y = FFTop * x
# Ensure inverse and adjoint recover x
xadj = FFTop.H * y # adjoint is same as inverse for fft
xinv = lsqr(FFTop, y, damp=0, iter_lim=10, show=0)[0]
assert_array_almost_equal(x, xadj, decimal=decimal)
assert_array_almost_equal(x, xinv, decimal=decimal)
# Dot tests
nr, nc = FFTop.shape
assert dottest(FFTop, nr, nc, complexflag=0, tol=10**(-decimal))
assert dottest(FFTop, nr, nc, complexflag=2, tol=10**(-decimal))
def derivative(dA, db, dc, **kwargs):
"""Applies derivative at (A, b, c) to perturbations dA, db, dc
Args:
dA: SciPy sparse matrix in CSC format; must have same sparsity
pattern as the matrix `A` from the cone program
db: NumPy array representing perturbation in `b`
dc: NumPy array representing perturbation in `c`
Returns:
NumPy arrays dx, dy, ds, the result of applying the derivative
to the perturbations.
"""
dQ = sparse.bmat(
[[None, dA.T, np.expand_dims(dc, -1)],
[-dA, None, np.expand_dims(db, -1)],
[-np.expand_dims(dc, -1).T, -np.expand_dims(db, -1).T, None]])
# can ignore w since w = 1
rhs = dQ @ pi_z
if np.allclose(rhs, 0):
dz = np.zeros(rhs.size)
else:
dz = splinalg.lsqr(M, rhs, **kwargs)[0]
du, dv, dw = np.split(dz, [n, n + m])
dx = du - x * dw
dy = D_proj_dual_cone @ dv - y * dw
ds = D_proj_dual_cone @ dv - dv - s * dw
return -dx, -dy, -ds
def test_VStack(par):
"""Dot-test and inversion for VStack operator"""
np.random.seed(0)
G1 = np.random.normal(0, 10, (par["ny"], par["nx"])).astype(par["dtype"])
G2 = np.random.normal(0, 10, (par["ny"], par["nx"])).astype(par["dtype"])
x = np.ones(par["nx"]) + par["imag"] * np.ones(par["nx"])
Vop = VStack(
[MatrixMult(G1, dtype=par["dtype"]), MatrixMult(G2, dtype=par["dtype"])],
dtype=par["dtype"],
)
assert dottest(
Vop, 2 * par["ny"], par["nx"], complexflag=0 if par["imag"] == 0 else 3
)
xlsqr = lsqr(Vop, Vop * x, damp=1e-20, iter_lim=300, atol=1e-8, btol=1e-8, show=0)[
0
]
assert_array_almost_equal(x, xlsqr, decimal=4)
# use numpy matrix directly in the definition of the operator
V1op = VStack([G1, MatrixMult(G2, dtype=par["dtype"])], dtype=par["dtype"])
assert dottest(
V1op, 2 * par["ny"], par["nx"], complexflag=0 if par["imag"] == 0 else 3
)
# use scipy matrix directly in the definition of the operator
G1 = sp_random(par["ny"], par["nx"], density=0.4).astype("float32")
V2op = VStack([G1, MatrixMult(G2, dtype=par["dtype"])], dtype=par["dtype"])
assert dottest(
V2op, 2 * par["ny"], par["nx"], complexflag=0 if par["imag"] == 0 else 3
)
def run_lsqr(self,logdamp,scale=True,**kwargs):
# scale the log(damp) into a damping
if logdamp is None:
damp=0.
else:
damp=10.**logdamp
if scale:
damp*=self.frob # scale the damping by frobenius
print('[info]Running LSQR with l={}'.format(damp))
t1=default_timer()
r=ssl.lsqr(self.A,self.bi,damp=damp,calc_var=True,**kwargs)
#atol=atol,btol=btol,conlim=conlim,iter_lim=maxiter)#
#,show=show,
print(r[1],r[2])
t2=default_timer()
dt=(t2-t1)/60. # in minutes
# take the target out
if self.target is not None:
r=(r[0]+self.target,*r[1:])
# package the outputs
r=LSQRResult(*r,r[-1].copy(),damp/self.frob)
# update the Lcurve
self.lcurve.append(r.r1norm,r.xnorm,r.logdamp)
return r
def backward(self, x, tau):
# (1 + tau A^T A)^-1(x + tau A^T b)
# which amounts to
# min_y ||A y - b||^2_F + tau * || y - x ||
# TODO solve the dual when we have fat matrix
if hasattr(self.A, 'A') and type(self.A.A) is _np.ndarray:
# self.A is a dense matrix
# we can pre-factorize the system using cholesky decomposition
# and then quickly re-solve the system
if self._solve_backward is None or self._solve_backward_tau != tau:
from scipy.linalg import cho_factor, cho_solve
A = self.A.A
H = tau * A.T.dot(A) + _np.eye(A.shape[1])
self._solve_backward = partial(cho_solve, cho_factor(H))
self._solve_backward_tau = tau
return self._solve_backward(x + tau * self.A.rmatvec(self.b))
else:
from scipy.sparse.linalg import lsqr, LinearOperator
def matvec(y):
return y + tau * self.A.rmatvec(self.A.matvec(y))
x, istop, itn, r1norm, r2norm, anorm, acond, arnorm, xnorm, var = \
lsqr(LinearOperator((self.A.shape[1], self.A.shape[1]), matvec, matvec),
x + tau * self.A.rmatvec(self.b))
return x
def test_HStack(par):
"""Dot-test and inversion for HStack operator with numpy array as input
"""
np.random.seed(0)
G1 = np.random.normal(0, 10, (par['ny'], par['nx'])).astype('float32')
G2 = np.random.normal(0, 10, (par['ny'], par['nx'])).astype('float32')
x = np.ones(2 * par['nx']) + par['imag'] * np.ones(2 * par['nx'])
Hop = HStack([G1, MatrixMult(G2, dtype=par['dtype'])], dtype=par['dtype'])
assert dottest(Hop,
par['ny'],
2 * par['nx'],
complexflag=0 if par['imag'] == 0 else 3)
xlsqr = lsqr(Hop, Hop * x, damp=1e-20, iter_lim=300, show=0)[0]
assert_array_almost_equal(x, xlsqr, decimal=4)
# use numpy matrix directly in the definition of the operator
H1op = HStack([G1, MatrixMult(G2, dtype=par['dtype'])], dtype=par['dtype'])
assert dottest(H1op,
par['ny'],
2 * par['nx'],
complexflag=0 if par['imag'] == 0 else 3)
# use scipy matrix directly in the definition of the operator
G1 = sp_random(par['ny'], par['nx'], density=0.4).astype('float32')
H2op = HStack([G1, MatrixMult(G2, dtype=par['dtype'])], dtype=par['dtype'])
assert dottest(H2op,
par['ny'],
2 * par['nx'],
complexflag=0 if par['imag'] == 0 else 3)
def test_well_conditioned_problems():
# Test that sparse the lsqr solver returns the right solution
# on various problems with different random seeds.
# This is a non-regression test for a potential ZeroDivisionError
# raised when computing the `test2` & `test3` convergence conditions.
n = 10
A_sparse = scipy.sparse.eye(n, n)
A_dense = A_sparse.toarray()
with np.errstate(invalid='raise'):
for seed in range(30):
rng = np.random.RandomState(seed + 10)
beta = rng.rand(n)
beta[beta == 0] = 0.00001 # ensure that all the betas are not null
b = A_sparse * beta[:, np.newaxis]
output = lsqr(A_sparse, b, show=show)
# Check that the termination condition corresponds to an approximate
# solution to Ax = b
assert_equal(output[1], 1)
solution = output[0]
# Check that we recover the ground truth solution
assert_allclose(solution, beta)
# Sanity check: compare to the dense array solver
reference_solution = np.linalg.solve(A_dense, b).ravel()
assert_allclose(solution, reference_solution)
def get_transformations_and_masks(triangulation, average_landmarks, original_landmarks):
transformations = {}
masks = {}
for idx, triangle in enumerate(triangulation.simplices):
orig_verts = np.take(original_landmarks, triangle, axis=0).astype('int32')
average_verts = np.take(average_landmarks, triangle, axis=0).astype('int32')
A = lil_matrix((6,6))
b = np.zeros((6, 1))
equation = 0
for idx2, vert in enumerate(orig_verts):
A[equation, :] = [vert[0], vert[1], 1, 0, 0, 0]
A[equation+1, :] = [0, 0, 0, vert[0], vert[1], 1]
b[equation] = average_verts[idx2][0]
b[equation+1] = average_verts[idx2][1]
equation += 2
A = A.tocsr()
results = linalg.lsqr(A, b, atol=1e-13, btol=1e-13)
v = results[0]
M = v.reshape((2,3))
transformations[idx] = M
mask = get_image_mask(900, 1200, orig_verts)
masks[idx] = mask
return transformations, masks
def test_Convolve3D(par):
"""Dot-test and inversion for ConvolveND operator
"""
# 3D on 3D
Cop = ConvolveND(par['nz'] * par['ny'] * par['nx'],
h=h3,
offset=par['offset'],
dims=[par['nz'], par['ny'], par['nx']],
dtype='float32')
assert dottest(Cop, par['nz'] * par['ny'] * par['nx'],
par['nz'] * par['ny'] * par['nx'])
x = np.zeros((par['nz'], par['ny'], par['nx']))
x[int(par['nz'] / 2 - 3):int(par['nz'] / 2 + 3),
int(par['ny'] / 2 - 3):int(par['ny'] / 2 + 3),
int(par['nx'] / 2 - 3):int(par['nx'] / 2 + 3)] = 1.
x = x.flatten()
y = Cop * x
xlsqr = lsqr(Cop, y, damp=1e-20, iter_lim=400, show=0)[0]
# due to ringing in solution we cannot use assert_array_almost_equal
assert np.linalg.norm(xlsqr - x) / np.linalg.norm(xlsqr) < 2e-1
# 3D on 4D (only modelling)
Cop = ConvolveND(par['nz'] * par['ny'] * par['nx'] * par['nt'],
h=h3,
offset=par['offset'],
dims=[par['nz'], par['ny'], par['nx'], par['nt']],
dirs=[0, 1, 2],
dtype='float32')
assert dottest(Cop, par['nz'] * par['ny'] * par['nx'] * par['nt'],
par['nz'] * par['ny'] * par['nx'] * par['nt'])
def solveFunctionWithConstraints(self, constraints, deltaCoords, g, overwriteRows = None): #TODO: Implement overwriteRows (I, J, V) = self.getLaplacianSparseMatrixCoords(overwriteRows, LaplaceBeltramiWeightFunc) NVerts = len(self.vertices) NConstraints = g.shape[0] Y = deltaCoords.shape[1] for i in range(NConstraints): constraint = constraints[i] for elem in constraint: (index, val) = elem I.append(i + NVerts) J.append(index) V.append(val) N = NVerts + NConstraints M = NVerts b = deltaCoords if g.shape[0] > 0: b = np.append(deltaCoords, g, axis = 0) I = np.array(I) J = np.array(J) V = np.array(V) #print "V.shape = %s, N = %i, M = %i"%(V.shape, N, M) A = sparse.coo_matrix((V, (I, J)), shape=(N,M)).tocsr() ret = np.zeros((NVerts, Y)) for i in range(Y): print "Solving column %i..."%i thisColumn = lsqr(A, b[:, i])[0] ret[:, i] = thisColumn return ret
def _calculate(self, graph1, graph2, i, j):
if self.is_training and (self.res[j, i] > 0 or self.res[i, j] > 0):
return
# norm1, norm2 - normalized adjacency matrixes
# norm1 = _norm(graph1)
# norm2 = _norm(graph2)
norm1 = graph1
norm2 = graph2
# if graph is unweighted, W_prod = kron(a_norm(g1)*a_norm(g2))
w_prod = kron(lil_matrix(norm1), lil_matrix(norm2))
starting_prob = np.ones(w_prod.shape[0]) / (w_prod.shape[0])
stop_prob = starting_prob
# first solve (I - lambda * W_prod) * x = p_prod
A = identity(w_prod.shape[0]) - (w_prod * self._lmb)
x = lsqr(A, starting_prob)
self.res[i, j] = stop_prob.T.dot(x[0])
if self.is_training:
self.res[j, i] = self.res[i, j]
print 'Kernel: ', i, ', ', j, self.res[i, j]
def fit(self, X, y):
"""
Fit linear model.
Parameters
----------
X : numpy array or sparse matrix of shape [n_samples,n_features]
Training data
y : numpy array of shape [n_samples]
Target values
Returns
-------
self : returns an instance of self.
"""
X = safe_asarray(X)
y = np.asarray(y)
X, y, X_mean, y_mean, X_std = self._center_data(X, y,
self.fit_intercept, self.normalize, self.copy_X)
if sp.issparse(X):
if hasattr(sp_linalg, 'lsqr'):
out = sp_linalg.lsqr(X, y)
self.coef_ = out[0]
self.residues_ = out[3]
else:
# DEPENDENCY: scipy 0.7
self.coef_ = sp_linalg.spsolve(X, y)
self.residues_ = y - safe_sparse_dot(X, self.coef_)
else:
self.coef_, self.residues_, self.rank_, self.singular_ = \
linalg.lstsq(X, y)
self._set_intercept(X_mean, y_mean, X_std)
return self
def backward(self, x, tau):
# (1 + tau A^T A)^-1(x + tau A^T b)
# which amounts to
# min_y ||A y - b||^2_F + tau * || y - x ||
# TODO solve the dual when we have fat matrix
if hasattr(self.A, 'A') and type(self.A.A) is _np.ndarray:
# self.A is a dense matrix
# we can pre-factorize the system using cholesky decomposition
# and then quickly re-solve the system
if self._solve_backward is None or self._solve_backward_tau != tau:
from scipy.linalg import cho_factor, cho_solve
A = self.A.A
H = tau * A.T.dot(A) + _np.eye(A.shape[1])
self._solve_backward = partial(cho_solve, cho_factor(H))
self._solve_backward_tau = tau
return self._solve_backward(x + tau * self.A.rmatvec(self.b))
else:
from scipy.sparse.linalg import lsqr, LinearOperator
def matvec(y):
return y + tau * self.A.rmatvec(self.A.matvec(y))
x, istop, itn, r1norm, r2norm, anorm, acond, arnorm, xnorm, var = \
lsqr(LinearOperator((self.A.shape[1], self.A.shape[1]), matvec, matvec),
x + tau * self.A.rmatvec(self.b))
return x
def poisson_blend(s, s_mask, tinyt, t, tinyt_topleft, maximum=False):
s_inside = inside(s_mask)
s_border = s_mask & ~s_inside
s_outside = ~s_inside
A4 = construct_A4(s)
t_prime = A4.dot(tinyt.ravel())
s_prime = A4.dot(s.ravel())
b = t_prime.copy()
if maximum == True:
max_prime = np.maximum(s_prime, t_prime)
b = set_b(b, s_inside.ravel(), max_prime)
else:
b = set_b(b, s_inside.ravel(), s_prime)
tinyt_values = np.concatenate([tinyt.ravel(), tinyt.ravel(), tinyt.ravel(), tinyt.ravel()])
b = set_b(b, s_border.ravel(), tinyt_values)
A4 = construct_A4(s, s_border=s_border)
imh, imw = s.shape
v = lsqr(A4, b)[0]
out = v.reshape((imh, imw))
tttly, tttlx = tinyt_topleft
tty, ttx = tinyt.shape
t[tttly:tttly + tty, tttlx:tttlx + ttx] = out
return t
def _solve_sym_nonposdef(self, Q, q):
# since Q is indefinite, i.e., the function is linear along the eigenvectors
# correspondent to the null eigenvalues, the system has not solutions, so we
# will choose the one that minimizes the residue, i.e. the least-squares solution
# see more @ https://docs.scipy.org/doc/scipy/reference/sparse.linalg.html#solving-linear-problems
# bad numerical solution: does not exploit the symmetricity of Q, waiting for `symmlq` in scipy
if self.sym_nonposdef_solver == 'lsqr':
x = lsqr(Q, -q)[0]
else:
# `min ||Ax - b||` is formally equivalent to solve the linear system:
# A^T A x = A^T b
Q, q = np.inner(Q, Q), Q.T.dot(q)
if self.sym_nonposdef_solver == 'minres':
x = minres(Q, -q)[0]
else:
raise TypeError(
f'{self.sym_nonposdef_solver} is not an allowed solver, '
f'choose one of `minres` or `lsqr`')
return x
def infer_scene(self, data):
"""
Take data and a current belief about the PSF; infer the scene for
this image given the PSF.
## Arguments
* `data` (numpy.ndarray): The data.
## Returns
* `new_scene` (numpy.ndarray): The scene implied by this particular
data alone.
## Note
This method has been deprecated by `get_dlds` and the proper
stochastic gradient update. I'm keeping this here for now just in
case.
"""
# Infer scene and return
data_vector = np.append(data.flatten(), np.zeros(self.scene.size))
results = lsqr(self.get_psf_matrix(L2=True), data_vector)
new_scene = results[0].reshape(self.scene.shape)
return new_scene
def __truediv__(self, y, niter=100):
if self.explicit is True:
if sp.sparse.issparse(self.A):
# use scipy solver for sparse matrices
xest = spsolve(self.A, y)
elif isinstance(self.A, np.ndarray):
# use scipy solvers for dense matrices (used for backward
# compatibility, could be switched to numpy equivalents)
if self.A.shape[0] == self.A.shape[1]:
xest = solve(self.A, y)
else:
xest = lstsq(self.A, y)[0]
else:
# use numpy/cupy solvers for dense matrices
ncp = get_array_module(y)
if self.A.shape[0] == self.A.shape[1]:
xest = ncp.linalg.solve(self.A, y)
else:
xest = ncp.linalg.lstsq(self.A, y)[0]
else:
if isinstance(y, np.ndarray):
# numpy backend
xest = lsqr(self, y, iter_lim=niter)[0]
else:
# cupy backend
ncp = get_array_module(y)
xest = cgls(self,
y,
x0=ncp.zeros(int(self.shape[1]), dtype=self.dtype),
niter=niter)[0]
return xest
def lsqr_heat_phi_about_lm(self, landmark_key): geo = self.geodesics_about_lm(landmark_key, method='heat') div_X = geo['div_X'] L_c = self._cache['laplacian_cotangent'] lsqr_solution = sparse_linalg.lsqr(L_c, div_X, show=True) phi_lsqr = lsqr_solution[0] phi_lsqr = phi_lsqr - phi_lsqr[self.landmarks[landmark_key]] return phi_lsqr
def compute_lsqr(s):
imh, imw = s.shape
A2 = construct_A2(s)
b = A2.dot(s.ravel())
v = lsqr(A2, b)[0]
return v.reshape((imh, imw))
def extract_w_paralell(img, mlist):
'''
:param img: <fits>
:param mlist: <list> one element of the csr_matrix
:return: <ndarray> result of lsqr
'''
x = lsqr(mlist, img)
return x[0]
def doFlattening(mesh, quadIdxs):
if len(quadIdxs) != 4:
print "please select 4 points"
return
L = getLaplacianMatrixHelp(mesh, quadIdxs, umbrellaWeight, True)
delta = np.zeros((len(mesh.vertices), 3))
delta[quadIdxs, :] = [[0, 0, 0], [0, 1, 0], [1, 1, 0], [1, 0, 0]]
for col in range(3):
mesh.VPos[:, col] = lsqr(L, delta[:, col])[0]
def extract_w_paralell(img, mlist):
'''
:param img: <fits>
:param mlist: <list> one element of the csr_matrix
:return: <ndarray> result of lsqr
'''
from scipy.sparse.linalg import lsqr
x = lsqr(mlist, img)
return x[0]
def solveLaplacianMesh(mesh, anchors, anchorsIdx):
N = len(mesh.vertices)
K = len(anchorsIdx)
L = getLaplacianMatrixUmbrella(mesh, anchorsIdx)
#L = getLaplacianMatrixCotangent(mesh, anchorsIdx)
delta = np.array(L.dot(mesh.VPos))
for i in range(0, K):
delta[i+N, :] = anchors[i]
for j in range(3):
mesh.VPos[:, j] = lsqr(L, delta[:, j])[0]
def interpolate(self,t,pts):
"""
Initialize control points by interpolation.
"""
A = self.assemble_interpolation_matrix(t)
for i in range(0,self.d):
result = lsqr(A,pts[i])
self.cp[i,:] = result[0]
def beginDeformationTransfer(self):
resultFrames = np.empty([self.NFrames, self.NVertices, 3]) # this is result array to fill in
resultFrames[0, :, :] = self.warpedFrames[0, :, :]
origOldVPos4 = self.getVPos4(self.origFrames[0, :, :], self.ITris) # old VPos with extra NFaces vectors
warpedOldVPos4 = self.getVPos4(self.warpedFrames[0, :, :], self.ITris)
for i in range(1, self.NFrames):
# 1 orig: get newVPos4
origNewVPos4 = self.getVPos4(self.origFrames[i, :, :], self.ITris)
# 2 orig: use old and new VPos4 to get S-matrix which shape is 3 x 3NFaces
S = self.getSMatrix(origOldVPos4, origNewVPos4, self.Tris4)
# 3 warped: use old VPos4 to get A (coefficient) sparse matrix which shape is 3NFaces x NVertices
A = self.getAMatrix(warpedOldVPos4, self.Tris4)
origOldVPos4 = origNewVPos4
warpedOldVPos4[:, 0] = lsqr(A, S[0, :])[0]
warpedOldVPos4[:, 1] = lsqr(A, S[1, :])[0]
warpedOldVPos4[:, 2] = lsqr(A, S[2, :])[0]
# print "new VPos4 shape:", warpedOldVPos4[np.arange(self.NVertices), :].shape
resultFrames[i, :, :] = warpedOldVPos4[np.arange(self.NVertices), :]
self.warpedVideo.Frames = resultFrames
def depths(mask, normals):
"""Reconstructs the depths from normals.
Args:
normals: width x height x 3 array
"""
width, height, three = normals.shape
assert three == 3
m = dok_matrix((width*height*2, width*height), dtype=float)
b = np.zeros(width*height*2, dtype=float)
log.debug('maximal shape: %s', m.shape)
row = 0
coords = ConsistentBimap()
for x in range(width):
for y in range(height):
if not mask[x,y]: continue
elif not (mask[x+1,y] and mask[x,y+1] and mask[x-1,y] and mask[x,y-1]):
continue
else:
# n_z (z(x+1, y) - z(x, y)) = -n_x
m[row, coords[(x+1,y)]] = 1
m[row, coords[(x,y)]] = -1
b[row] = normals[x,y,X]/normals[x,y,Z]
row += 1
# n_z (z(x, y+1) - z(x, y)) = -n_y
m[row, coords[(x,y+1)]] = 1
m[row, coords[(x,y)]] = -1
b[row] = normals[x,y,Y]/normals[x,y,Z]
row += 1
# Now we know how many pixels are used and we restrict the matrix to the
# rows needed.
m_p = dok_matrix((row+1, coords.i), dtype=float)
for (x,y), v in m.items():
try:
m_p[x,y] = v
except Exception as e:
log.error('error at (%s, %s)', x, y)
raise
# normalization
m_p[row,0] = 1
m_p = m_p.tocsr()
b = b[:row+1]
log.debug('actual shape: %s', m_p.shape)
s = lsqr(m_p, b, atol=1e-3, btol=1e-6, show=True)
z_p = s[0]
z_p = normalize(z_p)
z = np.zeros((width, height))
for row,(x,y) in coords.r.items():
z[x,y] = z_p[row]
log.debug('z(0,0) = %s', z[0,0])
return z
def doFlattening(mesh, quadIdxs):
N = mesh.VPos.shape[0]
L = getLaplacianMatrixUmbrella(mesh, [])
vertices = [[0, 0, 0], [0, 1, 0], [1, 1, 0], [1, 0, 0]]
delta = np.zeros((N, 3))
for i in range(4):
L[quadIdxs[i], :] = 0
L[quadIdxs[i], quadIdxs[i]] = 1
delta[quadIdxs[i], :] = vertices[i]
for j in range(3):
mesh.VPos[:, j] = lsqr(L, delta[:, j])[0]
def solveLaplacianMesh(VPos, ITris, anchorsIdx, anchors):
N = VPos.shape[0]
L = getLaplacianMatrixCotangent(VPos, ITris, anchorsIdx)
delta = L.dot(VPos)
delta[N:, :] = anchors
sio.savemat("System.mat", {"L":L, "delta":delta})
VPosNew = np.zeros((N, 3))
for k in range(3):
print "Solving Laplacian mesh coordinates %i of %i..."%(k+1, 3)
VPosNew[:, k] = lsqr(L, delta[:, k])[0]
return VPosNew
def aper_extract(model_map, wcols, img):
from scipy.sparse.linalg import lsqr
n0 = model_map.total_fibers
n1 = img.shape[1]
rss = numpy.zeros((n0, n1))
for key, val in wcols.items():
yl = img[:, key]
res = lsqr(val, yl)
rss[:, key] = res[0]
return rss
def learn(self, state_iterator):
print("building the input matrix from states")
A, b = self._build_equations(state_iterator)
print("shape: A: {}, b: {}".format(A.shape, b.shape))
print("converting A to CSR format")
A = A.tocsr()
print("least squares")
self.x = lsqr(A, b)[0]
def interpolate(self,A,t,pts):
"""
Initialize control points by interpolation.
"""
if(len(pts)!=self.d):
print "Dimension mismatch..."
return
for i in range(0,self.d):
result = lsqr(A,pts[i])
self.cp[i,:,:] = np.reshape(result[0],(self.cp.shape[1],self.cp.shape[2]))
def lamed(self):
"""lamed, the Phoenician name for lambda. (As the word lambda is
reserved in Python.)"""
if self._lamed is None:
eH = powerflow(self.ev, self.extY)
resid = self.eb - eH
rresid = resid[self.reindr2eindr]
out = spsl.lsqr(self.C, rresid, atol=1e-14, btol=1e-14)
# assert out[3] < 1e-8
self._lamed = np.matrix(out[0]).T
return self._lamed
def _solve_lsqr(X, y, alpha, max_iter=None, tol=1e-3):
n_samples, n_features = X.shape
coefs = np.empty((y.shape[1], n_features))
# According to the lsqr documentation, alpha = damp^2.
sqrt_alpha = np.sqrt(alpha)
for i in range(y.shape[1]):
y_column = y[:, i]
coefs[i] = sp_linalg.lsqr(X, y_column, damp=sqrt_alpha[i], atol=tol, btol=tol, iter_lim=max_iter)[0]
return coefs
