CNN

CNN(Convolutional Neural Network)은 딥러닝의 한 종류로서, 주로 이미지 분류, 객체 인식, 얼굴 인식 등의 컴퓨터 비전 분야에서 많이 사용.

CNN은 이미지의 특징을 추출하기 위한 필터와 그 필터로 추출한 특징을 바탕으로 분류하는 분류기로 구성

CNN의 원리는 크게 두 가지

첫째, Convolutional Layer에서 필터(filter)를 이용해 이미지의 특징을 추출하고

둘째, Fully Connected Layer에서 추출된 특징을 바탕으로 이미지를 분류합니다.

 

Convolutional Layer에서는 필터를 사용하여 이미지의 특징을 추출

필터는 이미지를 훑어가며, 특정한 패턴을 찾아냄

예를 들어, 개를 분류하기 위한 필터는 강아지의 귀, 눈, 코 등의 특징을 찾아내는 역할.

이때 필터는 학습을 통해 최적화되며, 이 과정에서 필터의 가중치(weight)가 결정

Convolutional Layer에서 추출된 특징 맵(feature map)은 Max Pooling Layer를 거쳐 축소

Max Pooling Layer는 특징 맵의 크기를 줄이면서 특징을 보존하는 역할

Fully Connected Layer에서는 Convolutional Layer에서 추출된 특징을 바탕으로 이미지를 분류

이때 분류기는 추출된 특징을 입력으로 받아서, 이미 학습된 가중치를 사용하여 이미지를 분류

따라서, CNN은 이미지의 특징을 추출하기 위해 Convolutional Layer를 사용하고, 추출된 특징을 바탕으로 이미지를 분류하기 위해 Fully Connected Layer를 사용하는 구조

이 과정에서 필터의 학습과 가중치의 최적화가 이루어지는데, 이것이 CNN의 핵심 원리.

 

<전처리>

1. 데이터 불러오기: CNN 모델링을 위해 먼저 데이터를 불러와야 합니다. 데이터는 보통 이미지 형태로 주어지며, 각 이미지의 레이블도 함께 필요

from keras.datasets import mnist

# Min-Max 스케일링
# sklearn의 minmaxscaler는 2차원 배열만 가능 이미지 데이터는 4차원

max_v, min_v = x_train.max(), x_train.min()

x_train = (x_train - min_v) / (max_v - min_v)
x_test = (x_test - min_v) / (max_v - min_v)

x_train.max(), x_train.min()

# 표준화 스케일링
mean_v, std_v = train_x.mean(), train_x.std()

train_x = (train_x - mean_v) / std_v
test_x = (test_x - mean_v) / std_v

train_x.mean(), train_x.std()

2. 이미지 리사이징: 이미지의 크기를 일정하게 맞춰주는 것이 좋습니다. 이는 모델이 학습하는 데에 필요한 계산을 줄여줄 뿐만 아니라, 이미지의 특징을 더 잘 잡아낼 수 있도록 도와줌.

3. 이미지 정규화: 이미지의 각 픽셀 값이 0에서 255 사이의 값으로 주어지므로, 이를 일반적으로 0에서 1 사이의 값으로 정규화. 이를 통해 모델이 학습하는 데에 필요한 계산을 줄여줌

