def fit(self, epochs=1, batch_size=1, gamma=0.9, **args):
X = args['X_train']
y = args['y_train']
if 'verbose' in args:
verbose = args['verbose']
else:
verbose = None
epochs = int(epochs)
loss_val = cp.zeros((cp.int(epochs)))
par_gpu = deepcopy(self.start)
momentum = {
var: cp.zeros_like(self.start[var])
for var in self.start.keys()
}
#n_data=cp.float(y.shape[0])
for i in tqdm(range(np.int(epochs))):
for X_batch, y_batch in self.iterate_minibatches(X, y, batch_size):
n_batch = cp.float(y_batch.shape[0])
grad_p = self.model.grad(par_gpu,
X_train=X_batch,
y_train=y_batch)
for var in par_gpu.keys():
momentum[var] = gamma * momentum[
var] - self.step_size * grad_p[var]
par_gpu[var] += momentum[var]
loss_val[i] = self.model.log_likelihood(par_gpu,
X_train=X_batch,
y_train=y_batch)
if verbose and (i % (epochs / 10) == 0):
print('loss: {0:.8f}'.format(cp.asnumpy(loss_val[i])))
return par_gpu, cp.asnumpy(loss_val)
def fit_dropout(self, epochs=1, batch_size=1, p=0.5, gamma=0.9, **args):
X = args['X_train']
y = args['y_train']
if 'verbose' in args:
verbose = args['verbose']
else:
verbose = None
loss_val = cp.zeros((cp.int(epochs)))
par_gpu = deepcopy(self.start)
momemtum = {var: cp.zeros_like(par_gpu[var]) for var in par_gpu.keys()}
for i in range(int(epochs)):
for batch in self.iterate_minibatches(X, y, batch_size):
X_batch, y_batch = batch
Z = cp.random.binomial(1, p, size=X_batch.shape)
X_batch_dropout = cp.multiply(X_batch, Z)
grad_p = self.model.grad(par_gpu,
X_train=X_batch_dropout,
y_train=y_batch)
for var in par_gpu.keys():
momemtum[var] = gamma * momemtum[
var] + -self.step_size * grad_p[var]
par_gpu[var] += momemtum[var]
loss_val[i] = self.model.negative_log_posterior(par_gpu,
X_train=X_batch,
y_train=y_batch)
if verbose and (i % (epochs / 10) == 0):
print('loss: {0:.4f}'.format(cp.asnumpy(loss_val[i])))
return par_gpu, loss_val
def fit(self, X, y=None):
"""Fit training data and construct histogram.
The type of histogram is 'regular', and right-open
Note: If n_bins=None, the number of breaks is being computed as in:
L. Birge, Y. Rozenholc, How many bins should be put in a regular
histogram? 2006.
X (cupy.ndarray) : NxD training sample.
"""
nrows, n_components = X.shape
if not self.n_bins:
self.n_bins = int(1 * (nrows ** 1) * (cp.log(nrows) ** -1))
n_nonzero_components = cp.sqrt(n_components)
n_zero_components = n_components - cp.int(n_nonzero_components)
self.projections = cp.random.randn(self.n_random_cuts, n_components)
self.histograms = cp.zeros([self.n_random_cuts, self.n_bins])
self.limits = cp.zeros((self.n_random_cuts, self.n_bins + 1))
for i in range(self.n_random_cuts):
rands = cp.random.permutation(n_components)[:n_zero_components]
self.projections[i, rands] = 0.
projected_data = self.projections[i, :].dot(X.T)
self.histograms[i, :], self.limits[i, :] = cp.histogram(
projected_data, bins=self.n_bins, density=False)
self.histograms[i, :] += 1e-12
self.histograms[i, :] /= cp.sum(self.histograms[i, :])
return self
def fit(self, train_data):
"""
Fit training data and construct histograms.
:param train_data: NxD training sample
:type train_data: cupy.ndarray
Examples
--------
>>> from clx.analytics.loda import Loda
>>> import cupy as cp
>>> x = cp.random.randn(100,5) # 5-D multivariate synthetic dataset
>>> loda_ad = Loda(n_bins=None, n_random_cuts=100)
>>> loda_ad.fit(x)
"""
nrows, n_components = train_data.shape
if not self._n_bins:
self._n_bins = int(1 * (nrows**1) * (cp.log(nrows)**-1))
n_nonzero_components = cp.sqrt(n_components)
n_zero_components = n_components - cp.int(n_nonzero_components)
self._projections = cp.random.randn(self._n_random_cuts, n_components)
self._histograms = cp.zeros([self._n_random_cuts, self._n_bins])
self._limits = cp.zeros((self._n_random_cuts, self._n_bins + 1))
for i in range(self._n_random_cuts):
rands = cp.random.permutation(n_components)[:n_zero_components]
self._projections[i, rands] = 0.
projected_data = self._projections[i, :].dot(train_data.T)
self._histograms[i, :], self._limits[i, :] = cp.histogram(
projected_data, bins=self._n_bins, density=False)
self._histograms[i, :] += 1e-12
self._histograms[i, :] /= cp.sum(self._histograms[i, :])
def valid_positions(R, vertices, depth, K, mask, lower, grid_size):
valid_positions_device(
((mask.size * len(vertices)) // 512 + 1, ), (512, ),
(cp.asarray(K.flatten()), cp.asarray(R.flatten()),
cp.asarray(vertices.flatten()), cp.asarray(depth.flatten()),
cp.array(depth.shape, cp.int), cp.float32(grid_size),
cp.asarray(mask.flatten(), cp.int), cp.array(
mask.shape, cp.int), cp.asarray(lower), cp.int(len(vertices))))
def PDcalculate(x, y, data2):
lon1 = x
lat1 = y
lon1 = cp.asarray(lon1)
lat1 = cp.asarray(lat1)
lon2 = data2["CLUSTERLONGITUDE"]
lat2 = data2["CLUSTERLATITUDE"]
lon3 = lon2.values
lat3 = lat2.values
lon4 = cp.asarray(lon3)
lat4 = cp.asarray(lat3)
shortdistance = geodistance_cp(lon1, lat1, lon4, lat4)
indexmin = cp.argmin(shortdistance)
indexmin = cp.int(indexmin)
targetcID = data2.at[indexmin, "CLUSTERID"]
mindistance = cp.int(cp.min(shortdistance))
return mindistance, targetcID
def concat_hists(weights1, bins1, weights2, bins2, bin_size, rd):
min1, max1 = cp.around(bins1[0], rd), cp.around(bins1[-1], rd)
min2, max2 = cp.around(bins2[0], rd), cp.around(bins2[-1], rd)
mini, maxi = min(min1, min2), max(max1, max2)
new_bins = cp.arange(
mini, maxi + bin_size * 0.9,
bin_size) # * 0.9 to avoid unexpected random inclusion of last element
if min1 - mini != 0 and maxi - max1 != 0:
ext1 = cp.pad(weights1, (cp.int(cp.around((min1 - mini) / bin_size)),
cp.int(cp.around((maxi - max1) / bin_size))),
'constant',
constant_values=0)
elif min1 - mini != 0:
ext1 = cp.pad(weights1, (cp.int(cp.around(
(min1 - mini) / bin_size)), 0),
'constant',
constant_values=0)
elif maxi - max1 != 0:
ext1 = cp.pad(weights1, (0, cp.int(cp.around(
(maxi - max1) / bin_size))),
'constant',
constant_values=0)
else:
ext1 = weights1
if min2 - mini != 0 and maxi - max2 != 0:
ext2 = cp.pad(weights2, (cp.int(cp.around((min2 - mini) / bin_size)),
cp.int(cp.around((maxi - max2) / bin_size))),
'constant',
constant_values=0)
elif min2 - mini != 0:
ext2 = cp.pad(weights2, (cp.int(cp.around(
(min2 - mini) / bin_size)), 0),
'constant',
constant_values=0)
elif maxi - max2 != 0:
ext2 = cp.pad(weights2, (0, cp.int(cp.around(
(maxi - max2) / bin_size))),
'constant',
constant_values=0)
else:
ext2 = weights2
new_ext = ext1 + ext2
return new_ext, new_bins
def expm(A,delta=1e-10):
j = max(0,cp.int(1+cp.log2(cp.linalg.norm(A,cp.inf))))
A = A/(2**j)
q = u_nb.expm_eps_less_than(delta)
n = A.shape[0]
I = cp.eye(n)
D = I
N = I
X = I
c = 1
sign = 1
for k in range(1,q+1):
c = c*(q-k+1)/((2*q - k+ 1)*k)
X = A@X
N = N + c*X
sign = -1*sign
D = D + sign*c*X
F = cp.linalg.solve(D,N)
for _ in range(j):
F = F@F
return F
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))
trainY_val = dataY_tmp[train_idx_val, :]
testX_val = dataX[test_idx_val, :]
testY_val = dataY_tmp[test_idx_val, :]
[model_tmp, train_acc_temp, test_acc_temp, training_time_temp, testing_time_temp] = MRVFL(trainX_val, trainY_val, testX_val, testY_val, option)
del model_tmp
cp._default_memory_pool.free_all_blocks()
while (test_acc_temp > tMAX_acc).any():
if (test_acc_temp > MAX_acc).any():
tMAX_acc = sMAX_acc
sMAX_acc = MAX_acc
MAX_acc = test_acc_temp.max()
option_best.acc_test = test_acc_temp.max()
option_best.acc_train = train_acc_temp.max()
option_best.C = option.C
option_best.N = option.N
option_best.L = cp.int(test_acc_temp.argmax()+1)
option_best.scale = option.scale
option_best.nCV = i
option_best.ratio = r
option_best.drop = d
test_acc_temp[test_acc_temp.argmax()] = 0
print('Temp Best Option:{}'.format(option_best.__dict__))
elif (test_acc_temp > sMAX_acc).any():
tMAX_acc = sMAX_acc
sMAX_acc = test_acc_temp.max()
option_sbest.acc_test = test_acc_temp.max()
option_sbest.acc_train = train_acc_temp.max()
option_sbest.C = option.C
option_sbest.N = option.N
option_sbest.L = cp.int(test_acc_temp.argmax()+1)
option_sbest.scale = option.scale
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
def find_binary_threshold(v, vol_frac):
frac_ind = np.int(np.ceil(v.size * (1-vol_frac)))
return np.partition(v.ravel(), frac_ind)[frac_ind]
if theta_img[i,j] <= theta_max:
count = 0
ray = cp.zeros((stop + 1 - start, 3), dtype=cp.int)
for k in range(start, stop + 1):
if count > 0:
ray[k-start,:] = cp.array([cp.nan, cp.nan, cp.nan])
else:
theta_slice = thetav[k,:,:]
theta_slice[theta_slice > theta_max] = cp.nan
phi_slice = phiv[k,:,:]
dist = cp.sqrt((theta_slice - theta_img[i,j])**2 + (phi_slice - phi_img[i,j])**2)
mini, minj = cp.unravel_index(cp.nanargmin(dist), theta_slice.shape)
mini = cp.int(mini); minj = cp.int(minj)
# prevent smearing
if (mini in boundary) or (minj in boundary):
count += 1
ray[k-start,0] = k
ray[k-start,1] = mini
ray[k-start,2] = minj
not_nans = ~cp.isnan(ray[:,0])
how_many = cp.sum(not_nans)
kx = ray[:,0]
kx = kx[not_nans]
ix = ray[:,1]
ix = ix[not_nans]
jx = ray[:,2]
def MRVFLtrain(trainX, trainY, option):
fs_mode = 'INF'
rand_seed = np.random.RandomState(2)
[n_sample, n_dims] = trainX.shape
N = option.N
L = option.L
C = option.C
s = option.scale
mode = option.mode
ratio = option.ratio
drop = option.drop
TrainingAccuracy = cp.zeros(L)
if mode == 'merged':
drop_amount = cp.int(cp.floor(drop * N))
selected_amount = cp.int(cp.floor(ratio * N))
bi = []
A = []
beta = []
weights = []
biases = []
mu = []
sigma = []
sfi = []
fs = []
A_input = trainX
time_start = time.time()
for i in range(L):
if i == 0:
w = s * 2 * cp.asarray(rand_seed.rand(n_dims, N)) - 1
elif mode == 'merged':
######################### SETTING
# w = s * 2 * cp.asarray(rand_seed.rand(n_dims - drop_amount + N, N)) - 1
w = s * 2 * cp.asarray(
rand_seed.rand(n_dims + selected_amount - drop_amount + N,
N)) - 1
# w = s * 2 * cp.asarray(rand_seed.rand(n_dims + selected_amount*i - drop_amount + N, N)) - 1
b = s * cp.asarray(rand_seed.rand(1, N))
weights.append(w)
biases.append(b)
A_ = cp.matmul(A_input, w) # A_ should be 100 at any loop
# layer normalization
A_mean = cp.mean(A_, axis=0)
A_std = cp.std(A_, axis=0)
A_ = (A_ - A_mean) / A_std
mu.append(A_mean)
sigma.append(A_std)
A_ = A_ + cp.repeat(b, n_sample, 0)
A_ = selu(A_)
if i == 0:
A_tmp = cp.concatenate(
[trainX, A_, cp.ones((n_sample, 1))], axis=1)
else:
A_tmp = cp.concatenate(
[trainX, sf, A_, cp.ones((n_sample, 1))], axis=1)
beta_ = l2_weights(A_tmp, trainY, C, n_sample)
if fs_mode == 'LASSO':
significance = cp.linalg.norm(beta_, ord=1, axis=1)
ranked_index = cp.argsort(significance[n_dims:-1])
if fs_mode == 'RIDGE':
significance = cp.linalg.norm(beta_, ord=2, axis=1)
ranked_index = cp.argsort(significance[n_dims:-1])
elif fs_mode == 'MI':
at = cp.asnumpy(A_tmp[:, n_dims:-1])
ty = cp.asnumpy(cp.asarray([cp.argmax(i) for i in trainY]))
mis = mi(at, ty)
# with joblib.parallel_backend('loky'):
# mis = Parallel(10)(delayed(mi)(at[:, i].reshape(-1, 1), ty) for i in range(N))
# ranked_index = cp.argsort(cp.asarray(mis).ravel())
ranked_index = cp.argsort(mis)
elif fs_mode == 'INF':
at = cp.asnumpy(A_tmp[:, n_dims:-1])
rank, score = inf_fs(at)
ranked_index = rank
A.append(A_tmp)
beta.append(beta_)
selected_index = ranked_index[:
selected_amount] # chosen features, used in the next layers
sfi.append(selected_index)
left_amount = N - drop_amount
left_index = ranked_index[:left_amount]
A_except_trainX = A_tmp[:, n_dims:-1]
A_selected = A_except_trainX[:, selected_index]
fs.append(A_selected)
A_ = A_except_trainX[:, left_index]
################### SETTING
sf = A_selected
# sf = cp.concatenate(fs, axis=1)
################### SETTING
A_input = cp.concatenate([trainX, sf, A_], axis=1)
# A_input = cp.concatenate([trainX, A_], axis=1)
bi.append(left_index)
pred_result = cp.zeros((n_sample, i + 1))
for j in range(i + 1):
Ai = A[j]
beta_temp = beta[j]
predict_score = cp.matmul(Ai, beta_temp)
predict_index = cp.argmax(predict_score, axis=1).ravel()
# indx=indx.reshape(n_sample,1)
pred_result[:, j] = predict_index
TrainingAccuracy_temp = majorityVoting(trainY, pred_result)
TrainingAccuracy[i] = TrainingAccuracy_temp
'''
## Calculate the training accuracy
pred_result = cp.zeros((n_sample, L))
for i in range(L):
Ai = A[i]
beta_temp = beta[i]
predict_score = cp.matmul(Ai, beta_temp)
predict_index = cp.argmax(predict_score, axis=1).ravel()
# indx=indx.reshape(n_sample,1)
pred_result[:, i] = predict_index
TrainingAccuracy = majorityVoting(trainY, pred_result)
'''
time_end = time.time()
Training_time = time_end - time_start
model = mod(L, weights, biases, beta, mu, sigma, sfi, bi)
return model, TrainingAccuracy, Training_time
def main(dataset, device_number):
root_path = '/home/hu/eRVFL/UCIdata'
# data_name = 'cardiotocography-10clases'
data_name = dataset
# n_device = 6
n_device = device_number
print('Dataset Name:{}\nDevice Number:{}'.format(data_name, n_device))
logging.debug('Dataset Name:{}\tDevice Number:{}'.format(
data_name, n_device))
cp.cuda.Device(n_device).use()
cp.cuda.Device(n_device).use()
# load dataset
# dataX
datax = np.loadtxt('{0}/{1}/{1}_py.dat'.format(root_path, data_name),
delimiter=',')
dataX = cp.asarray(datax)
# dataY
datay = np.loadtxt('{}/{}/labels_py.dat'.format(root_path, data_name),
delimiter=',')
dataY = cp.asarray(datay)
# Validation Index
Validation = np.loadtxt('{}/{}/validation_folds_py.dat'.format(
root_path, data_name),
delimiter=',')
validation = cp.asarray(Validation)
# Folds Index
Folds_index = np.loadtxt('{}/{}/folds_py.dat'.format(root_path, data_name),
delimiter=',')
folds_index = cp.asarray(Folds_index)
types = cp.unique(dataY)
n_types = types.size
n_CV = folds_index.shape[1]
# One hot coding for the target
dataY_tmp = cp.zeros((dataY.size, n_types))
for i in range(n_types):
for j in range(dataY.size): # remove this loop
if dataY[j] == types[i]:
dataY_tmp[j, i] = 1
option = op(N=256,
L=16,
C=2**-6,
scale=1,
seed=1,
nCV=0,
ratio=0,
mode='merged',
drop=0)
if dataX.shape[1] <= 16:
N_range = [16, 32, 64]
#N_range = [1024, 2048, 4096]
elif dataX.shape[1] <= 64:
N_range = [64, 128, 256, 512]
else:
N_range = [128, 256, 512, 1024]
option.L = 16
option.scale = 1
C_range = np.append(0, 2.**np.arange(-6, 12, 2))
# C_range = 2.**np.arange(-6, 12, 2)
Models = []
# dataX = rescale(dataX) #####delete
train_acc_result = cp.zeros((n_CV, 1))
test_acc_result = cp.zeros((n_CV, 1))
train_time_result = cp.zeros((n_CV, 1))
test_time_result = cp.zeros((n_CV, 1))
option_best = op(N=256,
L=32,
C=2**-6,
scale=1,
seed=0,
nCV=0,
ratio=0,
mode='merged',
drop=0)
option_sbest = op(N=256,
L=32,
C=2**-6,
scale=1,
seed=0,
nCV=0,
ratio=0,
mode='merged',
drop=0)
option_tbest = op(N=256,
L=32,
C=2**-6,
scale=1,
seed=0,
nCV=0,
ratio=0,
mode='merged',
drop=0)
for i in range(n_CV):
MAX_acc = 0
sMAX_acc = 0
tMAX_acc = 0
train_idx = cp.where(folds_index[:, i] == 0)[0]
test_idx = cp.where(folds_index[:, i] == 1)[0]
trainX = dataX[train_idx, :]
trainY = dataY_tmp[train_idx, :]
testX = dataX[test_idx, :]
testY = dataY_tmp[test_idx, :]
st = time.time()
for n in N_range:
option.N = n
for j in C_range:
option.C = j
for r in cp.arange(0, 0.6, 0.1):
option.ratio = r
# for d in [0]:
for d in cp.arange(0, 0.6, 0.2):
option.drop = d
train_idx_val = cp.where(validation[:, i] == 0)[0]
test_idx_val = cp.where(validation[:, i] == 1)[0]
trainX_val = dataX[train_idx_val, :]
trainY_val = dataY_tmp[train_idx_val, :]
testX_val = dataX[test_idx_val, :]
testY_val = dataY_tmp[test_idx_val, :]
[
model_tmp, train_acc_temp, test_acc_temp,
training_time_temp, testing_time_temp
] = MRVFL(trainX_val, trainY_val, testX_val, testY_val,
option)
del model_tmp
cp._default_memory_pool.free_all_blocks()
while (test_acc_temp > tMAX_acc).any():
if (test_acc_temp > MAX_acc).any():
tMAX_acc = sMAX_acc
sMAX_acc = MAX_acc
MAX_acc = test_acc_temp.max()
option_best.acc_test = test_acc_temp.max()
option_best.acc_train = train_acc_temp.max()
option_best.C = option.C
option_best.N = option.N
option_best.L = cp.int(test_acc_temp.argmax() +
1)
option_best.scale = option.scale
option_best.nCV = i
option_best.ratio = r
option_best.drop = d
test_acc_temp[test_acc_temp.argmax()] = 0
print('Temp Best Option:{}'.format(
option_best.__dict__))
logging.debug('Temp Best Option:{}'.format(
option_best.__dict__))
elif (test_acc_temp > sMAX_acc).any():
tMAX_acc = sMAX_acc
sMAX_acc = test_acc_temp.max()
option_sbest.acc_test = test_acc_temp.max()
option_sbest.acc_train = train_acc_temp.max()
option_sbest.C = option.C
option_sbest.N = option.N
option_sbest.L = cp.int(
test_acc_temp.argmax() + 1)
option_sbest.scale = option.scale
option_sbest.nCV = i
option_sbest.ratio = r
option_sbest.drop = d
test_acc_temp[test_acc_temp.argmax()] = 0
print('Temp Second Best Option:{}'.format(
option_sbest.__dict__))
logging.debug(
'Temp Second Best Option:{}'.format(
option_sbest.__dict__))
elif (test_acc_temp > tMAX_acc).any():
tMAX_acc = test_acc_temp.max()
option_tbest.acc_test = test_acc_temp.max()
option_tbest.acc_train = train_acc_temp.max()
option_tbest.C = option.C
option_tbest.N = option.N
option_tbest.L = cp.int(
test_acc_temp.argmax() + 1)
option_tbest.scale = option.scale
option_tbest.nCV = i
option_tbest.ratio = r
option_tbest.drop = d
test_acc_temp[test_acc_temp.argmax()] = 0
print('Temp Third Best Option:{}'.format(
option_tbest.__dict__))
logging.debug(
'Temp Third Best Option:{}'.format(
option_tbest.__dict__))
#print('Training Time for one option set:{:.2f}'.format(time.time() - st))
#logging.debug('Training Time for one option set:{:.2f}'.format(time.time() - st))
[model_RVFL0, train_acc0, test_acc0, train_time0,
test_time0] = MRVFL(trainX, trainY, testX, testY, option_best)
[model_RVFL1, train_acc1, test_acc1, train_time1,
test_time1] = MRVFL(trainX, trainY, testX, testY, option_sbest)
[model_RVFL2, train_acc2, test_acc2, train_time2,
test_time2] = MRVFL(trainX, trainY, testX, testY, option_tbest)
best_index = cp.argmax(
cp.array([test_acc0.max(),
test_acc1.max(),
test_acc2.max()]))
print('Best Index:{}'.format(best_index))
print('Training Time for one fold set:{:.2f}'.format(time.time() - st))
logging.debug(
'Best Index:{}\nTraining Time for one fold set:{:.2f}'.format(
best_index,
time.time() - st))
model_RVFL = eval('model_RVFL{}'.format(best_index))
Models.append(model_RVFL)
train_acc_result[i] = eval('train_acc{}.max()'.format(best_index))
test_acc_result[i] = eval('test_acc{}.max()'.format(best_index))
train_time_result[i] = eval('train_time{}'.format(best_index))
test_time_result[i] = eval('test_time{}'.format(best_index))
del model_RVFL
cp._default_memory_pool.free_all_blocks()
print(
'Best Train accuracy in fold{}:{}\nBest Test accuracy in fold{}:{}'
.format(i, train_acc_result[i], i, test_acc_result[i]))
logging.debug(
'Best Train accuracy in fold{}:{}\nBest Test accuracy in fold{}:{}'
.format(i, train_acc_result[i], i, test_acc_result[i]))
mean_train_acc = train_acc_result.mean()
mean_test_acc = test_acc_result.mean()
print('Train accuracy:{}\nTest accuracy:{}'.format(train_acc_result,
test_acc_result))
logging.debug('Train accuracy:{}\nTest accuracy:{}'.format(
train_acc_result, test_acc_result))
print('Mean train accuracy:{}\nMean test accuracy:{}'.format(
mean_train_acc, mean_test_acc))
logging.debug('Mean train accuracy:{}\tMean test accuracy:{}'.format(
mean_train_acc, mean_test_acc))
save_result = open('Model_{}'.format(data_name), 'wb')
pickle.dump(Models, save_result)
save_result.close()
count = 0
ray = cp.zeros((stop + 1 - start, 3), dtype=cp.int)
for k in range(start, stop + 1):
if count > 0:
ray[k - start, :] = cp.array([cp.nan, cp.nan, cp.nan])
else:
theta_slice = thetav[k, :, :]
theta_slice[theta_slice > theta_max] = cp.nan
phi_slice = phiv[k, :, :]
dist = cp.sqrt((theta_slice - theta_img[i, j])**2 +
(phi_slice - phi_img[i, j])**2)
mini, minj = cp.unravel_index(cp.nanargmin(dist),
theta_slice.shape)
mini = cp.int(mini)
minj = cp.int(minj)
# prevent smearing
if (mini in boundary) or (minj in boundary):
count += 1
ray[k - start, 0] = k
ray[k - start, 1] = mini
ray[k - start, 2] = minj
not_nans = ~cp.isnan(ray[:, 0])
how_many = cp.sum(not_nans)
kx = ray[:, 0]
kx = kx[not_nans]
ix = ray[:, 1]
ix = ix[not_nans]
