def __init__(self, reconstruct_method):
super().__init__()
self.reconstruct_method = reconstruct_method
method = {
'LinearRegression':
LinearRegression(fit_intercept=False, n_jobs=-1),
'Ridge':
Ridge(
alpha=1e-4,
fit_intercept=False,
tol=1e-2,
),
'Lasso':
Lasso(
alpha=1e-5,
fit_intercept=False,
warm_start=False,
tol=1e-3,
),
'ElasticNet':
ElasticNet(
alpha=1e-2,
l1_ratio=0.5,
fit_intercept=False,
tol=1e-3,
),
'OMP':
OMP(n_nonzero_coefs=num_range * num_sample_per_batch,
fit_intercept=False),
}
self.clf = method[reconstruct_method]
print('Reconstructor initialized with the method as %s' %
reconstruct_method)
def GetNeighborDims(data, paras):
ndata, ndim=data.shape
kND=paras["kND"]
objOMP=OMP(n_nonzero_coefs=kND)
idxDict=npy.ones(ndim, dtype=npy.bool)
w=npy.zeros((ndim-1, ndim), dtype=npy.float32)
for kk in range(ndim):
idxDict.fill(True)
idxDict[kk]=False
objOMP.fit(data[:,idxDict], data[:,kk])
w[:,kk]=objOMP.coef_.astype(npy.float32)
return w
def _solver_OMP(A, b, K):
"""
Find a K-sparse solution to Ax = b.
@param K Sparsity of the solution.
"""
from sklearn.linear_model import OrthogonalMatchingPursuit as OMP
omp = OMP(n_nonzero_coefs=K)
omp.fit(A, b)
x = omp.coef_
return x
def __init__(self,
n_nonzero_coefs=None,
tol=None,
fit_intercept=True,
normalize=False,
precompute='auto'):
self.n_nonzero_coefs = n_nonzero_coefs
self.precompute = precompute
self.fit_intercept = fit_intercept
self.tol = tol
self.normalize = normalize
self.model = OMP(fit_intercept=self.fit_intercept,
n_nonzero_coefs=self.n_nonzero_coefs,
precompute=self.precompute,
normalize=self.normalize,
tol=self.tol)
# -----------------------------------
sys.stderr.write("Training classifiers... \r")
t0 = time.time()
# OMP: Orthogonal Matching Pursuit
from sklearn.linear_model import OrthogonalMatchingPursuit as OMP
from sklearn.feature_selection import f_classif, SelectKBest
from sklearn.pipeline import Pipeline
# Create as many OMP as voxels to predict
clfs = []
n_clfs = y_train.shape[1]
for i in range(y_train.shape[1]):
sys.stderr.write("Training classifiers %03d/%d... \r" % (i + 1, n_clfs))
clf = Pipeline([('selection', SelectKBest(f_classif, 500)),
('clf', OMP(n_nonzero_coefs=10))])
clf.fit(X_train, y_train[:, i])
clfs.append(clf)
sys.stderr.write("Training classifiers %03d/%d... Done (%.2fs).\n" %
(n_clfs, n_clfs, time.time() - t0))
############################################################################
# Here we run the prediction: the decoding itself
# ------------------------------------------------
sys.stderr.write("Calculating scores and outputs...")
t0 = time.time()
y_pred = []
for clf in clfs:
y_pred.append(clf.predict(X_test))
def shapelet_decomposition(N1=20, N2=20, basis='XY'):
# Obtaining galaxy images
cube_real = pyfits.getdata('../../data/cube_real.fits')
cubr_real_noiseless = pyfits.getdata('../../data/cube_real_noiseless.fits')
background = 1.e6 * 0.16**2
img = galsim.Image(78, 78) # cube_real has 100, 78x78 images
D = np.zeros((78 * 78, 4 * N1 * N2)) # alloc for Dictionary
base_coefs = np.zeros((N1, N2))
X = np.linspace(0, 77, 78)
Y = np.linspace(0, 77, 78)
for img_idx in [91]:
cube_real[img_idx] -= background
img = galsim.Image(cube_real[img_idx], xmin=0, ymin=0)
shape = img.FindAdaptiveMom()
x0, y0 = shape.moments_centroid.x, shape.moments_centroid.y ## possible swap b/w x,y
sigma = shape.moments_sigma
Xv, Yv = np.meshgrid((X - x0), (Y - y0))
R = np.sqrt(Xv**2 + Yv**2)
Phi = np.zeros_like(R)
for i in xrange(np.shape(Xv)[0]):
for j in xrange(np.shape(Xv)[1]):
Phi[i, j] = math.atan2(Yv[i, j], Xv[i, j])
signal = cube_real[img_idx].flatten()
shapelet_reconst = np.zeros_like(signal)
k_p = 0
if (basis == 'Polar'):
for n in xrange(N1):
for m in xrange(-n, n + 1, 2):
if (
n <= (78 / sigma - 1)
): # n_max ~ theta_max (image size) / theta_min (pixel or kernel smoothing size) -1
arr = p_shapelet.polar_shapelets_real(n, m, sigma)(
R, Phi).flatten()
arr_im = p_shapelet.polar_shapelets_imag(n, m, sigma)(
R, Phi).flatten()
#arr = shapelet2d(m,n,x0=x0,y0=y0,sx=sigma,sy=sigma)(X,Y).flatten()
#arr2 = shapelet2d(m,n,x0=x0,y0=y0,sx=0.5*sigma,sy=0.5*sigma)(X,Y).flatten()
#arr3 = shapelet2d(m,n,x0=x0,y0=y0,sx=1.5*sigma,sy=2.*sigma)(X,Y).flatten()
#arr4 = shapelet2d(m,n,x0=x0,y0=y0,sx=2.0*sigma,sy=2.0*sigma)(X,Y).flatten()
D[:, k_p] = arr
#D[:,k+N1*N2]=arr2; D[:,k+2*N1*N2]=arr3; D[:,k+3*N1*N2]=arr4
k_p += 1
arr_norm2 = np.dot(arr, arr)
arr_norm_im2 = np.dot(arr_im, arr_im)
coef_r = np.dot(arr, signal)
coef_im = np.dot(arr_im, signal)
print(coef_im)
#coef_im = np.dot(arr_im, signal)
if (coef_r == 0):
base_coefs[n, m] = 0
else:
base_coefs[n, m] = coef_r / np.sqrt(
arr_norm2
) #coef_im/np.sqrt(arr_norm_im2)#np.sqrt(arr_norm2)#np.abs(coef/np.sqrt(arr_norm2) + coef_im/np.sqrt(arr_norm_im2))
shapelet_reconst = shapelet_reconst + (
coef_r * arr
) / arr_norm2 #+ coef_im*arr_im/arr_norm_im2
else:
break
elif (basis == 'XY'):
for k in xrange(N1 * N2):
m, n = k / N1, k % N1
if (m + n <= (78 / sigma - 1)):
arr = shapelet2d(m, n, x0=x0, y0=y0, sx=sigma,
sy=sigma)(X, Y).flatten()
#arr2 = shapelet2d(m,n,x0=x0,y0=y0,sx=0.5*sigma,sy=0.5*sigma)(X,Y).flatten()
#arr3 = shapelet2d(m,n,x0=x0,y0=y0,sx=1.5*sigma,sy=2.*sigma)(X,Y).flatten()
#arr4 = shapelet2d(m,n,x0=x0,y0=y0,sx=2.0*sigma,sy=2.0*sigma)(X,Y).flatten()
D[:, k] = arr
#D[:,k+N1*N2]=arr2; D[:,k+2*N1*N2]=arr3; D[:,k+3*N1*N2]=arr4
arr_norm2 = np.dot(arr, arr)
coef = np.dot(arr, signal)
#coef_im = np.dot(arr_im, signal)
if (coef == 0):
base_coefs[n, m] = 0
else:
base_coefs[n, m] = coef / np.sqrt(
arr_norm2
) #coef_im/np.sqrt(arr_norm_im2)#np.sqrt(arr_norm2)#np.abs(coef/np.sqrt(arr_norm2) + coef_im/np.sqrt(arr_norm_im2))
shapelet_reconst = shapelet_reconst + (
coef *
arr) / arr_norm2 #+ coef_im*arr_im/arr_norm_im2
else:
break
residual = signal - shapelet_reconst
residual_energy_fraction = np.sum(residual**2) / np.sum(signal**2)
recovered_energy_fraction = np.sum(shapelet_reconst**2) / np.sum(signal
**2)
print "Comparing moments_amp to base_coefs[0,0]", base_coefs[
0, 0], shape.moments_amp
print "Base coefficients sum over signal", np.sum(base_coefs**2) / (
np.sum(signal**2)), np.sum(residual**2) / np.sum(signal**2)
fig, ax = plt.subplots(2, 2)
coeff_plot2d(base_coefs, N1, N2, ax=ax[1, 1], fig=fig)
vmin, vmax = min(shapelet_reconst.min(),
signal.min()), max(shapelet_reconst.max(),
signal.max())
im00 = ax[0, 0].imshow(cube_real[img_idx], vmin=vmin, vmax=vmax)
im01 = ax[0, 1].imshow(shapelet_reconst.reshape(78, 78),
vmin=vmin,
vmax=vmax)
im10 = ax[1, 0].imshow(residual.reshape(78, 78))
fig.colorbar(im00, ax=ax[0, 0])
fig.colorbar(im01, ax=ax[0, 1])
fig.colorbar(im10, ax=ax[1, 0])
ax[0, 0].set_title('Original (noisy) image')
ax[0, 1].set_title('Reconstructed image - Frac. of energy = ' +
str(np.round(recovered_energy_fraction, 4)))
ax[1, 0].set_title('Residual image - Frac. of energy = ' +
str(np.round(residual_energy_fraction, 4)))
ax[1, 1].set_title('Rel. magnitude of coefficients')
fig.suptitle('Shapelet Basis decomposition')
plt.savefig('Decomp_cartesian.png')
# Sparse solver
omp = OMP(n_nonzero_coefs=N1 * N2 / 4)
omp.fit(D, signal)
sparse_coefs = omp.coef_
sparse_idx = sparse_coefs.nonzero()
sparse_reconst = np.dot(D, sparse_coefs)
sparse_residual = signal - sparse_reconst
residual_energy_fraction = np.sum(sparse_residual**2) / np.sum(signal**
2)
recovered_energy_fraction = np.sum(sparse_reconst**2) / np.sum(signal**
2)
fig2, ax2 = plt.subplots(2, 2)
im00 = ax2[0, 0].imshow(cube_real[img_idx])
im01 = ax2[0, 1].imshow(sparse_reconst.reshape(78, 78))
im10 = ax2[1, 0].imshow(sparse_residual.reshape(78, 78))
print sparse_coefs.shape
sparse_coefs = sparse_coefs.reshape(2 * N1, 2 * N2)
coeff_plot2d(sparse_coefs, N1 * 2, N2 * 2, ax=ax2[1, 1], fig=fig)
ax2[1, 1].grid(lw=2)
fig2.colorbar(im00, ax=ax2[0, 0])
fig2.colorbar(im01, ax=ax2[0, 1])
fig2.colorbar(im10, ax=ax2[1, 0])
ax2[0, 0].set_title('Original (noisy) image')
ax2[0, 1].set_title('Reconstructed image - Frac. of energy = ' +
str(np.round(recovered_energy_fraction, 4)))
ax2[1, 0].set_title('Residual image - Frac. of energy = ' +
str(np.round(residual_energy_fraction, 4)))
ax2[1, 1].set_title('Rel. magnitude of coefficients - ' +
str(omp.n_nonzero_coefs))
fig2.suptitle(
'Sparse decomposition from an semi-intelligent Dictionary :) ')
plt.show()
# OMP: Orthogonal Matching Pursuit
from sklearn.linear_model import OrthogonalMatchingPursuit as OMP
from sklearn.feature_selection import f_classif, SelectKBest
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
# Create as many OMP as voxels to predict
clfs = []
n_clfs = y_train.shape[1]
for i in range(y_train.shape[1]):
sys.stderr.write("Training classifiers %03d/%d... \r" % (i + 1, n_clfs))
clf = Pipeline([('selection', SelectKBest(f_classif, k=500)),
('scl', StandardScaler()),
('clf', OMP(normalize=False, n_nonzero_coefs=10))])
clf.fit(X_train, y_train[:, i])
clfs.append(clf)
sys.stderr.write("Training classifiers %03d/%d... Done (%.2fs).\n" %
(n_clfs, n_clfs, time.time() - t0))
############################################################################
# Here we run the prediction: the decoding itself
# ------------------------------------------------
sys.stderr.write("Calculating scores and outputs...")
t0 = time.time()
y_pred = []
for clf in clfs:
y_pred.append(clf.predict(X_test))
#A=create_Amat_kron(Nx,Ny,index) #A=create_Amat_1D(Nx,Ny,index) A=create_Amat_rand(M,Nx,Ny,index) #A=create_Amat_rand_Wave(M,Nx,Ny,index) #A=create_Amat_JL(Nx,Ny,index) #A=create_Amat_1DW(Nx,Ny,M) print "# reconstruction #" val=.001 count =1 # 0.0001,0.001,0.01,0.1 while(count!=0): #7.OMP #''' non_Zcoeff=CountSparse(Simage_) omp=OMP() omp.fit(A,Y) print "omp done" recon=idct(omp.coef_).reshape((Nx,Ny)) print type(recon) print omp.coef_ #''' #6.Lasso ''' lasso = Lasso(alpha=val) lasso.fit(A,Y) print (lasso.coef_).shape val=val*10 recons_sparse = coo_matrix(lasso.coef_)
def sparse_code(Y, D, X = None):
if X is None:
y_cols, d_cols = Y.shape[1], D.shape[1]
X = np.asmatrix(np.empty((d_cols, y_cols))
x_rows, x_cols = X.shape
for k in range(x_cols):
omp = OMP()
omp.fit(D, y[:, k])
X[:,k] = np.asmatrix(omp.coef_).T
return X
"""
Forms a matrix for a given vector x to enforce that the new update x will be
sparse. Here N is the columns of Y. Returns the matrix omega.
"""
def form_omega(x, N):
w = []
for i, x_i in enumerate(np.nditer(x)):
if abs(x_i) > 0:
w.append((i, x_i))
W = np.asmatrix(np.zeroes((N, len(w))
for w_i, i in w:
W[w_i, i] = 1
return W
"""
Update the dictionary D and the matrix X (phase 2)
"""
def update_dictionary(Y, D, X):
n, K = D.shape
# Dhat = np.asmatrix(np.zeroes((n, K)))
# Form E_k
for k in range(K):
j = 0
while j < K:
if j != k:
E_k = Y - D[:,j]*X[j,:]
j += 1
else:
j += 1
# Form E_kr to ensure that the update will be sparse. Call form_omega
omega_k = form_omega(X[k,:])
E_kr = E_k * omega_k
# Form SVD of E_kr and update matrices
U, sig, V = np.linalg.svd(E_kr, full_matrices = True)
x_kr = sig[0, 0]*V[0,:]
# Dhat[k,:] = U[0,:]
D[k,:] = U[0,:]
# Dhat = D
def main():
pass
if __name__ == '__main__':
main()
