[CV 2] Image Augmentation

🌀 Image Augmentation

이미지 증강 : 회전, 반전, 자르기, 밝기 혹은 채도 변화 등을 통해 데이터를 늘리는 방법

대부분 정면 데이터를 학습하기 때문에, 판단해야하는 물체가 기울어져 있거나 뒤집어진 이미지를 잘 예측하지 못한다는 취약점을 가지고 있다. 따라서, 일반화가 잘 되는 모델을 만들기 위해 학습 데이터셋에 있는 이미지를 일부러 회전하거나 기울여서 나타내는 방법을 이미지 데이터 증강이라고 한다. 이를 통해 더욱 강건(Robust)한 모델을 만들 수 있다.

과대적합은 일반적으로 훈련 데이터셋이 적을 때 발생한다. 데이터 증강을 통해 모델이 데이터의 더 많은 측면을 파악하게 되므로 일반화가 더 쉽다!!!!!

 

 

tf_flowers 데이터셋 사용하기

import tensorflow_datasets as tfds 

(train_ds, val_ds, test_ds), metadata = tfds.load('tf_flowers', split=['train[:80%]', 'train[80%:90%]', 'train[90%:]'],
																							with_info=True, as_supervised=True)

# train_ds에서 가져온 이미지, 레이블 시각
get_label_name = metadata.features['label'].int2str # label을 숫자에서 문자로 변환

image, label = next(iter(train_ds))
_ = plt.imshow(image)
_ = plt.title(get_label_name(label))

 

 

 

 

크기 및 배율 조정하기

IMG_SIZE = 180

resized_and_rescale = tf.keras.Sequential([
		layers.experimental.preprocessing.Resizing(IMG_SIZE, IMG_SIZE), # 크기 조정
		layers.experimental.preprocessing.Rescaling(1./255)]) # 픽셀값 배율 조정 : [0,1]로 표준화

cf) 픽셀값을 [-1,1]로 표준화를 원할 경우, Rescaling(1./127.5, offset=-1)

이러한 layer적용한 이미지 적용 결과보기

result = resized_and_rescale(image)

print(result.numpy().min(), result.numpy().max())
>> 0.0 1.0 # 픽셀 0~1 확인
_ = plt.imshow(result)

180크기로 이미지크기 조정된 것 확인 가능.

 

 

 

 

 

 

데이터 증강

전처리 레이어

data_augmentation = tf.keres.Sequential([
				layers.experimental.preprocessing.RandomFlip('horizontal_and_vertical'),
				layers.experimental.preprocessing.RandomRotation(0.2)])
# flip : 좌우반전 or 상하 반전
# 0.2강도로 무작위로 회전

# 이미지에 배치 차원 추가
image = tf.expand_dims(image, 0)  

tensorflow모델은 기본적으로 batch단위로 입력 데이터를 처리한다. 따라서 모델에 여러 이미지를 한 번에 처리하려면, 이미지를 배치 형태로 변환해야한다. tf.expand_dims를 사용해 이미지에 배치 차원을 추가하면, 한 번에 여러 이미지를 처리할 수 있는 형태가 된다. 위의 코드는 0으로 첫번째 차원이 추가 된다는 것이다.(높이, 너비, 채널) → (batch_size, 높이, 너비, 채널)

배치 차원 : 여러 데이터를 한 번에 처리하기 위한 차원으로 사용되며, 일반적으로 배치 크기를 나타낸다.

데이터 증강 전처리 레이어 사용한 이미지 시각화

plt.figure(figsize=(10,10))
for i in range(9):
	augmented_image = data_augmentation(image)
	ax = plt.subplot(3,3, i+1)
	plt.imshow(augmented_image[0])  # 데이터 증강과정에서 랜덤성 적용돼 매 반복마다 다른 결과
	plt.axis('off')

첫번째 원본 이미지와, 수평,수직으로 뒤집고, 회전한 이미지들의 결과

 

 

 

 

 

 

 

전처리 레이어를 사용하는 두 가지 옵션

참고) 데이터 증강은 훈련 세트에만 적용!!!!!!!!!

1. 전처리 레이어를 모델의 일부로 만들기

