ํฉ์ฑ๊ณฑ ์ ๊ฒฝ๋ง(CNN) CNN์ด ์ด๋ฏธ์ง์ ๊ณต๊ฐ ์ ๋ณด๋ฅผ ์ด๋ป๊ฒ ํ์ตํ๋์ง ์๋ฆฌ๋ฅผ ํํค์น๊ณ , TensorFlow/Keras๋ก MNIST ์๊ธ์จ ๋ถ๋ฅ ๋ชจ๋ธ์ ๋ง๋ ๋ค.
๋ค์ด๊ฐ๋ฉฐ
์ง๋ ํฌ์คํ ์์ ๋ฅ๋ฌ๋์ ๊ธฐ๋ณธ ๋ชจ๋ธ์ธ MLP์ ๋ํด ์์๋ณด์๋ค. MLP๋ ๊ฐ๋ ฅํ ๋ชจ๋ธ์ด์ง๋ง, ์ด๋ฏธ์ง๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐ๋ ํ๊ณ๊ฐ ๋ช ํํ๋ค. ์ด๋ฏธ์ง๋ฅผ 1์ฐจ์ ๋ฒกํฐ๋ก ํผ์ณ์ ์ฒ๋ฆฌํ๊ธฐ ๋๋ฌธ์, ํฝ์ ๊ฐ์ ๊ณต๊ฐ์ ์ธ ๊ด๊ณ ์ ๋ณด(spatial information)๋ฅผ ์์ด๋ฒ๋ฆฌ๊ธฐ ๋๋ฌธ์ด๋ค.
์ด๋ฌํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ๋ฑ์ฅํ ๊ฒ์ด ๋ฐ๋ก ํฉ์ฑ๊ณฑ ์ ๊ฒฝ๋ง(Convolutional Neural Network, CNN)์ด๋ค. CNN์ ์ธ๊ฐ์ ์์ ๊ฒฝ์ด ์ด๋ฏธ์ง๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐฉ์์ ๋ชจ๋ฐฉํ์ฌ, ์ด๋ฏธ์ง์ ์ง์ญ์ ํน์ง์ ํจ๊ณผ์ ์ผ๋ก ์ถ์ถํ๊ณ ํ์ตํ๋๋ก ์ค๊ณ๋์๋ค. ์ด๋ฒ ํฌ์คํ ์์๋ CNN์ ํต์ฌ ์๋ฆฌ๋ฅผ ํํค์น๊ณ , TensorFlow/Keras๋ก ์ง์ ์๊ธ์จ ์ซ์ ์ด๋ฏธ์ง(MNIST)๋ฅผ ๋ถ๋ฅํ๋ ๋ชจ๋ธ์ ๋ง๋ค์ด๋ณด์๋ค.
1. ํฉ์ฑ๊ณฑ ์ ๊ฒฝ๋ง(CNN)์ด๋?
CNN์ ์ด๋ฏธ์ง ๋ฐ์ดํฐ ์ฒ๋ฆฌ์ ํนํ๋ ๋ฅ๋ฌ๋ ๋ชจ๋ธ์ด๋ค.
๋ชจ๋ธ ์ค์ค๋ก ์ด๋ฏธ์ง์ ํน์ง(Feature)์ ํ์ตํ์ฌ ํจํด์ ํ์ ํ๋ค.
ํํฐ(Filter, ๋๋ ์ปค๋)๋ฅผ ์ฌ์ฉํ์ฌ ์ด๋ฏธ์ง์ ํน์ง์ ์ถ์ถํ๋ ํฉ์ฑ๊ณฑ(Convolution) ์ฐ์ฐ๊ณผ,
ํน์ง์ ์์ถํ๊ณ ๊ฐ์กฐํ๋ ํ๋ง(Pooling) ์ฐ์ฐ์ด ํต์ฌ์ ์ธ ๊ตฌ์ฑ ์์๋ค.

