์ฝ˜ํ…์ธ  ๋Œ€ํ‘œ ์ด๋ฏธ์ง€ - ๐Ÿค– ๋จธ์‹ ๋Ÿฌ๋‹ ์ž…๋ฌธ๋ถ€ํ„ฐ ์‹ค์ „๊นŒ์ง€: Scikit-learnยทTensorFlowยทPyTorch๋กœ ๋งŒ๋“œ๋Š” ํŒŒ์ด์ฌ AI ๋ชจ๋ธ ๊ฐœ๋ฐœ ๐Ÿ

๐Ÿค– ๋จธ์‹ ๋Ÿฌ๋‹ ์ž…๋ฌธ๋ถ€ํ„ฐ ์‹ค์ „๊นŒ์ง€: Scikit-learnยทTensorFlowยทPyTorch๋กœ ๋งŒ๋“œ๋Š” ํŒŒ์ด์ฌ AI ๋ชจ๋ธ ๊ฐœ๋ฐœ ๐Ÿ

โ€œAI ๋ชจ๋ธ ๋งŒ๋“ ๋‹คโ€๋Š” ๋ง, ๋ง‰์ƒ ๋“ค์œผ๋ฉด ๊ฑฐ์ฐฝํ•˜์ง€? ๊ทผ๋ฐ ๋œฏ์–ด๋ณด๋ฉด ๋ฐ์ดํ„ฐ โ†’ ๋ชจ๋ธ โ†’ ํ•™์Šต โ†’ ํ‰๊ฐ€ โ†’ ๋ฐฐํฌ๋ผ๋Š” ๊ฝค ์ •์งํ•œ ํ๋ฆ„์ด์•ผ. ์˜ค๋Š˜์€ ์นœ๊ตฌํ•œํ…Œ ์ปคํ”ผ ํ•œ ์ž” ์‚ฌ์ฃผ๋ฉด์„œ ์„ค๋ช…ํ•˜๋“ฏ, ํŒŒ์ด์ฌ 3๋Œ€์žฅ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋กœ ๊ทธ ํ๋ฆ„์„ ํ•˜๋‚˜์”ฉ ๊ฐ™์ด ๊ฑธ์–ด๊ฐ€ ๋ณด์ž โ˜•

ํŒŒ์ด์ฌ AI ๋ชจ๋ธ ๊ฐœ๋ฐœ ๊ณต์žฅ ๋ฐ์ดํ„ฐ ๋ชจ๋ธ ํ•™์Šต ๊ณ ์–‘์ด 97% ์˜ˆ์ธก Scikit-learn ์ „ํ†ต ๋จธ์‹ ๋Ÿฌ๋‹ ํ‘œ ๋ฐ์ดํ„ฐ ๊ฐ•์ž TensorFlow Keras๋กœ ๋น ๋ฅด๊ฒŒ ๋ฐฐํฌ ์ƒํƒœ๊ณ„ PyTorch ํŒŒ์ด์ฌ๋‹ค์šด ์ฝ”๋“œ ์—ฐ๊ตฌยทLLM ๋Œ€์„ธ

๋ฐ์ดํ„ฐ๊ฐ€ ๋“ค์–ด๊ฐ€ ๋ชจ๋ธ๋กœ ํ•™์Šต๋˜๊ณ  ์˜ˆ์ธก์ด ๋‚˜์˜ค๋Š” ํ๋ฆ„, ๊ทธ๋ฆฌ๊ณ  ์ด๋ฅผ ๋ฐ›์ณ์ฃผ๋Š” ํŒŒ์ด์ฌ 3๋Œ€ ๋„๊ตฌ

1. ๋จธ์‹ ๋Ÿฌ๋‹, ๋Œ€์ฒด ์ •์ฒด๊ฐ€ ๋ญ์•ผ? ๐Ÿง 

๋จผ์ € ์˜คํ•ด ํ•˜๋‚˜๋ถ€ํ„ฐ ํ’€๊ณ  ๊ฐ€์ž. ๋จธ์‹ ๋Ÿฌ๋‹์€ ์ปดํ“จํ„ฐ๊ฐ€ โ€œ์Šค์Šค๋กœ ์ƒ๊ฐํ•˜๋Š”โ€ ๋งˆ๋ฒ•์ด ์•„๋‹ˆ์•ผ. ์ •ํ™•ํžˆ ๋งํ•˜๋ฉด ๋ฐ์ดํ„ฐ์—์„œ ๊ทœ์น™(ํ•จ์ˆ˜)์„ ์ž๋™์œผ๋กœ ์ฐพ์•„๋‚ด๋Š” ๊ธฐ์ˆ ์ด์•ผ.
์ „ํ†ต์ ์ธ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์€ ์‚ฌ๋žŒ์ด ๊ทœ์น™์„ ์ง์ ‘ ์งœ. โ€œ๋ฉ”์ผ ์ œ๋ชฉ์— โ€˜๋ฌด๋ฃŒโ€™์™€ โ€˜๋‹น์ฒจโ€™์ด ์žˆ์œผ๋ฉด ์ŠคํŒธโ€ ์ด๋Ÿฐ ์‹์œผ๋กœ ๋ง์ด์ง€. ๋จธ์‹ ๋Ÿฌ๋‹์€ ๋ฐ˜๋Œ€๋กœ ๊ฐ€. ์ŠคํŒธ ๋ฉ”์ผ ์ˆ˜์ฒœ ๊ฐœ์™€ ์ •์ƒ ๋ฉ”์ผ ์ˆ˜์ฒœ ๊ฐœ๋ฅผ ๋ณด์—ฌ์ฃผ๋ฉด, ์ปดํ“จํ„ฐ๊ฐ€ โ€œ์ด๋Ÿฐ ํŒจํ„ด์ด๋ฉด ์ŠคํŒธ์ผ ํ™•๋ฅ ์ด ๋†’๋„คโ€ ํ•˜๋Š” ๊ทœ์น™์„ ํ†ต๊ณ„์ ์œผ๋กœ ์ถ”์ •ํ•ด ๋‚ด๋Š” ๊ฑฐ์•ผ.

์ˆ˜ํ•™์ ์œผ๋กœ ์“ฐ๋ฉด ์•„์ฃผ ๋‹จ์ˆœํ•ด. ์ž…๋ ฅ x์™€ ์ •๋‹ต y๊ฐ€ ์žˆ์„ ๋•Œ, y โ‰ˆ f(x)๊ฐ€ ๋˜๋„๋ก ํ•˜๋Š” ํ•จ์ˆ˜ f๋ฅผ ์ฐพ๋Š” ๊ฒƒ. ๊ทธ๋ฆฌ๊ณ  ๊ทธ f๋ฅผ ์ฐพ๋Š” ๊ณผ์ •์„ ํ•™์Šต(training), ์ฐพ์•„๋‚ธ f๋ฅผ ๋ชจ๋ธ(model)์ด๋ผ๊ณ  ๋ถˆ๋Ÿฌ. f์˜ ๋ชจ์–‘์„ ๊ฒฐ์ •ํ•˜๋Š” ์ˆซ์ž๋“ค(์ง์„ ์ด๋ผ๋ฉด ๊ธฐ์šธ๊ธฐ์™€ ์ ˆํŽธ)์„ ํŒŒ๋ผ๋ฏธํ„ฐ๋ผ๊ณ  ํ•˜๊ณ , ์‚ฌ๋žŒ์ด ํ•™์Šต ์ „์— ์ •ํ•ด์ฃผ๋Š” ์„ค์ •๊ฐ’(ํ•™์Šต๋ฅ , ํŠธ๋ฆฌ ๊นŠ์ด ๋“ฑ)์€ ํ•˜์ดํผํŒŒ๋ผ๋ฏธํ„ฐ๋ผ๊ณ  ๊ตฌ๋ถ„ํ•ด.

๐Ÿ“Œ AI โŠƒ ๋จธ์‹ ๋Ÿฌ๋‹ โŠƒ ๋”ฅ๋Ÿฌ๋‹ AI๋Š” โ€œ์ง€๋Šฅ์ ์œผ๋กœ ๋ณด์ด๋Š” ์‹œ์Šคํ…œโ€ ์ „์ฒด๋ฅผ ๋งํ•˜๋Š” ๊ฐ€์žฅ ํฐ ์šฐ์‚ฐ์ด์•ผ. ๊ทธ ์•ˆ์— ๋ฐ์ดํ„ฐ๋กœ ํ•™์Šตํ•˜๋Š” ๋จธ์‹ ๋Ÿฌ๋‹์ด ์žˆ๊ณ , ๋จธ์‹ ๋Ÿฌ๋‹ ์•ˆ์— ์—ฌ๋Ÿฌ ์ธต์˜ ์ธ๊ณต์‹ ๊ฒฝ๋ง์„ ์“ฐ๋Š” ๋”ฅ๋Ÿฌ๋‹์ด ์žˆ์–ด. ๊ทธ๋Ÿฌ๋‹ˆ๊นŒ ChatGPT ๊ฐ™์€ ๋Œ€ํ˜• ์–ธ์–ด ๋ชจ๋ธ๋„ ๊ฒฐ๊ตญ ๋”ฅ๋Ÿฌ๋‹ โ†’ ๋จธ์‹ ๋Ÿฌ๋‹ โ†’ AI ๊ณ„๋ณด์— ์†ํ•˜๋Š” ๊ฑฐ์ง€.

1-1. ํ•™์Šต ๋ฐฉ์‹ 3์ด์‚ฌ

๐ŸŽฏ ์ง€๋„ํ•™์Šต (Supervised)์ •๋‹ต(๋ ˆ์ด๋ธ”)์ด ๋ถ™์€ ๋ฐ์ดํ„ฐ๋กœ ํ•™์Šตํ•ด. ์ง‘๊ฐ’ ์˜ˆ์ธก์ฒ˜๋Ÿผ ์ˆซ์ž๋ฅผ ๋งžํžˆ๋ฉด ํšŒ๊ท€, ์ŠคํŒธ/์ •์ƒ์ฒ˜๋Ÿผ ๋ฒ”์ฃผ๋ฅผ ๋งžํžˆ๋ฉด ๋ถ„๋ฅ˜. ์‹ค๋ฌด์—์„œ ๊ฐ€์žฅ ๋งŽ์ด ์“ฐ๋Š” ํ˜•ํƒœ์•ผ.
๐Ÿ” ๋น„์ง€๋„ํ•™์Šต (Unsupervised)์ •๋‹ต ์—†์ด ๋ฐ์ดํ„ฐ ๊ตฌ์กฐ ์ž์ฒด๋ฅผ ํŒŒ์•…ํ•ด. ๊ณ ๊ฐ์„ ๋น„์Šทํ•œ ๊ทธ๋ฃน์œผ๋กœ ๋ฌถ๋Š” ๊ตฐ์ง‘ํ™”, ๋ณ€์ˆ˜๋ฅผ ์••์ถ•ํ•˜๋Š” ์ฐจ์› ์ถ•์†Œ(PCA ๋“ฑ), ์ด์ƒ ํƒ์ง€๊ฐ€ ๋Œ€ํ‘œ ์„ ์ˆ˜.
๐ŸŽฎ ๊ฐ•ํ™”ํ•™์Šต (Reinforcement)์—์ด์ „ํŠธ๊ฐ€ ํ™˜๊ฒฝ๊ณผ ์ƒํ˜ธ์ž‘์šฉํ•˜๋ฉฐ ๋ณด์ƒ์„ ์ตœ๋Œ€ํ™”ํ•˜๋Š” ํ–‰๋™์„ ๋ฐฐ์›Œ. ๋ฐ”๋‘‘ AI ์•ŒํŒŒ๊ณ , ๋กœ๋ด‡ ์ œ์–ด๊ฐ€ ์œ ๋ช…ํ•˜๊ณ , LLM์„ ์‚ฌ๋žŒ ์„ ํ˜ธ์— ๋งž์ถ”๋Š” RLHF์—๋„ ์“ฐ์˜€์–ด.

์š”์ฆ˜์€ ์—ฌ๊ธฐ์— ์ž๊ธฐ์ง€๋„ํ•™์Šต(Self-supervised)๋„ ์ž์ฃผ ๋“ฑ์žฅํ•ด. ๋ฌธ์žฅ์˜ ๋‹ค์Œ ๋‹จ์–ด๋ฅผ ๋งžํžˆ๊ฑฐ๋‚˜ ๊ฐ€๋ ค์ง„ ๋‹จ์–ด๋ฅผ ๋ณต์›ํ•˜๋Š” ์‹์œผ๋กœ, ๋ฐ์ดํ„ฐ ์Šค์Šค๋กœ ์ •๋‹ต์„ ๋งŒ๋“ค์–ด ํ•™์Šตํ•˜๋Š” ๋ฐฉ์‹์ด์•ผ. GPTยทBERT ๊ฐ™์€ ์–ธ์–ด ๋ชจ๋ธ์˜ ์‚ฌ์ „ํ•™์Šต์ด ๋ฐ”๋กœ ์ด ์›๋ฆฌ๋ผ์„œ, ์‚ฌ์‹ค์ƒ ํ˜„๋Œ€ AI ๋ถ์˜ ์—”์ง„์ด๋ผ๊ณ  ๋ด๋„ ๋ผ.

1-2. ์™œ ํ•˜ํ•„ ํŒŒ์ด์ฌ์ด์•ผ?

๋จธ์‹ ๋Ÿฌ๋‹์€ C++์ด๋‚˜ ์ž๋ฐ”๋กœ๋„ ํ•  ์ˆ˜ ์žˆ์–ด. ๊ทธ๋Ÿฐ๋ฐ ์—…๊ณ„ ํ‘œ์ค€์ด ํŒŒ์ด์ฌ์ด ๋œ ๋ฐ์—๋Š” ์ด์œ ๊ฐ€ ์žˆ์ง€.
์ฒซ์งธ, ๋ฌธ๋ฒ•์ด ๊ฐ„๊ฒฐํ•ด์„œ ์‹คํ—˜์„ ๋นจ๋ฆฌ ๋Œ๋ ค๋ณผ ์ˆ˜ ์žˆ์–ด. ๋‘˜์งธ, NumPyยทpandasยทMatplotlib ๊ฐ™์€ ๊ณผํ•™ ๊ณ„์‚ฐ ์ƒํƒœ๊ณ„๊ฐ€ ์˜ค๋ž˜์ „๋ถ€ํ„ฐ ํƒ„ํƒ„ํ–ˆ์–ด. ์…‹์งธ, ๊ฒ‰์€ ํŒŒ์ด์ฌ์ด์ง€๋งŒ ์†(๋ฌด๊ฑฐ์šด ํ–‰๋ ฌ ์—ฐ์‚ฐ)์€ C/C++ยทCUDA๋กœ ๋Œ์•„๊ฐ€์„œ ์†๋„ ์†ํ•ด๊ฐ€ ์ƒ๊ฐ๋ณด๋‹ค ์ ์–ด. ๊ฒฐ๊ตญ โ€œ์‚ฌ๋žŒ์€ ํŽธํ•˜๊ฒŒ, ๊ณ„์‚ฐ์€ ๋น ๋ฅด๊ฒŒโ€๋ผ๋Š” ์กฐํ•ฉ์ด ๋จนํžŒ ๊ฑฐ์•ผ.

2. ๋ชจ๋ธ ๊ฐœ๋ฐœ์˜ ํฐ ๊ทธ๋ฆผ: 7๋‹จ๊ณ„ ํŒŒ์ดํ”„๋ผ์ธ ๐Ÿ—บ๏ธ

๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๊ฐ€ ๋ญ๋“  ๊ฐ„์—, AI ๋ชจ๋ธ ๊ฐœ๋ฐœ์€ ๊ฑฐ์˜ ๊ฐ™์€ ์ˆœ์„œ๋กœ ์ง„ํ–‰๋ผ. ์ด ์ง€๋„๋ฅผ ๋จธ๋ฆฌ์— ๋„ฃ์–ด๋‘๋ฉด ์–ด๋–ค ์ฝ”๋“œ๋ฅผ ๋ด๋„ โ€œ์•„, ์ง€๊ธˆ ๋ช‡ ๋‹จ๊ณ„๊ตฌ๋‚˜โ€ ํ•˜๊ณ  ๊ฐ์ด ์™€.

