Scientific machine learningScientific machine learning
Now that differential equations feel familiar, here is what modern scientific machine learning does with them. Five ideas, each a different bargain between what we know (the equations) and what we measured (the data) — from a network that obeys a known law, to one that discovers the law, to ones that replace the solver entirely. Everything trains live in your browser.
Setelah persamaan diferensial terasa akrab, inilah yang dilakukan scientific machine learning modern terhadapnya. Lima ide, masing-masing tawar-menawar berbeda antara apa yang kita tahu (persamaannya) dan apa yang kita ukur (datanya) — dari jaringan yang menaati hukum yang diketahui, ke yang justru menemukan hukumnya, sampai yang menggantikan solver sepenuhnya. Semuanya dilatih langsung di browser-mu.
Part 2 of 2 · new here? start withBagian 2 dari 2 · baru di sini? mulai dari ← Differential equationsPersamaan diferensial
A Physics-Informed Neural Network is just a small network that takes time t and outputs a guess u(t). It is trained by two losses at once: a data loss ("pass near my measurements") and a physics loss ("your derivative must obey the differential equation — everywhere"). The magic: with almost no data, the physics term alone carries the solution into regions no measurement ever touched.
Sebuah Physics-Informed Neural Network hanyalah jaringan kecil yang menerima waktu t dan mengeluarkan tebakan u(t). Ia dilatih oleh dua loss sekaligus: sebuah data loss ("lewati dekat pengukuranku") dan sebuah physics loss ("turunanmu harus menaati persamaan diferensial — di mana pun"). Keajaibannya: dengan nyaris tanpa data, suku fisika sendirian membawa solusi ke wilayah yang tak pernah disentuh satu pengukuran pun.
The network: 1 → 32 tanh neurons → 1. Its derivatives u′, u″ are computed exactly (that is what "autodiff" does in real PINN libraries), then punished where they break the equation.
Jaringannya: 1 → 32 neuron tanh → 1. Turunan u′, u″-nya dihitung persis (itulah yang dilakukan "autodiff" di pustaka PINN sungguhan), lalu dihukum di tempat mereka melanggar persamaan.
Red: distance to measurements. Gold: match the known starting condition. Green: how badly the network's own derivative violates the equation at the gold collocation points — no measurements needed there, the rule is checked on the network itself.
Merah: jarak ke pengukuran. Emas: cocokkan kondisi awal yang diketahui. Hijau: seberapa buruk turunan jaringan itu sendiri melanggar persamaan di titik-titik kolokasi emas — tak perlu pengukuran di sana, aturannya diperiksa pada jaringan itu sendiri.
The network never saw the formula for the true solution. It only got: a few noisy dots, a starting value, and the demand "your slope must equal what the equation says, at these gold points." Gradient descent then sculpted the weights until both teachers were satisfied.
Jaringan tak pernah melihat rumus solusi sejati. Ia hanya menerima: beberapa titik berderau, sebuah nilai awal, dan tuntutan "kemiringanmu harus sama dengan yang dikatakan persamaan, di titik-titik emas ini." Gradient descent lalu memahat bobotnya sampai kedua guru puas.
Why people care: real measurements are sparse and noisy (a few sensors on a wing, a few probes in a reactor), but the governing equations are known. PINNs blend both — and unlike the classical grid solvers in part 1, they don't need a grid, handle missing data naturally, and can also run "backwards" (infer λ itself from data — inverse problems). The catch: training is slow and fiddly compared to RK4 when the problem is easy — PINNs shine when classical solvers struggle, not on this toy.
Kenapa orang peduli: pengukuran nyata itu jarang dan berderau (beberapa sensor di sayap, beberapa probe di reaktor), tapi persamaan yang mengaturnya diketahui. PINN memadukan keduanya — dan tidak seperti solver grid klasik di bagian 1, ia tak butuh grid, menangani data hilang secara alami, dan juga bisa berjalan "mundur" (menyimpulkan λ sendiri dari data — masalah invers). Tangkapannya: pelatihan lambat dan rewel dibanding RK4 saat masalahnya mudah — PINN bersinar ketika solver klasik kesulitan, bukan pada mainan ini.
The opposite direction from PINNs: here we don't know the law. We only have a measured trajectory. SINDy (Sparse Identification of Nonlinear Dynamics) writes down a menu of candidate terms (x, y, x², xy, …), asks which tiny combination best explains the measured rates of change, and deletes everything small. What survives is the differential equation — the same way Kepler's data became Newton's law.
Arah kebalikan dari PINN: di sini kita tak tahu hukumnya. Kita hanya punya lintasan terukur. SINDy (Sparse Identification of Nonlinear Dynamics) menuliskan menu suku-suku kandidat (x, y, x², xy, …), menanyakan kombinasi kecil mana yang paling menjelaskan laju perubahan terukur, lalu menghapus semua yang kecil. Yang bertahan adalah persamaan diferensialnya — sama seperti data Kepler menjadi hukum Newton.
Pipeline: measure (x, y) → estimate ẋ, ẏ by finite differences (Euler from part 1, in reverse!) → least-squares fit over the term menu → repeatedly zero out small coefficients (STLSQ).
Alur: ukur (x, y) → estimasi ẋ, ẏ lewat beda hingga (Euler dari bagian 1, dibalik!) → fit least-squares atas menu suku → berulang-ulang menolkan koefisien kecil (STLSQ).
SINDy solved ẋ ≈ Θ(x,y)·w where Θ's columns are the menu terms evaluated on your data, then kept only large entries of w. It's plain linear least squares plus a delete-loop — no neural network at all — yet it outputs something a human can read, publish, and reason about: an equation.
SINDy menyelesaikan ẋ ≈ Θ(x,y)·w di mana kolom-kolom Θ adalah suku menu yang dievaluasi pada datamu, lalu menyimpan hanya entri besar dari w. Ini sekadar least squares linear plus loop-penghapus — tanpa jaringan saraf sama sekali — namun keluarannya sesuatu yang bisa dibaca, dipublikasikan, dan dinalar manusia: sebuah persamaan.
Contrast with the PINN: a PINN knows the law and finds the solution. SINDy has the solution (measured) and finds the law. Weak spot: everything hinges on estimating derivatives from noisy data, and the true law must be expressible in your menu — if the real term is sin(x) and your menu only has polynomials, you get a polynomial impostor.
Bandingkan dengan PINN: PINN tahu hukumnya dan mencari solusinya. SINDy punya solusinya (terukur) dan mencari hukumnya. Titik lemah: semuanya bergantung pada estimasi turunan dari data berderau, dan hukum sejati harus bisa dinyatakan dalam menumu — jika suku sebenarnya sin(x) dan menumu hanya berisi polinomial, kamu dapat penipu polinomial.
SINDy searched a fixed menu of terms. A Neural ODE throws the menu away and lets a small neural network be the right-hand side of the equation: $\dot{\mathbf y} = f_\theta(\mathbf y)$. Train the network so its output matches the observed velocities, and you have learned the dynamics as a smooth vector field — even shapes no polynomial library could spell.
SINDy mencari dalam menu suku yang tetap. Sebuah Neural ODE membuang menu itu dan membiarkan jaringan saraf kecil menjadi ruas kanan persamaan: $\dot{\mathbf y} = f_\theta(\mathbf y)$. Latih jaringan agar keluarannya cocok dengan kecepatan terukur, dan kamu telah mempelajari dinamikanya sebagai medan vektor yang mulus — bahkan bentuk yang tak bisa dieja pustaka polinomial mana pun.
The network: 2 → 16 → 16 → 2 with tanh. Loss = how far its output $f_\theta(\mathbf y_i)$ sits from each measured velocity $\mathbf v_i$.
Jaringannya: 2 → 16 → 16 → 2 dengan tanh. Loss = seberapa jauh keluarannya $f_\theta(\mathbf y_i)$ dari tiap kecepatan terukur $\mathbf v_i$.
No fixed terms, no readable formula — just weights. That is the trade against SINDy: more flexible, less interpretable.
Tak ada suku tetap, tak ada rumus terbaca — hanya bobot. Itulah tukar-tambahnya melawan SINDy: lebih fleksibel, kurang bisa ditafsirkan.
You trained a network to be the function $f$ in $\dot{\mathbf y}=f(\mathbf y)$, then handed it to the same RK4 solver from the physics playground. It is the bridge between the two halves of this course: classical solvers need $f$ written by a human; a Neural ODE lets data write $f$, then solves it the classical way.
Kamu melatih jaringan untuk menjadi fungsi $f$ dalam $\dot{\mathbf y}=f(\mathbf y)$, lalu menyerahkannya ke solver RK4 yang sama dari playground fisika. Inilah jembatan antara dua paruh kursus ini: solver klasik butuh $f$ yang ditulis manusia; Neural ODE membiarkan data menulis $f$, lalu menyelesaikannya dengan cara klasik.
Where it shines: continuous-time models of messy real systems (patient vitals, chemical kinetics) where the equations are unknown but trajectories are recorded. The catch: the field is a black box — accurate near the data, untrustworthy beyond it, and it cannot be read like SINDy's equation.
Di mana ia bersinar: model waktu-kontinu untuk sistem nyata yang berantakan (tanda vital pasien, kinetika kimia) di mana persamaannya tak diketahui tapi lintasannya terekam. Tangkapannya: medannya kotak hitam — akurat dekat data, tak bisa dipercaya di luarnya, dan tak bisa dibaca seperti persamaan SINDy.
PINN, SINDy, and Neural ODE each handle one problem at a time; change the input and you must re-simulate or re-train. A neural operator learns the whole mapping: give it any input function f (a forcing, a heat source, a load) and it returns the solution function u in a single forward pass. Train once on random examples, then answer infinitely many new problems instantly — draw your own f below and watch.
PINN, SINDy, dan Neural ODE masing-masing menangani satu masalah dalam satu waktu; ganti masukannya dan kamu harus simulasi ulang atau latih ulang. Sebuah neural operator mempelajari seluruh pemetaannya: beri ia fungsi masukan f apa pun (gaya paksa, sumber panas, beban) dan ia mengembalikan fungsi solusi u dalam satu forward pass. Latih sekali pada contoh acak, lalu jawab tak hingga masalah baru seketika — gambar sendiri f-mu di bawah dan lihat.
Every step draws a fresh batch of random wiggly functions f, computes their true u numerically, and teaches branch × trunk to match. The network below is never retrained when you change f.
Tiap langkah menggambar satu batch fungsi f acak yang meliuk, menghitung u sejatinya secara numerik, dan mengajari branch × trunk agar cocok. Jaringan di bawah tak pernah dilatih ulang saat kamu mengganti f.
Or draw: drag your mouse on the red chart to sculpt your own f.
Atau gambar: seret mouse-mu pada grafik merah untuk memahat f-mu sendiri.
The branch net reads f only through 16 sampled sensor values and compresses it into a few numbers bₖ — "which situation am I in?". The trunk net turns the query location x into basis functions τₖ(x) — "what shapes can answers have?". Their dot product is the answer. It's a learned, problem-aware Fourier series.
Branch net membaca f hanya lewat 16 nilai sensor tersampel dan memampatkannya jadi beberapa angka bₖ — "aku sedang dalam situasi mana?". Trunk net mengubah lokasi kueri x jadi fungsi basis τₖ(x) — "bentuk apa saja yang bisa dimiliki jawaban?". Hasil kali titik keduanya adalah jawabannya. Ini deret Fourier terpelajar yang sadar-masalah.
You trained a network whose input is a function and whose output is a function — an operator, the thing the RK4 loop and Euler rule from part 1 actually are. Real versions (DeepONet, Fourier Neural Operator) do this for weather, airflow over car bodies, and stress in materials: the expensive simulator runs offline to generate training data, then engineers get answers in milliseconds instead of hours.
Kamu melatih jaringan yang masukannya sebuah fungsi dan keluarannya sebuah fungsi — sebuah operator, hal yang sebenarnya adalah loop RK4 dan aturan Euler dari bagian 1. Versi nyatanya (DeepONet, Fourier Neural Operator) melakukan ini untuk cuaca, aliran udara di bodi mobil, dan tegangan pada material: simulator mahal berjalan offline untuk membangkitkan data pelatihan, lalu insinyur memperoleh jawaban dalam milidetik alih-alih jam.
The trade: you pay a huge cost once (data generation + training) to make every future query nearly free. Worth it exactly when the same physics must be solved over and over with different inputs — design loops, control, uncertainty sweeps.
Tukar-tambahnya: kamu membayar ongkos besar sekali (pembangkitan data + pelatihan) agar tiap kueri berikutnya nyaris gratis. Sepadan tepat ketika fisika yang sama harus diselesaikan berulang-ulang dengan masukan berbeda — loop desain, kendali, sapuan ketakpastian.
DeepONet learned an operator by sampling the input at sensor points. A Fourier Neural Operator does it differently and often better: it moves the input into frequency space (a Fourier transform), rescales each frequency by a learned weight, and transforms back. Many physical operators — smoothing, integrating, diffusing — are almost diagonal in frequency, so this is a stunningly natural fit. Watch it rediscover the exact multipliers.
DeepONet mempelajari operator dengan menyampel masukan di titik sensor. Sebuah Fourier Neural Operator melakukannya dengan cara berbeda dan sering lebih baik: ia memindahkan masukan ke ruang frekuensi (transformasi Fourier), menskala ulang tiap frekuensi dengan bobot terpelajar, lalu mentransformasikannya kembali. Banyak operator fisika — menghaluskan, mengintegralkan, mendifusikan — nyaris diagonal dalam frekuensi, jadi ini kecocokan yang menakjubkan alaminya. Lihat ia menemukan kembali pengali yang persis.
New to Fourier transforms? The Fourier primer → builds frequency space from scratch and shows why smoothing/integrating are just per-mode multiplies — the weights this tab learns.
Baru dengan transformasi Fourier? Primer Fourier → membangun ruang frekuensi dari nol dan menunjukkan kenapa menghaluskan/mengintegralkan hanyalah perkalian per-mode — bobot yang dipelajari tab ini.
Each step draws fresh random functions, transforms them, and nudges the per-mode weights. The net below is never retrained when you change the test input.
Tiap langkah menggambar fungsi acak baru, mentransformasikannya, dan menyenggol bobot per-mode. Jaringan di bawah tak pernah dilatih ulang saat kamu mengganti masukan uji.
Or draw on the red chart to sculpt your own f.
Atau gambar pada grafik merah untuk memahat f-mu sendiri.
Each bar is how much the network multiplies one frequency. As training proceeds they lock onto the exact analytic curve — for integration that is $1/(2\pi k)$ (low frequencies boosted); for diffusion it is $e^{-\alpha k^2}$ (high frequencies crushed). The operator was hiding in these few numbers all along.
Tiap batang adalah seberapa banyak jaringan mengalikan satu frekuensi. Seiring pelatihan berjalan, mereka mengunci pada kurva analitik yang persis — untuk integrasi itu $1/(2\pi k)$ (frekuensi rendah dikuatkan); untuk difusi itu $e^{-\alpha k^2}$ (frekuensi tinggi dihancurkan). Operatornya bersembunyi di beberapa angka ini sejak awal.
$\mathcal F$ is the Fourier transform, $R$ the learned per-frequency weights, $W$ a plain pointwise term. Real FNOs stack several of these with nonlinearities in between and carry many channels — that is what lets them handle operators that are not perfectly diagonal, like turbulent flow. Here a single clean layer already nails the diagonal ones.
$\mathcal F$ adalah transformasi Fourier, $R$ bobot per-frekuensi terpelajar, $W$ suku pointwise biasa. FNO nyata menumpuk beberapa lapisan ini dengan nonlinearitas di antaranya dan membawa banyak kanal — itulah yang membuat mereka menangani operator yang tidak sepenuhnya diagonal, seperti aliran turbulen. Di sini satu lapisan bersih saja sudah menaklukkan yang diagonal.
Instead of reading the input at fixed sensor points like DeepONet, the FNO reads it in frequency space and learns one weight per frequency. Because differentiation, integration, and diffusion are all simple multiplications in that space, the FNO represents them almost perfectly with a handful of numbers — and applies to any resolution grid.
Alih-alih membaca masukan di titik sensor tetap seperti DeepONet, FNO membacanya di ruang frekuensi dan mempelajari satu bobot per frekuensi. Karena diferensiasi, integrasi, dan difusi semuanya perkalian sederhana di ruang itu, FNO merepresentasikannya nyaris sempurna dengan segenggam angka — dan berlaku untuk grid resolusi apa pun.
Why people care: FNOs are today's leading fast surrogates for PDEs — weather, fluids, materials — often beating DeepONet on smooth, grid-based physics. The catch: the Fourier basis loves periodic, smooth data; sharp shocks and complex geometries are where it strains and where research is active.
Kenapa orang peduli: FNO adalah surrogate cepat terdepan untuk PDE saat ini — cuaca, fluida, material — sering mengungguli DeepONet pada fisika mulus berbasis grid. Tangkapannya: basis Fourier menyukai data periodik dan mulus; kejut tajam dan geometri rumit adalah tempat ia kesulitan dan tempat riset masih aktif.
Scientific ML is the middle of this map: every method is a different answer to "how do I combine what I know with what I measured?" The first playground lived in the green corner — pure equations. These five methods each let go of some knowledge and lean on data instead.
Scientific ML adalah bagian tengah peta ini: tiap metode adalah jawaban berbeda atas "bagaimana aku memadukan apa yang kutahu dengan apa yang kuukur?" Playground pertama tinggal di sudut hijau — persamaan murni. Kelima metode ini masing-masing melepas sebagian pengetahuan dan bersandar pada data.
| PINN | SINDy | Neural ODE | DeepONet | FNO | |
|---|---|---|---|---|---|
| You give itKamu memberinya | The equation + a few noisy pointsPersamaan + beberapa titik berderau | One measured trajectorySatu lintasan terukur | Measured trajectory (+ velocities)Lintasan terukur (+ kecepatan) | Many input→solution pairsBanyak pasangan masukan→solusi | Many input→solution pairsBanyak pasangan masukan→solusi |
| It learnsIa mempelajari | The solution of one problemSolusi satu masalah | The equation, as a readable formulaPersamaannya, sebagai rumus terbaca | The dynamics f as a black-box fieldDinamika f sebagai medan kotak-hitam | The solution operator (sensor-based)Operator solusi (berbasis sensor) | The solution operator (frequency-based)Operator solusi (berbasis frekuensi) |
| Core trickTrik inti | Equation residual in the loss (autodiff)Residu persamaan di loss (autodiff) | Sparse regression on a term menuRegresi sparse atas menu suku | Network is the ODE's right-hand sideJaringan adalah ruas kanan ODE | branch(f) · trunk(x) | Rescale each Fourier modeSkala ulang tiap mode Fourier |
| Output isKeluarannya | A curveSebuah kurva | An equationSebuah persamaan | A vector field you integrateMedan vektor yang kamu integralkan | A function, in one passSebuah fungsi, dalam satu pass | A function, in one passSebuah fungsi, dalam satu pass |
| Breaks whenGagal ketika | Training won't converge; easy = use RK4Pelatihan tak konvergen; mudah = pakai RK4 | Noisy derivatives; term not in menuTurunan berderau; suku tak ada di menu | Away from the data; not interpretableJauh dari data; tak dapat ditafsirkan | Input unlike the training setMasukan tak seperti set pelatihan | Sharp shocks; non-periodic geometryKejut tajam; geometri non-periodik |
| Best forPaling cocok untuk | Sparse sensors + known physics; inverse problemsSensor jarang + fisika diketahui; masalah invers | Discovering interpretable lawsMenemukan hukum yang dapat ditafsirkan | Unknown continuous-time dynamicsDinamika waktu-kontinu tak diketahui | Fast surrogates on scattered inputsSurrogate cepat untuk masukan tersebar | Fast PDE surrogates on gridsSurrogate PDE cepat pada grid |