* ์ด ํฌ์ŠคํŒ…์€ ์•„๋ž˜ ์›๋ฌธ์„ ๋ฒˆ์—ญํ•œ ํฌ์ŠคํŒ…์ž…๋‹ˆ๋‹ค. ํฌ์ŠคํŒ…์˜ ๊ฒŒ์‹œ ์‹œ์ ๊ณผ ๋ฒˆ์—ญ ์‹œ์ ์ด ์ผ์น˜ํ•˜์ง€ ์•Š์Œ์„ ์‚ฌ์ „์— ๋ฐํž™๋‹ˆ๋‹ค.
์›๋ฌธ: Introducing deep learning and long-short term memory networks https://www.ibm.com/developerworks/analytics/library/iot-deep-learning-anomaly-detection-1/index.html

* ๋ณธ ํฌ์ŠคํŒ…์€ ๋”ฅ๋Ÿฌ๋‹์˜ ํŠน์ˆ˜์„ฑ์— ๊ธฐ์ธํ•˜์—ฌ ๊ธฐ์ˆ  ์šฉ์–ด์— ํ•œํ•ด์„œ ์˜๋ฌธํ‘œ๊ธฐ๋ฅผ ๊ทธ๋Œ€๋กœ ๋”ฐ๋ž์Šต๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด ‘long-short term memory networks’๋ฅผ ‘์žฅ๊ธฐ-๋‹จ๊ธฐ ๋ฉ”๋ชจ๋ฆฌ ๋„คํŠธ์›Œํฌ’๋กœ ํ‘œ๊ธฐํ•˜์ง€ ์•Š์•˜์Šต๋‹ˆ๋‹ค.

Content series:
‘๋”ฅ๋Ÿฌ๋‹๊ณผ LSTM ๋„คํŠธ์›Œํฌ ์†Œ๊ฐœ’๋Š” ‘๋”ฅ๋Ÿฌ๋‹์„ ์‚ฌ์šฉํ•œ IoT ์‹œ๊ณ„์—ด ๋ฐ์ดํ„ฐ์˜ ์ด์ƒ ๊ฒ€์ถœ’์˜ ์—ฐ์žฌ ํฌ์ŠคํŒ… ์ค‘ ์ฒซ๋ฒˆ์งธ ํฌ์ŠคํŒ…์ž…๋‹ˆ๋‹ค. ๋ณธ ์—ฐ์žฌ ํฌ์ŠคํŒ…์€ ์ด 5๊ฐœ์˜ ํฌ์ŠคํŒ…์œผ๋กœ ๊ตฌ์„ฑ๋˜์–ด ์žˆ์Šต๋‹ˆ๋‹ค.

์˜ˆ์ธก์—๋Š” ํ•ญ์ƒ ๋…ผ๋ž€์˜ ์—ฌ์ง€๊ฐ€ ์žˆ์ง€๋งŒ ๊ฐ€ํŠธ๋„ˆ๋Š” 2017๋…„์— ์Šค๋งˆํŠธ ํฐ์„ ์ œ์™ธํ•œ 84์–ต๊ฐœ์˜ ์—ฐ๊ฒฐ๋œ IoT ์žฅ์น˜๊ฐ€ ์žˆ๋‹ค๊ณ  ๋งํ–ˆ์Šต๋‹ˆ๋‹ค. ์ด์—, ์ผ๋ถ€ ๋ถ„์„๊ฐ€๋“ค์€ 2020๋…„๊นŒ์ง€ ๊ทธ ์ˆซ์ž๊ฐ€ 500์–ต๊ฐœ๊ฐ€ ๋  ๊ฒƒ์ด๋ผ๊ณ ๋„ ๋งํ•ฉ๋‹ˆ๋‹ค. ๋น„๋ก ๊ทธ ์ˆซ์ž๊ฐ€ ๊ณผ๋Œ€ ํ‰๊ฐ€ ๋˜์—ˆ๋‹ค ํ•˜๋”๋ผ๋„ ์กฐ๋งŒ๊ฐ„ IoT ๊ธฐ๊ธฐ์˜ ์ˆ˜๋Š” ์ง€๊ตฌ์ƒ์—์žˆ๋Š” ์‚ฌ๋žŒ์˜ ์ˆ˜๋ฅผ ์ดˆ๊ณผ ํ•  ๊ฒƒ์ž…๋‹ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ์ด ๋ชจ๋“  IoT ๊ธฐ๊ธฐ๋“ค์ด ์ง€์†์ ์œผ๋กœ ๋ฐ์ดํ„ฐ๋ฅผ ์ƒ์„ฑํ•˜๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค; ๋น„๋ก ๋งŽ์€ ๋ฐ์ดํ„ฐ๊ฐ€ ์ƒ์„ฑ๋˜์—ˆ์œผ๋‚˜ ๋งŒ์ผ ๋ถ„์„ํ•  ์ˆ˜ ์—†๋‹ค๋ฉด ์“ธ๋ชจ์—†์„ ๊ฒƒ์ž…๋‹ˆ๋‹ค.

์ฝ”๊ทธ๋„ˆํ‹ฐ๋ธŒ ์‹œ์Šคํ…œ์€ ์ธ๊ณต ์ง€๋Šฅ(AI), ์ž์—ฐ์–ด ์ฒ˜๋ฆฌ, ๋จธ์‹ ๋Ÿฌ๋‹ ๋ฐ ๊ณ ๊ธ‰ ๋จธ์‹ ๋Ÿฌ๋‹ ๊ธฐ๋ฒ•๊ณผ ๊ฐ™์€ ์ผ๋ จ์˜ ๊ธฐ๋Šฅ์„ ์ œ๊ณตํ•˜์—ฌ ๋ชจ๋“  ๋ฐ์ดํ„ฐ๋ฅผ ๋ถ„์„ํ•˜๋Š”๋ฐ ๋„์›€์„ ์ค๋‹ˆ๋‹ค. ๋˜ํ•œ ์ฝ”๊ทธ๋„ˆํ‹ฐ๋ธŒ ์‹œ์Šคํ…œ์€ ์ธ๊ฐ„๊ณผ ์ž์—ฐ์Šค๋Ÿฝ๊ฒŒ ๋ฐฐ์šฐ๊ณ  ์ƒํ˜ธ ์ž‘์šฉํ•˜์—ฌ ๋ฐ์ดํ„ฐ๋กœ๋ถ€ํ„ฐ ํ†ต์ฐฐ๋ ฅ์„ ์ˆ˜์ง‘ํ•˜๊ณ  ๋” ๋‚˜์€ ๊ฒฐ์ •์„ ๋‚ด๋ฆฌ๋Š” ๋ฐ ๋„์›€์„ ์ค„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ง€๋‚œ ๊ธฐ์‚ฌ์—์„œ ์ €๋Š” ์ธ์ง€ ์ปดํ“จํŒ…์ด ๋‹จ์ˆœํ•œ ์ธ๊ฐ„-์ปดํ“จํ„ฐ ์ƒํ˜ธ ์ž‘์šฉ (HCI)์ด ์•„๋‹ˆ๋ผ ๊ฐ•๋ ฅํ•œ ์•Œ๊ณ ๋ฆฌ์ฆ˜(๋ชจ๋ธ)๊ณผ ๊ฑฐ์˜ ๋ฌด์ œํ•œ์˜ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ ๋Šฅ๋ ฅ์— ๊ธฐ๋ฐ˜ํ•œ ๊ณ ๊ธ‰ ๊ธฐ๊ณ„ ํ•™์Šต์ด๋ผ๋Š” ๊ฒƒ์„ ์–ธ๊ธ‰ํ–ˆ์Šต๋‹ˆ๋‹ค.

