# reference: online.codingapple.com
CNN์ ํ์ฉ: ์๊ธ์จ ์ธ์ / ์ฌ๋ฌผ์ธ์ / ์์จ์ฃผํ ๊ธฐ์ด์ ๋ณด ์์ง ๋ฑ
* ๊ธฐ์ด ๊ฐ๋ ๋ณต๊ธฐ
๋ชจ๋ธ > ๋ ์ด์ด > ๋ ธ๋
ํ ์: ๋ฐ์ดํฐ, ๋๋ ๋ฐ์ดํฐ๋ฅผ ๋ด์ ์๋ฃํ ์์ฒด
๋ชจ๋ธ: ๋ฐ์ดํฐ์ ์ ์ฒด์ ์ธ ํ๋ฆ์ ๋ด์ ๊ฒ(?). ๋ ์ด์ด๋ค๋ก ์ด๋ฃจ์ด์ง
๋ ์ด์ด: ๋ ธ๋๋ก ์ด๋ฃจ์ด์ง ๋ฐ์ดํฐ๊ฐ ์ฒ๋ฆฌ๋๋ ํ๋์ ๊ณ์ธต.
์ปค๋: ์ด๋ฏธ์ง์์ ํน์ง์ ๊ฐ์งํ๋ ํํฐ์ญํ . ํ๋์ ์ปค๋์ ํ๋์ ํน์ง๋ง ๊ฐ์งํ ์ ์์.
1. ๋ฐ์ดํฐ์ ๋ก๋
CNN์ ๋๋ถ๋ถ ์ด๋ฏธ์ง ์ฒ๋ฆฌ์ด๊ธฐ ๋๋ฌธ์ ์ด๋ฏธ์ง ๋ก๋๋ฅผ ์๋ฏธํฉ๋๋ค.
์ด๋ฏธ์ง๋ฅผ ๋ก๋ํ ์ ์๋ ๋ํ์ ์ธ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ค์ pillow, matplot, opencv ๋ฑ์ด ์์ต๋๋ค.
1-1) PIL (Pillow)
from PIL import Image
image = Image.open("ROUTE")
+) PIL์ ์ด๋ฏธ์ง ์์ฒด๋ฅผ ๋ถ๋ฌ์ค๋ฏ๋ก ์ด๋ฏธ์ง๋ฅผ rgb ๋ฐฐ์ด๋ก ๋ณํํ๋ ๊ณผ์ ์ด ํ์ํฉ๋๋ค. ๋ฐ๋ผ์ ์๋ ์ฝ๋๋ฅผ ํตํด ๋ฐฐ์ด๋ก ๋ณํํฉ๋๋ค.
import numpy as np
ar = np.array(image)
> Preview
image.show()
1-2) Matplotlib
import matplotlib.pyplot as plt
image = plt.imread("ROUTE")
+) Matplotlib๋ ์ด๋ฏธ์ง๋ฅผ rgb๊ฐ ๋ฐฐ์ด ํํ๋ก ๋ถ๋ฌ์ค๋ฏ๋ก ์ด๋ฏธ์ง๋ฅผ rgb ๋ฐฐ์ด๋ก ๋ณํํ๋ ๊ณผ์ ์ด ํ์์์ต๋๋ค.
> Preview
plt.imshow(image)
plt.show()
1-3) Opencv
import cv2
image = cv2.imread("ROUTE")
> Preview
cv2.imshow('image', image)
cv2.waitKey()
+) cv2์ ๊ฒฝ์ฐ RGB ์์๋ก ์ฝ๋ ๊ฒ์ด ์๋ BGR ์์๋ก ํ์ํ๊ธฐ ๋๋ฌธ์ ์ฃผ์ํ ํ์๊ฐ ์์ต๋๋ค.
2. ๋ชจ๋ธ ๋ง๋ค๊ธฐ
๋ชจ๋ธ์ tf.keras.Sequential ๋ช ๋ น์ด๋ฅผ ํตํด ๋ง๋ค ์ ์์ต๋๋ค.
model = tf.keras.Sequential([...])
๋ชจ๋ธ ์์๋ ์ฌ๋ฌ ๋ ์ด์ด๋ฅผ ์ ์ธํ ๋ ๋ฃ๊ฑฐ๋, ๋น ๋ชจ๋ธ์ ๋ง๋ค๊ณ model.add๋ฅผ ํตํด ์ถ๊ฐํ ์ ์์ต๋๋ค. ํด๋น ํฌ์คํธ์์๋ ์ ์์ ๋ฐฉ์์ ์ฌ์ฉํ์ฌ ํฌ์คํ ํฉ๋๋ค.
3. ๋ ์ด์ด ๋ง๋ค๊ธฐ
๋ ์ด์ด์ ์ข ๋ฅ๋ ๋ค์ํฉ๋๋ค.
3-1) ์ด๋ฏธ์ง ํน์ง ์ถ์ถ ๋ ์ด์ด (= Convolutional Layer)
์ปดํจํฐ๋ ๋ฐฐ์ดํ์์ ํตํด ์ด๋ฏธ์ง๋ฅผ ์ฝ๊ณ ํ์ํ ์ ์๋๋ฐ, ์ฐ๋ฆฌ๊ฐ ์ํ๋ ์ถ๋ ฅํ์์ผ๋ก ์ค์ ํ๊ฒ ๋๋ฉด ๊ทธ์ ๋ง๊ฒ ์ฑ์ฌ๋ฃ๋ค๋ณด๋ ์ด๋ฏธ์ง์ ํน์ง์ ์ด๋ฆด ์ ์์ต๋๋ค.
๋ฐ๋ผ์ ์ด ํน์ง์ ์ด๋ ค ์ฝ์ด๋ผ ์ ์๋ ๋ ์ด์ด๊ฐ ํ์ํ๋ฐ, ์ด ๋ ์ด์ด๊ฐ Convolutional Layer์ ๋๋ค.
Convolutional Layer์์ ์ด๋ฏธ์ง์ ํน์ง์ ์ถ์ถํ๋ ๋ ์์ Kernel์ด๋ผ ํฉ๋๋ค. ๊ธฐ์กด ์ด๋ฏธ์ง์์ ์ด๋ค ๋ถ๋ถ์ด ์ผ๋ง๋ ์ค์ํ์ง๋ฅผ ํ๋จํ๋ ๊ธฐ์ค์ ๋ด๊ณ ์๋๋ฐ, ๊ธฐ์กด ์ด๋ฏธ์ง์ rgb๊ฐ์ Kernel์ด ๊ฐ์ง๊ณ ์๋ ์ค์๋์ ๋ํ ๊ฐ์ ๊ณฑํด ๋ชจ๋ ๋ํ์ฌ ๊ฒฐ๊ณผ๊ฐ์ ํ ์นธ์ผ๋ก ์์ถํฉ๋๋ค. ๋ฐ๋ผ์ Kernel์ ํ๊ฐ์ ํน์ง๋ง์ ๊ฐ์งํ ์ ์์ต๋๋ค. n๊ฐ์ ํน์ง์ ์ถ์ถํ๊ณ ์ถ๋ค๋ฉด n๊ฐ์ kernel์ ์ ์ฉํ๋๋ก ๋ช ๋ นํด์ผ๊ฒ ์ฃ ? :)
> ์ ๋ฆฌ: Convolutional Layer๋ ์ผ์ ํฌ๊ธฐ์ ํํฐ (=Kernel)๋ฅผ ์์ผ๋ก ํ์นธ์ฉ ๋ฐ๋ฉด์ (=Striding) ์ด๋ฏธ์ง์ ํน์ง์ ์ถ์ถํด๋ด๋ ๋ ์ด์ด์ ๋๋ค.
tf.keras.Layer.Conv2D(n, (x, y), padding="[paddingOption]", activation="[activationFunction]", input_shape=([inpshape]))
Tensorflow์์ Convolutional Layer๋ ์ด์ ๊ฐ์ด ๋ง๋ญ๋๋ค.
n๊ฐ์ kernel์ x,y ์ฌ์ด์ฆ๋ก ๋ง๋ญ๋๋ค. kernel์ ์๋์ผ๋ก ์์ฑ๋ฉ๋๋ค.
padding์ ๊ฐ์ VALID or SAME์ผ๋ก ์ค์ ํ ์ ์์ต๋๋ค. ๊ฐ๊ฐ ํ ๋๋ฆฌ์ ๋น ์์ญ์ผ๋ก ์ฑ์ ์ด๋ฏธ์ง ํฌ๊ธฐ๋ฅผ ๊ธฐ์กด ํฌ๊ธฐ์ ๋ง์ถ์ง ๋ง์ง๋ฅผ ๋ํ๋ ๋๋ค.
activation์๋ ํ์ฑํจ์์ ์ด๋ฆ์ด ๋ค์ด๊ฐ๋๋ค. ํ์์ ๋ฐ๋ผ ์๋ง๊ฒ ์ค์ ํ๋ฉด ๋ฉ๋๋ค.
input_shape๋ ์ด ๊ณ์ธต์ ์ ๋ ฅ๋๋ ์ด๋ฏธ์ง ํํ๋ฅผ ๋งํฉ๋๋ค. ์ฒซ๋ฒ์งธ ๋ ์ด์ด์ Convolutional Layer๊ฐ ์ฌ ๊ฒฝ์ฐ ์ด ๊ฐ์ ํ์์ ๋๋ค. ์ฒซ๋ฒ์งธ ๋ ์ด์ด๊ฐ ์๋๋๋ผ๋ ์ด ๊ฐ์ ๊ถ์ฅ๋๋๋ฐ, ์ด ๋ ์ด์ด์๋ ๋ฌด์กฐ๊ฑด 4์ฐจ์ ๋ ์ด์ด๊ฐ ๋ค์ด๊ฐ์ผํ๊ธฐ ๋๋ฌธ์ ๋๋ค. ๋ณดํต ์ฐ๋ฆฌ๊ฐ ๊ฐ์ง๊ณ ์๋ ๋ฐ์ดํฐ๋ (์ด๋ฏธ์ง ๊ฐ์, ๊ฐ๋ก, ์ธ๋ก)๋ก 3์ฐจ์ ๋ฐ์ดํฐ์ด๋ฏ๋ก, ํ๋ฐฑ ์ฒ๋ฆฌ์์๋ ๋ง์ง๋ง์ 1, ์ปฌ๋ฌ ์ฒ๋ฆฌ์์๋ ๋ง์ง๋ง์ 3์ ์ถ๊ฐํ์ฌ ์ฐจ์์๋ฅผ ํ๋ ๋๋ ค์ค์ผ ํฉ๋๋ค. ์๋์ ๊ฐ์ ํ์์ผ๋ก ์ ํด์ฃผ์๋ฉด ๋ฉ๋๋ค:
input_shape = (์ด๋ฏธ์ง ๊ฐ๋กํฌ๊ธฐ, ์ด๋ฏธ์ง ์ธ๋ก ํฌ๊ธฐ, 1)
# or
input_shape = (์ด๋ฏธ์ง ๊ฐ๋กํฌ๊ธฐ, ์ด๋ฏธ์ง ์ธ๋ก ํฌ๊ธฐ, 3)
3-2) ํ๋ง ๋ ์ด์ด (= Pooling Layer)
Convolutional Layer์์๋ ์์ ๋งํ๋ฏ ํน์ง์ ์ถ์ถํ๋ฏ๋ก ๋ฐ์ดํฐ์ ์์ด ํ์คํ ๋์ด๋ฉ๋๋ค. ๋ฐ๋ผ์ ํ๋ฆ์์ ์ฐ์ฐ๋์ด ๋์ด๋๊ฒ ๋๊ณ , ์ด์ ๋ฐ๋ผ Overfitting(๊ณผ์ ํฉ, ํ์ต๋ฐ์ดํฐ๋ง ์ ๋ต๋ฅ ์ด ๋๊ณ ์ค์ ์ ์ฉ์์๋ ์ ๋ต๋ฅ ์ด ๋ฎ์ ํ์) ๊ฐ๋ฅ์ฑ์ด ๋์ด๋ฉ๋๋ค.
์์๋ฅผ ๋ค์๋ฉด, ํธ๋ํฐ ์ด๋ฏธ์ง๋ฅผ Convolutional Layer๋ฅผ ํตํด ํ์ต์์ผฐ๋ค ํ๋๋ผ๋, ํธ๋ํฐ์ ์์น๊ฐ ์กฐ๊ธ์ด๋ผ๋ ๋ฐ๋๋ค๋ฉด ์ธ์๋ฅ ์ด ํฌ๊ฒ ๋จ์ด์ง๋ค๋ ๊ฒ์ ๋๋ค.
์ด๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด์ ์ฐ์ฐ๋์ ์ค์ด๊ณ ํน์ง์ ์ ํํ ํ์ ํ๋๋ก ๋์์ฃผ๋ ๋ ์ด์ด๊ฐ ํ์ํ๋ฐ, ์ด๋ฐ ์์ ์ ์ํํ๋ ๋ ์ด์ด๋ฅผ Pooling Layer๋ผ๊ณ ํฉ๋๋ค. ํน์ ๊ธฐ์ค์ ๋ฐ๋ผ ๋ฐ์ดํฐ์ ํฌ๊ธฐ๋ฅผ ์ค์ฌ ๊ฐ์ด๋ฐ๋ก ๋ชจ์๋ฒ๋ฆฌ๋ ๊ฒ์ด์ฃ (=Down Sampling).
๊ฐ์ฅ ๋ง์ด ์ฌ์ฉํ๋ Max Pooling Layer์์๋ ๊ฐ์ฅ ๊ฐํ ํน์ง๋ง ๋ฝ์๋ ๋๋ค.
tf.keras.Layer.MaxPooling2D( (x, y) )
Tensorflow์์ Max Pooling Layer๋ ์ด์ ๊ฐ์ด ๋ง๋ญ๋๋ค.
x,y ์ฌ์ด์ฆ๋ก down sampling ํ๋ผ๋ ๋ง์ ๋๋ค.
'๐ [STUDY] AI > Tensorflow' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Tensorflow - D0: ๋จธ์ ๋ฌ๋ ๊ธฐ์ด์ ๋ฆฌ (0) | 2021.04.24 |
---|