예제가 포함된 TensorFlow의 오토인코더

딥러닝에서 오토인코더란 무엇인가요?

An 자동 인코더 데이터 코딩을 효율적으로 학습하기 위한 도구입니다. 감독되지 않은 방식입니다. 일종의 방식입니다. 인공 신경망 이는 신경망이 신호 잡음을 무시하도록 훈련시켜 차원 축소를 위한 데이터 세트 표현 방식을 학습하는 데 도움이 됩니다. 입력값을 재구성하는 데 매우 유용한 도구입니다.

간단히 말해, 이 기계는 예를 들어 이미지를 입력받아 그와 매우 유사한 이미지를 생성할 수 있습니다. 이러한 종류의 신경망 입력에는 레이블이 지정되지 않으므로, 네트워크는 감독 없이 학습할 수 있습니다. 더 정확히 말하면, 네트워크는 입력에서 가장 중요한 특징만을 추출하도록 인코딩합니다. 이것이 오토인코더가 차원 축소에 널리 사용되는 이유 중 하나입니다. 또한, 오토인코더는 생성형 학습 모델을 만드는 데에도 사용될 수 있습니다. 예를 들어, 신경망을 얼굴 이미지 데이터셋으로 학습시킨 후 새로운 얼굴 이미지를 생성할 수 있습니다.

TensorFlow Autoencoder는 어떻게 작동하나요?

오토인코더의 목적은 필수 기능에만 초점을 맞춰 입력의 근사치를 생성하는 것입니다. 단순히 입력을 복사하고 붙여넣어 출력을 생성하는 방법만 배우면 안 되는지 생각할 수도 있습니다. 실제로 오토인코더는 단순히 출력을 복사하는 것과는 달리 네트워크가 데이터를 표현하는 새로운 방법을 배우도록 하는 일련의 제약 조건입니다.

일반적인 오토인코더는 입력, 내부 표현, 그리고 출력(입력의 근사값)으로 구성됩니다. 학습은 내부 표현에 연결된 레이어에서 이루어집니다. 실제로, 전통적인 신경망과 유사하게 두 개의 주요 레이어 블록이 있습니다. 약간의 차이점은 출력을 포함하는 레이어가 입력과 동일해야 한다는 것입니다. 아래 그림에서, 원래 입력은 인코더라고 불리는 첫 번째 블록으로 들어갑니다. 이 내부 표현은 입력의 크기를 압축(축소)합니다. 두 번째 블록에서는 입력을 복원합니다. 이것이 디코딩 단계입니다.

모델은 손실 함수를 최소화하여 가중치를 업데이트합니다. 재구성 출력이 입력과 다르면 모델에 불이익이 발생합니다.

구체적으로, 50×50(즉, 2,500픽셀) 크기의 이미지와 100개의 뉴런으로 구성된 단 하나의 은닉층을 가진 신경망을 상상해 보세요. 학습은 입력 이미지보다 25배 작은 특징 맵을 기반으로 이루어집니다. 이는 신경망이 100개의 뉴런으로 이루어진 벡터만을 사용하여 2,500픽셀을 재구성하는 방법을 찾아야 한다는 것을 의미합니다.

스택형 오토인코더 예

이 오토인코더 튜토리얼에서는 스택형 오토인코더 사용법을 배우게 됩니다. 이 아키텍처는 기존의 신경망과 유사합니다. 입력은 압축(크기 축소)을 위해 은닉층을 거친 후, 복원층에 도달합니다. 목표는 원본 이미지와 최대한 유사한 출력 이미지를 생성하는 것입니다. 모델은 주어진 제약 조건 하에서, 즉 더 낮은 차원으로 작업을 수행하는 방법을 학습해야 합니다.

오늘날 딥러닝에서 오토인코더는 주로 이미지 노이즈 제거에 사용됩니다. 예를 들어, 긁힌 자국이 있는 이미지를 생각해 보세요. 사람은 여전히 ​​이미지의 내용을 인식할 수 있습니다. 노이즈 제거 오토인코더의 아이디어는 이미지에 노이즈를 추가하여 네트워크가 데이터 뒤에 숨겨진 패턴을 학습하도록 하는 것입니다.

오토인코더의 또 다른 유용한 제품군 딥러닝 변분 오토인코더는 새로운 이미지를 생성할 수 있는 네트워크입니다. 예를 들어, 남성 이미지를 학습시킨 네트워크는 새로운 얼굴을 생성할 수 있습니다.