IoT ์„ผ์„œ์™€ ๋”ฅ๋Ÿฌ๋‹ ๋ถ„์„์„ ์‚ฌ์šฉํ•˜๋Š” ์ฝ”๊ทธ๋„ˆํ‹ฐ๋ธŒ ์‹œ์Šคํ…œ์„ ์ดํ•ดํ•˜๋ ค๋ฉด ๋จผ์ € ๊ณ ๊ธ‰ ๋จธ์‹ ๋Ÿฌ๋‹์—์„œ ์‹ ๊ฒฝ๋ง ๋ถ„์„์œผ๋กœ์˜ ๊ธฐ์ˆ ์  ๋„์•ฝ์„ ์ดํ•ดํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ๋ณธ ํฌ์ŠคํŒ…์—์„œ ํ•„์ž๋Š” ๊ธฐ์ˆ ์  ๋„์•ฝ์„ ์ž˜ ์ดํ•ดํ•˜๋„๋ก ๋„์šธ ๊ฒƒ์ž…๋‹ˆ๋‹ค. ๋‹ค๊ฐ€์˜ค๋Š” ๋ช‡ ์ฃผ ๋™์•ˆ, Deeplearning4j, ApacheSystemML ๋ฐ TensorFlow (TensorSpark)์˜ ๋”ฅ๋Ÿฌ๋‹ ํ”„๋ ˆ์ž„ ์›Œํฌ๋ฅผ ์‚ฌ์šฉํ•  ๊ฒƒ์ž…๋‹ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ  Apache Spark์˜ ์‹œ๊ณ„์—ด ๋ฐ์ดํ„ฐ์— ๋Œ€ํ•œ ๋น„์ •์ƒ ํƒ์ง€์— ๋Œ€ํ•œ ์„ธ ๊ฐ€์ง€ ํŠœํ† ๋ฆฌ์–ผ์„ ์ œ๊ณตํ•˜์—ฌ ๋น„์ •์ƒ ํƒ์ง€๋ฅผ ์œ„ํ•œ ์ฝ”๊ทธ๋„ˆํ‹ฐ๋ธŒ IoT ์†”๋ฃจ์…˜์„ ๋”ฅ๋Ÿฌ๋‹์„ ์‚ฌ์šฉํ•˜์—ฌ ๊ฐœ๋ฐœํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ์™„์ „ํžˆ ์ดํ•ดํ•  ์ˆ˜ ์žˆ๋„๋ก ํ•  ๊ฒƒ์ž…๋‹ˆ๋‹ค.

๋จธ์‹ ๋Ÿฌ๋‹์—์„œ ์‹ ๊ฒฝ๋ง ๋ฐ ๋”ฅ๋Ÿฌ๋‹์— ์ด๋ฅด๊ธฐ๊นŒ์ง€

๋งŒ์ผ ์ฝ”๊ทธ๋„ˆํ‹ฐ๋ธŒ ์‹œ์Šคํ…œ์ด ๋ชจ๋ธ์„ ๊ธฐ๋ฐ˜์œผ๋กœํ•œ๋‹ค๋ฉด, ๋จผ์ € ๋จธ์‹ ๋Ÿฌ๋‹ ๋ชจ๋ธ์ด ๋ฌด์—‡์ธ์ง€ ์•Œ์•„์•ผ ํ•ฉ๋‹ˆ๋‹ค. ๊ทธ๊ฒƒ์€ ๋ฌผ๋ฆฌ์  ๋ชจ๋ธ(White box)๊ณผ ๋‹ฌ๋ฆฌ ๋ฐ์ดํ„ฐ๋กœ ๋ถ€ํ„ฐ ์ˆจ๊ฒจ์ง„ ํŒจํ„ด์„ ๋ฐฐ์šฐ๊ธฐ ์œ„ํ•ด ํ›ˆ๋ จ๋œ ํ†ต๊ณ„ ๋ชจ๋ธ (black box)์ž…๋‹ˆ๋‹ค.

ํ‘œ 1์„ ๋ณด์„ธ์š”. ์—ฌ๊ธฐ์—๋Š” ์—ฌ๋Ÿฌ ๋งค๊ฐœ ๋ณ€์ˆ˜๋ฅผ ํฌํ•จํ•˜๋Š” ๊ณผ๊ฑฐ ๋ฐ์ดํ„ฐ, ์ œ์กฐ ํŒŒ์ดํ”„ ๋ผ์ธ์— ๋Œ€ํ•œ ์ธก์ •๋œ ๊ด€์ธก ๊ฐ’ ๋ฐ ์ด์ง„ ๊ฒฐ๊ณผ๊ฐ’์ด ํฌํ•จ๋˜์–ด ์žˆ์Šต๋‹ˆ๋‹ค.

ํ‘œ 1. ๋จธ์‹ ๋Ÿฌ๋‹ ๋ชจ๋ธ

์ด ์ธ๊ณต์ ์ธ ์˜ˆ์‹œ์—์„œ ๋ฐ์ดํ„ฐ๋Š” ๊ทธ ์ž์ฒด๋กœ ์ด์•ผ๊ธฐ๋ฅผ ํ•˜๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค. ๋‹น์‹ ์ด ์ถ”์ธกํ•˜๋“ฏ์ด, ๊ณ ์˜จ๊ณผ ์žฆ์€ ์ง„๋™์ด ๊ธฐ๊ณ„์˜ ๊ฒฐํ•จ์„ ์ดˆ๋ž˜ํ–ˆ์„ ๊ฒƒ์ž…๋‹ˆ๋‹ค. ์ด๋Ÿฐ ์ƒํ™ฉ์˜ ๊ทผ๋ณธ ์›์ธ์€ ์•„๋งˆ๋„ ๊ธฐ๊ณ„์—์„œ ๋ฒ ์–ด๋ง์ด ํŒŒ์†๋œ ๊ฒฐ๊ณผ์ผ ๊ฒƒ ์ž…๋‹ˆ๋‹ค.