1๋ฌธ์ œ ์ •์˜ โ€” ๋ถ„๋ฅ˜์ธ์ง€ ํšŒ๊ท€์ธ์ง€, ์„ฑ๊ณต ๊ธฐ์ค€(์ง€ํ‘œ)์€ ๋ญ”์ง€๋ถ€ํ„ฐ ์ •ํ•ด. โ€œ์ •ํ™•๋„ 95%โ€๋ณด๋‹ค โ€œ์‚ฌ๊ธฐ ๊ฑฐ๋ž˜์˜ 80%๋ฅผ ์žก๋˜ ์˜คํƒ์€ 1% ์ดํ•˜โ€ ๊ฐ™์€ ์—…๋ฌด ์–ธ์–ด๊ฐ€ ์ข‹์•„.
2๋ฐ์ดํ„ฐ ์ˆ˜์ง‘ยทํƒ์ƒ‰(EDA) โ€” ๋ถ„ํฌ, ๊ฒฐ์ธก์น˜, ์ด์ƒ์น˜, ํด๋ž˜์Šค ๋ถˆ๊ท ํ˜•์„ ํ™•์ธํ•ด. pandas์˜ describe(), value_counts()๊ฐ€ ๋‹จ๊ณจ์ด์•ผ.
3์ „์ฒ˜๋ฆฌยทํŠน์„ฑ ๊ณตํ•™ โ€” ๊ฒฐ์ธก์น˜ ๋Œ€์ฒด, ์Šค์ผ€์ผ๋ง, ๋ฒ”์ฃผํ˜• ์ธ์ฝ”๋”ฉ, ์ƒˆ๋กœ์šด ํŠน์„ฑ ๋งŒ๋“ค๊ธฐ. ์„ฑ๋Šฅ์˜ ์ƒ๋‹น ๋ถ€๋ถ„์ด ์—ฌ๊ธฐ์„œ ๊ฐˆ๋ ค.
4๋ฐ์ดํ„ฐ ๋ถ„ํ•  โ€” ํ•™์Šต/๊ฒ€์ฆ/ํ…Œ์ŠคํŠธ ์„ธํŠธ๋กœ ๋‚˜๋ˆ . ํ…Œ์ŠคํŠธ ์„ธํŠธ๋Š” ๋งˆ์ง€๋ง‰๊นŒ์ง€ โ€œ๋ด‰์ธโ€ํ•ด ๋‘๋Š” ๊ฒŒ ์›์น™!
5๋ชจ๋ธ ํ•™์Šต โ€” ๊ฐ„๋‹จํ•œ ๋ฒ ์ด์Šค๋ผ์ธ๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ด ์ ์  ๋ณต์žกํ•œ ๋ชจ๋ธ๋กœ ๊ฐ€.
6ํ‰๊ฐ€ยทํŠœ๋‹ โ€” ๊ต์ฐจ ๊ฒ€์ฆ, ํ•˜์ดํผํŒŒ๋ผ๋ฏธํ„ฐ ํƒ์ƒ‰, ์˜ค๋ฅ˜ ๋ถ„์„์„ ๋ฐ˜๋ณตํ•ด.
7๋ฐฐํฌยท๋ชจ๋‹ˆํ„ฐ๋ง โ€” API๋‚˜ ์•ฑ์— ํƒ‘์žฌํ•˜๊ณ , ์‹ค์ œ ๋ฐ์ดํ„ฐ ๋ถ„ํฌ๊ฐ€ ๋ณ€ํ•˜๋Š”์ง€(๋ฐ์ดํ„ฐ ๋“œ๋ฆฌํ”„ํŠธ) ์ง€์ผœ๋ด.
๐Ÿ’ก ๋ฒ ์ด์Šค๋ผ์ธ์˜ ํž˜ ์ฒ˜์Œ๋ถ€ํ„ฐ ๊ฑฐ๋Œ€ํ•œ ์‹ ๊ฒฝ๋ง์„ ์“ฐ์ง€ ๋ง๊ณ , ๋กœ์ง€์Šคํ‹ฑ ํšŒ๊ท€๋‚˜ โ€œ๊ฐ€์žฅ ๋งŽ์€ ํด๋ž˜์Šค๋งŒ ์ฐ๊ธฐโ€ ๊ฐ™์€ ๋‹จ์ˆœ ๋ชจ๋ธ ์ ์ˆ˜๋ฅผ ๋จผ์ € ๊ธฐ๋กํ•ด ๋‘ฌ. ๊ทธ๋ž˜์•ผ ๋ณต์žกํ•œ ๋ชจ๋ธ์ด ์ง„์งœ๋กœ ๋‚˜์•„์ง„ ๊ฑด์ง€ ํŒ๋‹จํ•  ์ˆ˜ ์žˆ์–ด. ์˜์™ธ๋กœ ๋ฒ ์ด์Šค๋ผ์ธ์ด ๊ฝค ๊ฐ•ํ•œ ๊ฒฝ์šฐ๊ฐ€ ๋งŽ์•„์„œ ์‹œ๊ฐ„์„ ํฌ๊ฒŒ ์•„๊ปด์ค˜.

3. Scikit-learn: ์ „ํ†ต ๋จธ์‹ ๋Ÿฌ๋‹์˜ ๊ตญ๋ฏผ ๋„๊ตฌ ๐Ÿงฐ

Scikit-learn(์‚ฌ์ดํ‚ท๋Ÿฐ)์€ 2007๋…„ ๊ตฌ๊ธ€ ์„œ๋จธ ์˜ค๋ธŒ ์ฝ”๋“œ ํ”„๋กœ์ ํŠธ์—์„œ ์ถœ๋ฐœํ•ด ์ปค๋ฎค๋‹ˆํ‹ฐ๊ฐ€ ํ‚ค์›Œ์˜จ ์˜คํ”ˆ์†Œ์Šค ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ์•ผ. ์„ ํ˜• ํšŒ๊ท€, ๊ฒฐ์ • ํŠธ๋ฆฌ, ๋žœ๋ค ํฌ๋ ˆ์ŠคํŠธ, SVM, k-ํ‰๊ท , PCA ๊ฐ™์€ ๊ณ ์ „ ์•Œ๊ณ ๋ฆฌ์ฆ˜ ๋Œ€๋ถ€๋ถ„๊ณผ ์ „์ฒ˜๋ฆฌยทํ‰๊ฐ€ ๋„๊ตฌ๋ฅผ ํ•œ๊ณณ์— ๋ชจ์•„๋†จ์–ด. NumPyยทSciPy ์œ„์—์„œ ๋Œ์•„๊ฐ€๊ณ , ๊ธฐ๋ณธ์ ์œผ๋กœ CPU ๊ธฐ๋ฐ˜์ด์•ผ.

3-1. ์‚ฌ์ดํ‚ท๋Ÿฐ์˜ ๋งˆ๋ฒ• ์ฃผ๋ฌธ: fit / predict / transform

์‚ฌ์ดํ‚ท๋Ÿฐ์ด ์‚ฌ๋ž‘๋ฐ›๋Š” ๊ฐ€์žฅ ํฐ ์ด์œ ๋Š” ์ผ๊ด€๋œ API์•ผ. ๊ฑฐ์˜ ๋ชจ๋“  ๊ฐ์ฒด๊ฐ€ ๊ฐ™์€ ๊ทœ์น™์„ ๋”ฐ๋ฅด๊ฑฐ๋“ .

๊ฐ์ฒด ์ข…๋ฅ˜ํ•ต์‹ฌ ๋ฉ”์„œ๋“œ์˜ˆ์‹œ
Estimator (์ถ”์ •๊ธฐ)fit(X, y)๋ชจ๋“  ๋ชจ๋ธยท๋ณ€ํ™˜๊ธฐ์˜ ๊ณตํ†ต ๋ถ€๋ชจ ๊ฐœ๋…
Predictor (์˜ˆ์ธก๊ธฐ)predict(X), predict_proba(X), score(X, y)LogisticRegression, RandomForestClassifier
Transformer (๋ณ€ํ™˜๊ธฐ)transform(X), fit_transform(X)StandardScaler, OneHotEncoder, PCA

์ด ๋•๋ถ„์— ๋žœ๋ค ํฌ๋ ˆ์ŠคํŠธ๋ฅผ ์“ฐ๋‹ค๊ฐ€ ๊ทธ๋ž˜๋””์–ธํŠธ ๋ถ€์ŠคํŒ…์œผ๋กœ ๋ฐ”๊พธ๊ณ  ์‹ถ์œผ๋ฉด, ๋ณดํ†ต import ํ•œ ์ค„๊ณผ ์ƒ์„ฑ์ž ํ•œ ์ค„๋งŒ ๋ฐ”๊พธ๋ฉด ๋์ด์•ผ. ์ด๊ฒŒ ๋ณ„๊ฒƒ ์•„๋‹Œ ๊ฒƒ ๊ฐ™์ง€๋งŒ ์‹คํ—˜ ์†๋„๋ฅผ ์—„์ฒญ๋‚˜๊ฒŒ ๋Œ์–ด์˜ฌ๋ ค ์ค˜.

3-2. ์ฒซ ๋ชจ๋ธ ๋งŒ๋“ค์–ด๋ณด๊ธฐ: ๋ถ“๊ฝƒ ๋ถ„๋ฅ˜

๋จธ์‹ ๋Ÿฌ๋‹๊ณ„์˜ โ€œHello, World!โ€์ธ ๋ถ“๊ฝƒ(Iris) ๋ฐ์ดํ„ฐ๋กœ ๊ฐ€๋ณด์ž. ๊ฝƒ๋ฐ›์นจยท๊ฝƒ์žŽ์˜ ๊ธธ์ด์™€ ๋„ˆ๋น„ 4๊ฐœ ํŠน์„ฑ์œผ๋กœ ํ’ˆ์ข… 3๊ฐ€์ง€๋ฅผ ๋ถ„๋ฅ˜ํ•˜๋Š” ๋ฌธ์ œ์•ผ.

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

X, y = load_iris(return_X_y=True)

# stratify=y : ํด๋ž˜์Šค ๋น„์œจ์„ ์œ ์ง€ํ•˜๋ฉฐ ๋ถ„ํ• 
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

model = RandomForestClassifier(n_estimators=200, random_state=42)
model.fit(X_train, y_train)          # ํ•™์Šต
pred = model.predict(X_test)         # ์˜ˆ์ธก

print(accuracy_score(y_test, pred))
print(classification_report(y_test, pred))

์ฝ”๋“œ ๋ช‡ ์ค„๋กœ ํ•™์Šตยท์˜ˆ์ธกยทํ‰๊ฐ€๊นŒ์ง€ ๋! random_state๋Š” ๋‚œ์ˆ˜ ์‹œ๋“œ๋ฅผ ๊ณ ์ •ํ•ด์„œ ์‹คํ–‰ํ•  ๋•Œ๋งˆ๋‹ค ๊ฐ™์€ ๊ฒฐ๊ณผ๊ฐ€ ๋‚˜์˜ค๊ฒŒ ํ•ด์ค˜. ์žฌํ˜„์„ฑ์€ ์‹ค๋ฌด์—์„œ ์ƒ๊ฐ๋ณด๋‹ค ํ›จ์”ฌ ์ค‘์š”ํ•ด. ๋™๋ฃŒ๊ฐ€ โ€œ๋‚ด ์ปดํ“จํ„ฐ์—์„  ์ ์ˆ˜๊ฐ€ ๋‹ค๋ฅธ๋ฐ?โ€๋ผ๊ณ  ํ•˜๋Š” ์ˆœ๊ฐ„ ์ง€์˜ฅ๋ฌธ์ด ์—ด๋ฆฌ๊ฑฐ๋“  ๐Ÿ˜‡

3-3. Pipeline๊ณผ ColumnTransformer: ๋ฐ์ดํ„ฐ ๋ˆ„์ˆ˜ ๋ฐฉ์ง€์˜ ํ•ต์‹ฌ

์‹ค์ œ ๋ฐ์ดํ„ฐ๋Š” ์ˆซ์ž, ๋ฒ”์ฃผ, ๊ฒฐ์ธก์น˜๊ฐ€ ๋’ค์„ž์—ฌ ์žˆ์–ด. ์ด๊ฑธ ๋”ฐ๋กœ๋”ฐ๋กœ ์ฒ˜๋ฆฌํ•˜๋‹ค ๋ณด๋ฉด ํ”ํ•˜๊ฒŒ ์ €์ง€๋ฅด๋Š” ์‹ค์ˆ˜๊ฐ€ ์žˆ๋Š”๋ฐ, ๋ฐ”๋กœ ๋ฐ์ดํ„ฐ ๋ˆ„์ˆ˜(Data Leakage)์•ผ. ์˜ˆ๋ฅผ ๋“ค์–ด ์ „์ฒด ๋ฐ์ดํ„ฐ๋กœ ํ‰๊ท ยทํ‘œ์ค€ํŽธ์ฐจ๋ฅผ ๊ตฌํ•ด ์Šค์ผ€์ผ๋งํ•œ ๋’ค ํ•™์Šต/ํ…Œ์ŠคํŠธ๋ฅผ ๋‚˜๋ˆ„๋ฉด, ํ…Œ์ŠคํŠธ ์„ธํŠธ ์ •๋ณด๊ฐ€ ํ•™์Šต์— ๋ชฐ๋ž˜ ์„ž์—ฌ ๋“ค์–ด๊ฐ€์„œ ์ ์ˆ˜๊ฐ€ ์‹ค์ œ๋ณด๋‹ค ๋ถ€ํ’€๋ ค์ ธ.

์‚ฌ์ดํ‚ท๋Ÿฐ์˜ Pipeline์€ ์ „์ฒ˜๋ฆฌ์™€ ๋ชจ๋ธ์„ ํ•˜๋‚˜๋กœ ๋ฌถ์–ด์„œ, fitํ•  ๋•Œ๋Š” ํ•™์Šต ๋ฐ์ดํ„ฐ๋กœ๋งŒ ํ†ต๊ณ„๋ฅผ ๊ณ„์‚ฐํ•˜๊ณ  ์˜ˆ์ธกํ•  ๋•Œ๋Š” ๊ทธ ํ†ต๊ณ„๋ฅผ ๊ทธ๋Œ€๋กœ ์ ์šฉํ•˜๊ฒŒ ํ•ด์ค˜.

import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression

num_cols = ["age", "income"]
cat_cols = ["city", "job"]

preprocess = ColumnTransformer([
    ("num", Pipeline([
        ("impute", SimpleImputer(strategy="median")),
        ("scale", StandardScaler()),
    ]), num_cols),
    ("cat", Pipeline([
        ("impute", SimpleImputer(strategy="most_frequent")),
        ("onehot", OneHotEncoder(handle_unknown="ignore")),
    ]), cat_cols),
])

clf = Pipeline([
    ("prep", preprocess),
    ("model", LogisticRegression(max_iter=1000)),
])

clf.fit(X_train, y_train)
print(clf.score(X_test, y_test))

handle_unknown="ignore"๋Š” ํ•™์Šต ๋•Œ ๋ชป ๋ณธ ๋ฒ”์ฃผ(์˜ˆ: ์ƒˆ๋กœ ์ƒ๊ธด ๋„์‹œ)๊ฐ€ ๋“ค์–ด์™€๋„ ์—๋Ÿฌ ์—†์ด ์ฒ˜๋ฆฌํ•˜๊ฒŒ ํ•ด์ฃผ๋Š” ์˜ต์…˜์ด์•ผ. ์šด์˜ ํ™˜๊ฒฝ์—์„œ ์€๊ทผํžˆ ์ƒ๋ช…์ค„์ด ๋ผ.

3-4. ๊ต์ฐจ ๊ฒ€์ฆ๊ณผ ํ•˜์ดํผํŒŒ๋ผ๋ฏธํ„ฐ ํƒ์ƒ‰