아래 표는 이 튜토리얼에서 만든 스택형 오토인코더를 여러분이 접하게 될 다른 패밀리들과 나란히 배치하여 각 패밀리가 추가하는 제약 조건을 쉽게 비교할 수 있도록 합니다.

TensorFlow를 사용하여 자동 인코더를 구축하는 방법

이 튜토리얼에서는 스택형 오토인코더를 구축하여 이미지를 재구성하는 방법을 배웁니다.

60000개의 32×32 컬러 이미지가 포함된 CIFAR-10 데이터셋을 사용하게 됩니다. 오토인코더 데이터셋은 이미 50000개의 이미지는 학습용으로, 10000개의 이미지는 테스트용으로 분할되어 있습니다. 클래스는 최대 10개까지 있습니다.

• 비행기
• 자동차
• 새
• 고양이
• 사슴
• 개
• 개구리
• 말
• 디지털,
• 트럭

이미지를 다운로드해야 합니다. CIFAR-10 데이터셋 페이지 압축 파일을 해제하세요. cifar-10-batches-py 폴더에는 각각 10000개의 이미지가 무작위 순서로 배열된 5개의 데이터 배치가 있습니다.

모델을 구축하고 훈련하기 전에 일부 데이터 처리를 적용해야 합니다. 다음과 같이 진행하게 됩니다:

1. 데이터 가져 오기
2. 데이터를 흑백 형식으로 변환
3. 모든 배치 추가
4. 학습 데이터 세트 구성
5. 이미지 시각화 장치 구성

버전 참고: 이 튜토리얼의 코드는 TensorFlow 1.x를 대상으로 합니다. TensorFlow 2에서는 tf.contrib 모듈이 더 이상 존재하지 않으며, 플레이스홀더, 세션 및 초기화 가능한 이터레이터는 tf.compat.v1에 있습니다. import 후 tf.compat.v1.disable_v2_behavior()를 호출하는 것이 코드를 변경 없이 실행하는 가장 빠른 방법입니다.

이미지 전처리

1단계) 데이터 가져오기

공식 웹사이트에 따르면 다음 코드를 사용하여 데이터를 업로드할 수 있습니다. 오토인코더 코드는 데이터와 레이블을 담은 딕셔너리에 데이터를 불러옵니다. 참고로, 이 코드는 함수입니다.

import numpy as np
import tensorflow as tf
import pickle
def unpickle(file):
    import pickle
    with open(file, 'rb') as fo:
        dict = pickle.load(fo, encoding='latin1')
    return dict

2단계) 데이터를 흑백 형식으로 변환

단순화를 위해 데이터를 회색조로 변환하겠습니다. 즉, 색상 이미지의 경우 XNUMX차원에 대해 XNUMX차원만 사용합니다. 대부분의 신경망은 XNUMX차원 입력에만 작동합니다.

def grayscale(im):
    return im.reshape(im.shape[0], 3, 32, 32).mean(1).reshape(im.shape[0], -1)

3단계) ​​모든 배치를 추가합니다.

이제 두 함수가 모두 생성되었고 데이터셋이 로드되었으므로, 메모리에 데이터를 추가하는 루프를 작성할 수 있습니다. 자세히 살펴보면 압축 해제된 데이터 파일의 이름은 data_batch_이며, 1부터 5까지의 숫자가 포함되어 있습니다. 이 파일들을 순회하면서 데이터를 기존 데이터에 추가하면 됩니다.

이 단계가 완료되면 컬러 데이터를 회색조 형식으로 변환합니다. 보시다시피 데이터의 형태는 50000과 1024입니다. 32*32 픽셀이 이제 1024로 평면화되었습니다.

# Load the data into memory
data, labels = [], []
## Loop over the b
for i in range(1, 6):
    filename = './cifar-10-batches-py/data_batch_' + str(i)
    open_data = unpickle(filename)
    if len(data) > 0:
        data = np.vstack((data, open_data['data']))
        labels = np.hstack((labels, open_data['labels']))
    else:
        data = open_data['data']
        labels = open_data['labels']

data = grayscale(data)
x = np.matrix(data)
y = np.array(labels)
print(x.shape)
(50000, 1024)