์ด๋ฒˆ ์˜ˆ์‹œ์—์„œ, (Supervised) ๋จธ์‹ ๋Ÿฌ๋‹ ์•Œ๊ณ ๋ฆฌ์ฆ˜์€ ์ด ๋ชจ๋“  ๋ฐ์ดํ„ฐ (๋ฐ ํ›จ์”ฌ ๋”)๋ฅผ ๊ณ ๋ คํ•˜์—ฌ ๊ฒฐํ•จ์„ ํ•™์Šตํ•˜๊ณ  ์˜ˆ์ธกํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๋Ÿฌํ•œ ์•Œ๊ณ ๋ฆฌ์ฆ˜์ด ์ƒ์„ฑํ•˜๋Š” ๊ตฌ์„ฑ ์š”์†Œ๋ฅผ ๋จธ์‹ ๋Ÿฌ๋‹ ๋ชจ๋ธ์ด๋ผ๊ณ ํ•ฉ๋‹ˆ๋‹ค.

๋จธ์‹ ๋Ÿฌ๋‹ ์•Œ๊ณ ๋ฆฌ์ฆ˜์˜ ํŠน๋ณ„ํ•œ ํƒ€์ž…์ค‘ ํ•˜๋‚˜๋Š” ์‹ ๊ฒฝ๋ง(neural network) ์ž…๋‹ˆ๋‹ค. ์ด๋Š” ๋ฐ์ดํ„ฐ์— ๋งค์šฐ ์ž˜ ์ ์‘ํ•  ์ˆ˜ ์žˆ์œผ๋ฉฐ, ๋ฐ์ดํ„ฐ์™€ ๊ฒฐ๊ณผ ์‚ฌ์ด์˜ ์ˆจ๊ฒจ์ง„ ์ˆ˜ํ•™์  ํ•จ์ˆ˜๋ฅผ ๋ฐฐ์šธ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์‹ ๊ฒฝ๋ง์„ ๊ตฌ์ถ•ํ•˜๋Š” ์œ ์ผํ•œ ๋ฐฉ๋ฒ•์€, ํ•ด๋‹น ์—ฐ์‚ฐ์„ ์ˆ˜ํ–‰ํ•  ์ˆ˜ ์žˆ๋Š” ์—„์ฒญ๋‚œ ์–‘์˜ ์ปดํ“จํŒ… ์ž์›๊ณผ ๋ฐ์ดํ„ฐ๋ฅผ ํ™•๋ณดํ•˜๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ๊ทธ๋ ‡๋‹ค๋ฉด ์™œ ์ €๋Š” ์‹ ๊ฒฝ๋ง์— ๋Œ€ํ•ด ์ด์•ผ๊ธฐํ•˜๊ณ  ์žˆ์„๊นŒ์š”? ์šฐ๋ฆฌ๋Š” ์—„์ฒญ๋‚œ ์–‘์˜ ๋ฐ์ดํ„ฐ๋ฅผ ์ˆ˜์ง‘ํ•  ์ˆ˜ ์žˆ๋Š” IoT ์„ธ๊ณ„์— ์‚ด๊ณ  ์žˆ์œผ๋ฉฐ, ํด๋ผ์šฐ๋“œ๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ (๊ฑฐ์˜) ๋ฌดํ•œํ•œ ๊ณ„์‚ฐ ๋Šฅ๋ ฅ์„ ์ด์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๋Ÿฌํ•œ ์ƒํ™ฉ์ด ํŠนํžˆ IoT ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ์— ์žˆ์–ด ์‹ ๊ฒฝ๋ง์„ ํ™œ์šฉํ•˜๋Š” ๊ฒƒ์˜ ํฅ๋ฏธ๋กœ์šด ์ ์ž…๋‹ˆ๋‹ค.

์‹ ๊ฒฝ๋ง์€ ์ธ๊ฐ„์˜ ๋‘๋‡Œ์—์„œ ์˜๊ฐ์„ ์–ป์—ˆ์œผ๋ฉฐ ๋”ฅ๋Ÿฌ๋‹ ๋„คํŠธ์›Œํฌ(Deep Learning Network)๋„ ๋งˆ์ฐฌ๊ฐ€์ง€์ž…๋‹ˆ๋‹ค. ์‹ ๊ฒฝ๋ง๊ณผ ๋”ฅ๋Ÿฌ๋‹ ๋„คํฌ์›Œํฌ ๊ฐ„์˜ ์ฃผ๋œ ์ฐจ์ด๋Š” ๋‹ค์ค‘ ์‹ ๊ฒฝ ๋ง(multiple neural layers)์˜ ์ถ”๊ฐ€์ž…๋‹ˆ๋‹ค. ๋”ฅ๋Ÿฌ๋‹์ด ์ „ํ†ต์ ์ธ ๊ธฐ๊ณ„ ํ•™์Šต์„ ๋Šฅ๊ฐ€ํ•˜์—ฌ ์–ผ๋งˆ๋‚˜ ์ž˜ ์ ์šฉ๋˜๋Š”์ง€์— ๋Œ€ํ•œ ์˜ˆ๋Š” ์ด๋ฏธ์ง€ ์ธ์‹์ž…๋‹ˆ๋‹ค. ๋ชจ๋“  ์ตœ์‹  ์‹œ์Šคํ…œ์€ ํŠน๋ณ„ํ•œ ์œ ํ˜•์˜ ๋”ฅ๋Ÿฌ๋‹ ์‹ ๊ฒฝ๋ง(์ปจ๋ณผ๋ฃจ์…˜ ์‹ ๊ฒฝ๋ง์ด๋ผ๊ณ ๋„ ํ•จ)์„ ์‚ฌ์šฉํ•˜์—ฌ ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•ฉ๋‹ˆ๋‹ค.

์˜ˆ๋ฅผ ๋“ค์–ด, ๋”ฅ๋Ÿฌ๋‹ ๊ธฐ๋ฐ˜์˜ ์ด๋ฏธ์ง€ ์ธ์‹ ์•Œ๊ณ ๋ฆฌ์ฆ˜์€ ์ œ์กฐ ํŒŒ์ดํ”„ ๋ผ์ธ์—์„œ ๊ฒฐํ•จ์ด์žˆ๋Š” ๋ถ€ํ’ˆ๊ณผ ์ข‹์€ ๋ถ€ํ’ˆ์„ ๊ตฌ๋ณ„ ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ €๋Š” ์ด๊ฒƒ์„ ๊ธฐ๊ณ„ ์ง€๋Šฅ(machine intelligence)์ด๋ผ ๋ถ€๋ฅด๋ฉฐ IBM Watson Visual Recognition Service์—์„œ์™€ ๊ฐ™์ด ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด, ๊ธฐ๊ณ„๋Š” ์ธ๊ฐ„๊ณผ ๋™์ผํ•œ ์ •ํ™•๋„๋กœ ๋™์ผํ•œ ์ž‘์—…์„ ์ˆ˜ํ–‰ ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ธฐ๊ณ„์˜ ๊ณ ์œ ํ•œ ์ด์ ์€ ๊ฒฐ์ฝ” ์ž์ง€ ์•Š์œผ๋ฉฐ, ์•„ํ”„์ง€ ์•Š์œผ๋ฉฐ ๊ฒฐ์ฝ” ์ƒ์ฒ˜ ์ž…์ง€ ์•Š๋Š”๋‹ค๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ๋˜ํ•œ ์ฒ˜๋ฆฌ๋Ÿ‰์„ ๋‘ ๋ฐฐ๋กœ ๋Š˜๋ ค์•ผํ•˜๋Š” ๊ฒฝ์šฐ ํ•˜๋“œ์›จ์–ด ๋˜๋Š” ํด๋ผ์šฐ๋“œ ๋ฆฌ์†Œ์Šค์˜ ์–‘์„ ์–ธ์ œ๋“ ์ง€ ๋‘ ๋ฐฐ๋กœ ๋Š˜๋ฆด ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ ๋ถ€ํ’ˆ์ด ๋•Œ๋•Œ๋กœ ๊ฒฐํ•จ์ด ์žˆ๋Š” ๊ทผ๋ณธ ์›์ธ ๋ถ„์„(RCA)์„ ์ ์šฉํ•˜๋Š” ๊ฒƒ์€ ์—ฌ์ „ํžˆ ์ „๋ฌธ๊ฐ€์˜ ์˜์—ญ์ž…๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ ์ด ์‹œ๋‚˜๋ฆฌ์˜ค๋Š” ๋”ฅ๋Ÿฌ๋‹์„ ์ ์šฉํ•˜๋Š” ์ฝ”๋“œ๋„ˆํ‹ฐ๋ธŒ ์†”๋ฃจ์…˜์„ ์‚ฌ์šฉํ•˜๋Š” ์˜ˆ์‹œ์ž…๋‹ˆ๋‹ค.

