Assalamualaikum Pak Dai dan kawan-kawan, perkenalkan nama saya Naufal Hafash Ghiffary dengan NPM 2306203091, pada kesempatan kali ini saya akan mencoba untuk menjelaskan apa prinsip dan algoritma PINN pada kasus heat conduction 1D menggunakan framework berpikir DAI5, sebelum itu saya akan menjelaskan apa itu PINN, Physics-Informed Neural Networks (PINN) adalah pendekatan dalam machine learning yang mengintegrasikan hukum-hukum fisika dengan jaringan saraf buatan (neural networks). Ide utamanya adalah memanfaatkan persamaan fisika (seperti persamaan diferensial parsial, atau PDE) sebagai bagian dari fungsi loss dalam pelatihan jaringan saraf. Hal ini memungkinkan PINN untuk tidak hanya belajar dari data, tetapi juga mematuhi hukum-hukum fisika yang relevan. Secara sederhana PINN dapat dijelaskan dengan grafik berikut
Penjelasan untuk grafik di atas adalah, proses dimulai dengan memasukkan koordinat masukan, yang merupakan representasi dari variabel independen dalam sistem fisik. Variabel ini dapat berupa posisi dalam ruang, waktu, atau kombinasi dari keduanya, tergantung pada permasalahan yang ingin diselesaikan. Setelah itu, koordinat masukan ini diproses melalui jaringan saraf yang terdiri dari beberapa lapisan tersembunyi. Setiap lapisan memiliki bobot dan bias yang dilambangkan dengan parameter ฮธ1, ฮธ2, …, ฮธ10 yang terus diperbarui selama proses pelatihan.
Output yang dihasilkan dari jaringan ini merepresentasikan besaran fisik tertentu, seperti suhu, tekanan, atau kecepatan dalam suatu sistem. Keunikan dari PINN terletak pada metode pelatihannya yang tidak hanya bergantung pada data, tetapi juga memanfaatkan hukum-hukum fisika dalam bentuk persamaan diferensial.
Proses pelatihan PINN terdiri dari dua komponen utama. Komponen pertama adalah perbandingan dengan data pelatihan, di mana jaringan saraf dievaluasi terhadap data eksperimental atau data simulasi yang tersedia. Tujuannya adalah untuk meminimalkan kesalahan antara prediksi jaringan dan nilai sebenarnya. Komponen kedua adalah penyelesaian persamaan diferensial, di mana hasil keluaran dari jaringan digunakan untuk menghitung turunan pertama dan kedua dari besaran fisik yang diamati. Dengan menghitung turunan ini, jaringan dapat memastikan bahwa solusi yang dipelajari tetap mematuhi hukum fisika yang berlaku.
Dalam pendekatan ini, kesalahan atau residu dalam persamaan diferensial diminimalkan sebagai bagian dari fungsi loss. Dengan cara ini, PINN mampu menghasilkan solusi yang lebih akurat dan konsisten dengan prinsip-prinsip fisika, bahkan dalam kondisi di mana jumlah data pelatihan terbatas. Hal ini menjadikan PINN sebagai alat yang sangat berguna dalam berbagai aplikasi teknik dan sains, termasuk simulasi dinamika fluida, propagasi gelombang, dan perpindahan panas.
Untuk mempelajari PINN lebih dalam berikut merupakan salah satu contoh penerapan PINN untuk menyelesaikan permasalahan 1D heat conduction menggunakan koding berikut:
import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt
import tkinter as tk
from tkinter import ttk
import tkinter.messagebox
# Define the PINN neural network
class PINN(nn.Module):
def init(self):
super(PINN, self).init()
self.net = nn.Sequential(
nn.Linear(1, 20),
nn.Tanh(),
nn.Linear(20, 20),
nn.Tanh(),
nn.Linear(20, 1)
)
def forward(self, x):
return self.net(x)
# Function to compute the loss
def compute_loss(model, x, T0, T1):
x = x.requires_grad_(True)
T = model(x)
# Compute derivatives
dT_dx = torch.autograd.grad(T, x, grad_outputs=torch.ones_like(T), create_graph=True)[0]
d2T_dx2 = torch.autograd.grad(dT_dx, x, grad_outputs=torch.ones_like(dT_dx), create_graph=True)[0]
# Physics loss (d^2T/dx^2 = 0)
physics_loss = torch.mean(d2T_dx2**2)
# Boundary conditions
T_left = model(torch.tensor([[0.0]]))
T_right = model(torch.tensor([[1.0]]))
bc_loss = (T_left - T0)*2 + (T_right - T1)*2
return physics_loss + bc_loss
# Training function
def train_pinn(T0, T1, epochs=1000):
model = PINN()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
x = torch.linspace(0, 1, 100).reshape(-1, 1)
for epoch in range(epochs):
optimizer.zero_grad()
loss = compute_loss(model, x, T0, T1)
loss.backward()
optimizer.step()
if epoch % 100 == 0:
print(f"Epoch {epoch}, Loss: {loss.item():.6f}")
return model
# Function to plot results
def plot_results(model, T0, T1):
x = torch.linspace(0, 1, 100).reshape(-1, 1)
with torch.no_grad():
T_pred = model(x).numpy()
x = x.numpy()
T_analytical = T0 + (T1 - T0) * x
plt.figure(figsize=(8, 6))
plt.plot(x, T_pred, label="PINN Solution")
plt.plot(x, T_analytical, '--', label="Analytical Solution")
plt.xlabel("x")
plt.ylabel("Temperature")
plt.title("1D Steady-State Heat Conduction")
plt.legend()
plt.grid(True)
plt.show()
# GUI Application
class PINNApp:
def init(self, root):
self.root = root
self.root.title("PINN 1D Heat Conduction Solver")
# Labels and Entries
ttk.Label(root, text="T0 (Left Boundary, ยฐC):").grid(row=0, column=0, padx=5, pady=5)
self.T0_entry = ttk.Entry(root)
self.T0_entry.grid(row=0, column=1, padx=5, pady=5)
self.T0_entry.insert(0, "100")
ttk.Label(root, text="T1 (Right Boundary, ยฐC):").grid(row=1, column=0, padx=5, pady=5)
self.T1_entry = ttk.Entry(root)
self.T1_entry.grid(row=1, column=1, padx=5, pady=5)
self.T1_entry.insert(0, "0")
ttk.Label(root, text="Epochs:").grid(row=2, column=0, padx=5, pady=5)
self.epochs_entry = ttk.Entry(root)
self.epochs_entry.grid(row=2, column=1, padx=5, pady=5)
self.epochs_entry.insert(0, "1000")
# Solve Button
self.solve_button = ttk.Button(root, text="Solve & Plot", command=self.solve)
self.solve_button.grid(row=3, column=0, columnspan=2, pady=10)
def solve(self):
try:
T0 = float(self.T0_entry.get())
T1 = float(self.T1_entry.get())
epochs = int(self.epochs_entry.get())
model = train_pinn(T0, T1, epochs)
plot_results(model, T0, T1)
except ValueError:
tk.messagebox.showerror("Error", "Please enter valid numerical values.")
# Run the GUI
if name == "main":
root = tk.Tk()
app = PINNApp(root)
root.mainloop()1. Deep Awareness of ‘I’
Pada tahap ini, kita perlu memahami pentingnya peran kita dalam menerapkan metode numerik dan pembelajaran mesin untuk menyelesaikan masalah fisika. Model PINN (Physics-Informed Neural Network) yang digunakan dalam kode ini bertujuan untuk menyelesaikan persamaan diferensial parsial (PDE) yang berkaitan dengan fenomena difusi atau konduksi panas satu dimensi. Dengan memahami bagaimana jaringan saraf tiruan dapat mengaproksimasi solusi fisika, kita dapat lebih sadar terhadap keterkaitan antara pemodelan numerik dan penerapannya dalam dunia nyata, seperti di bidang teknik dan ilmu material.
2. Intention
Tujuan utama dari implementasi kode ini adalah untuk menyelesaikan masalah difusi zat atau konduksi panas steady-state menggunakan PINN. Dengan memanfaatkan pendekatan berbasis deep learning, model ini tidak hanya menyelesaikan persamaan diferensial secara eksplisit, tetapi juga mengintegrasikan hukum fisika ke dalam proses pelatihan jaringan saraf tiruan. Secara lebih spesifik, kode ini bertujuan untuk:
- Melatih model neural network untuk mendekati solusi PDE.
- Menggunakan loss function yang mempertimbangkan hukum fisika (physics loss) dan kondisi batas (boundary loss).
- Memvisualisasikan hasil prediksi model dan membandingkannya dengan solusi analitik.
- Menyediakan antarmuka pengguna (GUI) agar proses input parameter dan eksekusi model menjadi lebih mudah.
3. Initial Thinking
Pendekatan awal yang digunakan dalam implementasi kode ini melibatkan beberapa langkah kunci:
- Impor Library: Digunakan untuk membangun model, melakukan komputasi numerik, visualisasi hasil, dan pembuatan GUI.
- Definisi Model PINN: Arsitektur jaringan saraf tiruan menggunakan tiga lapisan linear dengan aktivasi Tanh untuk menangkap hubungan non-linear dalam data.
- Fungsi Loss: Menghitung physics loss berdasarkan hukum diferensial dan boundary loss berdasarkan kondisi batas.
- Proses Pelatihan: Menggunakan optimizer Adam untuk meminimalkan loss dan menghasilkan solusi yang sesuai dengan persamaan fisika.
- Plotting Hasil: Membandingkan hasil prediksi model dengan solusi analitik untuk menilai akurasi model.
- Antarmuka Pengguna (GUI): Memfasilitasi pengguna dalam mengatur parameter input dan menampilkan hasil secara visual.
4. Idealization
Pada tahap ini, kita mengembangkan konsep ideal dari implementasi kode. Model PINN yang ideal harus:
- Akurasi tinggi: Dapat menyelesaikan PDE dengan tingkat kesalahan minimal.
- Efisien dalam komputasi: Mampu melakukan training dengan jumlah iterasi yang wajar.
- Mudah digunakan: Memiliki antarmuka GUI yang intuitif agar dapat digunakan oleh berbagai kalangan, termasuk mahasiswa dan peneliti.
- Generalisasi yang baik: Tidak hanya terbatas pada satu jenis PDE, tetapi juga dapat diperluas ke permasalahan fisika lainnya.
Beberapa aspek yang dapat ditingkatkan untuk mencapai model ideal meliputi:
- Penggunaan arsitektur jaringan yang lebih kompleks untuk meningkatkan akurasi.
- Pemanfaatan teknik regularisasi untuk menghindari overfitting.
- Optimalisasi algoritma pelatihan agar lebih cepat mencapai solusi.
5. Instruction Set
A. Mendefinisikanย neural network
class PINN(nn.Module):
def init(self):
super(PINN, self).init()
self.net = nn.Sequential(
nn.Linear(1, 20),
nn.Tanh(),
nn.Linear(20, 20),
nn.Tanh(),
nn.Linear(20, 1)
)
def forward(self, x):
return self.net(x)Input berdimensi 1 (koordinat x), dua lapisan tersembunyi dengan 20 neuron masing-masing dan fungsi aktivasi Tanh, dan output berdimensi 1 (nilai temperatur T)
2. Menghitungย Loss
def compute_loss(model, x, T0, T1):
x = x.requires_grad_(True)
T = model(x)
# Compute derivatives
dT_dx = torch.autograd.grad(T, x, grad_outputs=torch.ones_like(T), create_graph=True)[0]
d2T_dx2 = torch.autograd.grad(dT_dx, x, grad_outputs=torch.ones_like(dT_dx), create_graph=True)[0]
# Physics loss (d^2T/dx^2 = 0)
physics_loss = torch.mean(d2T_dx2**2)
# Boundary conditions
T_left = model(torch.tensor([[0.0]]))
T_right = model(torch.tensor([[1.0]]))
bc_loss = (T_left - T0)*2 + (T_right - T1)*2
return physics_loss + bc_lossDengan meminimalkan total loss ini, model dapat menghasilkan solusi temperatur T(x) yang tidak hanya memenuhi hukum fisika, tetapi juga menyesuaikan diri dengan kondisi batas yang diberikan. Proses ini memastikan bahwa pendekatan PINN mampu mempelajari solusi yang valid secara matematis tanpa perlu dataset eksplisit, melainkan hanya berdasarkan hukum fisika yang mendasari masalah.
3. Training PINN
def train_pinn(T0, T1, epochs=1000):
model = PINN()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
x = torch.linspace(0, 1, 100).reshape(-1, 1)
for epoch in range(epochs):
optimizer.zero_grad()
loss = compute_loss(model, x, T0, T1)
loss.backward()
optimizer.step()
if epoch % 100 == 0:
print(f"Epoch {epoch}, Loss: {loss.item():.6f}")
return modelInisialisasi Model dan Optimizer:
- Membuat instance dari kelas PINN.
- Optimizer Adam digunakan dengan learning rate 0.001.
Pembuatan Data Input:
xadalah tensor yang berisi 100 titik secara merata di interval [0, 1] (domain spasial).
Loop Training:
- Untuk setiap epoch:
optimizer.zero_grad()membersihkan gradien.loss = compute_loss(model, x, T0, T1)menghitung loss total.loss.backward()menghitung gradien dari loss terhadap parameter jaringan.optimizer.step()memperbarui parameter menggunakan algoritma Adam.
- Setiap 100 epoch, nilai loss dicetak untuk memantau proses training.
Output:
- Fungsi mengembalikan model terlatih setelah jumlah epoch yang ditentukan
4. Plot Hasil
def plot_results(model, T0, T1):
x = torch.linspace(0, 1, 100).reshape(-1, 1)
with torch.no_grad():
T_pred = model(x).numpy()
x = x.numpy()
T_analytical = T0 + (T1 - T0) * x
plt.figure(figsize=(8, 6))
plt.plot(x, T_pred, label="PINN Solution")
plt.plot(x, T_analytical, '--', label="Analytical Solution")
plt.xlabel("x")
plt.ylabel("Temperature")
plt.title("1D Steady-State Heat Conduction")
plt.legend()
plt.grid(True)
plt.show()Model digunakan untuk menghasilkan prediksi temperatur Tpredictionโ untuk semua x. Fungsi torch.no_grad() digunakan agar tidak menghitung gradien. Menggunakan matplotlib untuk menggambarkan perbandingan antara solusi yang dihasilkan oleh PINN dan solusi analitik. Sehingga menghasilkan plot sebagai berikut:
1. untuk 1000 epochs
2. untuk 2000 epochs
3. untuk 8000 epochs
4. untuk 10000 epochs
dapat kita lihat solusi PINN semakin mendekati solusi analitik ketika epoch diperbanyak hal tersebut dikarenakan setiap epoch membawa model lebih dekat ke solusi optimal dengan cara meminimalkan physics loss dan boundary loss. Proses ini terjadi secara bertahap melalui optimasi berbasis gradien, sehingga semakin lama model dilatih, semakin akurat solusinya.
Kesimpulan
Dengan mengintegrasikan prinsip fisika langsung ke dalam arsitektur jaringan saraf, PINN memungkinkan penyelesaian persamaan konduksi panas 1D secara lebih efisien dan fleksibel. Metode ini dapat diaplikasikan ke berbagai sistem termal tanpa membutuhkan data pengukuran dalam jumlah besar, sehingga menjadi alternatif potensial untuk simulasi berbasis fisika.
