์ฝ˜ํ…์ธ  ๋Œ€ํ‘œ ์ด๋ฏธ์ง€ - ๐Ÿš€ GPU ์ปดํ“จํŒ…๊ณผ ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ ๊ธฐ๋ฒ•
๐Ÿ”ฌ ์ •๋ณด ์ง€๋Šฅ๊ณตํ•™ ยท ๊ณตํ•™ ์นดํ…Œ๊ณ ๋ฆฌ

๐Ÿš€ GPU ์ปดํ“จํŒ…๊ณผ ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ ๊ธฐ๋ฒ•

์ˆ˜์ฒœ ๊ฐœ์˜ ์ฝ”์–ด๊ฐ€ ๋™์‹œ์— ๋‹ฌ๋ฆฌ๋Š” ์„ธ๊ณ„ โ€”
์™œ AI ์‹œ๋Œ€์˜ ์‹ฌ์žฅ์€ GPU์ธ๊ฐ€? ์นœ๊ตฌ์ฒ˜๋Ÿผ ์‰ฝ๊ณ  ์žฌ๋ฏธ์žˆ๊ฒŒ ํŒŒํ—ค์ณ๋ณด์ž!

๐ŸŽฎ ๊ฒŒ์ž„์„ ์ข‹์•„ํ•˜๋Š” ์นœ๊ตฌ๋ผ๋ฉด GPU(Graphics Processing Unit)๋ผ๋Š” ๋‹จ์–ด๋ฅผ ํ•œ ๋ฒˆ์ฏค์€ ๋“ค์–ด๋ดค์„ ๊ฑฐ์•ผ.
"์•„, ๊ทธ๋ž˜ํ”ฝ์นด๋“œ ๋งํ•˜๋Š” ๊ฑฐ์ง€?" ๋งž์•„! ๊ทผ๋ฐ ์š”์ฆ˜ GPU๋Š” ๋‹จ์ˆœํžˆ ๊ฒŒ์ž„ ํ™”๋ฉด์„ ์˜ˆ์˜๊ฒŒ ๊ทธ๋ ค์ฃผ๋Š” ๊ฒƒ ์ด์ƒ์˜ ์—ญํ• ์„ ํ•˜๊ณ  ์žˆ์–ด.
ChatGPT๋ฅผ ํ•™์Šต์‹œํ‚ค๊ณ , ์ž์œจ์ฃผํ–‰์ฐจ๊ฐ€ ๋„๋กœ๋ฅผ ์ธ์‹ํ•˜๊ณ , ์‹ ์•ฝ ๊ฐœ๋ฐœ ์‹œ๋ฎฌ๋ ˆ์ด์…˜์„ ๋Œ๋ฆฌ๋Š” ๊ฒƒ โ€” ์ด ๋ชจ๋“  ๊ฒŒ GPU ์—†์ด๋Š” ๋ถˆ๊ฐ€๋Šฅ์— ๊ฐ€๊นŒ์›Œ.

์˜ค๋Š˜์€ GPU๊ฐ€ ์™œ ์ด๋ ‡๊ฒŒ ๊ฐ•๋ ฅํ•œ์ง€, ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ(Parallel Processing)๊ฐ€ ๋ญ”์ง€, ๊ทธ๋ฆฌ๊ณ  ์‹ค์ œ๋กœ ์–ด๋–ป๊ฒŒ ์ฝ”๋“œ๋ฅผ ์งœ์„œ GPU๋ฅผ ํ™œ์šฉํ•˜๋Š”์ง€๊นŒ์ง€
๋งˆ์น˜ ์นœ๊ตฌํ•œํ…Œ ์„ค๋ช…ํ•˜๋“ฏ ์‰ฝ๊ณ  ์žฌ๋ฏธ์žˆ๊ฒŒ ํ’€์–ด๋ณผ๊ฒŒ. ์ค€๋น„๋์–ด? ๊ทธ๋Ÿผ ์ถœ๋ฐœ! ๐Ÿ


CPU vs GPU โ€” ๋ˆ„๊ฐ€ ๋” ๊ฐ•ํ• ๊นŒ? CPU (์ค‘์•™์ฒ˜๋ฆฌ์žฅ์น˜) ์ฝ”์–ด 1 ๊ณ ์„ฑ๋Šฅ ์ฝ”์–ด 2 ๊ณ ์„ฑ๋Šฅ ์ฝ”์–ด 3 ๊ณ ์„ฑ๋Šฅ ์ฝ”์–ด 4 ๊ณ ์„ฑ๋Šฅ 4~32๊ฐœ์˜ ๊ฐ•๋ ฅํ•œ ์ฝ”์–ด ๋ณต์žกํ•œ ์ˆœ์ฐจ ์ž‘์—…์— ์ตœ์ ํ™” ํด๋Ÿญ์†๋„: 3~5GHz ์ˆ˜์ค€ GPU (๊ทธ๋ž˜ํ”ฝ์ฒ˜๋ฆฌ์žฅ์น˜) ... ์ˆ˜์ฒœ~์ˆ˜๋งŒ ๊ฐœ์˜ ์ฝ”์–ด ... ์ˆ˜์ฒœ~์ˆ˜๋งŒ ๊ฐœ์˜ ์†Œํ˜• ์ฝ”์–ด ๋‹จ์ˆœ ๋ฐ˜๋ณต ๋ณ‘๋ ฌ ์ž‘์—…์— ์ตœ์ ํ™” ํด๋Ÿญ์†๋„: 1~2GHz ์ˆ˜์ค€ VS ๐Ÿ’ก CPU๋Š” '์ฒœ์žฌ ์†Œ์ˆ˜', GPU๋Š” 'ํ‰๋ฒ”ํ•œ ๋‹ค์ˆ˜'์˜ ํ˜‘๋ ฅ!

๐Ÿง  1. GPU๋ž€ ๋ญ์•ผ? โ€” ๊ทธ๋ž˜ํ”ฝ์นด๋“œ์˜ ์ง„์งœ ์ •์ฒด

GPU๋Š” Graphics Processing Unit์˜ ์•ฝ์ž์•ผ. ์›๋ž˜๋Š” ์ด๋ฆ„ ๊ทธ๋Œ€๋กœ ๊ทธ๋ž˜ํ”ฝ ์ฒ˜๋ฆฌ๋ฅผ ์œ„ํ•ด ๋งŒ๋“ค์–ด์ง„ ์นฉ์ด์—ˆ์–ด.
3D ๊ฒŒ์ž„์—์„œ ์ˆ˜๋ฐฑ๋งŒ ๊ฐœ์˜ ์‚ผ๊ฐํ˜•์„ ์‹ค์‹œ๊ฐ„์œผ๋กœ ๊ทธ๋ฆฌ๊ณ , ๋น›์˜ ๋ฐ˜์‚ฌ๋ฅผ ๊ณ„์‚ฐํ•˜๊ณ , ํ…์Šค์ฒ˜๋ฅผ ์ž…ํžˆ๋Š” ์ž‘์—… โ€” ์ด๋Ÿฐ ๊ฑธ CPU ํ˜ผ์ž ํ•˜๋ฉด ๋„ˆ๋ฌด ๋А๋ ค์„œ ํ™”๋ฉด์ด ๋š๋š ๋Š๊ฒจ๋ฒ„๋ฆฌ๊ฑฐ๋“ .

๐ŸŽฏ GPU์˜ ํƒ„์ƒ ๋ฐฐ๊ฒฝ 1999๋…„, NVIDIA๊ฐ€ GeForce 256์„ ์ถœ์‹œํ•˜๋ฉด์„œ ์ฒ˜์Œ์œผ๋กœ "GPU"๋ผ๋Š” ์šฉ์–ด๋ฅผ ๊ณต์‹ ์‚ฌ์šฉํ–ˆ์–ด.
์ด ์นฉ์€ ๊ธฐ์กด์— CPU๊ฐ€ ๋‹ด๋‹นํ•˜๋˜ ๊ธฐํ•˜ํ•™ ๋ณ€ํ™˜(Transform)๊ณผ ์กฐ๋ช… ๊ณ„์‚ฐ(Lighting)์„ ํ•˜๋“œ์›จ์–ด๋กœ ์ฒ˜๋ฆฌํ–ˆ์ง€.
๋•๋ถ„์— ๊ฒŒ์ž„ ๊ทธ๋ž˜ํ”ฝ์ด ํญ๋ฐœ์ ์œผ๋กœ ๋ฐœ์ „ํ–ˆ๊ณ , ๊ฐœ๋ฐœ์ž๋“ค์€ "์ด ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ ๋Šฅ๋ ฅ์„ ๊ทธ๋ž˜ํ”ฝ ๋ง๊ณ  ๋‹ค๋ฅธ ๊ณณ์—๋„ ์“ธ ์ˆ˜ ์žˆ์ง€ ์•Š์„๊นŒ?" ํ•˜๋Š” ์ƒ๊ฐ์„ ํ•˜๊ธฐ ์‹œ์ž‘ํ–ˆ์–ด.

๐Ÿ”‘ GPU์˜ ํ•ต์‹ฌ ํŠน์ง•

GPU๊ฐ€ CPU์™€ ๊ทผ๋ณธ์ ์œผ๋กœ ๋‹ค๋ฅธ ์ ์€ ์„ค๊ณ„ ์ฒ ํ•™์ด์•ผ.
CPU๋Š” ๋ณต์žกํ•˜๊ณ  ๋‹ค์–‘ํ•œ ์ž‘์—…์„ ๋น ๋ฅด๊ฒŒ ์ฒ˜๋ฆฌํ•˜๋Š” ๋ฐ ์ตœ์ ํ™”๋˜์–ด ์žˆ์–ด.
๋ฐ˜๋ฉด GPU๋Š” ๋‹จ์ˆœํ•˜์ง€๋งŒ ์—„์ฒญ๋‚˜๊ฒŒ ๋งŽ์€ ์ž‘์—…์„ ๋™์‹œ์— ์ฒ˜๋ฆฌํ•˜๋Š” ๋ฐ ํŠนํ™”๋˜์–ด ์žˆ์ง€.

๊ตฌ๋ถ„ CPU GPU
์ฝ”์–ด ์ˆ˜ 4 ~ 128๊ฐœ ์ˆ˜์ฒœ ~ ์ˆ˜๋งŒ ๊ฐœ
์ฝ”์–ด ์„ฑ๋Šฅ ๋งค์šฐ ๊ณ ์„ฑ๋Šฅ ์ƒ๋Œ€์ ์œผ๋กœ ๋‹จ์ˆœ
ํด๋Ÿญ ์†๋„ 3 ~ 5GHz 1 ~ 2GHz
์บ์‹œ ๋ฉ”๋ชจ๋ฆฌ ํฌ๊ณ  ๋ณต์žกํ•œ ๊ณ„์ธต ๊ตฌ์กฐ ์ž‘๊ณ  ๋‹จ์ˆœ
์ตœ์  ์ž‘์—… ์ˆœ์ฐจ์ ยท๋ณต์žกํ•œ ๋กœ์ง ๋ฐ˜๋ณต์ ยท๋ณ‘๋ ฌ ์—ฐ์‚ฐ
๋ฉ”๋ชจ๋ฆฌ ๋Œ€์—ญํญ ์ƒ๋Œ€์ ์œผ๋กœ ๋‚ฎ์Œ ๋งค์šฐ ๋†’์Œ (GDDR6X ๊ธฐ์ค€ 1TB/s+)
"CPU๋Š” ์ฒœ์žฌ ์ˆ˜ํ•™์ž ํ•œ ๋ช…์ด ๋ณต์žกํ•œ ๋ฌธ์ œ๋ฅผ ํ’€์–ด๋‚ด๋Š” ๊ฒƒ์ด๊ณ ,
GPU๋Š” ์ˆ˜์ฒœ ๋ช…์˜ ํ•™์ƒ์ด ๋‹จ์ˆœํ•œ ๊ณ„์‚ฐ์„ ๋™์‹œ์— ์ฒ˜๋ฆฌํ•˜๋Š” ๊ฒƒ์ด๋‹ค."

์ด ๋น„์œ ๊ฐ€ ํ•ต์‹ฌ์ด์•ผ! ๋”ฅ๋Ÿฌ๋‹ ๋ชจ๋ธ์„ ํ•™์Šต์‹œํ‚ฌ ๋•Œ ํ•„์š”ํ•œ ๊ฑด ํ–‰๋ ฌ ๊ณฑ์…ˆ(Matrix Multiplication)์ด๋ผ๋Š” ๋‹จ์ˆœํ•˜์ง€๋งŒ ์—„์ฒญ๋‚˜๊ฒŒ ๋งŽ์€ ์—ฐ์‚ฐ์ด๊ฑฐ๋“ .
์ด๋Ÿฐ ์ž‘์—…์—์„œ GPU๋Š” CPU๋ณด๋‹ค ์ˆ˜์‹ญ ๋ฐฐ์—์„œ ์ˆ˜๋ฐฑ ๋ฐฐ ๋น ๋ฅธ ์„ฑ๋Šฅ์„ ๋ณด์—ฌ์ค˜.


โšก 2. ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ(Parallel Processing)๋ž€? โ€” ๋™์‹œ์— ๋‹ฌ๋ฆฌ๋Š” ๊ธฐ์ˆ 

์ž, ์ด์ œ ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ๊ฐ€ ๋ญ”์ง€ ์ œ๋Œ€๋กœ ์ดํ•ดํ•ด๋ณด์ž.
์‰ฝ๊ฒŒ ๋งํ•˜๋ฉด "์—ฌ๋Ÿฌ ์ž‘์—…์„ ๋™์‹œ์— ์ฒ˜๋ฆฌํ•˜๋Š” ๊ฒƒ"์ด์•ผ. ๊ทผ๋ฐ ์ด๊ฒŒ ์ƒ๊ฐ๋ณด๋‹ค ํ›จ์”ฌ ๊นŠ์€ ๊ฐœ๋…์ด๊ฑฐ๋“ .

๐Ÿ• ํ”ผ์ž ๊ฐ€๊ฒŒ ๋น„์œ ๋กœ ์ดํ•ดํ•˜๊ธฐ

์ˆœ์ฐจ ์ฒ˜๋ฆฌ(Sequential Processing): ์š”๋ฆฌ์‚ฌ 1๋ช…์ด ํ”ผ์ž 10ํŒ์„ ์ˆœ์„œ๋Œ€๋กœ ๋งŒ๋“ค์–ด. 1ํŒ ์™„์„ฑ โ†’ 2ํŒ ์‹œ์ž‘ โ†’ ... โ†’ 10ํŒ ์™„์„ฑ.
์‹œ๊ฐ„์ด ์˜ค๋ž˜ ๊ฑธ๋ฆฌ์ง€๋งŒ ์š”๋ฆฌ์‚ฌ๊ฐ€ ๋ชจ๋“  ๊ฑธ ์ปจํŠธ๋กคํ•  ์ˆ˜ ์žˆ์–ด.

๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ(Parallel Processing): ์š”๋ฆฌ์‚ฌ 10๋ช…์ด ๋™์‹œ์— ํ”ผ์ž 1ํŒ์”ฉ ๋งŒ๋“ค์–ด. ๊ฐ™์€ ์‹œ๊ฐ„์— 10ํŒ์ด ์™„์„ฑ๋ผ!
ํ›จ์”ฌ ๋น ๋ฅด์ง€๋งŒ, ์žฌ๋ฃŒ๋ฅผ ๋‚˜๋ˆ„๊ณ  ์˜ค๋ธ์„ ๊ณต์œ ํ•˜๋Š” ์กฐ์œจ(Coordination)์ด ํ•„์š”ํ•ด.

์ปดํ“จํ„ฐ์—์„œ๋„ ๋งˆ์ฐฌ๊ฐ€์ง€์•ผ. ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ๋ฅผ ์ž˜ ํ•˜๋ ค๋ฉด ์ž‘์—…์„ ์ž˜๊ฒŒ ์ชผ๊ฐœ์„œ ๋…๋ฆฝ์ ์œผ๋กœ ์‹คํ–‰ํ•  ์ˆ˜ ์žˆ์–ด์•ผ ํ•ด.
์ด๊ฑธ ๋ฐ์ดํ„ฐ ๋ณ‘๋ ฌ์„ฑ(Data Parallelism)์ด๋ผ๊ณ  ๋ถˆ๋Ÿฌ.

๐Ÿ“Š ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ์˜ ์ข…๋ฅ˜

1
๋ฐ์ดํ„ฐ ๋ณ‘๋ ฌ์„ฑ (Data Parallelism)
๊ฐ™์€ ์—ฐ์‚ฐ์„ ์„œ๋กœ ๋‹ค๋ฅธ ๋ฐ์ดํ„ฐ์— ๋™์‹œ ์ ์šฉ. ์˜ˆ: ์ด๋ฏธ์ง€ 1000์žฅ์„ ๋™์‹œ์— ์ฒ˜๋ฆฌํ•˜๊ฑฐ๋‚˜, ํ–‰๋ ฌ์˜ ๊ฐ ์›์†Œ๋ฅผ ๋™์‹œ์— ๊ณ„์‚ฐ.
2
์ž‘์—… ๋ณ‘๋ ฌ์„ฑ (Task Parallelism)
์„œ๋กœ ๋‹ค๋ฅธ ์ž‘์—…์„ ๋™์‹œ์— ์‹คํ–‰. ์˜ˆ: ์Œ์•… ์žฌ์ƒํ•˜๋ฉด์„œ ํŒŒ์ผ ๋‹ค์šด๋กœ๋“œํ•˜๋ฉด์„œ ์›น ๋ธŒ๋ผ์šฐ์ง•.
3
ํŒŒ์ดํ”„๋ผ์ธ ๋ณ‘๋ ฌ์„ฑ (Pipeline Parallelism)
์ž‘์—…์„ ๋‹จ๊ณ„๋ณ„๋กœ ๋‚˜๋ˆ ์„œ ๊ฐ ๋‹จ๊ณ„๋ฅผ ๋™์‹œ์— ์ฒ˜๋ฆฌ. ์˜ˆ: ์ž๋™์ฐจ ์กฐ๋ฆฝ ๋ผ์ธ์ฒ˜๋Ÿผ ๊ฐ ๊ณต์ •์ด ๋™์‹œ์— ์ง„ํ–‰.
4
๋ชจ๋ธ ๋ณ‘๋ ฌ์„ฑ (Model Parallelism)
๋”ฅ๋Ÿฌ๋‹ ๋ชจ๋ธ ์ž์ฒด๋ฅผ ์—ฌ๋Ÿฌ GPU์— ๋‚˜๋ˆ ์„œ ๋ฐฐ์น˜. ๋ชจ๋ธ์ด ๋„ˆ๋ฌด ์ปค์„œ GPU 1๊ฐœ์— ์•ˆ ๋“ค์–ด๊ฐˆ ๋•Œ ์‚ฌ์šฉ.

