def run_gibbs_with_external_field(image):
#image = images_processing.reduce_channels_for_sampler(image)
image = images_processing.convert_image_to_ising_model(image)
iterations = 2
initial_beta = 0.3
beta_difference = 0.1
beta_range = arithmetic_progression_series(initial_beta, beta_difference,
10)
rows = range(image.shape[0])
columns = range(image.shape[1])
beta = 1.3
all_spins_energy = sum_of_all_spins(image)
for t in range(iterations):
for i in rows:
for j in columns:
site = (i, j)
s = neighbors_energy(image,
site) # a sum of markov blanket values
#odds = np.exp(2*beta*s + 0.5*all_spins_energy)
p = 1 / (1 + np.exp(-2 * s))
u = random.random()
if u < p.any():
image[i, j] = 1
else:
image[i, j] = -1
sampled_image = images_processing.convert_from_ising_to_image(image)
#sampled_image = images_processing.restore_channels(sampled_image, 3) # restored image
images_processing.save_image(
'Denoised images/testing_no_channel_reduction/metropolis_noise_ising_chest_b={0}_noise={1}'
.format(beta, NOISE_LEVEL), 'jpeg', sampled_image)
def run_gibbs_without_noise(image):
image = images_processing.reduce_channels_for_sampler(image)
image = images_processing.convert_image_to_ising_model(image)
iterations = 100
initial_beta = 0.3
beta_difference = 0.1
beta_range = arithmetic_progression_series(initial_beta, beta_difference,
10)
beta = 0.8
# noise_prob = 0.05 # this parameter is taken from the knowledge of noise level in the image
rows = range(image.shape[0])
columns = range(image.shape[1])
for t in range(iterations):
for i in rows:
for j in columns:
site = (i, j)
number_of_black_neighbors = energy_gibbs(image, site, 'black')
number_of_white_neighbors = energy_gibbs(image, site, 'white')
Z_normalizing_constant = np.exp(
number_of_black_neighbors) + np.exp(
number_of_white_neighbors)
posterior = np.exp(
beta * number_of_black_neighbors) / Z_normalizing_constant
u = random.random()
if u < posterior:
image[site] = 1
else:
image[site] = -1
sampled_image = images_processing.convert_from_ising_to_image(image)
sampled_image = images_processing.restore_channels(sampled_image,
3) # restored image
images_processing.save_image(
'Denoised images/gibbs_sampler_no_noise/metropolis_noise_ising_chest_b={0}_noise={1}'
.format(beta, NOISE_LEVEL), 'jpeg', sampled_image)
def run_metropolis_without_noise_for_beta_range(image_name, initial_beta, beta_step, iterations, neighbors_number):
original_image = cv2.imread(image_name)
original_image = images_processing.reduce_channels_for_sampler(original_image)
original_image = images_processing.convert_image_to_ising_model(original_image)
rows = range(original_image.shape[0])
columns = range(original_image.shape[1])
beta_range = arithmetic_progression_series(initial_beta, beta_step, 10)
for beta in beta_range:
sampled_image = original_image # for different values of beta, reset the sampled image to the original one
for t in range(iterations):
for i in rows:
for j in columns:
i = random.randint(0, rows - 1)
j = random.randint(0, columns - 1)
current_site = (i, j)
flipped_value = - sampled_image[current_site]
d = beta * metropolis_sampler.potentials(sampled_image, current_site, flipped_pixel_value=False,
neighbors_number=neighbors_number)
d_flipped = beta * metropolis_sampler.potentials(sampled_image, current_site,
flipped_pixel_value=True)
posterior = np.exp(min(d_flipped - d, 0))
u = random.random()
if u < posterior:
sampled_image[current_site] = flipped_value
sampled_image = images_processing.convert_from_ising_to_image(sampled_image)
sampled_image = images_processing.restore_channels(sampled_image, 3)
format = what(image_name)
images_processing.save_image(
'result_beta={0}_iter={1}_neighbors={2}'.format(beta, iterations, neighbors_number), format, sampled_image,
directory='Results')
noise_probability,
- sampled_image[current_site], original_image[current_site])
posterior = np.exp(min(d_flipped - d, 0))
u = random.random()
if u < posterior:
sampled_image[current_site] = flipped_value
# convert back from Ising
sampled_image = images_processing.convert_from_ising_to_image(sampled_image)
# restore channels
sampled_image = images_processing.restore_channels(sampled_image, 3) # restored image
# create a separate folder to save the result with parameters specified
format = what(image_name)
images_processing.save_image(
'result_beta={0}_noise_p={1}_iter={2}_neighbors={3}'.format(beta, noise_probability, iterations,
neighbors_number), format, sampled_image,
directory='Results')
if __name__ == '__main__':
#arguments = sys.argv
#image_name, beta, iterations, noise_probability, neighbors_number = arguments[1:]
#denoising_pipeline(image_name, float(beta), int(iterations), float(noise_probability), int(neighbors_number))
#print('successfully denoised')
im = cv2.imread('Noisy images/noised_40.0%_grumpy_cat.jpeg')
pixels_number = im.shape[0] * im.shape[1]
beta_values = auxiliary_methods.arithmetic_progression_series(0.8, 0.1, 10)
for b in beta_values:
denoising_pipeline('Noisy images/noised_40.0%_grumpy_cat.jpeg', beta=b, iterations=pixels_number,
noise_probability=.4, neighbors_number=8)
# TODO: next step is to evaluate performance for denoising of 20%-noised image and build corresponding graphs
# TODO: add the possibility to run the sampler with the beta range specified
import cv2
from MCMC.services.auxiliary_methods import arithmetic_progression_series
from MCMC import images_comparison
import matplotlib.pyplot as plt
if __name__ == '__main__':
original_im = cv2.imread('chest_bw.jpeg')
sampled_images = [
'metropolis_noise_ising_chest_b=0.3_noise=0.1.jpeg',
'metropolis_noise_ising_chest_b=0.4_noise=0.1.jpeg',
'metropolis_noise_ising_chest_b=0.5_noise=0.1.jpeg',
'metropolis_noise_ising_chest_b=0.6_noise=0.1.jpeg',
'metropolis_noise_ising_chest_b=0.7_noise=0.1.jpeg',
'metropolis_noise_ising_chest_b=0.8_noise=0.1.jpeg',
'metropolis_noise_ising_chest_b=0.9_noise=0.1.jpeg',
'metropolis_noise_ising_chest_b=1.0_noise=0.1.jpeg',
'metropolis_noise_ising_chest_b=1.1_noise=0.1.jpeg',
'metropolis_noise_ising_chest_b=1.2_noise=0.1.jpeg',
'metropolis_noise_ising_chest_b=1.3_noise=0.1.jpeg']
errors = []
for im in sampled_images:
im = cv2.imread(im)
error = images_comparison.percentage_of_wrong_pixels(im, original_im)
errors.append(error)
betas = arithmetic_progression_series(0.3, 0.1, 11)
plt.plot(betas, errors)
plt.show()
# TODO: graph: beta vs percentage of wrong pixels