ํ…Œ์ŠคํŠธ ์„ธํŠธ ํ•œ ๋ฒˆ ๋‚˜๋ˆ ์„œ ํ‰๊ฐ€ํ•˜๋ฉด, ์–ด๋–ป๊ฒŒ ๋‚˜๋ˆด๋А๋ƒ์— ๋”ฐ๋ผ ์šด์ด ๊ฐœ์ž…ํ•ด. ๊ทธ๋ž˜์„œ K-๊ฒน ๊ต์ฐจ ๊ฒ€์ฆ(K-Fold Cross Validation)์„ ์จ. ๋ฐ์ดํ„ฐ๋ฅผ K์กฐ๊ฐ์œผ๋กœ ๋‚˜๋ˆ  K๋ฒˆ ๋Œ์•„๊ฐ€๋ฉฐ ํ•œ ์กฐ๊ฐ์„ ๊ฒ€์ฆ์šฉ์œผ๋กœ ์“ฐ๊ณ , ์ ์ˆ˜์˜ ํ‰๊ท ๊ณผ ํ‘œ์ค€ํŽธ์ฐจ๋ฅผ ๋ณด๋Š” ๊ฑฐ์•ผ.

from sklearn.model_selection import cross_val_score, GridSearchCV

scores = cross_val_score(clf, X_train, y_train, cv=5, scoring="f1_macro")
print(scores.mean(), scores.std())

param_grid = {"model__C": [0.01, 0.1, 1, 10]}
search = GridSearchCV(clf, param_grid, cv=5, scoring="f1_macro", n_jobs=-1)
search.fit(X_train, y_train)
print(search.best_params_, search.best_score_)

ํŒŒ์ดํ”„๋ผ์ธ ์•ˆ์˜ ํŒŒ๋ผ๋ฏธํ„ฐ๋Š” ๋‹จ๊ณ„์ด๋ฆ„__ํŒŒ๋ผ๋ฏธํ„ฐ๋ช…์ฒ˜๋Ÿผ ์–ธ๋”์Šค์ฝ”์–ด ๋‘ ๊ฐœ๋กœ ์ ‘๊ทผํ•ด. ํƒ์ƒ‰ ๋ฒ”์œ„๊ฐ€ ๋„“์œผ๋ฉด RandomizedSearchCV๊ฐ€ GridSearch๋ณด๋‹ค ํšจ์œจ์ ์ธ ๊ฒฝ์šฐ๊ฐ€ ๋งŽ๊ณ , ๋” ๋˜‘๋˜‘ํ•œ ํƒ์ƒ‰์ด ํ•„์š”ํ•˜๋ฉด Optuna ๊ฐ™์€ ์™ธ๋ถ€ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ์™€๋„ ์ž˜ ์–ด์šธ๋ ค.

๐ŸŒฒ ํ‘œ ๋ฐ์ดํ„ฐ๋ผ๋ฉด ํŠธ๋ฆฌ ์•™์ƒ๋ธ”์„ ๋จผ์ €! ์—‘์…€์ฒ˜๋Ÿผ ํ–‰ยท์—ด๋กœ ๋œ ์ •ํ˜•(tabular) ๋ฐ์ดํ„ฐ์—์„œ๋Š” ๋”ฅ๋Ÿฌ๋‹๋ณด๋‹ค ๊ทธ๋ž˜๋””์–ธํŠธ ๋ถ€์ŠคํŒ… ๊ณ„์—ด(์‚ฌ์ดํ‚ท๋Ÿฐ์˜ HistGradientBoostingClassifier, ๋˜๋Š” XGBoostยทLightGBMยทCatBoost)์ด ๊ฐ•ํ•œ ๊ฒฝ์šฐ๊ฐ€ ๋งŽ์•„. ์บ๊ธ€ ์ •ํ˜• ๋ฐ์ดํ„ฐ ๋Œ€ํšŒ์—์„œ๋„ ์˜ค๋žซ๋™์•ˆ ์ด ๊ณ„์—ด์ด ์ƒ์œ„๊ถŒ ๋‹จ๊ณจ์ด์—ˆ์ง€. ๋”ฅ๋Ÿฌ๋‹์ด ๋ฌด์กฐ๊ฑด ์ •๋‹ต์€ ์•„๋‹ˆ๋ผ๋Š” ๊ฒƒ, ๊ผญ ๊ธฐ์–ตํ•ด ๋‘ฌ.

3-5. ์‚ฌ์ดํ‚ท๋Ÿฐ์˜ ํ•œ๊ณ„

์‚ฌ์ดํ‚ท๋Ÿฐ์€ ๋ฒ”์šฉ GPU ๊ฐ€์†์„ ๊ธฐ๋ณธ์œผ๋กœ ์ง€์›ํ•˜์ง€ ์•Š๊ณ (์ผ๋ถ€ ๊ธฐ๋Šฅ์˜ ์‹คํ—˜์  Array API ์ง€์›์€ ์žˆ์–ด), ์ด๋ฏธ์ง€ยท์Œ์„ฑยทํ…์ŠคํŠธ ๊ฐ™์€ ๋น„์ •ํ˜• ๋ฐ์ดํ„ฐ๋ฅผ ๋‹ค๋ฃจ๋Š” ๋Œ€๊ทœ๋ชจ ๋”ฅ๋Ÿฌ๋‹์šฉ์œผ๋กœ ์„ค๊ณ„๋˜์ง€ ์•Š์•˜์–ด. ์‹ ๊ฒฝ๋ง ๋ชจ๋ธ(MLPClassifier)์ด ์žˆ๊ธด ํ•˜์ง€๋งŒ ๊ฐ„๋‹จํ•œ ๋‹ค์ธต ํผ์…‰ํŠธ๋ก  ์ˆ˜์ค€์ด์•ผ. ๊ทธ๋ž˜์„œ ์‚ฌ์ง„ ์† ๊ณ ์–‘์ด๋ฅผ ์ฐพ๊ฑฐ๋‚˜ ๋ฌธ์žฅ์„ ์ƒ์„ฑํ•˜๋ ค๋ฉด ๋‹ค์Œ ์ฃผ์ž, TensorFlow์™€ PyTorch๊ฐ€ ๋“ฑํŒํ•  ์ฐจ๋ก€์•ผ.

4. ๋”ฅ๋Ÿฌ๋‹ ๊ธฐ์ดˆ ์ฒด๋ ฅ: ์‹ ๊ฒฝ๋ง๊ณผ ๊ฒฝ์‚ฌํ•˜๊ฐ•๋ฒ• โ›ฐ๏ธ

TensorFlow์™€ PyTorch๋ฅผ ์ œ๋Œ€๋กœ ์“ฐ๋ ค๋ฉด ๋”ฅ๋Ÿฌ๋‹์ด ์–ด๋–ป๊ฒŒ ํ•™์Šตํ•˜๋Š”์ง€ ์›๋ฆฌ๋ฅผ ์žก๊ณ  ๊ฐ€์•ผ ํ•ด. ๊ฑฑ์ • ๋งˆ, ์ˆ˜์‹ ํญํƒ„์€ ์•ˆ ๋˜์งˆ๊ฒŒ.

4-1. ๋‰ด๋Ÿฐ ํ•˜๋‚˜์˜ ์ผ

์ธ๊ณต ๋‰ด๋Ÿฐ ํ•˜๋‚˜๋Š” ์ž…๋ ฅ๊ฐ’์— ๊ฐ€์ค‘์น˜๋ฅผ ๊ณฑํ•ด ๋”ํ•˜๊ณ (ํŽธํ–ฅ ํฌํ•จ), ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ํ™œ์„ฑํ™” ํ•จ์ˆ˜์— ํ†ต๊ณผ์‹œ์ผœ. ์‹์œผ๋กœ ์“ฐ๋ฉด ์ถœ๋ ฅ = ํ™œ์„ฑํ™”(wโ‚xโ‚ + wโ‚‚xโ‚‚ + โ€ฆ + b). ํ™œ์„ฑํ™” ํ•จ์ˆ˜๊ฐ€ ์—†์œผ๋ฉด ์ธต์„ ์•„๋ฌด๋ฆฌ ์Œ“์•„๋„ ๊ฒฐ๊ตญ ํ•˜๋‚˜์˜ ์„ ํ˜• ๋ณ€ํ™˜๊ณผ ๊ฐ™์•„์ ธ์„œ, ๋ณต์žกํ•œ ํŒจํ„ด์„ ๋ชป ๋ฐฐ์›Œ. ๊ทธ๋ž˜์„œ ReLU(์Œ์ˆ˜๋Š” 0, ์–‘์ˆ˜๋Š” ๊ทธ๋Œ€๋กœ), ์‹œ๊ทธ๋ชจ์ด๋“œ, GELU ๊ฐ™์€ ๋น„์„ ํ˜• ํ•จ์ˆ˜๊ฐ€ ํ•„์ˆ˜์•ผ.

4-2. ์†์‹ค ํ•จ์ˆ˜์™€ ๊ฒฝ์‚ฌํ•˜๊ฐ•๋ฒ•

๋ชจ๋ธ์ด ์–ผ๋งˆ๋‚˜ ํ‹€๋ ธ๋Š”์ง€๋ฅผ ์ˆซ์ž ํ•˜๋‚˜๋กœ ํ‘œํ˜„ํ•œ ๊ฒŒ ์†์‹ค ํ•จ์ˆ˜(loss)์•ผ. ํšŒ๊ท€๋Š” ์ฃผ๋กœ ํ‰๊ท ์ œ๊ณฑ์˜ค์ฐจ(MSE), ๋ถ„๋ฅ˜๋Š” ๊ต์ฐจ ์—”ํŠธ๋กœํ”ผ(Cross-Entropy)๋ฅผ ์จ. ํ•™์Šต์˜ ๋ชฉํ‘œ๋Š” ์ด ์†์‹ค์„ ์ตœ์†Œํ™”ํ•˜๋Š” ํŒŒ๋ผ๋ฏธํ„ฐ๋ฅผ ์ฐพ๋Š” ๊ฑฐ๊ณ , ๊ทธ ๋ฐฉ๋ฒ•์ด ๊ฒฝ์‚ฌํ•˜๊ฐ•๋ฒ•(Gradient Descent)์ด์•ผ.

์•ˆ๊ฐœ ๋‚€ ์‚ฐ์—์„œ ๋ˆˆ์„ ๊ฐ€๋ฆฌ๊ณ  ๊ณจ์งœ๊ธฐ๋กœ ๋‚ด๋ ค๊ฐ„๋‹ค๊ณ  ์ƒ์ƒํ•ด ๋ด. ๋ฐœ๋ฐ‘ ๊ฒฝ์‚ฌ(๊ธฐ์šธ๊ธฐ, gradient)๋ฅผ ๋А๊ปด์„œ ๊ฐ€์žฅ ๊ฐ€ํŒŒ๋ฅด๊ฒŒ ๋‚ด๋ ค๊ฐ€๋Š” ๋ฐฉํ–ฅ์œผ๋กœ ํ•œ ๊ฑธ์Œ์”ฉ ์˜ฎ๊ธฐ๋Š” ๊ฑฐ์ง€. ์ด๋•Œ ํ•œ ๊ฑธ์Œ์˜ ํฌ๊ธฐ๊ฐ€ ํ•™์Šต๋ฅ (learning rate)์ด์•ผ.

๊ฒฝ์‚ฌํ•˜๊ฐ•๋ฒ•: ์†์‹ค์˜ ๊ณจ์งœ๊ธฐ ๋‚ด๋ ค๊ฐ€๊ธฐ ํŒŒ๋ผ๋ฏธํ„ฐ w ์†์‹ค ์ตœ์†Ÿ๊ฐ’ ํ•™์Šต๋ฅ ์ด ๋„ˆ๋ฌด ํฌ๋ฉด ์˜คํžˆ๋ ค ํŠ•๊ฒจ ๋‚˜๊ฐ ์ ๋‹นํ•œ ๋ณดํญ์œผ๋กœ ์กฐ๊ธˆ์”ฉ ํ•˜๊ฐ•

์™ผ์ชฝ์€ ์ ์ ˆํ•œ ํ•™์Šต๋ฅ ๋กœ ์ตœ์†Ÿ๊ฐ’์— ๋‹ค๊ฐ€๊ฐ€๋Š” ๋ชจ์Šต, ์˜ค๋ฅธ์ชฝ์€ ํ•™์Šต๋ฅ ์ด ์ปค์„œ ์†์‹ค์ด ๋‹ค์‹œ ์ปค์ง€๋Š” ๋ชจ์Šต

๊ทธ๋Ÿผ ์ˆ˜๋ฐฑ๋งŒ, ์ˆ˜์‹ญ์–ต ๊ฐœ์˜ ํŒŒ๋ผ๋ฏธํ„ฐ ๊ฐ๊ฐ์˜ ๊ธฐ์šธ๊ธฐ๋Š” ์–ด๋–ป๊ฒŒ ๊ตฌํ• ๊นŒ? ์—ฌ๊ธฐ์„œ ์—ญ์ „ํŒŒ(Backpropagation)๊ฐ€ ๋‚˜์™€. ๋ฏธ๋ถ„์˜ ์—ฐ์‡„ ๋ฒ•์น™(chain rule)์„ ์ด์šฉํ•ด ์ถœ๋ ฅ์ธต์—์„œ ์ž…๋ ฅ์ธต ๋ฐฉํ–ฅ์œผ๋กœ ๊ธฐ์šธ๊ธฐ๋ฅผ ํšจ์œจ์ ์œผ๋กœ ๊ณ„์‚ฐํ•˜๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜์ด์•ผ. ๊ทธ๋ฆฌ๊ณ  TensorFlow์™€ PyTorch์˜ ํ•ต์‹ฌ ๋Šฅ๋ ฅ์ด ๋ฐ”๋กœ ์ด๊ฑธ ์ž๋™์œผ๋กœ ํ•ด์ฃผ๋Š” ์ž๋™ ๋ฏธ๋ถ„(Autograd)์ด์ง€. ์šฐ๋ฆฌ๋Š” ์ˆœ์ „ํŒŒ(forward) ๊ณ„์‚ฐ๋งŒ ์“ฐ๋ฉด, ๊ธฐ์šธ๊ธฐ๋Š” ํ”„๋ ˆ์ž„์›Œํฌ๊ฐ€ ์•Œ์•„์„œ ๊ตฌํ•ด์ค˜.

์šฉ์–ด์‰ฝ๊ฒŒ ๋งํ•˜๋ฉด
๋ฐฐ์น˜(batch)ํ•œ ๋ฒˆ์— ๊ธฐ์šธ๊ธฐ๋ฅผ ๊ณ„์‚ฐํ•˜๋Š” ๋ฐ์ดํ„ฐ ๋ฌถ์Œ. ์ „์ฒด๋ฅผ ํ•œ ๋ฒˆ์— ์“ฐ๊ธฐ์—” ๋ฉ”๋ชจ๋ฆฌ๊ฐ€ ๋ถ€์กฑํ•ด์„œ ์ชผ๊ฐœ ์”€
๋ฏธ๋‹ˆ๋ฐฐ์น˜ SGD๋ฐฐ์น˜ ๋‹จ์œ„๋กœ ๊ธฐ์šธ๊ธฐ๋ฅผ ๊ตฌํ•ด ํŒŒ๋ผ๋ฏธํ„ฐ๋ฅผ ๊ฐฑ์‹ ํ•˜๋Š” ๋ฐฉ์‹. ๋”ฅ๋Ÿฌ๋‹ ํ•™์Šต์˜ ๊ธฐ๋ณธ
์—ํญ(epoch)์ „์ฒด ํ•™์Šต ๋ฐ์ดํ„ฐ๋ฅผ ํ•œ ๋ฐ”ํ€ด ๋‹ค ๋ณธ ํšŸ์ˆ˜
์˜ตํ‹ฐ๋งˆ์ด์ €๋ณดํญ๊ณผ ๋ฐฉํ–ฅ์„ ์กฐ์ ˆํ•˜๋Š” ์ „๋žต. SGD+๋ชจ๋ฉ˜ํ…€, Adam, AdamW ๋“ฑ์ด ๋Œ€ํ‘œ์ 
ํ…์„œ(tensor)๋‹ค์ฐจ์› ๋ฐฐ์—ด. ์Šค์นผ๋ผ(0์ฐจ์›)ยท๋ฒกํ„ฐ(1์ฐจ์›)ยทํ–‰๋ ฌ(2์ฐจ์›)์„ ์ผ๋ฐ˜ํ™”ํ•œ ๊ฐœ๋…