๐Ÿ“ ์•”๋‹ฌ์˜ ๋ฒ•์น™ (Amdahl's Law)

๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ๋ฅผ ๊ณต๋ถ€ํ•˜๋ฉด ๋ฐ˜๋“œ์‹œ ๋งŒ๋‚˜๋Š” ๊ฐœ๋…์ด ์žˆ์–ด โ€” ๋ฐ”๋กœ ์•”๋‹ฌ์˜ ๋ฒ•์น™์ด์•ผ.
1967๋…„ ์ง„ ์•”๋‹ฌ(Gene Amdahl)์ด ์ œ์‹œํ•œ ์ด ๋ฒ•์น™์€ ๋ณ‘๋ ฌํ™”์˜ ํ•œ๊ณ„๋ฅผ ์ˆ˜ํ•™์ ์œผ๋กœ ์„ค๋ช…ํ•ด์ค˜.

๐Ÿ”ข ์•”๋‹ฌ์˜ ๋ฒ•์น™ ๊ณต์‹ S(n) = 1 / [(1-p) + p/n]

S(n) = ์ „์ฒด ์†๋„ ํ–ฅ์ƒ ๋น„์œจ
p = ๋ณ‘๋ ฌํ™” ๊ฐ€๋Šฅํ•œ ๋ถ€๋ถ„์˜ ๋น„์œจ (0~1)
n = ํ”„๋กœ์„ธ์„œ(์ฝ”์–ด) ์ˆ˜

์˜ˆ๋ฅผ ๋“ค์–ด, ํ”„๋กœ๊ทธ๋žจ์˜ 90%๊ฐ€ ๋ณ‘๋ ฌํ™” ๊ฐ€๋Šฅํ•˜๊ณ  ์ฝ”์–ด๊ฐ€ ๋ฌดํ•œํžˆ ๋งŽ๋‹ค๋ฉด?
S = 1 / (1 - 0.9) = ์ตœ๋Œ€ 10๋ฐฐ๊นŒ์ง€๋งŒ ๋นจ๋ผ์งˆ ์ˆ˜ ์žˆ์–ด!
๋‚˜๋จธ์ง€ 10%์˜ ์ˆœ์ฐจ ์ฒ˜๋ฆฌ ๋ถ€๋ถ„์ด ๋ณ‘๋ชฉ์ด ๋˜๋Š” ๊ฑฐ์•ผ.

์ด๊ฒŒ ์™œ ์ค‘์š”ํ•˜๋ƒ๋ฉด, GPU๋ฅผ ์•„๋ฌด๋ฆฌ ๋งŽ์ด ์จ๋„ ์ˆœ์ฐจ์ ์œผ๋กœ ์ฒ˜๋ฆฌํ•ด์•ผ ํ•˜๋Š” ๋ถ€๋ถ„์ด ์žˆ์œผ๋ฉด ๊ทธ๊ฒŒ ์ „์ฒด ์„ฑ๋Šฅ์˜ ํ•œ๊ณ„๊ฐ€ ๋œ๋‹ค๋Š” ๊ฑฐ์•ผ.
๊ทธ๋ž˜์„œ ์ข‹์€ GPU ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ํ•ต์‹ฌ์€ ๋ณ‘๋ ฌํ™” ๊ฐ€๋Šฅํ•œ ๋ถ€๋ถ„์„ ์ตœ๋Œ€ํ•œ ๋Š˜๋ฆฌ๋Š” ๊ฒƒ์ด์•ผ.

์•”๋‹ฌ์˜ ๋ฒ•์น™ โ€” ๋ณ‘๋ ฌํ™” ๋น„์œจ์— ๋”ฐ๋ฅธ ์†๋„ ํ–ฅ์ƒ ํ”„๋กœ์„ธ์„œ(์ฝ”์–ด) ์ˆ˜ ์†๋„ ํ–ฅ์ƒ ๋ฐฐ์œจ 1 2 4 8 16 โˆž 1x 2x 4x 6x 8x p=50% (์ตœ๋Œ€ 2๋ฐฐ) p=75% (์ตœ๋Œ€ 4๋ฐฐ) p=90% (์ตœ๋Œ€ 10๋ฐฐ) p=95% (์ตœ๋Œ€ 20๋ฐฐ)

๐Ÿ—๏ธ 3. GPU ๋‚ด๋ถ€ ๊ตฌ์กฐ โ€” ์ˆ˜์ฒœ ๊ฐœ์˜ ์ฝ”์–ด๊ฐ€ ์–ด๋–ป๊ฒŒ ์ƒ๊ฒผ์„๊นŒ?

GPU ์•ˆ์„ ๋“ค์—ฌ๋‹ค๋ณด๋ฉด ์ •๋ง ์‹ ๊ธฐํ•œ ๊ตฌ์กฐ๊ฐ€ ์žˆ์–ด. NVIDIA GPU๋ฅผ ๊ธฐ์ค€์œผ๋กœ ์„ค๋ช…ํ• ๊ฒŒ.
(AMD๋„ ๋น„์Šทํ•œ ๊ฐœ๋…์ด์ง€๋งŒ ์šฉ์–ด๊ฐ€ ์กฐ๊ธˆ ๋‹ฌ๋ผ.)

๐Ÿ”ฌ NVIDIA GPU ๊ณ„์ธต ๊ตฌ์กฐ

1
SM (Streaming Multiprocessor)
GPU์˜ ๊ธฐ๋ณธ ์ฒ˜๋ฆฌ ๋‹จ์œ„์•ผ. ํ•˜๋‚˜์˜ SM ์•ˆ์— ์ˆ˜์‹ญ ๊ฐœ์˜ CUDA ์ฝ”์–ด, ํ…์„œ ์ฝ”์–ด, ๋ ˆ์ง€์Šคํ„ฐ ํŒŒ์ผ, ๊ณต์œ  ๋ฉ”๋ชจ๋ฆฌ ๋“ฑ์ด ๋“ค์–ด์žˆ์–ด.
์ตœ์‹  H100 GPU์—๋Š” 132๊ฐœ์˜ SM์ด ์žˆ์–ด.
2
CUDA ์ฝ”์–ด (CUDA Core)
์‹ค์ œ ๋ถ€๋™์†Œ์ˆ˜์  ์—ฐ์‚ฐ์„ ์ˆ˜ํ–‰ํ•˜๋Š” ์ตœ์†Œ ๋‹จ์œ„์•ผ. H100 ๊ธฐ์ค€์œผ๋กœ SM๋‹น 128๊ฐœ, ์ „์ฒด 16,896๊ฐœ์˜ CUDA ์ฝ”์–ด๊ฐ€ ์žˆ์–ด.
์ด ์ฝ”์–ด๋“ค์ด ๋™์‹œ์— ์—ฐ์‚ฐ์„ ์ˆ˜ํ–‰ํ•˜๋Š” ๊ฑฐ์•ผ.
3
ํ…์„œ ์ฝ”์–ด (Tensor Core)
๋”ฅ๋Ÿฌ๋‹ ํ–‰๋ ฌ ์—ฐ์‚ฐ์— ํŠนํ™”๋œ ํŠน์ˆ˜ ์ฝ”์–ด์•ผ. ์ผ๋ฐ˜ CUDA ์ฝ”์–ด๋ณด๋‹ค ํ–‰๋ ฌ ๊ณฑ์…ˆ์„ ํ›จ์”ฌ ๋น ๋ฅด๊ฒŒ ์ฒ˜๋ฆฌํ•ด.
H100์—๋Š” SM๋‹น 4๊ฐœ, ์ „์ฒด 528๊ฐœ์˜ ํ…์„œ ์ฝ”์–ด๊ฐ€ ์žˆ์–ด.
4
๊ณต์œ  ๋ฉ”๋ชจ๋ฆฌ (Shared Memory)
๊ฐ™์€ SM ๋‚ด์˜ ์Šค๋ ˆ๋“œ๋“ค์ด ๊ณต์œ ํ•˜๋Š” ์ดˆ๊ณ ์† ๋ฉ”๋ชจ๋ฆฌ์•ผ. L1 ์บ์‹œ์™€ ํ•จ๊ป˜ ์‚ฌ์šฉ๋˜๋ฉฐ, ์ „์—ญ ๋ฉ”๋ชจ๋ฆฌ(VRAM)๋ณด๋‹ค ์ˆ˜์‹ญ ๋ฐฐ ๋น ๋ฅด๊ฒŒ ์ ‘๊ทผํ•  ์ˆ˜ ์žˆ์–ด.
5
VRAM (Video RAM)
GPU์˜ ์ฃผ ๋ฉ”๋ชจ๋ฆฌ์•ผ. H100 ๊ธฐ์ค€ 80GB์˜ HBM3 ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ์‚ฌ์šฉํ•˜๊ณ , ๋ฉ”๋ชจ๋ฆฌ ๋Œ€์—ญํญ์ด 3.35TB/s์— ๋‹ฌํ•ด.
CPU์˜ DDR5 ๋ฉ”๋ชจ๋ฆฌ ๋Œ€์—ญํญ(~100GB/s)๊ณผ ๋น„๊ตํ•˜๋ฉด ์—„์ฒญ๋‚œ ์ฐจ์ด์•ผ.

๐Ÿงต ์Šค๋ ˆ๋“œ ๊ณ„์ธต ๊ตฌ์กฐ (CUDA ๊ธฐ์ค€)

GPU์—์„œ ํ”„๋กœ๊ทธ๋ž˜๋ฐํ•  ๋•Œ๋Š” ์Šค๋ ˆ๋“œ(Thread)๋ฅผ ๊ณ„์ธต์ ์œผ๋กœ ๊ด€๋ฆฌํ•ด.
์ด ๊ฐœ๋…์ด ์ฒ˜์Œ์—” ์ข€ ํ—ท๊ฐˆ๋ฆด ์ˆ˜ ์žˆ๋Š”๋ฐ, ์ฐจ๊ทผ์ฐจ๊ทผ ๋ณด๋ฉด ์ดํ•ด๋ผ!

๐Ÿ”บ ์Šค๋ ˆ๋“œ ๊ณ„์ธต (์ž‘์€ ๊ฒƒ โ†’ ํฐ ๊ฒƒ) Thread (์Šค๋ ˆ๋“œ): ๊ฐ€์žฅ ์ž‘์€ ์‹คํ–‰ ๋‹จ์œ„. ๊ฐ ์Šค๋ ˆ๋“œ๋Š” ๋…๋ฆฝ์ ์œผ๋กœ ์—ฐ์‚ฐ์„ ์ˆ˜ํ–‰ํ•ด.

Warp (์›Œํ”„): 32๊ฐœ์˜ ์Šค๋ ˆ๋“œ ๋ฌถ์Œ. GPU๋Š” ์›Œํ”„ ๋‹จ์œ„๋กœ ์Šค์ผ€์ค„๋งํ•ด. ์›Œํ”„ ๋‚ด ์Šค๋ ˆ๋“œ๋“ค์€ ๊ฐ™์€ ๋ช…๋ น์–ด๋ฅผ ๋™์‹œ์— ์‹คํ–‰ํ•ด (SIMT ๋ฐฉ์‹).

Block (๋ธ”๋ก): ์—ฌ๋Ÿฌ ์›Œํ”„์˜ ๋ฌถ์Œ. ๊ฐ™์€ ๋ธ”๋ก ๋‚ด ์Šค๋ ˆ๋“œ๋“ค์€ ๊ณต์œ  ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ์‚ฌ์šฉํ•˜๊ณ  ๋™๊ธฐํ™”ํ•  ์ˆ˜ ์žˆ์–ด.

Grid (๊ทธ๋ฆฌ๋“œ): ์—ฌ๋Ÿฌ ๋ธ”๋ก์˜ ๋ฌถ์Œ. ํ•˜๋‚˜์˜ ์ปค๋„(GPU ํ•จ์ˆ˜) ์‹คํ–‰ ์‹œ ๊ทธ๋ฆฌ๋“œ ๋‹จ์œ„๋กœ ์‹คํ–‰๋ผ.
๐Ÿ’ก SIMT (Single Instruction, Multiple Threads) GPU์˜ ํ•ต์‹ฌ ์‹คํ–‰ ๋ชจ๋ธ์ด์•ผ. ํ•˜๋‚˜์˜ ๋ช…๋ น์–ด๋ฅผ ์—ฌ๋Ÿฌ ์Šค๋ ˆ๋“œ๊ฐ€ ๋™์‹œ์— ์‹คํ–‰ํ•˜๋˜, ๊ฐ ์Šค๋ ˆ๋“œ๋Š” ์„œ๋กœ ๋‹ค๋ฅธ ๋ฐ์ดํ„ฐ๋ฅผ ์ฒ˜๋ฆฌํ•ด.
์ด๊ฒŒ ๋ฐ”๋กœ GPU๊ฐ€ ๋ฐ์ดํ„ฐ ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ์— ๊ฐ•ํ•œ ์ด์œ ์•ผ!

๋‹จ, ๊ฐ™์€ ์›Œํ”„ ๋‚ด์—์„œ ์Šค๋ ˆ๋“œ๋“ค์ด ์„œ๋กœ ๋‹ค๋ฅธ ๋ถ„๊ธฐ(if-else)๋ฅผ ํƒ€๋ฉด ์›Œํ”„ ๋‹ค์ด๋ฒ„์ „์Šค(Warp Divergence)๊ฐ€ ๋ฐœ์ƒํ•ด์„œ ์„ฑ๋Šฅ์ด ๋–จ์–ด์ ธ.
์ด๊ฑธ ํ”ผํ•˜๋Š” ๊ฒŒ GPU ์ตœ์ ํ™”์˜ ํ•ต์‹ฌ ์ค‘ ํ•˜๋‚˜์•ผ.

๐Ÿ’ป 4. CUDA ํ”„๋กœ๊ทธ๋ž˜๋ฐ โ€” GPU์—๊ฒŒ ์ผ ์‹œํ‚ค๋Š” ๋ฐฉ๋ฒ•

์ž, ์ด์ œ ์‹ค์ œ๋กœ GPU๋ฅผ ์–ด๋–ป๊ฒŒ ํ”„๋กœ๊ทธ๋ž˜๋ฐํ•˜๋Š”์ง€ ์•Œ์•„๋ณด์ž!
NVIDIA๊ฐ€ ๋งŒ๋“  CUDA(Compute Unified Device Architecture)๋Š” GPU ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ํ‘œ์ค€์ด์•ผ.
2006๋…„์— ์ฒ˜์Œ ์ถœ์‹œ๋๊ณ , ์ง€๊ธˆ๋„ AI/๋”ฅ๋Ÿฌ๋‹ ๋ถ„์•ผ์—์„œ ์••๋„์ ์œผ๋กœ ๋งŽ์ด ์“ฐ์—ฌ.

๐Ÿ”ง CUDA์˜ ๊ธฐ๋ณธ ๊ฐœ๋…

CUDA ํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ๋Š” ๋‘ ๊ฐ€์ง€ ์‹คํ–‰ ํ™˜๊ฒฝ์„ ๊ตฌ๋ถ„ํ•ด์•ผ ํ•ด:

๐Ÿ–ฅ๏ธ Host (ํ˜ธ์ŠคํŠธ)
CPU์™€ ๋ฉ”์ธ ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ์˜๋ฏธํ•ด.
ํ”„๋กœ๊ทธ๋žจ์˜ ์ „์ฒด ํ๋ฆ„์„ ์ œ์–ดํ•˜๊ณ ,
GPU์— ์ž‘์—…์„ ์ง€์‹œํ•˜๋Š” ์—ญํ• .
๐ŸŽฎ Device (๋””๋ฐ”์ด์Šค)
GPU์™€ VRAM์„ ์˜๋ฏธํ•ด.
์‹ค์ œ ๋ณ‘๋ ฌ ์—ฐ์‚ฐ์„ ์ˆ˜ํ–‰ํ•˜๋Š” ๊ณณ.
์ปค๋„(Kernel) ํ•จ์ˆ˜๊ฐ€ ์‹คํ–‰๋˜๋Š” ๊ณต๊ฐ„.

๐Ÿ“ CUDA ์ฝ”๋“œ ์˜ˆ์‹œ โ€” ๋ฒกํ„ฐ ๋ง์…ˆ

๊ฐ€์žฅ ๊ธฐ๋ณธ์ ์ธ ์˜ˆ์ œ์ธ ๋ฒกํ„ฐ ๋ง์…ˆ์„ CUDA๋กœ ๊ตฌํ˜„ํ•ด๋ณผ๊ฒŒ.
๋‘ ๋ฐฐ์—ด A์™€ B๋ฅผ ๋”ํ•ด์„œ C์— ์ €์žฅํ•˜๋Š” ๊ฐ„๋‹จํ•œ ์ž‘์—…์ด์•ผ.

// CUDA ์ปค๋„ ํ•จ์ˆ˜ ์ •์˜ (__global__ ํ‚ค์›Œ๋“œ)
__global__ void vectorAdd(float* A, float* B, float* C, int n) {
    // ๊ฐ ์Šค๋ ˆ๋“œ์˜ ๊ณ ์œ  ์ธ๋ฑ์Šค ๊ณ„์‚ฐ
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    
    // ๋ฐฐ์—ด ๋ฒ”์œ„ ์ดˆ๊ณผ ๋ฐฉ์ง€
    if (idx < n) {
        C[idx] = A[idx] + B[idx];  // ๊ฐ ์Šค๋ ˆ๋“œ๊ฐ€ ํ•˜๋‚˜์˜ ์›์†Œ ์ฒ˜๋ฆฌ
    }
}

int main() {
    int n = 1000000;  // 100๋งŒ ๊ฐœ ์›์†Œ
    size_t size = n * sizeof(float);
    
    // ํ˜ธ์ŠคํŠธ(CPU) ๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น
    float *h_A = (float*)malloc(size);
    float *h_B = (float*)malloc(size);
    float *h_C = (float*)malloc(size);
    
    // ๋””๋ฐ”์ด์Šค(GPU) ๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น
    float *d_A, *d_B, *d_C;
    cudaMalloc(&d_A, size);
    cudaMalloc(&d_B, size);
    cudaMalloc(&d_C, size);
    
    // ๋ฐ์ดํ„ฐ๋ฅผ CPU โ†’ GPU๋กœ ๋ณต์‚ฌ
    cudaMemcpy(d_A, h_A, size, cudaMemcpyHostToDevice);
    cudaMemcpy(d_B, h_B, size, cudaMemcpyHostToDevice);
    
    // ์ปค๋„ ์‹คํ–‰: ๋ธ”๋ก๋‹น 256๊ฐœ ์Šค๋ ˆ๋“œ
    int threadsPerBlock = 256;
    int blocksPerGrid = (n + threadsPerBlock - 1) / threadsPerBlock;
    vectorAdd<<<blocksPerGrid, threadsPerBlock>>>(d_A, d_B, d_C, n);
    
    // ๊ฒฐ๊ณผ๋ฅผ GPU โ†’ CPU๋กœ ๋ณต์‚ฌ
    cudaMemcpy(h_C, d_C, size, cudaMemcpyDeviceToHost);
    
    // ๋ฉ”๋ชจ๋ฆฌ ํ•ด์ œ
    cudaFree(d_A); cudaFree(d_B); cudaFree(d_C);
    free(h_A); free(h_B); free(h_C);
    return 0;
}
๐Ÿ” ์ฝ”๋“œ ํ•ต์‹ฌ ํฌ์ธํŠธ __global__: GPU์—์„œ ์‹คํ–‰๋˜๋Š” ํ•จ์ˆ˜(์ปค๋„)๋ฅผ ์„ ์–ธํ•˜๋Š” ํ‚ค์›Œ๋“œ
blockIdx.x * blockDim.x + threadIdx.x: ๊ฐ ์Šค๋ ˆ๋“œ์˜ ์ „์—ญ ์ธ๋ฑ์Šค ๊ณ„์‚ฐ
<<>>: ์ปค๋„ ์‹คํ–‰ ์„ค์ • (๊ทธ๋ฆฌ๋“œ ํฌ๊ธฐ, ๋ธ”๋ก ํฌ๊ธฐ)
cudaMalloc / cudaFree: GPU ๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น/ํ•ด์ œ
cudaMemcpy: CPU โ†” GPU ๊ฐ„ ๋ฐ์ดํ„ฐ ์ „์†ก

๐Ÿš€ CUDA ๋ฉ”๋ชจ๋ฆฌ ์ตœ์ ํ™” ์ „๋žต

GPU ํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ ์„ฑ๋Šฅ์˜ ํ•ต์‹ฌ์€ ๋ฉ”๋ชจ๋ฆฌ ์ ‘๊ทผ ํŒจํ„ด์ด์•ผ.
์ž˜๋ชป๋œ ๋ฉ”๋ชจ๋ฆฌ ์ ‘๊ทผ์€ GPU์˜ ๊ฐ•๋ ฅํ•œ ์—ฐ์‚ฐ ๋Šฅ๋ ฅ์„ ๋ฌด์šฉ์ง€๋ฌผ๋กœ ๋งŒ๋“ค์–ด๋ฒ„๋ ค.

1
ํ•ฉ์ณ์ง„ ๋ฉ”๋ชจ๋ฆฌ ์ ‘๊ทผ (Coalesced Memory Access)
๊ฐ™์€ ์›Œํ”„์˜ ์Šค๋ ˆ๋“œ๋“ค์ด ์—ฐ์†๋œ ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ์— ์ ‘๊ทผํ•˜๋ฉด ํ•œ ๋ฒˆ์˜ ๋ฉ”๋ชจ๋ฆฌ ํŠธ๋žœ์žญ์…˜์œผ๋กœ ์ฒ˜๋ฆฌ๋ผ.
๋ฐ˜๋Œ€๋กœ ํฉ์–ด์ง„ ์ฃผ์†Œ์— ์ ‘๊ทผํ•˜๋ฉด ์—ฌ๋Ÿฌ ๋ฒˆ์˜ ํŠธ๋žœ์žญ์…˜์ด ํ•„์š”ํ•ด์„œ ๋А๋ ค์ ธ.
2
๊ณต์œ  ๋ฉ”๋ชจ๋ฆฌ ํ™œ์šฉ (Shared Memory)
์ „์—ญ ๋ฉ”๋ชจ๋ฆฌ(VRAM)๋ณด๋‹ค 100๋ฐฐ ์ด์ƒ ๋น ๋ฅธ ๊ณต์œ  ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ์ ๊ทน ํ™œ์šฉํ•ด์•ผ ํ•ด.
๊ฐ™์€ ๋ฐ์ดํ„ฐ๋ฅผ ์—ฌ๋Ÿฌ ๋ฒˆ ์ฝ์–ด์•ผ ํ•  ๋•Œ ๊ณต์œ  ๋ฉ”๋ชจ๋ฆฌ์— ์บ์‹ฑํ•˜๋ฉด ์„ฑ๋Šฅ์ด ํฌ๊ฒŒ ํ–ฅ์ƒ๋ผ.
3
๋ฑ…ํฌ ์ถฉ๋Œ ๋ฐฉ์ง€ (Bank Conflict Avoidance)
๊ณต์œ  ๋ฉ”๋ชจ๋ฆฌ๋Š” 32๊ฐœ์˜ ๋ฑ…ํฌ๋กœ ๋‚˜๋‰˜์–ด ์žˆ์–ด. ๊ฐ™์€ ์›Œํ”„์˜ ์Šค๋ ˆ๋“œ๋“ค์ด ๊ฐ™์€ ๋ฑ…ํฌ์— ๋™์‹œ ์ ‘๊ทผํ•˜๋ฉด ์ถฉ๋Œ์ด ๋ฐœ์ƒํ•ด์„œ ์ง๋ ฌํ™”๋ผ.
์ ์ ˆํ•œ ํŒจ๋”ฉ์œผ๋กœ ์ด๋ฅผ ๋ฐฉ์ง€ํ•  ์ˆ˜ ์žˆ์–ด.
4
๋ ˆ์ง€์Šคํ„ฐ ํ™œ์šฉ ์ตœ์ ํ™”
์Šค๋ ˆ๋“œ๋‹น ์‚ฌ์šฉํ•˜๋Š” ๋ ˆ์ง€์Šคํ„ฐ ์ˆ˜๋ฅผ ์ตœ์†Œํ™”ํ•ด์•ผ ํ•ด. ๋ ˆ์ง€์Šคํ„ฐ๊ฐ€ ๋ถ€์กฑํ•˜๋ฉด ๋กœ์ปฌ ๋ฉ”๋ชจ๋ฆฌ(๋А๋ฆฐ VRAM)๋กœ ์Šคํ•„(Spill)์ด ๋ฐœ์ƒํ•ด.
GPU ๋ฉ”๋ชจ๋ฆฌ ๊ณ„์ธต ๊ตฌ์กฐ ๋ ˆ์ง€์Šคํ„ฐ (Register) ์Šค๋ ˆ๋“œ๋‹น ์ „์šฉ | ์ ‘๊ทผ์†๋„: 1 ์‚ฌ์ดํด | ์šฉ๋Ÿ‰: ๋งค์šฐ ์ž‘์Œ ๊ณต์œ  ๋ฉ”๋ชจ๋ฆฌ (Shared Memory) / L1 ์บ์‹œ ๋ธ”๋ก ๋‚ด ๊ณต์œ  | ์ ‘๊ทผ์†๋„: ~5 ์‚ฌ์ดํด | ์šฉ๋Ÿ‰: ์ˆ˜์‹ญ KB L2 ์บ์‹œ GPU ์ „์ฒด ๊ณต์œ  | ์ ‘๊ทผ์†๋„: ~30 ์‚ฌ์ดํด | ์šฉ๋Ÿ‰: ์ˆ˜ MB ์ „์—ญ ๋ฉ”๋ชจ๋ฆฌ (Global Memory / VRAM) GPU ์ „์ฒด ๊ณต์œ  | ์ ‘๊ทผ์†๋„: ~200-800 ์‚ฌ์ดํด | ์šฉ๋Ÿ‰: ์ˆ˜์‹ญ GB ํ˜ธ์ŠคํŠธ ๋ฉ”๋ชจ๋ฆฌ (CPU RAM) CPU ๋ฉ”์ธ ๋ฉ”๋ชจ๋ฆฌ | PCIe ์ „์†ก | ์šฉ๋Ÿ‰: ์ˆ˜์‹ญ~์ˆ˜๋ฐฑ GB โšก ์ตœ๊ณ ์† โšก ๊ณ ์† ๐Ÿ”ถ ์ค‘์† ๐Ÿ”ท ์ €์† ๐Ÿ”ด ์ตœ์ €์† ๐Ÿ’ก ์œ„๋กœ ๊ฐˆ์ˆ˜๋ก ๋น ๋ฅด๊ณ  ์ž‘๋‹ค โ€” ์•„๋ž˜๋กœ ๊ฐˆ์ˆ˜๋ก ๋А๋ฆฌ๊ณ  ํฌ๋‹ค

๐Ÿ› ๏ธ 5. GPU ์ปดํ“จํŒ… ํ”„๋ ˆ์ž„์›Œํฌ ์ด์ •๋ฆฌ

CUDA๋งŒ์ด GPU ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ์ „๋ถ€๋Š” ์•„๋‹ˆ์•ผ! ๋‹ค์–‘ํ•œ ํ”„๋ ˆ์ž„์›Œํฌ์™€ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๊ฐ€ ์žˆ์–ด์„œ
๋ชฉ์ ์— ๋งž๊ฒŒ ์„ ํƒํ•ด์„œ ์“ธ ์ˆ˜ ์žˆ์–ด. ํ•œ๋ฒˆ ์ญ‰ ์‚ดํŽด๋ณด์ž. ๐Ÿ—บ๏ธ

๐Ÿ”ต CUDA (NVIDIA)

NVIDIA ์ „์šฉ C/C++ Python ๋ฐ”์ธ๋”ฉ ์ง€์›

NVIDIA GPU๋ฅผ ์œ„ํ•œ ๊ณต์‹ ๋ณ‘๋ ฌ ์ปดํ“จํŒ… ํ”Œ๋žซํผ์ด์•ผ. 2006๋…„ ์ถœ์‹œ ์ดํ›„ GPU ์ปดํ“จํŒ…์˜ ํ‘œ์ค€์ด ๋์–ด.
๋”ฅ๋Ÿฌ๋‹ ํ”„๋ ˆ์ž„์›Œํฌ(PyTorch, TensorFlow)์˜ ๊ธฐ๋ฐ˜์ด ๋˜๋Š” ํ•ต์‹ฌ ๊ธฐ์ˆ ์ด์•ผ.
cuBLAS(์„ ํ˜•๋Œ€์ˆ˜), cuDNN(๋”ฅ๋Ÿฌ๋‹), cuFFT(๊ณ ์† ํ‘ธ๋ฆฌ์— ๋ณ€ํ™˜) ๋“ฑ ๋‹ค์–‘ํ•œ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ์ œ๊ณตํ•ด.

๐Ÿ”ด OpenCL (Open Computing Language)

ํฌ๋กœ์Šค ํ”Œ๋žซํผ AMD/NVIDIA/Intel ์ง€์›

Khronos Group์ด ๊ด€๋ฆฌํ•˜๋Š” ๊ฐœ๋ฐฉํ˜• ํ‘œ์ค€์ด์•ผ. NVIDIA, AMD, Intel GPU๋Š” ๋ฌผ๋ก  CPU, FPGA์—์„œ๋„ ์‹คํ–‰๋ผ.
CUDA๋ณด๋‹ค ์ด์‹์„ฑ์ด ๋†’์ง€๋งŒ, ์ฝ”๋“œ๊ฐ€ ๋” ๋ณต์žกํ•˜๊ณ  ์ตœ์ ํ™”๊ฐ€ ์–ด๋ ค์›Œ.
ํŠน์ • ๋ฒค๋”์— ์ข…์†๋˜์ง€ ์•Š์•„์•ผ ํ•  ๋•Œ ์„ ํƒํ•˜๋Š” ์˜ต์…˜์ด์•ผ.

๐ŸŸฃ ROCm (AMD)

AMD ์ „์šฉ ์˜คํ”ˆ์†Œ์Šค

AMD์˜ GPU ์ปดํ“จํŒ… ํ”Œ๋žซํผ์ด์•ผ. CUDA์™€ ์œ ์‚ฌํ•œ HIP(Heterogeneous-compute Interface for Portability) API๋ฅผ ์ œ๊ณตํ•ด์„œ
CUDA ์ฝ”๋“œ๋ฅผ ๋น„๊ต์  ์‰ฝ๊ฒŒ AMD GPU๋กœ ํฌํŒ…ํ•  ์ˆ˜ ์žˆ์–ด.
์ตœ๊ทผ AMD GPU์˜ ์„ฑ๋Šฅ์ด ํฌ๊ฒŒ ํ–ฅ์ƒ๋˜๋ฉด์„œ ROCm ์ƒํƒœ๊ณ„๋„ ๋น ๋ฅด๊ฒŒ ์„ฑ์žฅํ•˜๊ณ  ์žˆ์–ด.

๐ŸŸก OpenGL Compute Shader / Vulkan Compute

๊ทธ๋ž˜ํ”ฝ์Šค ์—ฐ๋™ ๊ฒŒ์ž„ ๊ฐœ๋ฐœ

๊ทธ๋ž˜ํ”ฝ ๋ Œ๋”๋ง ํŒŒ์ดํ”„๋ผ์ธ๊ณผ ํ†ตํ•ฉ๋œ GPU ์ปดํ“จํŒ…์ด์•ผ.
๊ฒŒ์ž„ ์—”์ง„์—์„œ ๋ฌผ๋ฆฌ ์‹œ๋ฎฌ๋ ˆ์ด์…˜, ํŒŒํ‹ฐํด ์‹œ์Šคํ…œ, ํฌ์ŠคํŠธ ํ”„๋กœ์„ธ์‹ฑ ๋“ฑ์— ํ™œ์šฉ๋ผ.

๐Ÿ Python ๊ธฐ๋ฐ˜ ๊ณ ์ˆ˜์ค€ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ

์ง์ ‘ CUDA ์ฝ”๋“œ๋ฅผ ์งœ์ง€ ์•Š์•„๋„ Python์—์„œ GPU๋ฅผ ํ™œ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋“ค์ด ์žˆ์–ด:

๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ํŠน์ง• ์ฃผ์š” ์šฉ๋„
PyTorch ๋™์  ๊ณ„์‚ฐ ๊ทธ๋ž˜ํ”„, ์ง๊ด€์  API ๋”ฅ๋Ÿฌ๋‹ ์—ฐ๊ตฌ/๊ฐœ๋ฐœ
TensorFlow ์ •์ /๋™์  ๊ทธ๋ž˜ํ”„, ํ”„๋กœ๋•์…˜ ๊ฐ•์  ๋”ฅ๋Ÿฌ๋‹ ๋ฐฐํฌ/์„œ๋น„์Šค
CuPy NumPy ํ˜ธํ™˜ GPU ๋ฐฐ์—ด ๊ณผํ•™ ๊ณ„์‚ฐ, ์ˆ˜์น˜ ํ•ด์„
Numba Python ํ•จ์ˆ˜๋ฅผ GPU ์ปค๋„๋กœ JIT ์ปดํŒŒ์ผ ์ปค์Šคํ…€ GPU ์ปค๋„ ๊ฐœ๋ฐœ
JAX ์ž๋™ ๋ฏธ๋ถ„ + XLA ์ปดํŒŒ์ผ ML ์—ฐ๊ตฌ, ๊ณ ์„ฑ๋Šฅ ์ˆ˜์น˜ ๊ณ„์‚ฐ
RAPIDS GPU ๊ฐ€์† ๋ฐ์ดํ„ฐ ๋ถ„์„ ๋ฐ์ดํ„ฐ ์‚ฌ์ด์–ธ์Šค, ๋จธ์‹ ๋Ÿฌ๋‹

๐Ÿ Numba๋กœ GPU ์ปค๋„ ์ž‘์„ฑํ•˜๊ธฐ

Python์—์„œ ์ง์ ‘ GPU ์ปค๋„์„ ์ž‘์„ฑํ•˜๊ณ  ์‹ถ๋‹ค๋ฉด Numba๊ฐ€ ์ตœ๊ณ ์•ผ!
CUDA C ์ฝ”๋“œ ์—†์ด Python ๋ฌธ๋ฒ•์œผ๋กœ GPU ํ”„๋กœ๊ทธ๋ž˜๋ฐ์ด ๊ฐ€๋Šฅํ•ด.

from numba import cuda
import numpy as np
import math

# GPU ์ปค๋„ ํ•จ์ˆ˜ ์ •์˜
@cuda.jit
def vector_add_gpu(A, B, C):
    # ์Šค๋ ˆ๋“œ ์ธ๋ฑ์Šค ๊ณ„์‚ฐ
    idx = cuda.grid(1)
    if idx < A.shape[0]:
        C[idx] = A[idx] + B[idx]

# ๋ฐ์ดํ„ฐ ์ค€๋น„
n = 1_000_000
A = np.random.rand(n).astype(np.float32)
B = np.random.rand(n).astype(np.float32)
C = np.zeros(n, dtype=np.float32)

# GPU๋กœ ๋ฐ์ดํ„ฐ ์ „์†ก
d_A = cuda.to_device(A)
d_B = cuda.to_device(B)
d_C = cuda.to_device(C)

# ์ปค๋„ ์‹คํ–‰ ์„ค์ •
threads_per_block = 256
blocks_per_grid = math.ceil(n / threads_per_block)

# GPU ์ปค๋„ ์‹คํ–‰
vector_add_gpu[blocks_per_grid, threads_per_block](d_A, d_B, d_C)

# ๊ฒฐ๊ณผ ๊ฐ€์ ธ์˜ค๊ธฐ
result = d_C.copy_to_host()
print(f"๊ฒฐ๊ณผ ํ™•์ธ: {np.allclose(A + B, result)}")  # True
โœ… Numba์˜ ์žฅ์  Python ๋ฌธ๋ฒ• ๊ทธ๋Œ€๋กœ GPU ์ปค๋„ ์ž‘์„ฑ ๊ฐ€๋Šฅ
@cuda.jit ๋ฐ์ฝ”๋ ˆ์ดํ„ฐ ํ•˜๋‚˜๋กœ GPU ํ•จ์ˆ˜ ์„ ์–ธ
NumPy ๋ฐฐ์—ด๊ณผ ์ž์—ฐ์Šค๋Ÿฝ๊ฒŒ ์—ฐ๋™
CUDA C๋ณด๋‹ค ํ›จ์”ฌ ๋น ๋ฅธ ๊ฐœ๋ฐœ ์†๋„
JIT ์ปดํŒŒ์ผ๋กœ ์„ฑ๋Šฅ๋„ ์ค€์ˆ˜

๐Ÿค– 6. AI/๋”ฅ๋Ÿฌ๋‹๊ณผ GPU โ€” ์™œ AI๋Š” GPU ์—†์ด ๋ชป ์‚ด๊นŒ?

์š”์ฆ˜ AI ๋ถ์˜ ํ•ต์‹ฌ์— GPU๊ฐ€ ์žˆ์–ด. ์™œ ๋”ฅ๋Ÿฌ๋‹์€ GPU๋ฅผ ์ด๋ ‡๊ฒŒ ํ•„์š”๋กœ ํ• ๊นŒ?
๊ทธ ์ด์œ ๋ฅผ ์ˆ˜ํ•™์ ์œผ๋กœ ์ดํ•ดํ•ด๋ณด์ž.

๐Ÿ“ ํ–‰๋ ฌ ์—ฐ์‚ฐ์ด ์ „๋ถ€๋‹ค

๋”ฅ๋Ÿฌ๋‹์˜ ํ•ต์‹ฌ ์—ฐ์‚ฐ์€ ํ–‰๋ ฌ ๊ณฑ์…ˆ(GEMM: General Matrix Multiplication)์ด์•ผ.
์‹ ๊ฒฝ๋ง์˜ ๊ฐ ๋ ˆ์ด์–ด๋Š” ๊ธฐ๋ณธ์ ์œผ๋กœ Y = WยทX + b ํ˜•ํƒœ์˜ ์—ฐ์‚ฐ์ด๊ฑฐ๋“ .
(W: ๊ฐ€์ค‘์น˜ ํ–‰๋ ฌ, X: ์ž…๋ ฅ ํ–‰๋ ฌ, b: ํŽธํ–ฅ ๋ฒกํ„ฐ)

๐Ÿ”ข ์‹ค์ œ ๊ทœ๋ชจ๋ฅผ ๋А๊ปด๋ณด์ž GPT-3 ๋ชจ๋ธ์˜ ๊ฒฝ์šฐ:
- ํŒŒ๋ผ๋ฏธํ„ฐ ์ˆ˜: 1,750์–ต ๊ฐœ
- ํ•™์Šต ๋ฐ์ดํ„ฐ: ์•ฝ 570GB
- ํ•™์Šต์— ํ•„์š”ํ•œ ์—ฐ์‚ฐ: ์•ฝ 3.14 ร— 10ยฒยณ FLOP
- A100 GPU 1๊ฐœ๋กœ ํ•™์Šต ์‹œ: ์•ฝ 355๋…„ ์†Œ์š” (์ด๋ก ์ƒ)
- ์‹ค์ œ๋กœ๋Š” ์ˆ˜์ฒœ ๊ฐœ์˜ GPU๋ฅผ ๋ณ‘๋ ฌ๋กœ ์‚ฌ์šฉํ•ด์„œ ์ˆ˜ ์ฃผ ๋งŒ์— ์™„๋ฃŒ!

๐Ÿ”ฅ ํ…์„œ ์ฝ”์–ด (Tensor Core)์˜ ๋งˆ๋ฒ•

NVIDIA๋Š” ๋”ฅ๋Ÿฌ๋‹ ํ–‰๋ ฌ ์—ฐ์‚ฐ์„ ์œ„ํ•ด ํ…์„œ ์ฝ”์–ด๋ฅผ ๊ฐœ๋ฐœํ–ˆ์–ด.
์ผ๋ฐ˜ CUDA ์ฝ”์–ด๊ฐ€ ํ•œ ๋ฒˆ์— ํ•˜๋‚˜์˜ ๊ณฑ์…ˆ-๋ง์…ˆ์„ ์ฒ˜๋ฆฌํ•œ๋‹ค๋ฉด,
ํ…์„œ ์ฝ”์–ด๋Š” 4ร—4 ํ–‰๋ ฌ ๊ณฑ์…ˆ์„ ํ•œ ์‚ฌ์ดํด์— ์ฒ˜๋ฆฌํ•ด!

GPU ์„ธ๋Œ€ ํ…์„œ ์ฝ”์–ด ์„ธ๋Œ€ FP16 ์„ฑ๋Šฅ ์ฃผ์š” ํŠน์ง•
Volta (V100) 1์„ธ๋Œ€ 125 TFLOPS ํ…์„œ ์ฝ”์–ด ์ตœ์ดˆ ๋„์ž…
Ampere (A100) 3์„ธ๋Œ€ 312 TFLOPS TF32, BF16 ์ง€์›
Hopper (H100) 4์„ธ๋Œ€ 989 TFLOPS FP8, Transformer Engine
Blackwell (B200) 5์„ธ๋Œ€ 4,500 TFLOPS FP4 ์ง€์›, ์ฐจ์„ธ๋Œ€ AI

๐Ÿงฎ PyTorch๋กœ GPU ํ™œ์šฉํ•˜๊ธฐ

์‹ค์ œ๋กœ ๋”ฅ๋Ÿฌ๋‹ ๊ฐœ๋ฐœ์ž๋“ค์ด ๊ฐ€์žฅ ๋งŽ์ด ์“ฐ๋Š” PyTorch์—์„œ GPU๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ๋ณด์ž.

import torch
import torch.nn as nn

# GPU ์‚ฌ์šฉ ๊ฐ€๋Šฅ ์—ฌ๋ถ€ ํ™•์ธ
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f"์‚ฌ์šฉ ์žฅ์น˜: {device}")
print(f"GPU ์ด๋ฆ„: {torch.cuda.get_device_name(0)}")
print(f"GPU ๋ฉ”๋ชจ๋ฆฌ: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")

