가장 쉬운 denoising autoencoder by 바죠

가장 쉬운 Denoising autoencoder

노이즈를 없애버리는 autoencoder, denoising autoencoder

autoencoder의 변형으로 denosing autoencoder를 생각할 수 있다.
아래의 왼쪽의 오염된 문서를 오른쪽의 문서로 변환하는 식으로 응용될 수 있다.

기계학습은 기존의 전통적인 계산체계와는 다른 새로운 형식의 계산을 추구한다.
기존의 계산 방법으로는 푸리에 변환같은 것을 상상할 수 있다.

이러한 denosing 방법은 왜 유용한가?
전통적인 denosing 방법은 픽셀 주변의 데이터를 평균화시기는 것과 유사하다.
따라서, 이미지, 즉 데이터의 미분량을 계산할 때, 이것이 문제가 될 수 있다.

binary_crossentropy,  mse 두 가지 모두 동일한 점을 지향하기는 한다. 

\[ mse = \frac{1}{N} \sum_{i=1}^{N}  (t_i-y_i)^2 \]
\[ bce=  \frac{1}{N}\sum_{i=1}^{N} \{ -t_i log(y_i) -(1-t_i) log(1-y_i)  \} \]



denoising autoencoder 는 x → x 가 아니라 x x 가 되도록 훈련한 것. 여기서 x'은 노이즈를 가지고 있는 객체이다. 노이즈를 업애는 작업을 훈련시킬 수 있다.
x' → x가 되는 훈련을 시키면 된다.

가장 쉬운 생성적 적대 모델, GAN : http://incredible.egloos.com/7473304
가장 쉬운 오토인코더: http://incredible.egloos.com/7473318

---------------------------------------------------------------------------------------------------------------------
#     get MNIST
import numpy as np
from keras.datasets import mnist
(x_train, _), (x_test, y_test) = mnist.load_data()
print(x_train.shape)
print(x_test.shape)
#     noising
x_train = x_train.astype('float32') / 255.
x_test = x_test.astype('float32') / 255.
x_train = np.reshape(x_train, (len(x_train), 28, 28, 1))
#     adapt this if using `channels_first` image data format
x_test = np.reshape(x_test, (len(x_test), 28, 28, 1))
#     adapt this if using `channels_first` image data format
noise_factor = 0.5
x_train_noisy = x_train + noise_factor * np.random.normal(loc=0.0, scale=1.0, size=x_train.shape)
x_test_noisy = x_test + noise_factor * np.random.normal(loc=0.0, scale=1.0, size=x_test.shape)
x_train_noisy = np.clip(x_train_noisy, 0., 1.)
x_test_noisy = np.clip(x_test_noisy, 0., 1.)
#     make a model
from keras.layers import Input, Dense, Conv2D, MaxPooling2D, UpSampling2D
from keras.models import Model
#     adapt this if using `channels_first` image data format
input_img = Input(shape=(28, 28, 1))
x = Conv2D(32, (3, 3), activation='relu', padding='same')(input_img)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(32, (3, 3), activation='relu', padding='same')(x)
encoded = MaxPooling2D((2, 2), padding='same')(x)
#     at this point the representation is (7, 7, 32)
x = Conv2D(32, (3, 3), activation='relu', padding='same')(encoded)
x = UpSampling2D((2, 2))(x)
x = Conv2D(32, (3, 3), activation='relu', padding='same')(x)
x = UpSampling2D((2, 2))(x)
decoded = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(x)
#     this model maps an input to its reconstruction
autoencoder = Model(input_img, decoded)
#     this model maps an input to its encoded representation
encoder = Model(input_img, encoded)
#     compile
autoencoder.compile(optimizer='adadelta', loss='binary_crossentropy')
#     train
from keras.callbacks import TensorBoard
history = autoencoder.fit(x_train_noisy, x_train, epochs=30, batch_size=256, shuffle=True, validation_data=(x_test, x_test), callbacks=[TensorBoard(log_dir='/tmp/autoencoder')])
#     test
#     encode and decode some digits
#     note that we take them from the *test* set
encoded_imgs = encoder.predict(x_test)
decoded_imgs = autoencoder.predict(x_test)
print(encoded_imgs.shape)
print('z: ' + str(encoded_imgs))
#     structure of model
from keras.utils import plot_model
plot_model(autoencoder, show_shapes=True, to_file='autoencoder.png')
#     visualize
import matplotlib.pyplot as plt
n = 10
#     how many digits we will display
plt.figure(figsize=(20, 4))
for i in range(n):
#     display original
    ax = plt.subplot(2, n, i + 1)
    plt.imshow(x_test[i].reshape(28, 28))
    plt.gray()
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)
#     display reconstruction
    ax = plt.subplot(2, n, i + 1 + n)
    plt.imshow(decoded_imgs[i].reshape(28, 28))
    plt.gray()
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)
plt.show()



---------------------------------------------------------------------------------------------------------------------
import matplotlib.pyplot as plt
import numpy as np
from keras.datasets import mnist
from keras.layers import Dense
from keras.models import Sequential

(x_train, _), (x_test, _) = mnist.load_data()

x_train = x_train.astype('float32') / 255.
x_test = x_test.astype('float32') / 255.
x_train = np.reshape(x_train, (len(x_train), 784))
x_test = np.reshape(x_test, (len(x_test), 784))

noise_factor = 0.5
x_train_noisy = x_train + noise_factor * np.random.normal(loc=0.0, scale=1.0, size=x_train.shape) 
x_test_noisy = x_test + noise_factor * np.random.normal(loc=0.0, scale=1.0, size=x_test.shape) 
x_train_noisy = np.clip(x_train_noisy, 0., 1.)
x_test_noisy = np.clip(x_test_noisy, 0., 1.)


