def eval_one_view(model, batch, near_far, radii, device, **render_kwargs):
model.eval()
near, far = near_far
with torch.no_grad():
batch_rays = batch['rays'].to(device)
# Run nerf
ret_dict = model(batch_rays, (near, far), radii=radii, **render_kwargs)
for k, v in ret_dict.items():
ret_dict[k] = v.cpu()
metric_dict = {}
if 'target_s' in batch:
target_s = batch['target_s']
ret_dict['target_s'] = target_s
mse = img2mse(ret_dict['rgb'], target_s)
metric_dict['mse'] = mse
metric_dict['psnr'] = mse2psnr(mse)
metric_dict['ssim'] = ssim(ret_dict['rgb'], target_s, format='HWC')
metric_dict['lpips'] = lpips(ret_dict['rgb'],
target_s,
format='HWC')
return ret_dict, metric_dict
def main():
ch_dir('2_ssim_precision')
for x_position_update, patch_shift_x in position_updates.items():
for y_position_update, patch_shift_y in position_updates.items():
exp_name = f'ssim_precision_x_{x_position_update}_y_{y_position_update}'
output_name = construct_file_name(exp_name)
with open(output_name + '.log', 'w') as f:
f.writelines([
f'Log file for experiment {output_name}\n',
'The experiment presents one big gabor patch in pink noise scene.\n'
f'New pink noise is generated every {base_period:.2f} s\n',
f'\nExperiment settings:\n',
f'Scene dimensions: {base_size}\n',
f'Length [s]: {length}\n',
f'FPS: {fps}\n',
f'PPD: {ppd}\n',
f'Contrast: {base_contrast:.2f}\n',
f'Patch position: {base_position}\n',
f'Position update (x, y) [s^-1]: {(patch_shift_x, patch_shift_y)}\n',
])
base_noise = ContinuousNoiseGenerator(base_size,
base_size,
PinkNoise(
base_size, base_size),
period=base_period)
patch_generator = GaborGenerator(patch_size_deg=patch_size_deg,
ppd=ppd)
noise_with_gabor = PatchedNoiseGenerator(
base_size,
base_size,
base_noise,
[(patch_generator,
get_position_updater(
(patch_shift_x, patch_shift_y), base_position))],
contrast=base_contrast)
field_names = []
output_generators = []
field_names.extend([
'ssim_gabor_noise_vs_gabor', 'ssim_noise_vs_gabor',
'ssim_gabor_noise_vs_noise'
])
output_generators.extend([
lambda: ssim(noise_with_gabor.get_next_frame(0),
patch_generator.get_normalized_patch(), alpha,
beta, gamma),
lambda: ssim(base_noise.get_next_frame(0),
patch_generator.get_normalized_patch(), alpha,
beta, gamma),
lambda: ssim(noise_with_gabor.get_next_frame(0),
base_noise.get_next_frame(0), alpha, beta, gamma),
])
field_names.extend([
'cw_ssim_gabor_noise_vs_gabor', 'cw_ssim_noise_vs_gabor',
'cw_ssim_gabor_noise_vs_noise'
])
output_generators.extend([
lambda: cw_ssim(noise_with_gabor.get_next_frame(0),
patch_generator.get_normalized_patch(), alpha,
beta, gamma),
lambda: cw_ssim(base_noise.get_next_frame(0),
patch_generator.get_normalized_patch(), alpha,
beta, gamma),
lambda: cw_ssim(noise_with_gabor.get_next_frame(
0), base_noise.get_next_frame(0), alpha, beta, gamma),
])
generate_experiment_output(output_name=output_name,
generator=noise_with_gabor,
fields=field_names,
outputs=output_generators)
def get_ssim(window):
return ssim(window,
patch_generator.get_normalized_patch(),
alpha=0,
beta=-0.5,
gamma=0.5)
def run_experiment(size=500,
length=10,
ppd=60,
fps=30,
exp_name='test',
live=True,
output_diff=False,
delimiter=';',
gabor=True,
alpha=1,
beta=1,
gamma=1,
theta_speed: int = None,
phase_speed: int = None,
freq_speed: int = None,
patch_position=(0, 0),
patch_shift_x=0,
patch_shift_y=0,
contrast=0.5,
period=1,
output_values: [str] = None,
granularity=0):
width = height = size
if 'run' in exp_name:
base_noise = RunningPinkNoise(width, height, period=period * length)
elif 'v2' in exp_name:
base_noise = PinkNoise2(width, height, length=length, deg=1 / 100)
else:
base_noise = ContinuousNoiseGenerator(width,
height,
PinkNoise(width, height),
period=period)
patch_constructor = get_patch_generator(gabor)
patch_generator = patch_constructor(patch_size_deg=size / ppd,
ppd=ppd,
update_list=get_patch_value_updates(
theta_speed, phase_speed,
freq_speed))
noise_with_gabor = PatchedNoiseGenerator(
width,
height,
base_noise, [(patch_generator,
get_position_updater(
(patch_shift_x, patch_shift_y), patch_position))],
contrast=contrast)
if output_diff:
diff_noise = DifferenceNoiseGenerator(noise_with_gabor, period)
else:
diff_noise = None
output_name = construct_file_name(exp_name)
with open(output_name + '.log', 'w') as f:
f.writelines([
f'Log file for experiment {output_name}\n',
f'The experiment presents one big {"gabor" if gabor else "plaid"} patch in pink noise scene.\n'
f'New pink noise is generated every {period:.2f} s\n',
f'\nExperiment settings:\n',
f'Scene dimensions: {size}\n',
f'Length [s]: {length}\n',
f'FPS: {fps}\n',
f'PPD: {ppd}\n',
f'Contrast: {contrast:.2f}\n',
f'Patch position: {patch_position}\n',
f'Position update (x, y) [s^-1]: {(patch_shift_x, patch_shift_y)}\n',
f'Theta update [s^-1]: {theta_speed or 0:.2f}\n',
f'Phase update [s^-1]: {phase_speed or 0:.2f}\n',
f'Frequency update [s^-1]: {freq_speed or 0:.2f}\n',
])
output_values = [] if output_values is None else output_values
fieldnames = []
output_generators = []
for output_value in output_values:
output_value = output_value.lower()
if output_value == 'luminance':
fieldnames.extend([
'compare_lum_gabor_noise_vs_gabor',
'compare_lum_noise_vs_gabor',
'compare_lum_gabor_noise_vs_noise'
])
output_generators.extend([
lambda: luminance_comparison(
noise_with_gabor.get_next_frame(0),
patch_generator.get_normalized_patch()),
lambda: luminance_comparison(
base_noise.get_next_frame(0),
patch_generator.get_normalized_patch()),
lambda: luminance_comparison(
noise_with_gabor.get_next_frame(0),
base_noise.get_next_frame(0)),
])
elif output_value == 'contrast':
fieldnames.extend([
'compare_con_gabor_noise_vs_gabor',
'compare_con_noise_vs_gabor',
'compare_con_gabor_noise_vs_noise'
])
output_generators.extend([
lambda: contrast_comparison(
noise_with_gabor.get_next_frame(0),
patch_generator.get_normalized_patch()),
lambda: contrast_comparison(
base_noise.get_next_frame(0),
patch_generator.get_normalized_patch()),
lambda: contrast_comparison(noise_with_gabor.get_next_frame(0),
base_noise.get_next_frame(0)),
])
elif output_value == 'structure':
fieldnames.extend([
'compare_str_gabor_noise_vs_gabor',
'compare_str_noise_vs_gabor',
'compare_str_gabor_noise_vs_noise'
])
output_generators.extend([
lambda: structural_similarity(
noise_with_gabor.get_next_frame(0),
patch_generator.get_normalized_patch()),
lambda: structural_similarity(
base_noise.get_next_frame(0),
patch_generator.get_normalized_patch()),
lambda: structural_similarity(
noise_with_gabor.get_next_frame(0),
base_noise.get_next_frame(0)),
])
elif output_value == 'cw_structure':
fieldnames.extend([
'compare_cw_str_gabor_noise_vs_gabor',
'compare_cw_str_noise_vs_gabor',
'compare_cw_str_gabor_noise_vs_noise'
])
output_generators.extend([
lambda: phase_invariant_similarity(
noise_with_gabor.get_next_frame(0),
patch_generator.get_normalized_patch()),
lambda: phase_invariant_similarity(
base_noise.get_next_frame(0),
patch_generator.get_normalized_patch()),
lambda: phase_invariant_similarity(
noise_with_gabor.get_next_frame(0),
base_noise.get_next_frame(0)),
])
elif output_value == 'ssim':
fieldnames.extend([
'ssim_gabor_noise_vs_gabor', 'ssim_noise_vs_gabor',
'ssim_gabor_noise_vs_noise'
])
output_generators.extend([
lambda: ssim(noise_with_gabor.get_next_frame(0),
patch_generator.get_normalized_patch(), alpha,
beta, gamma),
lambda: ssim(base_noise.get_next_frame(0),
patch_generator.get_normalized_patch(), alpha,
beta, gamma),
lambda: ssim(noise_with_gabor.get_next_frame(0),
base_noise.get_next_frame(0), alpha, beta, gamma),
])
elif output_value == 'cw_ssim':
fieldnames.extend([
'cw_ssim_gabor_noise_vs_gabor', 'cw_ssim_noise_vs_gabor',
'cw_ssim_gabor_noise_vs_noise'
])
output_generators.extend([
lambda: cw_ssim(noise_with_gabor.get_next_frame(0),
patch_generator.get_normalized_patch(), alpha,
beta, gamma),
lambda: cw_ssim(base_noise.get_next_frame(0),
patch_generator.get_normalized_patch(), alpha,
beta, gamma),
lambda: cw_ssim(noise_with_gabor.get_next_frame(
0), base_noise.get_next_frame(0), alpha, beta, gamma),
])
elif output_value == 'pattern_search_ssim' and granularity:
simple_patch_comparator = PatchComparator(size / ppd,
ppd,
gabor,
granularity=granularity,
alpha=alpha,
beta=beta,
gamma=gamma)
fieldnames.extend([
'simple_ssim_gabor_noise_vs_patch_search',
'simple_ssim_noise_vs_patch_search',
'simple_ssim_gabor_noise_vs_noise',
])
output_generators.extend([
lambda: simple_patch_comparator.get_best_ssim_match(
noise_with_gabor.get_next_frame(0)),
lambda: simple_patch_comparator.get_best_ssim_match(
base_noise.get_next_frame(0)),
lambda: ssim(noise_with_gabor.get_next_frame(0),
base_noise.get_next_frame(0), alpha, beta, gamma)
])
elif output_value == 'pattern_search_cw_ssim' and granularity:
complex_patch_comparator = PatchComparator(size / ppd,
ppd,
gabor,
granularity=granularity,
alpha=alpha,
beta=beta,
gamma=gamma,
simple=False)
fieldnames.extend([
'cw_ssim_gabor_noise_vs_patch_search',
'cw_ssim_noise_vs_patch_search',
'cw_ssim_gabor_noise_vs_noise',
])
output_generators.extend([
lambda: complex_patch_comparator.get_best_ssim_match(
noise_with_gabor.get_next_frame(0)),
lambda: complex_patch_comparator.get_best_ssim_match(
base_noise.get_next_frame(0)),
lambda: cw_ssim(noise_with_gabor.get_next_frame(
0), base_noise.get_next_frame(0), alpha, beta, gamma),
])
elif output_value == 'diff' and output_diff:
fieldnames.extend([
'diff_gabor_noise_max',
'diff_gabor_noise_min',
'diff_gabor_noise_mean',
])
# noinspection PyArgumentList
output_generators.extend([
lambda: diff_noise.get_next_frame(0).max(),
lambda: diff_noise.get_next_frame(0).min(),
lambda: diff_noise.get_next_frame(0).mean(),
])
else:
raise ValueError(f'{output_value} is not a valid output value')
noise_generator = NoiseGeneratorWithCSVOutput(
generator=diff_noise or noise_with_gabor,
file_name=output_name + ".csv",
field_names=fieldnames,
output_generators=output_generators)
if live:
output = PygletOutput(noise_generator.get_next_frame, width, height)
else:
secondary_outputs = [('original', noise_with_gabor.get_next_frame)
] if output_diff else []
output = VideoOutput(noise_generator.get_next_frame,
width,
height,
secondary_outputs=secondary_outputs,
FPS=fps,
length=length,
video_name=output_name + ".avi")
output.run()
hasattr(output, '__del__') and output.__del__()
noise_generator.__del__()
def main():
ch_dir('3_changing_gabor_adv_detection')
for update_type, update_options in patch_updates.items():
for granularity, granularity_value in granularities.items():
update_speed = update_options['middle']
exp_name = f'patch_{update_type}_granularity_{granularity}'
output_name = construct_file_name(exp_name)
with open(output_name + '.log', 'w') as f:
f.writelines([f'Log file for experiment {output_name}\n',
'The experiment presents one big gabor patch in pink noise scene.\n'
f'New pink noise is generated every {base_period:.2f} s\n',
f'\nExperiment settings:\n',
f'Scene dimensions: {base_size}\n',
f'Length [s]: {length}\n',
f'FPS: {fps}\n',
f'PPD: {ppd}\n',
f'Contrast: {base_contrast:.2f}\n',
f'{update_type} update [s^-1]: {update_speed}\n',
])
base_noise = ContinuousNoiseGenerator(base_size, base_size, PinkNoise(base_size, base_size),
period=base_period)
patch_generator = GaborGenerator(patch_size_deg=patch_size_deg, ppd=ppd,
update_list=get_patch_value_updates(update_type, update_speed,
initial_value=6
if update_type == 'freq'
else 0))
noise_with_gabor = PatchedNoiseGenerator(base_size, base_size, base_noise,
[(patch_generator, lambda dt: base_position)],
contrast=base_contrast)
field_names = []
output_generators = []
field_names.extend([
'ssim_gabor_noise_vs_gabor',
'ssim_noise_vs_gabor',
'ssim_gabor_noise_vs_noise'
])
output_generators.extend([
lambda: ssim(noise_with_gabor.get_next_frame(0),
patch_generator.get_normalized_patch(),
alpha, beta, gamma),
lambda: ssim(base_noise.get_next_frame(0),
patch_generator.get_normalized_patch(),
alpha, beta, gamma),
lambda: ssim(noise_with_gabor.get_next_frame(0),
base_noise.get_next_frame(0),
alpha, beta, gamma),
])
field_names.extend([
'simple_ssim_gabor_noise_vs_patch_search',
'simple_ssim_noise_vs_patch_search',
'simple_ssim_gabor_noise_vs_noise',
])
simple_patch_comparator = PatchComparator(patch_size_deg, ppd, granularity=granularity_value,
alpha=alpha, beta=beta, gamma=gamma)
output_generators.extend([
lambda: simple_patch_comparator.get_best_ssim_match(noise_with_gabor.get_next_frame(0)),
lambda: simple_patch_comparator.get_best_ssim_match(base_noise.get_next_frame(0)),
lambda: ssim(noise_with_gabor.get_next_frame(0),
base_noise.get_next_frame(0),
alpha, beta, gamma)
])
field_names.extend([
'cw_ssim_gabor_noise_vs_gabor',
'cw_ssim_noise_vs_gabor',
'cw_ssim_gabor_noise_vs_noise'
])
output_generators.extend([
lambda: cw_ssim(noise_with_gabor.get_next_frame(0),
patch_generator.get_normalized_patch(),
alpha, beta, gamma),
lambda: cw_ssim(base_noise.get_next_frame(0),
patch_generator.get_normalized_patch(),
alpha, beta, gamma),
lambda: cw_ssim(noise_with_gabor.get_next_frame(0),
base_noise.get_next_frame(0),
alpha, beta, gamma),
])
field_names.extend([
'cw_ssim_gabor_noise_vs_patch_search',
'cw_ssim_noise_vs_patch_search',
'cw_ssim_gabor_noise_vs_noise',
])
complex_patch_comparator = PatchComparator(patch_size_deg, ppd, granularity=granularity_value,
alpha=alpha, beta=beta, gamma=gamma, simple=False)
output_generators.extend([
lambda: complex_patch_comparator.get_best_ssim_match(noise_with_gabor.get_next_frame(0)),
lambda: complex_patch_comparator.get_best_ssim_match(base_noise.get_next_frame(0)),
lambda: cw_ssim(noise_with_gabor.get_next_frame(0),
base_noise.get_next_frame(0),
alpha, beta, gamma),
])
generate_experiment_output(output_name=output_name,
generator=noise_with_gabor,
fields=field_names,
outputs=output_generators)
def get_ssim(window):
return ssim(window, get_patch(), alpha=0, beta=-0.5, gamma=0.5)