# ๊ฐ„๋‹จํ•œ ์‹ ๊ฒฝ๋ง ์ •์˜
class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.layers = nn.Sequential(
            nn.Linear(784, 512),
            nn.ReLU(),
            nn.Linear(512, 256),
            nn.ReLU(),
            nn.Linear(256, 10)
        )
    
    def forward(self, x):
        return self.layers(x)

# ๋ชจ๋ธ์„ GPU๋กœ ์ด๋™
model = SimpleNet().to(device)

# ๋ฐ์ดํ„ฐ๋ฅผ GPU๋กœ ์ด๋™
batch_size = 64
x = torch.randn(batch_size, 784).to(device)
y = torch.randint(0, 10, (batch_size,)).to(device)

# ์ˆœ์ „ํŒŒ (GPU์—์„œ ์‹คํ–‰)
optimizer = torch.optim.Adam(model.parameters())
criterion = nn.CrossEntropyLoss()

output = model(x)
loss = criterion(output, y)

# ์—ญ์ „ํŒŒ (GPU์—์„œ ์‹คํ–‰)
optimizer.zero_grad()
loss.backward()
optimizer.step()

print(f"Loss: {loss.item():.4f}")

# GPU ๋ฉ”๋ชจ๋ฆฌ ์‚ฌ์šฉ๋Ÿ‰ ํ™•์ธ
print(f"GPU ๋ฉ”๋ชจ๋ฆฌ ์‚ฌ์šฉ: {torch.cuda.memory_allocated() / 1e6:.1f} MB")

