def test_robust_visual(conf, training_result, idx):
"""
Noise std vs Reconstruction Quality at fixed sampling rate visual test.
Parameters
----------
conf : conf_loader.Conf
Experiment parameters
training_result : touple
Retrun values of function `training`
idx : int
Id of image to test
Returns
-------
srange : np.array
noise std range used
sampling_rate : float
sampling rate used
(bk_ser, fa_ser, rc_ser) : (np.array, np.array, np.array)
SER for `k-best`, `f_avg` and `LSC` methods at different noise std
(bk_mse, fa_mse, rc_mse) : (np.array, np.array, np.array)
mse for `k-best`, `f_avg` and `LSC` methods at different noise std
"""
(sort, tros), (energy, comulated, bands), codebooks = training_result
n_bands = conf.nbands
# matrxi to vector (m2v) and vector to matrix (v2m) functions
m2v, v2m = conf.vect_functions()
subcfg = conf.testing['robust_reconstruction_visual']
testing, Testing = common.load_dataset(conf.testingset_path(),
conf.fformat, conf.size())
FlatTst = m2v(Testing)[:, sort]
# f_avg sampling pattern
Omega = energy.argsort()[::-1]
# lsc sampling pattern
Omegas = [c.sampling_pattern() for c in codebooks]
shape = testing[0].shape
n = np.prod(shape)
srange = np.logspace(*subcfg['noise_range'])
sampling_rate = subcfg['sampling_rate']
W, H = shape
Wt = W * 3
Ht = H * len(srange)
res = np.zeros((Wt, Ht))
print(f'Robust Reconstruction Quality Visual Test (img {idx}):')
for i, sigma in enumerate(srange):
print(f'\r {i+1:3d}/{len(srange)}', flush=True, end='')
X = FlatTst[idx] + common.noise(sigma, n)
M = int(round(sampling_rate * n))
m = int(round(M / n_bands))
ms = lsc.num_samples(bands, m)
M = np.sum(ms)
smalls = [omega[:y] for omega, y in zip(Omegas, ms)]
Xsbs = lsc.split(X, bands)
Ysbs = lsc.sub_sample(Xsbs, Omegas, m)
recovered = [
codebooks[b].reconstruct(Ysbs[b], smalls[b])
for b in range(len(bands))
]
Y = v2m((lsc.union(recovered))[tros], shape)
y = common.norm(common.pos(common.ifft2(Y).real))
BK = X.copy()[tros]
O = np.abs(BK).argsort()[::-1]
BK[O[M:]] = 0
BK = v2m(BK, shape)
bK = common.norm(common.pos(common.ifft2(BK).real))
FA = X.copy()[tros]
FA[Omega[M:]] = 0
FA = v2m(FA, shape)
fA = common.norm(common.pos(common.ifft2(FA).real))
res[:W, H * i:H * (i + 1)] = bK
res[W:2 * W, H * i:H * (i + 1)] = fA
res[2 * W:3 * W, H * i:H * (i + 1)] = y
print('\t[done]')
return srange, res
def test_robust_sampling(conf, training_result):
"""
Sampling rate vs Reconstruction Quality at fixed noise std.
Parameters
----------
conf : conf_loader.Conf
Experiment parameters
training_result : touple
Retrun values of function `training`
Returns
-------
srange : np.array
sampling rate range used
sampling_rate : float
sampling rate used
(bk_ser, fa_ser, rc_ser) : (np.array, np.array, np.array)
SER for `k-best`, `f_avg` and `LSC` methods
(bk_mse, fa_mse, rc_mse) : (np.array, np.array, np.array)
mse for `k-best`, `f_avg` and `LSC` methods
"""
(sort, tros), (energy, comulated, bands), codebooks = training_result
n_bands = conf.nbands
# matrxi to vector (m2v) and vector to matrix (v2m) functions
m2v, v2m = conf.vect_functions()
subcfg = conf.testing['robust_sampling']
# Load testing set
testing, Testing = common.load_dataset(conf.testingset_path(),
conf.fformat, conf.size())
FlatTst = m2v(Testing)[:, sort]
# f_avg sampling pattern
Omega = energy.argsort()[::-1]
# lsc sampling pattern
Omegas = [c.sampling_pattern() for c in codebooks]
shape = testing[0].shape
n = np.prod(shape)
N = len(testing)
srange = np.logspace(*subcfg['sampling_range'])
sigma = subcfg['noise_rate']
bk_ser = np.zeros(len(srange))
fa_ser = np.zeros(len(srange))
rc_ser = np.zeros(len(srange))
bk_mse = np.zeros(len(srange))
fa_mse = np.zeros(len(srange))
rc_mse = np.zeros(len(srange))
print('Sampling rate at fixed noise test:')
for i, rate in enumerate(srange):
print(f'\r {i+1:3d}/{len(srange)}', flush=True, end='')
M = int(round(n * rate))
m = int(round(M / n_bands))
ms = lsc.num_samples(bands, m)
M = np.sum(ms)
smalls = [omega[:y] for omega, y in zip(Omegas, ms)]
for idx in range(N):
reference = common.norm(testing[idx])
X = FlatTst[idx] + common.noise(sigma, n)
Xsbs = lsc.split(X, bands)
Ysbs = lsc.sub_sample(Xsbs, Omegas, m)
recovered = [
codebooks[b].reconstruct(Ysbs[b], smalls[b])
for b in range(len(bands))
]
Y = v2m((lsc.union(recovered))[tros], shape)
y = common.norm(common.pos(common.ifft2(Y).real))
BK = X.copy()[tros]
O = np.abs(BK).argsort()[::-1]
BK[O[M:]] = 0
BK = v2m(BK, shape)
bK = common.norm(common.pos(common.ifft2(BK).real))
FA = X.copy()[tros]
FA[Omega[M:]] = 0
FA = v2m(FA, shape)
fA = common.norm(common.pos(common.ifft2(FA).real))
fa_ser[i] += common.SER(reference, fA) / N
bk_ser[i] += common.SER(reference, bK) / N
rc_ser[i] += common.SER(reference, y) / N
fa_mse[i] += mse(reference, fA) / N
bk_mse[i] += mse(reference, bK) / N
rc_mse[i] += mse(reference, y) / N
print(' [done]')
return srange, sigma, (bk_ser, fa_ser, rc_ser), (bk_mse, fa_mse, rc_mse)
def training(conf):
"""Training step.
Parameters
----------
conf : conf_loader.Conf
Experiment parameters
Returns
-------
(sort, tros) : ([int], [int])
Sorting order, direct and inverse
(energy, comulated, bands) : (np.array, np.array, [int])
Average energy, comulated average energy and band splitting
codebooks : [Codebook]
codebooks per band
"""
print('Loading training dataset...', end='', flush=True)
n_bands = conf.nbands
# matrxi to vector (m2v) and vector to matrix (v2m) functions
m2v, v2m = conf.vect_functions()
training, Training = common.load_dataset(conf.trainingset_path(),
fformat=conf.fformat,
size=conf.size())
print(' [done]')
"""
Extract stastics.
"""
print('Extracting statistics and computing bands...', end='', flush=True)
shape = training[0].shape
n = np.prod(shape)
mag, mag_std, phs, phs_std = common.retrive_basic_stats(Training)
# direct sorting
sort = np.arange(n)
if conf.training['sort'] == 'random':
sort = np.random.choice(n, size=n, replace=False)
elif conf.training['sort'] == 'energy':
sort = m2v(mag).argsort()[::-1]
# inverse sorting
tros = common.inv(sort)
"""
Generate bands.
"""
energy = common.norm(m2v(mag_std)[sort])
comulated = common.norm(common.comulate(energy))
bands = lsc.divide(comulated, n_bands)
print(' [done]')
"""
Check if codebook is cached.
"""
if not os.path.isdir('codebooks'):
os.mkdir('codebooks')
codebook_path = f'codebooks/{conf.codebook_name()}'
if os.path.isfile(codebook_path):
print('Loading existing codebooks...', end='', flush=True)
with open(codebook_path, 'rb') as f:
codebooks = pickle.load(f)
else:
print('Computing codebooks...', end='', flush=True)
"""
Prepare dataset for codes generation.
"""
n_levels = conf.training['n_levels']
n_codes = conf.training['n_codes']
batch_size = conf.training['batch']
normalize = m2v(mag)[sort]
discretize = normalize / n_levels
FlatTrn = m2v(Training)[:, sort]
DiscTrn = np.round(FlatTrn / discretize) * discretize
SBsTrn = lsc.split(DiscTrn, bands)
"""
Compute codebook for each sub-band.
"""
codebooks = lsc.gen_codebooks(SBsTrn,
n_codes,
mode='ReIm',
batch_size=batch_size)
with open(codebook_path, 'wb') as f:
pickle.dump(codebooks, f)
print(' [done]')
return (sort, tros), (energy, comulated, bands), codebooks