def run_exp(intup):
global X_train, X_test, y_train, y_test
rep, i, p = intup
# Make noisy data, simulate pool-based case
X_train_noisy = utils.add_gaussian_noise(X_train, p)
y_train_noisy = y_train # utils.flip_labels(y_train, p)
X_seed, X_pool = X_train_noisy[:n_seed], X_train_noisy[n_seed:]
y_seed, y_pool = y_train_noisy[:n_seed], y_train_noisy[n_seed:]
# Initializing the learner
learner = ActiveLearner(
estimator=RandomForestClassifier(n_estimators=10),
query_strategy=entropy_sampling,
X_training=X_seed, y_training=y_seed
)
# Run active learning and record history of test accuracy
history = np.zeros(query_budget - n_seed)
for j in range(query_budget - n_seed):
query_idx, query_inst = learner.query(X_pool)
learner.teach(X_pool[query_idx], y_pool[query_idx])
history[j] = learner.score(X_test, y_test)
return history
import cv2
import numpy as np
from skimage.restoration import denoise_wavelet
def wavelet_denoise(noisy_im):
im_est = denoise_wavelet(noisy_im,
method='BayesShrink',
mode='soft',
rescale_sigma=True)
im_est = np.clip(im_est * 255, 0, 255)
im_est = im_est.astype(np.uint8)
return im_est
if __name__ == '__main__':
from utils import add_gaussian_noise
sigma = 40
im = cv2.imread('test_image/Cameraman.png', cv2.IMREAD_GRAYSCALE)
noisy_im = add_gaussian_noise(im, sigma)
im_est = wavelet_denoise(noisy_im)
cv2.imwrite('im_est.png', im_est)
import os
import cv2
from utils import add_gaussian_noise, symetrize
# <hyper parameter>
ref_i, ref_j = 196, 142
# ref_i, ref_j = 271, 206
kHW = 8
NHW = 3
nHW = 16
tauMatch = 2500
# <hyper parameter \>
im = cv2.imread('test_data/image/Cameraman.png', cv2.IMREAD_GRAYSCALE)
im_noisy = add_gaussian_noise(im, 10, seed=1)
img_noisy_p = symetrize(im_noisy, nHW)
near_pij, threshold_count = precompute_BM(img_noisy_p,
kHW=kHW,
NHW=NHW,
nHW=nHW,
tauMatch=tauMatch)
im = cv2.cvtColor(img_noisy_p, cv2.COLOR_GRAY2RGB)
# <draw search area>
points_list = [(ref_j - nHW, ref_i - nHW), (ref_j + nHW, ref_i - nHW),
(ref_j - nHW, ref_i + nHW), (ref_j + nHW, ref_i + nHW)]
for point in points_list:
cv2.circle(im, point, 0, (0, 0, 255), 1)
# <draw search area \>
img_basic = numerator / denominator
return img_basic
if __name__ == '__main__':
from utils import add_gaussian_noise, symetrize
# <hyper parameter> -------------------------------------------------------------------------------
sigma = 20
nHard = 16
kHard = 8
NHard = 16
pHard = 3
lambdaHard3D = 2.7 # ! Threshold for Hard Thresholding
tauMatchHard = 2500 if sigma < 35 else 5000 # ! threshold determinates similarity between patches
useSD_h = False
tau_2D_hard = 'BIOR'
# <\ hyper parameter> -----------------------------------------------------------------------------
img = cv2.imread('test_data/image/Cameraman.png', cv2.IMREAD_GRAYSCALE)
img_noisy = add_gaussian_noise(img, sigma)
# img_noisy = cv2.imread('matlab_officialfg_compare/noisy_image.png', cv2.IMREAD_GRAYSCALE)
img_noisy_p = symetrize(img_noisy, nHard)
img_basic = bm3d_1st_step(sigma, img_noisy_p, nHard, kHard, NHard, pHard,
lambdaHard3D, tauMatchHard, useSD_h, tau_2D_hard)
img_basic = img_basic[nHard:-nHard, nHard:-nHard]
# cv2.imwrite('y_basic.png', img_basic.astype(np.uint8))
nHard = 16
kHard = 8
NHard = 16
pHard = 3
lambdaHard3D = 2.7 # ! Threshold for Hard Thresholding
useSD_h = False
tau_2D_hard = 'BIOR'
# <\ hyper parameter> -----------------------------------------------------------------------------
read_dir = 'test_data/image'
# for sigma in [2, 5, 10, 20, 30, 40, 60, 80, 100]:
for sigma in [30, 40, 60, 80, 100]:
tauMatchHard = 2500 if sigma < 35 else 5000 # ! threshold determinates similarity between patches
for image_name in os.listdir(read_dir):
image_path = os.path.join(read_dir, image_name)
im = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
im_noisy = add_gaussian_noise(im, sigma, seed=0)
im_noisy_p = symetrize(im_noisy, nHard)
im_basic = bm3d_1st_step(sigma, im_noisy_p, nHard, kHard, NHard,
pHard, lambdaHard3D, tauMatchHard,
useSD_h, tau_2D_hard)
im_basic = im_basic[nHard:-nHard, nHard:-nHard]
im_basic = (np.clip(im_basic, 0, 255)).astype(np.uint8)
cv2.imwrite(
'noisy_image_and_1st_res/' + image_name[:-4] + '_sigma' +
str(sigma) + '.png', im_noisy)
cv2.imwrite(
'noisy_image_and_1st_res/' + image_name[:-4] + '_sigma' +
str(sigma) + '_1st.png', im_basic)
print(image_name[:-4] + '_sigma' + str(sigma))
else:
return -self._u_max
policy = BangBang(1, t_final)
simulated_sys = simulate_system(cp, s0, policy, t_final, n_steps=150)
# define x0 and P0
x0 = np.array([.2, 0, 0, 0])
P0 = np.diag([1, .01, .5, .01])
Q = .1 * np.eye(cp.n_state)
R = np.eye(2)
ekf = ExtendedKF(cp, x0, P0)
state_estimate = []
measurement_types = [PendulumTipPosition(cp), PendulumTipVelocity(cp)]
for sys_info in simulated_sys[1:]:
ekf.propagate(policy(sys_info['t'], ekf.x), sys_info['t'], Q)
measurement_method = random.choice(measurement_types)
raw_meas = measurement_method.calculate(sys_info['state'],
sys_info['input'])
meas = add_gaussian_noise(raw_meas, std=np.array([.05, .05]))
ekf.update(meas, measurement_method, np.diag([.05, .05]))
state_estimate.append(ekf.x)
from ssa import ssa_2d
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import numpy as np
from skimage.measure import compare_psnr as psnr
from skimage.measure import compare_ssim as ssim
import utils
img = mpimg.imread('lena.bmp')
img = utils.scale_img(img)
img_noise = utils.add_gaussian_noise(img, noise_variance=0.2)
img_noise = utils.scale_img(img_noise)
window_height = 10
window_width = 15
number_of_eigenvectors = 25
#number_of_eigenvectors_rec = 17
img_reconstructed = ssa_2d(
img=img_noise,
u=window_height,
v=window_width,
l=number_of_eigenvectors,
#l_rec = number_of_eigenvectors_rec,
verbose=3)
img_reconstructed = utils.scale_img(img_reconstructed)
patch_k = 9
im_dir = 'special_test_image'
sigma_list = [10, 20, 30, 40, 60, 80, 100]
for im_name in os.listdir(im_dir):
auc_list_noisy = list()
auc_list_nlm = list()
auc_list_tv = list()
auc_list_Wavelet = list()
for sigma in sigma_list:
im_path = os.path.join(im_dir, im_name)
im = cv2.imread(im_path, cv2.IMREAD_GRAYSCALE)
noisy_im = add_gaussian_noise(im, sigma, seed=1)
fpr_list, tpr_list = compute_fpr_tpr(im, noisy_im, patch_k)
roc_auc = auc(fpr_list, tpr_list)
# plt.plot(fpr_list, tpr_list, lw=1, alpha=0.7, color='black', linestyle='--',
# label='noisy_im_AUC=%0.6f' % (roc_auc))
auc_list_noisy.append(roc_auc)
im_est = nlm_denoise(noisy_im, sigma)
fpr_list, tpr_list = compute_fpr_tpr(im, im_est, patch_k)
roc_auc = auc(fpr_list, tpr_list)
# plt.plot(fpr_list, tpr_list, lw=1, alpha=0.7, color='gold', linestyle='--',
# label='NLM_AUC= %0.6f' % (roc_auc))
auc_list_nlm.append(roc_auc)
im_est = tv_denoise(noisy_im, sigma)
xv = xv[:min(n_matched, N2_wie)]
yv = yv[mask]
xv = xv[:min(n_matched, N2_wie)]
for i in range(len(grp_noisy)):
step2_agg[yv[i]:yv[i] + N1_wie,
xv[i]:xv[i] + N1_wie] += grp_noisy[i]
step2_weights[yv[i]:yv[i] + N1_wie,
xv[i]:xv[i] + N1_wie] += weights
final_im = step2_agg / (step2_weights + 10e-8)
return basic_im, final_im
if __name__ == '__main__':
gt_im = utils.load_image_to_array('images/lena.tif', size=[256, 256])
noisy = utils.add_gaussian_noise(gt_im, 20)
utils.array_to_image(noisy, clip=True).save('noisy' + '.jpg')
im = bm3d(noisy, sigma=20)
basic_im, final_im = im
print('PSNR for basic estimate is %.1f' % (utils.psnr(gt_im, basic_im)))
print('PSNR for final estimate is %.1f' % (utils.psnr(gt_im, final_im)))
utils.array_to_image(basic_im, clip=True).save('bm3d_basic.jpg')
utils.array_to_image(final_im, clip=True).save('bm3d_final.jpg')
quit()
for x in [8, 12, 16, 32]:
im = bm3d(noisy, sigma=20, N2_ht=x, N2_wie=x)
# im = utils.dct(gt_im)
# im = utils.hard_thr(im, 2.7*20)
# im = utils.dct(im, inverse=True)
# utils.array_to_image(im, clip=True).save('dct'+'.jpg')
# quit()
if k == 0:
filtered_block = ptv.tvgen(tensor, [lamb_x, lamb_y, lamb_z], [1, 2, 3],
[1, 1, 1])
elif k == 1:
pass
elif k == 2:
pass
else:
raise NotImplementedError
return filtered_block
if __name__ == '__main__':
import cv2
import time
block = np.ones((64, 64, 16)) * 128
block = add_gaussian_noise(block, 50)
tik = time.time()
res = trendFilter3D(block, 10, k=0)
print(time.time() - tik)
res_im = res.astype(np.uint8)
for i in range(16):
slice = res_im[:, i, :]
# <hyper parameter> -------------------------------------------------------------------------------
sigma = 20
nHard = 16
kHard = 8
NHard = 16
pHard = 3
lambdaHard3D = 2.7 # ! Threshold for Hard Thresholding
tauMatchHard = 2500 if sigma < 35 else 5000 # ! threshold determinates similarity between patches
useSD_h = False
tau_2D_hard = 'BIOR'
# <\ hyper parameter> -----------------------------------------------------------------------------
img = cv2.imread('test_data/image/Cameraman.png', cv2.IMREAD_GRAYSCALE)
img = cv2.resize(img, (128, 128))
img_noisy = add_gaussian_noise(img, sigma, seed=0)
img_noisy_p = symetrize(img_noisy, nHard)
img_basic = bm3d_1st_step(sigma, img_noisy_p, nHard, kHard, NHard, pHard,
lambdaHard3D, tauMatchHard, useSD_h, tau_2D_hard)
img_basic = img_basic[nHard:-nHard, nHard:-nHard]
# <hyper parameter> -------------------------------------------------------------------------------
sigma = 20
nWien = 16
kWien = 8
NWien = 16
pWien = 3
tauMatchWien = 400 if sigma < 35 else 3500 # ! threshold determinates similarity between patches
useSD_w = True
h_e_hat = 0.95 # threshold for the measure of the edge (domain: [0, 1])
sp_noise_amount = 0 # amount of salt-paper noise (domain: [0, 1])
gaus_noise_snr = 15 # signal-to-noise ratio for gaussian noise (domain: >= 0)
sigma = 3 # sigma for gaussian filter (domain: >= 1)
# ----------
# Get image
img_orig = img2gray(plt.imread(img_path))
img = img_orig.copy()
# Add noise
if sp_noise_amount:
img = add_sp_noise(img, amount=sp_noise_amount)
if gaus_noise_snr:
img = add_gaussian_noise(img, snr=gaus_noise_snr)
# if sigma:
# img = apply_gaussian_filter(img, sigma=sigma)
# Show image
plt.figure()
plt.subplot(1, 2, 1)
plt.title('Original image')
plt.imshow(img_orig, cmap='gray', vmin=0, vmax=1)
plt.subplot(1, 2, 2)
plt.title('Noisy image')
plt.imshow(img, cmap='gray', vmin=0, vmax=1)
plt.show(block=False)
# Corners detection
pixel_corners_coords = corners_harris(img, sigma=sigma, min_distance=1, threshold_rel=0.05)
'''
Created on Aug 6, 2019
@author: jsaavedr
Adding Gaussian Noise
'''
import matplotlib.pyplot as plt
import scipy.ndimage.filters as nd_filters
import skimage.filters as filters
import skimage.io as io
import utils
import pai_io
if __name__ == '__main__' :
filename ='../images/gray/lenna_gray.png'
image=pai_io.imread(filename, as_gray = True)
noisy_image = utils.add_gaussian_noise(image, 20)
#io.imsave(filename+"noisy.png", noisy_image)
g_kernel = utils.get_gaussian2d(1, 3)
image_g = nd_filters.convolve(image, g_kernel, mode='constant', cval=0)
fig, xs = plt.subplots(1,3)
for i in range(3):
xs[i].set_axis_off()
xs[0].imshow(image, cmap = 'gray', vmin = 0, vmax = 255)
xs[0].set_title('Image')
xs[1].imshow(noisy_image, cmap = 'gray', vmin = 0, vmax = 255)
xs[1].set_title('Ruido Gaussiano')
xs[2].imshow(image_g, cmap = 'gray', vmin = 0, vmax = 255)
xs[2].set_title('Imagen Filtrada')
plt.show()