n = 10
plt.figure(figsize=(20, 2))
for i in range(1, n + 1):
    ax = plt.subplot(1, n, i)
    plt.imshow(x_test_noisy[i].reshape(28, 28))
    plt.gray()
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)
plt.show()


model = Sequential()
model.add(Dense(128, activation='relu', input_dim=784))
model.add(Dense(64, activation='relu'))
model.add(Dense(32, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(128, activation='relu'))
model.add(Dense(784, activation='sigmoid'))
model.compile(optimizer='adam', loss='binary_crossentropy')
model.fit(x_train_noisy, x_train, epochs=100,batch_size=256, shuffle=True, validation_data=(x_test_noisy, x_test))
decoded_imgs = model.predict(x_test)
n = 10
plt.figure(figsize=(20, 6))
for i in range(1, n+1):
    # display original
    ax = plt.subplot(3, n, i)
    plt.imshow(x_test[i].reshape(28, 28))
    plt.gray()
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)
    # display noisy
    ax = plt.subplot(3, n, i + n)
    plt.imshow(x_test_noisy[i].reshape(28, 28))
    plt.gray()
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)
    # display reconstruction
    ax = plt.subplot(3, n, i + 2*n)
    plt.imshow(decoded_imgs[i].reshape(28, 28))
    plt.gray()
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)
plt.show()
---------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------------
PCA를 이용해서 필터링을 할 수 있다. 노이즈를 제거할 수 있다. 
편차의 정도 또는 주성분의 총 갯수등이 각각 입력이 될 수 있다.

---------------------------------------------------------------------------------------------------------------------

핑백

덧글

  • 바죠 2020/01/14 10:41 # 삭제 답글

  • 바죠 2021/12/17 15:37 # 답글

    import numpy as np
    import cv2 as cv
    from matplotlib import pyplot as plt
    img = cv.imread('die.png')
    dst = cv.fastNlMeansDenoisingColored(img,None,10,10,7,21)
    plt.subplot(121),plt.imshow(img)
    plt.subplot(122),plt.imshow(dst)
    plt.show()


    import numpy as np
    import cv2
    from matplotlib import pyplot as plt

    img = cv2.imread('DiscoveryMuseum_NoiseAdded.jpg')
    b,g,r = cv2.split(img) # get b,g,r
    rgb_img = cv2.merge([r,g,b]) # switch it to rgb

    # Denoising
    dst = cv2.fastNlMeansDenoisingColored(img,None,10,10,7,21)

    b,g,r = cv2.split(dst) # get b,g,r
    rgb_dst = cv2.merge([r,g,b]) # switch it to rgb

    plt.subplot(211),plt.imshow(rgb_img)
    plt.subplot(212),plt.imshow(rgb_dst)
    plt.show()

    import cv2

    img = cv2.imread("test1.jpg", cv2.IMREAD_COLOR)

    '노이즈 제거'
    denoised_img1 = cv2.fastNlMeansDenoisingColored(img, None, 15, 15, 5, 10) # NLmeans
    denoised_img2 = cv2.GaussianBlur(img, (5, 5), 0) # Gaussian
    denoised_img3 = cv2.medianBlur(img, 5) # Median
    denoised_img4 = cv2.bilateralFilter(img, 5, 50, 50) # Bilateral

    cv2.imshow("before", img)
    cv2.imshow("after(NLmeans)", denoised_img1)
    cv2.imshow("after(Gaussian)", denoised_img2)
    cv2.imshow("after(Median)", denoised_img3)
    cv2.imshow("after(Bilateral)", denoised_img4)


    Gaussian, Median, Bilateral 필터처리를 이용해서 노이즈를 제거하는 것에 한계를 가짐:
    median 필터만 해도 salt-and-pepper와 같이 위치 상 떨어져 있는 픽셀들에 노이즈가 낀 경우에만 성공적일 뿐
    노이즈가 여러 픽셀들에 걸쳐있는 경우에는 제대로 노이즈를 제거해내지 못함.

    지역적, 주변 픽셀들을 참고했던 Gaussian, Median, Bilateral 필터처리와 달리 Non-local, 즉 지역을 벗어나서 전체를 고려해서 현재 픽셀의 값을 수정
    import cv2

    img = cv2.imread("test1.jpg", cv2.IMREAD_COLOR)

    '노이즈 제거'
    denoised_img = cv2.fastNlMeansDenoisingColored(img, None, 15, 15, 5, 10)

    cv2.imshow("before", img)
    cv2.imshow("after", denoised_img)


  • 바죠 2021/12/17 15:39 # 답글

    denoise_1 = cv2.fastNlMeansDenoisingColored(img,None,3,3,7,21)
    denoise_2 = cv2.fastNlMeansDenoisingColored(img,None,5,5,7,21)
    denoise_3 = cv2.fastNlMeansDenoisingColored(img,None,15,15,7,21)
  • 바죠 2021/12/31 08:20 # 답글

    https://medium.com/@AnasBrital98/autoencoders-explained-da131e60e02a
  • 바죠 2022/06/10 09:53 # 답글

    https://scikit-learn.org/stable/auto_examples/applications/plot_digits_denoising.html
    https://github.com/jakevdp/PythonDataScienceHandbook/blob/master/notebooks/05.09-Principal-Component-Analysis.ipynb

    https://scikit-learn.org/stable/auto_examples/neighbors/plot_digits_kde_sampling.html#sphx-glr-auto-examples-neighbors-plot-digits-kde-sampling-py

댓글 입력 영역

최근 포토로그