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

자동암호기 (autoencoder, AE)의 용도:
data denoising
dimensionality reduction
image recognition 
anomaly detection 
semantic segmentation
recommendation engines
feature extraction
classification
encoder as data preparation for predictive model
regularization 


주어진 데이터의 핵심 사항을 찾아내려고 한다. 암호화가 가능한가? 정보의 양이 대폭 축소화된 상태에서도 데이터의 원본 복구가 가능한가? 즉, 암호화가 가능한가?
이렇게 질문하면, 이러한 질문은 비지도학습에 해당한다. 데이터 자체를 탐색하는 것이다. 데이터의 속성을 알아내고자 한다. 핵심 정보의 분포를 알아내고자 한다. 

AE : vector로 정보를 축약함.
VAE : vector로 정보를 축야하지 않고 평균 그리고 편차로 정의되는 함수로 정보를 축약함.

가장 쉬운 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='adam', 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)
---------------------------------------------------------------------------------------------------------------------


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

----

차원 축소의 예, 30 차원 데이터 --> 2차원 데이터

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from tensorflow.keras.layers import Dense
from tensorflow.keras.models import Sequential,Model
#from sklearn.preprocessing import MinMaxScaler
%matplotlib inline

# synthetic classification dataset
from sklearn.datasets import make_classification
# define dataset
X, y = make_classification(n_samples=2000, n_features=30, n_informative=10, n_redundant=10, random_state=7)
# summarize the dataset
print(X.shape, y.shape)

num_inputs = 30
num_hidden = 2 
num_outputs = num_inputs 

model = Sequential()
model.add(Dense(num_inputs, input_shape=[num_inputs]))
model.add(Dense(20,activation='relu'))    # 5 < 20 < num_inputs
model.add(Dense(5,activation='relu'))     # 2 < 5 
model.add(Dense(num_hidden, activation='relu'))
model.add(Dense(5, activation='relu'))   # 2 < 5
model.add(Dense(20,activation='relu'))   # 2 < 5 < 20 < num_outputs=num_inputs
model.add(Dense(num_outputs))
model.compile(optimizer='adam',loss='mse')
model.summary()

history = model.fit(X, X, validation_split=0.20, epochs=250, batch_size=10, verbose=0)

plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('model loss', fontsize=20)
plt.ylabel('loss', fontsize=20)
plt.xlabel('epoch', fontsize=20)
plt.legend(['train', 'test'], loc='upper right')
plt.show()

intermediate_layer_model = Model(inputs=model.input, outputs=model.get_layer(index=3).output)
intermediate_output = intermediate_layer_model.predict(X)

intermediate_output.shape

sns.scatterplot(intermediate_output[:,0],intermediate_output[:,1], hue=y  )

----

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

2012년이 딥러닝의 원년이다.
2011년 Relu 함수의 출현 : vanishing gradient problem 해결, 표현력이 높은 딥러닝이 시작됨.
2012년 Dropout 방법의 출현 : overfitting problem 해결, 정규화된 훈련이 가능함. regularization의 도입.
2012년 CNN 출현 : 방대한 이미지 데이터 처리 문제 해결, 비대칭 데이터에 대한 처리가 가능함.
2013년 VAE 출현: 생성모델로서 다양한 가능성을 제안함.
2014년 GAN 출현: 생성모델로서 많은 응용 가능성을 제안함.
2015년 TensorFlow 구현의 출현과 보급 : 실질적인 딥러닝의 민주화가 단행됨.
2016년 알파고 출현 : 바둑 정복
2017년 알파고 제로 출현 : tabula rasa, first-principles 방법을 이용하여 바둑 정복, 진정한 바둑의 정복이 가능함. 기보없이 바둑 정복함. 프로기사에게 절대로 지지 않는 사실상 바둑의 신이 탄생함. 바둑의 역사 5000년 Mastering the game of Go without human knowledge | Nature http://incredible.egloos.com/7372719
2017년 cycleGAN 출현 http://incredible.egloos.com/7530913
2018년 알파폴드 출현
2021년 플로어플랜닝 (반도체 칩 설계) A graph placement methodology for fast chip design | Nature
2021년 나우캐스팅 (단기 일기예보) https://www.nature.com/articles/s41586-021-03854-z
2022년 알파코드  https://alphacode.deepmind.com/

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

참고:


핑백

덧글

  • 바죠 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

댓글 입력 영역

최근 포토로그