2. CNN์ ํต์ฌ ๊ตฌ์ฑ ์์
๊ฐ. ํฉ์ฑ๊ณฑ ์ธต (Convolutional Layer)
ํฉ์ฑ๊ณฑ ์ธต์์๋ ํํฐ(Filter)๊ฐ ์ด๋ฏธ์ง ์๋ฅผ ์ผ์ ํ ๊ฐ๊ฒฉ(Stride)์ผ๋ก ์ด๋ํ๋ฉด์, ํํฐ์ ์ด๋ฏธ์ง์ ํด๋น ๋ถ๋ถ์ ์์๋ณ ๊ณฑ์ ํฉ์ ๊ณ์ฐํ๋ค. ์ด ๊ณผ์ ์ ํตํด ์ด๋ฏธ์ง์ ํน์ ํจํด(์์ง์ , ์ํ์ , ํน์ ์์ ๋ฑ)์ด ์ด๋์ ์๋์ง๋ฅผ ๋ํ๋ด๋ ํน์ง ๋งต(Feature Map)์ด ์์ฑ๋๋ค.
- ํํฐ(Filter): ํน์ง ์ถ์ถ๊ธฐ์ ์ญํ ์ ํ๋ ์์ ํ๋ ฌ. ์ด ํํฐ์ ๊ฐ๋ค(๊ฐ์ค์น)์ด ๋ฐ๋ก ํ์ต ๊ณผ์ ์์ ์ ๋ฐ์ดํธ๋๋ค.
- ์คํธ๋ผ์ด๋(Stride): ํํฐ๊ฐ ํ ๋ฒ์ ์ด๋ํ๋ ํฝ์ ์ ํฌ๊ธฐ.
- ํจ๋ฉ(Padding): ํฉ์ฑ๊ณฑ ์ฐ์ฐ ํ ํน์ง ๋งต์ ํฌ๊ธฐ๊ฐ ์์์ง๋ ๊ฒ์ ๋ฐฉ์งํ๊ณ , ์ด๋ฏธ์ง์ ์ธ๊ณฝ ๋ถ๋ถ ์ ๋ณด๋ฅผ ๋ณด์กดํ๊ธฐ ์ํด ์ ๋ ฅ ์ด๋ฏธ์ง์ ๊ฐ์ฅ์๋ฆฌ์ ํน์ ๊ฐ(์ฃผ๋ก 0)์ ์ฑ์ ๋ฃ๋ ๊ฒ.
๋. ํ๋ง ์ธต (Pooling Layer)
ํ๋ง ์ธต์ ํฉ์ฑ๊ณฑ ์ธต์์ ์ป์ ํน์ง ๋งต์ ํฌ๊ธฐ๋ฅผ ์ค์ฌ(Sub-sampling) ๊ณ์ฐ๋์ ๊ฐ์์ํค๊ณ , ์ฃผ์ ํน์ง์ ๋์ฑ ๊ฐ์กฐํ๋ ์ญํ ์ ํ๋ค. ์ฃผ๋ก ์ต๋ ํ๋ง(Max Pooling)์ด ์ฌ์ฉ๋๋๋ฐ, ์ด๋ ํน์ ๊ตฌ์ญ์์ ๊ฐ์ฅ ํฐ ๊ฐ(๊ฐ์ฅ ํ์ฑํ๋ ํน์ง)๋ง์ ๋จ๊ธฐ๋ ๋ฐฉ์์ด๋ค.
ํ๋ง์ ํตํด ๋ชจ๋ธ์ ์ด๋ฏธ์ง ๋ด์์ ๊ฐ์ฒด์ ์์น๊ฐ ์กฐ๊ธ ๋ณํ๋๋ผ๋ ๋์ผํ ๊ฐ์ฒด๋ก ์ธ์ํ ์ ์๋ ์ด๋ ๋ถ๋ณ์ฑ(Translation Invariance) ํน์ฑ์ ์ป๊ฒ ๋๋ค.
3. Python์ผ๋ก CNN ๊ตฌํํ๊ธฐ
์ด๋ฒ์๋ TensorFlow/Keras๋ฅผ ์ฌ์ฉํ์ฌ ์ ๋ช
ํ MNIST ์๊ธ์จ ์ซ์ ๋ฐ์ดํฐ์
์ ๋ถ๋ฅํ๋ ๊ฐ๋จํ CNN ๋ชจ๋ธ์ ๊ตฌํํด๋ณด์๋ค.
๊ฐ. ํ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ค์น
MLP ํฌ์คํ
์์ tensorflow๋ฅผ ์ด๋ฏธ ์ค์นํ๋ค๋ฉด ๋ณ๋์ ์ค์น๋ ํ์ ์๋ค.
๋. ์์ ์์ค ์ฝ๋
28x28 ํฝ์ ํฌ๊ธฐ์ ํ๋ฐฑ ์๊ธ์จ ์ซ์ ์ด๋ฏธ์ง๋ฅผ 0๋ถํฐ 9๊น์ง 10๊ฐ์ ํด๋์ค๋ก ๋ถ๋ฅํ๋ CNN ๋ชจ๋ธ์ด๋ค.
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
# 1. MNIST ๋ฐ์ดํฐ์
๋ก๋ ๋ฐ ์ ์ฒ๋ฆฌ
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# ์ด๋ฏธ์ง ๋ฐ์ดํฐ๋ฅผ 0~1 ์ฌ์ด ๊ฐ์ผ๋ก ์ ๊ทํ ๋ฐ ์ฑ๋ ์ฐจ์ ์ถ๊ฐ
# (60000, 28, 28) -> (60000, 28, 28, 1)
x_train = x_train.reshape((60000, 28, 28, 1)) / 255.0
x_test = x_test.reshape((10000, 28, 28, 1)) / 255.0
# 2. CNN ๋ชจ๋ธ ๊ตฌ์ถ (Keras ์ฌ์ฉ)
model = tf.keras.models.Sequential([
# ์ฒซ ๋ฒ์งธ ํฉ์ฑ๊ณฑ ์ธต
# 32๊ฐ์ 3x3 ํํฐ, ํ์ฑํ ํจ์ ReLU
# ์
๋ ฅ ์ด๋ฏธ์ง ํฌ๊ธฐ: (28, 28, 1)
tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
# ์ฒซ ๋ฒ์งธ ํ๋ง ์ธต (Max Pooling)
tf.keras.layers.MaxPooling2D((2, 2)),
# ๋ ๋ฒ์งธ ํฉ์ฑ๊ณฑ ์ธต
tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),
# ๋ ๋ฒ์งธ ํ๋ง ์ธต
tf.keras.layers.MaxPooling2D((2, 2)),
# ์ธ ๋ฒ์งธ ํฉ์ฑ๊ณฑ ์ธต
tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),
# 3D ํน์ง ๋งต์ 1D ๋ฒกํฐ๋ก ๋ณํ
tf.keras.layers.Flatten(),
# ์์ ์ฐ๊ฒฐ์ธต (MLP)
tf.keras.layers.Dense(64, activation='relu'),
# ์ถ๋ ฅ์ธต (10๊ฐ ํด๋์ค, Softmax ํ์ฑํ ํจ์)
tf.keras.layers.Dense(10, activation='softmax')
])
# 3. ๋ชจ๋ธ ์ปดํ์ผ
# ์์ค ํจ์: sparse_categorical_crossentropy (์ ์ ํํ์ ๋ ์ด๋ธ์ฉ)
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# ๋ชจ๋ธ ๊ตฌ์กฐ ์์ฝ
model.summary()
# 4. ๋ชจ๋ธ ํ์ต
model.fit(x_train, y_train, epochs=5, batch_size=64)
# 5. ๋ชจ๋ธ ํ๊ฐ
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
print(f"\nTest accuracy: {test_acc*100:.2f}%")
# 6. ์์ธก ๊ฒฐ๊ณผ ํ์ธ
# ํ
์คํธ ๋ฐ์ดํฐ์ ์ฒซ ๋ฒ์งธ ์ด๋ฏธ์ง๋ฅผ ์ฌ์ฉํ์ฌ ์์ธก
predictions = model.predict(x_test)
predicted_label = np.argmax(predictions[0])
actual_label = y_test[0]
plt.imshow(x_test[0].reshape(28, 28), cmap='gray_r')
plt.title(f"Predicted: {predicted_label}, Actual: {actual_label}")
plt.show()
๋ค. ์คํ ๊ฒฐ๊ณผ
ํ์ต ์ค ์์ค(Loss)๊ณผ ์ ํ๋(Accuracy)๊ฐ ์ด๋ป๊ฒ ๋ณํ๋์ง ๋ณด์ฌ์ฃผ๋ ๊ทธ๋ํ์ด๋ค.
์ํฌํฌ๊ฐ ์งํ๋ ์๋ก ์์ค์ ์ค๊ณ ์ ํ๋๋ 1์ ๊ฐ๊น์์ง๋ ์ด์์ ์ธ ๋ชจ์ต์ ๋ณด์ธ๋ค.

