๐ก Sigmoid
๋ ์ถ๋ ฅ์ธต์์ ์ฃผ๋ก ์ฌ์ฉ
sigmoid
์ฌ์ฉ ์ flatten ์ ํตํด ์์ธก๊ฐ์ 1์ฐจ์์ผ๋ก ๋ณํ# ๋ชจ๋ธ ์ปดํ์ผ
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
# ์์ธก
# ์์ธก๊ฐ์ y_pred ๋ณ์์ ํ ๋น ํ ์ฌ์ฌ์ฉํฉ๋๋ค.
y_pred = model.predict(X_test)
y_pred.shape
# Outcome; ์๋์ ๊ฐ์ ํ๋ฅ ๊ฐ์ X_test ๊ฐ์ (154๊ฐ) ๋งํผ ์ถ๋ ฅ
array([[0.62700105],
[0.01058297],
[0.3780695 ],
[0.5054825 ],
[0.2762504 ],
...
๐ค ๋ฐ์ด๋๋ฆฌ๋ฉด ๊ฒฐ๊ณผ๊ฐ 2๊ฐ ๋์์ผ ํ๋๊ฑฐ ์๋๊ฐ์?
์ํํธ๋งฅ์ค๋ผ๋ฉด 2๊ฐ๊ฐ ๋์ค์ง๋ง, ๋ชจ๋ธ ์ปดํ์ผ ์ ๋ฐ์ด๋๋ฆฌ๋ฅผ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ ์์ธก๊ฐ์ด ๊ฐ row๋น ํ๋์ฉ ๋์ต๋๋ค. ์ฌ๊ธฐ์ ๋์ค๋ ๊ฐ์ 0 ~ 1 ์ฌ์ด์ ํ๋ฅ ๊ฐ(sigmoid)์ด ๋์ต๋๋ค.
argmax()
: ๋ค์ฐจ์ ๋ฐฐ์ด์ ์ฐจ์์ ๋ฐ๋ผ ๊ฐ์ฅ ํฐ ๊ฐ์ ์ธ๋ฑ์ค๋ค์ ๋ฐํํด์ฃผ๋ ํจ์
y_predict = np.argmax(y_pred, axis=1)
unit์ ์๋ฅผ ๋ณ๊ฒฝํ์ฌ ๋คํธ์ํฌ๋ฅผ ๋ค์ํ๊ฒ ๊ตฌ์ฑํด ๋ณผ ์ ์๊ณ fit์ ํ ๋ epoch ์ ๋ฑ์ ์กฐ์ ํด์ ์ฑ๋ฅ์ ๋ณ๊ฒฝํด ๋ณผ ์ ์๋ค.
https://www.tensorflow.org/tutorials/keras/regression
๐ก ๋ณดํต ํ๊ท์์๋ ์ถ๋ ฅ์ 1๋ก ๋ฐ๋๋ค.
# ์ฌ์ดํท๋ฐ์ ์ ์ฒ๋ฆฌ ๊ธฐ๋ฅ์ด๋ ์ง์ ๊ณ์ฐ์ ํตํด ์ ๊ทํ ํด์ฃผ๋ ๋ฐฉ๋ฒ๋ ์๋ค.
# TF์์๋ ์ ๊ทํํ๋ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ค.
# horsepower_normalizer: Horsepower ๋ณ์๋ฅผ ๊ฐ์ ธ์์ ํด๋น ๋ณ์๋ง ์ ๊ทํ ํด์ฃผ๋ ์ฝ๋
horsepower = np.array(train_features['Horsepower'])
horsepower_normalizer = layers.Normalization(input_shape=[1,], axis=None)
horsepower_normalizer.adapt(horsepower)
โฌ๏ธ ์
๋ ฅ์ธต โฌ๏ธ
---------------------------------------------------------------------------
# ์ ์ฒ๋ฆฌ ๋ ์ด์ด๋ฅผ ์ถ๊ฐํด์ ๋ชจ๋ธ์ ๋ง๋ค ๋ ์ ์ฒ๋ฆฌ ๊ธฐ๋ฅ์ ๊ฐ์ด ๋ฃ์ด์ค ์ ์์ต๋๋ค.
# ์ฅ์ ์ ์ ๊ทํ ๋ฐฉ๋ฒ์ ๋ชจ๋ฅด๋๋ผ๋ ์ถ์ํ๋ ๊ธฐ๋ฅ์ ์ฌ์ฉํด์ ์ฝ๊ฒ ์ ๊ทํ ํด์ค ์ ์๋ค๋ ๊ฒ์ด์ง๋ง
# ์ถ์ํ๋ ๊ธฐ๋ฅ์ ๋จ์ ์ ์์ค์ฝ๋, ๋ฌธ์๋ฅผ ์ด์ด๋ณด๊ธฐ ์ ์๋ ์ด๋ค ๊ธฐ๋ฅ์ธ์ง ์๊ธฐ ์ด๋ ต๋ค๋ ๋จ์
# ์ฌ์ดํท๋ฐ์ pipeline๊ธฐ๋ฅ๊ณผ ์ ์ฌํ๋ค.
horsepower_model = tf.keras.Sequential([
horsepower_normalizer,
layers.Dense(units=1) # (activation = "linear")๊ฐ ์๋ต๋์ด ์๋ ๊ฒ๊ณผ ๊ฐ๋ค.
]) # == ํญ๋ฑํจ์; ์
๋ ฅ๋ฐ์ ๊ฐ์ ๊ทธ๋๋ก ์ถ๋ ฅ
horsepower_model.summary()
Output:
Model: "sequential"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
normalization_1 (Normalizat (None, 1) 3
ion)
dense (Dense) (None, 1) 2
=================================================================
Total params: 5
Trainable params: 2
Non-trainable params: 3
_________________________________________________________________
๐ค ๋ ์ด์ด ๊ตฌ์ฑ์์ ์ถ๋ ฅ์ธต์ ๋ถ๋ฅ์ ํ๊ท์ ์ฐจ์ด?
๐ก ํ๊ท์ ์ถ๋ ฅ์ธต์ ํญ์
layers.Dense(units=1)
ํํ
๐ค ๋ถ๋ฅ ์ค์ต๊ณผ ํ๊ท loss ์ ์ฐจ์ด?
โ ์ ํํ๊ท์ DNN์ ์ฌ์ฉํ์ ๋ loss ๊ฐ์ ์ฐจ์ด
๐ค loss์ val_loss์ ์ฐจ์ด?
loss๋ ํ๋ จ ์์ค๊ฐ, val_loss๋ ๊ฒ์ฆ ์์ค๊ฐ
๐ค ์ด๋ป๊ฒ ํด์ผ val ๊ฒฐ๊ณผ๊ฐ ๋์ฌ๊น?
ํ์ต๋จ๊ณ์์ validation_split
์ง์
model.fit(X_train, y_train, epochs, validation_split)
๐ค flatten()
์ 2์ฐจ์๋ง ๋ฐ์์ 1์ฐจ์์ผ๋ก ๋ฐ๊ฟ์ฃผ๋?
A: n์ฐจ์์ 1์ฐจ์์ผ๋ก ๋ง๋ค์ด์ค.
๐ก
ndim()
: ํด๋น ๋ฐ์ดํฐ์ dimension ์ถ๋ ฅ
๐ก ๊ดํธ n๊ฐ == n์ฐจ์
e.g.[[[ ]]]] == 3์ฐจ์
๐ ์ฐธ๊ณ ํ ๋งํ ์ฌ์ดํธ: https://numpy.org/doc/stable/user/absolute_beginners.html
1) ์ ํ๋ฐ์ดํฐ ์
๋ ฅ์ธต: input_shape
2) ์ ๊ทํ ๋ ์ด์ด์ ์ฌ์ฉ: ์ง์ ์ ๊ทํํด๋ ๋๋ค.
3) ์ถ๋ ฅ์ธต์ด ๋ถ๋ฅ์ ๋ค๋ฅด๊ฒ ๊ตฌ์ฑ์ด ๋๋ค.
4) loss ์ค์ ์ด ๋ถ๋ฅ, ํ๊ท์ ๋ฐ๋ผ ๋ค๋ฅด๋ค.
5) ์
๋ ฅ๋ณ์(ํผ์ฒ)๋ฅผ ํ๋๋ง ์ฌ์ฉํ์ ๋๋ณด๋ค ์ฌ๋ฌ ๋ณ์๋ฅผ ์ฌ์ฉํ์ ๋ ์ฑ๋ฅ์ด ๋ ์ข์์ก๋ค.
๐ก ๋ฐ๋์ ์ฌ๋ฌ ๋ณ์๋ฅผ ์ฌ์ฉํ๋ค๊ณ ํด์ ์ฑ๋ฅ์ด ์ข์์ง์ง ์์ ์๋ ์์ง๋ง ๋๋ฌด ์ ์ ๋ณ์๋ก๋ ์์ธก๋ชจ๋ธ์ ์ ๋ง๋ค๊ธฐ ์ด๋ ต๋ค๋ ์ ์ ์ ์ ์๋ค.
# ๋ชจ๋ธ์ ์ปดํ์ผ ํฉ๋๋ค.
# loss์ metrics์ ํ๋ ์ด์์ ์ง์ ํ๊ฒ๋๋ฉด ํ๊ฐ๋ฅผ ์ฌ๋ฌ๊ฐ์ง๋ก ํ๊ฒ๋๋ค.
model.compile(loss=['mae', 'mse'],
optimizer=tf.keras.optimizers.Adam(0.001),
metrics=['mae', 'mse'])
# ๋ชจ๋ธ์ ํ์ตํฉ๋๋ค.
early_stop = tf.keras.callbacks.EarlyStopping(monitor='val_mae',
patience=50)
# ํ์ต๊ฒฐ๊ณผ๋ฅผ history ๋ณ์์ ํ ๋นํฉ๋๋ค.
# validation_split: ๋ฐ์ดํฐ์
๋ด์์ ์ง์ ํ ๊ฐ์ ๋ฐ๋ผ ์์์ validation set์ ์์ฑ
history = model.fit(X_train, y_train, epochs=1000, verbose=0,
callbacks=[early_stop], validation_split=0.2)
# history๋ฅผ ๋ฐ์ดํฐํ๋ ์์ผ๋ก ๋ง๋ญ๋๋ค.
df_hist = pd.DataFrame(history.history)
df_hist.tail(3)
Output:
output ์์๋ compile ์ ์ง์ ํ ์์๋๋ก ์ถ๋ ฅ. loss ๋ ๋ค๋ฅธ ์งํ๋ฅผ ์ง์ ํ์ ๋ ๊ฐ์ฅ ์์ ์ถ๋ ฅ๋จ.
๐ค loss, val_loss, mae, val_mae ๊ฐ์ด ๊ฐ์ ์ด์ ?
loss์ ๊ธฐ์ค์ mae๋ก ์ง์ ํ๊ธฐ ๋๋ฌธ์ ๊ฐ์ ๊ฐ์ด ์ถ๋ ฅ๋๋ค.
๐ก optimizer์ ์ข ๋ฅ์ learning_rate์ ๋ฐ๋ผ ํ์ต์๋์ ์ฐจ์ด๊ฐ ์๊ธด๋ค.
๐ค mae์ val_mae๊ฐ ๋ฒ์ด์ง๋ ํ์?
๊ณผ์ ํฉ
# ์์ธก
y_pred = model.predict(X_test)
y_pred.shape
Output:
(79, 1)
# ์์ธก๊ฐ์ flatten์ ์ฌ์ฉํด 1์ฐจ์์ผ๋ก ๋ณํ
y_predict = y_pred.flatten()
y_predict.shape
Output:
(79,)
# evaluate๋ฅผ ํตํด ํ๊ฐ
# loss, mae, mse
loss, mae, mse = model.evaluate(X_test, y_test)
print("ํ
์คํธ ์ธํธ์ ํ๊ท ์ ๋ ์ค์ฐจ : {:5.2f}".format(mae))
print("ํ
์คํธ ์ธํธ์ ํ๊ท ์ ๊ณฑ ์ค์ฐจ : {:5.2f}".format(mse))
Output:
- loss: 63.7553 - mae: 63.7553 - mse: 11125.1436
ํ
์คํธ ์ธํธ์ ํ๊ท ์ ๋ ์ค์ฐจ : 63.76
ํ
์คํธ ์ธํธ์ ํ๊ท ์ ๊ณฑ ์ค์ฐจ : 11125.14
1) ๋ฅ๋ฌ๋ ๋ชจ๋ธ์ ์กฐ์ ํ์ฌ์ ํ๊ท ๋ฅ๋ฌ๋ ๋ชจ๋ธ์ ์์ฑํ์์ต๋๋ค!
(๋ถ๋ฅ ๋ชจ๋ธ๊ณผ ๋ค๋ฅด๊ฒ Dense ์ถ๋ ฅ ์ ๋ 1๋ก ์ค์ , Compile์์ loss, metrics ๋ณ๊ฒฝ)
2) ์์๊ณผ ์๊ฐ์ ์๋ผ๊ธฐ ์ํด์ ํ์ต ๊ณผ์ ์ค ์ฑ๋ฅ์ด ๋น์ทํ๋ฉด ๋ฉ์ถ ์ ์๋๋ก EarlyStopping์ ์ค์ ํด์ค๋๋ค!
(tf.keras.callbacks.EarlyStopping -> ์ฑ๋ฅ์ด ๋น์ทํจ์๋ ๋จ์ epochs๊ฐ ๋ง์ด ๋จ์๋ค๋ฉด ์๊ฐ์ด ์๊น์ฐ๋๊น์)
3) ํ์ต ๊ณผ์ ์์ validation_split์ ์ค์ ํ์ฌ ๊ฒ์ฆ ๋ฐ์ดํฐ์
๋ ์ค์ ํด์ค๋๋ค!
(๋ชจ๋ธ์ด ๊ณผ์ ํฉ์ธ์ง ๊ณผ์์ ํฉ์ธ์ง ์ ์ฑ๋ฅ์ ํ๋์ง ํ์ธํ๊ธฐ ์ํด์)
4) ๋ฅ๋ฌ๋ ๋ชจ๋ธ์ ํ์ต์ํต๋๋ค.
(model.fit)
5) ํ์ตํ ๋ชจ๋ธ์ ์ฑ๋ฅ์ history ํ๋ฅผ ๋ณด๋ฉด์ ์ธก์ ํฉ๋๋ค!
(์ฌ๊ธฐ์ ์ฐ๋ฆฌ ์ ์ ๋ฐฐ์ ๋ loss, mae, mse ์งํ๋ฅผ ๋ณด๋ฉด์ ๋ชจ๋ธ์ด ์ ์์ธกํ๋์ง ํ๊ฐํด๋ด
๋๋ค. -> ๊ฒ์ฆ๋ชจ๋ธ์์์ ์งํ์ ๋น๊ต๋ฅผ ํด๋ณด๊ณ (val_loss, val_mae, val_mse ๋ฑ๋ฑ) ๊ณผ๋์ ํฉ์ด ๋๋์ง, ๊ณผ์์ ํฉ์ด ๋๋์ง๋ ๋ณผ ์ ์์ต๋๋ค.)
Q: sigmoid ๊ทธ๋ํ๋ฅผ ์ด๋ป๊ฒ 2์ง ๋ถ๋ฅ์ ์ฌ์ฉํ ๊น์?
A: 0.5๋ฅผ ๊ธฐ์ค์ผ๋ก ์
๋ค์ด. ํน์ ์๊ณ๊ฐ์ ์ ํด์ ํฌ๊ณ ์๋ค๋ฅผ ํตํด True, False๊ฐ์ผ๋ก ํ๋จํฉ๋๋ค. ์๊ณ๊ฐ์ ๋ณดํต 0.5๋ฅผ ์ฌ์ฉํ์ง๋ง ๋ค๋ฅธ ๊ฐ์ ์ฌ์ฉํ๊ธฐ๋ ํฉ๋๋ค.
Q: loss, metric ์ ์ฐจ์ด๋ ๋ฌด์์ธ๊ฐ์?
A: loss๋ W, b ๊ฐ์ ์
๋ฐ์ดํธ ํด์ฃผ๊ธฐ ์ํด ํ๋ จ์ ์ฌ์ฉํ๊ณ , metric ๋ชจ๋ธ์ ์ฑ๋ฅ์ ํ๊ฐํ๊ธฐ ์ํด ๊ฒ์ฆ์ ์ฌ์ฉํ๋ค.
Q: ๋ถ๋ฅ์ผ ๋ ์ฌ์ฉํ๋ loss ์ ์ข
๋ฅ๋ ๋ฌด์์ด ์์๊น์?
A: Cross entropy.
loss ๊ฐ์ ๋ณด๊ณ label์ด ์ด๋ค ํํ์ธ์ง ์ ์ ์์ต๋๋ค. label ๊ฐ์ด ๋ฐ์ด๋๋ฆฌ, ์ํซ, ์ค๋๋ ์ธ์ฝ๋ฉ ๋์ด ์๋์ง ๋ณด๊ณ loss ๊ฐ์ ์ง์ ํด์ผ ํฉ๋๋ค.
- ์ด์ง๋ถ๋ฅ : binarycrossentropy
- ๋ค์ค๋ถ๋ฅ : ์ํซ์ธ์ฝ๋ฉ - categorical_crossentropy
- ๋ค์ค๋ถ๋ฅ : ์ค๋๋ - sparse_categorical_crossentropy
Q: ๋จธ์ ๋ฌ๋์ ์ผ์ ๋์ ๋ฅ๋ฌ๋์ ์ฌ์ฉํ์ ๋ ์ฑ๋ฅ์ด ์ด๋ค๊ฐ์?
A: ๋ณดํต์ ์ ํ๋ฐ์ดํฐ๋ ๋ฅ๋ฌ๋๋ณด๋ค๋ ๋จธ์ ๋ฌ๋์ด ๋์ฒด์ ์ผ๋ก ์ข์ ์ฑ๋ฅ์ ๋ด๊ธฐ๋ ํฉ๋๋ค. ๋ฌผ๋ก ๋ฅ๋ฌ๋์ด ์ข์ ์ฑ๋ฅ์ ๋ผ๋๋ ์์ต๋๋ค. ๋ฌด์๋ณด๋ค๋ ์ค์ํ ๊ฒ์ ๋ฐ์ดํฐ ์ ์ฒ๋ฆฌ์ ํผ์ฒ์์ง๋์ด๋ง์ด ์ฑ๋ฅ์ ๋ ๋ง์ ์ํฅ์ ์ค๋๋ค.
์ ํ๋ฐ์ดํฐ: ๋ถ์คํ 3๋์ฅ
๋น์ ํ๋ฐ์ดํฐ: ๋ฅ๋ฌ๋
Q: standard, min-max, robust ์ค์ผ์ผ๋ง ๊ฐ๊ฐ์ ํน์ง์ ์๊ธฐํด ์ฃผ์ธ์!
A:
- Z-score (Standard) scaling์ ํ๊ท ์ 0์ผ๋ก, ํ์คํธ์ฐจ๋ฅผ 1๋ก ๋ง๋ค๊ณ ํ๊ท ์ ์ด์ฉํ์ฌ ๊ณ์ฐํ๊ธฐ ๋๋ฌธ์ ์ด์์น์ ๋ฏผ๊ฐํ์ง ์์ต๋๋ค.
- Min-Max scaler๋ ์ด๋ฆ ๊ทธ๋๋ก ์ต์๊ฐ๊ณผ ์ต๋๊ฐ์ 0๊ณผ 1๋ก ์ง์ ํฉ๋๋ค. ์ด๋ ์ ๊ท๋ถํฌ๊ฐ ์๋๊ฑฐ๋ ํ์คํธ์ฐจ๊ฐ ์์ ๋ ํจ๊ณผ์ ์ ๋๋ค. ํ์ง๋ง ์ด์์น๋ฅผ ํฌํจํ๊ณ ์๋ค๋ฉด ๋ฒ์ ์ค์ ์ ์ํฅ์ด ๊ฐ๊ธฐ ๋๋ฌธ์ ์ด์์น์ ๋ฏผ๊ฐํฉ๋๋ค.
- Robust scaler๋ ์ค์๊ฐ์ 0์ผ๋ก, ์ฌ๋ถ์ ์๋ฅผ 1๋ก ๋ง๋ค๊ณ ์ค์๊ฐ์ ์ด์ฉํ๊ธฐ ๋๋ฌธ์ ์์ ๋ ์ ๊ทํ ๋ฐฉ๋ฒ๋ค์ ๋นํด ์ด์์น์ ๊ฐํฉ๋๋ค.
๐ก standard, min-max, robust: ์ค์ผ์ผ๋ง ๋ฐ๊ฟ ๋ฟ์ด์ง ๋ถํฌ๋ ๋ณํ์ง ์์ต๋๋ค.
Q: ๋ฅ๋ฌ๋์์๋, model ์ fit ํด์ค๊ฑธ ์ history ๋ผ๊ณ ํ๋์?
A: epoch๋ฅผ ํตํด ํ์ต์ ํ๋ฉด ๊ทธ ํ์ต๊ฒฐ๊ณผ๋ฅผ ๋ก๊ทธ๋ก ์ ์ฅ์ ํด์ history๋ผ๋ API๋ช
์ ์ฌ์ฉํฉ๋๋ค.
Q: ๋ค์ค์
๋ ฅ ์ ํํ๊ท ์ฌ์ฉํ์ ๋์ ์๋ฌ๊ฐ ๋จ์ผ์
๋ ฅ DNN ์ฌ์ฉํ์ ๋์ ์๋ฌ๋ณด๋ค ๋ฎ์๋ฐ ๊ทธ๋ผ DNN์ฌ์ฉ ์ฌ๋ถ๋ณด๋ค๋ ๋ค์ค์
๋ ฅ์ธ์ง ๋จ์ผ์
๋ ฅ์ธ์ง๊ฐ ๋ ์ค์ํ๊ฑด๊ฐ์?
A: DNN์ด๋ผ๋ ์
๋ ฅ๊ฐ์ด ๋ถ์ถฉ๋ถํ๋ค๋ฉด ์ ๋๋ก ํ์ตํ๊ธฐ ์ด๋ ต๋ค๋ ๊ฒ์ ๋ณผ ์ ์์ต๋๋ค. (=๊ณผ์์ ํฉ)
Q: ๋ ์ด์ด ๊ตฌ์ฑ์ 2์ ์ ๊ณฑ๋ค๋ก๋ง ํด์ผํ๋์?
A: ๋ณดํต์ 2์ ์ ๊ณฑ์ผ๋ก ์ฌ์ฉํ๋ ํธ์ธ๋ฐ ๊ทธ๋ ๊ฒ ์ฌ์ฉํ์ง ์์๋ ์๊ด ์์ต๋๋ค.
Q: ๋๋์์ ์ฝ๋๋ ํ ์ค๋ง ์จ์ค๋ ๋ชจ๋ layer์ ์ ์ฉ ๋๋์?
A: ๋ฐ๋ก ์ ๋ ์ด์ด์๋ง ์ ์ฉ๋ฉ๋๋ค.
Q: ํญ๋ฑํจ์๋ผ๋ ๊ฐ๋
์ ์ ๋ชจ๋ฅด๊ฒ ์ต๋๋ค.
A: ์
๋ ฅ๋ฐ์ ๊ฐ์ ๊ทธ๋๋ก ์ถ๋ ฅํ๋ ํจ์์
๋๋ค.
Q: ๊ทธ๋ฌ๋ฉด ํ๊ท์ ์ถ๋ ฅ์ธต์ ํญ์ layers.Dense(units=1)์ด ํํ๊ฐ ๋๋์?
A: ๋ต
Q: ์ ๊ฒฝ๋ง ๋ชจ๋ธ ์์ฒด๊ฐ 2์ฐจ์ ๊ฒฐ๊ณผ๊ฐ ๋์ค๊ธฐ๋ก ๋ง๋ค์ด์ง๊ฑด๊ฐ์? ๊ฒฐ๊ณผ๊ฐ 2์ฐจ์์ธ๊ฒ ์กฐ๊ธ ํท๊ฐ๋ฆฌ๋ค์.
A: ์์ธก๊ฐ์ด ๊ธฐ๋ณธ์ ์ผ๋ก 2์ฐจ์์ผ๋ก ๋์ต๋๋ค. API ์์ ์ ๊ณตํ๋ ๊ธฐ๋ฅ์ด๋ผ ์ฌ์ดํท๋ฐ๊ณผ ์ฐจ์ด๊ฐ ์์ต๋๋ค. ์ฌ์ดํท๋ฐ์์ ์ ํ๋ฐ์ดํฐ๋ฅผ ์ ์ฒ๋ฆฌํ๋ ๊ธฐ๋ฅ์ ํฌํจํ๊ณ ์๋ ๊ฒ์ฒ๋ผ ํ
์ํ๋ก์์๋ ์ ํ๋ฐ์ดํฐ, ์ด๋ฏธ์ง, ํ
์คํธ ๋ฑ์ ์ ์ฒ๋ฆฌํ๋ ๊ธฐ๋ฅ๋ค๋ ํฌํจํ๊ณ ์์ต๋๋ค.