์ฝ˜ํ…์ธ  ๋Œ€ํ‘œ ์ด๋ฏธ์ง€ - ๐Ÿง  ์‹ ๊ฒฝ๋ง์œผ๋กœ ๋ฏธ๋ถ„๋ฐฉ์ •์‹ ํ’€๊ธฐ: ์ˆ˜ํ•™๊ณผ AI์˜ ํ™˜์ƒ์ ์ธ ๋งŒ๋‚จ

๐Ÿง  ์‹ ๊ฒฝ๋ง์œผ๋กœ ๋ฏธ๋ถ„๋ฐฉ์ •์‹ ํ’€๊ธฐ: ์ˆ˜ํ•™๊ณผ AI์˜ ํ™˜์ƒ์ ์ธ ๋งŒ๋‚จ

๋ณต์žกํ•œ ์ˆ˜์‹๋„ ์‹ ๊ฒฝ๋ง์ด ์ฒ™์ฒ™! ์ „ํ†ต์  ์ˆ˜์น˜ํ•ด์„์˜ ์ƒˆ๋กœ์šด ํŒจ๋Ÿฌ๋‹ค์ž„

์•ˆ๋…•! ์˜ค๋Š˜์€ ์ •๋ง ํฅ๋ฏธ์ง„์ง„ํ•œ ์ฃผ์ œ๋ฅผ ๊ฐ€์ง€๊ณ  ์™”์–ด. ๐Ÿ˜Š ๋ฐ”๋กœ ์‹ ๊ฒฝ๋ง์„ ์ด์šฉํ•œ ๋ฏธ๋ถ„๋ฐฉ์ •์‹ ํ•ด๋ฒ•์ด์•ผ. "์–ด? ์‹ ๊ฒฝ๋ง์ด๋ž‘ ๋ฏธ๋ถ„๋ฐฉ์ •์‹์ด ๋ฌด์Šจ ์ƒ๊ด€์ด์ง€?"๋ผ๊ณ  ์ƒ๊ฐํ•  ์ˆ˜๋„ ์žˆ๋Š”๋ฐ, ์ด ๋‘˜์˜ ์กฐํ•ฉ์€ ํ˜„๋Œ€ ๊ณผํ•™๊ณ„์‚ฐ ๋ถ„์•ผ์—์„œ ์ •๋ง ํ˜์‹ ์ ์ธ ๋ณ€ํ™”๋ฅผ ์ผ์œผํ‚ค๊ณ  ์žˆ์–ด.

์ „ํ†ต์ ์œผ๋กœ ๋ฏธ๋ถ„๋ฐฉ์ •์‹์„ ํ’€ ๋•Œ๋Š” ์œ ํ•œ์ฐจ๋ถ„๋ฒ•(Finite Difference Method), ์œ ํ•œ์š”์†Œ๋ฒ•(Finite Element Method) ๊ฐ™์€ ์ˆ˜์น˜ํ•ด์„ ๊ธฐ๋ฒ•์„ ์‚ฌ์šฉํ–ˆ์–ด. ํ•˜์ง€๋งŒ ์ด๋Ÿฐ ๋ฐฉ๋ฒ•๋“ค์€ ๋ณต์žกํ•œ ๊ฒฝ๊ณ„์กฐ๊ฑด์ด๋‚˜ ๊ณ ์ฐจ์› ๋ฌธ์ œ์—์„œ ๊ณ„์‚ฐ๋Ÿ‰์ด ํญ๋ฐœ์ ์œผ๋กœ ์ฆ๊ฐ€ํ•˜๋Š” ๋ฌธ์ œ๊ฐ€ ์žˆ์—ˆ์ง€. ๐Ÿ”ฅ

๊ทธ๋Ÿฐ๋ฐ ์ตœ๊ทผ ๋”ฅ๋Ÿฌ๋‹ ๊ธฐ์ˆ ์ด ๋ฐœ์ „ํ•˜๋ฉด์„œ, ์‹ ๊ฒฝ๋ง์„ ์ด์šฉํ•ด ๋ฏธ๋ถ„๋ฐฉ์ •์‹์„ ํ‘ธ๋Š” ์™„์ „ํžˆ ์ƒˆ๋กœ์šด ์ ‘๊ทผ๋ฒ•์ด ๋“ฑ์žฅํ–ˆ์–ด. ์ด ๋ฐฉ๋ฒ•์€ Physics-Informed Neural Networks(PINNs)๋ผ๊ณ  ๋ถˆ๋ฆฌ๋ฉฐ, ๋ฌผ๋ฆฌ ๋ฒ•์น™์„ ์‹ ๊ฒฝ๋ง ํ•™์Šต์— ์ง์ ‘ ๋ฐ˜์˜ํ•˜๋Š” ํ˜์‹ ์ ์ธ ์•„์ด๋””์–ด์•ผ. ๐Ÿš€

๐ŸŽฏ ์™œ ์‹ ๊ฒฝ๋ง์œผ๋กœ ๋ฏธ๋ถ„๋ฐฉ์ •์‹์„ ํ’€๊นŒ?

๋จผ์ € ๊ทผ๋ณธ์ ์ธ ์งˆ๋ฌธ๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ด๋ณด์ž. ์ด๋ฏธ ์ž˜ ์ž‘๋™ํ•˜๋Š” ์ „ํ†ต์ ์ธ ์ˆ˜์น˜ํ•ด์„ ๋ฐฉ๋ฒ•์ด ์žˆ๋Š”๋ฐ, ์™œ ๊ตณ์ด ์‹ ๊ฒฝ๋ง์„ ์‚ฌ์šฉํ• ๊นŒ? ๐Ÿค”

์‚ฌ์‹ค ์ด ์งˆ๋ฌธ์—๋Š” ์—ฌ๋Ÿฌ ๊ฐ€์ง€ ์‹ค์šฉ์ ์ธ ๋‹ต์ด ์žˆ์–ด. ์ฒซ์งธ, ๊ณ ์ฐจ์› ๋ฌธ์ œ์—์„œ ์ „ํ†ต์  ๋ฐฉ๋ฒ•์€ "์ฐจ์›์˜ ์ €์ฃผ(Curse of Dimensionality)"๋ผ๋Š” ๋ฌธ์ œ์— ์ง๋ฉดํ•ด. ๋ณ€์ˆ˜๊ฐ€ 10๊ฐœ, 20๊ฐœ๋กœ ๋Š˜์–ด๋‚˜๋ฉด ๊ณ„์‚ฐ ๋ณต์žก๋„๊ฐ€ ๊ธฐํ•˜๊ธ‰์ˆ˜์ ์œผ๋กœ ์ฆ๊ฐ€ํ•˜๊ฑฐ๋“ . ํ•˜์ง€๋งŒ ์‹ ๊ฒฝ๋ง์€ ๊ณ ์ฐจ์› ๊ณต๊ฐ„์—์„œ๋„ ์ƒ๋Œ€์ ์œผ๋กœ ํšจ์œจ์ ์œผ๋กœ ์ž‘๋™ํ•  ์ˆ˜ ์žˆ์–ด.

๋‘˜์งธ, ๋ณต์žกํ•œ ๊ธฐํ•˜ํ•™์  ์˜์—ญ์„ ๋‹ค๋ฃฐ ๋•Œ์•ผ. ์ „ํ†ต์  ๋ฐฉ๋ฒ•์€ ๋ฉ”์‰ฌ(mesh)๋ฅผ ์ƒ์„ฑํ•ด์•ผ ํ•˜๋Š”๋ฐ, ๋ณต์žกํ•œ 3D ํ˜•์ƒ์—์„œ ์ข‹์€ ํ’ˆ์งˆ์˜ ๋ฉ”์‰ฌ๋ฅผ ๋งŒ๋“œ๋Š” ๊ฑด ๊ทธ ์ž์ฒด๋กœ ์–ด๋ ค์šด ๋ฌธ์ œ์•ผ. ์‹ ๊ฒฝ๋ง์€ ๋ฉ”์‰ฌ ์—†์ด๋„ ์ž‘๋™ํ•  ์ˆ˜ ์žˆ์–ด์„œ ์ด๋Ÿฐ ๋ฌธ์ œ๋ฅผ ์šฐํšŒํ•  ์ˆ˜ ์žˆ์ง€.

์…‹์งธ, ์—ญ๋ฌธ์ œ(Inverse Problems)๋ฅผ ํ’€ ๋•Œ ํŠนํžˆ ๊ฐ•๋ ฅํ•ด. ๊ด€์ธก ๋ฐ์ดํ„ฐ๋กœ๋ถ€ํ„ฐ ์‹œ์Šคํ…œ์˜ ํŒŒ๋ผ๋ฏธํ„ฐ๋‚˜ ์ดˆ๊ธฐ์กฐ๊ฑด์„ ์ถ”์ •ํ•˜๋Š” ๋ฌธ์ œ์—์„œ ์‹ ๊ฒฝ๋ง ๊ธฐ๋ฐ˜ ๋ฐฉ๋ฒ•์€ ๋†€๋ผ์šด ์„ฑ๋Šฅ์„ ๋ณด์—ฌ์ค˜. ๐Ÿ“Š

๐Ÿ’ก ์‹ค์ œ ํ™œ์šฉ ์‚ฌ๋ก€ โ€ข ์œ ์ฒด์—ญํ•™: ๋ณต์žกํ•œ ๋‚œ๋ฅ˜ ์‹œ๋ฎฌ๋ ˆ์ด์…˜
โ€ข ์žฌ๋ฃŒ๊ณผํ•™: ์—ด์ „๋‹ฌ ๋ฐ ์‘๋ ฅ ๋ถ„ํฌ ์˜ˆ์ธก
โ€ข ๊ธˆ์œต๊ณตํ•™: ๋ธ”๋ž™-์ˆ„์ฆˆ ๋ฐฉ์ •์‹ ํ•ด์„
โ€ข ์ƒ๋ฌผํ•™: ๋ฐ˜์‘-ํ™•์‚ฐ ์‹œ์Šคํ…œ ๋ชจ๋ธ๋ง
โ€ข ๊ธฐ์ƒํ•™: ๋‚ ์”จ ์˜ˆ์ธก ๋ชจ๋ธ ๊ฐœ์„ 
์‹ ๊ฒฝ๋ง ๊ธฐ๋ฐ˜ ๋ฏธ๋ถ„๋ฐฉ์ •์‹ ํ•ด๋ฒ•์˜ ์ž‘๋™ ์›๋ฆฌ ์ž…๋ ฅ์ธต ์‹œ๊ฐ„ t, ์œ„์น˜ x ์ขŒํ‘œ ์ž…๋ ฅ ์€๋‹‰์ธต ๋น„์„ ํ˜• ๋ณ€ํ™˜ ํŠน์ง• ์ถ”์ถœ ์ถœ๋ ฅ์ธต ํ•ด u(t,x) ๋ฐฉ์ •์‹ ํ•ด ์†์‹ค ํ•จ์ˆ˜ ๊ตฌ์„ฑ 1. ๋ฏธ๋ถ„๋ฐฉ์ •์‹ ์ž”์ฐจ L_PDE = |โˆ‚u/โˆ‚t + N[u]|ยฒ 2. ๊ฒฝ๊ณ„์กฐ๊ฑด ์˜ค์ฐจ L_BC = |u - u_boundary|ยฒ 3. ์ดˆ๊ธฐ์กฐ๊ฑด ์˜ค์ฐจ ํ•™์Šต ๊ณผ์ • Step 1: ๋žœ๋ค ์ƒ˜ํ”Œ๋ง ํฌ์ธํŠธ ์ƒ์„ฑ Step 2: ์‹ ๊ฒฝ๋ง์œผ๋กœ ์˜ˆ์ธก๊ฐ’ ๊ณ„์‚ฐ Step 3: ์ž๋™๋ฏธ๋ถ„์œผ๋กœ ๋„ํ•จ์ˆ˜ ๊ณ„์‚ฐ Step 4: ์†์‹คํ•จ์ˆ˜ ์ตœ์†Œํ™” Step 5: ์—ญ์ „ํŒŒ๋กœ ๊ฐ€์ค‘์น˜ ์—…๋ฐ์ดํŠธ

๐Ÿ”ฌ Physics-Informed Neural Networks (PINNs)์˜ ํ•ต์‹ฌ ๊ฐœ๋…

์ž, ์ด์ œ ๋ณธ๊ฒฉ์ ์œผ๋กœ PINNs์˜ ์„ธ๊ณ„๋กœ ๋“ค์–ด๊ฐ€๋ณด์ž! ๐ŸŒŸ

PINNs์˜ ํ•ต์‹ฌ ์•„์ด๋””์–ด๋Š” ์ •๋ง ๊ฐ„๋‹จํ•˜๋ฉด์„œ๋„ ๊ฐ•๋ ฅํ•ด. ๋ฌผ๋ฆฌ ๋ฒ•์น™(๋ฏธ๋ถ„๋ฐฉ์ •์‹)์„ ์‹ ๊ฒฝ๋ง์˜ ์†์‹ค ํ•จ์ˆ˜์— ์ง์ ‘ ํฌํ•จ์‹œํ‚ค๋Š” ๊ฑฐ์•ผ. ์ผ๋ฐ˜์ ์ธ ์‹ ๊ฒฝ๋ง์ด ๋ฐ์ดํ„ฐ๋งŒ์œผ๋กœ ํ•™์Šตํ•œ๋‹ค๋ฉด, PINNs๋Š” ๋ฐ์ดํ„ฐ์™€ ๋ฌผ๋ฆฌ ๋ฒ•์น™์„ ๋™์‹œ์— ํ•™์Šตํ•˜๋Š” ๊ฑฐ์ง€.