โšก ํ˜ผํ•ฉ ์ •๋ฐ€๋„ ํ•™์Šต (Mixed Precision Training)

์ตœ์‹  ๋”ฅ๋Ÿฌ๋‹ ํ•™์Šต์—์„œ ๋น ์งˆ ์ˆ˜ ์—†๋Š” ๊ธฐ๋ฒ•์ด์•ผ!
FP32(32๋น„ํŠธ ๋ถ€๋™์†Œ์ˆ˜์ ) ๋Œ€์‹  FP16(16๋น„ํŠธ)์„ ์‚ฌ์šฉํ•ด์„œ ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ์ ˆ๋ฐ˜์œผ๋กœ ์ค„์ด๊ณ  ์†๋„๋ฅผ 2๋ฐฐ ๋†’์—ฌ.

from torch.cuda.amp import autocast, GradScaler

scaler = GradScaler()  # ๊ทธ๋ž˜๋””์–ธํŠธ ์Šค์ผ€์ผ๋Ÿฌ

for batch in dataloader:
    x, y = batch
    x, y = x.to(device), y.to(device)
    
    optimizer.zero_grad()
    
    # ์ž๋™ ํ˜ผํ•ฉ ์ •๋ฐ€๋„ ์ปจํ…์ŠคํŠธ
    with autocast():
        output = model(x)
        loss = criterion(output, y)
    
    # ์Šค์ผ€์ผ๋œ ์—ญ์ „ํŒŒ
    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()
๐Ÿ’ก ํ˜ผํ•ฉ ์ •๋ฐ€๋„์˜ ํšจ๊ณผ ๋ฉ”๋ชจ๋ฆฌ ์‚ฌ์šฉ๋Ÿ‰: ์•ฝ 50% ๊ฐ์†Œ (FP32 โ†’ FP16)
ํ•™์Šต ์†๋„: 2~3๋ฐฐ ํ–ฅ์ƒ (ํ…์„œ ์ฝ”์–ด ์ตœ๋Œ€ ํ™œ์šฉ)
์ •ํ™•๋„: FP32์™€ ๊ฑฐ์˜ ๋™์ผ (GradScaler๋กœ ์ˆ˜์น˜ ์•ˆ์ •์„ฑ ๋ณด์žฅ)
A100 ๊ธฐ์ค€ FP16 ํ…์„œ ์ฝ”์–ด ์„ฑ๋Šฅ: 312 TFLOPS (FP32์˜ 10๋ฐฐ!)

๐ŸŒ 7. ๋ถ„์‚ฐ GPU ์ปดํ“จํŒ… โ€” GPU ์—ฌ๋Ÿฌ ๊ฐœ๋ฅผ ํ•จ๊ป˜ ์“ฐ๋Š” ๋ฒ•

GPU 1๊ฐœ๋กœ ๋ถ€์กฑํ•˜๋‹ค๋ฉด? ์—ฌ๋Ÿฌ ๊ฐœ๋ฅผ ๋™์‹œ์— ์จ์•ผ์ง€! ๐Ÿš€
๋Œ€๊ทœ๋ชจ AI ๋ชจ๋ธ ํ•™์Šต์—์„œ๋Š” ์ˆ˜๋ฐฑ~์ˆ˜์ฒœ ๊ฐœ์˜ GPU๋ฅผ ๋™์‹œ์— ํ™œ์šฉํ•ด.

๐Ÿ”— ๋ฐ์ดํ„ฐ ๋ณ‘๋ ฌ ํ•™์Šต (Data Parallel Training)

๊ฐ€์žฅ ๊ธฐ๋ณธ์ ์ธ ๋ถ„์‚ฐ ํ•™์Šต ๋ฐฉ๋ฒ•์ด์•ผ.
๊ฐ™์€ ๋ชจ๋ธ์„ ์—ฌ๋Ÿฌ GPU์— ๋ณต์‚ฌํ•˜๊ณ , ๋ฐ์ดํ„ฐ๋ฅผ ๋‚˜๋ˆ ์„œ ๊ฐ GPU๊ฐ€ ์ฒ˜๋ฆฌํ•ด.
๊ทธ ํ›„ ๊ทธ๋ž˜๋””์–ธํŠธ๋ฅผ ํ•ฉ์‚ฐ(All-Reduce)ํ•ด์„œ ๋ชจ๋ธ์„ ์—…๋ฐ์ดํŠธํ•ด.

import torch
import torch.nn as nn
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP

# ๋ถ„์‚ฐ ํ•™์Šต ์ดˆ๊ธฐํ™”
dist.init_process_group(backend='nccl')  # NCCL: GPU ๊ฐ„ ํ†ต์‹  ์ตœ์ ํ™” ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ
local_rank = dist.get_rank()
torch.cuda.set_device(local_rank)

# ๋ชจ๋ธ์„ ํ˜„์žฌ GPU์— ๋ฐฐ์น˜
model = SimpleNet().to(local_rank)

# DDP๋กœ ๋ž˜ํ•‘ (์ž๋™์œผ๋กœ ๊ทธ๋ž˜๋””์–ธํŠธ ๋™๊ธฐํ™”)
model = DDP(model, device_ids=[local_rank])

# ์ดํ›„ ํ•™์Šต ์ฝ”๋“œ๋Š” ๋‹จ์ผ GPU์™€ ๋™์ผ!

๐Ÿงฉ ๋ชจ๋ธ ๋ณ‘๋ ฌ ํ•™์Šต (Model Parallel Training)

๋ชจ๋ธ์ด ๋„ˆ๋ฌด ์ปค์„œ GPU 1๊ฐœ์— ์•ˆ ๋“ค์–ด๊ฐˆ ๋•Œ ์‚ฌ์šฉํ•ด.
๋ชจ๋ธ์˜ ๊ฐ ๋ ˆ์ด์–ด๋ฅผ ์„œ๋กœ ๋‹ค๋ฅธ GPU์— ๋ฐฐ์น˜ํ•˜๋Š” ๋ฐฉ์‹์ด์•ผ.

๐Ÿ”€ ํŒŒ์ดํ”„๋ผ์ธ ๋ณ‘๋ ฌ์„ฑ (Pipeline Parallelism) ๋ชจ๋ธ์„ ์—ฌ๋Ÿฌ ๋‹จ๊ณ„(Stage)๋กœ ๋‚˜๋ˆ ์„œ ๊ฐ GPU์— ๋ฐฐ์น˜ํ•ด.
๋งˆ์น˜ ๊ณต์žฅ ์กฐ๋ฆฝ ๋ผ์ธ์ฒ˜๋Ÿผ, ๊ฐ GPU๊ฐ€ ์ž์‹ ์˜ ๋‹จ๊ณ„๋ฅผ ์ฒ˜๋ฆฌํ•˜๊ณ  ๋‹ค์Œ GPU๋กœ ๋„˜๊ฒจ์ค˜.

๋งˆ์ดํฌ๋กœ ๋ฐฐ์น˜(Micro-batch)๋ฅผ ์‚ฌ์šฉํ•ด์„œ GPU๊ฐ€ ๋†€์ง€ ์•Š๋„๋ก ์ตœ์ ํ™”ํ•ด.
GPT-3 ํ•™์Šต์—์„œ๋Š” ์ด ๋ฐฉ์‹์œผ๋กœ ์ˆ˜์ฒœ ๊ฐœ์˜ GPU๋ฅผ ํšจ์œจ์ ์œผ๋กœ ํ™œ์šฉํ–ˆ์–ด.

๐Ÿ“ก GPU ๊ฐ„ ํ†ต์‹  ๊ธฐ์ˆ 

๊ธฐ์ˆ  ์„ค๋ช… ๋Œ€์—ญํญ
NVLink NVIDIA GPU ๊ฐ„ ๊ณ ์† ์ง์ ‘ ์—ฐ๊ฒฐ H100 ๊ธฐ์ค€ 900 GB/s
NVSwitch ์—ฌ๋Ÿฌ GPU๋ฅผ All-to-All๋กœ ์—ฐ๊ฒฐํ•˜๋Š” ์Šค์œ„์น˜ ์„œ๋ฒ„ ๋‚ด GPU ์™„์ „ ์—ฐ๊ฒฐ
InfiniBand ์„œ๋ฒ„ ๊ฐ„ ๊ณ ์† ๋„คํŠธ์›Œํฌ 400 Gb/s (HDR200)
PCIe ์ผ๋ฐ˜ ์„œ๋ฒ„์˜ GPU ์—ฐ๊ฒฐ ๋ฐฉ์‹ PCIe 5.0 ๊ธฐ์ค€ 128 GB/s
NCCL NVIDIA ์ง‘ํ•ฉ ํ†ต์‹  ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ์†Œํ”„ํŠธ์›จ์–ด ์ตœ์ ํ™” ๋ ˆ์ด์–ด

๐Ÿญ ๋Œ€๊ทœ๋ชจ AI ํด๋Ÿฌ์Šคํ„ฐ์˜ ์‹ค์ œ ๊ตฌ์„ฑ

์˜ˆ์‹œ: NVIDIA DGX H100 ์„œ๋ฒ„ 1๋Œ€ GPU: H100 SXM5 ร— 8๊ฐœ
GPU ๋ฉ”๋ชจ๋ฆฌ: 80GB ร— 8 = 640GB
GPU ๊ฐ„ ์—ฐ๊ฒฐ: NVLink 4.0 (900 GB/s)
CPU: Intel Xeon ร— 2๊ฐœ
์‹œ์Šคํ…œ ๋ฉ”๋ชจ๋ฆฌ: 2TB
๋„คํŠธ์›Œํฌ: InfiniBand 400Gb/s ร— 8ํฌํŠธ
๊ฐ€๊ฒฉ: ์•ฝ 30๋งŒ ๋‹ฌ๋Ÿฌ (์•ฝ 4์–ต ์›) ๐Ÿ’ธ

OpenAI, Google, Meta ๊ฐ™์€ ํšŒ์‚ฌ๋“ค์€ ์ด๋Ÿฐ ์„œ๋ฒ„๋ฅผ ์ˆ˜์ฒœ ๋Œ€์”ฉ ์—ฐ๊ฒฐํ•ด์„œ AI๋ฅผ ํ•™์Šต์‹œ์ผœ.
GPT-4 ํ•™์Šต์—๋Š” ์•ฝ 25,000๊ฐœ์˜ A100 GPU๊ฐ€ ์‚ฌ์šฉ๋๋‹ค๊ณ  ์•Œ๋ ค์ ธ ์žˆ์–ด.