5. TensorFlow & Keras: ๊ตฌ๊ธ€์ด ํ‚ค์šด ํ”„๋กœ๋•์…˜ ๊ฐ•์ž ๐Ÿญ

TensorFlow๋Š” ๊ตฌ๊ธ€ ๋ธŒ๋ ˆ์ธ ํŒ€์ด ๊ฐœ๋ฐœํ•ด 2015๋…„ 11์›” ์˜คํ”ˆ์†Œ์Šค๋กœ ๊ณต๊ฐœํ–ˆ์–ด. ์ดˆ๊ธฐ 1.x ์‹œ์ ˆ์—” ์—ฐ์‚ฐ ๊ทธ๋ž˜ํ”„๋ฅผ ๋จผ์ € ์ •์˜ํ•˜๊ณ  ์„ธ์…˜(Session)์œผ๋กœ ์‹คํ–‰ํ•˜๋Š” ๋ฐฉ์‹์ด๋ผ ๋””๋ฒ„๊น…์ด ๊ฝค ๊ณ ํ†ต์Šค๋Ÿฌ์› ๋Š”๋ฐ, 2019๋…„ TensorFlow 2.0์—์„œ ์ฆ‰์‹œ ์‹คํ–‰(Eager Execution)์„ ๊ธฐ๋ณธ์œผ๋กœ ๋ฐ”๊พธ๊ณ  ๊ณ ์ˆ˜์ค€ API์ธ Keras๋ฅผ ๊ณต์‹ ์ธํ„ฐํŽ˜์ด์Šค๋กœ ์ฑ„ํƒํ•˜๋ฉด์„œ ํ›จ์”ฌ ์นœ์ ˆํ•ด์กŒ์–ด.

๐Ÿ“ฐ Keras 3์˜ ๋“ฑ์žฅ 2023๋…„ ๋ง ์ถœ์‹œ๋œ Keras 3๋Š” TensorFlow๋ฟ ์•„๋‹ˆ๋ผ JAX์™€ PyTorch๋„ ๋ฐฑ์—”๋“œ๋กœ ์“ธ ์ˆ˜ ์žˆ๋Š” ๋ฉ€ํ‹ฐ ๋ฐฑ์—”๋“œ ํ”„๋ ˆ์ž„์›Œํฌ๋กœ ๋‹ค์‹œ ํƒœ์–ด๋‚ฌ์–ด. TensorFlow 2.16๋ถ€ํ„ฐ๋Š” tf.keras๊ฐ€ ๊ธฐ๋ณธ์ ์œผ๋กœ Keras 3๋ฅผ ๊ฐ€๋ฆฌํ‚ค๊ฒŒ ๋๊ณ , ์˜ˆ์ „ Keras 2 ๋™์ž‘์ด ํ•„์š”ํ•˜๋ฉด ๋ณ„๋„ ํŒจํ‚ค์ง€(tf_keras)๋ฅผ ์“ฐ๋Š” ์‹์ด์•ผ. ๊ทธ๋ž˜์„œ ์˜ค๋ž˜๋œ ๋ธ”๋กœ๊ทธ ์ฝ”๋“œ๊ฐ€ ์ตœ์‹  ํ™˜๊ฒฝ์—์„œ ์—๋Ÿฌ๊ฐ€ ๋‚˜๋Š” ๊ฒฝ์šฐ๊ฐ€ ์ข…์ข… ์žˆ์–ด. ๋ฒ„์ „ ํ™•์ธ์€ ์Šต๊ด€์ฒ˜๋Ÿผ!

5-1. Keras๋กœ ์†๊ธ€์”จ ์ˆซ์ž ๋ถ„๋ฅ˜ํ•˜๊ธฐ

๋”ฅ๋Ÿฌ๋‹๊ณ„์˜ โ€œHello, World!โ€๋Š” MNIST์•ผ. 28ร—28 ํ”ฝ์…€ ํ‘๋ฐฑ ์†๊ธ€์”จ ์ˆซ์ž(0~9) ์ด๋ฏธ์ง€ 7๋งŒ ์žฅ(ํ•™์Šต 6๋งŒ, ํ…Œ์ŠคํŠธ 1๋งŒ)์œผ๋กœ ๊ตฌ์„ฑ๋ผ ์žˆ์ง€. ์ž‘์€ ํ•ฉ์„ฑ๊ณฑ ์‹ ๊ฒฝ๋ง(CNN)์„ ๋งŒ๋“ค์–ด ๋ณด์ž.

import keras
from keras import layers

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
x_train = x_train[..., None].astype("float32") / 255.0   # (60000, 28, 28, 1)
x_test  = x_test[..., None].astype("float32") / 255.0

model = keras.Sequential([
    keras.Input(shape=(28, 28, 1)),
    layers.Conv2D(32, 3, activation="relu"),
    layers.MaxPooling2D(),
    layers.Conv2D(64, 3, activation="relu"),
    layers.MaxPooling2D(),
    layers.Flatten(),
    layers.Dropout(0.3),
    layers.Dense(10, activation="softmax"),
])

model.compile(
    optimizer="adam",
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"],
)

history = model.fit(
    x_train, y_train,
    batch_size=128, epochs=10,
    validation_split=0.1,
    callbacks=[keras.callbacks.EarlyStopping(patience=2, restore_best_weights=True)],
)

model.evaluate(x_test, y_test)

Keras์˜ ์ฒ ํ•™์€ compile โ†’ fit โ†’ evaluate ์„ธ ๋ฐ•์ž์•ผ. ํ•™์Šต ๋ฃจํ”„๋ฅผ ์ง์ ‘ ์งค ํ•„์š” ์—†์ด, ์˜ตํ‹ฐ๋งˆ์ด์ €ยท์†์‹คยท์ง€ํ‘œ๋งŒ ์ •ํ•ด์ฃผ๋ฉด ๋ฐฐ์น˜ ๋‚˜๋ˆ„๊ธฐ, ๊ธฐ์šธ๊ธฐ ๊ณ„์‚ฐ, ํŒŒ๋ผ๋ฏธํ„ฐ ๊ฐฑ์‹ , ์ง„ํ–‰๋ฅ  ์ถœ๋ ฅ๊นŒ์ง€ ๋‹ค ํ•ด์ค˜. ์ด ์ •๋„ CNN์ด๋ฉด MNIST ํ…Œ์ŠคํŠธ ์ •ํ™•๋„๊ฐ€ ๋Œ€๋žต 99% ์•ˆํŒŽ๊นŒ์ง€ ๋‚˜์˜ค๋Š” ๊ฒŒ ์ผ๋ฐ˜์ ์ด์•ผ.

์—ฌ๊ธฐ์„œ sparse_categorical_crossentropy๋Š” ์ •๋‹ต์ด ์›-ํ•ซ ๋ฒกํ„ฐ๊ฐ€ ์•„๋‹ˆ๋ผ ์ •์ˆ˜(0~9)์ผ ๋•Œ ์“ฐ๋Š” ์†์‹ค์ด์•ผ. ์ •๋‹ต์„ ์›-ํ•ซ์œผ๋กœ ๋ฐ”๊ฟจ๋‹ค๋ฉด categorical_crossentropy๋ฅผ ์จ์•ผ ํ•ด. ์ด๊ฑฐ ํ—ท๊ฐˆ๋ ค์„œ shape ์—๋Ÿฌ ๋ณด๋Š” ๊ฒŒ ์ž…๋ฌธ์ž ๊ตญ๋ฃฐ์ด์•ผ ๐Ÿ™ƒ

5-2. Keras ๋ชจ๋ธ์„ ๋งŒ๋“œ๋Š” ์„ธ ๊ฐ€์ง€ ๋ฐฉ๋ฒ•

โ‘  Sequential API์ธต์„ ์ˆœ์„œ๋Œ€๋กœ ์Œ“๋Š” ๊ฐ€์žฅ ๊ฐ„๋‹จํ•œ ๋ฐฉ์‹. ์ž…๋ ฅ ํ•˜๋‚˜, ์ถœ๋ ฅ ํ•˜๋‚˜์ธ ์ผ์žํ˜• ๋ชจ๋ธ์— ๋”ฑ์ด์•ผ.
โ‘ก Functional API์ธต์„ ํ•จ์ˆ˜์ฒ˜๋Ÿผ ์—ฐ๊ฒฐํ•ด ๋‹ค์ค‘ ์ž…๋ ฅยท๋‹ค์ค‘ ์ถœ๋ ฅ, ์ž”์ฐจ ์—ฐ๊ฒฐ(skip connection) ๊ฐ™์€ ๋ณต์žกํ•œ ๊ตฌ์กฐ๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ์–ด.
โ‘ข Model ์„œ๋ธŒํด๋ž˜์‹ฑkeras.Model์„ ์ƒ์†ํ•ด call()์„ ์ง์ ‘ ์ •์˜. ๊ฐ€์žฅ ์ž์œ ๋กญ์ง€๋งŒ ์ฝ”๋“œ ๊ด€๋ฆฌ ์ฑ…์ž„๋„ ์ปค์ ธ.

5-3. tf.data์™€ tf.function: ์†๋„๋ฅผ ์œ„ํ•œ ๋‘ ๋ฌด๊ธฐ

๋ฐ์ดํ„ฐ๊ฐ€ ๋ฉ”๋ชจ๋ฆฌ์— ๋‹ค ์•ˆ ๋“ค์–ด๊ฐˆ ๋งŒํผ ํฌ๋ฉด tf.data API๋กœ ์ž…๋ ฅ ํŒŒ์ดํ”„๋ผ์ธ์„ ๋งŒ๋“ค์–ด. ํŒŒ์ผ์„ ์ฝ๊ณ , ์„ž๊ณ (shuffle), ๋ฐฐ์น˜๋กœ ๋ฌถ๊ณ , ๋‹ค์Œ ๋ฐฐ์น˜๋ฅผ ๋ฏธ๋ฆฌ ์ค€๋น„(prefetch)ํ•˜๋Š” ๊ณผ์ •์„ GPU ํ•™์Šต๊ณผ ๋ณ‘๋ ฌ๋กœ ์ฒ˜๋ฆฌํ•ด์„œ GPU๊ฐ€ ๋…ธ๋Š” ์‹œ๊ฐ„์„ ์ค„์—ฌ์ค˜.

import tensorflow as tf

ds = (tf.data.Dataset.from_tensor_slices((x_train, y_train))
        .shuffle(10_000)
        .batch(128)
        .prefetch(tf.data.AUTOTUNE))

@tf.function ๋ฐ์ฝ”๋ ˆ์ดํ„ฐ๋Š” ํŒŒ์ด์ฌ ํ•จ์ˆ˜๋ฅผ TensorFlow ๊ทธ๋ž˜ํ”„๋กœ ๋ณ€ํ™˜(ํŠธ๋ ˆ์ด์‹ฑ)ํ•ด์„œ ์ตœ์ ํ™”๋œ ํ˜•ํƒœ๋กœ ์‹คํ–‰ํ•ด ์ค˜. ์ฆ‰์‹œ ์‹คํ–‰์˜ ํŽธ๋ฆฌํ•จ๊ณผ ๊ทธ๋ž˜ํ”„ ์‹คํ–‰์˜ ์†๋„๋ฅผ ๋‘˜ ๋‹ค ์ฑ™๊ธฐ๋Š” ์žฅ์น˜์•ผ. Keras์˜ fit()์€ ๋‚ด๋ถ€์ ์œผ๋กœ ์ด๋ฏธ ์ด๊ฑธ ํ™œ์šฉํ•˜๊ณ  ์žˆ์–ด.

5-4. TensorFlow ์ƒํƒœ๊ณ„์˜ ์ง„์งœ ๋ฌด๊ธฐ: ๋ฐฐํฌ

TensorFlow๊ฐ€ ์˜ค๋žซ๋™์•ˆ ๊ธฐ์—…์—์„œ ์‚ฌ๋ž‘๋ฐ›์€ ์ด์œ ๋Š” ๋ฐฐํฌ ๋„๊ตฌ๊ฐ€ ํ’๋ถ€ํ•ด์„œ์•ผ.

๋„๊ตฌ์šฉ๋„
SavedModel๋ชจ๋ธ ๊ตฌ์กฐยท๊ฐ€์ค‘์น˜ยท์—ฐ์‚ฐ ๊ทธ๋ž˜ํ”„๋ฅผ ํ†ต์งธ๋กœ ์ €์žฅํ•˜๋Š” TensorFlow ํ‘œ์ค€ ํฌ๋งท
TensorFlow Serving์ €์žฅํ•œ ๋ชจ๋ธ์„ REST/gRPC API ์„œ๋ฒ„๋กœ ๋„์šฐ๋Š” ๊ณ ์„ฑ๋Šฅ ์„œ๋น™ ์‹œ์Šคํ…œ
TensorFlow Lite (LiteRT)๋ชจ๋ฐ”์ผยท์ž„๋ฒ ๋””๋“œ ๊ธฐ๊ธฐ์šฉ ๊ฒฝ๋Ÿ‰ ๋Ÿฐํƒ€์ž„. ์–‘์žํ™”๋กœ ๋ชจ๋ธ ํฌ๊ธฐยท์ง€์—ฐ์‹œ๊ฐ„ ๊ฐ์†Œ. ๊ตฌ๊ธ€์€ ์ตœ๊ทผ ์ด ๋Ÿฐํƒ€์ž„์„ LiteRT๋ผ๋Š” ์ด๋ฆ„์œผ๋กœ ๋ฆฌ๋ธŒ๋žœ๋”ฉํ–ˆ์–ด
TensorFlow.js๋ธŒ๋ผ์šฐ์ €์™€ Node.js์—์„œ ๋ชจ๋ธ ์‹คํ–‰
TFX๋ฐ์ดํ„ฐ ๊ฒ€์ฆ๋ถ€ํ„ฐ ๋ฐฐํฌ๊นŒ์ง€ ์—”๋“œํˆฌ์—”๋“œ ML ํŒŒ์ดํ”„๋ผ์ธ ํ”Œ๋žซํผ
โš ๏ธ ์œˆ๋„์šฐ GPU ์‚ฌ์šฉ์ž ์ฃผ์˜ TensorFlow๋Š” 2.10 ๋ฒ„์ „ ์ดํ›„ ๋„ค์ดํ‹ฐ๋ธŒ ์œˆ๋„์šฐ์—์„œ์˜ GPU ์ง€์›์„ ์ค‘๋‹จํ–ˆ์–ด. ์œˆ๋„์šฐ์—์„œ GPU๋กœ ํ•™์Šตํ•˜๋ ค๋ฉด WSL2(๋ฆฌ๋ˆ…์Šค์šฉ ์œˆ๋„์šฐ ํ•˜์œ„ ์‹œ์Šคํ…œ)๋ฅผ ์“ฐ๋Š” ๊ฒƒ์ด ๊ณต์‹ ๊ถŒ์žฅ ๋ฐฉ๋ฒ•์ด์•ผ. โ€œ์„ค์น˜๋Š” ๋๋Š”๋ฐ GPU๋ฅผ ๋ชป ์žก์•„์š”โ€์˜ ์ƒ๋‹น์ˆ˜๊ฐ€ ์ด ๋ฌธ์ œ๋ผ์„œ ๋ฏธ๋ฆฌ ์•Œ์•„๋‘๋ฉด ๋ฐ˜๋‚˜์ ˆ์€ ์•„๊ปด.

6. PyTorch: ์—ฐ๊ตฌ์‹ค์—์„œ ์‹œ์ž‘ํ•ด ์—…๊ณ„ ํ‘œ์ค€์ด ๋œ ์นœ๊ตฌ ๐Ÿ”ฅ

