def variational_inference(data):
entropy = 0
new_entropy = 1
mus = np.zeros(data.shape)
# initialize mu
for i in range(data.shape[0]):
for j in range(data.shape[1]):
if data[i, j] == 1:
mus[i, j] = L1.pdf(1) - L1.pdf(-1)
else:
mus[i, j] = L_1.pdf(1) - L_1.pdf(-1)
entropy = compute_entropy(data, mus)
iter = 0
print("initialized")
while abs(entropy - new_entropy) > 0.0001:
iter += 1
entropy = new_entropy
for i in range(data.shape[0]):
for j in range(data.shape[1]):
mus = update_mu(i, j, data, mus)
new_entropy = compute_entropy(data, mus)
print(new_entropy)
iter_mus = mus.copy()
denoized_data = np.round(iter_mus)
denoized_data = transform_back_values(denoized_data)
denoized_data = transform_back_shape(denoized_data)
write_data(
denoized_data,
str(J) + '_J_' + str(sigma) + '_sigma_' + str(iter) + '_epoch' +
str(filenumber) + '_noise_vi.txt')
read_data(
str(J) + '_J_' + str(sigma) + '_sigma_' + str(iter) + '_epoch' +
str(filenumber) + '_noise_vi.txt', True, False, True)
return mus
def output(data_dict, filename, prefix='outputs/a2/'):
for type, data in data_dict.items():
write_data(data, prefix + type + '_' + filename)
read_data(prefix + type + '_' + filename,
False,
save=True,
save_name=prefix + type + '_' +
filename.replace('.txt', '.jpg'))
def main(): # Denoise noise images 1-4 using the gibbs sampling algorithm and save the # denoised data matrix and denoised image into text and png files respectively for a in range(1,5): noisetxt = "../a1/" + str(a) + "_noise.txt" print(noisetxt) data, image = read_data(noisetxt, True) data_arr = data_to_arr(data) new_data_arr = gibbs_sample(data_arr, 15) new_data = arr_to_data(new_data_arr) denoisetxt = "../output/" + str(a) + "_denoise_gibbs.txt" write_data(new_data, denoisetxt) denoisepng = "../output/" + str(a) + "_denoise_gibbs.png" read_data(denoisetxt, True, False, True, denoisepng)
def denoise_gibbs(filenumber):
"""transform data, preforms gibbs sampling, transform back data"""
data, image = read_data('../a1/' + str(filenumber) + '_noise.txt', True)
data = transform_data_shape(data)
# put data in {-1, 1} space
data = transform_data_values(data)
denoized_data = gibbs_sampling(data)
denoized_data = transform_back_values(denoized_data)
denoized_data = transform_back_shape(denoized_data)
write_data(
denoized_data, 'final_denoised' + str(J) + '_J_' + str(sigma) +
'_sigma_' + str(filenumber) + '_noise.txt')
read_data(
'final_denoised' + str(J) + '_J_' + str(sigma) + '_sigma_' +
str(filenumber) + '_noise.txt', True, False, True)
return denoized_data
def process_save(animal, data, responsibilities, k):
max_responsibilities = [
np.argmax(responsibilities[i])
for i in range(responsibilities.shape[0])
]
data_classified = np.zeros(data.shape)
for i in range(data.shape[0]):
data_classified[i, 0] = data[i, 0]
data_classified[i, 1] = data[i, 1]
data_classified[i, 2] = (100 / (k - 1)) * max_responsibilities[i]
data_classified[i, 3] = 0
data_classified[i, 4] = 0
write_data(data_classified, animal + '_mask.txt')
for k in range(k):
for i in range(data.shape[0]):
data_classified[i, 2] = data[i, 2] * (max_responsibilities[i] == k)
data_classified[i, 3] = data[i, 3] * (max_responsibilities[i] == k)
data_classified[i, 4] = data[i, 4] * (max_responsibilities[i] == k)
write_data(data_classified, animal + '_seg' + str(k) + '.txt')
def gibbs_sampling(data):
"""
perform gibbs sampling as described in lecture 10 on data
:param data: input image that went through transform shape and transform values
:return: denoised data
"""
observations = data
square_size = observations.shape[0]
for t in range(num_iter):
print('epoch ', t)
for i in range(observations.shape[0]):
# print(' line ', i)
for j in range(observations.shape[1]):
y = observations[i, j]
# print(y)
local_evidence_law = scipy.stats.norm(y, sigma)
neighbors = find_neighbors(i, j, data.shape[0] - 1,
data.shape[1] - 1)
sum_neigh = sum_neighbors(neighbors, data)
# print(J, sum_neigh)
term_1 = local_evidence_law.pdf(1) * math.exp(J * sum_neigh)
term_minus_1 = local_evidence_law.pdf(-1) * math.exp(
-J * sum_neigh)
proba_x_1 = term_1 / (term_1 + term_minus_1)
rand = np.random.rand()
if rand < proba_x_1:
observations[i, j] = 1
else:
observations[i, j] = -1
epoch = observations.copy()
denoized_data = transform_back_values(epoch)
denoized_data = transform_back_shape(denoized_data)
write_data(
denoized_data,
str(J) + '_J_' + str(sigma) + '_sigma_' + str(t) + '_epoch' +
str(filenumber) + '_noise.txt')
return observations
def main():
for img in range(2, 3):
print("Denoising for image " + str(img))
data, image = read_data("../data/" + str(img) + "_noise.txt",
True,
visualize=True)
print(data.shape)
print(image.shape)
image[image == 0] = -1
image[image == 255] = 1
avg = denoise(image, 0.7, 20, 100)
avg[avg >= 0] = 255
avg[avg < 0] = 0
print(avg.shape)
width = avg.shape[0]
height = avg.shape[1]
counter = 0
for i in range(0, width):
for j in range(0, height):
data[counter][2] = avg[i][j][0]
counter = counter + 1
write_data(data, "../output/" + str(img) + "_denoise.txt")
read_data("../output/" + str(img) + "_denoise.txt",
True,
save=True,
save_name="../output/" + str(img) + "_denoise.jpg")
print("Finished writing data. Please check " + str(img) +
"_denoise.jpg \n")
mask_image[:, 2] = mask * 100
foreground = np.zeros(shape=data.shape)
foreground[:, 0:2] = data[:, 0:2]
for i in range(2, 5):
foreground[:, i] = np.multiply(data[:, i], inverse_mask)
background = np.zeros(shape=data.shape)
background[:, 0:2] = data[:, 0:2]
for i in range(2, 5):
background[:, i] = np.multiply(data[:, i], mask)
return mask_image, foreground, background
if __name__ == '__main__':
values = ['fox', 'owl', 'zebra', 'cow']
for i in values:
print("Now Processing : " + str(i) + ".txt")
filename = "data" + os.sep + str(i) + ".txt"
data, image = read_data(filename, is_RGB=False)
mask, foreground, background = segment_image(data)
output_filename = "results" + os.sep + str(i) + "_mask.txt"
write_data(mask, output_filename)
data, image = read_data(output_filename, is_RGB=False, save=True)
output_filename = "results" + os.sep + str(i) + "_foreground.txt"
write_data(foreground, output_filename)
data, image = read_data(output_filename, is_RGB=False, save=True)
output_filename = "results" + os.sep + str(i) + "_background.txt"
write_data(background, output_filename)
data, image = read_data(output_filename, is_RGB=False, save=True)
def write_read_data(start_name, end_name, data):
# save data matrix and image into text and jpg files respectively
txt = "../output/" + start_name + "_" + end_name + ".txt"
write_data(data, txt)
jpg = "../output/" + start_name + "_" + end_name + ".jpg"
read_data(txt, False, False, True, jpg)
def expect_maxim(self, filename):
#initializing for first iteration
self.prior = [0.5, 0.5]
exp_mean1 = 0
exp_mean2 = 0
#Expectation step
log_lh = []
while (1):
self.post_sum = [0, 0]
self.posterior = [[0, 0]]
exp_mean1 = [0, 0, 0]
exp_mean2 = [0, 0, 0]
for v in self.image:
for i in v:
l_post = [0, 0]
l_post[0] = multivariate_normal.pdf(
i,
mean=self.Mean[0],
cov=self.Cov1,
allow_singular=True) # Likelihood 1
l_post[1] = multivariate_normal.pdf(
i,
mean=self.Mean[1],
cov=self.Cov2,
allow_singular=True) # Likelihood 2
l_post[0] = self.prior[0] * l_post[0]
l_post[1] = self.prior[1] * l_post[1]
Normalization = l_post[0] + l_post[1]
l_post[0] = l_post[0] / Normalization
l_post[1] = l_post[1] / Normalization
self.posterior.append(l_post)
self.post_sum[0] = self.post_sum[0] + l_post[
0] #used in the maximization step
self.post_sum[1] = self.post_sum[1] + l_post[1]
exp_mean1 = exp_mean1 + (l_post[0] * i)
exp_mean2 = exp_mean2 + (l_post[1] * i)
#Maximization Step :
self.Mean[0] = exp_mean1 / self.post_sum[0] #updated Mean
self.Mean[1] = exp_mean2 / self.post_sum[1]
variance1 = np.zeros((3, 3))
variance2 = np.zeros((3, 3))
j = 1
for v in self.image:
for i in v:
variance1 = variance1 + (self.posterior[j][0] * np.outer(
(i - self.Mean[0]), (i - self.Mean[0])))
variance2 = variance2 + (self.posterior[j][1] * np.outer(
(i - self.Mean[1]), (i - self.Mean[1])))
j = j + 1
self.Cov1 = variance1 / self.post_sum[0] #updated variance
self.Cov2 = variance2 / self.post_sum[1]
self.prior[0] = self.post_sum[0] / self.X.shape[0] #updated prior
self.prior[1] = self.post_sum[1] / self.X.shape[0]
print("Maximization ended")
lval = 0
sumList = []
for v in self.image:
for i in v:
l_post[0] = multivariate_normal.pdf(i,
self.Mean[0],
self.Cov1,
allow_singular=True)
l_post[1] = multivariate_normal.pdf(i,
self.Mean[1],
self.Cov2,
allow_singular=True)
Normalization = (self.prior[0] *
l_post[0]) + (self.prior[1] * l_post[1])
sumList.append(np.log(Normalization))
lval = np.sum(np.asarray(sumList))
log_lh.append(lval)
print("Log Likelihood: " + str(lval))
if len(log_lh) < 2: continue
if np.abs(lval - log_lh[-2]) < 0.5: break
#end of While loop
#Copying mask
backg = self.data.copy()
foreg = self.data.copy()
mask = self.data.copy()
for i in range(0, len(self.data) - 1):
cell = self.data[i]
point = [cell[2], cell[3], cell[4]]
l_post = [0, 0]
l_post[0] = multivariate_normal.pdf(
point, mean=self.Mean[0], cov=self.Cov1,
allow_singular=True) # Likelihood 1
l_post[1] = multivariate_normal.pdf(
point, mean=self.Mean[1], cov=self.Cov2,
allow_singular=True) # Likelihood 2
l_post[0] = self.prior[0] * l_post[0]
l_post[1] = self.prior[1] * l_post[1]
Normalization = l_post[0] + l_post[1]
l_post[0] = l_post[0] / Normalization
l_post[1] = l_post[1] / Normalization
if (l_post[0] < l_post[1]):
backg[i][2] = backg[i][3] = backg[i][4] = 0
mask[i][2] = mask[i][3] = mask[i][4] = 0
else:
foreg[i][2] = foreg[i][3] = foreg[i][4] = 0
mask[i][2] = 100
mask[i][3] = mask[i][4] = 0
write_data(backg, filename + "_back.txt")
read_data(filename + "_back.txt",
False,
save=True,
save_name=filename + "_background.jpg")
write_data(foreg, filename + "_fore.txt")
read_data(filename + "_fore.txt",
False,
save=True,
save_name=filename + "_foreground.jpg")
write_data(mask, filename + "_mask.txt")
read_data(filename + "_mask.txt",
False,
save=True,
save_name=filename + "_masked.jpg")
#Importing data and initializing the parameters
data,image = read_data("../a1/4_noise.txt",True)
Y = normalize_img(image)
r,c = Y.shape
X0 = np.zeros(Y.shape)
Beta = 8
nbiter = 10
step = max(int(nbiter/100),1)
sigma = 3.5
#Image denoising
X_list = gibbs(X0,Beta,Y,sigma,nbiter)[2:]
X_avg = unnormalize_avg_img(X_list)
#Output
write_data(img_to_data(X_avg), "../outputs/a1/4_output_5.txt")
read_data("../outputs/a1/4_output_5.txt", True, save=True)
sigmas = np.tile(np.identity(d),(K,1)).reshape(K,d,d)
pis = np.repeat(1/K,K)
#Using K-Means to provide the initial means for EM
mus,r = Kmeans(obs_data,mus,K_epsilon)
#Using EM for data segmentation (expressed in gamma)
gamma,pis,mus,sigmas = EM(obs_data,pis,mus,sigmas,EM_epsilon)
print(pis)
#Generating mask, foreground, background and exporting them
mask = BuildMask(data,gamma)
Fgnd,Bgnd = FBgnd(data,mask)
write_data(mask,"../outputs/a2/"+ animal +"_mask.txt")
read_data("../outputs/a2/"+animal + "_mask.txt", True, save=True)
write_data(Fgnd,"../outputs/a2/"+animal +"_Fgnd.txt")
read_data("../outputs/a2/"+animal + "_Fgnd.txt", False, save = True)
write_data(Bgnd,"../outputs/a2/"+animal +"_Bgnd.txt")
read_data("../outputs/a2/"+animal + "_Bgnd.txt", False, save = True)
def fit_EM(m1, m2, filename, data, image):
mean1 = m1 #Mean 1
mean2 = m2 #Mean 2
eps = 0.5 #Threshold
z = np.asarray([[13, 20, 29], [13, 23, 37], [13, 23, 29]])
cov1 = np.cov(z) #covariance 1
z = np.asarray([[9, -58, 7], [8, -7, 10], [6, -4, 6]])
cov2 = np.cov(z) #covariance 2
mix1 = 0.4 #mixing co-efficient 1
mix2 = 0.6 #mixing co-efficient 2
N = image.shape[0] * image.shape[1] #Total number of samples
log_likelihoods = []
print("Initialization of mean,covariance and mixing co-efficient statement done for "+str(filename))
print("")
print("Starting EM algorithm for "+str(filename))
# Expectation Step :
iteration_number = 0
while (1):
iteration_number += 1
print("Iteration: "+str(iteration_number))
N1 = 0
N2 = 0
resp1_list = []
resp2_list = []
mu_sum1 = [0, 0, 0]
mu_sum2 = [0, 0, 0]
for y in image:
for x in y:
prob1 = pyro.sample("prob1", dist.multivariate_studentt)
prob1 = multivariate_normal.pdf(x, mean=mean1, cov=cov1, allow_singular=True) # gaussian density 1
prob2 = multivariate_normal.pdf(x, mean=mean2, cov=cov2, allow_singular=True) # gaussian density 2
Numerator1 = mix1 * prob1
Numerator2 = mix2 * prob2
denom = Numerator1 + Numerator2
resp1 = Numerator1 / denom #responsibility for 1st cluster
resp2 = Numerator2 / denom #responsibility for 2nd cluster
resp1_list.append(resp1)
resp2_list.append(resp2)
mu_sum1 += resp1 * x
mu_sum2 += resp2 * x
N1 += resp1
N2 += resp2
# Maximization Step :
mu_new1 = mu_sum1 / N1 #updated mean 1
mu_new2 = mu_sum2 / N2 #updated mean 2
var_1 = np.zeros((3, 3))
var_2 = np.zeros((3, 3))
i = 0
for y in image:
for x in y:
var_1 += resp1_list[i] * np.outer((x - mu_new1), (x - mu_new1))
var_2 += resp2_list[i] * np.outer((x - mu_new2), (x - mu_new2))
i = i + 1
var_new1 = var_1 / N1 #updated covariance1
var_new2 = var_2 / N2 #updated covariance2
mix_new1 = N1 / N #updated mixing co-efficient1
mix_new2 = N2 / N #updated mixing co-efficient2
mean1 = mu_new1
mean2 = mu_new2
cov1 = var_new1
cov2 = var_new2
mix1 = mix_new1
mix2 = mix_new2
#Calculate Log Likelihood
Z = [0, 0]
ll = 0
sumList=[]
for y in image:
for x in y:
prob1 = multivariate_normal.pdf(x, mu_new1, var_new1, allow_singular=True)
prob2 = multivariate_normal.pdf(x, mu_new2, var_new2, allow_singular=True)
sum = (mix_new1 * prob1) + (mix_new2 * prob2)
sumList.append(np.log(sum))
ll = np.sum(np.asarray(sumList))
log_likelihoods.append(ll)
print("Log Likelihood: " + str(ll))
if len(log_likelihoods) < 2: continue
if np.abs(ll - log_likelihoods[-2]) < eps: break
#Break loop if log likelihoods dont change more than threshold over 2 iterations
print("")
print("End of iterations for: " + str(filename))
print("")
#Write to File
print("Writing to file for: " + str(filename))
back_data = data.copy()
front_data = data.copy()
mask_data = data.copy()
for i in range(0,len(data)-1):
cell = data[i]
point = [cell[2], cell[3], cell[4]]
prob1 = multivariate_normal.pdf(point, mean=mean1, cov=cov1, allow_singular=True)
resp1 = mix1 * prob1
prob2 = multivariate_normal.pdf(point, mean=mean2, cov=cov2, allow_singular=True)
resp2 = mix2 * prob2
resp1 = resp1/(resp1+resp2)
resp2 = resp2/(resp1+resp2)
if (resp1 < resp2):
back_data[i][2] = back_data[i][3] = back_data[i][4] = 0
mask_data[i][2] = mask_data[i][3] = mask_data[i][4] = 0
else:
front_data[i][2] = front_data[i][3] = front_data[i][4] = 0
mask_data[i][2] = 100
mask_data[i][3] = mask_data[i][4] = 0
write_data(back_data,"../output/"+str(filename)+"_back.txt")
read_data("../output/"+str(filename)+"_back.txt", False, save=True, save_name="../output/"+str(filename)+"_background.jpg")
write_data(front_data,"../output/"+str(filename)+"_fore.txt")
read_data("../output/"+str(filename)+"_fore.txt", False, save=True, save_name="../output/"+str(filename)+"_foreground.jpg")
write_data(mask_data,"../output/"+str(filename)+"_mask.txt")
read_data("../output/"+str(filename)+"_mask.txt", False, save=True, save_name="../output/"+str(filename)+"_masked.jpg")
print("Finished writing data. Please check "+str(filename)+"_background.jpg, "+str(filename)+
"_foreground.jpg and "+str(filename)+"_masked.jpg ")
def denoise_data(data):
X = get_mrf(data)
gibbs_params = {
'coupling_strength' : 3,
'sigma' : 0.5,
'iterations' : 5
}
gibbs_samples = run_gibbs_sampling(X,gibbs_params)
denoised_data = mrf_to_txt(gibbs_samples)
return denoised_data
if __name__=='__main__':
for i in range(1,5):
print ("Now Processing : " + str(i) + "_noise.txt")
filename = "data" + os.sep + str(i) +"_noise.txt"
data, image = read_data(filename, is_RGB = True)
denoised_data = denoise_data(data)
for j in range(denoised_data.shape[2]):
if j == 0:
output_filename = "gibbs_denoising_results" + os.sep + str(i) + "_original.txt"
write_data(denoised_data[:,:,j], output_filename)
data, image = read_data(output_filename, is_RGB=True, save=True)
else:
output_filename = "gibbs_denoising_results" + os.sep + str(i) + "_denoise_iter{:d}.txt".format(j)
write_data(denoised_data[:,:,j], output_filename)
data, image = read_data(output_filename, is_RGB=True, save=True)