์˜ˆ๋ฅผ ๋“ค์–ด, ๋‹ค์Œ๊ณผ ๊ฐ™์€ ํŽธ๋ฏธ๋ถ„๋ฐฉ์ •์‹(PDE)์ด ์žˆ๋‹ค๊ณ  ํ•ด๋ณด์ž:

โˆ‚u/โˆ‚t + N[u] = 0, (x, t) โˆˆ ฮฉ
u(x, 0) = h(x), x โˆˆ ฮฉ (์ดˆ๊ธฐ์กฐ๊ฑด)
u(x, t) = g(x, t), (x, t) โˆˆ โˆ‚ฮฉ (๊ฒฝ๊ณ„์กฐ๊ฑด)

์—ฌ๊ธฐ์„œ N[u]๋Š” u์— ๋Œ€ํ•œ ๋น„์„ ํ˜• ๋ฏธ๋ถ„ ์—ฐ์‚ฐ์ž์•ผ. ์ „ํ†ต์ ์ธ ๋ฐฉ๋ฒ•์ด๋ผ๋ฉด ์ด ๋ฐฉ์ •์‹์„ ์ด์‚ฐํ™”ํ•ด์„œ ํ–‰๋ ฌ ์‹œ์Šคํ…œ์œผ๋กœ ๋งŒ๋“ค์–ด ํ’€์—ˆ์„ ๊ฑฐ์•ผ. ํ•˜์ง€๋งŒ PINNs๋Š” ๋‹ค๋ฅด๊ฒŒ ์ ‘๊ทผํ•ด.

์‹ ๊ฒฝ๋ง u_ฮธ(x, t)๋ฅผ ์ •์˜ํ•˜๊ณ , ์ด ์‹ ๊ฒฝ๋ง์ด ์œ„ ๋ฐฉ์ •์‹์„ ๋งŒ์กฑํ•˜๋„๋ก ํ•™์Šต์‹œํ‚ค๋Š” ๊ฑฐ์•ผ. ์–ด๋–ป๊ฒŒ? ์†์‹ค ํ•จ์ˆ˜๋ฅผ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ๊ตฌ์„ฑํ•˜๋ฉด ๋ผ:

Loss = ฮปโ‚ ยท L_PDE + ฮปโ‚‚ ยท L_IC + ฮปโ‚ƒ ยท L_BC

L_PDE = (1/N_f) ฮฃ |โˆ‚u_ฮธ/โˆ‚t + N[u_ฮธ]|ยฒ
L_IC = (1/N_0) ฮฃ |u_ฮธ(x, 0) - h(x)|ยฒ
L_BC = (1/N_b) ฮฃ |u_ฮธ(x, t) - g(x, t)|ยฒ

์—ฌ๊ธฐ์„œ ฮปโ‚, ฮปโ‚‚, ฮปโ‚ƒ๋Š” ๊ฐ ํ•ญ์˜ ๊ฐ€์ค‘์น˜๊ณ , N_f, N_0, N_b๋Š” ๊ฐ๊ฐ ์˜์—ญ ๋‚ด๋ถ€, ์ดˆ๊ธฐ์กฐ๊ฑด, ๊ฒฝ๊ณ„์กฐ๊ฑด์—์„œ ์ƒ˜ํ”Œ๋งํ•œ ์ ์˜ ๊ฐœ์ˆ˜์•ผ. ๐ŸŽฒ

์ด ์†์‹ค ํ•จ์ˆ˜์˜ ์•„๋ฆ„๋‹ค์šด ์ ์€ ๋ญ˜๊นŒ? ๋ฏธ๋ถ„๋ฐฉ์ •์‹ ์ž์ฒด๊ฐ€ ์ •๊ทœํ™”(regularization) ์—ญํ• ์„ ํ•œ๋‹ค๋Š” ๊ฑฐ์•ผ! ๋ฐ์ดํ„ฐ๊ฐ€ ๋ถ€์กฑํ•ด๋„ ๋ฌผ๋ฆฌ ๋ฒ•์น™์ด ์‹ ๊ฒฝ๋ง์„ ์˜ฌ๋ฐ”๋ฅธ ๋ฐฉํ–ฅ์œผ๋กœ ์•ˆ๋‚ดํ•ด์ฃผ๋Š” ๊ฑฐ์ง€.

์ž๋™ ๋ฏธ๋ถ„(Automatic Differentiation)์˜ ๋งˆ๋ฒ• โœจ

PINNs๊ฐ€ ์ž‘๋™ํ•˜๋ ค๋ฉด ์‹ ๊ฒฝ๋ง์˜ ์ถœ๋ ฅ์— ๋Œ€ํ•œ ๋„ํ•จ์ˆ˜๋ฅผ ๊ณ„์‚ฐํ•ด์•ผ ํ•ด. ์˜ˆ๋ฅผ ๋“ค์–ด โˆ‚u_ฮธ/โˆ‚t, โˆ‚ยฒu_ฮธ/โˆ‚xยฒ ๊ฐ™์€ ๊ฒƒ๋“ค ๋ง์ด์•ผ. ์†์œผ๋กœ ๊ณ„์‚ฐํ•˜๋ฉด ์ •๋ง ๋ณต์žกํ•˜๊ฒ ์ง€? ๐Ÿ˜ฐ

๋‹คํ–‰ํžˆ๋„ ํ˜„๋Œ€ ๋”ฅ๋Ÿฌ๋‹ ํ”„๋ ˆ์ž„์›Œํฌ๋“ค(PyTorch, TensorFlow, JAX ๋“ฑ)์€ ์ž๋™ ๋ฏธ๋ถ„ ๊ธฐ๋Šฅ์„ ์ œ๊ณตํ•ด. ์ด๊ฑด ๋‹จ์ˆœํ•œ ์ˆ˜์น˜ ๋ฏธ๋ถ„์ด ์•„๋‹ˆ๋ผ, ๊ณ„์‚ฐ ๊ทธ๋ž˜ํ”„๋ฅผ ๋”ฐ๋ผ ์ •ํ™•ํ•œ ๋„ํ•จ์ˆ˜๋ฅผ ๊ณ„์‚ฐํ•˜๋Š” ๊ฑฐ์•ผ.

PyTorch๋ฅผ ์˜ˆ๋กœ ๋“ค๋ฉด, ๋‹ค์Œ๊ณผ ๊ฐ™์ด ๊ฐ„๋‹จํ•˜๊ฒŒ ๋„ํ•จ์ˆ˜๋ฅผ ๊ณ„์‚ฐํ•  ์ˆ˜ ์žˆ์–ด:

import torch

# ์ž…๋ ฅ์— ๋Œ€ํ•ด gradient ์ถ”์  ํ™œ์„ฑํ™”
x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
t = torch.tensor([0.5, 1.0, 1.5], requires_grad=True)

# ์‹ ๊ฒฝ๋ง ์ถœ๋ ฅ
u = neural_network(x, t)

# 1์ฐจ ๋„ํ•จ์ˆ˜ ๊ณ„์‚ฐ
u_t = torch.autograd.grad(u, t, grad_outputs=torch.ones_like(u), 
                          create_graph=True)[0]
u_x = torch.autograd.grad(u, x, grad_outputs=torch.ones_like(u), 
                          create_graph=True)[0]

# 2์ฐจ ๋„ํ•จ์ˆ˜๋„ ๊ฐ€๋Šฅ!
u_xx = torch.autograd.grad(u_x, x, grad_outputs=torch.ones_like(u_x), 
                           create_graph=True)[0]

create_graph=True ์˜ต์…˜์ด ์ค‘์š”ํ•œ๋ฐ, ์ด๊ฒŒ ์žˆ์–ด์•ผ ๋„ํ•จ์ˆ˜์— ๋Œ€ํ•œ ๋„ํ•จ์ˆ˜(๊ณ ์ฐจ ๋ฏธ๋ถ„)๋ฅผ ๊ณ„์‚ฐํ•  ์ˆ˜ ์žˆ๊ฑฐ๋“ . ์ด ๊ธฐ๋Šฅ ๋•๋ถ„์— ๋ณต์žกํ•œ ํŽธ๋ฏธ๋ถ„๋ฐฉ์ •์‹๋„ ์‰ฝ๊ฒŒ ๋‹ค๋ฃฐ ์ˆ˜ ์žˆ์–ด! ๐ŸŽ‰

๐Ÿ’ป ์‹ค์ „ ๊ตฌํ˜„: ์—ด๋ฐฉ์ •์‹ ํ’€์–ด๋ณด๊ธฐ

์ด๋ก ๋งŒ ๋ณด๋ฉด ์žฌ๋ฏธ์—†์œผ๋‹ˆ๊นŒ, ์‹ค์ œ๋กœ ๊ฐ„๋‹จํ•œ ์˜ˆ์ œ๋ฅผ ๊ตฌํ˜„ํ•ด๋ณด์ž! 1์ฐจ์› ์—ด๋ฐฉ์ •์‹(Heat Equation)์„ ํ’€์–ด๋ณผ ๊ฑฐ์•ผ. ์ด๊ฑด ๋ฌผ๋ฆฌํ•™์—์„œ ์ •๋ง ๊ธฐ๋ณธ์ ์ด๋ฉด์„œ๋„ ์ค‘์š”ํ•œ ๋ฐฉ์ •์‹์ด์ง€. ๐Ÿ”ฅ

๐Ÿ“Œ ๋ฌธ์ œ ์„ค์ • โˆ‚u/โˆ‚t = ฮฑ ยท โˆ‚ยฒu/โˆ‚xยฒ, x โˆˆ [0, 1], t โˆˆ [0, 1]
์ดˆ๊ธฐ์กฐ๊ฑด: u(x, 0) = sin(ฯ€x)
๊ฒฝ๊ณ„์กฐ๊ฑด: u(0, t) = 0, u(1, t) = 0
์—ดํ™•์‚ฐ๊ณ„์ˆ˜: ฮฑ = 0.01

์ด ๋ฌธ์ œ๋Š” ํ•ด์„ํ•ด(analytical solution)๊ฐ€ ์•Œ๋ ค์ ธ ์žˆ์–ด์„œ ์šฐ๋ฆฌ๊ฐ€ ๋งŒ๋“  ์‹ ๊ฒฝ๋ง์˜ ์ •ํ™•๋„๋ฅผ ๊ฒ€์ฆํ•˜๊ธฐ ์ข‹์•„. ํ•ด์„ํ•ด๋Š” u(x, t) = exp(-ฮฑยทฯ€ยฒยทt)ยทsin(ฯ€x)์•ผ. ๐Ÿ“

์ž, ์ด์ œ ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•ด๋ณด์ž! ๋จผ์ € ํ•„์š”ํ•œ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ์ž„ํฌํŠธํ•˜๊ณ  ์‹ ๊ฒฝ๋ง ๊ตฌ์กฐ๋ฅผ ์ •์˜ํ• ๊ฒŒ.

import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt

# ์‹ ๊ฒฝ๋ง ์ •์˜
class PINN(nn.Module):
    def __init__(self, layers):
        super(PINN, self).__init__()
        self.layers = nn.ModuleList()
        
        # ์€๋‹‰์ธต ๊ตฌ์„ฑ
        for i in range(len(layers) - 1):
            self.layers.append(nn.Linear(layers[i], layers[i+1]))
        
        # ๊ฐ€์ค‘์น˜ ์ดˆ๊ธฐํ™” (Xavier initialization)
        for layer in self.layers:
            nn.init.xavier_normal_(layer.weight)
            nn.init.zeros_(layer.bias)
    
    def forward(self, x, t):
        # ์ž…๋ ฅ ๊ฒฐํ•ฉ
        inputs = torch.cat([x, t], dim=1)
        
        # ์ˆœ์ „ํŒŒ
        for i, layer in enumerate(self.layers[:-1]):
            inputs = torch.tanh(layer(inputs))
        
        # ์ถœ๋ ฅ์ธต (ํ™œ์„ฑํ™” ํ•จ์ˆ˜ ์—†์Œ)
        output = self.layers[-1](inputs)
        return output

# ๋„คํŠธ์›Œํฌ ๊ตฌ์กฐ: [2, 32, 32, 32, 1]
# ์ž…๋ ฅ 2๊ฐœ(x, t), ์€๋‹‰์ธต 3๊ฐœ(๊ฐ 32๊ฐœ ๋‰ด๋Ÿฐ), ์ถœ๋ ฅ 1๊ฐœ(u)
model = PINN([2, 32, 32, 32, 1])

์—ฌ๊ธฐ์„œ ํ™œ์„ฑํ™” ํ•จ์ˆ˜๋กœ tanh๋ฅผ ์‚ฌ์šฉํ–ˆ์–ด. ์ด๊ฒŒ PINNs์—์„œ ์ผ๋ฐ˜์ ์œผ๋กœ ์ž˜ ์ž‘๋™ํ•˜๋Š” ๊ฒƒ์œผ๋กœ ์•Œ๋ ค์ ธ ์žˆ๊ฑฐ๋“ . ReLU๋ณด๋‹ค ๋ถ€๋“œ๋Ÿฌ์šด ๋„ํ•จ์ˆ˜๋ฅผ ๊ฐ€์ง€๊ณ  ์žˆ์–ด์„œ ๋ฏธ๋ถ„๋ฐฉ์ •์‹์„ ๋‹ค๋ฃฐ ๋•Œ ์œ ๋ฆฌํ•ด. ๐ŸŒŠ

