def get_F_T_projection(): """ INPUT: Takes OUTPUT: U matrix in csr format """ import scipy.sparse as sp GRID_CENTERS = grid_cell_centers() F = sp.kron(sp.identity(len(GRID_CENTERS)), numpy.array([1,1,1])) F = F.tocsc() v = numpy.array([1]*len(GRID_CENTERS)) factor = cholmod.cholesky_AAt(F) FFT_inv_F = sp.lil_matrix((F.shape[0], F.shape[1])) for i in range(F.shape[1]): FFT_inv_F[:,i] = factor(F[:,i].toarray()) Proj_matrix = F.T*FFT_inv_F Proj_perp_matrix = sp.identity(Proj_matrix.shape[0])-Proj_matrix v_bar = F.T*factor(v) return (Proj_perp_matrix, v_bar)
def test_cholesky_matrix_market(): for problem in ("well1033", "illc1033", "well1850", "illc1850"): X = mm_matrix(problem) y = mm_matrix(problem + "_rhs1") answer = np.linalg.lstsq(X.todense(), y)[0] XtX = (X.T * X).tocsc() Xty = X.T * y for mode in ("auto", "simplicial", "supernodal"): assert np.allclose(cholesky(XtX, mode=mode)(Xty), answer) assert np.allclose(cholesky_AAt(X.T, mode=mode)(Xty), answer) assert np.allclose(cholesky(XtX, mode=mode).solve_A(Xty), answer) assert np.allclose( cholesky_AAt(X.T, mode=mode).solve_A(Xty), answer) f1 = analyze(XtX, mode=mode) f2 = f1.cholesky(XtX) assert np.allclose(f2(Xty), answer) assert_raises(CholmodError, f1, Xty) assert_raises(CholmodError, f1.solve_A, Xty) assert_raises(CholmodError, f1.solve_LDLt, Xty) assert_raises(CholmodError, f1.solve_LD, Xty) assert_raises(CholmodError, f1.solve_DLt, Xty) assert_raises(CholmodError, f1.solve_L, Xty) assert_raises(CholmodError, f1.solve_D, Xty) assert_raises(CholmodError, f1.apply_P, Xty) assert_raises(CholmodError, f1.apply_Pt, Xty) f1.P() assert_raises(CholmodError, f1.L) assert_raises(CholmodError, f1.LD) assert_raises(CholmodError, f1.L_D) assert_raises(CholmodError, f1.L_D) f1.cholesky_inplace(XtX) assert np.allclose(f1(Xty), answer) f3 = analyze_AAt(X.T, mode=mode) f4 = f3.cholesky(XtX) assert np.allclose(f4(Xty), answer) assert_raises(CholmodError, f3, Xty) f3.cholesky_AAt_inplace(X.T) assert np.allclose(f3(Xty), answer) print problem, mode for f in (f1, f2, f3, f4): pXtX = XtX.todense()[f.P()[:, np.newaxis], f.P()[np.newaxis, :]] assert np.allclose(np.prod(f.D()), np.linalg.det(XtX.todense())) assert np.allclose((f.L() * f.L().T).todense(), pXtX) L, D = f.L_D() assert np.allclose((L * D * L.T).todense(), pXtX) b = np.arange(XtX.shape[0])[:, np.newaxis] assert np.allclose(f.solve_A(b), np.dot(XtX.todense().I, b)) assert np.allclose(f(b), np.dot(XtX.todense().I, b)) assert np.allclose(f.solve_LDLt(b), np.dot((L * D * L.T).todense().I, b)) assert np.allclose(f.solve_LD(b), np.dot((L * D).todense().I, b)) assert np.allclose(f.solve_DLt(b), np.dot((D * L.T).todense().I, b)) assert np.allclose(f.solve_L(b), np.dot(L.todense().I, b)) assert np.allclose(f.solve_Lt(b), np.dot(L.T.todense().I, b)) assert np.allclose(f.solve_D(b), np.dot(D.todense().I, b)) assert np.allclose(f.apply_P(b), b[f.P(), :]) assert np.allclose(f.solve_P(b), b[f.P(), :]) # Pt is the inverse of P, and argsort inverts permutation # vectors: assert np.allclose(f.apply_Pt(b), b[np.argsort(f.P()), :]) assert np.allclose(f.solve_Pt(b), b[np.argsort(f.P()), :])
def test_cholesky_matrix_market(): for problem in ("well1033", "illc1033", "well1850", "illc1850"): X = mm_matrix(problem) y = mm_matrix(problem + "_rhs1") answer = np.linalg.lstsq(X.todense(), y)[0] XtX = (X.T * X).tocsc() Xty = X.T * y for mode in ("auto", "simplicial", "supernodal"): assert np.allclose(cholesky(XtX, mode=mode)(Xty), answer) assert np.allclose(cholesky_AAt(X.T, mode=mode)(Xty), answer) assert np.allclose(cholesky(XtX, mode=mode).solve_A(Xty), answer) assert np.allclose(cholesky_AAt(X.T, mode=mode).solve_A(Xty), answer) f1 = analyze(XtX, mode=mode) f2 = f1.cholesky(XtX) assert np.allclose(f2(Xty), answer) assert_raises(CholmodError, f1, Xty) assert_raises(CholmodError, f1.solve_A, Xty) assert_raises(CholmodError, f1.solve_LDLt, Xty) assert_raises(CholmodError, f1.solve_LD, Xty) assert_raises(CholmodError, f1.solve_DLt, Xty) assert_raises(CholmodError, f1.solve_L, Xty) assert_raises(CholmodError, f1.solve_D, Xty) assert_raises(CholmodError, f1.apply_P, Xty) assert_raises(CholmodError, f1.apply_Pt, Xty) f1.P() assert_raises(CholmodError, f1.L) assert_raises(CholmodError, f1.LD) assert_raises(CholmodError, f1.L_D) assert_raises(CholmodError, f1.L_D) f1.cholesky_inplace(XtX) assert np.allclose(f1(Xty), answer) f3 = analyze_AAt(X.T, mode=mode) f4 = f3.cholesky(XtX) assert np.allclose(f4(Xty), answer) assert_raises(CholmodError, f3, Xty) f3.cholesky_AAt_inplace(X.T) assert np.allclose(f3(Xty), answer) print problem, mode for f in (f1, f2, f3, f4): pXtX = XtX.todense()[f.P()[:, np.newaxis], f.P()[np.newaxis, :]] assert np.allclose(np.prod(f.D()), np.linalg.det(XtX.todense())) assert np.allclose((f.L() * f.L().T).todense(), pXtX) L, D = f.L_D() assert np.allclose((L * D * L.T).todense(), pXtX) b = np.arange(XtX.shape[0])[:, np.newaxis] assert np.allclose(f.solve_A(b), np.dot(XtX.todense().I, b)) assert np.allclose(f(b), np.dot(XtX.todense().I, b)) assert np.allclose(f.solve_LDLt(b), np.dot((L * D * L.T).todense().I, b)) assert np.allclose(f.solve_LD(b), np.dot((L * D).todense().I, b)) assert np.allclose(f.solve_DLt(b), np.dot((D * L.T).todense().I, b)) assert np.allclose(f.solve_L(b), np.dot(L.todense().I, b)) assert np.allclose(f.solve_Lt(b), np.dot(L.T.todense().I, b)) assert np.allclose(f.solve_D(b), np.dot(D.todense().I, b)) assert np.allclose(f.apply_P(b), b[f.P(), :]) assert np.allclose(f.solve_P(b), b[f.P(), :]) # Pt is the inverse of P, and argsort inverts permutation # vectors: assert np.allclose(f.apply_Pt(b), b[np.argsort(f.P()), :]) assert np.allclose(f.solve_Pt(b), b[np.argsort(f.P()), :])
def spsolve(sparse_X, dense_b): factor = cholesky_AAt(sparse_X.T) return factor(sparse_X.T.dot(dense_b)).toarray()
mat_zp = np.zeros((5, J.shape[1])) mat_zp[0, -5] = 1 mat_zp[1, -4] = 1 mat_zp[2, -3] = 1 mat_zp[3, -2] = 1 mat_zp[4, -1] = 1 J = sparse.coo_matrix(np.append(J.toarray(), mat_zp, axis=0)) sigmas = np.append(sigmas, 1*np.ones(5)) sigmas[-3] = 0.00001 values = np.append(values, np.zeros(5)) W1_2 = np.diag(1/sigmas) W = sparse.coo_matrix(W1_2**2) W1_2 = sparse.coo_matrix(W1_2) VJ = (W1_2 * J).tocsr() factor = cholesky_AAt(VJ.T) ga = factor(J.T * W*values) spec = ga[:n+1] dist = ga[n+1:-5] dzps = ga[-5:] fisher = (VJ.T*VJ).toarray() cov = np.linalg.inv(fisher) computed_sigmas = np.diag(np.ones(cov.shape[0]))*cov computed_sigmas = np.sqrt(computed_sigmas[computed_sigmas!=0].flatten()) #### Fit cosmo from pycosmo import priors def cosmo_part(cosmo, zs): x0 = cosmo.pars()
def lensModel(imagesetup,sourcesetup,lenses,gals,regconst,csub=11,psf=None,noResid=False,mapping='polygon',outputimages=False,returnRegCoeffs=False,mask2=None): image,sig,yc,xc,y0,x0,P,c,C,indx,imshape,mask=imagesetup srcx,srcy,srcxaxis,srcyaxis,R,pscale,sshape=sourcesetup import pixellatedTools import numpy import indexTricks as iT from imageSim import convolve from scipy.sparse.linalg import lsmr from scipy.sparse import diags galsubimage = image*1. for gal in gals: gal.setPars() galsubimage -= P*gal.pixeval(x0,y0,csub=csub) galsum=(image-galsubimage)#.reshape(imshape) for lens in lenses: lens.setPars() if mapping =='polygon': Lm = pixellatedTools.getLensPoly(lenses,indx,xc,yc,srcx,srcy,pscale) if mapping =='bilinear': Lm = pixellatedTools.getLensMatrixBilinear(lenses,x0,y0,srcx,srcy,srcxaxis,srcyaxis) if mapping =='nearest': Lm = pixellatedTools.getLensMatrixNNTom(lenses,x0,y0,srcx,srcy,srcxaxis,srcyaxis) if regconst!=0: Sinv=diags([regconst],[0],shape=R.shape)*R Om = P*Lm B=Om.T*C*Om rhs = Om.T*(galsubimage/sig**2) if regconst!=0:lhs = (B)+Sinv else: lhs=B #old slow method, not using cholesky decomposition #fit = lsmr(lhs,rhs,maxiter=5000) #fit=fit[0] from scikits.sparse.cholmod import cholesky_AAt A=lhs F=cholesky_AAt((A.T).tocsc()) fit = F(A.T * rhs) imin=image.copy() s=sig.copy() im=numpy.zeros(imshape).flatten() if mask != None: s=numpy.ones(imshape).flatten()*1e-99 s[mask]=sig imin=numpy.zeros(imshape).flatten() imin[mask]=image s=s.reshape(imshape) imin=imin.reshape(imshape) if outputimages: import pyfits im[mask]+= (Om*fit) im[mask]+=galsum im=im.reshape(imshape) src=fit.reshape(sshape).copy() pyfits.PrimaryHDU(im).writeto("model.fits",clobber=True) pyfits.PrimaryHDU((imin-im)/s).writeto("resid.fits",clobber=True) pyfits.PrimaryHDU(src).writeto("src.fits",clobber=True) sig=sig.flatten() #if noResid: return [(Om*fit).reshape(imshape),fit] resid=((Om*fit)-galsubimage)/sig #this prunes out the inner region of the fit - i.e. the regime where the regularization has no impact. if mask2!=None: galsubimage=galsubimage[mask2] Om=Om.tocsc()[mask2[0],:] C=diags(1./(sig[mask2])**2,0) s=numpy.matrix(fit).T #d=numpy.matrix(galsubimage).T #f=Om #Cdinv=C Ed=0.5*(resid**2).sum() Es=(0.5*((s.T)*(R*s)))[0,0] M=-(Ed+regconst*Es) return M,Es,B,R,F