๋ฐ์ดํ„ฐ ๋ณ‘๋ ฌ ๋ถ„์‚ฐ ํ•™์Šต ๊ตฌ์กฐ ์ „์ฒด ํ•™์Šต ๋ฐ์ดํ„ฐ์…‹ ๋ฏธ๋‹ˆ๋ฐฐ์น˜๋กœ ๋ถ„ํ•  GPU 0 ๋ชจ๋ธ ๋ณต์‚ฌ๋ณธ ๋ฐฐ์น˜ 1/4 ์ฒ˜๋ฆฌ ๊ทธ๋ž˜๋””์–ธํŠธ ๊ณ„์‚ฐ GPU 1 ๋ชจ๋ธ ๋ณต์‚ฌ๋ณธ ๋ฐฐ์น˜ 2/4 ์ฒ˜๋ฆฌ ๊ทธ๋ž˜๋””์–ธํŠธ ๊ณ„์‚ฐ GPU 2 ๋ชจ๋ธ ๋ณต์‚ฌ๋ณธ ๋ฐฐ์น˜ 3/4 ์ฒ˜๋ฆฌ ๊ทธ๋ž˜๋””์–ธํŠธ ๊ณ„์‚ฐ GPU 3 ๋ชจ๋ธ ๋ณต์‚ฌ๋ณธ ๋ฐฐ์น˜ 4/4 ์ฒ˜๋ฆฌ ๊ทธ๋ž˜๋””์–ธํŠธ ๊ณ„์‚ฐ All-Reduce (๊ทธ๋ž˜๋””์–ธํŠธ ํ•ฉ์‚ฐ ๋ฐ ํ‰๊ท ) NCCL / NVLink๋ฅผ ํ†ตํ•ด ๋ชจ๋“  GPU์˜ ๊ทธ๋ž˜๋””์–ธํŠธ๋ฅผ ๋™๊ธฐํ™” ๋ชจ๋ธ ํŒŒ๋ผ๋ฏธํ„ฐ ์—…๋ฐ์ดํŠธ ๋ชจ๋“  GPU์˜ ๋ชจ๋ธ์ด ๋™์ผํ•˜๊ฒŒ ๊ฐฑ์‹ ๋จ ๐Ÿ’ก 4๊ฐœ์˜ GPU๊ฐ€ ๋™์‹œ์— ์ฒ˜๋ฆฌ โ†’ ์ด๋ก ์ƒ 4๋ฐฐ ๋น ๋ฅธ ํ•™์Šต!

โš™๏ธ 8. GPU ์„ฑ๋Šฅ ์ตœ์ ํ™” ํ•ต์‹ฌ ๊ธฐ๋ฒ•๋“ค

GPU๋ฅผ ๊ทธ๋ƒฅ ์“ฐ๋Š” ๊ฒƒ๊ณผ ์ž˜ ์“ฐ๋Š” ๊ฒƒ์€ ์ฒœ์ง€ ์ฐจ์ด์•ผ.
๊ฐ™์€ GPU๋ผ๋„ ์ตœ์ ํ™” ์—ฌ๋ถ€์— ๋”ฐ๋ผ ์„ฑ๋Šฅ์ด 10๋ฐฐ ์ด์ƒ ์ฐจ์ด๋‚  ์ˆ˜ ์žˆ์–ด!
ํ•ต์‹ฌ ์ตœ์ ํ™” ๊ธฐ๋ฒ•๋“ค์„ ์•Œ์•„๋ณด์ž. ๐Ÿ”ง

๐ŸŽฏ ์ปค๋„ ํ“จ์ „ (Kernel Fusion)

์—ฌ๋Ÿฌ ๊ฐœ์˜ GPU ์ปค๋„์„ ํ•˜๋‚˜๋กœ ํ•ฉ์น˜๋Š” ๊ธฐ๋ฒ•์ด์•ผ.
์ปค๋„์„ ์‹คํ–‰ํ•  ๋•Œ๋งˆ๋‹ค ๋ฉ”๋ชจ๋ฆฌ ์ฝ๊ธฐ/์“ฐ๊ธฐ๊ฐ€ ๋ฐœ์ƒํ•˜๋Š”๋ฐ, ์ด๋ฅผ ์ค„์ด๋ฉด ์„ฑ๋Šฅ์ด ํฌ๊ฒŒ ํ–ฅ์ƒ๋ผ.

์˜ˆ: ReLU + BatchNorm + Dropout์„ ๊ฐ๊ฐ ์‹คํ–‰ํ•˜๋Š” ๋Œ€์‹  ํ•˜๋‚˜์˜ ์ปค๋„๋กœ ํ•ฉ์น˜๋ฉด
๋ฉ”๋ชจ๋ฆฌ ์ ‘๊ทผ ํšŸ์ˆ˜๊ฐ€ 3๋ถ„์˜ 1๋กœ ์ค„์–ด๋“ค์–ด!

Flash Attention์ด ๋Œ€ํ‘œ์ ์ธ ์ปค๋„ ํ“จ์ „ ์‚ฌ๋ก€์•ผ.
Transformer์˜ Attention ์—ฐ์‚ฐ์„ ์ตœ์ ํ™”ํ•ด์„œ ๋ฉ”๋ชจ๋ฆฌ ์‚ฌ์šฉ๋Ÿ‰์„ O(nยฒ)์—์„œ O(n)์œผ๋กœ ์ค„์˜€์–ด.

๐Ÿ“ฆ ๋ฐฐ์น˜ ํฌ๊ธฐ ์ตœ์ ํ™”

GPU๋Š” ํฐ ๋ฐฐ์น˜๋ฅผ ์ฒ˜๋ฆฌํ•  ๋•Œ ํšจ์œจ์ด ๋†’์•„์ ธ.
์ž‘์€ ๋ฐฐ์น˜๋Š” GPU ์ฝ”์–ด๋ฅผ ์ถฉ๋ถ„ํžˆ ํ™œ์šฉํ•˜์ง€ ๋ชปํ•ด์„œ ๋‚ญ๋น„๊ฐ€ ๋ฐœ์ƒํ•ด.

ํ•˜์ง€๋งŒ ๋„ˆ๋ฌด ํฐ ๋ฐฐ์น˜๋Š” ๋ฉ”๋ชจ๋ฆฌ ๋ถ€์กฑ(OOM: Out of Memory)์„ ์ผ์œผํ‚ฌ ์ˆ˜ ์žˆ์–ด.
๊ทธ๋ž˜๋””์–ธํŠธ ๋ˆ„์ (Gradient Accumulation)์„ ์‚ฌ์šฉํ•˜๋ฉด ์‹ค์ œ ๋ฐฐ์น˜ ํฌ๊ธฐ๋Š” ์ž‘๊ฒŒ ์œ ์ง€ํ•˜๋ฉด์„œ
ํฐ ๋ฐฐ์น˜ ํšจ๊ณผ๋ฅผ ๋‚ผ ์ˆ˜ ์žˆ์–ด.

๐Ÿ”„ ๋น„๋™๊ธฐ ์‹คํ–‰ (Asynchronous Execution)

CPU์™€ GPU๊ฐ€ ๋™์‹œ์— ์ž‘์—…ํ•˜๋„๋ก ํŒŒ์ดํ”„๋ผ์ด๋‹ํ•˜๋Š” ๊ธฐ๋ฒ•์ด์•ผ.

GPU๊ฐ€ ํ˜„์žฌ ๋ฐฐ์น˜๋ฅผ ์ฒ˜๋ฆฌํ•˜๋Š” ๋™์•ˆ, CPU๋Š” ๋‹ค์Œ ๋ฐฐ์น˜๋ฅผ ์ค€๋น„ํ•ด.
๋ฐ์ดํ„ฐ ๋กœ๋”ฉ๊ณผ GPU ์—ฐ์‚ฐ์„ ๊ฒน์ณ์„œ ์‹คํ–‰ํ•˜๋ฉด GPU๊ฐ€ ๋†€์ง€ ์•Š์•„!

PyTorch์˜ DataLoader(num_workers=N, pin_memory=True) ์„ค์ •์ด ์ด๋ฅผ ๊ตฌํ˜„ํ•ด์ค˜.

๐Ÿงฎ ์–‘์žํ™” (Quantization)

๋ชจ๋ธ์˜ ๊ฐ€์ค‘์น˜์™€ ํ™œ์„ฑํ™” ๊ฐ’์„ ๋‚ฎ์€ ๋น„ํŠธ๋กœ ํ‘œํ˜„ํ•˜๋Š” ๊ธฐ๋ฒ•์ด์•ผ.
FP32 โ†’ INT8๋กœ ์–‘์žํ™”ํ•˜๋ฉด ๋ฉ”๋ชจ๋ฆฌ๊ฐ€ 4๋ถ„์˜ 1๋กœ ์ค„๊ณ  ์†๋„๊ฐ€ ํฌ๊ฒŒ ํ–ฅ์ƒ๋ผ.

์ •๋ฐ€๋„ ๋น„ํŠธ ์ˆ˜ ๋ฉ”๋ชจ๋ฆฌ ์†๋„ ์ •ํ™•๋„
FP32 32๋น„ํŠธ ๊ธฐ์ค€ (1x) ๊ธฐ์ค€ (1x) ์ตœ๊ณ 
BF16/FP16 16๋น„ํŠธ 0.5x 2~3x ๊ฑฐ์˜ ๋™์ผ
INT8 8๋น„ํŠธ 0.25x 4x ์•ฝ๊ฐ„ ์†์‹ค
INT4 4๋น„ํŠธ 0.125x 8x ์†์‹ค ์žˆ์Œ
FP8 8๋น„ํŠธ 0.25x 4x INT8๋ณด๋‹ค ์šฐ์ˆ˜

๐Ÿ” ํ”„๋กœํŒŒ์ผ๋ง โ€” ๋ณ‘๋ชฉ ์ฐพ๊ธฐ

์ตœ์ ํ™”์˜ ์ฒซ ๋ฒˆ์งธ ๋‹จ๊ณ„๋Š” ์–ด๋””๊ฐ€ ๋А๋ฆฐ์ง€ ์ฐพ๋Š” ๊ฒƒ์ด์•ผ.
NVIDIA๋Š” ๋‹ค์–‘ํ•œ ํ”„๋กœํŒŒ์ผ๋ง ๋„๊ตฌ๋ฅผ ์ œ๊ณตํ•ด:

# PyTorch ํ”„๋กœํŒŒ์ผ๋Ÿฌ ์‚ฌ์šฉ
import torch
from torch.profiler import profile, record_function, ProfilerActivity

with profile(
    activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA],
    record_shapes=True,
    profile_memory=True,
    with_stack=True
) as prof:
    with record_function("model_inference"):
        output = model(input_data)

# ๊ฒฐ๊ณผ ์ถœ๋ ฅ (์ƒ์œ„ 10๊ฐœ ์—ฐ์‚ฐ)
print(prof.key_averages().table(
    sort_by="cuda_time_total", 
    row_limit=10
))
๐Ÿ› ๏ธ ์ฃผ์š” GPU ํ”„๋กœํŒŒ์ผ๋ง ๋„๊ตฌ NVIDIA Nsight Systems: ์ „์ฒด ์‹œ์Šคํ…œ ํƒ€์ž„๋ผ์ธ ๋ถ„์„
NVIDIA Nsight Compute: ์ปค๋„ ์ˆ˜์ค€ ์ƒ์„ธ ๋ถ„์„
PyTorch Profiler: Python ๋ ˆ๋ฒจ ํ”„๋กœํŒŒ์ผ๋ง
nvtop: ์‹ค์‹œ๊ฐ„ GPU ์‚ฌ์šฉ๋ฅ  ๋ชจ๋‹ˆํ„ฐ๋ง
nvidia-smi: GPU ์ƒํƒœ ๋ฐ ๋ฉ”๋ชจ๋ฆฌ ํ™•์ธ

๐ŸŒ 9. GPU ์ปดํ“จํŒ…์˜ ์‹ค์ œ ์‘์šฉ ๋ถ„์•ผ

GPU ์ปดํ“จํŒ…์€ ์ด์ œ ์šฐ๋ฆฌ ์ผ์ƒ ๊ณณ๊ณณ์— ์Šค๋ฉฐ๋“ค์–ด ์žˆ์–ด.
์–ด๋–ค ๋ถ„์•ผ์—์„œ ์–ด๋–ป๊ฒŒ ํ™œ์šฉ๋˜๋Š”์ง€ ์‚ดํŽด๋ณด์ž! ๐Ÿ”ญ

๐Ÿค– ์ธ๊ณต์ง€๋Šฅ / ๋จธ์‹ ๋Ÿฌ๋‹

๊ฐ€์žฅ ๋Œ€ํ‘œ์ ์ธ GPU ํ™œ์šฉ ๋ถ„์•ผ์•ผ.
๋Œ€ํ˜• ์–ธ์–ด ๋ชจ๋ธ(LLM) ํ•™์Šต: GPT-4, Claude, Gemini ๋“ฑ
์ด๋ฏธ์ง€ ์ƒ์„ฑ AI: Stable Diffusion, DALL-E, Midjourney
์Œ์„ฑ ์ธ์‹: Whisper, ์‹ค์‹œ๊ฐ„ ๋ฒˆ์—ญ ์‹œ์Šคํ…œ
์ถ”์ฒœ ์‹œ์Šคํ…œ: ๋„ทํ”Œ๋ฆญ์Šค, ์œ ํŠœ๋ธŒ์˜ ์ฝ˜ํ…์ธ  ์ถ”์ฒœ
์ž์œจ์ฃผํ–‰: Tesla FSD, Waymo์˜ ์‹ค์‹œ๊ฐ„ ์ธ์‹ ์‹œ์Šคํ…œ

๐Ÿ”ฌ ๊ณผํ•™ ์‹œ๋ฎฌ๋ ˆ์ด์…˜

๋ถ„์ž ๋™์—ญํ•™ ์‹œ๋ฎฌ๋ ˆ์ด์…˜: ์‹ ์•ฝ ๊ฐœ๋ฐœ, ๋‹จ๋ฐฑ์งˆ ํด๋”ฉ ์—ฐ๊ตฌ
AlphaFold2๋Š” GPU๋ฅผ ํ™œ์šฉํ•ด ์ˆ˜์‹ญ ๋…„ ๊ฑธ๋ฆฌ๋˜ ๋‹จ๋ฐฑ์งˆ ๊ตฌ์กฐ ์˜ˆ์ธก์„ ๋ช‡ ์‹œ๊ฐ„์œผ๋กœ ๋‹จ์ถ•ํ–ˆ์–ด!

