def __init__(self, is_stationary, sqrt_beta, order_number, n_samples, pcn,
init_sample_sym):
self.is_stationary = is_stationary
self.sqrt_beta = sqrt_beta
self.order_number = order_number
self.n_samples = n_samples
self.pcn = pcn
zero_compl_dummy = cp.zeros(self.pcn.fourier.basis_number_2D_ravel,
dtype=cp.complex64)
ones_compl_dummy = cp.ones(self.pcn.fourier.basis_number_2D_ravel,
dtype=cp.complex64)
self.stdev = ones_compl_dummy
self.stdev_sym = util.symmetrize(self.stdev)
self.samples_history = np.empty(
(self.n_samples, self.pcn.fourier.basis_number_2D_ravel),
dtype=np.complex64)
self.LMat = Lmatrix_2D(self.pcn.fourier, self.sqrt_beta)
self.current_noise_sample = self.pcn.random_gen.construct_w(
) #noise sample always symmetric
self.new_noise_sample = self.current_noise_sample.copy()
if self.is_stationary:
self.new_sample_sym = init_sample_sym
self.new_sample = init_sample_sym[self.pcn.fourier.
basis_number_2D_ravel - 1:]
self.current_sample = self.new_sample.copy()
self.current_sample_sym = self.new_sample_sym.copy()
self.new_sample_scaled_norm = 0
self.new_log_L_det = 0
#numba need this initialization. otherwise it will not compile
self.current_sample_scaled_norm = 0
self.current_log_L_det = 0
else:
init_sample = init_sample_sym[self.pcn.fourier.
basis_number_2D_ravel - 1:]
self.LMat.construct_from(init_sample)
self.LMat.set_current_L_to_latest()
self.new_sample_sym = cp.linalg.solve(
self.LMat.current_L, self.pcn.random_gen.construct_w())
self.new_sample = self.new_sample_sym[self.pcn.fourier.
basis_number_2D_ravel - 1:]
self.new_sample_scaled_norm = util.norm2(
self.LMat.current_L @ self.new_sample_sym) #ToDO: Modify this
self.new_log_L_det = self.LMat.logDet(True) #ToDO: Modify this
# #numba need this initialization. otherwise it will not compile
self.current_sample = init_sample.copy()
self.current_sample_sym = self.new_sample_sym.copy()
self.current_sample_scaled_norm = self.new_sample_scaled_norm
self.current_log_L_det = self.new_log_L_det
# self.update_current_sample()
self.i_record = 0
def preinit(self,is_stationary,sqrt_beta,order_number,n_samples,pcn,init_sample_sym):
self.is_stationary = is_stationary
self.sqrt_beta = sqrt_beta
self.order_number = order_number
self.n_samples = n_samples
self.pcn = pcn
# zero_compl_dummy = cp.zeros(self.pcn.fourier.basis_number_2D_ravel,dtype=cp.complex64)
ones_compl_dummy = cp.ones(self.pcn.fourier.basis_number_2D_ravel,dtype=cp.complex64)
self.stdev = ones_compl_dummy
self.stdev_sym = util.symmetrize(self.stdev)
self.samples_history = np.empty((self.n_samples, self.pcn.fourier.basis_number_2D_ravel), dtype=np.complex64)
self.current_noise_sample = self.pcn.random_gen.construct_w()#noise sample always symmetric
self.new_noise_sample = self.current_noise_sample.copy()
self.i_record = 0
def initialize_from_folder(target_folder, sim, sequence_no):
#TODO:HARD CODED relative path BADDD
relative_path = pathlib.Path("/scratch/work/emzirm1/SimulationResult")
init_folder = relative_path / target_folder
file_name = 'result_{}.hdf5'.format(sequence_no)
init_file_path = init_folder / file_name
if not init_file_path.exists():
initialize_using_FBP(sim)
else:
with h5py.File(init_file_path, mode='r') as file:
n_layers = file['n_layers'][()]
sim.pcn.beta = file['pcn/beta'][()]
for i in range(n_layers):
samples_history = file['Layers {}/samples_history'.format(i)][(
)]
init_Sym = util.symmetrize(cp.asarray(samples_history[-1]))
del samples_history
sim.Layers[i].current_sample_sym = init_Sym
sim.Layers[i].current_sample = sim.Layers[
i].current_sample_sym[sim.fourier.basis_number_2D_ravel -
1:]
sim.Layers[i].record_sample()
def _process_data(samples_history,u_samples_history,n,n_ext,t_start,t_end,target_image,corrupted_image,burn_percentage,isSinogram,sinogram,theta,fbp,SimulationResult_dir,result_file,cmap = plt.cm.seismic_r):
burn_start_index = np.int(0.01*burn_percentage*u_samples_history.shape[0])
#initial conditions
samples_init = samples_history[0,:]
#change
u_samples_history = u_samples_history[burn_start_index:,:]
samples_history = samples_history[burn_start_index:,:]
N = u_samples_history.shape[0]
#initial condition
vF_init = util.symmetrize(cp.asarray(samples_init)).reshape(2*n-1,2*n-1,order=imc.ORDER)
# vF_init = vF_init.conj()
vF_mean = util.symmetrize(cp.asarray(np.mean(samples_history,axis=0)))
vF_stdev = util.symmetrize(cp.asarray(np.std(samples_history,axis=0)))
vF_abs_stdev = util.symmetrize(cp.asarray(np.std(np.abs(samples_history),axis=0)))
fourier = imc.FourierAnalysis_2D(n,n_ext,t_start,t_end)
sL2 = util.sigmasLancosTwo(cp.int(n))
# if isSinogram:
# vF_init = util.symmetrize_2D(fourier.rfft2(cp.asarray(fbp,dtype=cp.float32)))
# if not isSinogram:
vForiginal = util.symmetrize_2D(fourier.rfft2(cp.array(target_image)))
reconstructed_image_original = fourier.irfft2(vForiginal[:,n-1:])
reconstructed_image_init = fourier.irfft2(vF_init[:,n-1:])
samples_history_cp = cp.asarray(samples_history)
v_image_count=0
v_image_M = cp.zeros_like(reconstructed_image_original)
v_image_M2 = cp.zeros_like(reconstructed_image_original)
v_image_aggregate = (v_image_count,v_image_M,v_image_M2)
for i in range(N):
vF = util.symmetrize(samples_history_cp[i,:]).reshape(2*n-1,2*n-1,order=imc.ORDER)
v_temp = fourier.irfft2(vF[:,n-1:])
v_image_aggregate = util.updateWelford(v_image_aggregate,v_temp)
v_image_mean,v_image_var,v_image_s_var = util.finalizeWelford(v_image_aggregate)
#TODO: This is sign of wrong processing, Remove this
# if isSinogram:
# reconstructed_image_init = cp.fliplr(reconstructed_image_init)
# v_image_mean = cp.fliplr(v_image_mean)
# v_image_s_var = cp.fliplr(v_image_s_var)
mask = cp.zeros_like(reconstructed_image_original)
r = (mask.shape[0]+1)//2
for i in range(mask.shape[0]):
for j in range(mask.shape[1]):
x = 2*(i - r)/mask.shape[0]
y = 2*(j - r)/mask.shape[1]
if (x**2+y**2 < 1):
mask[i,j]=1.
u_samples_history_cp = cp.asarray(u_samples_history)
u_image = cp.zeros_like(v_image_mean)
# ell_image = cp.zeros_like(v_image_mean)
u_image_count=0
u_image_M = cp.zeros_like(u_image)
u_image_M2 = cp.zeros_like(u_image)
u_image_aggregate = (u_image_count,u_image_M,u_image_M2)
ell_image_count=0
ell_image_M = cp.zeros_like(u_image)
ell_image_M2 = cp.zeros_like(u_image)
ell_image_aggregate = (ell_image_count,ell_image_M,ell_image_M2)
for i in range(N):
uF = util.symmetrize(u_samples_history_cp[i,:]).reshape(2*n-1,2*n-1,order=imc.ORDER)
u_temp = fourier.irfft2(uF[:,n-1:])
u_image_aggregate = util.updateWelford(u_image_aggregate,u_temp)
ell_temp = cp.exp(u_temp)
ell_image_aggregate = util.updateWelford(ell_image_aggregate, ell_temp)
u_image_mean,u_image_var,u_image_s_var = util.finalizeWelford(u_image_aggregate)
ell_image_mean,ell_image_var,ell_image_s_var = util.finalizeWelford(ell_image_aggregate)
# if isSinogram:
# u_image_mean = cp.flipud(u_image_mean) #cp.rot90(cp.fft.fftshift(u_image),1)
# u_image_var = cp.flipud(u_image_var) #cp.rot90(cp.fft.fftshift(u_image),1)
# ell_image_mean = cp.flipud(ell_image_mean)# cp.rot90(cp.fft.fftshift(ell_image),1)
# ell_image_var = cp.flipud(ell_image_var)# cp.rot90(cp.fft.fftshift(ell_image),1)
ri_fourier = cp.asnumpy(reconstructed_image_original)
if isSinogram:
ri_compare = fbp
else:
ri_compare = ri_fourier
is_masked=True
if is_masked:
reconstructed_image_var = mask*v_image_s_var
reconstructed_image_mean = mask*v_image_mean
reconstructed_image_init = mask*reconstructed_image_init
u_image_mean = mask*u_image_mean #cp.rot90(cp.fft.fftshift(u_image),1)
u_image_s_var = mask*u_image_s_var #cp.rot90(cp.fft.fftshift(u_image),1)
ell_image_mean = mask*ell_image_mean# cp.rot90(cp.fft.fftshift(ell_image),1)
ell_image_s_var = mask*ell_image_s_var# cp.rot90(cp.fft.fftshift(ell_image),1)
else:
reconstructed_image_mean = v_image_mean
ri_init = cp.asnumpy(reconstructed_image_init)
# ri_fourier = fourier.irfft2((sL2.astype(cp.float32)*vForiginal)[:,n-1:])
vForiginal_n = cp.asnumpy(vForiginal)
vF_init_n = cp.asnumpy(vF_init)
ri_fourier_n = cp.asnumpy(ri_fourier)
vF_mean_n = cp.asnumpy(vF_mean.reshape(2*n-1,2*n-1,order=imc.ORDER))
vF_stdev_n = cp.asnumpy(vF_stdev.reshape(2*n-1,2*n-1,order=imc.ORDER))
vF_abs_stdev_n = cp.asnumpy(vF_abs_stdev.reshape(2*n-1,2*n-1,order=imc.ORDER))
ri_mean_n = cp.asnumpy(reconstructed_image_mean)
ri_var_n = cp.asnumpy(reconstructed_image_var)
ri_std_n = np.sqrt(ri_var_n)
# ri_n_scalled = ri_n*cp.asnumpy(scalling_factor)
u_mean_n = cp.asnumpy(u_image_mean)
u_var_n = cp.asnumpy(u_image_s_var)
ell_mean_n = cp.asnumpy(ell_image_mean)
ell_var_n = cp.asnumpy(ell_image_s_var)
#Plotting one by one
#initial condition
fig = plt.figure()
plt.subplot(1,2,1)
im = plt.imshow(np.absolute(vF_init_n),cmap=cmap,vmin=-1,vmax=1)
fig.colorbar(im)
plt.title('Fourier - real part')
plt.subplot(1,2,2)
im = plt.imshow(np.angle(vF_init_n),cmap=cmap,vmin=-np.pi,vmax=np.pi)
fig.colorbar(im)
plt.title('Fourier - imaginary part')
plt.tight_layout()
plt.savefig(str(SimulationResult_dir/'vF_init')+image_extension, bbox_inches='tight')
plt.close()
#vF Original
fig = plt.figure()
plt.subplot(1,2,1)
im = plt.imshow(np.absolute(vForiginal_n),cmap=cmap,vmin=-1,vmax=1)
fig.colorbar(im)
plt.title('Fourier - absolute')
plt.subplot(1,2,2)
im = plt.imshow(np.angle(vForiginal_n),cmap=cmap,vmin=-np.pi,vmax=np.pi)
fig.colorbar(im)
plt.title('Fourier - angle')
plt.tight_layout()
plt.savefig(str(SimulationResult_dir/'vForiginal')+image_extension, bbox_inches='tight')
plt.close()
#vF Original
fig = plt.figure()
plt.subplot(1,2,1)
im = plt.imshow(np.absolute(vF_mean_n),cmap=cmap,vmin=-1,vmax=1)
fig.colorbar(im)
plt.title('Fourier - absolute')
plt.subplot(1,2,2)
im = plt.imshow(np.angle(vF_mean_n),cmap=cmap,vmin=-np.pi,vmax=np.pi)
fig.colorbar(im)
plt.title('Fourier - phase')
plt.tight_layout()
plt.savefig(str(SimulationResult_dir/'vF_mean')+image_extension, bbox_inches='tight')
plt.close()
#Absolute error of vF - vForiginal
fig = plt.figure()
im = plt.imshow(np.abs(vF_mean_n-vForiginal_n),cmap=cmap,vmin=-1,vmax=1)
fig.colorbar(im)
plt.title('Fourier abs Error')
plt.tight_layout()
plt.savefig(str(SimulationResult_dir/'abs_err_vF_mean')+image_extension, bbox_inches='tight')
plt.close()
#Absolute error of vF_init - vForiginal
fig = plt.figure()
im = plt.imshow(np.abs(vF_init_n-vForiginal_n),cmap=cmap,vmin=-1,vmax=1)
fig.colorbar(im)
plt.title('Fourier abs Error')
plt.tight_layout()
plt.savefig(str(SimulationResult_dir/'abs_err_vF_init')+image_extension, bbox_inches='tight')
plt.close()
#Absolute error of vF_init - vForiginal
fig = plt.figure()
im = plt.imshow(np.abs(vF_init_n-vF_mean_n),cmap=cmap,vmin=-1,vmax=1)
fig.colorbar(im)
plt.title('Fourier abs Error')
plt.tight_layout()
plt.savefig(str(SimulationResult_dir/'abs_err_vF_init_vF_mean')+image_extension, bbox_inches='tight')
plt.close()
fig = plt.figure()
im = plt.imshow(ri_mean_n,cmap=cmap,vmin=-1,vmax=1)
fig.colorbar(im)
plt.title('Reconstructed Image mean')
plt.tight_layout()
plt.savefig(str(SimulationResult_dir/'ri_mean_n')+image_extension, bbox_inches='tight')
plt.close()
fig = plt.figure()
im = plt.imshow(ri_fourier,cmap=cmap,vmin=-1,vmax=1)
fig.colorbar(im)
plt.title('Reconstructed Image through Fourier')
plt.tight_layout()
plt.savefig(str(SimulationResult_dir/'ri_or_n')+image_extension, bbox_inches='tight')
plt.close()
fig = plt.figure()
im = plt.imshow(ri_init,cmap=cmap,vmin=-1,vmax=1)
fig.colorbar(im)
plt.title('Reconstructed Image through Fourier')
plt.tight_layout()
plt.savefig(str(SimulationResult_dir/'ri_init')+image_extension, bbox_inches='tight')
plt.close()
fig = plt.figure()
im = plt.imshow(ri_var_n,cmap=cmap)
fig.colorbar(im)
plt.title('Reconstructed Image variance')
plt.tight_layout()
plt.savefig(str(SimulationResult_dir/'ri_var_n')+image_extension, bbox_inches='tight')
plt.close()
fig = plt.figure()
im = plt.imshow(target_image,cmap=cmap,vmin=-1,vmax=1)
fig.colorbar(im)
plt.title('Target Image')
plt.tight_layout()
plt.savefig(str(SimulationResult_dir/'target_image')+image_extension, bbox_inches='tight')
plt.close()
fig = plt.figure()
im = plt.imshow(ri_compare,cmap=cmap,vmin=-1,vmax=1)
if isSinogram:
plt.title('Filtered Back Projection -FBP')
else:
plt.title('Reconstructed Image From vFOriginal')
fig.colorbar(im)
plt.tight_layout()
plt.savefig(str(SimulationResult_dir/'ri_compare')+image_extension, bbox_inches='tight')
plt.close()
fig = plt.figure()
im = plt.imshow((target_image-ri_mean_n),cmap=cmap,vmin=-1,vmax=1)
fig.colorbar(im)
plt.title('Error SPDE')
plt.tight_layout()
plt.savefig(str(SimulationResult_dir/'err_RI_TI')+image_extension, bbox_inches='tight')
plt.close()
fig = plt.figure()
im = plt.imshow((target_image-ri_compare),cmap=cmap)#,vmin=-1,vmax=1)
fig.colorbar(im)
plt.title('Error SPDE')
plt.tight_layout()
plt.savefig(str(SimulationResult_dir/'err_RIO_TI')+image_extension, bbox_inches='tight')
plt.close()
fig = plt.figure()
im = plt.imshow((ri_compare-target_image),cmap=cmap,vmin=-1,vmax=1)
fig.colorbar(im)
plt.title('Error FPB')
plt.tight_layout()
plt.savefig(str(SimulationResult_dir/'err_RI_CMP')+image_extension, bbox_inches='tight')
plt.close()
fig = plt.figure()
im = plt.imshow(u_mean_n,cmap=cmap)
fig.colorbar(im)
plt.title('Mean $u$')
plt.tight_layout()
plt.savefig(str(SimulationResult_dir/'u_mean_n')+image_extension, bbox_inches='tight')
plt.close()
fig = plt.figure()
im = plt.imshow(u_var_n,cmap=cmap)
plt.title('Var $u$')
fig.colorbar(im)
plt.tight_layout()
plt.savefig(str(SimulationResult_dir/'u_var_n')+image_extension, bbox_inches='tight')
plt.close()
fig = plt.figure()
im = plt.imshow(ell_mean_n,cmap=cmap)
fig.colorbar(im)
plt.title('Mean $\ell$')
plt.tight_layout()
plt.savefig(str(SimulationResult_dir/'ell_mean_n')+image_extension, bbox_inches='tight')
plt.close()
fig = plt.figure()
im = plt.imshow(ell_var_n,cmap=cmap)
fig.colorbar(im)
plt.title('Var $\ell$')
plt.tight_layout()
plt.savefig(str(SimulationResult_dir/'ell_var_n')+image_extension, bbox_inches='tight')
plt.close()
fig = plt.figure()
if isSinogram:
im = plt.imshow(sinogram,cmap=cmap)
plt.title('Sinogram')
else:
im = plt.imshow(corrupted_image,cmap=cmap)
plt.title('corrupted_image --- CI')
fig.colorbar(im)
plt.tight_layout()
plt.savefig(str(SimulationResult_dir/'measurement')+image_extension, bbox_inches='tight')
plt.close()
#plot several slices
N_slices = 16
t_index = np.arange(target_image.shape[1])
for i in range(N_slices):
fig = plt.figure()
slice_index = target_image.shape[0]*i//N_slices
plt.plot(t_index,target_image[slice_index,:],'-k',linewidth=0.5,markersize=1)
plt.plot(t_index,ri_fourier_n[slice_index,:],'-r',linewidth=0.5,markersize=1)
plt.plot(t_index,ri_mean_n[slice_index,:],'-b',linewidth=0.5,markersize=1)
plt.fill_between(t_index,ri_mean_n[slice_index,:]-2*ri_std_n[slice_index,:],
ri_mean_n[slice_index,:]+2*ri_std_n[slice_index,:],
color='b', alpha=0.1)
plt.plot(t_index,ri_compare[slice_index,:],':k',linewidth=0.5,markersize=1)
plt.savefig(str(SimulationResult_dir/'1D_Slice_{}'.format(slice_index-(target_image.shape[0]//2)))+image_extension, bbox_inches='tight')
plt.close()
f_index = np.arange(n)
for i in range(N_slices):
fig = plt.figure()
slice_index = vForiginal_n.shape[0]*i//N_slices
plt.plot(f_index,np.abs(vForiginal_n[slice_index,n-1:]),'-r',linewidth=0.5,markersize=1)
plt.plot(f_index,np.abs(vF_init_n[slice_index,n-1:]),':k',linewidth=0.5,markersize=1)
plt.plot(f_index,np.abs(vF_mean_n[slice_index,n-1:]),'-b',linewidth=0.5,markersize=1)
plt.fill_between(f_index,np.abs(vF_mean_n[slice_index,n-1:])-2*vF_abs_stdev_n[slice_index,n-1:],
np.abs(vF_mean_n[slice_index,n-1:])+2*vF_abs_stdev_n[slice_index,n-1:],
color='b', alpha=0.1)
plt.savefig(str(SimulationResult_dir/'1D_F_Slice_{}'.format(slice_index-n))+image_extension, bbox_inches='tight')
plt.close()
# fig.colorbar(im, ax=ax[:,:], shrink=0.8)
# fig.savefig(str(SimulationResult_dir/'Result')+image_extension, bbox_inches='tight')
# for ax_i in ax.flatten():
# extent = ax_i.get_window_extent().transformed(fig.dpi_scale_trans.inverted())
# # print(ax_i.title.get_text())
# fig.savefig(str(SimulationResult_dir/ax_i.title.get_text())+''+image_extension, bbox_inches=extent.expanded(1.2, 1.2))
#
# fig = plt.figure()
# plt.hist(u_samples_history[:,0],bins=50,density=1)
error = (target_image-ri_mean_n)
error_CMP = (target_image-ri_compare)
L2_error = np.linalg.norm(error)
MSE = np.sum(error*error)/error.size
PSNR = 10*np.log10(np.max(ri_mean_n)**2/MSE)
SNR = np.mean(ri_mean_n)/np.sqrt(MSE*(error.size/(error.size-1)))
L2_error_CMP = np.linalg.norm(error_CMP)
MSE_CMP = np.sum(error_CMP*error_CMP)/error_CMP.size
PSNR_CMP = 10*np.log10(np.max(ri_compare)**2/MSE_CMP)
SNR_CMP = np.mean(ri_compare)/np.sqrt(MSE_CMP*(error_CMP.size/(error_CMP.size-1)))
metric = {'L2_error':L2_error,
'MSE':MSE,
'PSNR':PSNR,
'SNR':SNR,
'L2_error_CMP':L2_error_CMP,
'MSE_CMP':MSE_CMP,
'PSNR_CMP':PSNR_CMP,
'SNR_CMP':SNR_CMP}
with h5py.File(result_file,mode='a') as file:
for key,value in metric.items():
if key in file.keys():
del file[key]
# else:
file.create_dataset(key,data=value)
print('Shallow-SPDE : L2-error {}, MSE {}, SNR {}, PSNR {},'.format(L2_error,MSE,SNR,PSNR))
print('FBP : L2-error {}, MSE {}, SNR {}, PSNR {}'.format(L2_error_CMP,MSE_CMP,SNR_CMP,PSNR_CMP))
def post_analysis(input_dir):
relative_path = pathlib.Path(
"//data.triton.aalto.fi/work/emzirm1/SimulationResult/")
SimulationResult_dir = relative_path / input_dir
file = h5py.File(str(SimulationResult_dir / 'result.hdf5'), mode='r')
samples_history = file['Layers 1/samples_history'][()]
u_samples_history = file['Layers 0/samples_history'][()]
# meas_std = file['measurement/stdev'][()]
burn_start_index = np.int(0.3 * u_samples_history.shape[0])
u_samples_history = u_samples_history[burn_start_index:, :]
samples_history = samples_history[burn_start_index:, :]
N = u_samples_history.shape[0]
mean_field = util.symmetrize(cp.asarray(np.mean(samples_history, axis=0)))
# u_mean_field = util.symmetrize(cp.asarray(np.mean(u_samples_history,axis=0)))
# stdev_field = util.symmetrize(cp.asarray(np.std(samples_history,axis=0)))
n = file['fourier/basis_number'][()]
n_ext = file['fourier/extended_basis_number'][()]
t_start = file['t_start'][()]
t_end = file['t_end'][()]
target_image = file['measurement/target_image'][()]
corrupted_image = file['measurement/corrupted_image'][()]
isSinogram = 'sinogram' in file['measurement'].keys()
if isSinogram:
sinogram = file['measurement/sinogram'][()]
theta = file['measurement/theta'][()]
fbp = iradon(sinogram, theta, circle=True)
fourier = imc.FourierAnalysis_2D(n, n_ext, t_start, t_end)
sL2 = util.sigmasLancosTwo(cp.int(n))
vF = mean_field.reshape(2 * n - 1, 2 * n - 1, order=imc.ORDER).T
# if not isSinogram:
vForiginal = sL2 * util.symmetrize_2D(
fourier.fourierTransformHalf(cp.array(target_image)))
vFn = cp.asnumpy(vF)
reconstructed_image = fourier.inverseFourierLimited(vF[:, n - 1:])
if isSinogram:
reconstructed_image = cp.rot90(cp.fft.fftshift(reconstructed_image),
-1)
reconstructed_image_original = fourier.inverseFourierLimited(
vForiginal[:, n - 1:])
scalling_factor = (cp.max(reconstructed_image_original) -
cp.min(reconstructed_image_original)) / (
cp.max(reconstructed_image) -
cp.min(reconstructed_image))
u_samples_history_cp = cp.asarray(u_samples_history)
u_image = cp.zeros_like(reconstructed_image)
for i in range(N):
uF = util.symmetrize(u_samples_history_cp[i, :]).reshape(
2 * n - 1, 2 * n - 1, order=imc.ORDER).T
u_image += fourier.inverseFourierLimited(uF[:, n - 1:]) / N
if isSinogram:
u_image = cp.rot90(cp.fft.fftshift(u_image), -1)
ri_n = cp.asnumpy(reconstructed_image)
if isSinogram:
ri_or_n = fbp
else:
ri_or_n = cp.asnumpy(reconstructed_image_original)
ri_n_scalled = ri_n * cp.asnumpy(scalling_factor)
u_n = cp.asnumpy(u_image / (np.max(ri_n) - np.min(ri_n)))
ell_n = np.exp(u_n)
fig, ax = plt.subplots(ncols=3, nrows=3, figsize=(15, 15))
ax[0, 0].imshow(ri_n_scalled, cmap=plt.cm.Greys_r)
ax[0, 0].set_title('Reconstructed Image From vF--- RI')
ax[0, 1].imshow(target_image, cmap=plt.cm.Greys_r)
ax[0, 1].set_title('Target Image --- TI')
if isSinogram:
ax[0, 2].imshow(fbp, cmap=plt.cm.Greys_r)
ax[0, 2].set_title('FBP --- RIO')
else:
ax[0, 2].imshow(ri_or_n, cmap=plt.cm.Greys_r)
ax[0, 2].set_title('Reconstructed Image From vFOriginal --- RIO')
ax[1, 0].imshow(np.abs(target_image - ri_n_scalled), cmap=plt.cm.Greys_r)
ax[1, 0].set_title('Absolute error--- RI-TI')
ax[1, 1].imshow(np.abs(ri_or_n - target_image), cmap=plt.cm.Greys_r)
ax[1, 1].set_title('Absolute error--- RIO-TI')
ax[1, 2].imshow(np.abs(ri_n_scalled - ri_or_n), cmap=plt.cm.Greys_r)
ax[1, 2].set_title('Absolute error--- RI-RIO')
ax[2, 0].imshow(u_n, cmap=plt.cm.Greys_r)
ax[2, 0].set_title('Field u--- u')
ax[2, 1].imshow(ell_n, cmap=plt.cm.Greys_r)
ax[2, 1].set_title('Length Scale of v--- ell')
if isSinogram:
im = ax[2, 2].imshow(sinogram, cmap=plt.cm.Greys_r)
ax[2, 2].set_title('Measurement (Sinogram) --- CI')
else:
im = ax[2, 2].imshow(corrupted_image, cmap=plt.cm.Greys_r)
ax[2, 2].set_title('Measurement (corrupted_image) --- CI')
fig.colorbar(im, ax=ax[:, :], shrink=0.8)
fig.savefig(str(SimulationResult_dir / 'Result.pdf'), bbox_inches='tight')
for ax_i in ax.flatten():
extent = ax_i.get_window_extent().transformed(
fig.dpi_scale_trans.inverted())
# print(ax_i.title.get_text())
fig.savefig(str(SimulationResult_dir / ax_i.title.get_text()) + '.pdf',
bbox_inches=extent.expanded(1.2, 1.2))
return file
initialize_using_FBP(sim)
else:
#TODO:HARD CODED relative path BADDD
relative_path = pathlib.Path("/scratch/work/emzirm1/SimulationResult")
# relative_path = pathlib.Path("//data.triton.aalto.fi/work/emzirm1/SimulationResult")
init_folder = relative_path / args.init_folder
init_file = init_folder / 'result.hdf5'
if not init_file.exists():
initialize_using_FBP(sim)
else:
with h5py.File(init_file, mode='r') as file:
#take the latest sample from the folder
samples_history = file['Layers 1/samples_history'][()]
init_Sym = util.symmetrize(cp.asarray(samples_history[-1]))
del samples_history
u_samples_history = file['Layers 0/samples_history'][()]
u_init_Sym = util.symmetrize(cp.asarray(u_samples_history[-1]))
del u_samples_history
sim.Layers[-1].current_sample_sym = init_Sym
sim.Layers[-1].current_sample = sim.Layers[-1].current_sample_sym[
sim.fourier.basis_number_2D_ravel - 1:]
sim.Layers[-1].record_sample()
sim.Layers[0].current_sample_sym = u_init_Sym
sim.Layers[0].current_sample = sim.Layers[0].current_sample_sym[
sim.fourier.basis_number_2D_ravel - 1:]
sim.Layers[0].record_sample()
print("Used bytes so far, before even running the simulation {}".format(
lay.update_current_sample()
pcn.Layers_sqrtBetas[i] = lay.sqrt_beta
Layers.append(lay)
#%%
accepted_count = 0
for i in range(n_layers):
Layers[i].i_record = 0
for i in range(n_samples):
accepted_count += pcn.one_step_non_centered_dunlop(Layers)
print('Completed step {0}'.format(i))
if i + 1 % 5 == 0:
acceptancePercentage = accepted_count / (i + 1)
pcn.adapt_beta(acceptancePercentage)
#%%
mean_field = util.symmetrize(
cp.asarray(np.mean(Layers[-1].samples_history[:n_samples, :], axis=0)))
u_mean_field = util.symmetrize(
cp.asarray(np.mean(Layers[0].samples_history[:n_samples, :], axis=0)))
vF = mean_field.reshape(2 * f.basis_number - 1,
2 * f.basis_number - 1,
order=im.ORDER).T
uF = u_mean_field.reshape(2 * f.basis_number - 1,
2 * f.basis_number - 1,
order=im.ORDER).T
vForiginal = util.symmetrize_2D(
f.fourierTransformHalf(measurement.target_image))
vFwithNoise = util.symmetrize_2D(
f.fourierTransformHalf(measurement.corrupted_image))
vFn = cp.asnumpy(vF)
uFn = cp.asnumpy(uF)
vForiginaln = cp.asnumpy(vForiginal)
def construct_from(self, uHalf):
uHalf2D = util.from_u_2D_ravel_to_uHalf_2D(util.symmetrize(uHalf),
self.fourier.basis_number)
return self.construct_from_2D(uHalf2D)