[Kaggle]Super Image Resolution_고화질 이미지 만들기

220207 작성

<본 블로그는 Kaggle 을 참고해서 공부하며 작성하였습니다>

https://www.kaggle.com/theblackmamba31/low-resolution-images-to-high-resolution

Low resolution images to high resolution

http://dmqm.korea.ac.kr/activity/seminar/318

고려대학교 DMQA 연구실

 

 

 

 

 

 

 

1. Image super resolution

: 저화질의 이미지를 고화질로 바꾸어주는 것

: Image Super-Resolution 은 저해상도 이미지를 고해상도로 변환시키는 문제를 해결

: 미디어, 의료, 보안 등 다양한 산업 분야에서 중요한 문제로 대두

• 해상도를 높여주는 Super Resolution

- SR = Super-Resolution (초고해상도)

: 모델로 생성된 image 의미

 

- HR = High-Resolution (고해상도)

: Output Image 의미

 

- LR = Low-Resolution (저해상도)

: Input Image

 

• 해상도(resolution)란

: 디지털 화면을 구성하는 각각의 면 안에 얼마나 많은 수의 픽셀(pixel)을 담았는가

: 픽셀은 디지털 이미지를 이루는 가장 작은 원소

: 해상도가 높을 수록 픽셀의 수가 증가

 

 

 

 

 

 

2. Image Super Resolution 딥러닝 모델 개발

: 낮은 품질의 이미지를 높은 품질의 이미지로 변환하도록 모델을 훈련시키는 데이터 세트

 

 

1)  CNN_딥러닝을 통한 이미지 향상

•  Conv 연산

: 데이터에서 특징만이 남고 차원이 줄어드는데, 만일 패딩을 붙여서 차원 축소를 막는다고 하더라도,

pooling을 통해 대표적 특징을 추출하는 것

• Downsampling : 차원이 축소되어 Dense한 데이터를 만드는 것

• Upsampling : 이것을 다시 해독해서 원본의 sparse한 데이터를 만드는 것

=> CNN으로 데이터가 축약되고, upsampling 을 통하여 차원이 늘어나며, 

모델이 이 sampling 데이터를 가지고, 가장 확률이 높은 데이터를 추론해내도록, 필터들을 학습

 

 

 

 

 

2) CNN

1. HR 이미지를 수집
2. Downsampling 필터를 적용하여 LR 이미지를 얻기
3. CNN은 HR 이미지의 손실된 세부 정보를 복원하기 위해 Downsampling 필터의 역함수 Upsampling 로 학습

 

 

+) 저해상도인 Input 이미지를 고화질 이미지 크기에 맞춰야 함

+) 크기를 맞춘 뒤, 빈 영역에 대한 값을 어떻게 채울 것인가에 대한 고민 필요

 

 

• 1) Interpolation-based upsampling
  • Nearest-neighbor : 인접 픽셀값
  • Bilnear : 인접 4개 픽셀 값의 liner interpolation, 빈 영역에 대해 거리 가중치를 둔 평균값으로 채움

• 

   
  • Bicubic : 인접 16개 픽셀 값의 cubic interpolation
• 2) Learning-based upsampling
  • Transpose Convolution Layer : 저해상도 이미지 확장 후 (확장한 영역에 zero padding 진행) conv 연산

• 

   
  • Sub-pixel Convolution Layer : conv 연산 후 pixel 별로 모음

 

 

 

 

 

3. CNN 기반 딥러닝 모델

• 라이브러리 Import

import numpy as np
import tensorflow as tf
import keras
import cv2
from keras.models import Sequential
from keras.preprocessing.image import img_to_array
import os
from tqdm import tqdm   # dataloader 을 통해 data를 download 할 때, 상태바 넣어두기 (상태 진행 보여주기)
import re
import matplotlib.pyplot as plt

from keras import layers

 

• load Data

def sorted_alphanumeric(data):
    # isdigit() : 문자열이 숫자로 구성되어 있는지 판별
    convert = lambda text : int(text) if text.isdigit() else text.lower()
    alphanum_key = lambda key : [convert(c) for c in re.split('([0-9]+)', key)]
    return sorted(data, key = alphanum_key)

SIZE = 256
high_img = []
path = 'dataset/Raw Data/high_res'
files = os.listdir(path)
files = sorted_alphanumeric(files)


for i in tqdm(files) :
    if i == '855.jpg' :
        break
    else :
        img = cv2.imread(path + '/' + i, 1)
        # open bgr to rgb
        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
        # resize
        img = cv2.resize(img, (SIZE, SIZE))
        img = img.astype('float') / 255.0
        high_img.append(img_to_array(img))

    
    low_img = []
    path = "dataset/Raw Data/low_res"
    files = os.listdir(path)
    files = sorted_alphanumeric(files)

for i in tqdm(files) :
    if i == "855.jpg" :
        break
    else :
        img = cv2.imread(path + '/' + i, 1)
        # resize
        img = cv2.resize(img, (SIZE, SIZE))
        img = img.astype("float32") / 255.0
        low_img.append(img_to_array(img))

 

 

• Data 시각화

for i in range(4) :
    a = np.random.randint(0, 855)
    plt.figure(figsize=(10, 10,))

    plt.subplot(1,2,1)
    plt.title("High Resolution", color = "pink", fontsize = 20)
    plt.imshow(high_img[a])
    plt.axis('off')
    
    plt.subplot(1,2,2)
    plt.title("Low Resolution", color = "black", fontsize = 20)
    plt.imshow(low_img[a])
    plt.axis("off")

흠 원래 둘다 화질이 별로인가,, 색깔 빼고

 

 