๊ธฐํ›„ ๋ชจ๋ธ๋ง: ์ง€๊ตฌ ๊ธฐํ›„ ๋ณ€ํ™” ์‹œ๋ฎฌ๋ ˆ์ด์…˜
์œ ์ฒด ์—ญํ•™(CFD): ํ•ญ๊ณต๊ธฐ ์„ค๊ณ„, ์ž๋™์ฐจ ๊ณต๊ธฐ์—ญํ•™
ํ•ต์œตํ•ฉ ์—ฐ๊ตฌ: ํ”Œ๋ผ์ฆˆ๋งˆ ์‹œ๋ฎฌ๋ ˆ์ด์…˜
์ฒœ์ฒด๋ฌผ๋ฆฌํ•™: ์€ํ•˜ ์ถฉ๋Œ, ๋ธ”๋ž™ํ™€ ์‹œ๋ฎฌ๋ ˆ์ด์…˜

๐Ÿ’ฐ ๊ธˆ์œต / ์•”ํ˜ธํ™”ํ

๊ณ ๋นˆ๋„ ๊ฑฐ๋ž˜(HFT): ์ดˆ๊ณ ์† ๊ธˆ์œต ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ
๋ฆฌ์Šคํฌ ๋ถ„์„: ๋ชฌํ…Œ์นด๋ฅผ๋กœ ์‹œ๋ฎฌ๋ ˆ์ด์…˜์œผ๋กœ ์ˆ˜๋ฐฑ๋งŒ ๊ฐœ์˜ ์‹œ๋‚˜๋ฆฌ์˜ค ๋™์‹œ ๊ณ„์‚ฐ
์•”ํ˜ธํ™”ํ ์ฑ„๊ตด: SHA-256 ํ•ด์‹œ ์—ฐ์‚ฐ์˜ ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ
์˜ต์…˜ ๊ฐ€๊ฒฉ ์‚ฐ์ •: ๋ธ”๋ž™-์ˆ„์ฆˆ ๋ชจ๋ธ์˜ ๋Œ€๊ทœ๋ชจ ๊ณ„์‚ฐ

๐ŸŽฎ ๊ฒŒ์ž„ / ๋ฏธ๋””์–ด

์‹ค์‹œ๊ฐ„ ๋ ˆ์ด ํŠธ๋ ˆ์ด์‹ฑ: NVIDIA RTX์˜ ๊ด‘์„  ์ถ”์  ๊ธฐ์ˆ 
DLSS (Deep Learning Super Sampling): AI๋กœ ์ €ํ•ด์ƒ๋„ ์ด๋ฏธ์ง€๋ฅผ ๊ณ ํ•ด์ƒ๋„๋กœ ์—…์Šค์ผ€์ผ
์˜์ƒ ๋ Œ๋”๋ง: ํ”ฝ์‚ฌ, ๋“œ๋ฆผ์›์Šค์˜ 3D ์• ๋‹ˆ๋ฉ”์ด์…˜ ๋ Œ๋”๋ง
VR/AR: ์ดˆ์ €์ง€์—ฐ ๋ Œ๋”๋ง์œผ๋กœ ๋ฉ€๋ฏธ ๋ฐฉ์ง€

๐Ÿฅ ์˜๋ฃŒ / ๋ฐ”์ด์˜ค

์˜๋ฃŒ ์˜์ƒ ๋ถ„์„: CT, MRI ์ด๋ฏธ์ง€์—์„œ ์•” ์กฐ๊ธฐ ๋ฐœ๊ฒฌ
์œ ์ „์ฒด ๋ถ„์„: DNA ์‹œํ€€์‹ฑ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ
๋ฐฉ์‚ฌ์„  ์น˜๋ฃŒ ๊ณ„ํš: ์ตœ์  ๋ฐฉ์‚ฌ์„  ๊ฒฝ๋กœ ์‹ค์‹œ๊ฐ„ ๊ณ„์‚ฐ
์‹ ์•ฝ ๊ฐœ๋ฐœ: ๋ถ„์ž ๋„ํ‚น ์‹œ๋ฎฌ๋ ˆ์ด์…˜์œผ๋กœ ํ›„๋ณด ๋ฌผ์งˆ ์Šคํฌ๋ฆฌ๋‹