์‹ค์ œ๋กœ ์ด๋ฏธ์ง€ ์ธ์‹ ์„œ๋น„์Šค๋Š” “์ข‹์Œ” ๋˜๋Š” “๊ฒฐํ•จ”์ด๋ผ๋Š” ์ด์ง„ ๊ฒฐ๊ณผ๋ณด๋‹ค ํ›จ์”ฌ ๋งŽ์€ ์ •๋ณด๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. ์‚ฌ๋žŒ๊ณผ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ ์ด ์„œ๋น„์Šค๋Š” ์ด๋ฏธ์ง€์—์„œ ํ‘œ์ค€์—์„œ ๋ฒ—์–ด๋‚˜๋Š” ๊ตฌ์กฐ์™€ ์˜์—ญ์„ ๊ฐ์ง€ํ•ฉ๋‹ˆ๋‹ค. ๋งŒ์ผ ๋‹น์‹ ์ด ๋ชจ๋“  ์†Œ๋ฆฌ ๋ฐ์ดํ„ฐ์™€ ์ง„๋™ ๋ฐ์ดํ„ฐ ๊ทธ๋ฆฌ๊ณ  ๋ชจ๋“  ์‹œ๊ฐ ๋ฐ์ดํ„ฐ๋ฅผ ์—ฐ๊ด€์‹œ์ผœ ๋ถ„์„์— ํ™œ์šฉํ•œ๋‹ค๋ฉด, ์ €๋Š” ์ด๋Ÿฌํ•œ ์‹œ์Šคํ…œ์ด ์ธ๊ฐ„๋งŒํผ ๋ฟ๋งŒ ์•„๋‹ˆ๋ผ ์‹ฌ์ง€์–ด ์ธ๊ฐ„๋ณด๋‹ค ๋” ๊ฒฐํ•จ์˜ ๊ทผ๋ณธ ์›์ธ์„ ์ž˜ ๊ฐ์ง€ํ•  ์ˆ˜ ์žˆ์„ ๊ฒƒ์ด๋ผ๊ณ  ํ™•์‹ ํ•ฉ๋‹ˆ๋‹ค.

์–ด๋–ป๊ฒŒ ์ธ๊ณต์‹ ๊ฒฝ๋ง์ด ๋™์ž‘ํ•˜๋Š”์ง€

๋งŒ์ผ ๋ฉ”์‹œ์ง€ ๋ธŒ๋กœ์ปค์— ์—ฐ๊ฒฐ๋œ IoT ์„ผ์„œ๊ฐ€(MQTT ๊ธฐ๋ฐ˜ IBM Watson IoT Platform๊ณผ ๊ฐ™์ด) ์†”๋ฃจ์…˜์˜ ์ค‘์ถ” ์‹ ๊ฒฝ๊ณ„๋ผ๋ฉด, ๋”ฅ๋Ÿฌ๋‹์€ ๋‘๋‡Œ์ž…๋‹ˆ๋‹ค. ๋˜ํ•œ ๋”ฅ๋Ÿฌ๋‹์„ ์ดํ•ดํ•˜๊ธฐ ์œ„ํ•ด์„œ๋Š” ํšŒ๊ท€๋ถ„์„(regression), ํผ์…‰ํŠธ๋ก (perceptrons), ์ƒ๋ฌผํ•™์  ์‹ ๊ฒฝ๋ง๊ณผ ์ธ๊ณต์‹ ๊ฒฝ๋ง(biological and artificial neural networks) ๊ทธ๋ฆฌ๊ณ  ํžˆ๋“  ๋ ˆ์ด์–ด(hidden layers)์— ๋Œ€ํ•œ ๊ธฐ๋ณธ์ ์ธ ์ดํ•ด๊ฐ€ ํ•„์š”ํ•ฉ๋‹ˆ๋‹ค.

์„ ํ˜•๊ณผ ๋กœ์ง€์Šคํ‹ฑ ํšŒ๊ท€๋ถ„์„์œผ๋กœ ์‹œ์ž‘ํ•˜๊ธฐ

ํšŒ๊ท€ ๋ถ„์„์— ๊ด€ํ•œ ์ˆ˜๋งŽ์€ ๊ณผํ•™ ๋ฌธํ—Œ์ด ์žˆ์œผ๋ฏ€๋กœ ๊ฐœ๋ฐœ์ž์—๊ฒŒ ๋งž๋Š” ์งง์€ ์„ค๋ช…์„ ๋“œ๋ฆฌ๊ฒ ์Šต๋‹ˆ๋‹ค. ํ‘œ 2๋ฅผ ์ฐธ๊ณ ํ•˜์„ธ์š”. ๊ฒฐ๊ณผ๋ฅผ ์ด์ง„ ํ‘œํ˜„์œผ๋กœ ๋ฐ”๊พผ ๊ณณ์„ ์ œ์™ธํ•˜๊ณ ๋Š” ํ‘œ 1๊ณผ ๋™์ผํ•ฉ๋‹ˆ๋‹ค.

ํ‘œ 2. ์ธ๊ณต์‹ ๊ฒฝ๋ง ๋ฐ์ดํ„ฐ

๋ถ„๋ฅ˜(classification) ์ž‘์—…์„ ํ•˜๊ธฐ ์œ„ํ•ด ์†Œํ”„ํŠธ์›จ์–ด๋ฅผ ์ž‘์„ฑํ•˜๋Š” ๊ฒƒ์€ ๊ฝค ์‰ฝ์Šต๋‹ˆ๋‹ค.