참고 : './cifar-10-batches-py/data_batch_' 부분을 실제 파일 위치로 변경하세요. 예를 들어, Windows 컴퓨터의 경우 경로는 filename = 'E:\cifar-10-batches-py\data_batch_' + str(i)일 수 있습니다.

4단계) 학습 데이터 세트 구성

학습 속도를 높이고 과정을 간소화하기 위해 말 이미지만을 사용하여 모델을 학습시키겠습니다. 말 이미지는 레이블 데이터에서 7번으로 분류됩니다. CIFAR-10 데이터셋 문서에 언급된 바와 같이 각 클래스에는 5000개의 이미지가 포함되어 있습니다. 아래 TensorFlow Autoencoder 예제 단계에서처럼 데이터의 형태를 출력하여 5,000개의 이미지와 1024개의 열이 있는지 확인할 수 있습니다.

horse_i = np.where(y == 7)[0]
horse_x = x[horse_i]
print(np.shape(horse_x)) 
(5000, 1024)

5단계) 이미지 시각화 장치 구성

마지막으로 이미지를 플롯하는 함수를 구성합니다. 오토인코더에서 재구성된 이미지를 인쇄하려면 이 함수가 필요합니다.

이미지를 출력하는 쉬운 방법은 Matplotlib 라이브러리의 imshow() 함수를 사용하는 것입니다. 단, 데이터의 크기를 1024에서 32*32(이미지 형식)로 변환해야 합니다.

# To plot pretty figures
%matplotlib inline
import matplotlib
import matplotlib.pyplot as plt
def plot_image(image, shape=[32, 32], cmap = "Greys_r"):
    plt.imshow(image.reshape(shape), cmap=cmap,interpolation="nearest")
    plt.axis("off")   

이 함수는 3개의 인수를 사용합니다.

• 이미지: 입력
• 모양: 목록, 이미지 크기
• Cmap: 색상 맵을 선택하세요. 기본값은 회색입니다.

데이터 세트의 첫 번째 이미지를 플롯해 볼 수 있습니다. 말을 탄 사람을 봐야 합니다.

plot_image(horse_x[1], shape=[32, 32], cmap = "Greys_r")

이 호출은 아래와 같은 회색조 썸네일을 반환하며, 1024개의 값에서 32x32 이미지로의 재구성이 올바르게 수행되었음을 확인시켜 줍니다.

데이터세트 추정기 설정

자, 이제 데이터셋을 사용할 준비가 되었으니 TensorFlow를 사용해 볼 수 있습니다. 모델을 구축하기 전에 TensorFlow의 Dataset Estimator를 사용하여 네트워크에 데이터를 입력하세요.

TensorFlow 추정기를 사용하여 데이터 세트를 구축합니다. 마음을 새롭게 하려면 다음을 사용해야 합니다.

• from_tensor_slices
• 반복
• 일괄

데이터세트를 구축하는 전체 코드는 다음과 같습니다.

dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)

여기서 x는 [None, n_inputs] 형태의 플레이스홀더입니다. 첫 번째 차원이 None으로 설정된 이유는 네트워크에 입력되는 이미지 수가 배치 크기와 같기 때문이며, 배치 크기는 런타임에만 결정됩니다. 자세한 내용은 튜토리얼을 참조하십시오. TensorFlow를 이용한 선형 회귀 분석.

그런 다음 반복자를 만들어야 합니다. 이 코드 줄이 없으면 어떤 데이터도 파이프라인을 통과하지 않습니다.

iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()

이제 파이프라인이 준비되었으므로 첫 번째 이미지가 이전과 동일한지(즉, 말을 탄 사람) 확인할 수 있습니다.

배치 크기를 1로 설정한 이유는 데이터셋에 이미지 하나만 입력하기 때문입니다. `print(sess.run(features).shape)`를 통해 데이터의 차원을 확인할 수 있습니다. 이 값은 (1, 1024)입니다. 여기서 1은 1024개의 값으로 이루어진 이미지 하나만 한 번에 입력된다는 의미입니다. 배치 크기를 2로 설정하면 두 개의 이미지가 파이프라인을 거치게 됩니다. 배치 크기를 변경하면 `plot_image()` 함수에 한 번에 하나의 이미지만 입력될 수 있으므로 오류가 발생합니다. 따라서 배치 크기를 변경하지 마십시오.

## Parameters
n_inputs = 32 * 32
BATCH_SIZE = 1
batch_size = tf.placeholder(tf.int64)

