21 Wed
๋ฅ๋ฌ๋ CNN ์๋ฒฝ ๊ฐ์ด๋ - Fundamental ํธ
๊ฒฝ์ฌํ๊ฐ๋ฒ์ ์ดํด
ํน์ง์ด ๋ง์ ์๋ก ๊ฐ์ค์น์ ๊ฐ์๊ฐ ๋์ด๋๊ฒ ๋๋ค.
๊ฐ์ค์น์ ๊ฐ์๊ฐ ๋์ด๋๋ฉด ๊ณ ์ฐจ์ ๋ฐฉ์ ์์ผ๋ก ๋น์ฉ ํจ์๊ฐ ์ต์๊ฐ ๋๋ ๊ฐ์ค์น W๋ฅผ ์ฐพ๊ธฐ๊ฐ ์ด๋ ค์์ง๋ค.
๊ณ ์ฐจ์ ๋ฐฉ์ ์์ ๋ํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ฉด์ RSS๋ฅผ ์ต์ํํ๋ ๋ฐฉ๋ฒ์ ์ง๊ด์ ์ผ๋ก ์ ๊ณตํ๋ ๋ฐ์ด๋ ๋ฐฉ์
์์คํจ์์ ํธ๋ฏธ๋ถ
W์ ๋ํด์ ๋ชจ๋ ํญ์ ๋ฏธ๋ถํ ์ ์๊ธฐ ๋๋ฌธ์ ๊ฐ W์ ๋ํ ๋ฏธ๋ถ์ ํ๊ฒ ๋๋ค.
๊ฐ์ค์น์ ์ ํธ
๊ฐ์ค์น์ ์ ํธ์ ์์ค ํจ์์ ํธ๋ฏธ๋ถ ๊ฐ์ ๊ฐฑ์ ํ๋ฉด์ ๊ฐฑ์ ๋๋ค.
์ด ๋ ์ผ์ ํ ๊ณ์๋ฅผ ๊ณฑํด์ ๊ฐฑ์ ๋๋๋ฐ ์ด ๊ณ์๋ฅผ ํ์ต๋ฅ ์ด๋ผ๊ณ ํ๋ค.
๊ฒฝ์ฌํ๊ฐ๋ฒ์ ์ด์ฉํ์ฌ ์ ํํ๊ท ๊ตฌํํ๊ธฐ - 01
# ๋ฐ์ดํฐ ๊ฑด์
N = len(target)
# ์์ธก ๊ฐ.
predicted = w1 * rm + w2*lstat + bias
# ์ค์ ๊ฐ๊ณผ ์์ธก๊ฐ์ ์ฐจ์ด
diff = target - predicted
# bias ๋ฅผ array ๊ธฐ๋ฐ์ผ๋ก ๊ตฌํ๊ธฐ ์ํด์ ์ค์ .
bias_factors = np.ones((N,))
# weight์ bias๋ฅผ ์ผ๋ง๋ updateํ ๊ฒ์ธ์ง๋ฅผ ๊ณ์ฐ.
w1_update = -(2/N)*learning_rate*(np.dot(rm.T, diff))
w2_update = -(2/N)*learning_rate*(np.dot(lstat.T, diff))
bias_update = -(2/N)*learning_rate*(np.dot(bias_factors.T, diff))
# Mean Squared Error๊ฐ์ ๊ณ์ฐ.
mse_loss = np.mean(np.square(diff))
๊ฒฝ์ฌํ๊ฐ๋ฒ์ ์ด์ฉํ์ฌ ์ ํํ๊ท ๊ตฌํํ๊ธฐ - 02
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
scaled_features = scaler.fit_transform(bostonDF[['RM', 'LSTAT']])
์ฌ์ดํท๋ฐ์ minmax์ค์นผ๋ผ๋ฅผ ์ด์ฉํ๋ฉด ๋ฐ์ดํฐ์ ๊ฐ์ 0์์ 1 ์ฌ์ด๋ก ์ ๊ทํํ ์ ์๋ค.
from tensorflow.keras.layers import Dense
from tensorflow.keras.models import Sequential
from tensorflow.keras.optimizers import Adam
model = Sequential([
# ๋จ ํ๋์ units ์ค์ . input_shape๋ 2์ฐจ์, ํ๊ท์ด๋ฏ๋ก activation์ ์ค์ ํ์ง ์์.
# weight์ bias ์ด๊ธฐํ๋ kernel_inbitializer์ bias_initializer๋ฅผ ์ด์ฉ.
Dense(1, input_shape=(2, ), activation=None, kernel_initializer='zeros', bias_initializer='ones')
])
# Adam optimizer๋ฅผ ์ด์ฉํ๊ณ Loss ํจ์๋ Mean Squared Error, ์ฑ๋ฅ ์ธก์ ์ญ์ MSE๋ฅผ ์ด์ฉํ์ฌ ํ์ต ์ํ.
model.compile(optimizer=Adam(learning_rate=0.01), loss='mse', metrics=['mse'])
model.fit(scaled_features, bostonDF['PRICE'].values, epochs=1000)
์ผ๋ผ์ค ๋ชจ๋์ ์ด์ฉํ๋ฉด ๋ชจ๋ธ ๊ตฌ์ฑ์ ํ์ํ ํ๊ฒฝ๋ค์ ํ๋ฒ์ ๊ตฌ์ฑํ ์ ์๋ค.
ํ๋ฅ ์ ๊ฒฝ์ฌํ๊ฐ๋ฒ๊ณผ ๋ฏธ๋๋ฐฐ์น ๊ฒฝ์ฌํ๊ฐ๋ฒ์ ์ดํด
GD, Gradient Descent
์ ์ฒด ํ์ต ๋ฐ์ดํฐ๋ฅผ ๊ธฐ๋ฐ
SGD, Stochastic GD
์ ์ฒด ํ์ต ๋ฐ์ดํฐ ์ค ํ ๊ฑด๋ง ์์๋ก ์ ํ
๋งค์ฐ ํฐ ๋ฐ์ดํฐ ์ค ํ๋๋ง ํํ๊ธฐ ๋๋ฌธ์ ์์ํ ์ ์์ง๋ง ์์ธ๋ก ์กฐ๊ธ์ ์ฑ๋ฅ์ด ๋์จ๋ค.
Mini - Batch GD
์ ์ฒด ํ์ต ๋ฐ์ดํฐ ์ค ํน์ ํฌ๊ธฐ ๋งํผ ์์๋ก ์ ํ
ํ๋ฅ ์ ๊ฒฝ์ฌํ๊ฐ๋ฒ ๊ตฌํํ๊ธฐ
batch_indexes = np.random.choice(target.shape[0], batch_size)
np.random.choice
๋ ๋ฌด์์๋ก ์ผ์ ํฌ๊ธฐ๋งํผ ์ ํํ๋ ํจ์์ด ๋
batch_size
๊ฐ 1์ด๋ฉด SGD, 2 ์ด์์ด๋ฉด Mini - Batch ์ด๋ค.
๋ฏธ๋ ๋ฐฐ์น ๊ฒฝ์ฌํ๊ฐ๋ฒ ๊ตฌํํ๊ธฐ
์ถ๊ฐ์ ์ผ๋ก BATCH_SIZE ๋งํผ์ ์ง์ ํด์ฃผ๋ ๊ฒ ์ด์ธ์๋ ํ๋ฅ ์ ๊ฒฝ์ฌํ๊ฐ๋ฒ๊ณผ ์ฐจ์ด๊ฐ ์๋ค
Keras๋ ๋ฐ๋์ ๋ฏธ๋ ๋ฐฐ์น ๊ฒฝ์ฌํ๊ฐ๋ฒ์ ์ ์ฉํ๋ฉฐ ๊ธฐ๋ณธ ๋ฐฐ์น ์ฌ์ด์ฆ๋ 32์ด๋ค.
๊ฒฝ์ฌํ๊ฐ๋ฒ์ ์ฃผ์ ๋ฌธ์
Learning Rate
๋๋ฌด ์์ผ๋ฉด ์๋ ดํ๋๋ฐ ์ค๋ ์๊ฐ์ด ๊ฑธ๋ฆผ
๋๋ฌด ํฌ๋ฉด ์ฐพ์ง ๋ชปํ๊ฑฐ๋ ๋ฐ์ฐ๋จ
์ ์ญ ์ต์์ , ๊ตญ์ ์ต์์
๋ชจ๋ ๋น์ฉ ํจ์๊ฐ Convex์ ๊ฐ์ ์ด์์ ์ธ ํจ์๊ฐ ๋์ง ์์
Last updated
Was this helpful?