1
2
3
4
5
def  predict  (datapoint):  
     if  datapoint.MaxVibration1 > 100 : 
         return 0 
     else : 
         return 1
cs

์ด ํ™”์ดํŠธ ๋ฐ•์Šค ๋ชจ๋ธ์˜ ์˜ˆ๋Š” ๊ธฐ๋ณธ์ ์ธ ๋ฌผ๋ฆฌ์  ์‹œ์Šคํ…œ์— ๋Œ€ํ•œ ์ง€์‹์„ ํ™œ์šฉํ•˜์—ฌ ๋ช‡ ๊ฐ€์ง€ ๊ทœ์น™์„ ๋งŒ๋“œ๋Š” ๋ฐ ๋„์›€์ด๋˜์—ˆ์Šต๋‹ˆ๋‹ค(๋˜๋Š” ํ•ด๋‹น ๋ถ„์•ผ ์ „๋ฌธ๊ฐ€๊ฐ€ ๋ฐ์ดํ„ฐ๋ฅผ ๋ณด๋Š”๋ฐ์—). ๊ธฐ๊ณ„ ํ•™์Šต์˜ ๊ฐœ๋…์€ ๊ธฐ๊ณ„๊ฐ€ ๋ฐ์ดํ„ฐ๋กœ๋ถ€ํ„ฐ ์ด๋Ÿฌํ•œ ๊ทœ์น™์„ ํ•™์Šตํ•˜๋„๋กํ•˜๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ์ด ํ•™์Šต์ด ์ด๋ฃจ์–ด์ง€๋Š” ๋ฐฉ์‹์€ ์ฃผ๋œ ๋ถ„์„๋ฒ•(skeleton)์˜ ์„ ํƒ๊ณผ ์ตœ์ ํ™” ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ๋‚˜๋Š” ๋‹ค์Œ์˜ ์ฃผ๋œ ๋ถ„์„๋ฒ•(์„ ํ˜• ํšŒ๊ท€)์„ ์‚ฌ์šฉํ•  ๊ฒƒ์ž…๋‹ˆ๋‹ค.

1
2
def  predict (dp) : 
     return  a + b * dp.MaxTemp1 + c * dp.MinTemp1 + d * dp.MaxVibration1
cs

๋ณด์‹œ๋‹ค์‹œํ”ผ, ๋งค๊ฐœ ๋ณ€์ˆ˜ b ๋ฐ c๋ฅผ 0, a๋ฅผ 1, d๋ฅผ -0.0002930832 (-1/3412)๋กœ ์„ ํƒํ•˜๋ฉด ํ•„์š”ํ•œ ๊ฒฐ๊ณผ์— ๊ฐ€๊น๊ฒŒ ๋๋‚ฉ๋‹ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ์ข‹์€ ์†Œ์‹์€ ์•Œ๊ณ ๋ฆฌ์ฆ˜์—์„œ ๋งค๊ฐœ ๋ณ€์ˆ˜ a, b, c ๋ฐ d๋ฅผ ๋ฐฐ์šธ ์ˆ˜ ์žˆ๋‹ค๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ๊ทธ ๊ฒฐ๊ณผ๊ฐ€ ๋ฐ”๋กœ ๋จธ์‹ ๋Ÿฌ๋‹์ž…๋‹ˆ๋‹ค!

์„ ํ˜• ํšŒ๊ท€๊ฐ€ ์—ฐ์† ๋ชจ๋ธ์ด๋ฏ€๋กœ (float ์œ ํ˜•์˜ ๊ฐ’์„ ์˜ˆ์ธกํ•˜๋ ค๊ณ  ์‹œ๋„ํ–ˆ๊ธฐ ๋•Œ๋ฌธ์—) ๊ฒฐ๊ณผ๊ฐ€ ์ •ํ™•ํžˆ 1 ๋˜๋Š” 0์ด ์•„๋‹˜์„ ์•Œ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ ์šฐ๋ฆฌ๊ฐ€ ์›ํ•˜๋Š” ๊ฒƒ์€ ๋ฐ”์ด๋„ˆ๋ฆฌ ๋ถ„๋ฅ˜์ด์ฃ . ์—ฌ๊ธฐ์— ์‹œ๊ทธ๋ชจ์ด๋“œ(sigmoid)๋ผ๋Š” ํ—ฌํผ ํ•จ์ˆ˜๋ฅผ ์ถ”๊ฐ€ํ•˜๊ธฐ๋งŒ ํ•˜๋ฉด ์ด ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ๋กœ์ง€์Šคํ‹ฑ ํšŒ๊ท€ ๋ชจ๋ธ๋กœ ๋งŒ๋“ค ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

1
2
3
4
5
6
7
8
import  math 
 
def  sigmoid (x): 
    return  1 / (1  +  math.exp(  x)) 
 
def  predict (dp): 
    return  sigmoid(a + b * dp.MaxTemp1 + c * dp.MinTemp1 + d * dp.MaxVibration1)
 
cs

์‹œ๊ทธ๋ชจ์ด๋“œ ํ•จ์ˆ˜๋Š” ๋งˆ์ด๋„ˆ์Šค ๋ฌดํ•œ๋Œ€์—์„œ ํ”Œ๋Ÿฌ์Šค ๋ฌดํ•œ๋Œ€๊นŒ์ง€ ๋ฒ”์œ„๋ฅผ 0-1๋กœ ๋ณ€ํ™˜ํ•˜๋Š” ๊ฒƒ์„ ์ œ์™ธํ•˜๊ณ ๋Š” ์•„๋ฌด๊ฒƒ๋„ํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ๋‚ด๊ฐ€ ํ•  ํ•„์š”๊ฐ€ ์žˆ๋Š” ์œ ์ผํ•œ ๊ฒƒ์€ ์ž„๊ณ„๊ฐ’์„ ์ •์˜ํ•˜๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค (์˜ˆ : ์ „ํ™˜ ๊ฐ’์˜ ๋ฒ”์œ„๋ฅผ 0.5์—์„œ 0๋ณด๋‹ค ์ž‘๊ณ  0.5์—์„œ 1๋ณด๋‹ค ํฐ ๊ฒฝ์šฐ๋กœ ์ •์˜ํ•  ์ˆ˜ ์žˆ๊ฒ ์ฃ .)

๊ทธ๋ฆผ 1. ์‹œ๊ทธ๋ชจ์ด๋“œ ํ•จ์ˆ˜ ๋งต ๋ฒ”์œ„

๊ฐ€์žฅ ๋‹จ์ˆœํ•œ ์‹ ๊ฒฝ๋ง : ํผ์…‰ํŠธ๋ก (perceptron)