• slicing & reshaping images

train_high_image = high_img[:700]
train_low_image = low_img[:700]

train_high_image = np.reshape(train_high_image,(len(train_high_image),SIZE,SIZE,3))
train_low_image = np.reshape(train_low_image,(len(train_low_image),SIZE,SIZE,3))

print(train_high_image.shape)
print(train_low_image.shape)

validation_high_image = high_img[700:830]
validation_low_image = low_img[700:830]

validation_high_image= np.reshape(validation_high_image,(len(validation_high_image),SIZE,SIZE,3))
validation_low_image = np.reshape(validation_low_image,(len(validation_low_image),SIZE,SIZE,3))

print(validation_high_image.shape)
print(validation_low_image.shape)

test_high_image = high_img[830:]
test_low_image = low_img[830:]
test_high_image= np.reshape(test_high_image,(len(test_high_image),SIZE,SIZE,3))
test_low_image = np.reshape(test_low_image,(len(test_low_image),SIZE,SIZE,3))

print(test_high_image.shape)
print(test_low_image.shape)

print("Shape of training images:",train_high_image.shape)
print("Shape of test images:",test_high_image.shape)
print("Shape of validation images:",validation_high_image.shape)

 

 

 

• Model

def down(filters , kernel_size, apply_batch_normalization = True):
    downsample = tf.keras.models.Sequential()
    downsample.add(layers.Conv2D(filters,kernel_size,padding = 'same', strides = 2))
    
    if apply_batch_normalization:
        downsample.add(layers.BatchNormalization())
    downsample.add(keras.layers.LeakyReLU())
    return downsample

• batch_normalization : 각 레이어마다 정규화 하는 레이어를 두어, 변형된 분포가 나오지 않도록 조절
• LeakyReLU : 입력 값이 음수일 때 완만한 선형 활성화 함수

def up(filters, kernel_size, dropout = False):
    upsample = tf.keras.models.Sequential()
    upsample.add(layers.Conv2DTranspose(filters, kernel_size,padding = 'same', strides = 2))
    if dropout:
        upsample.dropout(0.2)
    upsample.add(keras.layers.LeakyReLU())
    return upsample

• Interpolation : 인접 픽셀 값을 활용해서 빈 영역을 채우는 방법
• dropout : 과대적합이 발생하기 쉬운 심층 신경망 구조에서 이를 방지할 수 있는 정규화 기법의 하나

def model():
    inputs = layers.Input(shape= [SIZE,SIZE,3])
    d1 = down(128,(3,3),False)(inputs)
    d2 = down(128,(3,3),False)(d1)
    d3 = down(256,(3,3),True)(d2)
    d4 = down(512,(3,3),True)(d3)
    
    d5 = down(512,(3,3),True)(d4)
    #upsampling
    u1 = up(512,(3,3),False)(d5)
    u1 = layers.concatenate([u1,d4])
    u2 = up(256,(3,3),False)(u1)
    u2 = layers.concatenate([u2,d3])
    u3 = up(128,(3,3),False)(u2)
    u3 = layers.concatenate([u3,d2])
    u4 = up(128,(3,3),False)(u3)
    u4 = layers.concatenate([u4,d1])
    u5 = up(3,(3,3),False)(u4)
    u5 = layers.concatenate([u5,inputs])
    
    output = layers.Conv2D(3,(2,2),strides = 1, padding = 'same')(u5)
    return tf.keras.Model(inputs=inputs, outputs=output)

model = model()
model.summary()

 

 

 

• compile

model.compile(optimizer= tf.keras.optimizers.Adam(learning_rate= 0.001),
    loss = "mean_absolute_error",
    metrics = ['acc'])

 

 

 

• fit model

model.fit(train_low_image, train_high_image, epochs=7,  batch_size= 1,
    validation_data = (validation_low_image, validation_high_image))

 

 

• 예측한거 시각화

def plot_images(high,low,predicted):
    plt.figure(figsize=(15,15))

    plt.subplot(1,3,1)
    plt.title('High Image', color = 'pink', fontsize = 20)
    plt.imshow(high)

    plt.subplot(1,3,2)
    plt.title('Low Image ', color = 'orange', fontsize = 20)
    plt.imshow(low)

    plt.subplot(1,3,3)
    plt.title('Predicted Image ', color = 'green', fontsize = 20)
    plt.imshow(predicted)
   
    plt.show()

for i in range(1,10):
    
    predicted = np.clip(model.predict(test_low_image[i].reshape(1,SIZE, SIZE,3)),0.0,1.0).reshape(SIZE, SIZE,3)
    plot_images(test_high_image[i],test_low_image[i],predicted)

 

 

 

 

 

+) 파라미터 바꿔서 진행해봄

# 1. 
Optimizers : Adam
Learning rate : 0.001
Loss : mean_absolute_error
epochs = 10
batch_size = 2
-----------------------------------
Loss : 0.0172 
Acc : 0.8596
val_loss : 0.0179
val_acc : 0.8716
Test_loss : 0.018
Test_acc : 0.9121

# 2.

Optimizers : Adam

Learning rate : 0.01

Loss : mean_absolute_error

epochs = 15

batch_size = 20

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

Loss : 0.0248 

Acc : 0.8551

val_loss : 0.0222

val_acc : 0.9167

Test_loss : 0.0213

Test_acc : 0.9220

# 1과 2 파라미터 비교

처음 모델꺼!
loss: 0.0053 - acc: 0.8702 - val_loss: 0.0060 - val_acc: 0.8673

 

 

 

 

 

cnn 말고
ㄷㅏ른걸로도
도전해보장