PyTorch๋Š” ํŽ˜์ด์Šค๋ถ(ํ˜„ ๋ฉ”ํƒ€) AI ์—ฐ๊ตฌํŒ€์ด ๊ฐœ๋ฐœํ•ด 2016๋…„ ๊ณต๊ฐœํ–ˆ์–ด. 2022๋…„์—๋Š” ๋ฆฌ๋ˆ…์Šค ์žฌ๋‹จ ์‚ฐํ•˜ PyTorch ์žฌ๋‹จ์œผ๋กœ ์ด๊ด€๋˜์–ด ํŠน์ • ๊ธฐ์—…์ด ์•„๋‹Œ ์ค‘๋ฆฝ ์žฌ๋‹จ์ด ๊ด€๋ฆฌํ•˜๊ณ  ์žˆ์ง€. ํŠน์ง•์€ ํ•œ๋งˆ๋””๋กœ โ€œ๊ทธ๋ƒฅ ํŒŒ์ด์ฌ์ฒ˜๋Ÿผ ์“ด๋‹คโ€์•ผ. ์ฒ˜์Œ๋ถ€ํ„ฐ ์ฆ‰์‹œ ์‹คํ–‰(define-by-run) ๋ฐฉ์‹์ด๋ผ ์ฝ”๋“œ๊ฐ€ ์“ฐ์ธ ์ˆœ์„œ๋Œ€๋กœ ์‹คํ–‰๋˜๊ณ , ์ผ๋ฐ˜ ํŒŒ์ด์ฌ ๋””๋ฒ„๊ฑฐ๋กœ ์ค‘๊ฐ„๊ฐ’์„ ์ฐ์–ด๋ณผ ์ˆ˜ ์žˆ์–ด.

์ด ์ง๊ด€์„ฑ ๋•๋ถ„์— ํ•™๊ณ„์—์„œ ๋น ๋ฅด๊ฒŒ ํผ์กŒ๊ณ , ์ง€๊ธˆ์€ ์ฃผ์š” AI ํ•™ํšŒ ๋…ผ๋ฌธ ๊ตฌํ˜„๊ณผ Hugging Face์˜ Transformers ์ƒํƒœ๊ณ„, ๋Œ€ํ˜• ์–ธ์–ด ๋ชจ๋ธ(LLM) ํ•™์Šต์—์„œ ์‚ฌ์‹ค์ƒ ์ฃผ๋ฅ˜ ์ž๋ฆฌ๋ฅผ ์ฐจ์ง€ํ•˜๊ณ  ์žˆ์–ด. Papers with Code ๊ฐ™์€ ๋…ผ๋ฌธ ๊ตฌํ˜„ ํ†ต๊ณ„์—์„œ๋„ PyTorch ๋น„์ค‘์ด ์••๋„์ ์œผ๋กœ ๋†’๊ฒŒ ๋‚˜ํƒ€๋‚˜๊ณค ํ–ˆ์ง€.

6-1. ํ…์„œ์™€ ์ž๋™ ๋ฏธ๋ถ„ ๋ง›๋ณด๊ธฐ

import torch

x = torch.tensor(3.0, requires_grad=True)
y = x**2 + 2*x + 1        # y = (x+1)^2
y.backward()              # ์—ญ์ „ํŒŒ
print(x.grad)             # dy/dx = 2x + 2 = 8.0

requires_grad=True๋กœ ํ‘œ์‹œํ•œ ํ…์„œ๋Š” ์—ฐ์‚ฐ ๊ธฐ๋ก์ด ๋‚จ๊ณ , backward()๋ฅผ ํ˜ธ์ถœํ•˜๋ฉด ๊ธฐ์šธ๊ธฐ๊ฐ€ .grad์— ์Œ“์—ฌ. ์†์œผ๋กœ ๋ฏธ๋ถ„ํ•˜๋ฉด 2x+2๋‹ˆ๊นŒ x=3์—์„œ 8. ์ •ํ™•ํžˆ ๋งž์ง€? ์ด๊ฒŒ ์ˆ˜์‹ญ์–ต ํŒŒ๋ผ๋ฏธํ„ฐ ๋ชจ๋ธ์—์„œ๋„ ๋˜‘๊ฐ™์ด ๋Œ์•„๊ฐ„๋‹ค๋Š” ๊ฒŒ ๋†€๋ผ์šด ํฌ์ธํŠธ์•ผ.

6-2. PyTorch ๋ชจ๋ธ์˜ ๊ธฐ๋ณธ ๊ณจ๊ฒฉ

PyTorch๋Š” ๋ชจ๋ธ์„ nn.Module์„ ์ƒ์†ํ•œ ํด๋ž˜์Šค๋กœ ๋งŒ๋“ค๊ณ , ํ•™์Šต ๋ฃจํ”„๋Š” ์ง์ ‘ ์จ. ์ฒ˜์Œ์—” Keras๋ณด๋‹ค ์ฝ”๋“œ๊ฐ€ ๊ธธ์–ด ๋ณด์ด์ง€๋งŒ, ๋ฃจํ”„ ์•ˆ์—์„œ ๋ญ๋“  ํ•  ์ˆ˜ ์žˆ๋‹ค๋Š” ์ž์œ ๊ฐ€ ์—ฐ๊ตฌ์ž๋“ค์„ ์‚ฌ๋กœ์žก์•˜์–ด.

import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

device = "cuda" if torch.cuda.is_available() else "cpu"

tfm = transforms.ToTensor()
train_ds = datasets.MNIST("data", train=True, download=True, transform=tfm)
test_ds  = datasets.MNIST("data", train=False, download=True, transform=tfm)
train_dl = DataLoader(train_ds, batch_size=128, shuffle=True)
test_dl  = DataLoader(test_ds, batch_size=256)

class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(1, 32, 3), nn.ReLU(), nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 3), nn.ReLU(), nn.MaxPool2d(2),
        )
        self.head = nn.Sequential(
            nn.Flatten(), nn.Dropout(0.3), nn.Linear(64 * 5 * 5, 10)
        )

    def forward(self, x):
        return self.head(self.features(x))

model = Net().to(device)
loss_fn = nn.CrossEntropyLoss()          # ๋‚ด๋ถ€์— softmax ํฌํ•จ!
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

for epoch in range(5):
    model.train()
    for xb, yb in train_dl:
        xb, yb = xb.to(device), yb.to(device)
        optimizer.zero_grad()            # 1) ๊ธฐ์šธ๊ธฐ ์ดˆ๊ธฐํ™”
        loss = loss_fn(model(xb), yb)    # 2) ์ˆœ์ „ํŒŒ + ์†์‹ค
        loss.backward()                  # 3) ์—ญ์ „ํŒŒ
        optimizer.step()                 # 4) ํŒŒ๋ผ๋ฏธํ„ฐ ๊ฐฑ์‹ 

    model.eval()
    correct = 0
    with torch.no_grad():                # ํ‰๊ฐ€ ๋• ๊ธฐ์šธ๊ธฐ ๊ณ„์‚ฐ ๋„๊ธฐ
        for xb, yb in test_dl:
            pred = model(xb.to(device)).argmax(1)
            correct += (pred == yb.to(device)).sum().item()
    print(epoch, correct / len(test_ds))

ํ•™์Šต ๋ฃจํ”„์˜ ํ•ต์‹ฌ์€ ๋”ฑ 4๋ฐ•์ž์•ผ. zero_grad โ†’ forward โ†’ backward โ†’ step. ์ด๊ฑฐ ํ•˜๋‚˜๋งŒ ์™ธ์›Œ๋„ PyTorch ์ฝ”๋“œ์˜ 70%๋Š” ์ฝํ˜€.

โš ๏ธ PyTorch ์ž…๋ฌธ์ž 3๋Œ€ ์‹ค์ˆ˜ โ‘  optimizer.zero_grad()๋ฅผ ๋นผ๋จน๊ธฐ โ†’ PyTorch๋Š” ๊ธฐ์šธ๊ธฐ๋ฅผ ๋ˆ„์ ํ•˜๊ธฐ ๋•Œ๋ฌธ์— ํ•™์Šต์ด ์ด์ƒํ•˜๊ฒŒ ํŠ€์–ด.
โ‘ก nn.CrossEntropyLoss ์•ž์— softmax๋ฅผ ๋˜ ๋„ฃ๊ธฐ โ†’ ์ด ์†์‹ค ํ•จ์ˆ˜๋Š” ๋‚ด๋ถ€์ ์œผ๋กœ log-softmax๋ฅผ ๊ณ„์‚ฐํ•˜๋‹ˆ๊นŒ ๋ชจ๋ธ ๋งˆ์ง€๋ง‰์—” raw ์ ์ˆ˜(logits)๋ฅผ ๋‚ด๋ณด๋‚ด์•ผ ํ•ด. Keras ์˜ˆ์ œ์™€ ๋‹ฌ๋ฆฌ ๋งˆ์ง€๋ง‰ ์ธต์— softmax๊ฐ€ ์—†๋Š” ์ด์œ ์•ผ.
โ‘ข model.eval()๊ณผ model.train() ์ „ํ™˜์„ ์žŠ๊ธฐ โ†’ Dropout๊ณผ BatchNorm์€ ํ•™์Šต/์ถ”๋ก  ๋ชจ๋“œ์—์„œ ๋‹ค๋ฅด๊ฒŒ ๋™์ž‘ํ•ด์„œ, ํ‰๊ฐ€ ์ ์ˆ˜๊ฐ€ ๋“ค์‘ฅ๋‚ ์‘ฅํ•ด์ ธ.

6-3. ์ฝ”๋“œ ์† ์ˆซ์ž 64*5*5๋Š” ์–ด๋””์„œ ์™”์„๊นŒ?

์ด๋Ÿฐ ๋””ํ…Œ์ผ์ด ์ง„์งœ ์‹ค๋ ฅ์ด๋‹ˆ๊นŒ ์งš๊ณ  ๊ฐ€์ž. ์ž…๋ ฅ 28ร—28์— 3ร—3 ํ•ฉ์„ฑ๊ณฑ(ํŒจ๋”ฉ ์—†์Œ)์„ ํ•˜๋ฉด 26ร—26, 2ร—2 ํ’€๋ง์œผ๋กœ 13ร—13. ๋‹ค์‹œ 3ร—3 ํ•ฉ์„ฑ๊ณฑ์ด๋ฉด 11ร—11, ํ’€๋งํ•˜๋ฉด 5ร—5(๋‚ด๋ฆผ). ์ฑ„๋„์ด 64๊ฐœ๋‹ˆ๊นŒ ํŽผ์น˜๋ฉด 64ร—5ร—5 = 1,600๊ฐœ ํŠน์„ฑ์ด ๋˜๋Š” ๊ฑฐ์•ผ. ํ•ฉ์„ฑ๊ณฑ ์ถœ๋ ฅ ํฌ๊ธฐ ๊ณต์‹์€ (์ž…๋ ฅ โˆ’ ์ปค๋„ + 2ร—ํŒจ๋”ฉ) รท ์ŠคํŠธ๋ผ์ด๋“œ + 1. shape ์—๋Ÿฌ๊ฐ€ ๋‚˜๋ฉด ์ด ๊ณต์‹์œผ๋กœ ์†๊ณ„์‚ฐํ•ด ๋ณด๋Š” ๊ฒŒ ์ œ์ผ ๋นจ๋ผ.

6-4. PyTorch 2.x์™€ torch.compile

2023๋…„ ๊ณต๊ฐœ๋œ PyTorch 2.0์˜ ๊ฐ„ํŒ ๊ธฐ๋Šฅ์€ torch.compile์ด์•ผ. ๋ชจ๋ธ์— ํ•œ ์ค„๋งŒ ๊ฐ์‹ธ๋ฉด ํŒŒ์ด์ฌ ์ฝ”๋“œ๋ฅผ ๊ทธ๋ž˜ํ”„๋กœ ์บก์ฒ˜ํ•˜๊ณ  ์ตœ์ ํ™”๋œ ์ปค๋„์„ ์ƒ์„ฑํ•ด์„œ ์†๋„๋ฅผ ๋Œ์–ด์˜ฌ๋ ค ์ค˜. ์ฆ‰์‹œ ์‹คํ–‰์˜ ํŽธ๋ฆฌํ•จ์€ ๊ทธ๋Œ€๋กœ ๋‘๊ณ  ์„ฑ๋Šฅ์€ ์ปดํŒŒ์ผ๋Ÿฌ๊ฐ€ ์ฑ™๊ธฐ๋Š” ๋ฐฉ์‹์ด์ง€. TensorFlow์˜ tf.function๊ณผ ๋น„์Šทํ•œ ๋ชฉํ‘œ๋ฅผ ๋‹ค๋ฅธ ๋ฐฉ์‹์œผ๋กœ ํ‘ผ ์…ˆ์ด์•ผ.

model = torch.compile(model)   # ๊ธฐ์กด ์ฝ”๋“œ๋Š” ๊ทธ๋Œ€๋กœ, ์ด ํ•œ ์ค„ ์ถ”๊ฐ€

๋‹ค๋งŒ ๋ชจ๋“  ๋ชจ๋ธยทํ™˜๊ฒฝ์—์„œ ํ•ญ์ƒ ๋นจ๋ผ์ง€๋Š” ๊ฑด ์•„๋‹ˆ๊ณ , ์ฒซ ์‹คํ–‰ ๋•Œ ์ปดํŒŒ์ผ ์‹œ๊ฐ„์ด ๋“ค์–ด. ์ž‘์€ ์‹คํ—˜๋ณด๋‹ค๋Š” ์˜ค๋ž˜ ๋Œ๋ฆฌ๋Š” ํ•™์Šต์—์„œ ํšจ๊ณผ๋ฅผ ๋ณด๋Š” ๊ฒฝ์šฐ๊ฐ€ ๋งŽ์•„.

6-5. PyTorch ์ƒํƒœ๊ณ„

torchvision ๐Ÿ–ผ๏ธ ์ด๋ฏธ์ง€ torchaudio ๐ŸŽต ์Œ์„ฑ Hugging Face Transformers ๐Ÿค— PyTorch Lightning โšก TorchServe ExecuTorch ๐Ÿ“ฑ ์˜จ๋””๋ฐ”์ด์Šค ONNX ๋‚ด๋ณด๋‚ด๊ธฐ

ํŠนํžˆ PyTorch Lightning์€ ๋ฐ˜๋ณต๋˜๋Š” ํ•™์Šต ๋ฃจํ”„ ๋ณด์ผ๋Ÿฌํ”Œ๋ ˆ์ดํŠธ๋ฅผ ์ •๋ฆฌํ•ด์„œ, PyTorch์˜ ์ž์œ ๋„๋Š” ์œ ์ง€ํ•˜๋ฉด์„œ Keras์ฒ˜๋Ÿผ ๊น”๋”ํ•˜๊ฒŒ ์“ฐ๊ฒŒ ํ•ด์ฃผ๋Š” ๋ž˜ํผ์•ผ. โ€œ๋ฃจํ”„ ์ง์ ‘ ์งœ๋Š” ๊ฑฐ ๊ท€์ฐฎ์€๋ฐ Keras๋กœ ๊ฐˆ์•„ํƒ€๊ธด ์‹ซ๋‹คโ€๋Š” ์‚ฌ๋žŒ๋“ค์—๊ฒŒ ์ธ๊ธฐ๊ฐ€ ๋งŽ์•„.

7. 3๋Œ€์žฅ ํ•œ๋ˆˆ์— ๋น„๊ต โš–๏ธ