์ด์ œ ๊ฐ€์žฅ ๋‹จ์ˆœํ•œ ์‹ ๊ฒฝ ๋„คํŠธ์›Œํฌ์ธ ํผ์…‰ํŠธ๋ก ์„ ๋งˆ์Šคํ„ฐํ–ˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๊ฒƒ์€ ๋กœ์ง€์Šคํ‹ฑ ํšŒ๊ท€ ๋ชจ๋ธ๊ณผ ๋น„์Šทํ•˜์ง€๋งŒ ์•ฝ๊ฐ„์˜ ์ฐจ์ด๋Š” ์žˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ “์‹ ๊ฒฝ ๋„คํŠธ์›Œํฌ”๋ผ๋Š” ์šฉ์–ด๋Š” ํ›จ์”ฌ ๋ฉ‹์ง€๊ฒŒ ๋“ค๋ฆฌ๋‚˜์š”? ๊ทธ๋ฆผ 2์˜ ํผ์…‰ํŠธ๋ก ์„ ๋ณด์‹ญ์‹œ์˜ค.

๊ทธ๋ฆผ 2. ํผ์…‰ํŠธ๋ก 

๋ชจ๋ธ x_1์—์„œ x_n์œผ๋กœ, ๋ชจ๋ธ ๋งค๊ฐœ ๋ณ€์ˆ˜ w_1์—์„œ w_n์œผ๋กœ ์ž…๋ ฅ์„ ํ–ˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿฐ ๋‹ค์Œ ์ด๋ฅผ ํ•ฉ์‚ฐํ•˜์—ฌ ์ •๋ฆฌํ•˜๊ณ  ํ™œ์„ฑํ•จ์ˆ˜ (activation_function, ์˜ˆ : ์‹œ๊ทธ๋ชจ์ด๋“œ)๋กœ ๋„˜๊ฒจ์ค๋‹ˆ๋‹ค. ์ด ๋ชจ๋ธ์„ ์กฐ๊ธˆ ๋‹ค๋ฅด๊ฒŒ ์ž‘์„ฑํ•˜๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™์ด ๋ณด์ž…๋‹ˆ๋‹ค.

1
2
out(x_1,x_2,โ€ฆ,x_n) = activation_function(w_0+w_1*x_1+w_2*x_2+โ€ฆ+w_n*x_n)
 
cs

๊ทธ๋ฆฌ๊ณ  ํ™œ์„ฑํ•จ์ˆ˜(activation_function)๋ฅผ sigmoid๋กœ ๋ฐ”๊พธ๋ฉด ๋กœ์ง€์Šคํ‹ฑ ํšŒ๊ท€๋กœ ๋Œ์•„๊ฐ‘๋‹ˆ๋‹ค. ์œ ์ผํ•œ ๊ฒƒ์€… ์ด์ œ๋Š” ๋‡Œ์˜ ๊ตฌ์กฐ์™€ ์กฐ๊ธˆ ๋” ๋น„์Šทํ•ด ๋ณด์ธ ๋‹ค๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ๊ทธ๋‚˜์ €๋‚˜ ์ธ๊ฐ„์˜ ๋‘๋‡Œ๋Š” ์–ด๋–ป๊ฒŒ ์ƒ๊ฒผ์„๊นŒ์š”?

์ƒ๋ฌผํ•™์  ์‹ ๊ฒฝ๋ง์—์„œ ์ธ๊ณต ์‹ ๊ฒฝ๋ง์— ์ด๋ฅด๊ธฐ๊นŒ์ง€

๊ทธ๋ฆผ 3์˜ ์ƒ๋ฌผํ•™์  ๋‰ด๋Ÿฐ์„ ์‚ดํŽด๋ณด์‹ญ์‹œ์˜ค. ์ˆ˜ํ•™์  ์šฉ์–ด๋กœ, ์ˆ˜์ƒ ๋Œ๊ธฐ๋Š” ์—…์ŠคํŠธ๋ฆผ ๋ฐ์ดํ„ฐ๊ฐ€ ์ž…๋ ฅ๋˜๋Š” “์ž…๋ ฅ”์ž…๋‹ˆ๋‹ค. ์„ธํฌ์ฒด (๋ฐ ์‹œ๋ƒ…์Šค)๋Š” ์ž…๋ ฅ๋“ค์˜ ํ•ฉ๊ณ„์™€ “ํ™œ์„ฑํ™” ํ•จ์ˆ˜”๋ฅผ ๊ณ„์‚ฐํ•ฉ๋‹ˆ๋‹ค. “๊ฒฐ๊ณผ”๋Š” ์ถ•์ƒ‰ ๋Œ๊ธฐ๋ฅผ ๊ฑฐ์ณ ํ›„์† ํ•˜๋ถ€ ๋‰ด๋Ÿฐ์œผ๋กœ ๋ณด๋‚ด์ง‘๋‹ˆ๋‹ค.

๊ทธ๋ฆผ 3. ์ƒ๋ฌผํ•™์  ๋‰ด๋Ÿฐ

๊ทธ๋ฆฌ๊ณ  ์žฌ๋ฏธ ์žˆ๊ธฐ ๋•Œ๋ฌธ์—(์ตœ์†Œํ•œ ์ œ๊ฒ), ๊ทธ๋ฆผ 4์—์„œ ๋‰ด๋Ÿฐ(์ƒํ™”ํ•™์ )์„ ์—ฐ๊ฒฐํ•˜๋Š” ์ƒ๋ฌผํ•™์  ์‹œ๋ƒ…์Šค์— ๋Œ€ํ•ด ์‚ดํŽด๋ณด์‹ญ์‹œ์˜ค. ์ด ๊ทธ๋ฆผ์€ ํผ์…‰ํŠธ๋ก ์—์„œ w_n ๊ฐ’์˜ ์ง‘ํ•ฉ์„ ๋‚˜ํƒ€๋ƒ…๋‹ˆ๋‹ค.

๊ทธ๋ฆผ 4. ์ƒ๋ฌผํ•™์  ์‹œ๋ƒ…์Šค

์—ฌ๋Ÿฌ ๊ฐœ์˜ ๋‰ด๋Ÿฐ์„ ํ•จ๊ป˜ ์—ฐ๊ฒฐํ•˜๋ฉด ๊ทธ๋ฆผ 5์™€ ๊ฐ™์ด ๋‘๋‡Œ ๋˜๋Š” ์ธ๊ณต ์‹ ๊ฒฝ๋ง์„ ๊ฐ–๊ฒŒ๋ฉ๋‹ˆ๋‹ค.

๊ทธ๋ฆผ 5. ์ธ๊ณต์‹ ๊ฒฝ๋ง

์ฐจ์ด์ ์€ ํžˆ๋“  ๋ ˆ์ด์–ด์— ์žˆ์Šต๋‹ˆ๋‹ค

