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)