ํ•ญ๋ชฉScikit-learnTensorFlow (Keras)PyTorch
์ฃผ ์šฉ๋„์ „ํ†ต ๋จธ์‹ ๋Ÿฌ๋‹, ์ •ํ˜• ๋ฐ์ดํ„ฐ๋”ฅ๋Ÿฌ๋‹ ํ•™์Šตยท๋Œ€๊ทœ๋ชจ ๋ฐฐํฌ๋”ฅ๋Ÿฌ๋‹ ์—ฐ๊ตฌยท๊ฐœ๋ฐœ, LLM
GPU ๊ฐ€์†๊ธฐ๋ณธ ๋ฏธ์ง€์›(CPU ์ค‘์‹ฌ)์ง€์›(GPUยทTPU)์ง€์›(CUDA, ROCm, Apple MPS ๋“ฑ)
ํ•™์Šต ๋ฐฉ์‹fit() ํ•œ ์ค„compile() + fit()ํ•™์Šต ๋ฃจํ”„ ์ง์ ‘ ์ž‘์„ฑ
๋Ÿฌ๋‹ ์ปค๋ธŒ๊ฐ€์žฅ ์™„๋งŒKeras๋Š” ์™„๋งŒ, ์ €์ˆ˜์ค€์€ ๊ฐ€ํŒŒ๋ฆ„์ค‘๊ฐ„(ํŒŒ์ด์ฌ์— ์ต์ˆ™ํ•˜๋ฉด ์ž์—ฐ์Šค๋Ÿฌ์›€)
๋””๋ฒ„๊น…์‰ฌ์›€์ฆ‰์‹œ ์‹คํ–‰์œผ๋กœ ๊ฐœ์„ ๋จํŒŒ์ด์ฌ ๋””๋ฒ„๊ฑฐ๋กœ ์ง๊ด€์ 
๋ฐฐํฌ ๋„๊ตฌjoblib/pickle, ONNX ๋ณ€ํ™˜TF Serving, TFLite(LiteRT), TF.jsTorchServe, ExecuTorch, ONNX
๋Œ€ํ‘œ ์‚ฌ์šฉ์ฒ˜์‹ ์šฉํ‰๊ฐ€, ์ˆ˜์š”์˜ˆ์ธก, ์ดํƒˆ ์˜ˆ์ธก๋ชจ๋ฐ”์ผ ๋น„์ „, ๊ธฐ์—… ํ”„๋กœ๋•์…˜๋…ผ๋ฌธ ๊ตฌํ˜„, ์ƒ์„ฑํ˜• AI, ํŒŒ์ธํŠœ๋‹
๐Ÿงญ ๊ทธ๋ž˜์„œ ๋ญ๋ถ€ํ„ฐ ๋ฐฐ์›Œ? ์ •๋‹ต์€ โ€œ์…‹ ๋‹ค ๋‹ค๋ฅธ ์—ญํ• โ€์ด์•ผ. ์ถ”์ฒœ ๊ฒฝ๋กœ๋Š” ์‚ฌ์ดํ‚ท๋Ÿฐ์œผ๋กœ ๋จธ์‹ ๋Ÿฌ๋‹ ๊ฐœ๋…(๋ถ„ํ• ยท๊ฒ€์ฆยท์ง€ํ‘œ)์„ ๋จผ์ € ์ตํžˆ๊ณ  โ†’ ๋”ฅ๋Ÿฌ๋‹์€ PyTorch ๋˜๋Š” Keras ์ค‘ ํ•˜๋‚˜๋กœ ๊นŠ๊ฒŒ ๋“ค์–ด๊ฐ€๋Š” ๊ฒƒ. ์ตœ๊ทผ ๊ณต๊ฐœ๋˜๋Š” ์ƒ์„ฑํ˜• AI ๋ชจ๋ธ๊ณผ ํŠœํ† ๋ฆฌ์–ผ์€ PyTorch ๊ธฐ๋ฐ˜์ด ๋งŽ๊ณ , ๋น ๋ฅธ ํ”„๋กœํ† ํƒ€์ดํ•‘๊ณผ ๋ชจ๋ฐ”์ผ ๋ฐฐํฌ๋Š” Keras/TensorFlow๊ฐ€ ํŽธํ•ด. ํ•˜๋‚˜๋ฅผ ์ œ๋Œ€๋กœ ์ตํžˆ๋ฉด ๋‹ค๋ฅธ ํ•˜๋‚˜๋Š” ๋ฌธ๋ฒ•๋งŒ ๊ฐˆ์•„๋ผ์šฐ๋Š” ์ˆ˜์ค€์ด๋ผ ์ƒ๊ฐ๋ณด๋‹ค ๊ธˆ๋ฐฉ ๋”ฐ๋ผ๊ฐ€.

8. ๋ชจ๋ธ ํ‰๊ฐ€: ์ •ํ™•๋„๋งŒ ๋ฏฟ์œผ๋ฉด ํฐ์ผ ๋‚˜ ๐Ÿ“

์•” ํ™˜์ž๊ฐ€ 1%์ธ ๋ฐ์ดํ„ฐ์—์„œ โ€œ๋ชจ๋‘ ์ •์ƒโ€์ด๋ผ๊ณ  ์ฐ๋Š” ๋ชจ๋ธ์˜ ์ •ํ™•๋„๋Š”? 99%์•ผ. ๊ทธ๋Ÿฐ๋ฐ ์ด ๋ชจ๋ธ์€ ์•” ํ™˜์ž๋ฅผ ํ•œ ๋ช…๋„ ๋ชป ์ฐพ์•„. ๊ทธ๋ž˜์„œ ๋ถ„๋ฅ˜ ๋ฌธ์ œ์—์„  ํ˜ผ๋™ ํ–‰๋ ฌ(Confusion Matrix)์„ ๊ธฐ๋ฐ˜์œผ๋กœ ์—ฌ๋Ÿฌ ์ง€ํ‘œ๋ฅผ ํ•จ๊ป˜ ๋ด์•ผ ํ•ด.

์ง€ํ‘œ๊ณ„์‚ฐ์–ธ์ œ ์ค‘์š”ํ•ด?
์ •๋ฐ€๋„(Precision)TP รท (TP + FP)โ€œ์–‘์„ฑ์ด๋ผ๊ณ  ํ•œ ๊ฒƒ ์ค‘ ์ง„์งœ ๋น„์œจโ€. ์ŠคํŒธ ํ•„ํ„ฐ์ฒ˜๋Ÿผ ์˜คํƒ์ด ์น˜๋ช…์ ์ผ ๋•Œ
์žฌํ˜„์œจ(Recall)TP รท (TP + FN)โ€œ์ง„์งœ ์–‘์„ฑ ์ค‘ ์žก์•„๋‚ธ ๋น„์œจโ€. ์งˆ๋ณ‘ ์ง„๋‹จยท์‚ฌ๊ธฐ ํƒ์ง€์ฒ˜๋Ÿผ ๋†“์น˜๋ฉด ์•ˆ ๋  ๋•Œ
F1 ์ ์ˆ˜์ •๋ฐ€๋„์™€ ์žฌํ˜„์œจ์˜ ์กฐํ™”ํ‰๊ท ๋‘˜ ์‚ฌ์ด ๊ท ํ˜•์ด ํ•„์š”ํ•  ๋•Œ, ๋ถˆ๊ท ํ˜• ๋ฐ์ดํ„ฐ
ROC-AUC์ž„๊ณ„๊ฐ’ ์ „์ฒด์— ๊ฑธ์นœ TPR-FPR ๊ณก์„  ์•„๋ž˜ ๋ฉด์ ์ž„๊ณ„๊ฐ’๊ณผ ๋ฌด๊ด€ํ•˜๊ฒŒ ์ˆœ์œ„ ๋งค๊ธฐ๋Š” ๋Šฅ๋ ฅ ๋น„๊ต
MAE / RMSE์˜ค์ฐจ ์ ˆ๋Œ“๊ฐ’ ํ‰๊ท  / ์ œ๊ณฑ ํ‰๊ท ์˜ ์ œ๊ณฑ๊ทผํšŒ๊ท€ ๋ฌธ์ œ. RMSE๋Š” ํฐ ์˜ค์ฐจ์— ๋” ๋ฏผ๊ฐ

(TP: ์ง„์–‘์„ฑ, FP: ์œ„์–‘์„ฑ, FN: ์œ„์Œ์„ฑ) ๊ทธ๋ฆฌ๊ณ  ๋ถ„๋ฅ˜ ๋ชจ๋ธ์€ ๋ณดํ†ต ํ™•๋ฅ ์„ ๋‚ด๋†“๊ณ  ๊ธฐ๋ณธ ์ž„๊ณ„๊ฐ’ 0.5๋กœ ์ž๋ฅด๋Š”๋ฐ, ์—…๋ฌด ๋ชฉํ‘œ์— ๋”ฐ๋ผ ์ด ์ž„๊ณ„๊ฐ’์„ ์กฐ์ •ํ•˜๋Š” ๊ฒƒ๋งŒ์œผ๋กœ๋„ ์ •๋ฐ€๋„ยท์žฌํ˜„์œจ ๊ท ํ˜•์ด ํฌ๊ฒŒ ๋‹ฌ๋ผ์ ธ. ๋ชจ๋ธ์„ ๋‹ค์‹œ ํ•™์Šตํ•˜์ง€ ์•Š์•„๋„ ๋˜๋Š” ๊ณต์งœ ํŠœ๋‹์ด๋‹ˆ ๊ผญ ์ฑ™๊ฒจ.

8-1. ๊ณผ์ ํ•ฉ๊ณผ ๊ณผ์†Œ์ ํ•ฉ

๋ชจ๋ธ์ด ํ•™์Šต ๋ฐ์ดํ„ฐ๋ฅผ ๋„ˆ๋ฌด ๋‹ฌ๋‹ฌ ์™ธ์›Œ์„œ ์ƒˆ ๋ฐ์ดํ„ฐ์— ์•ฝํ•ด์ง€๋Š” ๊ฑธ ๊ณผ์ ํ•ฉ(Overfitting), ๋ฐ˜๋Œ€๋กœ ๋„ˆ๋ฌด ๋‹จ์ˆœํ•ด์„œ ํ•™์Šต ๋ฐ์ดํ„ฐ์กฐ์ฐจ ๋ชป ๋งžํžˆ๋Š” ๊ฑธ ๊ณผ์†Œ์ ํ•ฉ(Underfitting)์ด๋ผ๊ณ  ํ•ด. ์‹œํ—˜ ๊ธฐ์ถœ๋ฌธ์ œ ๋‹ต๋งŒ ์™ธ์šด ์นœ๊ตฌ vs ๊ณต๋ถ€๋ฅผ ์•„์˜ˆ ์•ˆ ํ•œ ์นœ๊ตฌ๋ผ๊ณ  ์ƒ๊ฐํ•˜๋ฉด ๋ผ.

ํ•™์Šต ๊ณก์„ ์œผ๋กœ ๊ณผ์ ํ•ฉ ์•Œ์•„์ฑ„๊ธฐ ์—ํญ(ํ•™์Šต ์ง„ํ–‰) ์†์‹ค ์—ฌ๊ธฐ์„œ ๋ฉˆ์ถ”๊ธฐ ๊ณผ์ ํ•ฉ ๊ตฌ๊ฐ„ ๊ฒ€์ฆ ์†์‹ค์ด ๋‹ค์‹œ ์ƒ์Šน ํ•™์Šต ์†์‹ค ๊ฒ€์ฆ ์†์‹ค

ํ•™์Šต ์†์‹ค์€ ๊ณ„์† ๋‚ด๋ ค๊ฐ€๋Š”๋ฐ ๊ฒ€์ฆ ์†์‹ค์ด ๋‹ค์‹œ ์˜ค๋ฅด๊ธฐ ์‹œ์ž‘ํ•˜๋ฉด ๊ณผ์ ํ•ฉ ์‹ ํ˜ธ

๊ณผ์ ํ•ฉ์„ ๋ง‰๋Š” ๋Œ€ํ‘œ ๋ฌด๊ธฐ๋“ค์„ ์ •๋ฆฌํ•˜๋ฉด ์ด๋ž˜.

๐Ÿ“ฆ ๋ฐ์ดํ„ฐ ๋Š˜๋ฆฌ๊ธฐ๊ฐ€์žฅ ๊ฐ•๋ ฅํ•œ ์ฒ˜๋ฐฉ. ์ด๋ฏธ์ง€๋Š” ํšŒ์ „ยท๋’ค์ง‘๊ธฐยท์ž˜๋ผ๋‚ด๊ธฐ ๊ฐ™์€ ๋ฐ์ดํ„ฐ ์ฆ๊ฐ•์œผ๋กœ ํšจ๊ณผ๋ฅผ ๋‚ผ ์ˆ˜ ์žˆ์–ด.
โš–๏ธ ๊ทœ์ œ(Regularization)L2(๊ฐ€์ค‘์น˜ ๊ฐ์‡ ), L1 ๊ทœ์ œ๋กœ ํŒŒ๋ผ๋ฏธํ„ฐ๊ฐ€ ๊ณผํ•˜๊ฒŒ ์ปค์ง€๋Š” ๊ฑธ ์–ต์ œํ•ด.
๐ŸŽฒ ๋“œ๋กญ์•„์›ƒํ•™์Šต ์ค‘ ๋‰ด๋Ÿฐ ์ผ๋ถ€๋ฅผ ๋ฌด์ž‘์œ„๋กœ ๊บผ์„œ ํŠน์ • ๋‰ด๋Ÿฐ์— ๊ณผ์˜์กดํ•˜์ง€ ์•Š๊ฒŒ ํ•ด.
โน๏ธ ์กฐ๊ธฐ ์ข…๋ฃŒ๊ฒ€์ฆ ์†์‹ค์ด ๊ฐœ์„ ๋˜์ง€ ์•Š์œผ๋ฉด ํ•™์Šต์„ ๋ฉˆ์ถฐ. ์œ„ Keras ์˜ˆ์ œ์˜ EarlyStopping์ด ๋ฐ”๋กœ ์ด๊ฑฐ์•ผ.
๐Ÿ” ์ „์ด ํ•™์Šต๋Œ€๊ทœ๋ชจ ๋ฐ์ดํ„ฐ๋กœ ์‚ฌ์ „ํ•™์Šต๋œ ๋ชจ๋ธ์„ ๊ฐ€์ ธ์™€ ๋‚ด ๋ฐ์ดํ„ฐ์— ๋งž๊ฒŒ ๋ฏธ์„ธ์กฐ์ •. ๋ฐ์ดํ„ฐ๊ฐ€ ์ ์„ ๋•Œ ํŠนํšจ์•ฝ.

9. ์ „์ด ํ•™์Šต: ๊ฑฐ์ธ์˜ ์–ด๊นจ ์œ„์—์„œ ์‹œ์ž‘ํ•˜๊ธฐ ๐Ÿ”๏ธ

์š”์ฆ˜ ์‹ค๋ฌด์—์„œ ๋”ฅ๋Ÿฌ๋‹ ๋ชจ๋ธ์„ โ€œ์ฒ˜์Œ๋ถ€ํ„ฐ(from scratch)โ€ ํ•™์Šตํ•˜๋Š” ๊ฒฝ์šฐ๋Š” ์ƒ๊ฐ๋ณด๋‹ค ๋“œ๋ฌผ์–ด. ImageNet ๊ฐ™์€ ๋Œ€๊ทœ๋ชจ ๋ฐ์ดํ„ฐ๋กœ ์‚ฌ์ „ํ•™์Šต๋œ ๋ชจ๋ธ์„ ๊ฐ€์ ธ์™€ ๋‚ด ๋ฌธ์ œ์— ๋งž๊ฒŒ ๋๋ถ€๋ถ„๋งŒ ๋ฐ”๊ฟ” ํ•™์Šตํ•˜๋Š” ์ „์ด ํ•™์Šต(Transfer Learning)์ด ํ‘œ์ค€์ด์•ผ. ์‚ฌ์ง„ ์ˆ˜๋ฐฑ ์žฅ์œผ๋กœ๋„ ์“ธ ๋งŒํ•œ ๋ถ„๋ฅ˜๊ธฐ๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ๋Š” ๋น„๊ฒฐ์ด์ง€.

# PyTorch: ์‚ฌ์ „ํ•™์Šต ResNet18๋กœ ๋‚ด ๋ฐ์ดํ„ฐ(5๊ฐœ ํด๋ž˜์Šค) ๋ถ„๋ฅ˜
import torch
from torch import nn
from torchvision import models

model = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)

for p in model.parameters():          # ๋ชธํ†ต์€ ์–ผ๋ฆฌ๊ณ (freeze)
    p.requires_grad = False

