3๊ฐ ์์ฝ
ํจ์ F๋ก classifier(network) ์ ์ (x : input data, W : weights, ์ถ๋ ฅ : score vector)
Loss function ์ผ๋ก ์ฐ๋ฆฌ์ ํจ์ F๊ฐ ์ผ๋ง๋ ์ฑ๋ฅ์ด ์์ข์์ง ํ์ธ (e.g. SVM, BCE ๋ฑ...)
ํจ์ F๊ฐ training dataset์๋ง fit ํ๋ ๊ฒ์ ๋ฐฉ์งํ๊ธฐ ์ํด(์ฐ๋ฆฌ์ ๋ชฉํ๋ test dataset) Regularization term ์ถ๊ฐ
Loss๊ฐ ๊ฐ์ฅ ๋ฎ์์ง๋ W๋ฅผ ์ฐพ๊ณ ์ Gradient Descent ํ์ฉ
Computational graphs
์ฐ๋ฆฌ๋ ์ต์ข ์ ์ผ๋ก gradient ๊ฐ์ ์๋์ผ๋ก ๊ณ์ฐํ๊ธฐ ์ํด analytic gradient๋ฅผ ์ฌ์ฉํ ๊ฒ์ด๋ค.
Computational graph ๋ฅผ ํ์ฉํ์ฌ analytic gradient ๊ณ์ฐ ๋จ๊ณ๋ฅผ ํ์ธํด๋ณด์.
์์ ๊ทธ๋ํ์์ ๊ฐ ๋ ธ๋๋ ์ฐ์ฐ ๋จ๊ณ๋ฅผ ์๋ฏธํ๋ค.
Computational Graph๋ฅผ ์ฌ์ฉํด์ backpropagation ๊ณผ์ ์ ๋ณด๋ฉด, gradient๋ฅผ ์ป๊ธฐ ์ํด graph ๋ด๋ถ์ ๋ชจ๋ ๋ณ์์ ๋ํด chain rule์ ์ฌ๊ท์ ์ผ๋ก ์ฌ์ฉํ๊ฒ ๋๋ค.
์๋ ์์์์ ๋ฌด์จ ์๋ฏธ์ธ์ง ํ์ธํด๋ณด๋๋ก ํ์
Backpropagation: a simple example
์์ ์์์์ x, y, z๊ฐ ์ ๋ ฅ์ผ๋ก ๋ค์ด์ค๊ณ ์ค๊ฐ ๋ ธ๋๋ค์์ ๊ณ์ฐ์ด ์ด๋ฃจ์ด์ง๋ค.
์ต์ข ๊ฒฐ๊ณผ๊ฐ์ธ f์ output์ -12๊ฐ ๋๋๋ฐ, ์ด -12๊ฐ loss์ ๋ฏธ์น๋ ์ํฅ(๋ฏธ๋ถ๊ฐ)์ 1์ด๋ค.
์ด์ backpropagation์์ chain rule์ ์ ์ฉํด๊ฐ๋ฉฐ ๊ฐ ์ค๊ฐ ๋จ๊ณ์์์ ๋ฏธ๋ถ๊ฐ์ ๊ตฌํ ์ ์๋ค.
์ค๊ฐ ๊ฐ์ ๋ฏธ๋ถ๊ฐ์ ๊ฐ ์์๊ฐ ์ต์ข loss์ ์ผ๋งํผ์ ์ํฅ์ ๋ฏธ์น๋์ง๋ผ๊ณ ์๊ฐํด ๋ณผ ์ ์๋ค.
์ฐ๋ฆฌ๋ ๊ฐ ๋ ธ๋์ ๊ฐ ๋ ธ๋์ local ์ ๋ ฅ์ ๋ํด์๋ง ์๊ณ ์๋ค.
์์์ local ์ ๋ ฅ์ x, y์ด๊ณ ์ถ๋ ฅ์ z์ด๋ค.
์ฐ๋ฆฌ๋ ์ด๋ฅผ ํตํด local gradient๋ฅผ ๊ตฌํ ์ ์๋ค.
โญ ๋ค์ ์ ๋ฆฌ
Backpropagation ๊ณผ์ ์์ local gradient์ upstream gradient๋ฅผ ๊ณฑํ๋ ์ด์ ๋ ์ฐ์ ๋ฒ์น(Chain Rule) ๋๋ฌธ์ด๋ค.
์ฐ์ ๋ฒ์น์ ๋ฐ๋ฅด๋ฉด, ํจ์ ๊ฐ ์๊ณ ์ธ ๊ฒฝ์ฐ, ์ ๋ํ ์ ๋ฏธ๋ถ์ ๋ค์๊ณผ ๊ฐ์ด ๋ํ๋ผ ์ ์๋ค.
์ฌ๊ธฐ์ ์ด๋ค.
๋ฅ๋ฌ๋์์๋ ์์ค ํจ์๋ฅผ ๊ฐ ์ธต์ ํ๋ผ๋ฏธํฐ๋ก ๋ฏธ๋ถํ ๋ backpropagation์ ์ฐ์ ๋ฒ์น์ ์ฌ์ฉํ์ฌ ๊ฐ ์ธต์ ๊ทธ๋๋์ธํธ๋ฅผ ๊ณ์ฐํ๋ค.
- "Local gradient" : ํ์ฌ ์ธต์ ํ์ฑํ ํจ์์ ๋ฏธ๋ถ.
์ ๋ ฅ์ ๋ํ ์ถ๋ ฅ์ ๋ฏธ์ธํ ๋ณํ์ ๋ํ ์ธต ๋ด์ ๋ณํ๋ฅผ ์ธก์ - "Upstream gradient"๋ ํ์ฌ ์ธต ์ดํ์ ์ธต์์ ์ ๋ฌ๋ ๊ทธ๋๋์ธํธ.
์ดํ ๋ค์ ์ธต์์ ์์ค ํจ์์ ๊ทธ๋๋์ธํธ๊ฐ ํ์ฌ ์ธต์ ์ถ๋ ฅ์ ์ด๋ป๊ฒ ์ํฅ์ ๋ฏธ์น๋์ง๋ฅผ ์ธก์ .
๋ฐ๋ผ์ ์ด ๋ ๊ทธ๋๋์ธํธ๋ฅผ ๊ณฑํจ์ผ๋ก์จ, ํ์ฌ ์ธต์ ๊ฐ์ค์น์ ํธํฅ์ ๋ํ ์์ค ํจ์์ ๊ทธ๋๋์ธํธ๋ฅผ ํจ๊ณผ์ ์ผ๋ก ๊ณ์ฐํ ์ ์๊ฒ ๋๋ ๊ฒ์ด๋ค.
add gate๋ local gradient๊ฐ 1์ด๊ธฐ์ ๊ฐ์ gradient๋ฅผ ๋ฐ์ผ๋ฏ๋ก gradient distributor๋ก
max gate๋ ๋ ์ค ํ๋๋ฅผ ์ ํํ๋ฏ๋ก gradient router๋ก,
mul gate๋ ์๋ก์ ๊ฐ์ผ๋ก ๋ถํฐ ์ํฅ์ ๋ฐ์ผ๋ฏ๋ก gradient swithcer๋ผ๊ณ ์๊ฐํ ์ ์๋ค.
์ฌ๋ฌ ๋ ธ๋์ ์ฐ๊ฒฐ๋ ํ๋์ ๋ ธ๋๊ฐ ์๋ค๊ณ ๊ฐ์ ํด๋ณด์.
์ด๋๋ upstream gradient ๊ฐ๋ค์ ํฉํด์ ํ๋์ ๋ ธ๋์์ ๋ฐ๊ฒ ๋๋ค.
์์์๋ ์ค์นผ๋ผ๋ง ๋ค๋ค๋๋ฐ x, y, z๊ฐ ๋ฒกํฐ๋ผ๋ฉด ์ด๋ป๊ฒ ํด์ผ๋ ๊น?
=> ์์์ ํ ๊ฒ๊ณผ ๋์ผํ๋ค.
๋ค๋ง gradient๊ฐ Jacobian ํ๋ ฌ์ด ๋๋ค. (๊ฐ ์์์ ๋ฏธ๋ถ์ ํฌํจํ๋ ํ๋ ฌ)
ex) x์ ๊ฐ ์์์ ๋ํด z์ ๋ํ ๋ฏธ๋ถ์ ํฌํจํ๋
4096์ฐจ์์ ๋ฒกํฐ ์ ๋ ฅ์ ๋ฐ๋๋ค๊ณ ๊ฐ์ ํ์.
์์ ํ์ ๋ฐ์ค(๋ ธ๋)๋ ๋ฒกํฐ์ ๊ฐ ์์์ 0์ ๋น๊ตํด์ ์ต๋๊ฐ์ ๋ฐํํ๋ค.
์ด๋ ๊ฒ ๋๋ฉด ์ถ๋ ฅ๊ฐ์ 4096์ฐจ์์ ๋ฒกํฐ๊ฐ ๋๋ค.
๊ทธ๋ ๋ค๋ฉด ์์์ Jacobian matrix์ ์ฌ์ด์ฆ๋ ๋ช์ด ๋ ๊น?
Jacobian ํ๋ ฌ์ ๊ฐ ํ์ ์ ๋ ฅ์ ๋ํ ์ถ๋ ฅ์ ํธ๋ฏธ๋ถ์ด ๋๋ค.
=> (4096)^2 ๊ฐ ๋๋ค.
Q: what is the size of the Jacobian matrix? [4096 x 4096!]
A: in practice, we process an entire minibatch (e.g. 100) of examples at one time:
i.e. Jacobian would technically be a [409,600 x 409,600] matrix :\
Q2: what does it look like?
max(0,x)์์ ์ด๋ค ์ผ์ด ์ผ์ด๋๋์ง ์๊ฐํด๋ณด์.
์ด๋ ํธ๋ฏธ๋ถ์ ๋ํด ์๊ฐํด ๋ณผ ์ ์๋ค.
์ ๋ ฅ์ ์ด๋ค ์ฐจ์์ด ์ถ๋ ฅ์ ์ด๋ค ์ฐจ์์ ์ํฅ์ ์ค๊น?
Jacobian ํ๋ ฌ์์ ์ด๋ค ์ข ๋ฅ์ ๊ตฌ์กฐ๋ฅผ ๋ณผ ์ ์๋? --> ๋๊ฐ์
์ ๋ ฅ์ ๊ฐ ์์, ์ฒซ ๋ฒ์งธ ์ฐจ์์ ์ค์ง ์ถ๋ ฅ์ ํด๋น ์์์๋ง ์ํฅ์ ์ค๋ค.
๋ฐ๋ผ์ ์ฐ๋ฆฌ์ Jacobian ํ๋ ฌ์ ๋๊ฐํ๋ ฌ์ด ๋ ๊ฒ์ด๋ค.
ํ์ง๋ง Jacobian ํ๋ ฌ์ ์์ฑํ๊ณ ๊ณต์ํํ ํ์๋ ์๋ค.
์ฐ๋ฆฌ๋ ์ถ๋ ฅ์ ๋ํ x์ ์ํฅ์ ๋ํด์ ๊ทธ๋ฆฌ๊ณ ์ด ๊ฐ์ ์ฌ์ฉํ๋ค๋ ๊ฒ๊ณผ
์ฐ๋ฆฌ๊ฐ ๊ณ์ฐํ gradient์ ๊ฐ์ ์ฑ์ ๋ฃ๋๋ค๋ ์ฌ์ค๋ง ์๋ฉด ๋๋ค.
- Neural networks๋ ๋ณดํต ๋งค์ฐ ํฌ๊ธฐ์ ๋ชจ๋ ํ๋ผ๋ฏธํฐ์ ๋ํ ๋ฏธ๋ถ๊ฐ์ ์ง์ ๊ณ์ฐํ๋ ๊ฒ์ ๊ฑฐ์ ๋ถ๊ฐ๋ฅํ๋ค.
- Backpropagation์ ๋ชจ๋ ์ ๋ ฅ/ํ๋ผ๋ฏธํฐ/์ค๊ฐ ๋จ๊ณ์ ๋ฏธ๋ถ๊ฐ์ ๊ณ์ฐํ๊ธฐ ์ํด computational graph์์ chain rule์ ์ฌ๊ท์ ์ผ๋ก ์ ์ฉํ๋ ๊ฒ์ด๋ค.
- forward : ์ฐ์ฐ ๊ฒฐ๊ณผ๋ฅผ ๊ณ์ฐํ๊ณ gradient ๊ณ์ฐ์ ์ํด ํ์ํ ์ค๊ฐ ๊ฐ๋ค์ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅํ๋ค.
- backward : ์ ๋ ฅ์ด loss function์ ๋ฏธ์น๋ ๋ฏธ๋ถ๊ฐ์ ๊ณ์ฐํ๊ธฐ ์ํด chain rule์ ์ ์ฉํ๋ค.
Neural Networks
Neural Networks
์ ๊ฒฝ๋ง์ ํจ์๋ค์ ์งํฉ(class)์ผ๋ก
๋น์ ํ์ ๋ณต์กํ ํจ์๋ฅผ ๋ง๋ค๊ธฐ ์ํด์ ๊ฐ๋จํ ํจ์๋ค์ ๊ณ์ธต์ ์ผ๋ก ์ฌ๋ฌ๊ฐ ์์์ฌ๋ฆฌ๋ ํํ์ด๋ค.
์ธํฌ์ฒด(cell body)๋ ๋ค์ด์ค๋ ์ ํธ(input)์ ์ข ํฉํ์ฌ ์ถ์ญ(axon)์ ํตํด ๋ค์ ์ธํฌ์ฒด์ ์ ๋ฌํ๋ค.
์ด๋ ์์์ ์ดํด๋ณธ computational node์ ๋์๊ณผ ๋น์ทํ๋ค.
๋ด๋ฐ์ ์ด์ฐ spike ์ข ๋ฅ๋ฅผ ์ฌ์ฉํด์ ์ ํธ๋ฅผ ์ ๋ฌํ๋๋ฐ ์ด๋ ํ์ฑํํจ์์ ์ ์ฌํ ์ญํ ์ ํ๋ค๊ณ ๋ณผ ์ ์๋ค.
์ฌ์ค ๋ด๋ฐ์ ์ฐ๋ฆฌ๊ฐ ์๊ฐํ๋ ๊ฒ๋ณด๋ค ํจ์ฌ ๋ณต์กํ๊ฒ ๋์ํ๋ค.
๋จ์ํ w0์ฒ๋ผ ๋จ์ผ ๊ฐ์ค์น๋ฅผ ๊ฐ์ง์ง ์๊ณ ๋ณต์กํ ๋น์ ํ ์์คํ ์ ๊ฐ๋๋ค.
์ผ์ชฝ๊ณผ ๊ฐ์ 2๋ ์ด์ด ์ ๊ฒฝ๋ง์ ๋ ๊ฐ์ ์ ํ ๋ ์ด์ด๋ฅผ ๊ฐ์ง๊ณ ์๋ ๊ฒ์ผ๋ก
ํ๋์ ํ๋ ๋ ์ด์ด๋ฅผ ๊ฐ์ง ๋คํธ์ํฌ๋ผ๊ณ ๋ณผ ์ ์๋ค.
Example feed-forward computation of a neural network
class Neuron :
def neuron_tick(inputs):
#assume inputs ans weights are 1-D numpy arrays and bias is a number
cell_body_sum = np.sum(inputs * self.weights) + self.bias
firing_rate = 1/0 / (1.0 + math.exp(-cell_body_sum)) #sigmoid
return firing_rate
We can efficiently evaluate an entire layer of neurons
Summary
- We arrange neurons into fully-connected layers
- The abstraction of a layer has the nice property that it allows us to use efficient vectorized code (e.g. matrix multiplies)
- Neural networks are not really neural
- Next time: Convolutional Neural Networks
'์ธ๊ณต์ง๋ฅ ๐ > CS231n' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
CS231n 5๊ฐ Convolutional Neural Networks (0) | 2024.03.20 |
---|---|
CS231n 3๊ฐ Loss Functions and Optimization (1) | 2024.03.07 |
CS231n 2๊ฐ Image Classification Pipeline (0) | 2024.03.07 |