๋‹ค์Œ์œผ๋กœ ์†์‹ค ํ•จ์ˆ˜๋ฅผ ๊ณ„์‚ฐํ•˜๋Š” ํ•จ์ˆ˜๋ฅผ ๋งŒ๋“ค์–ด๋ณด์ž:

def compute_loss(model, x_pde, t_pde, x_ic, t_ic, u_ic, x_bc, t_bc, u_bc, alpha=0.01):
    # PDE ์†์‹ค ๊ณ„์‚ฐ
    x_pde.requires_grad = True
    t_pde.requires_grad = True
    
    u = model(x_pde, t_pde)
    
    # 1์ฐจ ๋„ํ•จ์ˆ˜
    u_t = torch.autograd.grad(u, t_pde, grad_outputs=torch.ones_like(u),
                              create_graph=True)[0]
    u_x = torch.autograd.grad(u, x_pde, grad_outputs=torch.ones_like(u),
                              create_graph=True)[0]
    
    # 2์ฐจ ๋„ํ•จ์ˆ˜
    u_xx = torch.autograd.grad(u_x, x_pde, grad_outputs=torch.ones_like(u_x),
                               create_graph=True)[0]
    
    # PDE ์ž”์ฐจ: โˆ‚u/โˆ‚t - ฮฑยทโˆ‚ยฒu/โˆ‚xยฒ
    pde_residual = u_t - alpha * u_xx
    loss_pde = torch.mean(pde_residual ** 2)
    
    # ์ดˆ๊ธฐ์กฐ๊ฑด ์†์‹ค
    u_pred_ic = model(x_ic, t_ic)
    loss_ic = torch.mean((u_pred_ic - u_ic) ** 2)
    
    # ๊ฒฝ๊ณ„์กฐ๊ฑด ์†์‹ค
    u_pred_bc = model(x_bc, t_bc)
    loss_bc = torch.mean((u_pred_bc - u_bc) ** 2)
    
    # ์ „์ฒด ์†์‹ค (๊ฐ€์ค‘์น˜ ์กฐ์ • ๊ฐ€๋Šฅ)
    total_loss = loss_pde + loss_ic + loss_bc
    
    return total_loss, loss_pde, loss_ic, loss_bc

์ด์ œ ํ•™์Šต ๋ฐ์ดํ„ฐ๋ฅผ ์ƒ์„ฑํ•˜๊ณ  ๋ชจ๋ธ์„ ํ•™์Šต์‹œ์ผœ๋ณด์ž! ๐Ÿš€