model.fc = nn.Linear(model.fc.in_features, 5)   # ๋จธ๋ฆฌ๋งŒ ๊ต์ฒดํ•ด์„œ ํ•™์Šต
# Keras: ๊ฐ™์€ ์•„์ด๋””์–ด
import keras
base = keras.applications.MobileNetV2(
    input_shape=(224, 224, 3), include_top=False, weights="imagenet")
base.trainable = False

inputs = keras.Input(shape=(224, 224, 3))
x = keras.applications.mobilenet_v2.preprocess_input(inputs)
x = base(x, training=False)
x = keras.layers.GlobalAveragePooling2D()(x)
outputs = keras.layers.Dense(5, activation="softmax")(x)
model = keras.Model(inputs, outputs)

๋จผ์ € ๋จธ๋ฆฌ(๋ถ„๋ฅ˜์ธต)๋งŒ ํ•™์Šตํ•œ ๋’ค, ์„ฑ๋Šฅ์ด ์•ˆ์ •๋˜๋ฉด ๋ชธํ†ต์˜ ์œ—๋ถ€๋ถ„ ์ผ๋ถ€๋ฅผ ํ’€์–ด์„œ(unfreeze) ์•„์ฃผ ์ž‘์€ ํ•™์Šต๋ฅ ๋กœ ํ•จ๊ป˜ ๋ฏธ์„ธ์กฐ์ •ํ•˜๋Š” 2๋‹จ๊ณ„ ์ „๋žต์ด ํ”ํžˆ ์“ฐ์—ฌ. ํ•™์Šต๋ฅ ์ด ํฌ๋ฉด ์‚ฌ์ „ํ•™์Šต์œผ๋กœ ์–ป์€ ์ง€์‹์ด ๋ง๊ฐ€์งˆ ์ˆ˜ ์žˆ๊ฑฐ๋“ . ๊ทธ๋ฆฌ๊ณ  ์‚ฌ์ „ํ•™์Šต ๋•Œ ์“ด ๊ฒƒ๊ณผ ๋™์ผํ•œ ์ „์ฒ˜๋ฆฌ(์ •๊ทœํ™”)๋ฅผ ์ ์šฉํ•˜๋Š” ๊ฑธ ์žŠ์œผ๋ฉด ์„ฑ๋Šฅ์ด ๋š ๋–จ์–ด์ง€๋‹ˆ ์ฃผ์˜!

ํ…์ŠคํŠธ ๋ถ„์•ผ์—์„œ๋Š” Hugging Face์˜ Transformers ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๊ฐ€ ์ด ์—ญํ• ์„ ํ•ด. BERT ๊ณ„์—ด ๋ชจ๋ธ์„ ๊ฐ€์ ธ์™€ ๊ฐ์„ฑ ๋ถ„๋ฅ˜๋‚˜ ๊ฐœ์ฒด๋ช… ์ธ์‹์— ๋งž์ถฐ ํŒŒ์ธํŠœ๋‹ํ•˜๋Š” ์ž‘์—…์ด ๋ช‡์‹ญ ์ค„ ์ฝ”๋“œ๋กœ ๊ฐ€๋Šฅํ•ด์กŒ๊ณ , ์ด ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋Š” ์ฃผ๋กœ PyTorch๋ฅผ ์ค‘์‹ฌ์œผ๋กœ ์›€์ง์ด๊ณ  ์žˆ์–ด.

10. ๋ชจ๋ธ ์ €์žฅ๊ณผ ๋ฐฐํฌ: ๋…ธํŠธ๋ถ ๋ฐ–์œผ๋กœ ๋‚˜๊ฐ€๊ธฐ ๐Ÿš€

์ฃผํ”ผํ„ฐ ๋…ธํŠธ๋ถ์—์„œ ์ •ํ™•๋„ 98% ์ฐ๊ณ  ๋๋‚˜๋ฉด ๊ทธ๊ฑด โ€œ์‹คํ—˜โ€์ด์ง€ โ€œ์„œ๋น„์Šคโ€๊ฐ€ ์•„๋‹ˆ์•ผ. ๋ชจ๋ธ์ด ์‹ค์ œ๋กœ ๊ฐ€์น˜๋ฅผ ๋งŒ๋“ค๋ ค๋ฉด ์ €์žฅํ•˜๊ณ , ๋ถˆ๋Ÿฌ์˜ค๊ณ , ์„œ๋น„์Šค์— ๋ถ™์—ฌ์•ผ ํ•ด.

10-1. ํ”„๋ ˆ์ž„์›Œํฌ๋ณ„ ์ €์žฅ ๋ฐฉ๋ฒ•

# Scikit-learn
import joblib
joblib.dump(clf, "model.joblib")
clf = joblib.load("model.joblib")

# Keras 3
model.save("model.keras")
model = keras.models.load_model("model.keras")

# PyTorch (state_dict ์ €์žฅ์ด ๊ถŒ์žฅ ๋ฐฉ์‹)
torch.save(model.state_dict(), "model.pt")
model = Net()
model.load_state_dict(torch.load("model.pt"))
model.eval()
๐Ÿ” ๋ณด์•ˆ ์ฃผ์˜: pickle ๊ณ„์—ด ํŒŒ์ผ์€ ๋ฏฟ์„ ์ˆ˜ ์žˆ๋Š” ์ถœ์ฒ˜๋งŒ joblibยทpickle, ๊ทธ๋ฆฌ๊ณ  PyTorch์˜ ๊ธฐ๋ณธ ์ €์žฅ ํ˜•์‹์€ ๋‚ด๋ถ€์ ์œผ๋กœ ํŒŒ์ด์ฌ pickle์„ ์“ฐ๋Š”๋ฐ, ์•…์˜์ ์œผ๋กœ ๋งŒ๋“  ํŒŒ์ผ์„ ๋ถˆ๋Ÿฌ์˜ค๋ฉด ์ž„์˜ ์ฝ”๋“œ๊ฐ€ ์‹คํ–‰๋  ์ˆ˜ ์žˆ์–ด. ์ถœ์ฒ˜๊ฐ€ ๋ถˆ๋ถ„๋ช…ํ•œ ๋ชจ๋ธ ํŒŒ์ผ์€ ์—ด์ง€ ๋ง๊ณ , PyTorch์—์„œ๋Š” torch.load(..., weights_only=True) ์˜ต์…˜(์ตœ์‹  ๋ฒ„์ „์—์„  ๊ธฐ๋ณธ๊ฐ’)์„ ํ™œ์šฉํ•˜๊ฑฐ๋‚˜ Hugging Face์˜ safetensors ํฌ๋งท์„ ์“ฐ๋Š” ๊ฒŒ ์•ˆ์ „ํ•ด. ๋˜ ์‚ฌ์ดํ‚ท๋Ÿฐ ๋ชจ๋ธ์€ ์ €์žฅํ•  ๋•Œ์™€ ๊ฐ™์€ ๋ฒ„์ „์—์„œ ๋ถˆ๋Ÿฌ์˜ค๋Š” ๊ฒŒ ์›์น™์ด์•ผ.

10-2. ํ”„๋ ˆ์ž„์›Œํฌ๋ฅผ ๋„˜๋‚˜๋“œ๋Š” ๋‹ค๋ฆฌ, ONNX

