가장 쉬운 AE (autoencoder) 예제 by 바죠


가장 쉬운 AE (Autoencoder) 예제

\[ \vec{x}  \rightarrow  \vec{y} \]
\[ \vec{x}  \rightarrow  \vec{x} \]

\[ \{ \vec{x} \}  \]


기계학습에서는 x-->y 처럼 데이터에 있는 함수 관계를 예측하는 것이다. 그런데, 많은 데이터들에 대해서, y=x로 두면 어떻게 될까?
VAE의 경우, 정규항이 추가된다. D_KL
self-supervised learning
이것이야 말로 나는 누구인가를 탐구하는 자기 성찰과정이다.
나는 무엇인가를 탐구하는 것이다.


Restricted Boltzmann Machine (RBM)의 구조와 유사하다. 
특히, W, W^T  조건이 성립하면 RMB으로 수렴한다. 즉, decoder와 encoder가 사실상 동일한 경우가 가능하다.

벡터가 들어가서 벡터 자신이 나오는 것 말이다. 물론, 데이터를 축약하는 것에 초점을 둔다. 데이터를 잃어버리면서 축약을 해 본다. 정보을 잃어 버리는 이러한 과정을 왜 할까? 그 이유는 뒤에서 언급할 것이다. 아무튼 이상한 짓이다. 그리고 원본을 만들어 본다. 매우 많은 데이터에 대해서 이러한 작업을 하면서 인공신경망을 훈련할 수 있다. 인공신경망을 활용한 훈련과 예측에 아무런 추가적인 제약이 없다. 다소 이상한 훈련이지만, 인공신경망의 훈련에는, 계산적으로, 구조적으로 아무런 문제점이 없다.
 
아래의 그림에서 처럼, x 데이터가 들어가서 x' 데이터가 나오게 한다. x'  = x가 되게 한다. 즉, 자신이 출력이 되게 한다. 사실, 이것을 자기 학습이라고 부를 수 있다. 자기 성찰이다. 나는 누구인가?
이 때, 인공신경망의 배열에 주목해야만 한다. 중간 단계에서 정보를 잃어버리게, 의도적으로, 인공 신경망을 설계한다.
다시 말해서, x' 은 결코 x 가 되지 못할 것이다. 왜냐하면 그러게 되도록 훈련을 시킨다고 하더라도 중간에 잃어버리는 정보가 너무 많기 때문이다.

매우 많은 예제들에 대해서 이러한 일들이 수행하여 인공 신경망을 훈련시킬 수 있다.

데이터의 압축하는 방법을 정립하므로써 새로운 데이터를 만들어 낼 수 있다. 데이터를 압축할 때, 당연히 정보를 잃어버린다.
동시에 압축된 정보로 부터 데이터를 복원하는 방법을 개발한다. 데이터를 가지고 있다면 언제든지 할 수 있는 일이다.

차원축소(dimensionality reduction)의 한 가지 방법이다. 차원 축소를 수행할 수 있는 방법은 여러 가지가 있다.
multidimensional scaling, principal component analysis 등 다양한 방법이 있다.

선형 활성함수를 사용할 경우, PCA와 완전히 동등한 분포를 얻을 수도 있다. PCA는 선형이다.
결국, 충분한 데이터에 대해서, 데이터 압축과정과 복원과정이라는 두 단계를 만들 수 있다. 잃어버린 정보가 있지만, 상당한 정보를 가진 네트워크를 만들 수 있다. 데이터를 기술하는 중추적인 정보를 인코더가 확보할 수 있을 것이다. 이 제한된, 하지만, 본질적인 정보로부터 원본을 최대한 복구하는 방법도 동시에 만드는 것이다. 중추적이지 못한 데이터도 있을 것이다. 이들은 어느정도 밖에서 조절할 수 있다. 정규분포같은 것이 있을 수 있다. 평균적으로 특정한 모양을 구축하고 편차 형식으로 샘플의 개성이 표현되도록 할 수 있을 것이다.

applications: data denoising and dimensionality reduction
dimensionality reduction or feature learning
NLP

가장 쉬운 디노이징 오토인코더 :  http://incredible.egloos.com/7479749

Wassersein GAN with gradient penalty
Our proposed method performs better than standard WGAN and enables stable training of a wide variety of GAN architectures with almost no hyperparameter tuning,including 101-layer ResNets and language models with continuous generators.We also achieve high quality generations on CIFAR-10 and LSUN bedrooms.




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

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

from keras.layers import Input, Dense
from keras.models import Model
#     this is the size of our encoded representations
encoding_dim = 32           # 32 floats -> compression of factor 24.5, assuming the input is 784 floats, 28*28/32 = 24.5

#     this is our input placeholder
input_img = Input(shape=(784,))
#     "encoded" is the encoded representation of the input
encoded = Dense(encoding_dim, activation='relu')(input_img)
#      "decoded" is the lossy reconstruction of the input
decoded = Dense(784, activation='sigmoid')(encoded)

#      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)

#     create a placeholder for an encoded 32D input
encoded_input = Input(shape=(encoding_dim,))
#     retrieve the last layer of the autoencoder model
decoder_layer = autoencoder.layers[-1]
#     create the decoder model
decoder = Model(encoded_input, decoder_layer(encoded_input))

autoencoder.compile(optimizer='adadelta', loss='binary_crossentropy')

from keras.datasets import mnist
import numpy as np
(x_train, _), (x_test, _) = mnist.load_data()
x_train = x_train.astype('float32') / 255.
x_test = x_test.astype('float32') / 255.
x_train = x_train.reshape((len(x_train), np.prod(x_train.shape[1:])))
x_test = x_test.reshape((len(x_test), np.prod(x_test.shape[1:])))
print(x_train.shape)
print(x_test.shape)

