๏ปฟ
- ์ธ๊ณต์ง๋ฅ
์ธ๊ณต์ง๋ฅ์ด๋, Machine์ด โ์ธ์ -> ์ถ๋ก -> ๊ฒฐ๋ก โ ํ๋ ๊ฒ์ ๋งํฉ๋๋ค.
Narrow AI - ์ฌ๋ ๋ฏธ๋ง. ํ์ฌ ์์ค ๋จธ์ ๋ฌ๋- ๊ฒฝํ์ ํตํด ํ์ตํ์ฌ ์์ผ๋ก์ ์ผ์๋ํ ์ฑ๋ฅ์ ๋์ด๋ ๊ฒ
General AI - ์ฌ๋ ์์ค
Super AI - ์ฌ๋์ ์ง๋ฅ ์ด๊ณผํ๋ ์์ค
ํ์ฌ๋ Narrow AI์ธ๋ฐ, ์ด Narrow AI ์ฐ๊ตฌ๊ฐ๋ฐ์ โMachine Learingโ(ML, ๋จธ์ ๋ฌ๋)์ด ์ฐ์ ๋๋ค.
๋จธ์ ๋ฌ๋์ ๊ธฐ๋ฒ ์ค ํ๋์ธ, ๋๋ฅผ ๋ชจ๋ธ๋กํ โDeep Learningโ(DL, ๋ฅ๋ฌ๋)์ด ์ฐ์ด๊ณ ์์ต๋๋ค.
- ML
ML์ ๊ฒฝํ์ ํตํ ํ์ต์ผ๋ก, ์์ผ๋ก์ ๋ํ ์ผ์๋ํ ์ฒ๋ฆฌ ๊ฐ๋ฅ์ฑ์ ๋์ด๋ ๋ฐฉ๋ฒ์ ๋๋ค.
ML์ 1. ์ง๋ํ์ต, 2. ๋น์ง๋ํ์ต, 3. ๊ฐํํ์ต. 3๊ฐ์ง๋ก ๋ถ๋ฅ๋ฉ๋๋ค.
(1) ์ง๋ํ์ต
๊ธฐ์กด ํ๋ก๊ทธ๋๋ฐ ๋ฐฉ์์, โํ๋ก๊ทธ๋๋จธ๊ฐ ํ๋ก๊ทธ๋จ์ ๋ง๋ฌ. ์ฌ์ฉ์๊ฐ ๊ฐ์ ์ ๋ ฅํ๋ฉด, ํ๋ก๊ทธ๋จ ์ฒ๋ฆฌ๊ฐ์ด ์ถ๋ ฅโ
e.g. ํ๋ก๊ทธ๋๋จธ๊ฐ ๊ฐ์ ๋๋ฐฐ๋ก ๋ง๋๋ ํ๋ก๊ทธ๋จ์ ์งฐ์ ๋, ์ฌ์ฉ์๊ฐ 1์ ์ ๋ ฅํ๋ฉด, ํ๋ก๊ทธ๋จ์ 2๋ฅผ ์ถ๋ ฅํจ.
ML์ โ์ฌ์ฉ์๊ฐ ์ ๋ ฅ๊ณผ ์ถ๋ ฅ์ ์ฃผ๋ฉด, ํ๋ก๊ทธ๋จ์ด ์ ๋ ฅ๊ณผ ์ถ๋ ฅ์ ์๊ด๊ด๊ณ๋ฅผ ์ฐพ์.โ
e.g. ์ฌ์ฉ์๊ฐ ์ ๋ ฅ์ 1, ์ถ๋ ฅ์ 2๋ฅผ ์ฃผ๋ฉด, ML ํ๋ก๊ทธ๋จ์ 1์ ์ ๋ ฅํ๋ฉด ์ถ๋ ฅ์ 2๊ฐ ๋์ค๋ ๋ชจ๋ ๊ท์น์ ์ฐพ์ต๋๋ค.. ์ ๋ ฅ์ 2 ์ถ๋ ฅ์ 4, ์ ๋ ฅ์ 3 ์ถ๋ ฅ์ 6 ์ ๋ ฅ์ 4 ์ถ๋ ฅ์ 8โฆ ์ด๋ฐ์์ผ๋ก ๋ง์ ๋ฐ์ดํฐ๋ฅผ ์ฃผ๋ฉด, 2๋ฐฐ์ ๊ท์น๋ง ๋จ์ต๋๋ค.
ML์ ์ด๋ฐ์์ผ๋ก ๊ฐ์์ง ์ฌ์ง์ ๋ณด๋ฉด, ์ด๊ฒ ๊ฐ์์ง๊ตฌ๋.. ์ธ์ํ๊ณ , ์ถฉ์น X-ray๋ฅผ ๋ณด๋ฉด, ์ด๊ฒ ์ถฉ์น๊ตฌ๋โฆ ํ์ต์ ํ๊ฒ๋ฉ๋๋ค.
๋ฟ๋ง์๋๋ผ, ML์ ์ฃผ๊ฐ์์ธก, ๊ฑด๊ฐ์์ธก์๋ ์ฐ์ด๋๋ฐ์.
์ ๋ฐ๋ณ์ ์ํฅ์ ๋ผ์น๋ ๊ฒ๋ค์ ์จ๋ณธ๋ค๋ฉด, 1.๊ฐ์กฑ ๋ด ์ํ์ ์(๊ฐ์กฑ๋ด๋ ฅ) 2.์์ฃผ๋ 3.ํก์ฐ๋.
์๋ฐ๋ณ ์ ๋ฌด = (์์ ๋ผ์น๋ ์ ์ ์์ ์ํฅ๋ ฅ x ์ฌ์ฉ์์ ๊ฐ์กฑ ๋ด ์ํ์ ์) + (์์ ๋ผ์น๋ ์์ฃผ๋์ ์ํฅ๋ ฅ x ์์ฃผ๋) + (์์ ๋ผ์น๋ ํก์ฐ๋์ ์ํฅ๋ ฅ x ํก์ฐ๋) + ํ ์์ธ
์ฌ๊ธฐ์ ์ฌ์ฉ์์ ์ ๋ ฅ๊ฐ์ ์๋ฐ๋ณ์ ๋ฌด์ ๋ฐ๋ณ์ ์ํฅ์ ๋ผ์น๋ ๊ฒ๋ค์ด๊ณ , ML์ ์ด ๊ฐ๋ค์ ๋ํ ์ํฅ๋ ฅ์ ์ฐพ์๋ ๋๋ค.
์ด๋ฐ ์์ผ๋ก ์์ผ๋ก ์ ๋ฐ๋ณ ํ๋ฅ ์ ML์ ์์ธกํฉ๋๋ค. ์ ํํ ์ ์์์ ์๋์ ๊ฐ์ต๋๋ค.
H(x) = w1x1 + w2x2 + w3x3 + b(b๋ bias๋ผ๊ณ ๋ถ๋ฆ ๋๋ค.)
๊ฒฐ๊ตญ MLํ๋ค๋ ๊ฒ์, โ์ฌ์ฉ์๊ฐ x์ H(x)๊ฐ์ ์คฌ์๋, x์ b ๊ฐ์ ๊ตฌํ๋ ๊ณผ์ โ์ ๋๋ค.
์ฌ์ฉ์๊ฐ ์ ๋ ฅ๊ฐ x๋ฅผ ์คฌ์๋, ML ํ๋ก๊ทธ๋จ์์ ๊ณ์ฐํ H(x)๊ฐ๊ณผ ์ฌ์ฉ์์ ์ค์ ๊ฐ์ธ ์ถ๋ ฅ๊ฐ y๊ฐ ๋ค๋ฅผ ์ ์์์์?
๊ทธ ์ฐจ์ด ๊ฐ์ error function(์ค์ฐจ ํจ์)๋ฐฉ๋ฒ์ผ๋ก ๊ตฌํฉ๋๋ค.
์ฐ๋ฆฌ๋ ์ค์ฐจ์ ํฌ๊ธฐ๋ง ๊ณ์ฐํ ๊ฑฐ๋ผ, ์์ ๊ฐ์ ๋ณด๊ณ ์ถ์ง ์์ต๋๋ค. ๊ทธ๋์ ์ ๊ณฑํฉ๋๋ค.
๊ทธ๋ฆฌ๊ณ ์ด ์ค์ฐจ๋ค์ ํ๊ท ๊ฐ์ ๋ณด๊ธฐ์ํด, ์ค์ฐจ์ ํฉ์ ํ๊ณ , ์ค์ฐจ๊ฐ๋ค์ ๊ฐ์ m์ผ๋ก ๋๋ ์ค๋๋ค.
์ฐ๋ฆฌ๋ ML์์ ๋ง๋ ์์ y๊ฐ๊ณผ ๋น๊ตํ๊ณ , ์ค์ฐจ์ ๋ฒ์๋ฅผ ์ต์๋ก ํ ๊ฑฐ์์. 2์ฐจํจ์์์ ์ต์๊ฐ์ ๋ฏธ๋ถํ์ ๋ 0์ธ ์ง์ ์ ๋๋ค.
ํ ์ฌ๋ผ์ ์์จ์ฃผํ์๋ ์ง๋ํ์ต์ ์ผ๋ถ์ธ ๋ชจ๋ฐฉํ์ต์ด ์ฐ์์ต๋๋ค.
(2) ๋น์ง๋ํ์ต
์ ๋ ฅ๊ฐ์ ์กด์ฌํ์ง๋ง, ์ถ๋ ฅ๊ฐ์ด ์กด์ฌํ์ง ์์ต๋๋ค. ๋ฐ์ดํฐ์ ๊ตฐ์งํ๋ฅผ ํ ๋ ์ฌ์ฉ๋ฉ๋๋ค.
๋น ๋ฐ์ดํฐ ๊ฐ์ ๋ฐ์ดํฐ ์ฌ์ด์ธ์ค์์ ์ฌ์ฉ๋ฉ๋๋ค.
(3) ๊ฐํํ์ต
์ ๋ ฅ๊ฐ๋ ํ๋ก๊ทธ๋จ๋ ์ถ๋ ฅ๊ฐ๋ ์ ํด์ ธ์์ง ์์ต๋๋ค.
ํ๋ก๊ทธ๋จ์ด ์๋ฎฌ๋ ์ด์ ์ ํ๊ณ , ๊ทธ์ ๋ํ ๊ฒฐ๊ณผ๋ฅผ ๊ธฐ์ค์ ๋ฐ๋ผ ํ๊ฐํฉ๋๋ค.
๋ํ์ ์ธ ์๋ก ์ํ๊ณ ์ ๋ฐ๋์ ๋๋ค.
- DL
๋๋ฅผ ๋ชจ๋ธ๋กํ ML์ ์ผ์ข ์ ๋๋ค. ๋ค์๋งํ์ง๋ง, ์ธ๊ณต์ง๋ฅ์ด๋, Machine์ด โ์ธ์ -> ์ถ๋ก -> ๊ฒฐ๋ก โ ํ๋ ๊ฒ์ ๋งํฉ๋๋ค.
์ฐ๋ฆฌ๋ ๋ด๋ฐ์ ํตํด ์ธ์์ ํฉ๋๋ค. ๋ด๋ฐ์ ์ผ์ ๊ฐ(์ญ์น) ์ด์์ ์๊ทน์ด ๋ค์ด์ค๋ฉด, ์ฐ๋ฆฌ๊ฐ ์ธ์ํ๊ฒ ๋ฉ๋๋ค.
๋ฅ๋ฌ๋์ perceptron์ด๋ผ๋ ๋ ผ๋ฆฌ๊ฒ์ดํธ๋ฅผ ์ญ์น๊ฐ์ผ๋ก ์ฌ์ฉํฉ๋๋ค. ML์์ ๋ดค๋ ์์ธ, ์ ๋ ฅ์ ํตํด ์ถ๋ ฅ์ด w1x1 + w2x2๊ฐ์ด ์ผ์ ๊ฐ ์ด์์ด๋ผ๋ฉด, ์ธ์.
๋ฅ๋ฌ๋์ ์ด ๊ณผ์ ์ด ๋ณต์กํ๊ณ ๋ค์ํ ์๋ก ๋ ์ ํํ ์ธ์, ์ถ๋ก , ๊ฒฐ๋ก ์ ํ๊ฒ๋ฉ๋๋ค.
- ์ ๊ฒฝ๋ง ์ข ๋ฅ
ANN(Artificial Neural Network) : ์ธ๊ณต์ ๊ฒฝ๋ง์ด๋, ์ธ๊ฐ์ ๋ด๋ฐ ๊ตฌ์กฐ๋ฅผ ๋ณธ๋ ๋ง๋ ๊ธฐ๊ณํ์ต ๋ชจ๋ธ
์ธ๊ฐ์ ๋์์ ๋ด๋ฐ๋ค์ด ์ด๋ค ์ ํธ, ์๊ทน ๋ฑ์ ๋ฐ๊ณ , ๊ทธ ์๊ทน์ด ์ด๋ ํ ์๊ณ๊ฐ(threshold)์ ๋์ด์๋ฉด ๊ฒฐ๊ณผ ์ ํธ๋ฅผ ์ ๋ฌ. ์
๋ ฅ๊ณผ ์ถ๋ ฅ ์ฌ์ด๋ฅผ ์๋์ธต์ด๋ผ๊ณ ๋ถ๋ฆ.
๊ฒฐ๊ณผ๊ฐ์ ๊ด์ฐฎ์ง๋ง, ํ๋์จ์ด์ ๋ถํ๋์ด ์ปค์ ๋ฌธ์ ์์ผ๋ ์ต๊ทผ์ ๋ฐ๋์ฒด ๋ฐ๋ฌ๋ก ์ธ ์ ์๊ฒ ๋จ.
ANN์์ ์๋์ธต์ด ๊น์ด์ง ๊ฒ์ด DNN์ด๊ณ , DNN์ ์์ฉํ ์๊ณ ๋ฆฌ์ฆ์ด CNN, RNN.
DNN(Deep Neural Network)๋ผ๊ณ ํฉ๋๋ค. DNN์ ANN์์ 2๊ฐ์ด์์ธ ๋คํธ์ํฌ๋ฅผ ๋งํ๋ค.
์๊ณ ๋ฆฌ์ฆ ์ค์ค๋ก ๋ถ๋ฅํ๋ ๊ณผ์ ์ ๋ฐ๋ณตํ์ฌ ์ต์ ๋ก์ง์ ๋์ถ.
DNN์ ๊ตฌ์ฑํ๋ โ๋ด๋ฐโ์ ๋งค์ฐ ๋จ์ํ๋ โํ์ ๋ด๋ฐโ์ด๋ผ๋ ๋ชจ๋ธ์ ๊ธฐ๋ฐ์ผ๋ก ํ๊ณ ์์ผ๋ฉฐ, ๋ด๋ฐ์ด โ๋ฐํํ ์ง ์ฌ๋ถโ๋ ๋ด๋ฐ ๊ฐ์ ๊ฒฝ๋ก์ด์ ์ค์์น์ธ โ์๋
์คโ์ ๋ฌด๊ฒ ฯi์ ์ ํธ ฯi์ ์ ํ ฮฃ ฯiฯi ํฌ๊ธฐ๋ก ํ๋จํ๋ค.
๋ง์ ๋ฐ์ดํฐ์ ๋ฐ๋ณตํ์ต, ์ฌ์ ํ์ต๊ณผ ์ค๋ฅ์ญ์ ํ ๊ธฐ๋ฒ์ ํตํด ์ฐ์. ์ด๋ฅผ ์ผ์ปฌ์ด Multiply-Accumulation(MAC) ์ฐ์ฐ์ด๋ผ๊ณ ํ๋ฉฐ, ์ด ๊ณผ์ ์์ ์๊ฐ ๊ฐ๋
์ ํ์์น ์์ผ๋ฉฐ ๊ฒฐ๊ณผ๋ ์ค๋ก์ง ์
๋ ฅ์ ๊ฐ ํฌ๊ธฐ๋ก๋ถํฐ ๊ฒฐ์ ๋๋ค.
CNN(Convolution Neural Network) : ๊ธฐ์กด์ ๋ฐฉ์์ ๋ฐ์ดํฐ์์ ์ง์์ ์ถ์ถํด ํ์ต์ด ์ด๋ฃจ์ด์ก์ง๋ง, CNN์ ๋ฐ์ดํฐ์ ํน์ง์ ์ถ์ถํ์ฌ ํน์ง๋ค์ ํจํด์ ํ์
.
Convolution / Pooling์ ํตํด ์งํ. Convolution Layer์ Pooling Layer๋ฅผ ๋ณตํฉ์ ์ผ๋ก ๊ตฌ์ฑํ์ฌ ์๊ณ ๋ฆฌ์ฆ ์์ฑ.
์๋ ์ฌ์ดํธ์์ ๋งค์ฐ ์ ์ค๋ช
๋์ด์์ต๋๋ค. ๊ทธ ์ ๋ช
ํ ๊ฐ์์ง ๊ทธ๋ฆผ ๋ง์ถ๊ธฐ๋ฅผ CNN์ผ๋ก ํ๋ ๊ฒ ๊ฐ์ต๋๋ค.
https://youngq.tistory.com/40
RNN(Recurrent Neural Network) : ์์ฐจ์ ์ธ ๋ฐ์ดํฐ(Sequential data)ํ์ต์ ํนํ๋ ์ธ๊ณต์ ๊ฒฝ๋ง์ ํ ์ข
๋ฅ๋ก์จ ๋ด๋ถ์ ์ํ๊ตฌ์กฐ๊ฐ ๋ค์ด์๋ค๋ ํน์ง์ ๊ฐ์ง๊ณ ์์ต๋๋ค. ์ํ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ์ฌ ๊ณผ๊ฑฐ์ ํ์ต์ Weight๋ฅผ ํตํด ํ์ฌ ํ์ต์ ๋ฐ์.
์์ฑ์ธ์, ํ
์คํธ ๋ถ์์ ์ฐ์
๋๋ค.
SNN(Spiking Neural Network) : Spiking์ โ๋ด๋ฐโ ๊ฐ ์ฃผ๊ณ ๋ฐ๋ ์ ํธ์ ํํ์ด ์คํ์ดํฌ, ๋ค์ ๋งํด ์นจ ํํ์ ๋๊ธฐ์ ๊ฐ์ ํํ์ด๊ธฐ ๋๋ฌธ์ ๋ถ์ฌ์ก๋ค. ์ ํธ์ ๊ฐ์ฝ์ ์ ํธ์ ํฌ๊ธฐ๋ ์งํญ์ด ์๋ ๋น๋์ ๋ง๊ณ ์ ์, ์ ๋์ , ์๋์ ํ์ด๋ฐ ๋ฑ์ผ๋ก ํํ๋๋ค. ์์ฒด์ ๋ด๋ฐ์ด ์ค์ ๋ก ์ด์ ๊ฐ์ ์คํ์ดํฌ ์ ํธ๋ฅผ ์ด์ฉํ๋ ๊ฒ์ ๋ชจ๋ฐฉํ ๊ฒ์ด๋ค. ๊ทธ ๊ฒฐ๊ณผ, SNN์ ๊ตฌํํ ๋ฐ๋์ฒด ํ๋ก๋ โ๋ํ(Neuromorphic)โ์ด๋ผ๊ณ ๋ถ๋ฆฌ๋ ๊ฒฝ์ฐ๋ ๋ง๋ค.
Q1 : ์ด๋ก ์ ๋์๋๋ฐ, ๊ทธ๋์ ์ ์์จ์ฃผํ๋ ๋ชปํด?
(1) ์ธ๊ณต์ง๋ฅ์ ๋ง๋ค๋ ค๋ฉด, ์๋ง์ ๋ฐ์ดํฐ๊ฐ ํ์ํฉ๋๋ค. ์์ง ๋ฐ์ดํฐ๊ฐ ๋ถ์กฑํฉ๋๋ค.
(2) ์์จ์ฃผํ์ค์๋ โ์ธ์, ์ถ๋ก , ๊ฒฐ๋ก โ์ ๊ณผ์ ์ ๊ณ์ ๋น ๋ฅด๊ฒ ํด์ผํ๋๋ฐ, ํ์ฌ ๊ทธ๋งํผ ๋น ๋ฅธ ๋ฐ๋์ฒด๊ฐ ์์ต๋๋ค.
1์์ ํ ์คํธ ์ฐจ๋์ ๋๋ฆฌ๋ ๋ฐฉ๋ฒ์ผ๋ก ํด๊ฒฐํ ์ ์์ต๋๋ค.
2์์ด ํฐ ๋ฌธ์ ์ ๋๋ค.
CPU -> GPU -> FGPA (ํ์ฌ) -> ASIC -> ๋ด๋ก๋ชจํฝ ASIC ์์ผ๋ก ๋ฐ์ ํ ๊ฒ์ผ๋ก ์์๋ฉ๋๋ค.
(AI ASIC์ ์ต์ CPU์ 1000๋ฐฐ ์ ๋ ์ ๋ ฅํจ์จ์ ๋ผ ๊ฒ์ผ๋ก ETRI(ํ๊ตญ์ ์ํต์ ์ฐ๊ตฌ์)์ [AI ๋ฐ๋์ฒด ์์ฅ ๋ํฅ ๋ฐ ์ฐ๋ฆฌ๋๋ผ ๊ฒฝ์๋ ฅ ๋ถ์]์ ์ธ์ฉ๋์์ต๋๋ค.)
Q2 : ํ๊ตญ์ ๋ฐ๋์ฒด ๊ฐ๊ตญ์ธ๋ฐ, ์ธ๊ณต์ง๋ฅ ๋ฐ๋์ฒดํ๋ฉด ๋๋ฐ ์๋์ผ?
์ฐ๋ฆฌ๋๋ผ๋ ์ธ๊ณ 3์๊ถ ์ด๋ด์ ๋ฐ๋์ฒด ์ ์กฐ๊ฐ๊ตญ์ด์ง๋ง, ๋ฏธ๊ตญ์ด๋ ์ค๊ตญ, ๋๋ง์ ๋นํด ์ ์ ์ ๋ถ ํฌ์์ ๋ฉ๋ชจ๋ฆฌ ๋ฐ๋์ฒด ์ด์ธ์ ๋ฐ๋์ฒด๋ ๊ธฐ์ ์ธ๋ ฅ๊ณผ ๋ถ์กฑํฉ๋๋ค.
Q3 : ์ด๋ฐ AI ๊ธฐ์ ์ ์ต๊ทผ ์ฐ๊ตฌ๊ฐ ์์๋๊ฑฐ์ผ?
์ต๊ทผ์ SNN๋ฐ๋์ฒด๊ฐ ๊ฐ์ฅ ํซํ ๊ฒ ๊ฐ์ต๋๋ค. 2020๋
์ธํ
์ด ๋ฐํํ Pohoiki Springs๋ ์ฅ์ ๋๋ ์์ค์ด๋ผ๊ณ ํ๋๋ฐ,
2000๋
๋์ ๋ฐ๋์ฒด ๊ณต์ , ์ค๊ณ ๋ฅ๋ ฅ์ผ๋ก๋ ๊ฐ๊ตฌ๋ฆฌ์ ์์ค ์ด์ ๋ง๋ค๊ธฐ ์ด๋ ค์ ๋ค๊ณ ํฉ๋๋ค.
SNN์ 1990๋
๋์ ๋ฐํ๋์์ต๋๋ค.