์ด ์ธ๊ณต๋ง๊ณผ ํผ์…‰ํŠธ๋ก ์˜ ๊ฐ€์žฅ ํฐ ์ฐจ์ด์ ์€ ํžˆ๋“  ๋ ˆ์ด์–ด์ž…๋‹ˆ๋‹ค. ์ด๊ฒŒ ๋ญ˜๊นŒ์š”? ์œ ์šฉํ• ๊นŒ์š”? ์•„๋งˆ๋„. ์ ์–ด๋„ ์ธ๊ฐ„์˜ ๋‡Œ์—์„œ๋Š” ํžˆ๋“  ๋ ˆ์ด์–ด๊ฐ€ ์œ ์šฉํ•  ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค. ์™œ๋ƒํ•˜๋ฉด ์šฐ๋ฆฌ๊ฐ€ ์ˆ˜๋ฐฑ ๊ฐœ์˜ ํžˆ๋“  ๋ ˆ์ด์–ด๋ฅผ ๋‘๋‡Œ์— ๊ฐ€์ง€๊ณ  ์žˆ๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค. ๊ทธ๋ฆผ 6์˜ ํ”ผ๋“œ ํฌ์›Œ๋“œ(Feed Forward) ์‹ ๊ฒฝ๋ง ์˜ˆ์ œ์—์„œ ๋ชจ๋ธ์ด ์Šคํƒ๋˜์–ด ์žˆ์Œ์„ ์•Œ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๊ทธ๋ฆผ 6. ์ด๋ฏธ์ง€ ์ธ์‹์„ ์œ„ํ•œ ์‹ ๊ฒฝ๋ง ๋ ˆ์ด์–ด ์Šคํƒ

์ด ๋ชจ๋ธ์ด ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด๋กœ ์–ด๋–ป๊ฒŒ ๋ณด์ด๋Š”์ง€ ํ•œ ๋ฒˆ ๋ณด์„ธ์š”. ๊ทธ ์ „์— ๋น„๋ฐ€์„ ๋งํ•ด๋“œ๋ฆด๊ฒŒ์š”. ์ˆ˜ํ•™์ž๋“ค์ด ๋ชจ๋‘๋ฅผ ๋†€๋ผ๊ฒŒํ•˜๋Š” ๋ฐ ์‚ฌ์šฉํ•˜๋Š” ๋น„๋ฐ€. ํ•˜์ง€๋งŒ ์™„์ „ํžˆ ๊ฐ„๋‹จํ•œ ๊ทธ ๋น„๋ฐ€. ์ €๋Š” ์ง€๊ธˆ ๋ฒกํ„ฐ ๊ณฑ์…ˆ์— ๋Œ€ํ•ด์„œ ๋งํ•˜๊ณ ์ž ํ•ฉ๋‹ˆ๋‹ค. ๊ทธ๋ ‡๋‹ค๋ฉด ๋ฒกํ„ฐ๋Š” ๋ฌด์—‡์ผ๊นŒ์š”? ์ˆซ์ž ๋ชฉ๋ก ์ผ๋ฟ์ž…๋‹ˆ๋‹ค. ํ”„๋กœ๊ทธ๋ž˜๋จธ๋Š” ๊ทธ๊ฒƒ์„ ๋ฐฐ์—ด์ด๋ผ๊ณ  ๋ถ€๋ฅผ ๊ฒƒ์ž…๋‹ˆ๋‹ค. ๋ฒกํ„ฐ์— ๋Œ€ํ•œ ๊ณฑ์…ˆ์€ ์•ฝ๊ฐ„ ๋‹ค๋ฅด๊ฒŒ ์ •์˜๋ฉ๋‹ˆ๋‹ค. ๋ฒกํ„ฐ x = (x_1, x_2, …, x_n)์™€ ๋‹ค๋ฅธ ๋ฒกํ„ฐ w = (w_1, w_2, …, w_n)๊ฐ€ ์žˆ๊ณ  x * w๋ฅผ ๊ณฑํ•˜๋ฉด ๊ฒฐ๊ณผ๋Š” ๋‹จ์ผ ๊ฐ’์ž…๋‹ˆ๋‹ค.

1
2
w_1*x_1+w_2*x_2+โ€ฆ+w_n*x_n
 
cs

์ด ๋ชจ๋ธ์ด ๋‹น์‹ ์—๊ฒŒ ์ต์ˆ™ํ•œ ๋ชจ์–‘์ธ๊ฐ€์š”? ๊ทธ๋ ‡์ง€ ์•Š๋‹ค๋ฉด ์„ ํ˜• ํšŒ๊ท€๋ฅผ ๋‹ค์‹œ๋ณด์‹ญ์‹œ์˜ค. ์‹œ๊ทธ๋ชจ์ด๋“œ (x * w)๋ฅผ ๊ณ„์‚ฐํ•˜์—ฌ ๋‹จ์ผ ๋‰ด๋Ÿฐ์„ ๊ณ„์‚ฐํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ํŒŒ์ด์ฌ์€ ์ƒ์ž ๋ฐ–์œผ๋กœ ๋ฒกํ„ฐ ๊ณฑ์…ˆ์„ ์ง€์›ํ•˜์ง€ ์•Š๊ธฐ ๋•Œ๋ฌธ์— numpy๋ผ๊ณ ํ•˜๋Š” ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ํ•˜๋‚˜์˜ ๋‰ด๋Ÿฐ์„ ๊ณ„์‚ฐํ•˜๊ธฐ ์‹œ์ž‘ํ•ฉ๋‹ˆ๋‹ค.

1
2
3
4
5
6
7
8
9
10
11
12
import numpy as np 
 
datapoint = {” MaxTemp1 “35 , ” MinTemp1 “35 , ” MaxVibration1 “12 } 
 
#randomly initialize weights
w_layer1 = np.random.rand(4)
 
def  neuron1 (dp): 
    x = np.array([ 1 ,dp[” MaxTemp1 “],dp[” MinTemp1 “],dp[” MaxVibration1 “]]) 
    return  sigmoid(x.dot(w_layer1)) 
 
print (neuron1 ( datapoint ) )
cs

๋™์‹œ์— ์—ฌ๋Ÿฌ ๊ฐœ์˜ ๋‰ด๋Ÿฐ (์˜ˆ : ๋ชจ๋“  ๋‰ด๋Ÿฐ์˜ ๋ ˆ์ด์–ด)์„ ๊ณ„์‚ฐํ•˜๋ ค๋ฉด ์ด ํ•จ์ˆ˜๋ฅผ ์—ฌ๋Ÿฌ ๋ฒˆ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ ์ˆ˜ํ•™์ž๋“ค์€ ๋‹น์‹ ์„ ํ˜ผ๋ž€์Šค๋Ÿฝ๊ฒŒํ•˜๋Š” ๋˜ ๋‹ค๋ฅธ ๊ฒƒ์„ ๋งŒ๋“ค์—ˆ์Šต๋‹ˆ๋‹ค. (๋ฒกํ„ฐ ๊ณฑ์…ˆ์—์„œ ์‚ด์•„๋‚จ์€ ๊ฒฝ์šฐ๋ฅผ ๋Œ€๋น„ํ•˜์—ฌ) ํ–‰๋ ฌ ๊ณฑ์…ˆ. ์‹ ๊ฒฝ๋ง์—์„œ๋Š” ์„ ํ˜• ํšŒ๊ท€์™€ ๊ฐ™์€ ๊ณ„์‚ฐ์„ ์—ฌ๋Ÿฌ๋ฒˆ ๋ณ‘๋ ฌ๋กœ ์ ์šฉ ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด ํ˜•์‹์œผ๋กœ ํ–‰๋ ฌ ๊ณฑ์…ˆ์„ ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๋‹ค์‹œ ๋งํ•˜์ง€๋งŒ, ์šฐ๋ฆฌ์˜ ์ž…๋ ฅ์€ ๋ฒกํ„ฐ x = (x_1, x_2, …, x_n)์— ์žˆ๋‹ค๊ณ  ๊ฐ€์ •ํ•ฉ๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ ์ง€๊ธˆ์€ ๋™์‹œ์— ์ˆจ๊ฒจ์ง„ ๋ ˆ์ด์–ด์˜ ๋ชจ๋“  ๋‰ด๋Ÿฐ์„ ๊ณ„์‚ฐํ•˜๊ณ  ์‹ถ์Šต๋‹ˆ๋‹ค. ๋‹จ์ผ ๋‰ด๋Ÿฐ์„ ๊ณ„์‚ฐํ•˜๊ธฐ ์œ„ํ•ด x์— ๊ฐ€์ค‘์น˜ ๋ฒกํ„ฐ w๋ฅผ ๊ณฑํ•˜๋Š” ๋Œ€์‹  x๋ฅผ ๊ฐ€์ค‘์น˜ ํ–‰๋ ฌ w =

 
w_1_1,  w_1_2,.., w_1_m
w_2_1,  w_2_2,.., w_2_m
โ€ฆ
w_n_1,  w_n_2,.., w_n_m

