2022. 4. 19. 12:35ใ๐งช Data Science/ML, DL
CNN basic
ํฉ์ฑ๊ณฑ ์ธต, ํ๋ง ์ธต
CNN(Convolutional neural network)์ด๋?
ํฉ์ฑ๊ณฑ ์ ๊ฒฝ๋ง์ ์๊ฐ ํผ์ง ์์ ๋ด๋ฐ ์๋๋ฐฉ์์ ๋ณธ ๋ฐ ๋ง๋ค์ด์ง ๋คํธ์ํฌ์ด๋ค.
์ ๊ทธ๋ฆผ์ ์ค์ ์๊ฐํผ์ง์ ๋ด๋ฐ์ด ์๋ํ๋ ๋ฐฉ์์ด๋ค. ์ธ๊ฐ์ ๋์ ์ฌ๋ฌผ์ ํ ๋ฒ์ ๋ฐ์๋ค์ฌ ์ธ์ํ๋ ๊ฒ์ด ์๋๋ค. ์ฌ๋ฌผ์ด ์ชผ๊ฐ์ ธ์ ์ ๋ ฅ๋๊ณ , ์ด๊ฒ๋ค์ด ๋ด๋ฐ ์ฐ๊ฒฐ๋ค์ ๊ฑฐ์ณ ํ๋์ ์ด๋ฏธ์ง๋ก ์ธ์๋๋ค. ๊ตญ๋ถ ์์ฉ์ฅ์ด๋ผ๋ ๋ถ๋ถ(๋๊ทธ๋ผ๋ฏธ)๋ค์ด ๋ด๋ฐ์ ์ ๋ ฅ๋๊ณ , ์ด ์ ๋ ฅ๊ฐ๋ค์ด ๋ค์ ๊น๊ฒ ์ฐ๊ฒฐ๋๋ฉฐ ๋ณต์กํ ํจํด์ ๊ฐ๋ค์ ๋์ถํ๋ค.
์ด์ ๊ฐ์ด, ํฉ์ฑ๊ณฑ ์ ๊ฒฝ๋ง์์๋ ์ด๋ฏธ์ง๋ฅผ ๋ถ๋ถ ๋ถ๋ถ์ผ๋ก ์ชผ๊ฐ์ ์ ๋ ฅ๊ฐ์ผ๋ก ๋ค์ด๊ฐ๋ค. ์ด ์ ๋ ฅ ๊ฐ๋ค์ ๋ด๋ฐ์ ์ฐ๊ฒฐ ์์์ ๋ ์๋ฏธ ์๊ณ , ๊น์ ํน์ง๋ค๋ก ๋ณํ์ฌ ์ถ๋ ฅ๋๋ค.
* ๋ณธ ํฌ์คํ ์ Keras์ Tensorflow๋ก ์งํ๋ฉ๋๋ค. Colab ํ๊ฒฝ์์ ์งํํ ๊ฒ์ ์ถ์ฒ๋๋ฆฝ๋๋ค.
[CNN์ ๊ธฐ๋ณธ ๊ตฌ์กฐ]
Image ์ ๋ ฅ -> ํฉ์ฑ๊ณฑ ์ธต -> ํ๋ง ์ธต -> flatten -> ์์ ์ ๊ฒฝ๋ง -> ์ถ๋ ฅ ์ธต
ํฉ์ฑ๊ณฑ ์ธต(convolutional layer)
CNN์์ ๊ฐ์ฅ ์ค์ํ ๊ตฌ์ฑ ์์.
์์ ์ธ๊ธํ๋ฏ์ด, ์ฒซ ๋ฒ์งธ ํฉ์ฑ๊ณฑ ์ธต์ ๋ด๋ฐ์ ์ด๋ฏธ์ง ์ ์ฒด ํฝ์ ๊ณผ ์ฐ๊ฒฐ๋๋ ๊ฒ์ด ์๋๋ค. ํ ๊ฐ์ ๋ด๋ฐ์ด ์์ฉํ๋ ๋ฒ์์ ์๋ ํฝ์ ๋ง ์ฐ๊ฒฐ๋์ด ์ ๋ ฅ๊ฐ์ผ๋ก ๋ค์ด๊ฐ๋ค.
์๋ฅผ ๋ค์ด, 3x3 ๋ฒ์๋ฅผ ํ๋์ ๋ด๋ฐ์ด ์ธ์ํ๋ค๊ณ ํ์. ๋นจ๊ฐ์ ์ฌ๊ฐํ์ ํฝ์ ๊ฐ์ ์ฒซ ๋ด๋ฐ์ด ์ธ์ํด์ ๊ฐ์ ธ๊ฐ๊ณ , ๊ทธ๋ค์ ๋ด๋ฐ์ ํ๋์ ์ฌ๊ฐํ์ ํฝ์ ๊ฐ๋ค์ ์ธ์ํด์ ์ ๋ ฅ๊ฐ์ผ๋ก ๊ฐ์ ธ๊ฐ๋ค.
์ฌ๊ธฐ์ ์ ๊น. ๋นจ๊ฐ์ ์ฌ๊ฐํ๊ณผ ํ๋์ ์ฌ๊ฐํ์ ๊ฐ๊ฒฉ์ ๋ชจ๋ธ๋ง์ ํ๋ ์ฌ๋์ด ์ ํ ์ ์๋ค. ์ด ๊ฐ๊ฒฉ์ ์คํธ๋ผ์ด๋(stride)๋ผ๊ณ ํ๋ค. ์ด ๊ฐ๊ฒฉ์ ํฌ๊ฒ ํ๋ค๋ฉด ํ๋์ ํฉ์ฑ๊ณฑ ์ธต์ ์ง๋ ๊ฐ์ ๋ณธ๋ ๊ฐ๋ณด๋ค ํฌ๊ธฐ๊ฐ ์์์ง ๊ฒ์ด๋ค.
์ ๊ทธ๋ฆผ์ ์คํธ๋ผ์ด๋๋ ๊ฐ๊ฒฉ์ด 1์ด๋ฏ๋ก, ์คํธ๋ผ์ด๋๋ 1์ด๋ค.
ํ์ง๋ง ํฉ์ฑ๊ณฑ ์ธต์ ์ง๋ ๊ฐ์ด ๋ณธ๋ ํฌ๊ธฐ์ ๊ฐ๊ฒ ํ๊ณ ์ถ๋ค๋ฉด ํจ๋ฉ(padding)์ ์ด์ฉํ ์ ์๋ค.
padding์ ์ฃผ์ ์ ํ์ง
SAME - ํฉ์ฑ๊ณฑ ์ธต์ ์ ๋ก ํจ๋ฉ์ ์ ์ฉํ๋ค. ์ฆ, ํฉ์ฑ๊ณฑ ์ธต์ ์ง๋๋ ํฌ๊ธฐ๋ฅผ ๋ง์ถ๊ธฐ ์ํด(SAME), ๋ณธ๋์ ๊ฐ์ 0 ๊ฐ๋ค์ ์ฃผ์์ ๋ถ์ฌ์ ์ ๋ ฅ๊ฐ์ ์ฌ๊ตฌ์ฑํ๋ ์์ ์ ๋งํ๋ค.
VAILD - ํจ๋ฉ ์์. ์ฆ, ํฉ์ฑ๊ณฑ ์ธต์ ์ ๋ก ํจ๋ฉ์ ์ฌ์ฉํ์ง ์๊ณ , ๊ทธ๋๋ก ๊ฐ์ ธ๊ฐ๋ ๊ฒ์ ๋งํ๋ค.
๊ทธ๋ฐ ์๋ฏธ์์ ์ ๊ทธ๋ฆผ์ stride=1, padding='same' ์ต์ ์ ์ ์ฉํ์ฌ ํฉ์ฑ๊ณฑ ์ธต์ ํต๊ณผ์์ผฐ๋ค.
ํํฐ(filter)
ํน์ฑ๋ค์ ๋ฝ์๋ด๊ธฐ ์ํด ํฉ์ฑ๊ณฑ ์ธต์ ๋ผ์ ๋ฃ๋ ํฉ์ฑ๊ณฑ ์ปค๋.
๋ ๊ฐ์ ํํฐ๊ฐ ์๋ค. ํ๋๋ ๊ฐ์ด๋ฐ ํฐ ์์ง์ ์ด ์๋ ๊ฒ์ ์ฌ๊ฐํ(๊ฐ์ด๋ฐ ์ด์ 1๋ก ์ฑ์์ ธ ์๊ณ , ๊ทธ ์ธ์๋ ๋ชจ๋ 0์ธ 7x7 ํ๋ ฌ)์ด๊ณ , ํ๋๋ ๊ฐ์ด๋ฐ ํฐ ์ํ์ ์ด ์๋ ๊ฒ์ ์ฌ๊ฐํ์ด๋ค. ์ ๋ ฅ๊ฐ์ด ์ด ์ฌ๊ฐํ์ ์ง๋๋ฉด ์ด๋ป๊ฒ ๋ ๊น? ์ฒซ ๋ฒ์งธ ์ฌ๊ฐํ์ ์ง๋๋ฉด ํฐ ์์ง์ ์ ์๋ ์ ๋ ฅ๊ฐ์ ์ ์ธํ ๋๋จธ์ง ๊ฐ์ ๋ชจ๋ ์์ด์ง๋ค. ๋ ๋ฒ์งธ ์ฌ๊ฐํ์ ์ง๋๋ฉด ํฐ ์ํ์ ์ ์๋ ์ ๋ ฅ๊ฐ์ ์ ์ธํ ๋๋จธ์ง ๊ฐ์ ๋ชจ๋ ์์ด์ง๋ค.
* ์ ๋ ฅ๊ฐ์ด ํ๋์ ํํฐ๋ฅผ ํต๊ณผํ ํ์, ๋ ๋ค๋ฅธ ํํฐ๋ฅผ ํต๊ณผํ๋ ๊ฒ์ด ์๋๋ค. ํ๋์ ํํฐ๋ฅผ ํต๊ณผํ ์ฒด๋ก ํ๋์ ํน์ฑ ๋งต์ด ๋๋ค. ์ฆ, ํํฐ ๊ฐ์๋งํผ ์ถ๋ ฅ๊ฐ์ ์ธต๋ ๋์ด๋๋ค๋ ๋ป.
์ ์ด๋ ๊ฒ ๊ฐ์ ์์จ๊น?
๋จ๊ฒจ์ง ๊ฐ(ํน์ฑ)์ ์ง์คํ๊ธฐ ์ํด์๋ค.
์ด๋ฐ ๋ค์ํ ํํฐ๋ค์ด 40๊ฐ, 100๊ฐ๊ฐ ๋๋ค๋ฉด ์ฐ๋ฆฐ ์ ๋ ฅ๊ฐ์ ๋งค์ฐ ๋ค์ํ ๊ฐ๋๋ก ํ์ธํ ์ ์๋ค.
Tensorflow ๊ตฌํ
from sklearn.datasets import load_sample_image
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
# ์ด๋ฏธ์ง๋ฅผ ๋ก๋ํฉ๋๋ค.
china = load_sample_image("china.jpg") / 255
# ํํฐ ์ ์ฉ ์
plt.imshow(china)
plt.show()
flower = load_sample_image("flower.jpg") / 255
images = np.array([china, flower])
batch_size, height, width, channels = images.shape
# ํํฐ 2๊ฐ ๋ง๋ค๊ธฐ
filters = np.zeros(shape=(7,7,channels,2), dtype=np.float32)
filters[:,3,:,0] = 1 # ์์ง์
filters[3,:,:,1] = 1 # ์ํ์
outputs = tf.nn.conv2d(images, filters, strides=1, padding='SAME')
# ์ฒซ ๋ฒ์งธ ์ด๋ฏธ์ง์ ๋ ๋ฒ์งธ ํน์ฑ ๋งต(์ํ์ )์ ๊ทธ๋ฆฝ๋๋ค.
plt.imshow(outputs[0,:,:,1], cmap='gray')
plt.show()
[Code Summary]
- ๊ฐ ์ปฌ๋ฌ ์ฑ๋์ ํฝ์ ๊ฐ๋๋ 0~255 ์ฌ์ด์ ๊ฐ์ ๊ฐ์ง ๋ฐ์ดํธ ํ๋๋ก ํํ๋๋ค. ์ด์ ์ด ํน์ฑ์ 255๋ก ๋๋์ด 0~1 ์ฌ์ด์ ์ค์๋ก ๋ณํ
- 7x7 ํํฐ ๋ง๋ค๊ธฐ
- tf.nn.conv2d() : images๋ 4D tensor. filters๋ ์ ์ฉ๋ ํํฐ. strides=1. padding='same' ์ง์ .
์๋ ํํฐ๋ฅผ ์ง๋ ๊ทธ๋ฆผ์ ๊ฒฐ๊ณผ๋ฌผ์ด๋ค. ์์ด ๋ณํ ๊ฒ์ gray๋ก ์ค์ ํ๊ธฐ ๋๋ฌธ์ด์ง๋ง, ๊ทธ๋ฆผ์ด ํ๋ฆฟํด์ง ๊ฒ์ ์ํ์ ํํฐ๋ฅผ ์ ์ฉํ๊ธฐ ๋๋ฌธ์ด๋ค. ํ๋ฆฟํด์ง ๊ทธ๋ฆผ์ ํ๋์ ํน์ฑ ๋งต์ด๋ค. ํฉ์ฑ๊ณฑ ์ธต์ ์ง๋ ๋ ์๋ง์ ํํฐ๋ฅผ ๊ฑฐ์น๊ณ ๊ทธ๋งํผ ์๋ง์ ํน์ฑ ๋งต์ด ๋์จ๋ค.
์ค์ CNN์์๋ ํ๋ จ ๊ฐ๋ฅํ ๋ณ์๋ก์ ํํฐ๋ฅผ ์ ์ํ๋ค.
ํฉ์ฑ๊ณฑ ์ธต์ ์ ์ํด์ค ๋, ํํฐ๋ฅผ ์ ์ํ๋ค. ๊ทธ๋ฌ๋ฉด ์ ๊ฒฝ๋ง์ด ์ ๋ง๋ ํํฐ๋ฅผ ์์์ ํ์ตํ ์ ์๋ค.
conv = keras.layers.Conv2D(filters=32, kernel_size=3, strides=1, padding='same', activation='relu')
[Code Summary]
3x3 ํฌ๊ธฐ์ 32๊ฐ์ ํํฐ๋ฅผ ์ ์ฉ. 1 ์คํธ๋ผ์ด๋ ๋จ์๋ก ์์ง์ด๋ฉฐ, ์ ๋ก ํจ๋ฉ์ ์ด์ฉํ์ฌ ํฉ์ฑ๊ณฑ ์ธต์ ๋ง๋ค์๋ค. ์ถ๋ ฅ์ ์ํด ReLU ํจ์ ์ด์ฉํ๋ค.
ํ๋ง ์ธต(pooling layer)
ํ๋ง ์ธต์ ๋ชฉ์ ์ ๊ณ์ฐ๋๊ณผ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋, ํ๋ผ๋ฏธํฐ ์๋ฅผ ์ค์ด๊ธฐ ์ํด, ์ด๋ฏธ์ง์ ์ถ์๋ณธ(๋ถํ๋ณธ)์ ๋ง๋๋ ๊ฒ์ด๋ค.
ํฉ์ฑ๊ณฑ ์ธต์์์ ๋ง์ฐฌ๊ฐ์ง๋ก ๊ฐ๊ฐ์ ๋ด๋ฐ์ ์ผ์ ์์ญ ์ฌ๊ฐํ ์์ ํฝ์ ๋ง์ ์ธ์ํ๋ค. ์ด์ ๊ณผ ๋์ผํ๊ฒ ํฌ๊ธฐ, ์คํธ๋ผ์ด๋, ํจ๋ฉ ์ ํ์ ์ง์ ํ์ง๋ง ๊ฐ์ค์น๋ ์กด์ฌํ์ง ์๋๋ค. ์ฌ๊ฐํ ์์ ํฝ์ ๋ค๋ก ์ต๋๊ฐ์ ๋ฝ๊ฑฐ๋, ํ๊ท ์ ๋ด๊ฑฐ๋ ํ ๋ฟ์ด๋ค.
ํ๋ง(pooling) ์ข ๋ฅ์๋ ํฌ๊ฒ ์ต๋ ํ๋ง ์ธต, ์ ์ญ ํ๊ท ํ๋ง ์ธต์ด ์๋ค.
์ต๋ ํ๋ง ์ธต - ์ผ์ ์์ค์ ๋ถ๋ณ์ฑ. ๋ถ๋ฅ ์์ ์ฒ๋ผ ์์ธก์ด ์์ ๋ถ๋ถ์์ ์ํฅ์ ๋ฐ์ง ์๋ ๊ฒฝ์ฐ ์ ์ฉํ๋ค. ํ์ง๋ง ์๋งจํฑ ๋ถํ ๊ณผ ๊ฐ์ด ๋ฑ๋ณ์ฑ์ด ๋ชฉํ๊ฐ ๋๋ ์์ ์์ ์คํ๋ ค ํจ์ฉ์ด ๋จ์ด์ง๋ค.
max_pool = keras.layers.MaxPool2D(pool_size=2)
์ ์ญ ํ๊ท ํ๋ง ์ธต - ๊ฐ ์ํ์ ํน์ฑ ๋งต๋ง๋ค ํ๋์ ์ซ์๋ฅผ ์ถ๋ ฅ. ๋งค์ฐ ํ๊ดด์ ์ธ ์ฐ์ฐ์ด์ง๋ง ์ถ๋ ฅ์ธต์๋ ์ ์ฉํ ์ ์๋ค.
global_avg_pool = keras.layers.GlobalAvgPool2D()
CNN ๊ตฌ์กฐ
๋ง์ง๋ง, CNN ๊ตฌ์ฑ์์๋ฅผ ๋ฐฐ์ ์ผ๋ ์ด๋ป๊ฒ ์์์ผ ํ๋์ง ๋ฐฐ์ธ ์ฐจ๋ก๋ค.
์ ํ์ ์ธ CNN ๊ตฌ์กฐ๋ ํฉ์ฑ๊ณฑ ์ธต์ ๋ช ๊ฐ ์๊ณ (๊ฐ๊ฐ ReLU ์ธต์ ๋ค์ ๋๋๋ค), ๊ทธ๋ค์์ ํ๋ง์ธต, ๋ ํฉ์ฑ๊ณฑ ์ธต์ ์๊ณ , ๋ค์ ํ๋ง ์ธต์ ์๋ ์์ด๋ค. ํฉ์ฑ๊ณฑ ์ธต์ ํต๊ณผํ ์๋ก ์ด๋ฏธ์ง๋ ์์์ง์ง๋ง ๋ ๊น์ ํน์ฑ์ ์ ๊ทผ์ด ๊ฐ๋ฅํ๋ค. ๊ทธ๋ฐ ๋ค์ ์ธต์ ๋ชจ๋ ์ซ ํผ๊ณ flatten(), ์์ ์ ๊ฒฝ๋ง์ ์ฐ๊ฒฐํ์ฌ ์ถ๋ ฅ์ธต๊น์ง ๋ณด๋ด๋ฉด ์์ธก์ด ์ด๋ค์ง๋ค.
๋ถ๋ฅ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํ ๊ฐ๋จํ CNN Code
* ํจ์ MNIST ๋ฐ์ดํฐ์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํ ๋ชจ๋ธ
model = keras.models.Sequential([
keras.layers.Conv2D(64, 7, activation='relu', padding='same', input_shape=[28,28,1]),
keras.layers.MaxPooling2D(2),
keras.layers.Conv2D(128, 3, activation='relu', padding='same'),
keras.layers.Conv2D(128, 3, activation='relu', padding='same'),
keras.layers.MaxPooling2D(2),
keras.layers.Conv2D(256, 3, activation='relu', padding='same'),
keras.layers.Conv2D(256, 3, activation='relu', padding='same'),
keras.layers.MaxPooling2D(2),
keras.layers.flatten(),
keras.layers.Dense(128, activation='relu'),
keras.layers.Dropout(0.5),
keras.layers.Dense(64, activation='relu'),
keras.layers.Dropout(0.5),
keras.layers.Dense(10, activation='softmax')
])
[Code Summary]
- ์ด๋ฏธ์ง๊ฐ 28x28 ํฝ์ ํฌ๊ธฐ์ด๊ณ , ํ๋์ ์ปฌ๋ฌ ์ฑ๋์ ๊ฐ์ง๊ณ ์์ผ๋ฏ๋ก input_shape=[28,28,1]๋ก ์ง์
- ํ๋ง ํฌ๊ธฐ๊ฐ 2์ธ ์ต๋ ํ๋ง ์ธต์ ์ถ๊ฐํ์ฌ ๊ณต๊ฐ ๋ฐฉํฅ ์ฐจ์์ ์ ๋ฐ์ผ๋ก ์ค์ด๊ธฐ
- ํฉ์ฑ๊ณฑ ์ธต - ํ๋ง ์ธต ๋ฐ๋ณต
- ํ๋ง ์ธต ๋ค์์ ํฉ์ฑ๊ณฑ ์ธต์ ํํฐ ๊ฐ์๋ฅผ ๋ ๋ฐฐ๋ก ๋๋ฆฌ๋ ๊ฒ์ด ์ผ๋ฐ์ ์ด๋ค.
- ๊ณผ๋ ์ ํฉ์ ์ค์ด๊ธฐ ์ํด 50%์ ๋๋กญ์์ ๋น์จ์ ๊ฐ์ง ๋๋กญ์์ ์ธต์ ์ถ๊ฐ
๋ฐ๋ก ๋ค์ ํฌ์คํ ์์ ์์ CNN๊ตฌ์กฐ๋ฅผ ๋ฐํ์ผ๋ก ๋ชจ๋ธ๋งํ ํ, MNIST ๋ฐ์ดํฐ์ ์ผ๋ก ํ์ต, ์์ธก๊น์ง ํด๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
'๐งช Data Science > ML, DL' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๊ฐํํ์ต] REINFORCE ์๊ณ ๋ฆฌ์ฆ : ์ฝ๋ ๊ตฌํ (1) | 2024.06.02 |
---|---|
[๊ฐํํ์ต] REINFORCE ์๊ณ ๋ฆฌ์ฆ : ๊ฐ๋ ๋ฐ ์์ (0) | 2024.05.27 |
[ML] ์ฐจ์ ์ถ์ (1) - ์ ์, PCA, ์์ ์ฝ๋ (1) | 2024.02.26 |
[์ถ์ฒ ์๊ณ ๋ฆฌ์ฆ] ALS ๊ฐ๋ , Basic ํ๊ฒ feat. ์ฝ๋ X (0) | 2022.05.23 |
[CNN basic] MNIST ๋ฐ์ดํฐ์ ํ์ต, ์์ธก (0) | 2022.04.19 |