autoencoder.fit(x_train, x_train, epochs=50, batch_size=256, shuffle=True, validation_data=(x_test, x_test))
#     encode and decode some digits
#     note that we take them from the *test* set
encoded_imgs = encoder.predict(x_test)
decoded_imgs = decoder.predict(encoded_imgs)

#     use matplotlib
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()


---------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------------
#If you have a GPU that supports CUDA
$ pip3 install tensorflow-gpu==2.0.0b1#Otherwise
$ pip3 install tensorflow==2.0.0b1

from tensorflow.keras.datasets import mnist
from tensorflow.keras.layers import Dense, Input, Flatten, Reshape, LeakyReLU as LR, Activation, Dropout
from tensorflow.keras.models import Model, Sequential
from matplotlib import pyplot as plt
from IPython import display                            #      If using IPython, Colab or Jupyter
import numpy as np(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train/255.0
x_test = x_test/255.0                                      #       Plot image data from x_train
plt.imshow(x_train[0], cmap = "gray")
plt.show()

LATENT_SIZE = 32
encoder = Sequential([
    Flatten(input_shape = (28, 28)),    Dense(512),    LR(),    Dropout(0.5), Dense(256),    LR(),    Dropout(0.5),   
    Dense(128),    LR(),    Dropout(0.5),    Dense(64),    LR(),    Dropout(0.5),     Dense(LATENT_SIZE),  LR() ])

decoder = Sequential([
    Dense(64, input_shape = (LATENT_SIZE,)),    LR(),   Dropout(0.5),  Dense(128), LR(), Dropout(0.5),   
    Dense(256), LR(), Dropout(0.5),
    Dense(512),    LR(),    Dropout(0.5),     Dense(784), Activation("sigmoid"),    Reshape((28, 28))  ])
img = Input(shape = (28, 28))
latent_vector = encoder(img)
output = decoder(latent_vector)
model = Model(inputs = img, outputs = output)
model.compile("nadam", loss = "binary_crossentropy")
EPOCHS = 60                     #     Only do plotting if you have IPython, Jupyter, or using Colab
for epoch in range(EPOCHS):
    fig, axs = plt.subplots(4, 4)
    rand = x_test[np.random.randint(0, 10000, 16)].reshape((4, 4, 1, 28, 28))
   
    display.clear_output()     #      If you imported display from IPython
   
    for i in range(4):
        for j in range(4):
            axs[i, j].imshow(model.predict(rand[i, j])[0], cmap = "gray")
            axs[i, j].axis("off")
   
    plt.subplots_adjust(wspace = 0, hspace = 0)
    plt.show()
    print("-----------", "EPOCH", epoch, "-----------")
    model.fit(x_train, x_train)
---------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------------




참고:


핑백

덧글

  • 바죠 2020/01/31 17:06 # 답글

    #If you have a GPU that supports CUDA
    $ pip3 install tensorflow-gpu==2.0.0b1#Otherwise
    $ pip3 install tensorflow==2.0.0b1

    from tensorflow.keras.datasets import mnist
    from tensorflow.keras.layers import Dense, Input, Flatten,
    Reshape, LeakyReLU as LR,
    Activation, Dropout
    from tensorflow.keras.models import Model, Sequential
    from matplotlib import pyplot as plt
    from IPython import display # If using IPython, Colab or Jupyter
    import numpy as np(x_train, y_train), (x_test, y_test) = mnist.load_data()
    x_train = x_train/255.0
    x_test = x_test/255.0# Plot image data from x_train
    plt.imshow(x_train[0], cmap = "gray")
    plt.show()LATENT_SIZE = 32encoder = Sequential([
    Flatten(input_shape = (28, 28)),
    Dense(512),
    LR(),
    Dropout(0.5),
    Dense(256),
    LR(),
    Dropout(0.5),
    Dense(128),
    LR(),
    Dropout(0.5),
    Dense(64),
    LR(),
    Dropout(0.5),
    Dense(LATENT_SIZE),
    LR()
    ])decoder = Sequential([
    Dense(64, input_shape = (LATENT_SIZE,)),
    LR(),
    Dropout(0.5),
    Dense(128),
    LR(),
    Dropout(0.5),
    Dense(256),
    LR(),
    Dropout(0.5),
    Dense(512),
    LR(),
    Dropout(0.5),
    Dense(784),
    Activation("sigmoid"),
    Reshape((28, 28))
    ])img = Input(shape = (28, 28))
    latent_vector = encoder(img)
    output = decoder(latent_vector)model = Model(inputs = img, outputs = output)
    model.compile("nadam", loss = "binary_crossentropy")EPOCHS = 60#Only do plotting if you have IPython, Jupyter, or using Colabfor epoch in range(EPOCHS):
    fig, axs = plt.subplots(4, 4)
    rand = x_test[np.random.randint(0, 10000, 16)].reshape((4, 4, 1, 28, 28))

    display.clear_output() # If you imported display from IPython

    for i in range(4):
    for j in range(4):
    axs[i, j].imshow(model.predict(rand[i, j])[0], cmap = "gray")
    axs[i, j].axis("off")

    plt.subplots_adjust(wspace = 0, hspace = 0)
    plt.show()
    print("-----------", "EPOCH", epoch, "-----------")
    model.fit(x_train, x_train)
  • 바죠 2020/05/27 08:41 # 답글

    Anomaly detection with Autoencoders
  • 바죠 2021/02/04 12:06 # 답글

    https://www.youtube.com/watch?v=9zKuYvjFFS8
  • 바죠 2021/02/04 12:27 # 답글

    autorencoder --> T SNE

댓글 입력 영역

최근 포토로그



MathJax