model = tf.keras.Sequential([
		resize_and_rescale,
		data_augmentation,
		layers.Conv2D(16,3, padding='same', activation='relu',
		layers.MaxPooling2D()])

유의사항

• 데이터 증강은 나머지 레이어와 동기적으로 기기에서 실행되며 GPU 가속 이용
• model.save를 사용해 모델을 내보낼 때 전처리 레이어가 모델의 나머지 부분과 함께 저장됨. 나중에 이 모델 배포 시, 레이어 구성에 따라 이미지가 자동으로 표준화되어 다시 구현해야되는 노력을 덜 수 있다.
• 데이터 증강은 테스트할 때는 비활성화 (model.evalute, predict시 x) (model.fit할때만 데이터 증강됨.)

1. 데이터세트에 전처리 레이어 적용하기

aug_ds = train_ds.map(lambda x,y : (resize_and_rescale(x, training=True), y))

유의사항

• 데이터 증강은 CPU에서 비동기적으로 이루어지며 차단되지 않는다. 아래와 같이 Dataset.prefetch를 사용해 GPU에서 모델 훈련을 데이터 전처리와 중첩시킬 수 있다.
• 전처리 레이어는 model.save를 호출할 때 모델과 함께 내보내지지 않는다. 저장하기 전에 이 레이어를 연결하거나, 서버측에서 다시 구현해야됨. 훈련 후, 내보내기 전에 전처리 레이어 연결 가능

 

 

이 두번째 방법인, 데이터세트에 전처리 레이어를 적용하는 방법을 해보자. 또한 병렬 읽기 및 버퍼링된 프리페치를 사용해 I/O 차단 없이 디스크에서 배치를 생성해 성능을 높이도록 데이트셋을 구성해보자.

일반적으로 데이터셋의 성능은 데이터를 로드하고 전처리하는 과정에서 발생하는 I/O 작업, CPU/GPU 작업에 의해 제한된다.

• AUTOTUNE : 데이터셋 처리하는 동안 CPU 및 GPU 자원을 최대한 동시에 활용해 처리 속도 향상
• 버퍼 크기 : 데이터셋을 처리할 때 메모리에 로드하는 데이터의 양이다. 데이터셋은 일반적으로 한 번에 모든 데이터를 메모리에 로드하지 않고, 일부 데이터를 미리 로드하고 처리한다. 버퍼 크기가 크면 한 번에 더 많은 데이터가 로드될 것이며, 작으면 로드되는 데 데이터 양이 줄어들겠지.

batch_size = 32
AUTOTUNE = tf.data.experimental.AUTOTUNE # 데이터셋 성능향상

def prepare(ds, shuffle=False, augment=False):
	# 이미지 크기 조절, 픽셀값 정규화
	ds = ds.map(lambda x, y: (resize_and_recale(x), y), num_parallel_calls=AUTOTUNE)

	if shuffle:
		ds = ds.shuffle(1000)

	# 데이터셋을 배치로 나누어 준비 (batch_size:한번에 처리되는 데이터 개수)
	ds = ds.batch(batch_size)

	# 훈련데이터셋에만 데이터 증강 적용
	if augment:
		ds = ds.map(lambda x,y : (data_augmentation(x, training=True),y), num_parallel_calls=AUTOTUNE)
		# training=True : 데이터 증강이 훈련 모드에서 수행됨.
	return ds.prefetch(buffer_size=AUTOTUNE)
	# prefetch : 처리된 데이터셋을 반환하기 전에, 데이터셋을 미리 로드하여 처리 속도 향상시키기 위해 버퍼링 적용
	# buffer_size=AUTOTUNE : 적절한 버퍼 크기를 자동으로 설정

train_ds = prepare(train_ds, shuffle=True, augment=True)
val_ds = prepare(val_ds)
test_ds = prepare(test_ds)

이러한 데이터셋을 사용해 모델 훈련 (정확도를 높이기 위한 것이 아니라, 그냥 흐름 전체를 알 수 있게 짰다.)

model = tf.keras.Sequential([
	layers.Conv2D(16,3, padding='same', activation='relu'),
	layers.MaxPooling2D(),
	layers.Conv2D(32,3, padding='same', activation='relu'),
	layers.MaxPooling2D(),
	layers.Conv2D(64,3, padding='same', activaiton='relu'),
	layers.MaxPooling2D(),
	layers.Flatten(),
	layers.Dense(128. acitvation='relu')
	layers.Dense(num_classes)])

model.compile(optimizer='adam', 
							loss=tf.keras.SparseCategoricalCrossEntropy(from_logits=True),
							metrics=['accuracy'])
# from_logits=True : softmax함수 적용 전의 로짓 값을 사용해 손실 계산한다. 
# 이는 손실 함수 내부에서 softmax 적용과정을 생략하여 계산 효율성을 높인다.

history = model.fit(train_ds, validation_data=val_ds, epochs=5)
loss, acc = model.evaluate(test_ds)

 

 

 

 

 

 

사용자 정의 데이터 증강

1. layers.Lambda 레이어 이용

원래 쓰던 lambda 함수를 층에 적용시킨 것이다.

# 무작위로 반전 효과 적용하는 함수를 적용시키자.

def random_invert_img(x, p=0.5):
	if tf.random.uniform([])<p: # p: 반전확률
		x = (255-x)
	else: x
	return x

def random_invert(factor=0.5):
	return layers.Lambda(lambda x: random_invert_img(x, factor))

random_invert = random_invert()

plt.figure(figsize=(10,10))
for i in range(9):
	augemented_image = random_invert(image)
	ax = plt.subplot(3,3, i+1)
	plt.imshow(augmented_image[0].numpy().astype('uint8')) 
	# tensor형태로 저장되어있어 numpy array로 변환후, 픽셀값의 데이터타입을 8비트 부호없는 정수로 변환
	plt.axis('off')

확률에 따라 이미지의 색상 무작위로 반전된 것 확인 가능

 

 

1. 서브 클래스 생성 이용

class RandomInvert(layers.Layer):
	def __init__(self, factor=0.5, **kwargs):
		super().__init__(**kwargs)
		self.factor = factor

	def call(self, x):
	return random_invert_img(x)

 

 

 

 

 

 

 

 

 

tf.image 사용하기

위의 layers.preprocessing 유틸리티는 편리하다. 보다 세밀한 제어를 위해서는 tf.data 및 tf.image를 사용해 데이터 증강 파이프라인 또는 레이어를 작성할 수 있다.

# 이미지 뒤집기 (수직 또는 수평으로)
tf.image.flip_left_right(image)

# 이미지 회색조로 만들기
tf.image.rgb_to_grayscale(image)

# 채도 계수를 주어 이미지 포화시킴.(색상 강조해 더 선명하게 표현)
tf.image.adjust_saturation(image, 3)

# 이미지 밝기 변경
tf.image.adjust_brightness(image, 0.4)

# 이미지 중앙 자르기
tf.image.central_crop(image, central_fraction=0.5)

# 이미지 회전하기
tf.image.rot90(image)

이러한 방법들이 있다.

최종적으로 정리

def resize_and_rescale(image, label):
	image = tf.cast(image, tf.float32) # 데이터 타입 변환
	image = tf.image.resize(image, [IMG_SIZE, IMG_SIZE])
	image = (image/255.0)
	return image, label

def augment(image, label):
	image, label = resize_and_rescale(image, label)
	image = tf.image.resize_with_crop_or_pad(image, IMG_SIZE+6, IMG_SIZE+6)
	image = tf.image.random_crop(image, size=[IMG_SIZE, IMG_SIZE,3])
	image = tf.image.random_brightness(image, max_delta=0.5)
	image = tf.clip_by_value(image,0,1)
	return image, label

train_ds = (train_ds.shuffle(1000).map(augment, num_parallel_calls=AUTOTUNE).batch(batch_size).prefetch(AUTOTUNE))
# val_ds, test_ds도 똑같이 하여 모델 훈

TensorFlow 애드온 이미지: 작업 및 TensorFlow I/O: 색 공간 변환

tf.data API로 성능 향상하기 (데이터세트 성능 관련)