์ด๋ ‡๊ฒŒ ๋‹ค์–‘ํ•œ ๋ถ„์•ผ์—์„œ GPU ์ปดํ“จํŒ…์ด ํ™œ์šฉ๋˜๋‹ค ๋ณด๋‹ˆ,
GPU ๊ด€๋ จ ๊ธฐ์ˆ ์„ ๋ฐฐ์šฐ๊ณ  ์‹ถ์€ ์‚ฌ๋žŒ๋“ค๋„ ์ •๋ง ๋งŽ์•„์กŒ์–ด.
์žฌ๋Šฅ๋„ท(https://www.jaenung.net) ๊ฐ™์€ ์žฌ๋Šฅ ๊ณต์œ  ํ”Œ๋žซํผ์—์„œ๋„ CUDA ํ”„๋กœ๊ทธ๋ž˜๋ฐ, GPU ์ตœ์ ํ™”,
๋”ฅ๋Ÿฌ๋‹ ๋ชจ๋ธ ๊ฐœ๋ฐœ ๊ฐ™์€ ์ „๋ฌธ ๊ธฐ์ˆ ์„ ๊ฐ€๋ฅด์ณ์ฃผ๋Š” ํŠœํ„ฐ๋“ค์„ ์ฐพ์„ ์ˆ˜ ์žˆ์–ด.
GPU ์ปดํ“จํŒ… ์‹ค๋ ฅ์„ ์Œ“์œผ๋ฉด ์ •๋ง ๋‹ค์–‘ํ•œ ๋ถ„์•ผ์—์„œ ํ™œ์•ฝํ•  ์ˆ˜ ์žˆ๋‹ค๋Š” ๊ฑฐ ๊ธฐ์–ตํ•ด! ๐Ÿ’ช


๐Ÿ”ฎ 10. GPU ์ปดํ“จํŒ…์˜ ์ตœ์‹  ํŠธ๋ Œ๋“œ์™€ ๋ฏธ๋ž˜

GPU ๊ธฐ์ˆ ์€ ์ •๋ง ๋น ๋ฅด๊ฒŒ ๋ฐœ์ „ํ•˜๊ณ  ์žˆ์–ด. ์ตœ์‹  ํŠธ๋ Œ๋“œ๋ฅผ ์‚ดํŽด๋ณด์ž! ๐Ÿš€

๐Ÿง  AI ์ „์šฉ ์นฉ์˜ ๋“ฑ์žฅ

GPU๊ฐ€ AI์— ๋„ˆ๋ฌด ์ค‘์š”ํ•ด์ง€๋‹ค ๋ณด๋‹ˆ, ์•„์˜ˆ AI ์—ฐ์‚ฐ์— ํŠนํ™”๋œ ์นฉ๋“ค์ด ๋“ฑ์žฅํ•˜๊ณ  ์žˆ์–ด.

Google TPU (Tensor Processing Unit): ํ–‰๋ ฌ ์—ฐ์‚ฐ์— ํŠนํ™”๋œ AI ๊ฐ€์†๊ธฐ. Google Cloud์—์„œ ์‚ฌ์šฉ ๊ฐ€๋Šฅ.
AWS Trainium/Inferentia: Amazon์ด ๊ฐœ๋ฐœํ•œ AI ํ•™์Šต/์ถ”๋ก  ์ „์šฉ ์นฉ.
Apple Neural Engine: iPhone/Mac์— ๋‚ด์žฅ๋œ AI ๊ฐ€์†๊ธฐ.
Cerebras WSE-3: ์›จ์ดํผ ์ „์ฒด๋ฅผ ํ•˜๋‚˜์˜ ์นฉ์œผ๋กœ ๋งŒ๋“  ์ดˆ๋Œ€ํ˜• AI ์นฉ (900,000๊ฐœ ์ฝ”์–ด!)

๐Ÿ’พ HBM (High Bandwidth Memory)์˜ ์ง„ํ™”

AI ๋ชจ๋ธ์ด ์ปค์งˆ์ˆ˜๋ก ๋ฉ”๋ชจ๋ฆฌ ๋Œ€์—ญํญ์ด ๋” ์ค‘์š”ํ•ด์ง€๊ณ  ์žˆ์–ด.

HBM2e: A100์— ์‚ฌ์šฉ, 2TB/s
HBM3: H100์— ์‚ฌ์šฉ, 3.35TB/s
HBM3e: H200์— ์‚ฌ์šฉ, 4.8TB/s
HBM4: ์ฐจ์„ธ๋Œ€, 8TB/s ์ด์ƒ ์˜ˆ์ƒ

๋ฉ”๋ชจ๋ฆฌ ๋Œ€์—ญํญ์ด ๋Š˜์–ด๋‚ ์ˆ˜๋ก ๋” ํฐ ๋ชจ๋ธ์„ ๋” ๋น ๋ฅด๊ฒŒ ์ฒ˜๋ฆฌํ•  ์ˆ˜ ์žˆ์–ด.

๐ŸŒ GPU ํด๋ผ์šฐ๋“œ ์„œ๋น„์Šค

๋น„์‹ผ GPU๋ฅผ ์ง์ ‘ ์‚ฌ์ง€ ์•Š์•„๋„ ํด๋ผ์šฐ๋“œ๋กœ ๋นŒ๋ ค ์“ธ ์ˆ˜ ์žˆ์–ด!
์ด๊ฒŒ AI ๋ฏผ์ฃผํ™”์˜ ํ•ต์‹ฌ์ด์•ผ.

์„œ๋น„์Šค ์ œ๊ณต GPU ํŠน์ง•
AWS EC2 P5 H100 ร— 8 ์—”ํ„ฐํ”„๋ผ์ด์ฆˆ๊ธ‰ ์•ˆ์ •์„ฑ
Google Cloud TPU v5 TPU v5e/p JAX/TensorFlow ์ตœ์ ํ™”
Azure NDv5 H100 ร— 8 Microsoft ์ƒํƒœ๊ณ„ ํ†ตํ•ฉ
Lambda Labs H100, A100 AI ํŠนํ™”, ์ €๋ ดํ•œ ๊ฐ€๊ฒฉ
RunPod ๋‹ค์–‘ํ•œ GPU ๊ฐœ์ธ ๊ฐœ๋ฐœ์ž ์นœํ™”์ 
Google Colab T4, A100 ๋ฌด๋ฃŒ ํ”Œ๋žœ ์ œ๊ณต

๐Ÿ”‹ ์—๋„ˆ์ง€ ํšจ์œจ์„ฑ ๋ฌธ์ œ

โš ๏ธ GPU ์ปดํ“จํŒ…์˜ ๊ทธ๋ฆผ์ž โ€” ์ „๋ ฅ ์†Œ๋น„ H100 GPU 1๊ฐœ์˜ TDP(์—ด์„ค๊ณ„์ „๋ ฅ): 700W
DGX H100 ์„œ๋ฒ„ 1๋Œ€: ์•ฝ 10kW
๋Œ€ํ˜• AI ๋ฐ์ดํ„ฐ์„ผํ„ฐ: ์ˆ˜์‹ญ~์ˆ˜๋ฐฑ MW

ChatGPT 1ํšŒ ์ฟผ๋ฆฌ์˜ ์ „๋ ฅ ์†Œ๋น„: ๊ตฌ๊ธ€ ๊ฒ€์ƒ‰์˜ ์•ฝ 10๋ฐฐ
GPT-3 ํ•™์Šต ํƒ„์†Œ ๋ฐœ์ž๊ตญ: ์ž๋™์ฐจ ์•ฝ 300๋Œ€์˜ ์—ฐ๊ฐ„ ๋ฐฐ์ถœ๋Ÿ‰

์ด ๋•Œ๋ฌธ์— ์—๋„ˆ์ง€ ํšจ์œจ์ ์ธ AI ์•Œ๊ณ ๋ฆฌ์ฆ˜๊ณผ ์žฌ์ƒ์—๋„ˆ์ง€ ๊ธฐ๋ฐ˜ ๋ฐ์ดํ„ฐ์„ผํ„ฐ๊ฐ€ ์ค‘์š”ํ•œ ์ด์Šˆ๊ฐ€ ๋˜๊ณ  ์žˆ์–ด.

๐Ÿš€ NVIDIA Blackwell ์•„ํ‚คํ…์ฒ˜ (2024)

2024๋…„ ๋ฐœํ‘œ๋œ NVIDIA์˜ ์ตœ์‹  GPU ์•„ํ‚คํ…์ฒ˜์•ผ.

B200 GPU: FP4 ํ…์„œ ์ฝ”์–ด, 4.5 PFLOPS AI ์„ฑ๋Šฅ
GB200 NVL72: 72๊ฐœ์˜ B200 GPU๋ฅผ NVLink๋กœ ์—ฐ๊ฒฐํ•œ ์Šˆํผ์ปดํ“จํ„ฐ
NVLink 5.0: GPU ๊ฐ„ 1.8 TB/s ๋Œ€์—ญํญ
Transformer Engine 2.0: FP8 ์ •๋ฐ€๋„๋กœ LLM ์ถ”๋ก  ์ตœ์ ํ™”

์ด์ „ ์„ธ๋Œ€(H100) ๋Œ€๋น„ AI ์„ฑ๋Šฅ์ด ์•ฝ 30๋ฐฐ ํ–ฅ์ƒ๋์–ด!

๐ŸŽ“ 11. GPU ์ปดํ“จํŒ… ์‹œ์ž‘ํ•˜๊ธฐ โ€” ์‹ค์ „ ๊ฐ€์ด๋“œ

์ž, ์ด์ œ ์ง์ ‘ GPU ์ปดํ“จํŒ…์„ ์‹œ์ž‘ํ•ด๋ณด๊ณ  ์‹ถ๋‹ค๋ฉด ์–ด๋–ป๊ฒŒ ํ•ด์•ผ ํ• ๊นŒ?
๋‹จ๊ณ„๋ณ„๋กœ ์•Œ๋ ค์ค„๊ฒŒ! ๐Ÿ—บ๏ธ

๐Ÿ“š ํ•™์Šต ๋กœ๋“œ๋งต

1
๊ธฐ์ดˆ ๋‹ค์ง€๊ธฐ (1~2๊ฐœ์›”)
Python ๊ธฐ์ดˆ, NumPy ๋ฐฐ์—ด ์—ฐ์‚ฐ ์ตํžˆ๊ธฐ
์„ ํ˜•๋Œ€์ˆ˜ ๊ธฐ์ดˆ (ํ–‰๋ ฌ ์—ฐ์‚ฐ, ๋ฒกํ„ฐ ๋‚ด์  ๋“ฑ)
์ปดํ“จํ„ฐ ๊ตฌ์กฐ ๊ธฐ์ดˆ (๋ฉ”๋ชจ๋ฆฌ ๊ณ„์ธต, ์บ์‹œ ๋“ฑ)
2
GPU ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์ž…๋ฌธ (2~3๊ฐœ์›”)
CUDA ๊ธฐ์ดˆ ๊ฐœ๋… ํ•™์Šต (์Šค๋ ˆ๋“œ, ๋ธ”๋ก, ๊ทธ๋ฆฌ๋“œ)
Numba๋กœ Python GPU ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์‹œ์ž‘
PyTorch/TensorFlow๋กœ ๋”ฅ๋Ÿฌ๋‹ ๊ธฐ์ดˆ ์‹ค์Šต
Google Colab ๋ฌด๋ฃŒ GPU ํ™œ์šฉ
3
์ค‘๊ธ‰ ๋‹จ๊ณ„ (3~6๊ฐœ์›”)
CUDA C/C++ ์ง์ ‘ ์ž‘์„ฑ
๋ฉ”๋ชจ๋ฆฌ ์ตœ์ ํ™” ๊ธฐ๋ฒ• ํ•™์Šต
ํ”„๋กœํŒŒ์ผ๋ง ๋„๊ตฌ ํ™œ์šฉ
๋ถ„์‚ฐ ํ•™์Šต ๊ธฐ์ดˆ (DDP, FSDP)
4
๊ณ ๊ธ‰ ๋‹จ๊ณ„ (6๊ฐœ์›” ์ด์ƒ)
์ปค์Šคํ…€ CUDA ์ปค๋„ ์ตœ์ ํ™”
๋Œ€๊ทœ๋ชจ ๋ถ„์‚ฐ ํ•™์Šต ์‹œ์Šคํ…œ ์„ค๊ณ„
์–‘์žํ™”, ์ปค๋„ ํ“จ์ „ ๋“ฑ ๊ณ ๊ธ‰ ์ตœ์ ํ™”
ํŠน์ • ๋„๋ฉ”์ธ(AI, ๊ณผํ•™ ๊ณ„์‚ฐ ๋“ฑ) ์ „๋ฌธํ™”

๐Ÿ”ง ์ถ”์ฒœ ํ•™์Šต ์ž๋ฃŒ

๊ณต์‹ ๋ฌธ์„œ ๋ฐ ๊ฐ•์˜ NVIDIA CUDA ๊ณต์‹ ๋ฌธ์„œ (docs.nvidia.com/cuda)
NVIDIA Deep Learning Institute (DLI) ๋ฌด๋ฃŒ ๊ฐ•์ขŒ
PyTorch ๊ณต์‹ ํŠœํ† ๋ฆฌ์–ผ (pytorch.org/tutorials)
Stanford CS231n (CNN for Visual Recognition)
Andrej Karpathy์˜ YouTube ๊ฐ•์˜ (makemore, nanoGPT)

์ถ”์ฒœ ์ฑ…

"Programming Massively Parallel Processors" - Kirk & Hwu
"CUDA by Example" - Sanders & Kandrot
"Deep Learning" - Goodfellow, Bengio, Courville
๐Ÿ’ก GPU ์ปดํ“จํŒ…์„ ๋ฐฐ์šฐ๋Š” ๊ฐ€์žฅ ์ข‹์€ ๋ฐฉ๋ฒ•์€ ์ง์ ‘ ์ฝ”๋“œ๋ฅผ ์งœ๋ณด๋Š” ๊ฒƒ์ด์•ผ.
Google Colab์—์„œ ๋ฌด๋ฃŒ๋กœ GPU๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์œผ๋‹ˆ, ์˜ค๋Š˜ ๋‹น์žฅ ์‹œ์ž‘ํ•ด๋ด!
์žฌ๋Šฅ๋„ท์—์„œ GPU ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๋ฉ˜ํ† ๋ฅผ ์ฐพ์•„ 1:1๋กœ ๋ฐฐ์šฐ๋Š” ๊ฒƒ๋„ ์ข‹์€ ๋ฐฉ๋ฒ•์ด์•ผ. ๐ŸŽฏ

๐Ÿ’ก GPU ์ปดํ“จํŒ… ์„ฑ๋Šฅ ์ฒดํฌ๋ฆฌ์ŠคํŠธ

โœ… ์ฝ”๋“œ ์ž‘์„ฑ ์‹œ ํ™•์ธํ•  ๊ฒƒ๋“ค โ–ก GPU ๋ฉ”๋ชจ๋ฆฌ ์‚ฌ์šฉ๋Ÿ‰์ด ์ ์ ˆํ•œ๊ฐ€? (nvidia-smi๋กœ ํ™•์ธ)
โ–ก GPU ์‚ฌ์šฉ๋ฅ ์ด 80% ์ด์ƒ์ธ๊ฐ€? (๋‚ฎ์œผ๋ฉด ๋ณ‘๋ชฉ ์กด์žฌ)
โ–ก ๋ฐ์ดํ„ฐ ๋กœ๋”ฉ์ด GPU ์—ฐ์‚ฐ์„ ๊ธฐ๋‹ค๋ฆฌ๊ฒŒ ํ•˜์ง€ ์•Š๋Š”๊ฐ€?
โ–ก ๋ฉ”๋ชจ๋ฆฌ ์ ‘๊ทผ ํŒจํ„ด์ด ํ•ฉ์ณ์ง„(Coalesced) ํ˜•ํƒœ์ธ๊ฐ€?
โ–ก ๋ถˆํ•„์š”ํ•œ CPU-GPU ๋ฐ์ดํ„ฐ ์ „์†ก์ด ์—†๋Š”๊ฐ€?
โ–ก ํ˜ผํ•ฉ ์ •๋ฐ€๋„(FP16/BF16)๋ฅผ ํ™œ์šฉํ•˜๊ณ  ์žˆ๋Š”๊ฐ€?
โ–ก ๋ฐฐ์น˜ ํฌ๊ธฐ๊ฐ€ GPU๋ฅผ ์ถฉ๋ถ„ํžˆ ํ™œ์šฉํ•˜๋Š” ํฌ๊ธฐ์ธ๊ฐ€?
โ–ก ์ปค๋„ ์‹คํ–‰ ์„ค์ •(๋ธ”๋ก/๊ทธ๋ฆฌ๋“œ ํฌ๊ธฐ)์ด ์ตœ์ ํ™”๋˜์–ด ์žˆ๋Š”๊ฐ€?
GPU ์ปดํ“จํŒ… ์ƒํƒœ๊ณ„ ์ „์ฒด ์ง€๋„ GPU ์ปดํ“จํŒ… AI / ๋”ฅ๋Ÿฌ๋‹ PyTorch ยท TensorFlow ยท JAX ๊ณผํ•™ ๊ณ„์‚ฐ CuPy ยท RAPIDS ยท CUDA ๊ทธ๋ž˜ํ”ฝ์Šค OpenGL ยท Vulkan ยท DirectX ๊ธˆ์œต / ์‹œ๋ฎฌ๋ ˆ์ด์…˜ ๋ชฌํ…Œ์นด๋ฅผ๋กœ ยท HFT ์˜๋ฃŒ / ๋ฐ”์ด์˜ค ์˜์ƒ๋ถ„์„ ยท ์‹ ์•ฝ๊ฐœ๋ฐœ ์•”ํ˜ธํ™”ํ ์ฑ„๊ตด ยท ๋ธ”๋ก์ฒด์ธ ์ž์œจ์ฃผํ–‰ ์‹ค์‹œ๊ฐ„ ์ธ์‹ ยท ํŒ๋‹จ ํด๋ผ์šฐ๋“œ ์„œ๋น„์Šค AWS ยท GCP ยท Azure ๐Ÿ’ก GPU ์ปดํ“จํŒ…์€ ํ˜„๋Œ€ ๊ธฐ์ˆ  ๋ฌธ๋ช…์˜ ํ•ต์‹ฌ ์ธํ”„๋ผ!

๐ŸŽฏ ๋งˆ๋ฌด๋ฆฌ โ€” GPU ์ปดํ“จํŒ…, ์ด์ œ ๋‘๋ ต์ง€ ์•Š์ง€?

์ž, ์˜ค๋Š˜ ์ •๋ง ๋งŽ์€ ๋‚ด์šฉ์„ ๋‹ค๋ค˜์–ด! ํ•ต์‹ฌ์„ ์ •๋ฆฌํ•ด๋ณผ๊ฒŒ. ๐Ÿ—‚๏ธ

๐Ÿ“Œ ์˜ค๋Š˜ ๋ฐฐ์šด ๊ฒƒ๋“ค ์š”์•ฝ 1. GPU์˜ ๋ณธ์งˆ: ์ˆ˜์ฒœ ๊ฐœ์˜ ์†Œํ˜• ์ฝ”์–ด๋กœ ๋ณ‘๋ ฌ ์—ฐ์‚ฐ์— ํŠนํ™”๋œ ํ”„๋กœ์„ธ์„œ
2. ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ: ๋ฐ์ดํ„ฐ/์ž‘์—…/ํŒŒ์ดํ”„๋ผ์ธ/๋ชจ๋ธ ๋ณ‘๋ ฌ์„ฑ์˜ 4๊ฐ€์ง€ ์œ ํ˜•
3. ์•”๋‹ฌ์˜ ๋ฒ•์น™: ๋ณ‘๋ ฌํ™”์˜ ํ•œ๊ณ„ โ€” ์ˆœ์ฐจ ์ฒ˜๋ฆฌ ๋ถ€๋ถ„์ด ๋ณ‘๋ชฉ
4. GPU ์•„ํ‚คํ…์ฒ˜: SM โ†’ CUDA ์ฝ”์–ด โ†’ ํ…์„œ ์ฝ”์–ด โ†’ ๋ฉ”๋ชจ๋ฆฌ ๊ณ„์ธต
5. CUDA ํ”„๋กœ๊ทธ๋ž˜๋ฐ: ์ปค๋„, ์Šค๋ ˆ๋“œ, ๋ธ”๋ก, ๊ทธ๋ฆฌ๋“œ์˜ ๊ณ„์ธต ๊ตฌ์กฐ
6. ๋”ฅ๋Ÿฌ๋‹๊ณผ GPU: ํ–‰๋ ฌ ์—ฐ์‚ฐ, ํ…์„œ ์ฝ”์–ด, ํ˜ผํ•ฉ ์ •๋ฐ€๋„ ํ•™์Šต
7. ๋ถ„์‚ฐ GPU: ๋ฐ์ดํ„ฐ ๋ณ‘๋ ฌ, ๋ชจ๋ธ ๋ณ‘๋ ฌ, NVLink, NCCL
8. ์ตœ์ ํ™” ๊ธฐ๋ฒ•: ์ปค๋„ ํ“จ์ „, ๋ฉ”๋ชจ๋ฆฌ ์ตœ์ ํ™”, ์–‘์žํ™”, ํ”„๋กœํŒŒ์ผ๋ง
9. ์‘์šฉ ๋ถ„์•ผ: AI, ๊ณผํ•™ ๊ณ„์‚ฐ, ๊ธˆ์œต, ๊ฒŒ์ž„, ์˜๋ฃŒ ๋“ฑ ์ „ ๋ถ„์•ผ
10. ๋ฏธ๋ž˜ ํŠธ๋ Œ๋“œ: AI ์ „์šฉ ์นฉ, HBM ์ง„ํ™”, ์—๋„ˆ์ง€ ํšจ์œจ์„ฑ

GPU ์ปดํ“จํŒ…์€ ๋‹จ์ˆœํžˆ "๋น ๋ฅธ ๊ทธ๋ž˜ํ”ฝ์นด๋“œ"๊ฐ€ ์•„๋‹ˆ์•ผ.
ํ˜„๋Œ€ AI ํ˜๋ช…์˜ ๋ฌผ๋ฆฌ์  ๊ธฐ๋ฐ˜์ด๊ณ , ๊ณผํ•™ ์—ฐ๊ตฌ์˜ ๊ฐ€์†๊ธฐ์ด๋ฉฐ, ๋ฏธ๋ž˜ ๊ธฐ์ˆ ์˜ ํ•ต์‹ฌ ์ธํ”„๋ผ์•ผ.

์ฒ˜์Œ์—” ๋ณต์žกํ•ด ๋ณด์ด์ง€๋งŒ, ํ•˜๋‚˜์”ฉ ๋ฐฐ์›Œ๋‚˜๊ฐ€๋‹ค ๋ณด๋ฉด ์–ด๋А์ƒˆ GPU๋ฅผ ์ž์œ ์ž์žฌ๋กœ ๋‹ค๋ฃจ๋Š” ์ž์‹ ์„ ๋ฐœ๊ฒฌํ•˜๊ฒŒ ๋  ๊ฑฐ์•ผ.
์ค‘์š”ํ•œ ๊ฑด ์ง์ ‘ ์ฝ”๋“œ๋ฅผ ์งœ๋ณด๋Š” ๊ฒƒ! Google Colab์—์„œ ์˜ค๋Š˜ ๋‹น์žฅ ์‹œ์ž‘ํ•ด๋ด. ๐Ÿš€

"The best way to learn GPU computing is to write code, profile it, optimize it, and repeat."
GPU ์ปดํ“จํŒ…์„ ๋ฐฐ์šฐ๋Š” ์ตœ๊ณ ์˜ ๋ฐฉ๋ฒ•์€ ์ฝ”๋“œ๋ฅผ ์งœ๊ณ , ํ”„๋กœํŒŒ์ผ๋งํ•˜๊ณ , ์ตœ์ ํ™”ํ•˜๊ณ , ๋ฐ˜๋ณตํ•˜๋Š” ๊ฒƒ์ด๋‹ค.

์•ž์œผ๋กœ AI๊ฐ€ ๋”์šฑ ๋ฐœ์ „ํ• ์ˆ˜๋ก GPU ์ปดํ“จํŒ…์˜ ์ค‘์š”์„ฑ์€ ๋” ์ปค์งˆ ๊ฑฐ์•ผ.
์ง€๊ธˆ ์ด ๊ธฐ์ˆ ์„ ๋ฐฐ์šฐ๋Š” ๊ฑด ๋ฏธ๋ž˜๋ฅผ ์œ„ํ•œ ์ตœ๊ณ ์˜ ํˆฌ์ž์•ผ. ํ™”์ดํŒ…! ๐Ÿ’ช

๋Œ“๊ธ€ ์ž‘์„ฑ

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

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

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