# using a placeholder
x = tf.placeholder(tf.float32, shape=[None,n_inputs])
## Dataset
dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)
iter = dataset.make_initializable_iterator() # create the iterator
features = iter.get_next()

## Print the image
with tf.Session() as sess:
    # feed the placeholder with data
    sess.run(iter.initializer, feed_dict={x: horse_x,
                                         batch_size: BATCH_SIZE}) 
    print(sess.run(features).shape) 
    plot_image(sess.run(features), shape=[32, 32], cmap = "Greys_r")
(1, 1024)

이 파이프라인은 NumPy 행렬에서 직접 그린 것과 동일한 라이더를 반환하며, 이는 플레이스홀더, 이터레이터 및 배치 크기가 올바르게 연결되었음을 증명합니다.

네트워크 구축

이제 네트워크를 구축할 차례입니다. 여러 개의 숨겨진 레이어가 있는 네트워크인 누적 오토인코더를 훈련시킵니다.

여러분의 네트워크는 이미지의 형태인 32×32 크기의 1024개 점으로 이루어진 하나의 입력 레이어를 갖게 될 것입니다.

인코더 블록은 300개의 뉴런을 가진 최상위 은닉층과 150개의 뉴런을 가진 중앙층으로 구성됩니다. 디코더 블록은 인코더 블록과 대칭 구조입니다. 아래 다이어그램에서 네트워크 구조를 시각화할 수 있습니다. 은닉층과 중앙층의 값은 변경할 수 있습니다.

오토인코더 구축은 다른 딥러닝 모델과 매우 유사합니다.

다음 단계에 따라 모델을 구성합니다.

1. 매개변수 정의
2. 레이어 정의
3. 아키텍처 정의
4. 최적화 정의
5. 모델 실행
6. 모델 평가

이전 섹션에서 모델에 데이터를 입력하는 파이프라인을 만드는 방법을 배웠으므로 데이터셋을 다시 만들 필요는 없습니다. 4개의 레이어로 구성된 오토인코더를 구축할 것입니다. 자비에르 초기화(Xavier initialization)를 사용하는데, 이는 입력과 출력의 분산을 고려하여 초기 가중치를 설정하는 기법입니다. 마지막으로 ELU 활성화 함수를 사용하고, 손실 함수에는 L2 정규화를 적용합니다.

1단계) 매개변수를 정의합니다

첫 번째 단계는 각 계층의 뉴런 수, 학습률 및 정규화기의 하이퍼파라미터를 정의하는 것을 의미합니다.

그 전에 부분 함수를 임포트해야 합니다. 이는 완전 연결 레이어의 매개변수를 정의하는 더 나은 방법입니다. 아래 코드는 오토인코더 아키텍처의 값을 정의합니다. 앞서 설명했듯이 인코더는 두 개의 레이어로 구성되며, 첫 번째 레이어에는 300개의 뉴런, 두 번째 레이어에는 150개의 뉴런이 있습니다. 이들의 값은 n_hidden_1과 n_hidden_2에 저장됩니다.

학습률과 L2 하이퍼파라미터를 정의해야 합니다. 해당 값은 learning_rate와 l2_reg에 저장됩니다.

from functools import partial

## Encoder
n_hidden_1 = 300
n_hidden_2 = 150  # codings

## Decoder
n_hidden_3 = n_hidden_1
n_outputs = n_inputs

learning_rate = 0.01
l2_reg = 0.0001

Xavier 초기화 기법은 추정기 contrib의 xavier_initializer 객체를 사용하여 호출됩니다. 동일한 추정기에서 l2_regularizer를 사용하여 정규화 기법을 추가할 수도 있습니다.

## Define the Xavier initialization
xav_init =  tf.contrib.layers.xavier_initializer()
## Define the L2 regularizer
l2_regularizer = tf.contrib.layers.l2_regularizer(l2_reg)

버전 참고: TensorFlow 2에서 tf.contrib가 제거되었습니다. 직접적인 대체 함수로는 xavier_initializer() 대신 tf.keras.initializers.GlorotUniform()을, l2_regularizer() 대신 tf.keras.regularizers.l2()를 사용할 수 있습니다.

2단계) 레이어를 정의합니다

완전 연결 레이어의 모든 매개변수가 설정되었습니다. partial 객체를 사용하여 모든 내용을 dense_layer 변수에 담을 수 있습니다. dense_layer는 호출될 때마다 ELU 활성화 함수, Xavier 초기화, L2 정규화를 적용합니다.