๋ค์์ ์ค์ ํ
์คํธ ์ด๋ฏธ์ง 10๊ฐ์ ๋ํ ์์ธก ๊ฒฐ๊ณผ์ด๋ค.
๋ชจ๋ธ์ด ์์ธกํ ๊ฐ(Pred)๊ณผ ์ค์ ๊ฐ(Actual)์ ๋น๊ตํด๋ณด๋ฉด, ํ๋ฆฐ ์์ธก์ ๋ถ์์์ผ๋ก ํ์๋๋ค.
์ด ์์์์๋ 10๊ฐ ๋ชจ๋ ์ ํํ๊ฒ ์์ธกํ๋ค.

๋ง์น๋ฉฐ
CNN์ ํฉ์ฑ๊ณฑ๊ณผ ํ๋ง์ด๋ผ๋ ๋
์ฐฝ์ ์ธ ์์ด๋์ด๋ฅผ ํตํด ์ด๋ฏธ์ง์ ๊ณต๊ฐ์ ํน์ง์ ํจ๊ณผ์ ์ผ๋ก ํ์ตํ๋ค.
์ด๋ฅผ ํตํด ์ด๋ฏธ์ง ๋ถ๋ฅ, ๊ฐ์ฒด ํ์ง(Object Detection), ์ด๋ฏธ์ง ๋ถํ (Image Segmentation) ๋ฑ ์ปดํจํฐ ๋น์ ๋ถ์ผ์ ํต์ฌ์ ์ธ ๊ธฐ์ ๋ก ์๋ฆฌ ์ก์๋ค.
์ฐธ๊ณ ์๋ฃ
- TensorFlow Core, Convolutional Neural Network (CNN)
'๐ Data Science & AI > Deep Learning' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| ํธ๋์คํฌ๋จธ(Transformer)์ ์ดํ ์ (Attention) (1) | 2026.06.07 |
|---|---|
| ์ํ ์ ๊ฒฝ๋ง(Recurrent Neural Network, RNN) (0) | 2026.03.02 |
| ๋ค์ธต ํผ์ ํธ๋ก (Multilayer Perceptron, MLP) (0) | 2026.03.02 |