ONNX(Open Neural Network Exchange)๋Š” ๋ชจ๋ธ์„ ํ‘œํ˜„ํ•˜๋Š” ๊ณตํ†ต ํฌ๋งท์ด์•ผ. PyTorch๋Š” torch.onnx.export๋กœ, ์‚ฌ์ดํ‚ท๋Ÿฐ์€ skl2onnx, TensorFlow๋Š” tf2onnx ๊ฐ™์€ ๋ณ€ํ™˜ ๋„๊ตฌ๋กœ ONNX ํŒŒ์ผ์„ ๋งŒ๋“ค ์ˆ˜ ์žˆ์–ด. ์ด๋ ‡๊ฒŒ ๋ณ€ํ™˜ํ•œ ๋ชจ๋ธ์€ ONNX Runtime์œผ๋กœ ๋‹ค์–‘ํ•œ ์–ธ์–ด(C++, C#, Java, JavaScript ๋“ฑ)์™€ ํ•˜๋“œ์›จ์–ด์—์„œ ์‹คํ–‰ํ•  ์ˆ˜ ์žˆ์ง€. โ€œํ•™์Šต์€ PyTorch๋กœ, ์„œ๋น„์Šค๋Š” C# ์„œ๋ฒ„์—์„œโ€์ฒ˜๋Ÿผ ํŒ€ ์ƒํ™ฉ์ด ๋ณต์žกํ•  ๋•Œ ์œ ์šฉํ•ด.

10-3. ๊ฐ„๋‹จํ•œ API ์„œ๋ฒ„ ๋งŒ๋“ค๊ธฐ

๊ฐ€์žฅ ํ”ํ•œ ๋ฐฉ์‹์€ FastAPI ๊ฐ™์€ ์›น ํ”„๋ ˆ์ž„์›Œํฌ๋กœ ๋ชจ๋ธ์„ ๊ฐ์‹ธ REST API๋ฅผ ๋งŒ๋“œ๋Š” ๊ฑฐ์•ผ.

from fastapi import FastAPI
from pydantic import BaseModel
import joblib, pandas as pd

app = FastAPI()
model = joblib.load("model.joblib")   # ์„œ๋ฒ„ ์‹œ์ž‘ ์‹œ ํ•œ ๋ฒˆ๋งŒ ๋กœ๋“œ

class Customer(BaseModel):
    age: float
    income: float
    city: str
    job: str

@app.post("/predict")
def predict(c: Customer):
    df = pd.DataFrame([c.model_dump()])
    prob = model.predict_proba(df)[0, 1]
    return {"churn_probability": float(prob)}

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

10-4. MLOps: ๋ฐฐํฌ ์ดํ›„๊ฐ€ ์ง„์งœ ์‹œ์ž‘

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

11. ์‹ค์ „ ์‹œ๋‚˜๋ฆฌ์˜ค: ๊ณ ๊ฐ ์ดํƒˆ ์˜ˆ์ธก ํ”„๋กœ์ ํŠธ ๐Ÿ›’

๊ฐœ๋…์„ ์—ฎ์–ด์„œ ์‹ค์ œ ํ”„๋กœ์ ํŠธ ํ•˜๋‚˜๋ฅผ ์ƒ์ƒ์œผ๋กœ ๊ตด๋ ค๋ณด์ž. ์–ด๋А ๊ตฌ๋… ์„œ๋น„์Šค ํšŒ์‚ฌ๊ฐ€ โ€œ๋‹ค์Œ ๋‹ฌ์— ํ•ด์ง€ํ•  ๊ณ ๊ฐ์„ ๋ฏธ๋ฆฌ ์ฐพ์•„ ์ฟ ํฐ์„ ๋ณด๋‚ด๊ณ  ์‹ถ๋‹คโ€๊ณ  ํ•ด.

1๋ฌธ์ œ ์ •์˜: ์ด์ง„ ๋ถ„๋ฅ˜. ํ•ด์ง€ ๊ณ ๊ฐ ๋น„์œจ์ด 10% ์ •๋„๋กœ ๋ถˆ๊ท ํ˜•์ด๋ผ ์ •ํ™•๋„ ๋Œ€์‹  ์žฌํ˜„์œจ๊ณผ PR-AUC๋ฅผ ์ฃผ ์ง€ํ‘œ๋กœ. ์ฟ ํฐ ๋น„์šฉ์„ ๊ณ ๋ คํ•ด ์ •๋ฐ€๋„ ํ•˜ํ•œ์„ ๋„ ์ •ํ•ด.
2๋ฐ์ดํ„ฐ: ๊ฐ€์ž… ๊ธฐ๊ฐ„, ์›” ์ด์šฉ ํšŸ์ˆ˜, ์ตœ๊ทผ ๋กœ๊ทธ์ธ ์ผ์ž, ์š”๊ธˆ์ œ, ๊ณ ๊ฐ์„ผํ„ฐ ๋ฌธ์˜ ํšŸ์ˆ˜ ๋“ฑ. ์ฃผ์˜ํ•  ์ ์€ โ€œํ•ด์ง€ ์‹ ์ฒญ ํŽ˜์ด์ง€ ๋ฐฉ๋ฌธ ์—ฌ๋ถ€โ€์ฒ˜๋Ÿผ ๋ฏธ๋ž˜ ์ •๋ณด๋ฅผ ๋‹ด์€ ํŠน์„ฑ์€ ๋ˆ„์ˆ˜๋ผ์„œ ๋นผ์•ผ ํ•ด.
3๋ถ„ํ• : ์‹œ๊ฐ„ ํ๋ฆ„์ด ์žˆ๋Š” ๋ฐ์ดํ„ฐ๋ผ ๋ฌด์ž‘์œ„ ๋ถ„ํ•  ๋Œ€์‹  ์‹œ๊ฐ„ ๊ธฐ์ค€ ๋ถ„ํ• (๊ณผ๊ฑฐ๋กœ ํ•™์Šต, ์ตœ๊ทผ์œผ๋กœ ๊ฒ€์ฆ). ์‚ฌ์ดํ‚ท๋Ÿฐ์˜ TimeSeriesSplit์ด ๋„์›€ ๋ผ.
4๋ชจ๋ธ: ๋กœ์ง€์Šคํ‹ฑ ํšŒ๊ท€ ๋ฒ ์ด์Šค๋ผ์ธ โ†’ HistGradientBoosting์œผ๋กœ ๊ฐœ์„ . ์ •ํ˜• ๋ฐ์ดํ„ฐ๋ผ ๋”ฅ๋Ÿฌ๋‹์€ ์šฐ์„ ์ˆœ์œ„๊ฐ€ ๋‚ฎ์•„.
5ํ•ด์„: permutation importance๋‚˜ SHAP์œผ๋กœ ์–ด๋–ค ํŠน์„ฑ์ด ์ดํƒˆ์— ์˜ํ–ฅ์„ ์ฃผ๋Š”์ง€ ํ™•์ธํ•ด์„œ ๋งˆ์ผ€ํŒ…ํŒ€๊ณผ ๊ณต์œ .
6๋ฐฐํฌ: ๋งค์ฃผ ๋ฐฐ์น˜๋กœ ์ „์ฒด ๊ณ ๊ฐ ์ ์ˆ˜๋ฅผ ๊ณ„์‚ฐํ•ด CRM์— ์ ์žฌํ•˜๊ณ , ์‹ค์ œ ํ•ด์ง€์œจ๊ณผ ๋น„๊ตํ•ด ์„ฑ๋Šฅ์„ ์ถ”์ .

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

12. ๊ฐœ๋ฐœ ํ™˜๊ฒฝ ์„ธํŒ… ํŒ ๐Ÿ’ป

โ€œ์ฝ”๋“œ๋Š” ๋งž๋Š”๋ฐ ํ™˜๊ฒฝ์ด ์•ˆ ๋ผ์š”โ€๋Š” AI ๊ฐœ๋ฐœ์ž์˜ ์˜์›ํ•œ ์ˆ™์ ์ด์•ผ. ๋ช‡ ๊ฐ€์ง€ ์›์น™๋งŒ ์ง€ํ‚ค๋ฉด ๊ณ ์ƒ์ด ํ™• ์ค„์–ด.

๐Ÿงช ๊ฐ€์ƒํ™˜๊ฒฝ์€ ํ•„์ˆ˜ํ”„๋กœ์ ํŠธ๋งˆ๋‹ค venv, conda, uv ๋“ฑ์œผ๋กœ ํ™˜๊ฒฝ์„ ๋ถ„๋ฆฌํ•ด. TensorFlow์™€ PyTorch๊ฐ€ ์š”๊ตฌํ•˜๋Š” ์˜์กด์„ฑ ๋ฒ„์ „์ด ์ถฉ๋Œํ•˜๋Š” ์ผ์ด ์ƒ๊ฐ๋ณด๋‹ค ํ”ํ•˜๊ฑฐ๋“ .
๐ŸŽฎ GPU ๋ฒ„์ „ ๊ถํ•ฉPyTorch๋Š” ๊ณต์‹ ์‚ฌ์ดํŠธ์˜ ์„ค์น˜ ์„ ํƒ๊ธฐ๊ฐ€ OSยทCUDA ๋ฒ„์ „์— ๋งž๋Š” ๋ช…๋ น์–ด๋ฅผ ์•Œ๋ ค์ค˜. ๋“œ๋ผ์ด๋ฒ„ ๋ฒ„์ „๋„ ํ•จ๊ป˜ ํ™•์ธํ•ด.
โ˜๏ธ ํด๋ผ์šฐ๋“œ ๋…ธํŠธ๋ถ๋กœ์ปฌ GPU๊ฐ€ ์—†๋‹ค๋ฉด Google Colab, Kaggle Notebooks์ฒ˜๋Ÿผ GPU๋ฅผ ์ œ๊ณตํ•˜๋Š” ๋ฌด๋ฃŒยท์œ ๋ฃŒ ๋…ธํŠธ๋ถ ํ™˜๊ฒฝ์œผ๋กœ ์‹œ์ž‘ํ•ด๋„ ์ถฉ๋ถ„ํ•ด.
๐Ÿ“Œ ๋ฒ„์ „ ๊ณ ์ •requirements.txt๋‚˜ lock ํŒŒ์ผ์— ๋ฒ„์ „์„ ๋ช…์‹œํ•ด. 6๊ฐœ์›” ๋’ค์˜ ๋‚ด๊ฐ€ ๊ณ ๋งˆ์›Œํ•  ๊ฑฐ์•ผ.
# ์„ค์น˜ ํ™•์ธ์šฉ ํ•œ ๋ฐฉ ์Šคํฌ๋ฆฝํŠธ
import sklearn, torch
print("scikit-learn", sklearn.__version__)
print("torch", torch.__version__, "| CUDA:", torch.cuda.is_available())

import tensorflow as tf
print("tensorflow", tf.__version__, "| GPU:", tf.config.list_physical_devices("GPU"))

์ฐธ๊ณ ๋กœ ์• ํ”Œ ์‹ค๋ฆฌ์ฝ˜(M ์‹œ๋ฆฌ์ฆˆ) ๋งฅ์—์„œ๋Š” PyTorch๊ฐ€ MPS ๋ฐฑ์—”๋“œ๋กœ GPU ๊ฐ€์†์„ ์ง€์›ํ•ด. torch.backends.mps.is_available()๋กœ ํ™•์ธํ•˜๊ณ  device="mps"๋กœ ์“ฐ๋ฉด ๋ผ.

13. ์ž์ฃผ ๋ฌป๋Š” ์งˆ๋ฌธ ๐Ÿ™‹

Q. ์ˆ˜ํ•™์„ ์–ผ๋งˆ๋‚˜ ์•Œ์•„์•ผ ํ•ด? ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ์“ฐ๋Š” ๋‹จ๊ณ„์—์„  ๊ณ ๋“ฑํ•™๊ต ์ˆ˜์ค€์˜ ํ•จ์ˆ˜ยท๋ฏธ๋ถ„ ๊ฐœ๋…๊ณผ ํ–‰๋ ฌ์ด โ€œ๋ฌด์—‡์„ ํ•˜๋Š”์ง€โ€ ์ •๋„๋ฉด ์ถœ๋ฐœํ•  ์ˆ˜ ์žˆ์–ด. ๋‹ค๋งŒ ๋ชจ๋ธ์ด ์™œ ์•ˆ ๋˜๋Š”์ง€ ๋””๋ฒ„๊น…ํ•˜๊ณ  ๋…ผ๋ฌธ์„ ์ฝ์œผ๋ ค๋ฉด ์„ ํ˜•๋Œ€์ˆ˜(ํ–‰๋ ฌ๊ณฑ, ๋ฒกํ„ฐ), ๋ฏธ์ ๋ถ„(ํŽธ๋ฏธ๋ถ„, ์—ฐ์‡„ ๋ฒ•์น™), ํ™•๋ฅ ยทํ†ต๊ณ„(๋ถ„ํฌ, ๊ธฐ๋Œ“๊ฐ’, ์ตœ๋Œ€์šฐ๋„)๋ฅผ ์ฐจ๊ทผ์ฐจ๊ทผ ๋ณด๊ฐ•ํ•˜๋Š” ๊ฒŒ ์ข‹์•„. ์ฝ”๋“œ๋กœ ๋จผ์ € ๊ฐ์„ ์žก๊ณ , ๋ง‰ํžˆ๋Š” ์ง€์ ์—์„œ ์ˆ˜ํ•™์„ ์ฐพ์•„๋ณด๋Š” ์ˆœ์„œ๊ฐ€ ๋œ ์ง€์ณ.
Q. TensorFlow๋Š” ์ด์ œ ๋๋ฌผ์ด์•ผ? ์—ฐ๊ตฌ ์ปค๋ฎค๋‹ˆํ‹ฐ์™€ ์ƒ์„ฑํ˜• AI ์ชฝ์—์„œ PyTorch ๋น„์ค‘์ด ํฌ๊ฒŒ ๋Š˜์–ด๋‚œ ๊ฑด ์‚ฌ์‹ค์ด์•ผ. ํ•˜์ง€๋งŒ TensorFlow๋Š” ์—ฌ์ „ํžˆ ์ˆ˜๋งŽ์€ ๊ธฐ์—… ์‹œ์Šคํ…œ๊ณผ ๋ชจ๋ฐ”์ผยท์—ฃ์ง€ ๋ฐฐํฌ์— ์“ฐ์ด๊ณ  ์žˆ๊ณ , Keras 3๋Š” ๋ฐฑ์—”๋“œ๋ฅผ ๊ฐˆ์•„๋ผ์šธ ์ˆ˜ ์žˆ์–ด์„œ Keras ๋ฌธ๋ฒ•์„ ์ตํ˜€๋‘๋ฉด ์†ํ•ด๊ฐ€ ์—†์–ด. โ€œ์ฃฝ์—ˆ๋‹คโ€๊ธฐ๋ณด๋‹ค๋Š” โ€œ์—ญํ• ์ด ๋ถ„ํ™”๋๋‹คโ€๊ฐ€ ์ •ํ™•ํ•œ ํ‘œํ˜„์ด์•ผ.
Q. JAX๋Š” ๋ญ์•ผ? ๊ตฌ๊ธ€์—์„œ ๋งŒ๋“  ์ˆ˜์น˜ ๊ณ„์‚ฐ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋กœ, NumPy ๊ฐ™์€ ๋ฌธ๋ฒ•์— ์ž๋™ ๋ฏธ๋ถ„๊ณผ XLA ์ปดํŒŒ์ผ์„ ๊ฒฐํ•ฉํ–ˆ์–ด. ๋Œ€๊ทœ๋ชจ ์—ฐ๊ตฌ์™€ TPU ํ™˜๊ฒฝ์—์„œ ์กด์žฌ๊ฐ์ด ์ปค์ง€๊ณ  ์žˆ๊ณ , Keras 3์˜ ๋ฐฑ์—”๋“œ๋กœ๋„ ์“ธ ์ˆ˜ ์žˆ์–ด. ์ž…๋ฌธ ๋‹จ๊ณ„์—์„  ์ผ๋‹จ 3๋Œ€์žฅ์„ ์ตํžŒ ๋’ค ๊ด€์‹ฌ์„ ๊ฐ€์ ธ๋„ ๋Šฆ์ง€ ์•Š์•„.
Q. ๋ฐ์ดํ„ฐ๊ฐ€ ์ ์€๋ฐ ๋”ฅ๋Ÿฌ๋‹ ํ•ด๋„ ๋ผ? ์ฒ˜์Œ๋ถ€ํ„ฐ ํ•™์Šตํ•˜๋Š” ๊ฑด ์œ„ํ—˜ํ•˜์ง€๋งŒ, ์ „์ด ํ•™์Šต๊ณผ ๋ฐ์ดํ„ฐ ์ฆ๊ฐ•์„ ์“ฐ๋ฉด ์ˆ˜๋ฐฑ~์ˆ˜์ฒœ ์žฅ ๊ทœ๋ชจ๋กœ๋„ ์‹ค์šฉ์ ์ธ ๊ฒฐ๊ณผ๋ฅผ ์–ป๋Š” ๊ฒฝ์šฐ๊ฐ€ ๋งŽ์•„. ์ •ํ˜• ๋ฐ์ดํ„ฐ๋ผ๋ฉด ์˜คํžˆ๋ ค ํŠธ๋ฆฌ ์•™์ƒ๋ธ”์ด ๋” ๋‚˜์€ ์„ ํƒ์ผ ๊ฐ€๋Šฅ์„ฑ์ด ๋†’๊ณ .
๐ŸŒฑ ํ˜ผ์ž ๋ง‰ํž ๋•Œ ๊ณต์‹ ํŠœํ† ๋ฆฌ์–ผ(scikit-learn User Guide, TensorFlow/Keras ๊ฐ€์ด๋“œ, PyTorch Tutorials)์€ ์ƒ๊ฐ๋ณด๋‹ค ํ›จ์”ฌ ์นœ์ ˆํ•˜๊ณ  ์ตœ์‹  ์ƒํƒœ๋กœ ๊ด€๋ฆฌ๋ผ. ๊ทธ๋ž˜๋„ ๋ฐ์ดํ„ฐ ์ „์ฒ˜๋ฆฌ๋‚˜ ๋ชจ๋ธ ํŠœ๋‹์ฒ˜๋Ÿผ ๊ฒฝํ—˜์ด ํ•„์š”ํ•œ ๋ถ€๋ถ„์—์„œ ๋ง‰ํžŒ๋‹ค๋ฉด, ์žฌ๋Šฅ๋„ท ๊ฐ™์€ ์žฌ๋Šฅ ๊ณต์œ  ํ”Œ๋žซํผ์—์„œ ํ˜„์—… ๊ฐœ๋ฐœ์ž์—๊ฒŒ ์ฝ”๋“œ ๋ฆฌ๋ทฐ๋‚˜ 1:1 ๋ฉ˜ํ† ๋ง์„ ๋ฐ›์•„๋ณด๋Š” ๊ฒƒ๋„ ์‹œ๊ฐ„์„ ์•„๋ผ๋Š” ํ˜„์‹ค์ ์ธ ๋ฐฉ๋ฒ•์ด์•ผ.

14. ๋งˆ๋ฌด๋ฆฌ: ํ•œ ์žฅ์œผ๋กœ ์ •๋ฆฌํ•˜๊ธฐ ๐Ÿ“

โœ… ์˜ค๋Š˜์˜ ํ•ต์‹ฌ ์š”์•ฝ โ‘  ๋จธ์‹ ๋Ÿฌ๋‹์€ ๋ฐ์ดํ„ฐ์—์„œ ํ•จ์ˆ˜๋ฅผ ์ถ”์ •ํ•˜๋Š” ๊ธฐ์ˆ ์ด๊ณ , ํ๋ฆ„์€ ์ •์˜ โ†’ ๋ฐ์ดํ„ฐ โ†’ ์ „์ฒ˜๋ฆฌ โ†’ ๋ถ„ํ•  โ†’ ํ•™์Šต โ†’ ํ‰๊ฐ€ โ†’ ๋ฐฐํฌ.
โ‘ก Scikit-learn: fit/predict์˜ ์ผ๊ด€๋œ API, Pipeline์œผ๋กœ ๋ˆ„์ˆ˜ ๋ฐฉ์ง€, ์ •ํ˜• ๋ฐ์ดํ„ฐ์™€ ๊ฐœ๋… ํ•™์Šต์— ์ตœ์ .
โ‘ข TensorFlow/Keras: compile/fit์˜ ๊ฐ„๊ฒฐํ•จ, tf.dataยทSavedModelยทLiteRT ๋“ฑ ๋ฐฐํฌ ์ƒํƒœ๊ณ„, Keras 3๋Š” ๋ฉ€ํ‹ฐ ๋ฐฑ์—”๋“œ.
โ‘ฃ PyTorch: ํŒŒ์ด์ฌ๋‹ค์šด ์ฆ‰์‹œ ์‹คํ–‰, zero_grad โ†’ forward โ†’ backward โ†’ step 4๋ฐ•์ž, ์—ฐ๊ตฌยทLLM์˜ ์ฃผ๋ฅ˜, torch.compile๋กœ ์„ฑ๋Šฅ ๋ณด๊ฐ•.
โ‘ค ์ •ํ™•๋„ ํ•˜๋‚˜๋งŒ ๋ณด์ง€ ๋ง๊ณ  ์ •๋ฐ€๋„ยท์žฌํ˜„์œจยทF1์„, ํ•™์Šต ๊ณก์„ ์œผ๋กœ ๊ณผ์ ํ•ฉ์„ ์ฒดํฌ.
โ‘ฅ ๋ฐ์ดํ„ฐ๊ฐ€ ์ ์œผ๋ฉด ์ „์ด ํ•™์Šต, ๋ฐฐํฌ ํ›„์—” ๋“œ๋ฆฌํ”„ํŠธ ๋ชจ๋‹ˆํ„ฐ๋ง๊นŒ์ง€๊ฐ€ ์ง„์งœ ์™„์„ฑ.

์ฒ˜์Œ์—” import ์—๋Ÿฌ, shape ์—๋Ÿฌ, CUDA ์—๋Ÿฌ๊ฐ€ ๋ฒˆ๊ฐˆ์•„ ๊ฐ€๋ฉฐ ๋ฐ˜๊ฒจ์ค„ ๊ฑฐ์•ผ. ๊ทผ๋ฐ ๊ทธ๊ฑด ๋‹ค๋“ค ๊ฑฐ์ณ ๊ฐ„ ํ†ต๊ณผ์˜๋ก€์•ผ ๐Ÿ˜„ ์˜ค๋Š˜ ๋ณธ ๋ถ“๊ฝƒ ๋ถ„๋ฅ˜๊ธฐ์™€ MNIST ๋ชจ๋ธ์„ ์ง์ ‘ ํ•œ ๋ฒˆ์”ฉ ๋Œ๋ ค๋ณด๊ณ , ํ•˜์ดํผํŒŒ๋ผ๋ฏธํ„ฐ๋ฅผ ๋ฐ”๊ฟ” ์ ์ˆ˜๊ฐ€ ์–ด๋–ป๊ฒŒ ์›€์ง์ด๋Š”์ง€ ๊ด€์ฐฐํ•ด ๋ด. ์†์œผ๋กœ ํ•œ ๋ฒˆ ๋งŒ์ ธ๋ณธ ๊ฐœ๋…์€ ์ ˆ๋Œ€ ์•ˆ ์žŠํžˆ๊ฑฐ๋“ . ๋„ค ์ฒซ ๋ฒˆ์งธ ๋ชจ๋ธ์ด ์„ธ์ƒ์— ๋‚˜์˜ค๋Š” ๋‚ ์„ ์‘์›ํ• ๊ฒŒ! ๐Ÿš€

โ€œ๋ชจ๋“  ๋ชจ๋ธ์€ ํ‹€๋ ธ๋‹ค. ํ•˜์ง€๋งŒ ์ผ๋ถ€๋Š” ์œ ์šฉํ•˜๋‹ค.โ€ โ€” ํ†ต๊ณ„ํ•™์ž ์กฐ์ง€ ๋ฐ•์Šค(George E. P. Box)
์™„๋ฒฝํ•œ ๋ชจ๋ธ๋ณด๋‹ค ๋ฌธ์ œ๋ฅผ ์‹ค์ œ๋กœ ํ’€์–ด์ฃผ๋Š” ์œ ์šฉํ•œ ๋ชจ๋ธ์„ ๋ชฉํ‘œ๋กœ ํ•˜์ž.
๋Œ“๊ธ€ ์ž‘์„ฑ

์ด ๊ธ€์— ๋Œ€ํ•œ ์—ฌ๋Ÿฌ๋ถ„์˜ ์ƒ๊ฐ์„ ๋“ค๋ ค์ฃผ์„ธ์š”

๋Œ“๊ธ€ 0
๋Œ“๊ธ€์„ ๋ถˆ๋Ÿฌ์˜ค๋Š” ์ค‘์ž…๋‹ˆ๋‹ค.

์•„์ง ๋Œ“๊ธ€์ด ์—†์Šต๋‹ˆ๋‹ค.