## Create the dense layer
dense_layer = partial(tf.layers.dense,
                         activation=tf.nn.elu,
                         kernel_initializer=xav_init,
                         kernel_regularizer=l2_regularizer)

3단계) ​​아키텍처를 정의합니다

아키텍처 다이어그램을 보면, 네트워크가 출력 레이어를 포함하여 세 개의 레이어로 구성되어 있음을 알 수 있습니다. 아래 코드에서는 각 레이어를 적절하게 연결합니다. 예를 들어, 첫 번째 레이어는 입력 행렬 특징과 300개의 가중치를 포함하는 행렬의 내적을 계산합니다. 내적 계산 후, 출력은 ELU 활성화 함수를 거칩니다. 이 출력은 다음 레이어의 입력이 되므로, hidden_2 등을 계산하는 데 사용됩니다. 각 레이어에서 동일한 활성화 함수를 사용하기 때문에 행렬 곱셈도 동일합니다. 마지막 레이어인 출력 레이어에는 활성화 함수가 적용되지 않습니다. 이는 재구성된 입력이기 때문에 당연한 결과입니다.

## Make the mat mul
hidden_1 = dense_layer(features, n_hidden_1)
hidden_2 = dense_layer(hidden_1, n_hidden_2)
hidden_3 = dense_layer(hidden_2, n_hidden_3)
outputs = dense_layer(hidden_3, n_outputs, activation=None)

4단계) 최적화를 정의합니다

마지막 단계는 옵티마이저를 구축하는 것입니다. 손실 함수로는 평균 제곱 오차(MSE)를 사용합니다. 선형 회귀 분석 튜토리얼을 떠올려보면, MSE는 예측 출력과 실제 레이블 간의 차이로 계산된다는 것을 알 수 있습니다. 여기서 레이블은 모델이 입력을 재구성하려고 하기 때문에 특징(feature)이 됩니다. 따라서 예측 출력과 입력 간의 차이 제곱합의 평균을 구하는 것이 목표입니다. TensorFlow를 사용하면 다음과 같이 손실 함수를 코딩할 수 있습니다.

loss = tf.reduce_mean(tf.square(outputs - features))

다음으로 손실 함수를 최적화해야 합니다. Adam 최적화 알고리즘을 사용하여 기울기를 계산합니다. 목적 함수는 손실을 최소화하는 것입니다.

## Optimize
loss = tf.reduce_mean(tf.square(outputs - features))
optimizer = tf.train.AdamOptimizer(learning_rate)
train  = optimizer.minimize(loss)

모델을 훈련하기 전에 설정이 하나 더 있습니다. 150의 배치 크기를 사용하려고 합니다. 즉, 반복할 때마다 150개의 이미지를 파이프라인에 공급하려고 합니다. 반복 횟수를 수동으로 계산해야 합니다. 이는 간단한 작업입니다.

만약 매번 150개의 이미지를 전달하고 싶고 데이터셋에 총 5000개의 이미지가 있다는 것을 알고 있다면, 반복 횟수는 5000을 150으로 나눈 값과 같습니다. Python 다음 코드를 실행하고 출력값이 33인지 확인하십시오.

BATCH_SIZE = 150
### Number of batches :  length dataset / batch size
n_batches = horse_x.shape[0] // BATCH_SIZE
print(n_batches)
33

5단계) 모델을 실행합니다

마지막으로 모델을 학습시키세요. 100 에포크 동안 모델을 학습시킵니다. 즉, 모델은 가중치를 최적화하는 동안 이미지를 100번 학습하게 됩니다.

TensorFlow에서 모델을 학습시키는 코드는 이미 익숙하실 겁니다. 약간의 차이점은 학습을 실행하기 전에 데이터를 파이프라인으로 전달하는 것입니다. 이렇게 하면 모델 학습 속도가 빨라집니다.

모델이 무엇인가 학습하고 있는지(즉, 손실이 감소하고 있는지) 확인하기 위해 2개의 에포크 후에 손실을 인쇄하는 데 관심이 있습니다. 훈련은 기계 하드웨어에 따라 5~XNUMX분 정도 소요됩니다.

## Set params
n_epochs = 100

