오토 인코더에 대해서 공부해야 할 일이 생겨서, 하는 도중 정리하기 위해 포스팅을 하게 되었습니다.
공부하여 작성하는 거라, 부족할 수 있으니 많은 피드백 주시면 감사하겠습니다.
01. 오토 인코더 (autoencoder)
오토 인코더는 비지도 학습 방법의 하나입니다. 그러기 때문에 모델을 학습하기 위한 명확한 라벨(정답)이 제공되지 않습니다. 즉, 오토 인코더를 학습하기 위해서는 입력 데이터를 필요로 합니다.
제가 공부하면서 느낀 것은 오토 인코더의 학습과정은 마치 "압축과 압축해제"와 같다고 느꼈습니다.
이미지를 학습한다고 가정했을 때, 입력 이미지를 받고, 학습 레이어를 거쳐 입력 이미지를 잘 설명할 수 있는 축소된 차원이 데이터("latent space" 또는 "bottle neck"이라고 하는)로 변환되고, 이 데이터를 다시 reconstruct하여 입력이미지를 복원하거나 target 이미지를 구성해내는 과정을 거친다고 이해했습니다.
조금 더 깊게 생각했을 때, 입력층에서 이미지가 들어오고, 각 노드들은 이에 대한 특징(feature)을 Encoder를 통해 차원 축소를 거치고, 입력 및 target 이미지를 잘 설명할 수 있는 데이터로 압축한 후에 이를 Decoder를 통해 복원하여 표현하는 과정이라고 이해했습니다.
마치 오토 인코더는 PCA와 비슷하다고 생각도 들었습니다. 하지만, PCA는 선형적 차원축소하는 반면 오토인코더는 비선형적 차원축소를 한다고 합니다 (활성함수 이야기 인거 같습니다).
02. Encoder와 Decoder
오토인코더 과정은 3단계로 나누어 볼 수 있을 거 같습니다.
데이터 입력
Encoder
Decoder
Encoder: Encoder는 결국 입력 데이터를"입력 데이터의 특징을 잘 설명할 수 있는 데이터로 차원 축소한다"이 공간을 "latent-space", 또는 "bottle neck"이라고 합니다.
Decoder: Decoder는 입력 및 target 데이터로 복원(복호화)을 합니다. decoder가 encoder로부터 받은 데이터로 정확하게 입력 및 target 데이터로 복원한다면 decoder의 성능이 좋다고 표현합니다.
#정답보기
for i in range(32):
pred_label = labels[np.argmax(predictions[i])]
fn = fns[i]
la = labels[label[i]]
print(i, '번째', '파일', fn, '참값', la, '예측값', pred_label)
>>>0 번째 파일 ./CIFAR-10-images-master/test/truck/0959.jpg 참값 truck 예측값 truck
>>>1 번째 파일 ./CIFAR-10-images-master/test/truck/0830.jpg 참값 truck 예측값 truck
>>>2 번째 파일 ./CIFAR-10-images-master/test/bird/0134.jpg 참값 bird 예측값 bird
>>>3 번째 파일 ./CIFAR-10-images-master/test/horse/0935.jpg 참값 horse 예측값 horse
>>>4 번째 파일 ./CIFAR-10-images-master/test/horse/0147.jpg 참값 horse 예측값 horse
>>>5 번째 파일 ./CIFAR-10-images-master/test/dog/0239.jpg 참값 dog 예측값 dog
>>>6 번째 파일 ./CIFAR-10-images-master/test/frog/0285.jpg 참값 frog 예측값 frog
>>>7 번째 파일 ./CIFAR-10-images-master/test/truck/0876.jpg 참값 truck 예측값 truck
>>>8 번째 파일 ./CIFAR-10-images-master/test/deer/0236.jpg 참값 deer 예측값 frog
위의 방법이 있다는 수준으로 전달 드린 것입니다. 결국 참값과 예측값을 비교하는 것이죠!!
이번에는 그림으로 시각화 해보시죠!
예측한 데이터와 정답 이미지로 확인 하기
#이미지 데이터를 랜덤하게 n개 추출하여 라벨, 파일이름, 이미지 배열 추출 함수
def load_rand_img(imagesset, randint):
images = imagesset.filepaths
labels = imagesset.labels
rand_imgs = []
label = []
for i in range(randint):
rand_num = random.randrange(0,len(images))
rand_imgs.append(images[rand_num])
label.append(labels[rand_num])
load_imgs = load_img(rand_imgs)
return label, rand_imgs, load_imgs
# 예측 결과를 figure로 확인하는 함수
def plot_predict(figsize, num, classes, label, images, predictions):
fig = plt.figure(figsize=(figsize[0], figsize[1]))
for i in range(num):
plt.subplot(figsize[0], figsize[1], i + 1)
plt.grid(False)
plt.xticks([])
plt.yticks([])
fn = plt.imread(images[i])
plt.imshow(fn)
la = classes[label[i]]
pred_label = classes[np.argmax(predictions[i])]
if pred_label == la:
color = 'green'
else:
color = 'red'
plt.xlabel("{}({}, i={})".format(pred_label, la, i), color=color)
plt.show()
# 메인 실행
labels = ["airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck"]
label, fns, images2 = load_rand_img(images, 10000)
predictions = model.predict(images2/255)
plot_predict((4,8),32, labels, label, fns, predictions)
xlabel의 형식은 "예측값(참값)" 으로 설정하였습니다.
이번 시행에서 32개 중에 7개 오답을 보였으니, 약 22%의 오답률, 즉 78% 정답률을 보여주었지만, 해당 코드는 실행할 때마다 다시 랜덤추출하기 때문에 한눈에 모델을 평가하기는 어렵습니다!!
그래서!! 모델의 성능을 한눈에 보기위해 "Confusion Matrix"를 적용해보았습니다!!
예측한 데이터와 정답을 "Confusion Matrix"로 확인 하기
Confusion Matrix에 대해 잠깐 본다면 참값(타겟의 원래 클래스)와 예측값(모형이 예측한 클래스)가 일치하는지를 갯수로 수치화 한 결과 표라고 보시면 되겠네요!
정답 클래스는 행(row)로, 예측 클래스는 열(column)로 표현하기때문에, Confusion Matrix는 모델이 잘 작동되는지 확인할 수 있는 좋은 방법입니다.
keras에서는 이미지데이터 학습을 쉽게하도록 하기위해 다양한 패키지를 제공한다. 그 중 하나가 ImageDataGenerator 클래스이다.
ImageDataGenerator 클래스를 통해 객체를 생성할 때 파라미터를 전달해주는 것을 통해 데이터의 전처리를 쉽게할 수 있고, 또 이 객체의 flow_from_directory 메소드를 활용하면 폴더 형태로된 데이터 구조를 바로 가져와서 사용할 수 있다.
이 과정은 매우 직관적이고 ImageDataGenerator를 사용하지 않는 방법에 비해 상당히 짧아진다.
ImageDataGenerator를 통해 parameter arugmentation을 하고, flow_from_directory
메소드를 사용해, 폴더를 특정 사이즈로 이미지를 불러올 수 있다.
02. CIFAR-10 학습해 보기
학습과정은 기본적인 FLOW를 배경으로 하였다.
이미지로드
train 과 validation 데이터 분리
이미지 전처리 (정규화 포함, DATAGENERATOR, 원핫인코딩)
학습모델형성
학습진행
학습평가 (시각화)
01. 이미지 로드
지난 시간에 subplot의 대한 사용법을 복습하고, rows: labels, columns 각 이미지로 하여,
10 x 10의 이미지를 추출해보았다. 데이터 탐색의 목적으로, 데이터 확인이 목적이다.
ex) 비행기는 비행기네,, 트럭은 트럭이네,, 등등 < 실무에 이러한 작업이 필수적>
02. train과 validation 데이터 분리
이 과정은 추가적으로 진행하게 된 작업이다. 기본적으로 데이터가 주어지면 train set, validation set, test set으로 구분해야 한다.
목적은 "Overfitting"!! 즉, 내가 만든 모델이 내가 제공한 train set데이터에 너무 과적합되도록 학습되어버려서 이를 조금이라도 벗어난 케이스에 대해서 예측률이 낮아지는 현상이 발생한다. 그렇기 때문에 이러한 현상을 막기 위해서 데이터를 목적에 맞도록 구분한다.
train set : 모델이 훈련하는 데이터셋
validation set : train set 학습 중간에 모델 평가에 사용되는 데이터셋 (모델 성능에 영향 줌)
test set : 오로지 모델의 성능 평가를 위해 사용되는 데이터셋 (모델 성능에 영향 안 줌)
이번 주차에서는 train set을 train을 위한 데이터셋과 validation을 위한 데이터셋으로 나누어 볼 것이다. 아주 간단하다. 왜냐하면, ImageDataGenerator과 flow_from_directory에서 쉽게 할 수 있다.
[train set, validation set] = [0.8, 0.2]로 나누어 볼 것이다.
핵심은,ImageDataGenerator로 argumentation에서 "validation_split"을 지정한 후에 (내가 원하는, 이는 이미지 전처리와 같음) 각flow_from_directory시에 "subset"을 지정해주면 된다. 5만 장으로 구성되었던, train directory의 데이터를 학습에 4만 장, 1만 장으로 나누었다. Good!
03. 이미지 전처리
이미지 전처리에서는ImageDataGenerator로 argumentation를 통해데이터 학습을 위한1) 데이터 가공 (정규화)과2) 데이터 뻥튀기를 통해 많은 데이터를 모델이 학습할 수 있도록 하는 역할이 있다. 생각할수록 굉장히 유용한 클래스이다.. overfitting 방지
이를 통해 두 가지를 한 번에 하는 마법 같은 경험을 하였다
#개수작을 좋아하는 나는 사용할 수 있는 모든 argumentation을 최대한 활용하였다.
train_datagen = ImageDataGenerator(rescale=1./255,
rotation_range=15,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
width_shift_range=0.1,
height_shift_range=0.1,
validation_split=0.2)
rescale:정규화 위해
rotation_range = 0~15도 까지 회전하기
shear_range = 시계반대방향으로 밀림,0.2이라면, 0.2 라이안내외로
시계반대방향으로 변형
zoom_range = “1-수치”부터 “1+수치”사이 범위로 확대/축소,0.2이라면,
0.8배에서 1.2배 크기 변화를 시킴
horizontal_flip = 수평방향으로 뒤집기
width_shift_range, height_shift_range = 0.1 배율의 픽셀 만큼 이동
진짜 돌아가는 건지, 그러니깐 ImageDataGenerator가 구동되는지 궁금했다.
airplane의 하나를 해당 조건으로 25장의 이미지로 만들어 저장하여 불러보았다.
뭐,,, 확실히 이미지의 변화가 생긴 거 같긴 하다. ok!
import numpy as np
import os
import matplotlib.pyplot as plt
from keras.preprocessing.image import ImageDataGenerator,
array_to_img, img_to_array, load_img
train_datagen = ImageDataGenerator(rescale=1./255,
rotation_range=15,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
width_shift_range=0.1,
height_shift_range=0.1,
validation_split=0.2)
img = load_img('./CIFAR-10-images-master/train/airplane/0001.jpg')
plt.figure()
a = plt.imread(img)
plt.imshow(a)
plt.show()
x = img_to_array(img)
x = x.reshape((1,) + x.shape)
i = 0
for batch in train_datagen.flow(x, batch_size=20,
save_to_dir='./CIFAR-10-images-master/tmp_files', save_prefix='tmp',
save_format='jpg'):
i += 1
if i > 24:
break
image_dir = './CIFAR-10-images-master/tmp_files'
plt.figure(figsize=(5,5))
images = os.listdir('./CIFAR-10-images-master/tmp_files')
for i in range(5):
for j in range(5):
plt.subplot(5,5,i*5 +j + 1)
fn = image_dir+ '/' + images[i]
image = plt.imread(fn)
plt.grid(False)
plt.tight_layout()
plt.imshow(image)
plt.show()
04. 이미지 모델 생성 & 학습 진행 & 학습평가 (시각화)
여러 가지 모델에 대하여 생성하고, 학습하고 평가까지 한 번에 해보았다. 코드 스플릿이 필요하긴 할 듯,, 다음에..
기본적은 CNN이며 둘 차이는 layer 수와 optimizer를 두었다.
이전과 다른 것은 ImageDataGenerator로 데이터를 전처리 및 부풀렸기 때문에, model에 대하여 fit() 메서드를 사용하는 것이아니라, fit_generator() 메소드를 사용한다는 것! 중요!
Accuracy가 높아지지 않았지만, validation의 accuracy가 train의 accuracy보다 높다...(?)
왜지?? 이는, train set에서 과적합이 발생하지 않고, validation set에서 잘 맞추었다는 이야기로, 정확도는 낮지만 bias와 variance가 낮은 모델이라고 볼 수 있다.
여기서 과적합에 대한 내용을 잠시 담자면, 조금 찾아보니깐, →"validation set의 accuracy가 train set보다 낮다면, Regularization을 계산 반복해야 한다."
이 말을 이해하고자 다음 그림을 인용해보았다.
작성자는 이렇게 말한다."overfitting 그래프(3번째)를 보면, 데이터 분포에 비해서 loss함수가 복잡해지고, smooth 하지 않다. 즉, 새로운 데이터를 넣으면 제대로 예측하지 못할 가능성이 높다."
2번째의 그래프의 경우 데이터 분포와 조화가 잘되어 smooth 하다, 이러한 곡선이 적절한 모델일 가능성이 높다고 한다. 이는 변동성을 낮추어야 한다고 하는데,, 잘 이해는 되지 않는다 다만 앞서 말한 것처럼 변동성을 낮추기 위해서 "Regularization" 이 필요하다고 한다.
그럼 해보자!
옵티 아미저는 model1과 함께 가고, epoch 늘리고 layers는 model2를 따라가는데,
Regularization을 layer마다 추가해보자! 어떻게? 케라스에서 친절히 제공한다.
가장 기본적인 예제인 MNIST 데이터셋을 이용하여 손글씨 데이터를 분류 예측하는 모델 제작.
케라스에서 MNIST 데이터셋을 numpy배열 형태로 호출이 가능하다.
# 필요한 라이브러리 불러오기
from keras.datasets import mnist
from keras import models
from keras import layers
from keras.utils import to_categorical
# MNIST 데이터셋 불러오기
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
# 이미지 데이터 준비하기 (모델에 맞는 크기로 바꾸고 0과 1사이로 스케일링)
# 노말라이즈를 하는, 0~1의 이미지를 기준으로 한다. (왜그런지 보쟈)
train_images = train_images.reshape((60000, 28 * 28))
train_images = train_images.astype('float32') / 255
test_images = test_images.reshape((10000, 28 * 28))
test_images = test_images.astype('float32') / 255
02. 훈련, 테스트 데이터 설정
# 레이블을 범주형으로 인코딩
train_labels = to_categorical(train_labels) #범주형이라고하고, 원핫인코딩 필수적인 작업
#원핫 인코딩 왜하냐 알아보기.
test_labels = to_categorical(test_labels)
03. 모델 정의
# 모델 정의하기 (여기에서는 Sequential 클래스 사용)
model = models.Sequential()
model.add(layers.Dense(512, activation='relu', input_shape=(28 * 28,))) 512개의 perceptron
model.add(layers.Dense(10, activation='softmax'))
model.add(layers.Dense(len(train_labels[0]), activation='softmax'))
# 모델 컴파일 하기
model.compile(optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=['accuracy'])
04. 모델 훈련
# fit() 메서드로 모델 훈련 시키기
model.fit(train_images, train_labels, epochs=5, batch_size=128)
National Institute of Standards and Technology의 줄임말로, 미국 국립표준기술연구소의 손으로 쓴 글자 데이터셋에서 숫자만 따로 뽑아낸 데이터 셋.
0~255사이의 값을 가지는 흑백 이미지이며 28x28(784) 사이즈를 지니며 7만 개의 이미지(6만 개 트레이닝 셋, 1만 개 테스트 셋)으로 구성되어있다.
02. MNIST 데이터 셋 살펴보기
# 필요한 라이브러리 불러오기
from keras.datasets import mnist
from keras import models
from keras import layers
from keras.utils import to_categorical
# MNIST 데이터셋 불러오기
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
------------------------------------------------------------------------------
test_image : shape : (10000,28,28) 28x28 이미지 10000장
test_label : shape : 10000 10000장 이미지 대한 0~9까지의 라벨
train_image : shape : (60000,28,28) 28x28 이미지 60000장
train_label : shape : 60000 60000장 이미지 대한 0~9까지의 라벨
* 각 한장에 28x28 배열이며 각 배열의 값들은 0~255의 값을 가지고 이미지로 보았을때
0~9까지의 형상을 가진다
03. MNIST 데이터 셋 PLOT 해보기
import matplotlib.pyplot as plt
#train image의 5번째 이미지 추출
image = train_images[4] #reshape전의 이미지
#plot the sample
fig = plt.figure
plt.imshow(image, cmap='gray')
plt.show()
print("train_image 4번째 라벨은", train_labels[4])
#실행결과 Console: train_image 4번째 라벨은 9
04. 모델구조 파악하기
모델을 정의하는 방법은 두 가지로, Sequential 클래스와 함수형 API를 사용한다.
1) Sequential 클래스 : 가장 자주 사용하는 구조로, 층을 순서대로 쌓아 올린 네트워크
2) 함수형 API : 완전히 임의의 구조를 만들 수 있는 비순환 유향 그래프(DAG) 만듬 ( 공부가 필요)
해당 코드에서는, Sequential 클래스 형태로 모델화하였다.
모델은 2개의 Dense 층으로 되어있고, 각각 "relu", "softmax"의 활성함수를 가진다.
마지막 층은 10개의 확률 점수가 들어 있는 배열을 반환하는 소프트맥스층이며, 각 점수는 현재 숫자 이미지가 10개의 숫자 클래스 중 하나에 속할 확률을 나타낸다(?)
#model.summary() 통해 전체적인 구조
Model: "sequential"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
dense (Dense) (None, 512) 401920
_________________________________________________________________
dense_1 (Dense) (None, 10) 5130
=================================================================
Total params: 407,050
Trainable params: 407,050
Non-trainable params: 0
_________________________________________________________________
05. 결과 파악하기
학습된 모델이 Test 모델을 판별할때, 98.34%로 MNIST의 숫자를 맞춘다는 의미이다.
즉, 테스트 데이터 10000개 중에서 200장 가량 틀렸다는 것으로 볼 수 있다.
Test loss: 0.08414454758167267
Test accuracy: 0.9817000031471252
예측 라벨과 실제 테스트라벨이 다른 결과들 16개를 랜덤하게 선정하여 보았을때, 실제로 사람이 보아도 판별하기 쉽이낳는 것들이 있는 것을 확인 할 수 있다.
04. 전체코드
01. 학습하기
# 필요한 라이브러리 불러오기
from keras.datasets import mnist
from keras import models
from keras import layers
from keras.utils import to_categorical
import matplotlib.pyplot as plt
from keras.utils import plot_model
# MNIST 데이터셋 불러오기
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
# 이미지 데이터 준비하기 (모델에 맞는 크기로 바꾸고 0과 1사이로 스케일링)
train_images = train_images.reshape((60000, 28 * 28))
train_images = train_images.astype('float32') / 255
test_images = test_images.reshape((10000, 28 * 28))
test_images = test_images.astype('float32') / 255
# 레이블을 범주형으로 인코딩
train_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)
# 모델 정의하기 (여기에서는 Sequential 클래스 사용)
model = models.Sequential()
model.add(layers.Dense(512, activation='relu', input_shape=(28 * 28,)))
model.add(layers.Dense(10, activation='softmax'))
model.summary()
# 구 조확인
from IPython.display import SVG
from keras.utils import model_to_dot
# SVG(model_to_dot(model, show_shapes=True).create(prog='dot',format='svg'))
# 모델 컴파일 하기
model.compile(optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=['accuracy'])
# fit() 메서드로 모델 훈련 시키기
history=model.fit(train_images, train_labels,epochs=10, batch_size=64, verbose=1)
# batch size가 높을수록, 속도빠르고, 정화도가 낮아.
# 테스트 데이터로 정확도 측정하기
test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=0)
print('Test loss:', test_loss)
print('Test accuracy:', test_acc)
# 학습 정확성 값과 검증 정확성 값을 플롯팅 합니다.
#결과파악.
import random
import numpy as np
predicted_result = model.predict(test_images)
predicted_labels = np.argmax(predicted_result, axis=1)
test_label = np.argmax(test_labels, axis=1)
wrong_result = []
for n in range(0, len(test_label)):
if predicted_labels[n] != test_label[n]:
wrong_result.append(n)
samples = random.choices(population=wrong_result, k=16)
count = 0
nrows = ncols = 4
plt.figure(figsize=(12,8))
for n in samples:
count += 1
plt.subplot(nrows, ncols, count)
plt.imshow(test_images[n].reshape(28, 28), cmap='Greys', interpolation='nearest')
tmp = "Label:" + str(test_label[n]) + ", Prediction:" + str(predicted_labels[n])
plt.title(tmp)
plt.tight_layout()
plt.show()
02. 결과보기
from keras.datasets import mnist
# MNIST 데이터셋 불러오기
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
import matplotlib.pyplot as plt
#train image의 4번째 이미지 추출
image = train_images[4]
#plot the sample
fig = plt.figure
plt.imshow(image, cmap='gray')
plt.show()
print("train_image 4번째 라벨은", train_labels[4])
num = 10
images = train_images[:num]
labels = train_labels[:num]
num_row = 2
num_col = 5
#plot images
fig, axes = plt.subplots(num_row, num_col, figsize=(1.5*num_col, 2*num_row))
for i in range(num):
ax = axes[i//num_col, i%num_col]
print(i//num_col, i%num_col)
ax.imshow(images[i], cmap='gray')
ax.set_title('Label: {}'.format(labels[i]))
plt.tight_layout()
plt.show()