ํ–‰๋ ฌ ๊ณฑ์…ˆ์€ w * x =

 
(w_1_1*x_1,  w_1_2*x_2,.., w_1_m*x_n,
w_2_1*x_1,  w_2_2*x_2,.., w_2_m*x_n,
โ€ฆ
 w_n_1*x_1,  w_n_2*x_2,.., w_n_m*x_n)

๊ฒฐ๊ณผ๋Š” float ๊ฐ’์˜ ๋ฒกํ„ฐ์ด๋ฉฐ ๋‹ค์Œ ๋ ˆ์ด์–ด๋กœ float ๊ฐ’์„ ๋„˜๊ฒจ์ค„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๋ฅผ ํŒŒ์ด์ฌ์œผ๋กœ ํ‘œํ˜„ํ•˜๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import numpy as np 
 
#make sigmoid function applicable to vectors instead of scalars only
def  sigmoid (z): 
    s =  1.0  / ( 1.0  + np.exp( 1.0  * z)) 
      return  s 
 
datapoint = {” MaxTemp1 “35 , ” MinTemp1 “35 , ” MaxVibration1 “12 } 
 
#randomly initialize weights, now as a matrix for the four hidden layer neurons
w_layer1 = np.random.rand(4,4)
 
def  layer 1 (dp): 
    x = np.array([ 1 ,dp[” MaxTemp1 “],dp[” MinTemp1 “],dp[” MaxVibration1 “]]) 
      return  sigmoid(x.dot(w_layer1)) 
 
print ( layer 1 ( datapoint ) )
 
cs

๋ณด์‹œ๋‹ค์‹œํ”ผ ์ฝ”๋“œ ๋ถ€๋ถ„ ์ค‘ x.dot (w_layer1)์€ ์ „ํ˜€ ๋ณ€๊ฒฝ๋˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ ๋‚ด๋ถ€์ ์œผ๋กœ w_layer1์€ ๋ฒกํ„ฐ๊ฐ€ ์•„๋‹Œ ํ–‰๋ ฌ์ด๋ฏ€๋กœ ๋ฒกํ„ฐ ๊ณฑ์…ˆ ๋Œ€์‹ ์— ํ–‰๋ ฌ ๊ณฑ์…ˆ์ด ์ ์šฉ๋ฉ๋‹ˆ๋‹ค. ๋งˆ์ง€๋ง‰์œผ๋กœ, ์ถœ๋ ฅ ๋ ˆ์ด์–ด๋ฅผ ์ถ”๊ฐ€ํ•˜๊ณ  ์™„๋ฃŒํ•ฉ๋‹ˆ๋‹ค.

1
2
3
4
5
6
7
w_layer2 = np.random.rand( 5 , 2 ) 
 
def  layer2 (x): 
    x = np.concatenate(([ 1 ],x)) 
      return  sigmoid(x.dot(w_layer2)) 
 
print (layer2(layer1(datapoint)))
cs

๋ฌผ๋ก , ๊ฐ€์ค‘์น˜ ํ–‰๋ ฌ w๋Š” ํ›ˆ๋ จ๋˜์ง€ ์•Š๊ณ  ๋ฌด์ž‘์œ„ ์ ์œผ๋กœ ์ดˆ๊ธฐํ™”๋ฉ๋‹ˆ๋‹ค. (์‹ ๊ฒฝ๋ง ํŠธ๋ ˆ์ด๋‹์€ ์ด ํฌ์ŠคํŒ…์˜ ๋ฒ”์œ„๋ฅผ ๋ฒ—์–ด๋‚ฉ๋‹ˆ๋‹ค.)

์ฐธ๊ณ  : ์ด ๋žœ๋ค ์‹ ๊ฒฝ๋ง์€ ๋‘ ๊ฐœ์˜ ๋ถ€๋™ ์†Œ์ˆ˜์  ์ˆซ์ž๋ฅผ ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค. ์ด ์ˆซ์ž๋Š” ํ•œ ํด๋ž˜์Šค ๋˜๋Š” ๋‹ค๋ฅธ ํด๋ž˜์Šค์— ์†ํ•˜๋Š” ํ•ญ๋ชฉ์˜ ํ™•๋ฅ ์ž…๋‹ˆ๋‹ค. ๋‹ค์‹œ ๋งํ•˜์ง€๋งŒ, ์‹ ๊ฒฝ ๋„คํŠธ์›Œํฌ๊ฐ€ ํ›ˆ๋ จ๋˜์ง€ ์•Š์•˜๊ธฐ ๋•Œ๋ฌธ์—์ด ์ˆซ์ž๋Š” ๋‹น์žฅ ์ ํ•ฉํ•˜์ง€ ์•Š์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
[0.97435552 0.89144977]

* ๋ณธ ํฌ์ŠคํŒ…์€ ‘๋”ฅ๋Ÿฌ๋‹๊ณผ LSTM ๋„คํŠธ์›Œํฌ ์†Œ๊ฐœ (2)’๋กœ ์ด์–ด์ง‘๋‹ˆ๋‹ค. https://developer.ibm.com/kr/systems/machinelearning/2017/11/15/deeplearning-lstm-2/
์ž‘์„ฑ์ž: ๋งน์œคํ˜ธ

ํ† ๋ก  ์ฐธ๊ฐ€

์ด๋ฉ”์ผ์€ ๊ณต๊ฐœ๋˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ํ•„์ˆ˜ ์ž…๋ ฅ์ฐฝ์€ * ๋กœ ํ‘œ์‹œ๋˜์–ด ์žˆ์Šต๋‹ˆ๋‹ค.