## Call Saver to save the model and re-use it later during evaluation
saver = tf.train.Saver()

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    # initialise iterator with train data
    sess.run(iter.initializer, feed_dict={x: horse_x,
                                          batch_size: BATCH_SIZE})
    print('Training...')
    print(sess.run(features).shape) 
    for epoch in range(n_epochs):       
        for iteration in range(n_batches):
            sess.run(train)
        if epoch % 10 == 0:
            loss_train = loss.eval()   # not shown
            print("\r{}".format(epoch), "Train MSE:", loss_train) 
        #saver.save(sess, "./my_model_all_layers.ckpt") 
    save_path = saver.save(sess, "./model.ckpt")    
    print("Model saved in path: %s" % save_path)  
Training...
(150, 1024)
0 Train MSE: 2934.455
10 Train MSE: 1672.676
20 Train MSE: 1514.709
30 Train MSE: 1404.3118
40 Train MSE: 1425.058
50 Train MSE: 1479.0631
60 Train MSE: 1609.5259
70 Train MSE: 1482.3223
80 Train MSE: 1445.7035
90 Train MSE: 1453.8597
Model saved in path: ./model.ckpt

6단계) 모델 평가

모델 학습이 완료되었으니 이제 평가할 차례입니다. /cifar-10-batches-py/ 파일에서 테스트 세트를 가져와야 합니다.

test_data = unpickle('./cifar-10-batches-py/test_batch')
test_x = grayscale(test_data['data'])
#test_labels = np.array(test_data['labels'])

참고 : Windows 컴퓨터에서 코드는 test_data = unpickle(r”E:\cifar-10-batches-py\test_batch”)가 됩니다.

말 그림인 13번 이미지를 인쇄해 보세요.

plot_image(test_x[13], shape=[32, 32], cmap = "Greys_r")

그래프는 테스트 배치가 올바르게 로드되었으며 이미지 13이 모델 학습에 사용된 클래스에 속함을 확인시켜 줍니다.

모델을 평가하기 위해 이 이미지의 픽셀 값을 사용하여 인코더가 이미지를 1024픽셀로 축소한 후 동일한 이미지를 복원할 수 있는지 확인합니다. 다양한 이미지에 대해 모델을 평가하는 함수를 정의해야 합니다. 이 모델은 말 이미지에 대해 더 나은 성능을 보여야 합니다.

이 함수는 두 가지 인수를 사용합니다.

• df: 테스트 데이터를 가져옵니다
• image_number: 가져올 이미지를 지정합니다.

이 기능은 세 부분으로 나누어집니다:

1. 이미지를 올바른 크기(예: 1, 1024)로 변경합니다.
2. 보이지 않는 이미지를 모델에 공급하고 이미지를 인코딩/디코딩합니다.
3. 실제 이미지와 재구성된 이미지를 인쇄하세요.

def reconstruct_image(df, image_number = 1):
    ## Part 1: Reshape the image to the correct dimension i.e 1, 1024
    x_test = df[image_number]
    x_test_1 = x_test.reshape((1, 32*32))
    
    ## Part 2: Feed the model with the unseen image, encode/decode the image
    with tf.Session() as sess:     
        sess.run(tf.global_variables_initializer()) 
        sess.run(iter.initializer, feed_dict={x: x_test_1,
                                      batch_size: 1})
    ## Part 3:  Print the real and reconstructed image
      # Restore variables from disk.
        saver.restore(sess, "./model.ckpt")  
        print("Model restored.")
      # Reconstruct image
        outputs_val = outputs.eval()
        print(outputs_val.shape)
        fig = plt.figure()
      # Plot real
        ax1 = fig.add_subplot(121)
        plot_image(x_test_1, shape=[32, 32], cmap = "Greys_r")
      # Plot estimated
        ax2 = fig.add_subplot(122)
        plot_image(outputs_val, shape=[32, 32], cmap = "Greys_r")
        plt.tight_layout()
        fig = plt.gcf()

이제 평가 함수가 정의되었으므로 재구성된 이미지 13번을 살펴보실 수 있습니다.

reconstruct_image(df =test_x, image_number = 13)

INFO:tensorflow:Restoring parameters from ./model.ckpt
Model restored.
(1, 1024)

이 그림은 왼쪽에 원본 테스트 이미지를, 오른쪽에 오토인코더 출력 이미지를 배치하여 1024에서 150으로 압축 후 발생하는 미세한 디테일 손실을 쉽게 판단할 수 있도록 합니다.

자주 묻는 질문