# ํ•™์Šต ๋ฐ์ดํ„ฐ ์ƒ์„ฑ
def generate_training_data(n_pde=1000, n_ic=100, n_bc=100):
    # PDE ํฌ์ธํŠธ (์˜์—ญ ๋‚ด๋ถ€)
    x_pde = torch.rand(n_pde, 1)
    t_pde = torch.rand(n_pde, 1)
    
    # ์ดˆ๊ธฐ์กฐ๊ฑด ํฌ์ธํŠธ (t=0)
    x_ic = torch.rand(n_ic, 1)
    t_ic = torch.zeros(n_ic, 1)
    u_ic = torch.sin(np.pi * x_ic)
    
    # ๊ฒฝ๊ณ„์กฐ๊ฑด ํฌ์ธํŠธ (x=0, x=1)
    x_bc_0 = torch.zeros(n_bc//2, 1)
    x_bc_1 = torch.ones(n_bc//2, 1)
    x_bc = torch.cat([x_bc_0, x_bc_1], dim=0)
    t_bc = torch.rand(n_bc, 1)
    u_bc = torch.zeros(n_bc, 1)
    
    return x_pde, t_pde, x_ic, t_ic, u_ic, x_bc, t_bc, u_bc

# ๋ฐ์ดํ„ฐ ์ƒ์„ฑ
x_pde, t_pde, x_ic, t_ic, u_ic, x_bc, t_bc, u_bc = generate_training_data()

# ์˜ตํ‹ฐ๋งˆ์ด์ € ์„ค์ •
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

# ํ•™์Šต ๋ฃจํ”„
epochs = 5000
for epoch in range(epochs):
    optimizer.zero_grad()
    
    loss, loss_pde, loss_ic, loss_bc = compute_loss(
        model, x_pde, t_pde, x_ic, t_ic, u_ic, x_bc, t_bc, u_bc
    )
    
    loss.backward()
    optimizer.step()
    
    if (epoch + 1) % 500 == 0:
        print(f'Epoch {epoch+1}/{epochs}, Loss: {loss.item():.6f}, '
              f'PDE: {loss_pde.item():.6f}, IC: {loss_ic.item():.6f}, '
              f'BC: {loss_bc.item():.6f}')

ํ•™์Šต์ด ์™„๋ฃŒ๋˜๋ฉด, ๊ฒฐ๊ณผ๋ฅผ ์‹œ๊ฐํ™”ํ•ด์„œ ํ™•์ธํ•ด๋ณผ ์ˆ˜ ์žˆ์–ด. ํ•ด์„ํ•ด์™€ ๋น„๊ตํ•˜๋ฉด ์–ผ๋งˆ๋‚˜ ์ •ํ™•ํ•œ์ง€ ์•Œ ์ˆ˜ ์žˆ์ง€! ๐Ÿ“Š

๐ŸŽ“ ํ•™์Šต ํŒ 1. ์ƒ˜ํ”Œ๋ง ์ „๋žต: ์ดˆ๊ธฐ์—๋Š” ๊ท ๋“ฑ ์ƒ˜ํ”Œ๋ง, ๋‚˜์ค‘์—๋Š” ์ž”์ฐจ๊ฐ€ ํฐ ์˜์—ญ์— ์ง‘์ค‘
2. ๊ฐ€์ค‘์น˜ ์กฐ์ •: ๊ฐ ์†์‹ค ํ•ญ์˜ ํฌ๊ธฐ๊ฐ€ ๋น„์Šทํ•˜๋„๋ก ฮป ๊ฐ’ ์กฐ์ •
3. ํ•™์Šต๋ฅ  ์Šค์ผ€์ค„๋ง: ์ดˆ๊ธฐ์—๋Š” ํฐ ํ•™์Šต๋ฅ , ์ ์ง„์ ์œผ๋กœ ๊ฐ์†Œ
4. ๋„คํŠธ์›Œํฌ ๊นŠ์ด: ๋ฌธ์ œ์˜ ๋ณต์žก๋„์— ๋”ฐ๋ผ ์ธต ์ˆ˜์™€ ๋‰ด๋Ÿฐ ์ˆ˜ ์กฐ์ •
5. ์ •๊ทœํ™”: ์ž…๋ ฅ ๋ฐ์ดํ„ฐ๋ฅผ [-1, 1] ๋ฒ”์œ„๋กœ ์ •๊ทœํ™”ํ•˜๋ฉด ํ•™์Šต ์•ˆ์ •์„ฑ ํ–ฅ์ƒ

๐ŸŽจ ๊ณ ๊ธ‰ ๊ธฐ๋ฒ•๋“ค

์ ์‘์  ๊ฐ€์ค‘์น˜ ์กฐ์ • (Adaptive Weighting)

์‹ค์ œ๋กœ PINNs๋ฅผ ์‚ฌ์šฉํ•˜๋‹ค ๋ณด๋ฉด, ์†์‹ค ํ•จ์ˆ˜์˜ ๊ฐ ํ•ญ์ด ์„œ๋กœ ๋‹ค๋ฅธ ์Šค์ผ€์ผ์„ ๊ฐ€์ง€๋Š” ๊ฒฝ์šฐ๊ฐ€ ๋งŽ์•„. ์˜ˆ๋ฅผ ๋“ค์–ด L_PDE๋Š” 10^-3 ์ •๋„์ธ๋ฐ L_BC๋Š” 10^-1 ์ •๋„๋ผ๋ฉด, ๊ฒฝ๊ณ„์กฐ๊ฑด๋งŒ ํ•™์Šต๋˜๊ณ  PDE๋Š” ์ œ๋Œ€๋กœ ํ•™์Šต๋˜์ง€ ์•Š์„ ์ˆ˜ ์žˆ์–ด. ๐Ÿ˜“

์ด๋ฅผ ํ•ด๊ฒฐํ•˜๊ธฐ ์œ„ํ•ด ์ ์‘์  ๊ฐ€์ค‘์น˜ ์กฐ์ • ๊ธฐ๋ฒ•์„ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์–ด. ํ•™์Šต ์ค‘์— ๊ฐ ์†์‹ค ํ•ญ์˜ ํฌ๊ธฐ๋ฅผ ๋ชจ๋‹ˆํ„ฐ๋งํ•˜๊ณ , ๊ฐ€์ค‘์น˜๋ฅผ ๋™์ ์œผ๋กœ ์กฐ์ •ํ•˜๋Š” ๊ฑฐ์•ผ.

class AdaptiveWeights:
    def __init__(self, num_losses):
        self.weights = torch.ones(num_losses)
        self.loss_history = []
    
    def update(self, losses):
        # ์†์‹ค ๊ฐ’๋“ค์„ ๊ธฐ๋ก
        self.loss_history.append(losses.detach().cpu().numpy())
        
        if len(self.loss_history) > 100:
            # ์ตœ๊ทผ 100 ์—ํญ์˜ ํ‰๊ท  ์†์‹ค ๊ณ„์‚ฐ
            recent_losses = np.array(self.loss_history[-100:])
            mean_losses = np.mean(recent_losses, axis=0)
            
            # ๊ฐ€์ค‘์น˜ ์—…๋ฐ์ดํŠธ (ํฐ ์†์‹ค์— ๋” ํฐ ๊ฐ€์ค‘์น˜)
            self.weights = torch.tensor(mean_losses / np.sum(mean_losses))
        
        return self.weights

# ์‚ฌ์šฉ ์˜ˆ์‹œ
adaptive_weights = AdaptiveWeights(num_losses=3)

for epoch in range(epochs):
    # ... ์†์‹ค ๊ณ„์‚ฐ ...
    losses = torch.stack([loss_pde, loss_ic, loss_bc])
    weights = adaptive_weights.update(losses)
    
    total_loss = torch.sum(weights * losses)
    # ... ์—ญ์ „ํŒŒ ๋ฐ ์—…๋ฐ์ดํŠธ ...

์ „์ด ํ•™์Šต (Transfer Learning)

๋น„์Šทํ•œ ๋ฌธ์ œ๋ฅผ ์—ฌ๋Ÿฌ ๋ฒˆ ํ’€์–ด์•ผ ํ•  ๋•Œ, ์ „์ด ํ•™์Šต์„ ํ™œ์šฉํ•˜๋ฉด ํ•™์Šต ์‹œ๊ฐ„์„ ํฌ๊ฒŒ ์ค„์ผ ์ˆ˜ ์žˆ์–ด. ์˜ˆ๋ฅผ ๋“ค์–ด, ํŒŒ๋ผ๋ฏธํ„ฐ๋งŒ ์•ฝ๊ฐ„ ๋‹ค๋ฅธ ์—ฌ๋Ÿฌ ์‹œ๋‚˜๋ฆฌ์˜ค๋ฅผ ์‹œ๋ฎฌ๋ ˆ์ด์…˜ํ•ด์•ผ ํ•œ๋‹ค๋ฉด, ํ•œ ๋ฒˆ ํ•™์Šตํ•œ ๋ชจ๋ธ์„ ์ดˆ๊ธฐ๊ฐ’์œผ๋กœ ์‚ฌ์šฉํ•˜๋Š” ๊ฑฐ์•ผ. ๐Ÿ”„

์žฌ๋Šฅ๋„ท(https://www.jaenung.net) ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ ๋‹ค์–‘ํ•œ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ํ”„๋กœ์ ํŠธ๋ฅผ ์ง„ํ–‰ํ•˜๋‹ค ๋ณด๋ฉด, ์ด๋Ÿฐ ํšจ์œจ์ ์ธ ์ ‘๊ทผ๋ฒ•์ด ์ •๋ง ์ค‘์š”ํ•˜๋‹ค๋Š” ๊ฑธ ๋А๋‚„ ์ˆ˜ ์žˆ์„ ๊ฑฐ์•ผ.

๋ฉ€ํ‹ฐ ํ”ผ๋ธ๋ฆฌํ‹ฐ ํ•™์Šต (Multi-Fidelity Learning)

๊ณ ํ•ด์ƒ๋„ ์‹œ๋ฎฌ๋ ˆ์ด์…˜ ๋ฐ์ดํ„ฐ๋Š” ๋น„์‹ธ๊ณ , ์ €ํ•ด์ƒ๋„ ๋ฐ์ดํ„ฐ๋Š” ๋งŽ์ด ์žˆ์„ ๋•Œ ์‚ฌ์šฉํ•˜๋Š” ๊ธฐ๋ฒ•์ด์•ผ. ์ €ํ•ด์ƒ๋„ ๋ฐ์ดํ„ฐ๋กœ ๋จผ์ € ํ•™์Šตํ•˜๊ณ , ๊ณ ํ•ด์ƒ๋„ ๋ฐ์ดํ„ฐ๋กœ ๋ฏธ์„ธ ์กฐ์ •ํ•˜๋Š” ๋ฐฉ์‹์ด์ง€. ๐Ÿ’Ž

์ด๊ฑด ํŠนํžˆ ์‹คํ—˜ ๋ฐ์ดํ„ฐ์™€ ์‹œ๋ฎฌ๋ ˆ์ด์…˜์„ ๊ฒฐํ•ฉํ•  ๋•Œ ์œ ์šฉํ•ด. ์‹คํ—˜ ๋ฐ์ดํ„ฐ๋Š” ์ ์ง€๋งŒ ์ •ํ™•ํ•˜๊ณ , ์‹œ๋ฎฌ๋ ˆ์ด์…˜ ๋ฐ์ดํ„ฐ๋Š” ๋งŽ์ง€๋งŒ ๊ทผ์‚ฌ์ ์ด์ž–์•„? ์ด ๋‘˜์„ ํšจ๊ณผ์ ์œผ๋กœ ๊ฒฐํ•ฉํ•  ์ˆ˜ ์žˆ์–ด.

๐ŸŒ ๋‹ค์–‘ํ•œ ๋ฏธ๋ถ„๋ฐฉ์ •์‹ ์œ ํ˜•๋ณ„ ์ ‘๊ทผ๋ฒ•

์Œ๊ณกํ˜• ๋ฐฉ์ •์‹ (Hyperbolic PDEs)

ํŒŒ๋™๋ฐฉ์ •์‹ ๊ฐ™์€ ์Œ๊ณกํ˜• ๋ฐฉ์ •์‹์€ ๋ถˆ์—ฐ์†์„ฑ์ด๋‚˜ ์ถฉ๊ฒฉํŒŒ(shock wave)๋ฅผ ํฌํ•จํ•  ์ˆ˜ ์žˆ์–ด. ์ด๋Ÿฐ ๊ฒฝ์šฐ ์ผ๋ฐ˜์ ์ธ PINNs๋Š” ์–ด๋ ค์›€์„ ๊ฒช์„ ์ˆ˜ ์žˆ๋Š”๋ฐ, ๋ช‡ ๊ฐ€์ง€ ํ•ด๊ฒฐ์ฑ…์ด ์žˆ์–ด:

๐ŸŒŠ ์Œ๊ณกํ˜• ๋ฐฉ์ •์‹ ์ฒ˜๋ฆฌ ์ „๋žต 1. ์ธ๊ณผ์  ํ•™์Šต(Causal Training): ์‹œ๊ฐ„ ์ˆœ์„œ๋Œ€๋กœ ์ ์ง„์ ์œผ๋กœ ํ•™์Šต
2. ์ ์‘์  ์ƒ˜ํ”Œ๋ง: ๋ถˆ์—ฐ์† ๊ทผ์ฒ˜์—์„œ ๋” ๋งŽ์€ ํฌ์ธํŠธ ์ƒ˜ํ”Œ๋ง
3. ๋ณด์กด ๋ฒ•์น™ ๊ฐ•์ œ: ๋ฌผ๋ฆฌ์  ๋ณด์กด๋Ÿ‰์„ ๋ช…์‹œ์ ์œผ๋กœ ์†์‹ค ํ•จ์ˆ˜์— ํฌํ•จ
4. ์•™์ƒ๋ธ” ๋ฐฉ๋ฒ•: ์—ฌ๋Ÿฌ ์‹ ๊ฒฝ๋ง์˜ ์˜ˆ์ธก์„ ๊ฒฐํ•ฉ
# ์ธ๊ณผ์  ํ•™์Šต ์˜ˆ์‹œ
def causal_training(model, x_data, t_data, time_windows=10):
    t_max = t_data.max()
    dt = t_max / time_windows
    
    for i in range(time_windows):
        t_start = i * dt
        t_end = (i + 1) * dt
        
        # ํ˜„์žฌ ์‹œ๊ฐ„ ์œˆ๋„์šฐ์˜ ๋ฐ์ดํ„ฐ๋งŒ ์„ ํƒ
        mask = (t_data >= t_start) & (t_data <= t_end)
        x_window = x_data[mask]
        t_window = t_data[mask]
        
        # ์ด์ „ ์‹œ๊ฐ„ ์œˆ๋„์šฐ์˜ ๊ฒฐ๊ณผ๋ฅผ ์ดˆ๊ธฐ์กฐ๊ฑด์œผ๋กœ ์‚ฌ์šฉ
        if i > 0:
            with torch.no_grad():
                u_prev = model(x_window, torch.full_like(t_window, t_start))
        
        # ํ˜„์žฌ ์œˆ๋„์šฐ ํ•™์Šต
        for epoch in range(1000):
            # ... ํ•™์Šต ์ฝ”๋“œ ...
            pass

ํƒ€์›ํ˜• ๋ฐฉ์ •์‹ (Elliptic PDEs)

ํฌ์•„์†ก ๋ฐฉ์ •์‹์ด๋‚˜ ๋ผํ”Œ๋ผ์Šค ๋ฐฉ์ •์‹ ๊ฐ™์€ ํƒ€์›ํ˜• ๋ฐฉ์ •์‹์€ ์ •์ƒ ์ƒํƒœ(steady-state) ๋ฌธ์ œ๋ฅผ ๋‹ค๋ค„. ์‹œ๊ฐ„ ์˜์กด์„ฑ์ด ์—†์–ด์„œ ์ƒ๋Œ€์ ์œผ๋กœ ํ•™์Šต์ด ์‰ฌ์šด ํŽธ์ด์•ผ. ํ•˜์ง€๋งŒ ๋ณต์žกํ•œ ๊ธฐํ•˜ํ•™์  ์˜์—ญ์—์„œ๋Š” ์—ฌ์ „ํžˆ ๋„์ „์ ์ด์ง€. ๐ŸŽฏ

# 2D ํฌ์•„์†ก ๋ฐฉ์ •์‹ ์˜ˆ์‹œ: โˆ‡ยฒu = f(x,y)
class PoissonPINN(nn.Module):
    def __init__(self):
        super(PoissonPINN, self).__init__()
        self.net = nn.Sequential(
            nn.Linear(2, 50),
            nn.Tanh(),
            nn.Linear(50, 50),
            nn.Tanh(),
            nn.Linear(50, 50),
            nn.Tanh(),
            nn.Linear(50, 1)
        )
    
    def forward(self, x, y):
        inputs = torch.cat([x, y], dim=1)
        return self.net(inputs)

def poisson_loss(model, x, y, f_source):
    x.requires_grad = True
    y.requires_grad = True
    
    u = model(x, y)
    
    # 1์ฐจ ๋„ํ•จ์ˆ˜
    u_x = torch.autograd.grad(u, x, grad_outputs=torch.ones_like(u),
                              create_graph=True)[0]
    u_y = torch.autograd.grad(u, y, grad_outputs=torch.ones_like(u),
                              create_graph=True)[0]
    
    # 2์ฐจ ๋„ํ•จ์ˆ˜ (๋ผํ”Œ๋ผ์‹œ์•ˆ)
    u_xx = torch.autograd.grad(u_x, x, grad_outputs=torch.ones_like(u_x),
                               create_graph=True)[0]
    u_yy = torch.autograd.grad(u_y, y, grad_outputs=torch.ones_like(u_y),
                               create_graph=True)[0]
    
    laplacian = u_xx + u_yy
    
    # PDE ์ž”์ฐจ
    residual = laplacian - f_source
    loss = torch.mean(residual ** 2)
    
    return loss

ํฌ๋ฌผํ˜• ๋ฐฉ์ •์‹ (Parabolic PDEs)

ํ™•์‚ฐ ๋ฐฉ์ •์‹์ด๋‚˜ ์—ด๋ฐฉ์ •์‹ ๊ฐ™์€ ํฌ๋ฌผํ˜• ๋ฐฉ์ •์‹์€ ์‹œ๊ฐ„์— ๋”ฐ๋ผ ๋ถ€๋“œ๋Ÿฝ๊ฒŒ ๋ณ€ํ™”ํ•˜๋Š” ํ˜„์ƒ์„ ๋ชจ๋ธ๋งํ•ด. ์•ž์—์„œ ๋ณธ ์—ด๋ฐฉ์ •์‹ ์˜ˆ์ œ๊ฐ€ ๋ฐ”๋กœ ์ด ๋ฒ”์ฃผ์— ์†ํ•˜์ง€. ์ด๋Ÿฐ ๋ฐฉ์ •์‹๋“ค์€ PINNs๋กœ ๋น„๊ต์  ์ž˜ ํ’€๋ ค. ๐Ÿ˜Š

๐Ÿ”ง ์‹ค๋ฌด์—์„œ์˜ ๋„์ „๊ณผ์ œ์™€ ํ•ด๊ฒฐ์ฑ…

์ˆ˜๋ ด ์†๋„ ๋ฌธ์ œ

PINNs์˜ ๊ฐ€์žฅ ํฐ ๋‹จ์  ์ค‘ ํ•˜๋‚˜๋Š” ํ•™์Šต์ด ๋А๋ฆด ์ˆ˜ ์žˆ๋‹ค๋Š” ๊ฑฐ์•ผ. ํŠนํžˆ ๋ณต์žกํ•œ ๋ฌธ์ œ์—์„œ๋Š” ์ˆ˜๋งŒ ๋ฒˆ์˜ ๋ฐ˜๋ณต์ด ํ•„์š”ํ•  ์ˆ˜ ์žˆ์–ด. ์ด๋ฅผ ๊ฐœ์„ ํ•˜๊ธฐ ์œ„ํ•œ ๋ช‡ ๊ฐ€์ง€ ๋ฐฉ๋ฒ•์ด ์žˆ์–ด:

๊ธฐ๋ฒ• ์„ค๋ช… ํšจ๊ณผ
L-BFGS ์˜ตํ‹ฐ๋งˆ์ด์ € 2์ฐจ ์ตœ์ ํ™” ๋ฐฉ๋ฒ• ์‚ฌ์šฉ ์ˆ˜๋ ด ์†๋„ 2-3๋ฐฐ ํ–ฅ์ƒ
ํ•™์Šต๋ฅ  ์Šค์ผ€์ค„๋ง Cosine annealing, Step decay ์•ˆ์ •์ ์ธ ์ˆ˜๋ ด
Residual ๋„คํŠธ์›Œํฌ Skip connection ์ถ”๊ฐ€ ๊นŠ์€ ๋„คํŠธ์›Œํฌ ํ•™์Šต ๊ฐ€๋Šฅ
Fourier Features ์ž…๋ ฅ์„ ํ‘ธ๋ฆฌ์— ๋ณ€ํ™˜ ๊ณ ์ฃผํŒŒ ์„ฑ๋ถ„ ํ•™์Šต ๊ฐœ์„ 
Curriculum Learning ์‰ฌ์šด ๋ฌธ์ œ๋ถ€ํ„ฐ ์ ์ง„์  ํ•™์Šต ๋ณต์žกํ•œ ๋ฌธ์ œ ํ•ด๊ฒฐ ๊ฐ€๋Šฅ
# Fourier Features ์˜ˆ์‹œ
class FourierFeatures(nn.Module):
    def __init__(self, input_dim, mapping_size=256, scale=10):
        super().__init__()
        self.input_dim = input_dim
        self.mapping_size = mapping_size
        
        # ๋žœ๋ค ํ‘ธ๋ฆฌ์— ํŠน์ง• ํ–‰๋ ฌ
        self.B = nn.Parameter(torch.randn(input_dim, mapping_size) * scale,
                              requires_grad=False)
    
    def forward(self, x):
        # x: [batch_size, input_dim]
        x_proj = 2 * np.pi * x @ self.B  # [batch_size, mapping_size]
        return torch.cat([torch.sin(x_proj), torch.cos(x_proj)], dim=-1)

# ์‚ฌ์šฉ ์˜ˆ์‹œ
class FourierPINN(nn.Module):
    def __init__(self):
        super().__init__()
        self.fourier = FourierFeatures(input_dim=2, mapping_size=128)
        self.net = nn.Sequential(
            nn.Linear(256, 128),  # 128*2 (sin + cos)
            nn.Tanh(),
            nn.Linear(128, 128),
            nn.Tanh(),
            nn.Linear(128, 1)
        )
    
    def forward(self, x, t):
        inputs = torch.cat([x, t], dim=1)
        features = self.fourier(inputs)
        return self.net(features)

๊ณ ์ฐจ์› ๋ฌธ์ œ

๋ณ€์ˆ˜๊ฐ€ ๋งŽ์€ ๊ณ ์ฐจ์› ๋ฌธ์ œ๋Š” ์—ฌ์ „ํžˆ ๋„์ „์ ์ด์•ผ. ํ•˜์ง€๋งŒ ๋ช‡ ๊ฐ€์ง€ ์ „๋žต์œผ๋กœ ์ด๋ฅผ ์™„ํ™”ํ•  ์ˆ˜ ์žˆ์–ด:

๐Ÿš€ ๊ณ ์ฐจ์› ๋ฌธ์ œ ๋Œ€์‘ ์ „๋žต 1. ์ฐจ์› ์ถ•์†Œ: PCA๋‚˜ ์˜คํ† ์ธ์ฝ”๋”๋กœ ์ค‘์š”ํ•œ ์ฐจ์›๋งŒ ์ถ”์ถœ
2. ๋ถ„๋ฆฌ ๊ฐ€๋Šฅ ๊ตฌ์กฐ: ๋ณ€์ˆ˜๋ฅผ ๊ทธ๋ฃน์œผ๋กœ ๋‚˜๋ˆ„์–ด ๋…๋ฆฝ์ ์œผ๋กœ ์ฒ˜๋ฆฌ
3. ํฌ์†Œ ๊ทธ๋ฆฌ๋“œ: ๋ชจ๋“  ์กฐํ•ฉ์ด ์•„๋‹Œ ์ค‘์š”ํ•œ ํฌ์ธํŠธ๋งŒ ์ƒ˜ํ”Œ๋ง
4. ๊ณ„์ธต์  ์ ‘๊ทผ: ์ €์ฐจ์› ๊ทผ์‚ฌ๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ด ์ ์ง„์ ์œผ๋กœ ์ฐจ์› ์ฆ๊ฐ€

์—ญ๋ฌธ์ œ (Inverse Problems)

PINNs์˜ ์ •๋ง ๊ฐ•๋ ฅํ•œ ์‘์šฉ ๋ถ„์•ผ ์ค‘ ํ•˜๋‚˜๊ฐ€ ์—ญ๋ฌธ์ œ์•ผ! ๊ด€์ธก ๋ฐ์ดํ„ฐ๋กœ๋ถ€ํ„ฐ ์‹œ์Šคํ…œ์˜ ํŒŒ๋ผ๋ฏธํ„ฐ๋‚˜ ์ดˆ๊ธฐ์กฐ๊ฑด์„ ์ถ”์ •ํ•˜๋Š” ๊ฑฐ์ง€. ๐Ÿ”

์˜ˆ๋ฅผ ๋“ค์–ด, ์—ด๋ฐฉ์ •์‹์—์„œ ์—ดํ™•์‚ฐ๊ณ„์ˆ˜ ฮฑ๋ฅผ ๋ชจ๋ฅธ๋‹ค๊ณ  ํ•ด๋ณด์ž. ๋ช‡ ๊ฐœ์˜ ์„ผ์„œ ์ธก์ •๊ฐ’๋งŒ ์žˆ๋‹ค๋ฉด, PINNs๋กœ ฮฑ๋ฅผ ์ถ”์ •ํ•  ์ˆ˜ ์žˆ์–ด!

class InversePINN(nn.Module):
    def __init__(self):
        super().__init__()
        # ์‹ ๊ฒฝ๋ง (ํ•ด u๋ฅผ ๊ทผ์‚ฌ)
        self.net = nn.Sequential(
            nn.Linear(2, 50),
            nn.Tanh(),
            nn.Linear(50, 50),
            nn.Tanh(),
            nn.Linear(50, 1)
        )
        
        # ํ•™์Šต ๊ฐ€๋Šฅํ•œ ํŒŒ๋ผ๋ฏธํ„ฐ (์—ดํ™•์‚ฐ๊ณ„์ˆ˜)
        self.alpha = nn.Parameter(torch.tensor([0.5]))
    
    def forward(self, x, t):
        inputs = torch.cat([x, t], dim=1)
        return self.net(inputs)

def inverse_loss(model, x_pde, t_pde, x_obs, t_obs, u_obs):
    # PDE ์†์‹ค (์•ŒํŒŒ ์‚ฌ์šฉ)
    x_pde.requires_grad = True
    t_pde.requires_grad = True
    
    u = model(x_pde, t_pde)
    u_t = torch.autograd.grad(u, t_pde, grad_outputs=torch.ones_like(u),
                              create_graph=True)[0]
    u_x = torch.autograd.grad(u, x_pde, grad_outputs=torch.ones_like(u),
                              create_graph=True)[0]
    u_xx = torch.autograd.grad(u_x, x_pde, grad_outputs=torch.ones_like(u_x),
                               create_graph=True)[0]
    
    pde_residual = u_t - model.alpha * u_xx
    loss_pde = torch.mean(pde_residual ** 2)
    
    # ๊ด€์ธก ๋ฐ์ดํ„ฐ ์†์‹ค
    u_pred = model(x_obs, t_obs)
    loss_obs = torch.mean((u_pred - u_obs) ** 2)
    
    # ์ „์ฒด ์†์‹ค
    total_loss = loss_pde + 100 * loss_obs  # ๊ด€์ธก ๋ฐ์ดํ„ฐ์— ๋†’์€ ๊ฐ€์ค‘์น˜
    
    return total_loss, model.alpha

# ํ•™์Šต ํ›„ ์ถ”์ •๋œ alpha ๊ฐ’ ํ™•์ธ
print(f"์ถ”์ •๋œ ์—ดํ™•์‚ฐ๊ณ„์ˆ˜: {model.alpha.item():.4f}")

์ด๋Ÿฐ ์—ญ๋ฌธ์ œ ํ•ด๊ฒฐ ๋Šฅ๋ ฅ์€ ์‹ค์ œ ์‚ฐ์—… ํ˜„์žฅ์—์„œ ์ •๋ง ์œ ์šฉํ•ด. ์‹คํ—˜์œผ๋กœ ์ง์ ‘ ์ธก์ •ํ•˜๊ธฐ ์–ด๋ ค์šด ๋ฌผ์„ฑ์น˜๋ฅผ ์ถ”์ •ํ•˜๊ฑฐ๋‚˜, ์‹œ์Šคํ…œ์˜ ์ˆจ๊ฒจ์ง„ ํŒŒ๋ผ๋ฏธํ„ฐ๋ฅผ ์ฐพ์•„๋‚ผ ์ˆ˜ ์žˆ๊ฑฐ๋“ ! ๐ŸŽฏ

๐ŸŒŸ ์ตœ์‹  ์—ฐ๊ตฌ ๋™ํ–ฅ

DeepONet (Deep Operator Networks)

PINNs์˜ ์ง„ํ™” ๋ฒ„์ „ ์ค‘ ํ•˜๋‚˜๊ฐ€ DeepONet์ด์•ผ. ์ด๊ฑด ๋‹จ์ผ ํ•ด๊ฐ€ ์•„๋‹ˆ๋ผ ์—ฐ์‚ฐ์ž(operator) ์ž์ฒด๋ฅผ ํ•™์Šตํ•˜๋Š” ๊ฑฐ์•ผ. ๋ฌด์Šจ ๋ง์ด๋ƒ๋ฉด, ๋‹ค์–‘ํ•œ ์ดˆ๊ธฐ์กฐ๊ฑด์ด๋‚˜ ๊ฒฝ๊ณ„์กฐ๊ฑด์— ๋Œ€ํ•œ ํ•ด๋ฅผ ํ•œ ๋ฒˆ์— ํ•™์Šตํ•˜๋Š” ๊ฑฐ์ง€! ๐Ÿคฏ

์˜ˆ๋ฅผ ๋“ค์–ด, ์—ด๋ฐฉ์ •์‹์—์„œ ์ดˆ๊ธฐ ์˜จ๋„ ๋ถ„ํฌ๊ฐ€ ๋ฐ”๋€” ๋•Œ๋งˆ๋‹ค ์ƒˆ๋กœ ํ•™์Šตํ•  ํ•„์š” ์—†์ด, DeepONet์€ "์ดˆ๊ธฐ์กฐ๊ฑด โ†’ ํ•ด"๋ผ๋Š” ๋งคํ•‘ ์ž์ฒด๋ฅผ ํ•™์Šตํ•ด. ์ด๊ฑด ์ •๋ง ๊ฐ•๋ ฅํ•œ ๊ฐœ๋…์ด์•ผ!

๐ŸŽ“ DeepONet์˜ ๊ตฌ์กฐ โ€ข Branch Network: ์ž…๋ ฅ ํ•จ์ˆ˜(์˜ˆ: ์ดˆ๊ธฐ์กฐ๊ฑด)๋ฅผ ์ธ์ฝ”๋”ฉ
โ€ข Trunk Network: ํ‰๊ฐ€ ์œ„์น˜(x, t)๋ฅผ ์ธ์ฝ”๋”ฉ
โ€ข ์ถœ๋ ฅ: ๋‘ ๋„คํŠธ์›Œํฌ์˜ ๋‚ด์ ์œผ๋กœ ํ•ด ๊ณ„์‚ฐ

u(x, t) = ฮฃแตข bแตข(uโ‚€) ยท tแตข(x, t)

Neural Operators

Fourier Neural Operator (FNO)๋Š” ๋˜ ๋‹ค๋ฅธ ํ˜์‹ ์ ์ธ ์ ‘๊ทผ๋ฒ•์ด์•ผ. ํ‘ธ๋ฆฌ์— ๊ณต๊ฐ„์—์„œ ์—ฐ์‚ฐ์„ ์ˆ˜ํ–‰ํ•ด์„œ ๊ณ„์‚ฐ ํšจ์œจ์„ฑ์„ ํฌ๊ฒŒ ๋†’์˜€์–ด. ํŠนํžˆ ์œ ์ฒด์—ญํ•™ ๊ฐ™์€ ๋ณต์žกํ•œ ๋ฌธ์ œ์—์„œ ์ „ํ†ต์  ๋ฐฉ๋ฒ•๋ณด๋‹ค ์ˆ˜์ฒœ ๋ฐฐ ๋น ๋ฅธ ์†๋„๋ฅผ ๋ณด์—ฌ์คฌ์–ด! โšก

Symbolic Regression๊ณผ์˜ ๊ฒฐํ•ฉ

์ตœ๊ทผ์—๋Š” ์‹ ๊ฒฝ๋ง์œผ๋กœ ํ•™์Šตํ•œ ๊ฒฐ๊ณผ๋ฅผ ํ•ด์„ ๊ฐ€๋Šฅํ•œ ์ˆ˜์‹์œผ๋กœ ๋ณ€ํ™˜ํ•˜๋Š” ์—ฐ๊ตฌ๋„ ํ™œ๋ฐœํ•ด. ์ด๋ฅผ ํ†ตํ•ด ๋ฐ์ดํ„ฐ๋กœ๋ถ€ํ„ฐ ์ƒˆ๋กœ์šด ๋ฌผ๋ฆฌ ๋ฒ•์น™์„ ๋ฐœ๊ฒฌํ•  ์ˆ˜๋„ ์žˆ์–ด. ์ •๋ง ํฅ๋ฏธ์ง„์ง„ํ•˜์ง€ ์•Š์•„? ๐Ÿ”ฌ

๐Ÿ’ผ ์‹ค์ œ ์‘์šฉ ์‚ฌ๋ก€

์œ ์ฒด์—ญํ•™ ์‹œ๋ฎฌ๋ ˆ์ด์…˜

๋‚˜๋น„์—-์Šคํ† ํฌ์Šค ๋ฐฉ์ •์‹(Navier-Stokes equations)์€ ์œ ์ฒด์˜ ์šด๋™์„ ๊ธฐ์ˆ ํ•˜๋Š” ๊ฐ€์žฅ ์ค‘์š”ํ•œ ๋ฐฉ์ •์‹์ด์•ผ. ํ•˜์ง€๋งŒ ํ•ด์„์ ์œผ๋กœ ํ’€๊ธฐ ์ •๋ง ์–ด๋ ค์›Œ์„œ ๋ฐ€๋ ˆ๋‹ˆ์—„ ๋ฌธ์ œ ์ค‘ ํ•˜๋‚˜๋กœ ์„ ์ •๋˜๊ธฐ๋„ ํ–ˆ์ง€. ๐Ÿ˜ฑ

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

# 2D ๋น„์••์ถ•์„ฑ ๋‚˜๋น„์—-์Šคํ† ํฌ์Šค ๋ฐฉ์ •์‹
# โˆ‚u/โˆ‚t + uยทโˆ‚u/โˆ‚x + vยทโˆ‚u/โˆ‚y = -โˆ‚p/โˆ‚x + ฮฝยทโˆ‡ยฒu
# โˆ‚v/โˆ‚t + uยทโˆ‚v/โˆ‚x + vยทโˆ‚v/โˆ‚y = -โˆ‚p/โˆ‚y + ฮฝยทโˆ‡ยฒv
# โˆ‚u/โˆ‚x + โˆ‚v/โˆ‚y = 0 (์—ฐ์† ๋ฐฉ์ •์‹)

class NavierStokesPINN(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(3, 100),  # ์ž…๋ ฅ: x, y, t
            nn.Tanh(),
            nn.Linear(100, 100),
            nn.Tanh(),
            nn.Linear(100, 100),
            nn.Tanh(),
            nn.Linear(100, 3)   # ์ถœ๋ ฅ: u, v, p
        )
    
    def forward(self, x, y, t):
        inputs = torch.cat([x, y, t], dim=1)
        output = self.net(inputs)
        u = output[:, 0:1]  # x ๋ฐฉํ–ฅ ์†๋„
        v = output[:, 1:2]  # y ๋ฐฉํ–ฅ ์†๋„
        p = output[:, 2:3]  # ์••๋ ฅ
        return u, v, p

def navier_stokes_loss(model, x, y, t, nu=0.01):
    x.requires_grad = True
    y.requires_grad = True
    t.requires_grad = True
    
    u, v, p = model(x, y, t)
    
    # ์†๋„์˜ ๋„ํ•จ์ˆ˜ ๊ณ„์‚ฐ
    u_t = torch.autograd.grad(u, t, grad_outputs=torch.ones_like(u),
                              create_graph=True)[0]
    u_x = torch.autograd.grad(u, x, grad_outputs=torch.ones_like(u),
                              create_graph=True)[0]
    u_y = torch.autograd.grad(u, y, grad_outputs=torch.ones_like(u),
                              create_graph=True)[0]
    u_xx = torch.autograd.grad(u_x, x, grad_outputs=torch.ones_like(u_x),
                               create_graph=True)[0]
    u_yy = torch.autograd.grad(u_y, y, grad_outputs=torch.ones_like(u_y),
                               create_graph=True)[0]
    
    v_t = torch.autograd.grad(v, t, grad_outputs=torch.ones_like(v),
                              create_graph=True)[0]
    v_x = torch.autograd.grad(v, x, grad_outputs=torch.ones_like(v),
                              create_graph=True)[0]
    v_y = torch.autograd.grad(v, y, grad_outputs=torch.ones_like(v),
                              create_graph=True)[0]
    v_xx = torch.autograd.grad(v_x, x, grad_outputs=torch.ones_like(v_x),
                               create_graph=True)[0]
    v_yy = torch.autograd.grad(v_y, y, grad_outputs=torch.ones_like(v_y),
                               create_graph=True)[0]
    
    # ์••๋ ฅ์˜ ๋„ํ•จ์ˆ˜
    p_x = torch.autograd.grad(p, x, grad_outputs=torch.ones_like(p),
                              create_graph=True)[0]
    p_y = torch.autograd.grad(p, y, grad_outputs=torch.ones_like(p),
                              create_graph=True)[0]
    
    # ์šด๋™๋Ÿ‰ ๋ฐฉ์ •์‹ ์ž”์ฐจ
    f_u = u_t + u*u_x + v*u_y + p_x - nu*(u_xx + u_yy)
    f_v = v_t + u*v_x + v*v_y + p_y - nu*(v_xx + v_yy)
    
    # ์—ฐ์† ๋ฐฉ์ •์‹ ์ž”์ฐจ
    f_cont = u_x + v_y
    
    loss = torch.mean(f_u**2) + torch.mean(f_v**2) + torch.mean(f_cont**2)
    return loss

์žฌ๋ฃŒ ๊ณผํ•™

์žฌ๋ฃŒ์˜ ์—ด์ฒ˜๋ฆฌ ๊ณผ์ •์ด๋‚˜ ์‘๋ ฅ ๋ถ„ํฌ๋ฅผ ์˜ˆ์ธกํ•˜๋Š” ๋ฐ๋„ PINNs๊ฐ€ ํ™œ์šฉ๋ผ. ํŠนํžˆ ์‹คํ—˜์œผ๋กœ ์ธก์ •ํ•˜๊ธฐ ์–ด๋ ค์šด ๋‚ด๋ถ€ ์ƒํƒœ๋ฅผ ์ถ”์ •ํ•˜๋Š” ๋ฐ ์œ ์šฉํ•˜์ง€. ๐Ÿ”ฉ

๊ธˆ์œต ๊ณตํ•™

๋ธ”๋ž™-์ˆ„์ฆˆ ๋ฐฉ์ •์‹์ด๋‚˜ ํ—ค์Šคํ„ด ๋ชจ๋ธ ๊ฐ™์€ ๊ธˆ์œต ํŒŒ์ƒ์ƒํ’ˆ ๊ฐ€๊ฒฉ ๊ฒฐ์ • ๋ชจ๋ธ๋„ ํŽธ๋ฏธ๋ถ„๋ฐฉ์ •์‹์ด์•ผ. PINNs๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ๋ณต์žกํ•œ ์˜ต์…˜ ๊ฐ€๊ฒฉ์„ ๋น ๋ฅด๊ฒŒ ๊ณ„์‚ฐํ•  ์ˆ˜ ์žˆ์–ด. ๐Ÿ’ฐ

์˜๋ฃŒ ์˜์ƒ

MRI๋‚˜ CT ์ด๋ฏธ์ง€ ์žฌ๊ตฌ์„ฑ ๋ฌธ์ œ๋„ ์—ญ๋ฌธ์ œ์˜ ์ผ์ข…์ด์•ผ. PINNs๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ์ ์€ ์ˆ˜์˜ ์ธก์ •์œผ๋กœ๋„ ๊ณ ํ’ˆ์งˆ ์ด๋ฏธ์ง€๋ฅผ ๋ณต์›ํ•  ์ˆ˜ ์žˆ์–ด. ์ด๋Š” ํ™˜์ž์˜ ๋ฐฉ์‚ฌ์„  ๋…ธ์ถœ์„ ์ค„์ด๋Š” ๋ฐ ๋„์›€์ด ๋ผ. ๐Ÿฅ

๐Ÿ› ๏ธ ์‹ค์ „ ํ”„๋กœ์ ํŠธ ๊ฐ€์ด๋“œ

์ž, ์ด์ œ ์‹ค์ œ๋กœ ํ”„๋กœ์ ํŠธ๋ฅผ ์‹œ์ž‘ํ•œ๋‹ค๋ฉด ์–ด๋–ค ๋‹จ๊ณ„๋ฅผ ๊ฑฐ์ณ์•ผ ํ• ๊นŒ? ์ฒด๊ณ„์ ์ธ ์ ‘๊ทผ๋ฒ•์„ ์•Œ๋ ค์ค„๊ฒŒ! ๐Ÿ“‹

1๋‹จ๊ณ„: ๋ฌธ์ œ ์ •์˜ ๋ฐ ๋ถ„์„

โœ… ์ฒดํฌ๋ฆฌ์ŠคํŠธ โ–ก ํ’€๊ณ ์ž ํ•˜๋Š” ๋ฏธ๋ถ„๋ฐฉ์ •์‹์ด ๋ช…ํ™•ํžˆ ์ •์˜๋˜์–ด ์žˆ๋Š”๊ฐ€?
โ–ก ์ดˆ๊ธฐ์กฐ๊ฑด๊ณผ ๊ฒฝ๊ณ„์กฐ๊ฑด์ด ๋ชจ๋‘ ๋ช…์‹œ๋˜์–ด ์žˆ๋Š”๊ฐ€?
โ–ก ํ•ด์˜ ์ •์„ฑ์  ํŠน์„ฑ(๋ถ€๋“œ๋Ÿฌ์›€, ๋Œ€์นญ์„ฑ ๋“ฑ)์„ ์•Œ๊ณ  ์žˆ๋Š”๊ฐ€?
โ–ก ๊ฒ€์ฆ์„ ์œ„ํ•œ ํ•ด์„ํ•ด๋‚˜ ์ฐธ์กฐ ๋ฐ์ดํ„ฐ๊ฐ€ ์žˆ๋Š”๊ฐ€?
โ–ก ๊ณ„์‚ฐ ์ž์›(GPU, ์‹œ๊ฐ„)์ด ์ถฉ๋ถ„ํ•œ๊ฐ€?

2๋‹จ๊ณ„: ๋„คํŠธ์›Œํฌ ์•„ํ‚คํ…์ฒ˜ ์„ค๊ณ„

๋ฌธ์ œ์˜ ํŠน์„ฑ์— ๋”ฐ๋ผ ์ ์ ˆํ•œ ๋„คํŠธ์›Œํฌ ๊ตฌ์กฐ๋ฅผ ์„ ํƒํ•ด์•ผ ํ•ด:

๋ฌธ์ œ ์œ ํ˜• ๊ถŒ์žฅ ๊ตฌ์กฐ ํŠน์ง•
๋ถ€๋“œ๋Ÿฌ์šด ํ•ด 3-5์ธต, ๊ฐ 20-50 ๋‰ด๋Ÿฐ ๋น ๋ฅธ ํ•™์Šต, ์ ์€ ํŒŒ๋ผ๋ฏธํ„ฐ
๋ณต์žกํ•œ ํ•ด 5-8์ธต, ๊ฐ 50-100 ๋‰ด๋Ÿฐ ๋†’์€ ํ‘œํ˜„๋ ฅ
๊ณ ์ฃผํŒŒ ์„ฑ๋ถ„ Fourier Features + 3-5์ธต ์ง„๋™ ํŒจํ„ด ์ž˜ ํฌ์ฐฉ
๋‹ค์ค‘ ์Šค์ผ€์ผ Residual ์—ฐ๊ฒฐ + ๊นŠ์€ ๋„คํŠธ์›Œํฌ ๋‹ค์–‘ํ•œ ์Šค์ผ€์ผ ๋™์‹œ ํ•™์Šต

3๋‹จ๊ณ„: ํ•™์Šต ๋ฐ์ดํ„ฐ ์ƒ์„ฑ

import numpy as np
import torch

def generate_collocation_points(n_interior, n_boundary, n_initial, domain):
    """
    ์ฝœ๋กœ์ผ€์ด์…˜ ํฌ์ธํŠธ ์ƒ์„ฑ
    
    Args:
        n_interior: ์˜์—ญ ๋‚ด๋ถ€ ํฌ์ธํŠธ ์ˆ˜
        n_boundary: ๊ฒฝ๊ณ„ ํฌ์ธํŠธ ์ˆ˜
        n_initial: ์ดˆ๊ธฐ ํฌ์ธํŠธ ์ˆ˜
        domain: {'x': [x_min, x_max], 't': [t_min, t_max]}
    """
    # ๋‚ด๋ถ€ ํฌ์ธํŠธ (Latin Hypercube Sampling ์‚ฌ์šฉํ•˜๋ฉด ๋” ์ข‹์Œ)
    x_interior = torch.rand(n_interior, 1) * (domain['x'][1] - domain['x'][0]) + domain['x'][0]
    t_interior = torch.rand(n_interior, 1) * (domain['t'][1] - domain['t'][0]) + domain['t'][0]
    
    # ๊ฒฝ๊ณ„ ํฌ์ธํŠธ
    t_boundary = torch.rand(n_boundary, 1) * (domain['t'][1] - domain['t'][0]) + domain['t'][0]
    x_boundary_left = torch.full((n_boundary//2, 1), domain['x'][0])
    x_boundary_right = torch.full((n_boundary//2, 1), domain['x'][1])
    x_boundary = torch.cat([x_boundary_left, x_boundary_right], dim=0)
    
    # ์ดˆ๊ธฐ ํฌ์ธํŠธ
    x_initial = torch.rand(n_initial, 1) * (domain['x'][1] - domain['x'][0]) + domain['x'][0]
    t_initial = torch.full((n_initial, 1), domain['t'][0])
    
    return {
        'interior': (x_interior, t_interior),
        'boundary': (x_boundary, t_boundary),
        'initial': (x_initial, t_initial)
    }

# ์‚ฌ์šฉ ์˜ˆ์‹œ
domain = {'x': [0, 1], 't': [0, 1]}
points = generate_collocation_points(1000, 200, 100, domain)

4๋‹จ๊ณ„: ํ•™์Šต ๋ฐ ๋ชจ๋‹ˆํ„ฐ๋ง

ํ•™์Šต ๊ณผ์ •์„ ์ž˜ ๋ชจ๋‹ˆํ„ฐ๋งํ•˜๋Š” ๊ฒŒ ์ •๋ง ์ค‘์š”ํ•ด. ๋‹ค์Œ๊ณผ ๊ฐ™์€ ์ง€ํ‘œ๋“ค์„ ์ถ”์ ํ•ด์•ผ ํ•ด:

import wandb  # Weights & Biases (์„ ํƒ์‚ฌํ•ญ)

class TrainingMonitor:
    def __init__(self, use_wandb=False):
        self.history = {
            'total_loss': [],
            'pde_loss': [],
            'ic_loss': [],
            'bc_loss': []
        }
        self.use_wandb = use_wandb
        if use_wandb:
            wandb.init(project="pinn-heat-equation")
    
    def log(self, epoch, losses):
        for key, value in losses.items():
            self.history[key].append(value)
        
        if self.use_wandb:
            wandb.log(losses, step=epoch)
        
        # ์ฃผ๊ธฐ์ ์œผ๋กœ ์ถœ๋ ฅ
        if (epoch + 1) % 100 == 0:
            print(f"Epoch {epoch+1}:")
            for key, value in losses.items():
                print(f"  {key}: {value:.6f}")
    
    def plot_history(self):
        import matplotlib.pyplot as plt
        
        fig, axes = plt.subplots(2, 2, figsize=(12, 10))
        axes = axes.flatten()
        
        for idx, (key, values) in enumerate(self.history.items()):
            axes[idx].plot(values)
            axes[idx].set_title(key)
            axes[idx].set_xlabel('Epoch')
            axes[idx].set_ylabel('Loss')
            axes[idx].set_yscale('log')
            axes[idx].grid(True)
        
        plt.tight_layout()
        plt.savefig('training_history.png')
        plt.show()

# ์‚ฌ์šฉ ์˜ˆ์‹œ
monitor = TrainingMonitor(use_wandb=False)

for epoch in range(epochs):
    # ... ํ•™์Šต ์ฝ”๋“œ ...
    
    losses = {
        'total_loss': total_loss.item(),
        'pde_loss': loss_pde.item(),
        'ic_loss': loss_ic.item(),
        'bc_loss': loss_bc.item()
    }
    monitor.log(epoch, losses)

monitor.plot_history()

5๋‹จ๊ณ„: ๊ฒฐ๊ณผ ๊ฒ€์ฆ ๋ฐ ์‹œ๊ฐํ™”

ํ•™์Šต์ด ์™„๋ฃŒ๋˜๋ฉด ๊ฒฐ๊ณผ๋ฅผ ์ฒ ์ €ํžˆ ๊ฒ€์ฆํ•ด์•ผ ํ•ด. ์—ฌ๋Ÿฌ ๊ฐ๋„์—์„œ ๋ถ„์„ํ•˜๋Š” ๊ฒŒ ์ค‘์š”ํ•ด! ๐Ÿ”

def validate_solution(model, analytical_solution=None):
    """
    ํ•™์Šต๋œ ๋ชจ๋ธ ๊ฒ€์ฆ
    """
    # ํ…Œ์ŠคํŠธ ๊ทธ๋ฆฌ๋“œ ์ƒ์„ฑ
    x_test = torch.linspace(0, 1, 100).reshape(-1, 1)
    t_test = torch.linspace(0, 1, 100).reshape(-1, 1)
    X, T = torch.meshgrid(x_test.squeeze(), t_test.squeeze(), indexing='ij')
    X_flat = X.reshape(-1, 1)
    T_flat = T.reshape(-1, 1)
    
    # ์˜ˆ์ธก
    with torch.no_grad():
        U_pred = model(X_flat, T_flat).reshape(100, 100)
    
    # ํ•ด์„ํ•ด์™€ ๋น„๊ต (์žˆ๋Š” ๊ฒฝ์šฐ)
    if analytical_solution is not None:
        U_exact = analytical_solution(X, T)
        error = torch.abs(U_pred - U_exact)
        relative_error = torch.mean(error) / torch.mean(torch.abs(U_exact))
        
        print(f"ํ‰๊ท  ์ ˆ๋Œ€ ์˜ค์ฐจ: {torch.mean(error):.6f}")
        print(f"์ƒ๋Œ€ ์˜ค์ฐจ: {relative_error:.6f}")
        
        # ์‹œ๊ฐํ™”
        import matplotlib.pyplot as plt
        
        fig, axes = plt.subplots(1, 3, figsize=(18, 5))
        
        im1 = axes[0].contourf(X.numpy(), T.numpy(), U_pred.numpy(), levels=50, cmap='viridis')
        axes[0].set_title('์˜ˆ์ธก ํ•ด')
        axes[0].set_xlabel('x')
        axes[0].set_ylabel('t')
        plt.colorbar(im1, ax=axes[0])
        
        im2 = axes[1].contourf(X.numpy(), T.numpy(), U_exact.numpy(), levels=50, cmap='viridis')
        axes[1].set_title('ํ•ด์„ ํ•ด')
        axes[1].set_xlabel('x')
        axes[1].set_ylabel('t')
        plt.colorbar(im2, ax=axes[1])
        
        im3 = axes[2].contourf(X.numpy(), T.numpy(), error.numpy(), levels=50, cmap='hot')
        axes[2].set_title('์ ˆ๋Œ€ ์˜ค์ฐจ')
        axes[2].set_xlabel('x')
        axes[2].set_ylabel('t')
        plt.colorbar(im3, ax=axes[2])
        
        plt.tight_layout()
        plt.savefig('solution_comparison.png', dpi=300)
        plt.show()
    
    return U_pred

# ์—ด๋ฐฉ์ •์‹์˜ ํ•ด์„ํ•ด
def heat_analytical(X, T, alpha=0.01):
    return torch.exp(-alpha * np.pi**2 * T) * torch.sin(np.pi * X)

# ๊ฒ€์ฆ ์‹คํ–‰
U_pred = validate_solution(model, heat_analytical)

๐ŸŽ“ ํ•™์Šต ๋ฆฌ์†Œ์Šค ๋ฐ ์ปค๋ฎค๋‹ˆํ‹ฐ

PINNs๋ฅผ ๋” ๊นŠ์ด ๊ณต๋ถ€ํ•˜๊ณ  ์‹ถ๋‹ค๋ฉด, ๋‹ค์Œ ๋ฆฌ์†Œ์Šค๋“ค์„ ์ถ”์ฒœํ•ด:

๐Ÿ“š ์ถ”์ฒœ ์ž๋ฃŒ ๋…ผ๋ฌธ:
โ€ข Raissi et al. (2019) - "Physics-informed neural networks: A deep learning framework for solving forward and inverse problems"
โ€ข Lu et al. (2021) - "DeepONet: Learning nonlinear operators"
โ€ข Li et al. (2020) - "Fourier Neural Operator"

์ฝ”๋“œ ์ €์žฅ์†Œ:
โ€ข GitHub: maziarraissi/PINNs
โ€ข GitHub: lululxvi/deepxde (๊ณ ์ˆ˜์ค€ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ)
โ€ข GitHub: neuraloperator/neuraloperator

์˜จ๋ผ์ธ ๊ฐ•์˜:
โ€ข Steve Brunton์˜ YouTube ์ฑ„๋„
โ€ข MIT์˜ "Introduction to Computational Thinking"
โ€ข Coursera์˜ "Deep Learning Specialization"

๋˜ํ•œ ์žฌ๋Šฅ๋„ท(https://www.jaenung.net)์—์„œ๋Š” ์ด๋Ÿฐ ๊ณ ๊ธ‰ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๊ธฐ์ˆ ์„ ๋ฐฐ์šฐ๊ฑฐ๋‚˜ ๊ฐ€๋ฅด์น  ์ˆ˜ ์žˆ๋Š” ๊ธฐํšŒ๋„ ์žˆ์–ด. ์ „๋ฌธ๊ฐ€์—๊ฒŒ 1:1๋กœ ๋ฐฐ์šฐ๊ฑฐ๋‚˜, ์ž์‹ ์˜ ์ง€์‹์„ ๊ณต์œ ํ•˜๋ฉด์„œ ์ˆ˜์ต๋„ ์–ป์„ ์ˆ˜ ์žˆ์ง€! ๐Ÿ˜Š

๐Ÿš€ ๋ฏธ๋ž˜ ์ „๋ง

PINNs์™€ ์‹ ๊ฒฝ๋ง ๊ธฐ๋ฐ˜ ๋ฏธ๋ถ„๋ฐฉ์ •์‹ ํ•ด๋ฒ•์€ ์•„์ง ๋ฐœ์ „ ์ดˆ๊ธฐ ๋‹จ๊ณ„์•ผ. ์•ž์œผ๋กœ ์–ด๋–ค ๋ฐœ์ „์ด ์žˆ์„๊นŒ? ๐Ÿ”ฎ

ํ•˜๋“œ์›จ์–ด ๊ฐ€์†

GPU๋ฟ๋งŒ ์•„๋‹ˆ๋ผ TPU, ๊ทธ๋ฆฌ๊ณ  ์–‘์ž ์ปดํ“จํ„ฐ๊นŒ์ง€ ํ™œ์šฉํ•˜๋Š” ์—ฐ๊ตฌ๊ฐ€ ์ง„ํ–‰ ์ค‘์ด์•ผ. ํŠนํžˆ Google์˜ TPU๋Š” ํ–‰๋ ฌ ์—ฐ์‚ฐ์— ์ตœ์ ํ™”๋˜์–ด ์žˆ์–ด์„œ ์‹ ๊ฒฝ๋ง ํ•™์Šต์— ์ •๋ง ํšจ๊ณผ์ ์ด์ง€.

์ž๋™ํ™”๋œ ๋ชจ๋ธ ์„ค๊ณ„

Neural Architecture Search (NAS) ๊ธฐ์ˆ ์„ PINNs์— ์ ์šฉํ•˜๋Š” ์—ฐ๊ตฌ๋„ ์žˆ์–ด. ๋ฌธ์ œ์— ๋งž๋Š” ์ตœ์ ์˜ ๋„คํŠธ์›Œํฌ ๊ตฌ์กฐ๋ฅผ ์ž๋™์œผ๋กœ ์ฐพ์•„์ฃผ๋Š” ๊ฑฐ์•ผ. ์ด๋ ‡๊ฒŒ ๋˜๋ฉด ์ „๋ฌธ ์ง€์‹์ด ์—†์–ด๋„ PINNs๋ฅผ ์‰ฝ๊ฒŒ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๊ฒŒ ๋  ๊ฑฐ์•ผ! ๐Ÿค–

ํ•˜์ด๋ธŒ๋ฆฌ๋“œ ์ ‘๊ทผ๋ฒ•

์ „ํ†ต์ ์ธ ์ˆ˜์น˜ํ•ด์„ ๋ฐฉ๋ฒ•๊ณผ ์‹ ๊ฒฝ๋ง์„ ๊ฒฐํ•ฉํ•˜๋Š” ํ•˜์ด๋ธŒ๋ฆฌ๋“œ ๋ฐฉ๋ฒ•๋„ ์ฃผ๋ชฉ๋ฐ›๊ณ  ์žˆ์–ด. ๊ฐ ๋ฐฉ๋ฒ•์˜ ์žฅ์ ์„ ์‚ด๋ ค์„œ ๋” ๊ฐ•๋ ฅํ•œ ์†”๋ฒ„๋ฅผ ๋งŒ๋“œ๋Š” ๊ฑฐ์ง€. ์˜ˆ๋ฅผ ๋“ค์–ด:

๐Ÿ”„ ํ•˜์ด๋ธŒ๋ฆฌ๋“œ ์ „๋žต โ€ข ๊ฑฐ์นœ ๋ฉ”์‰ฌ๋กœ ์ „ํ†ต์  ๋ฐฉ๋ฒ• โ†’ ์‹ ๊ฒฝ๋ง์œผ๋กœ ์„ธ๋ฐ€ํ™”
โ€ข ์‹ ๊ฒฝ๋ง์œผ๋กœ ์ดˆ๊ธฐ ์ถ”์ • โ†’ ์ „ํ†ต์  ๋ฐฉ๋ฒ•์œผ๋กœ ์ •๋ฐ€ํ™”
โ€ข ์˜์—ญ๋ณ„๋กœ ๋‹ค๋ฅธ ๋ฐฉ๋ฒ• ์ ์šฉ (๋„๋ฉ”์ธ ๋ถ„ํ•ด)
โ€ข ๋ฉ€ํ‹ฐ์Šค์ผ€์ผ ๋ฌธ์ œ์—์„œ ์Šค์ผ€์ผ๋ณ„ ๋‹ค๋ฅธ ์ ‘๊ทผ

์‹ค์‹œ๊ฐ„ ์‹œ๋ฎฌ๋ ˆ์ด์…˜

ํ•™์Šต๋œ PINNs ๋ชจ๋ธ์€ ์ถ”๋ก ์ด ๋งค์šฐ ๋น ๋ฅด๊ธฐ ๋•Œ๋ฌธ์—, ์‹ค์‹œ๊ฐ„ ์‹œ๋ฎฌ๋ ˆ์ด์…˜์ด๋‚˜ ์ œ์–ด์— ํ™œ์šฉ๋  ์ˆ˜ ์žˆ์–ด. ์˜ˆ๋ฅผ ๋“ค์–ด ์ž์œจ์ฃผํ–‰์ฐจ์˜ ๊ณต๊ธฐ์—ญํ•™ ์‹œ๋ฎฌ๋ ˆ์ด์…˜์„ ์‹ค์‹œ๊ฐ„์œผ๋กœ ์ˆ˜ํ–‰ํ•˜๊ฑฐ๋‚˜, ๋กœ๋ด‡์˜ ๋™์—ญํ•™์„ ์ฆ‰์‹œ ๊ณ„์‚ฐํ•  ์ˆ˜ ์žˆ์ง€. ๐ŸŽ๏ธ

๊ณผํ•™์  ๋ฐœ๊ฒฌ

๊ฐ€์žฅ ํฅ๋ฏธ๋กœ์šด ๊ฐ€๋Šฅ์„ฑ์€ ์ƒˆ๋กœ์šด ๋ฌผ๋ฆฌ ๋ฒ•์น™์˜ ๋ฐœ๊ฒฌ์ด์•ผ. ๋ฐ์ดํ„ฐ๋กœ๋ถ€ํ„ฐ ์ง€๋ฐฐ ๋ฐฉ์ •์‹์„ ์—ญ์œผ๋กœ ์ถ”๋ก ํ•˜๋Š” ์—ฐ๊ตฌ๊ฐ€ ํ™œ๋ฐœํ•œ๋ฐ, ์ด๋ฅผ ํ†ตํ•ด ์•„์ง ์•Œ๋ ค์ง€์ง€ ์•Š์€ ํ˜„์ƒ์„ ์ˆ˜ํ•™์ ์œผ๋กœ ๊ธฐ์ˆ ํ•  ์ˆ˜ ์žˆ์„ ๊ฑฐ์•ผ. ๐ŸŒŒ

๐Ÿ’ก ์‹ค๋ฌด ํŒ๊ณผ ๋…ธํ•˜์šฐ

๋งˆ์ง€๋ง‰์œผ๋กœ, ์‹ค์ œ๋กœ PINNs๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด์„œ ์–ป์€ ์‹ค๋ฌด ํŒ๋“ค์„ ๊ณต์œ ํ• ๊ฒŒ! ์ด๊ฑด ๋…ผ๋ฌธ์—๋Š” ์ž˜ ์•ˆ ๋‚˜์˜ค๋Š” ๋‚ด์šฉ๋“ค์ด์•ผ. ๐Ÿ˜‰

๋””๋ฒ„๊น… ์ „๋žต

def debug_pinn(model, x, t):
    """
    PINNs ๋””๋ฒ„๊น…์„ ์œ„ํ•œ ์œ ํ‹ธ๋ฆฌํ‹ฐ
    """
    x.requires_grad = True
    t.requires_grad = True
    
    u = model(x, t)
    
    # ๊ทธ๋ž˜๋””์–ธํŠธ ์ฒดํฌ
    u_x = torch.autograd.grad(u, x, grad_outputs=torch.ones_like(u),
                              create_graph=True)[0]
    
    print("=== ๋””๋ฒ„๊น… ์ •๋ณด ===")
    print(f"์ž…๋ ฅ ๋ฒ”์œ„: x=[{x.min():.3f}, {x.max():.3f}], t=[{t.min():.3f}, {t.max():.3f}]")
    print(f"์ถœ๋ ฅ ๋ฒ”์œ„: u=[{u.min():.3f}, {u.max():.3f}]")
    print(f"๋„ํ•จ์ˆ˜ ๋ฒ”์œ„: u_x=[{u_x.min():.3f}, {u_x.max():.3f}]")
    print(f"๊ทธ๋ž˜๋””์–ธํŠธ ์กด์žฌ: {u.grad is not None}")
    
    # NaN ์ฒดํฌ
    if torch.isnan(u).any():
        print("โš ๏ธ ๊ฒฝ๊ณ : ์ถœ๋ ฅ์— NaN ๋ฐœ๊ฒฌ!")
    if torch.isnan(u_x).any():
        print("โš ๏ธ ๊ฒฝ๊ณ : ๋„ํ•จ์ˆ˜์— NaN ๋ฐœ๊ฒฌ!")
    
    # ๊ฐ€์ค‘์น˜ ํ†ต๊ณ„
    for name, param in model.named_parameters():
        print(f"{name}: mean={param.mean():.6f}, std={param.std():.6f}")
    
    return u, u_x

# ์‚ฌ์šฉ ์˜ˆ์‹œ
x_debug = torch.linspace(0, 1, 10).reshape(-1, 1)
t_debug = torch.linspace(0, 1, 10).reshape(-1, 1)
debug_pinn(model, x_debug, t_debug)

ํ•˜์ดํผํŒŒ๋ผ๋ฏธํ„ฐ ํŠœ๋‹

PINNs์˜ ์„ฑ๋Šฅ์€ ํ•˜์ดํผํŒŒ๋ผ๋ฏธํ„ฐ์— ๋ฏผ๊ฐํ•ด. ๋‹ค์Œ์€ ๊ฒฝํ—˜์ ์œผ๋กœ ์ž˜ ์ž‘๋™ํ•˜๋Š” ์„ค์ •๋“ค์ด์•ผ:

ํ•˜์ดํผํŒŒ๋ผ๋ฏธํ„ฐ ๊ถŒ์žฅ ๋ฒ”์œ„ ์กฐ์ • ํŒ
ํ•™์Šต๋ฅ  1e-4 ~ 1e-2 Adam: 1e-3, L-BFGS: 1.0
๋ฐฐ์น˜ ํฌ๊ธฐ ์ „์ฒด ๋ฐ์ดํ„ฐ PINNs๋Š” ๋ณดํ†ต full-batch
์€๋‹‰์ธต ์ˆ˜ 3 ~ 8 ๋ณต์žก๋„์— ๋”ฐ๋ผ ์กฐ์ •
๋‰ด๋Ÿฐ ์ˆ˜ 20 ~ 100 ์ธต๋งˆ๋‹ค ๊ฐ™๊ฑฐ๋‚˜ ์ ์ง„์  ๊ฐ์†Œ
ํ™œ์„ฑํ™” ํ•จ์ˆ˜ tanh, sin ๋ถ€๋“œ๋Ÿฌ์šด ํ•จ์ˆ˜ ์„ ํ˜ธ
์†์‹ค ๊ฐ€์ค‘์น˜ 1 ~ 100 ๊ฐ ํ•ญ์˜ ํฌ๊ธฐ ๊ท ํ˜• ๋งž์ถ”๊ธฐ

์„ฑ๋Šฅ ์ตœ์ ํ™”

# GPU ๋ฉ”๋ชจ๋ฆฌ ํšจ์œจ์  ์‚ฌ์šฉ
def efficient_training(model, data, batch_size=None):
    """
    ๋ฉ”๋ชจ๋ฆฌ ํšจ์œจ์ ์ธ ํ•™์Šต
    """
    if batch_size is None:
        # ์ „์ฒด ๋ฐ์ดํ„ฐ ์‚ฌ์šฉ
        return standard_training(model, data)
    
    # ๋ฏธ๋‹ˆ๋ฐฐ์น˜ ํ•™์Šต (๋ฉ”๋ชจ๋ฆฌ ๋ถ€์กฑ์‹œ)
    n_samples = len(data['x'])
    indices = torch.randperm(n_samples)
    
    total_loss = 0
    for i in range(0, n_samples, batch_size):
        batch_indices = indices[i:i+batch_size]
        x_batch = data['x'][batch_indices]
        t_batch = data['t'][batch_indices]
        
        loss = compute_loss(model, x_batch, t_batch)
        loss.backward()
        
        total_loss += loss.item()
    
    return total_loss / (n_samples // batch_size)

# Mixed Precision Training (๋” ๋น ๋ฅธ ํ•™์Šต)
from torch.cuda.amp import autocast, GradScaler

scaler = GradScaler()

for epoch in range(epochs):
    optimizer.zero_grad()
    
    with autocast():
        loss = compute_loss(model, x, t)
    
    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()

์žฌํ˜„์„ฑ ๋ณด์žฅ

import random
import numpy as np
import torch

def set_seed(seed=42):
    """
    ์žฌํ˜„ ๊ฐ€๋Šฅํ•œ ๊ฒฐ๊ณผ๋ฅผ ์œ„ํ•œ ์‹œ๋“œ ์„ค์ •
    """
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)
    
    # ๊ฒฐ์ •๋ก ์  ๋™์ž‘ (์•ฝ๊ฐ„ ๋А๋ ค์งˆ ์ˆ˜ ์žˆ์Œ)
    torch.backends.cudnn.deterministic = True
    torch.backends.cudnn.benchmark = False

# ํ”„๋กœ์ ํŠธ ์‹œ์ž‘์‹œ ํ˜ธ์ถœ
set_seed(42)

๐ŸŽฏ ๋งˆ๋ฌด๋ฆฌํ•˜๋ฉฐ

์™€, ์ •๋ง ๊ธด ์—ฌ์ •์ด์—ˆ์ง€? ๐Ÿ˜… ์šฐ๋ฆฌ๋Š” ์‹ ๊ฒฝ๋ง์„ ์ด์šฉํ•œ ๋ฏธ๋ถ„๋ฐฉ์ •์‹ ํ•ด๋ฒ•์˜ ๊ธฐ์ดˆ๋ถ€ํ„ฐ ๊ณ ๊ธ‰ ๊ธฐ๋ฒ•, ์‹ค์ „ ์‘์šฉ๊นŒ์ง€ ๋ชจ๋‘ ์‚ดํŽด๋ดค์–ด.

ํ•ต์‹ฌ์„ ์ •๋ฆฌํ•˜์ž๋ฉด:

๐ŸŽ“ ํ•ต์‹ฌ ์š”์•ฝ 1. PINNs์˜ ๊ธฐ๋ณธ ์•„์ด๋””์–ด: ๋ฌผ๋ฆฌ ๋ฒ•์น™์„ ์†์‹ค ํ•จ์ˆ˜์— ์ง์ ‘ ํฌํ•จ
2. ์ž๋™ ๋ฏธ๋ถ„์˜ ํ™œ์šฉ: ๋ณต์žกํ•œ ๋„ํ•จ์ˆ˜๋„ ์‰ฝ๊ฒŒ ๊ณ„์‚ฐ
3. ๋‹ค์–‘ํ•œ ์‘์šฉ: ์œ ์ฒด์—ญํ•™, ์žฌ๋ฃŒ๊ณผํ•™, ๊ธˆ์œต, ์˜๋ฃŒ ๋“ฑ
4. ์‹ค๋ฌด ๋…ธํ•˜์šฐ: ๋””๋ฒ„๊น…, ์ตœ์ ํ™”, ๊ฒ€์ฆ ์ „๋žต
5. ๋ฏธ๋ž˜ ์ „๋ง: ํ•˜์ด๋ธŒ๋ฆฌ๋“œ ๋ฐฉ๋ฒ•, ์‹ค์‹œ๊ฐ„ ์‹œ๋ฎฌ๋ ˆ์ด์…˜, ๊ณผํ•™์  ๋ฐœ๊ฒฌ

PINNs๋Š” ์•„์ง ์™„๋ฒฝํ•˜์ง€ ์•Š์•„. ์ˆ˜๋ ด ์†๋„, ๊ณ ์ฐจ์› ๋ฌธ์ œ, ๋ณต์žกํ•œ ๊ธฐํ•˜ํ•™ ๋“ฑ ํ•ด๊ฒฐํ•ด์•ผ ํ•  ๊ณผ์ œ๋“ค์ด ๋‚จ์•„์žˆ์ง€. ํ•˜์ง€๋งŒ ๊ทธ๋งŒํผ ๋ฐœ์ „ ๊ฐ€๋Šฅ์„ฑ๋„ ํฌ๊ณ , ์—ฐ๊ตฌํ•  ๊ฑฐ๋ฆฌ๋„ ๋งŽ๋‹ค๋Š” ๋œป์ด์•ผ! ๐Ÿš€

์ด ๋ถ„์•ผ๋Š” ์ •๋ง ๋น ๋ฅด๊ฒŒ ๋ฐœ์ „ํ•˜๊ณ  ์žˆ์–ด์„œ, ๋งค๋‹ฌ ์ƒˆ๋กœ์šด ๋…ผ๋ฌธ๊ณผ ๊ธฐ๋ฒ•๋“ค์ด ์Ÿ์•„์ ธ ๋‚˜์™€. ๊ทธ๋Ÿฌ๋‹ˆ ๊ณ„์† ๊ณต๋ถ€ํ•˜๊ณ , ์‹คํ—˜ํ•˜๊ณ , ์ปค๋ฎค๋‹ˆํ‹ฐ์™€ ์†Œํ†ตํ•˜๋Š” ๊ฒŒ ์ค‘์š”ํ•ด.

ํ˜น์‹œ ์ด ๊ธ€์„ ์ฝ๊ณ  PINNs์— ๊ด€์‹ฌ์ด ์ƒ๊ฒผ๋‹ค๋ฉด, ์ง์ ‘ ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•ด๋ณด๋Š” ๊ฑธ ๊ฐ•๋ ฅํžˆ ์ถ”์ฒœํ•ด! ๊ฐ„๋‹จํ•œ 1D ์—ด๋ฐฉ์ •์‹๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ด์„œ ์ ์  ๋ณต์žกํ•œ ๋ฌธ์ œ๋กœ ๋‚˜์•„๊ฐ€๋‹ค ๋ณด๋ฉด, ์–ด๋А์ƒˆ ์ „๋ฌธ๊ฐ€๊ฐ€ ๋˜์–ด ์žˆ์„ ๊ฑฐ์•ผ. ๐Ÿ’ช

๊ทธ๋ฆฌ๊ณ  ํ˜น์‹œ ํ”„๋กœ์ ํŠธ๋ฅผ ์ง„ํ–‰ํ•˜๋ฉด์„œ ๋ง‰ํžˆ๋Š” ๋ถ€๋ถ„์ด ์žˆ๊ฑฐ๋‚˜, ๋” ๊นŠ์ด ๋ฐฐ์šฐ๊ณ  ์‹ถ๋‹ค๋ฉด ์ „๋ฌธ๊ฐ€์˜ ๋„์›€์„ ๋ฐ›๋Š” ๊ฒƒ๋„ ์ข‹์€ ๋ฐฉ๋ฒ•์ด์•ผ. ์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์„ ํ™œ์šฉํ•˜๋ฉด ๊ฒฝํ—˜ ๋งŽ์€ ๊ฐœ๋ฐœ์ž๋‚˜ ์—ฐ๊ตฌ์ž์—๊ฒŒ ๋ฉ˜ํ† ๋ง์„ ๋ฐ›์„ ์ˆ˜ ์žˆ๊ฑฐ๋“ !

์ž, ์ด์ œ ๋‹น์‹  ์ฐจ๋ก€์•ผ! ์‹ ๊ฒฝ๋ง๊ณผ ๋ฏธ๋ถ„๋ฐฉ์ •์‹์˜ ํ™˜์ƒ์ ์ธ ์กฐํ•ฉ์œผ๋กœ ๋ฉ‹์ง„ ํ”„๋กœ์ ํŠธ๋ฅผ ๋งŒ๋“ค์–ด๋ณด์ž! ๐ŸŽ‰โœจ

PINNs๋กœ ์—ฌ๋Š” ์ƒˆ๋กœ์šด ๊ฐ€๋Šฅ์„ฑ ๋น ๋ฅธ ๊ณ„์‚ฐ ๋ฉ”์‰ฌ ๋ถˆํ•„์š” ์—ญ๋ฌธ์ œ ํ•ด๊ฒฐ ๊ณ ์ฐจ์› ๋Œ€์‘ ๋ฐ์ดํ„ฐ ์œตํ•ฉ ํ•จ๊ป˜ ๋งŒ๋“ค์–ด๊ฐ€๋Š” ๋ฏธ๋ž˜์˜ ๊ณผํ•™๊ณ„์‚ฐ

ํ–‰์šด์„ ๋นŒ์–ด! ๋ฉ‹์ง„ ํ”„๋กœ์ ํŠธ ๋งŒ๋“ค๊ธธ ๋ฐ”๋ž„๊ฒŒ! ๐Ÿ€๐Ÿ’ป๐Ÿš€

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

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

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

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