(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

(x_train, y_train), (x_test, y_test) = keras.datasets.fashion_mnist.load_data()

# Mnist data
labels = ["T-shirt/top",  # index 0
            "Trouser",      # index 1
            "Pullover",     # index 2 
            "Dress",        # index 3 
            "Coat",         # index 4
            "Sandal",       # index 5
            "Shirt",        # index 6 
            "Sneaker",      # index 7 
            "Bag",          # index 8 
            "Ankle boot"]   # index 9

4. 데이터 증강: 이미지 데이터셋이 작은 경우, 데이터를 증강하여 모델이 더 다양한 상황에서도 잘 동작하도록 만들어줄 수 있다. 이를 위해 Keras의 ImageDataGenerator를 사용하여 이미지 데이터셋을 다양하게 변형할 수 있음.

5. 데이터 분할: 전체 데이터셋을 학습, 검증, 테스트 데이터셋으로 나누어야 합니다. 일반적으로 학습 데이터셋이 가장 많고, 검증 데이터셋은 하이퍼파라미터 튜닝 등에 사용하며, 테스트 데이터셋은 최종 모델의 성능을 평가하는 데 사용.

# one-hot Encoding
class_n = len(np.unique(y_train)) #중복되지 않는 요소들을 찾기
class_n  #타겟레이블을 범주형 데이터로 표현해야함
#범주형 변수를 이진수로 표현하여 모델이 이해하기 쉽게 만듬. 
# 이때, 각 카테고리(범주)는 하나의 이진수로 변환되기 때문에, 변환된 배열의 각 열(column)은 하나의 범주를 나타냄.
# 따라서, One-Hot Encoding을 적용한 배열의 열 개수는 해당 변수에 존재하는 고유한 범주의 수와 같습니다.
from keras.utils import to_categorical  #입력된 정수형 레이블을 one-hot-encoding으로 변환
y_train = to_categorical(y_train, class_n)
y_test = to_categorical(y_test, class_n)
x_train.shape, y_train.shape

6. One-hot Encoding: 레이블을 모델이 이해하기 쉬운 형태로 바꾸어 준다. 예를 들어, 0~9까지의 숫자를 분류하는 문제의 경우, 레이블을 0부터 9까지의 숫자를 나타내는 One-hot Encoding으로 변환 ⇒ 결국 y의 전처리

 

CNN에서 One-Hot Encoding을 주로 사용하는 경우는 분류 문제(classification task)에서 타겟 레이블(target label)을 범주형 데이터로 표현해야 하는 경우

예를 들어, 10개의 클래스를 가지는 MNIST 숫자 이미지 데이터셋을 분류하는 경우, 각 이미지는 0부터 9까지의 정수 레이블을 가지고 있습니다. 하지만, 이 레이블은 숫자 형태로 되어 있기 때문에 분류 모델이 이해하기 어려움

따라서, 각 레이블을 One-Hot Encoding으로 변환하여 범주형 데이터로 표현.

 

# 만약 데이터 shape이 (60000,28,28) 형태의 3차원이라면 reshape
x_train = x_train.reshape( (-1, 28, 28, 1) )  #cnn모델의 입력데이터는 4차원이여야 한다.
x_test = x_test.reshape((-1, 28, 28, 1))

7. 데이터 형태 변환: CNN 모델의 입력 데이터는 4차원 텐서 형태여야 합니다. 따라서 이미지 데이터셋의 형태를 (이미지 수, 이미지 너비, 이미지 높이, 채널 수)로 바꿔주어야 함. 채널 수는 일반적으로 흑백 이미지의 경우 1, 컬러 이미지의 경우 3이다.

 

<cnn 모델링>

# Mnist데이터로 모델링
from tensorflow import keras
from keras.models import Sequential
from keras.layers import Dense, Conv2D, MaxPool2D, Flatten, BatchNormalization, Dropout
from keras.optimizers import Adam
from tensorflow.keras.backend import clear_session

# CNN 모델 구성
clear_session()


model = Sequential([Conv2D(32,kernel_size=(3,3),padding='same',activation='relu',input_shape=(28,28,1)),
                    BatchNormalization(),
                    Conv2D(32,kernel_size=(3,3),padding='same',activation='relu'),
                    BatchNormalization(),
                    MaxPool2D(pool_size=(2,2),strides=(2,2)),
                    Dropout(0.25),
                    Conv2D(64,kernel_size=(3,3),padding='same',activation='relu'),
                    BatchNormalization(),
                    Conv2D(64,kernel_size=(3,3),padding='same',activation='relu'),
                    BatchNormalization(),
                    MaxPool2D(pool_size=(2,2),strides=(2,2)),
                    Dropout(0.25),
                    Flatten(),
                    Dense(512, activation='relu'),
                    Dense(10, activation='softmax')
                    ])

# 모델 컴파일
model.compile(optimizer=Adam(learning_rate=0.0001), loss='categorical_crossentropy',metrics=['accuracy'] )
model.summary()

위 코드에서 Sequential()은 Keras에서 모델을 만들 때 사용되는 함수. 이 함수를 이용하여 모델 객체를 생성.

Conv2D() 함수는 Convolutional Layer를 추가하는 함수입니다. 32는 필터(filter)의 개수, kernel_size는 필터의 크기 필터의 가로 세로 사이즈

activation은 활성화 함수로서 ReLU 함수를 사용

padding은 정보의 손실을 막기위해 감싸는 것.

1. 이전 feature map의 사이즈를 동일하게 유지하려고
2. 외곽의 정보를 좀 더 반영하려고.

Input_shape는 입력 이미지의 크기와 채널 수를 의미합니다. (x_train.shape)

(이미지수, 이미지너비, 이미지 높이, 채널 수)

strides: 필터가 훑는 보폭 설정

MaxPooling2D() 함수는 Max Pooling Layer를 추가하는 함수.

pool_size는 풀링(filter)의 크기를 의미, 풀링 필터의 가로 세로 사이즈

strides 풀링 필터의 보폭 설정 (default는 pool_size를 따름)

Flatten() 함수는 2차원 특징 맵을 1차원으로 펼치는 함수입니다.

Dense() 함수는 Fully Connected Layer를 추가하는 함수. 512는 뉴런(neuron)의 개수, activation은 활성화 함수로서 ReLU 함수를 사용

Dense() 함수는 output layer

마지막으로, compile() 함수를 이용하여 모델을 컴파일합니다.

loss는 손실 함수(loss function)로서 categorical crossentropy를 사용.

optimizer는 Adam을 사용

metrics 는 모델의 성능을 평가하는 지표로서 accuracy를 사용.

Batch Normalization: 딥러닝 모델에서 학습 과정을 안정화하는 방법 중 하나 이 방법은 각 층(layer)에서의 입력 값을 평균과 표준편차로 정규화(normalize)하는 과정을 추가하여 학습을 안정화

주로 디폴트 값을 씀(충분하기 때문)

Batch Normalization의 주요 장점.

1. 학습 속도를 빠르게 함: 입력값을 정규화하면, 각 층에서의 가중치(weight) 업데이트가 더욱 빠르게 이루어지기 때문에 학습 속도가 향상
2. Gradient vanishing 문제를 완화함:
3. Gradient vanishing 문제는 backpropagation 과정에서 역전파되는 gradient 값이 점점 작아져서, 학습이 이루어지지 않는 문제를 의미
4. Batch Normalization은 이 문제를 완화하는 효과가 있음
5. Regularization 효과: 입력값을 정규화하는 과정에서 노이즈(noise)를 줄이는 효과가 있어 모델의 일반화 성능을 향상.

결국 학습속도를 개선하고, 초깃값 의존을 방지하며 과적합을 방지한다.

<EarlyStopping 부여 후 학습 및 검증>

 

from tensorflow.keras.callbacks import EarlyStopping

es = EarlyStopping(monitor='val_loss',     # 관측대상 : 무엇을 보고 EarlyStopping 을 할 지
                   patience=5,             # 관측대상이 개선되지 않을 때 몇 번이나 더 지켜볼 것인지
                   min_delta=0,            # Threshold : 이 이상 or 이 이하로 값이 변해야 개선되었다고 간주
                   verbose=1,              # 어느 epoch에서 멈췄는지 알려줌 ex)Epoch 13: early stopping
                   restore_best_weights=True) # 최적 epoch의 가중치를 모델에 적용
#모델 학습
hist = model.fit(x_train, y_train, batch_size=128, epochs=1000, verbose=1,
                 validation_split=0.2, callbacks=[es])

#예측
y_pred = model.predict(x_test)
y_pred.shape # => (10000, 10)
y_pred = y_pred.argmax(axis=1)  
# 다중분류문제니까 softmax를 써서 확률분포다=>행에서 최대값을 가지는 열의 인덱스를 찾도록
y_pred.shape #=>(10000,)
# 같은 논리로 
y_test = y_test.argmax(axis=1)

#정확도
acc = accuracy_score(y_test, y_pred)

print(f'테스트셋 정확도 : {acc*100:.2f}%' )

#성능확인
id = rd.randrange(0,10000)

if y_test[id] == y_pred[id] :
    print('정답')
else : 
    print('오답')

<Image Data Augmentation>

Image Data Augmentation은 이미지 데이터셋을 다양한 방법으로 변형하여 데이터셋의 크기를 늘리는 기술.

기존의 이미지를 회전, 이동, 뒤집기 등의 변형을 가하거나, 밝기, 채도 등의 조절을 통해 이미지 데이터셋을 다양하게 만들어 모델이 다양한 상황에서 더욱 강건하게 동작하도록 한다.

이러한 Image Data Augmentation은 딥러닝 모델의 일반화 성능을 향상시키는 데 큰 역할

특히 데이터셋이 적은 경우, 이미지 데이터셋을 다양하게 변형하여 데이터셋의 크기를 늘림으로써 모델의 성능을 더욱 향상시킬 수 있음.

Keras에서는 ImageDataGenerator 클래스를 사용하여 Image Data Augmentation을 수행 ImageDataGenerator 클래스는 이미지 데이터셋을 자동으로 변환하고 증강하는 기능을 제공

예를 들어, 다음과 같은 코드로 이미지 회전과 좌우 반전을 수행하는 ImageDataGenerator 객체를 만들 수 있다.

 

from keras.preprocessing.image import ImageDataGenerator

train_IDG = ImageDataGenerator(rotation_range=20,      # 0 ~ 20 사이로 랜덤하게 이미지 각도를 비틈
                               zoom_range=0.1,         # 0 ~ 10% 사이로 랜덤하게 확대함
                               shear_range=0.1,        # 0 ~ 10% 사이로 랜덤하게 비틈
                               width_shift_range=0.1,  # 0 ~ 10% 사이로 랜덤하게 너비가 이동
                               height_shift_range=0.1) # 0 ~ 10% 사이로 랜덤하게 높이가 이동


# 어떤 데이터를 바탕으로 제너레이팅 할 것인지, 미리 알려줌!
# train_IDG.fit(train_x)옵션 주의하자. 
# 이미지 회전, 이동, 축소할 때 발생하는 공간을 채우는 방식


# 학습 할 때마다, '실시간'으로 데이터를 생성(뻥튀기 augmentation)하여 학습에 활용하고, 버리고를 반복할 준비
flow_trainIDG = train_IDG.flow(train_x, train_y, batch_size=32
                            #    , save_to_dir='output'  # Augmentation 과정에서 생성된 이미지를 output 경로에 저장
                            #    , save_prefix='image'  # 저장되는 파일에 접두어 설정
                            #    , save_format='jpg'  # 저장되는 파일의 포맷
                               )
# train_IDG.flow
# 모델 학습과 검증 과정에서 증강된 이미지를 사용하여 모델의 일반화 성능을 더욱 향상

val_IDG = ImageDataGenerator()
flow_valIDG = val_IDG.flow(val_x, val_y, batch_size=32)


# val_IDG.flow 메서드 :
# 데이터 증강을 적용하고 이미지를 배치단위로 가져올 수 있는 제너레이터(generator)를 생성
# 검증 데이터셋(validation set)을 생성하기 위해 사용
# batch_size: 배치 크기를 지정합니다. 디폴트는 32
# shuffle: 배치를 생성하기 전에 데이터를 섞을지 여부를 지정. 디폴트는 True.
# seed: 배치를 생성할 때 데이터를 섞는 데 사용되는 시드(seed)를 지정합니다. 디폴트는 None
# subset: 데이터셋 중 일부를 사용하는 경우 해당 부분을 선택합니다. train 또는 validation으로 선택 가능. 
          # 기본값은 validation


# 옵션 val_IDG.fit()
# 주어진 ImageDataGenerator를 이용하여 신경망 모델을 학습하는 함수로, 
# 출력 값으로 학습 결과에 대한 히스토리 객체를 반환
# 이 히스토리 객체는 손실 함수값, 정확도 등의 정보를 담고 있어
# 학습 결과를 검증할 때 유용


#cnn모델링하고(output layer의 노드수 주의!)~ EearlyStopping 하고~ 

#학습
model.fit(flow_trainIDG,
          validation_data=flow_valIDG,
          epochs=10000, verbose=1,
          callbacks=[es])