Assalamualaikum Warahmatullahi Wabarakatuh (ูฑูุณููููุงู ู ุนูููููููู ู ููุฑูุญูู ูุฉู ูฑูููููฐูู ููุจูุฑูููุงุชููู)
Perkenalkan nama saya Muhammad Faiq Fauzan dengan NPM 2306155281 dari Fakultas Teknik Universitas Indonesia, Departemen Teknik Mesin, Program Studi Teknik Mesin. Pada kesempatan kali ini saya akan mencoba memahami prinsip dan algoritma PINN dalam penerapan Heat Conduction 1 dimensi menggunakan framework DAI5.
Pertama-tama, saya akan menjelaskan terlebih dahulu pengertian dari PINN. Physics-Informed Neural Networks (PINN) adalah jenis jaringan saraf tiruan yang mengintegrasikan hukum fisika (dalam bentuk persamaan diferensial) ke dalam proses pembelajaran untuk memprediksi solusi sistem fisika.
Selanjutnya, mari kita ingat-ingat kembali apa saja yang terdapat pada framework DAI5. DAI5 terdiri dari lima langkah kronologis:
- Deep Awareness of I (Kesadaran Diri yang Mendalam). Kita harus menyadari hakikat dalam mencari ilmu, dimana semua hal memiliki keteraturan yang telah ditentukan oleh Allah SWT.
- Intention (Niat). Ketika kita ingin mendalami suatu ilmu pengetahuan harus diawali dengan niat untuk mengambil manfaat dari ilmu tersebut. Bukan sekadar prestasi semata, tapi harus ditujukan untuk kebermanfaatan umat manusia.
- Initial Thinking (Pemikiran Awal). Sebelum melangkah lebih jauh dalam melakukan proses analisa masalah, kita harus mampu memahami fundamental dari masalah tersebut dengan mengindentifikasi prinsip-prinsip dasarnya. Oleh karena itu, proses penyelesaian masalah dapat dilakukan tanpa menyimpang dari hukum-hukum alam yang telah ditetapkan oleh Allah SWT.
- Idealization (Idealisasi). Dalam menyesaikan suatu masalah sains, simplifikasi harus dilakukan dengan efektif sehingga kita dapat melihat gambaran besar dari masalah yang ada. Selain itu, sebagai akibat dari proses initial thinking, kita dapat menetapkan boundary condition dari simplifikasi yang telah dibuat.
- Instruction Set (Set Instruksi). Eksekusi dari model yang telah dibuat harus disusun secara runut dan dapat dipertaggungjawabkan.
Setelah saya ingat-ingat kembali apa saja runtutan dari framework DAI5, selanjutnya saya akan mengimplementasikan topik atau bahasan yang akan saya bahas menggunakan framework ini.
Deep Awareness of I
Penerapan PINN dalam simulasi konduksi panas 1 dimensi bertujuan untuk memahami dan memprediksi fenomena perpindahan panas yang terjadi secara alami sesuai dengan hukum fisika yang telah ditetapkan oleh Allah SWT. Persamaan yang digunakan, seperti persamaan konduksi panas, mencerminkan keteraturan alam yang harus kita pelajari dan manfaatkan untuk kesejahteraan manusia.
Intention (Niat)
Dalam mengembangkan model PINN untuk simulasi konduksi panas, niat utama adalah untuk memperoleh pemahaman yang lebih baik tentang bagaimana panas menyebar dalam suatu material. Model ini dapat digunakan untuk berbagai aplikasi, seperti perancangan sistem pendinginan, peningkatan efisiensi termal, dan optimasi material dalam rekayasa termal. Dalam kasusย heat conductionย 1D, maka tujuan akhirnya adalah menghasilkan solusi atas persamaan differensial berdasarkan Hukum Fourier Perpindahan Panas.
Maka dalam menyelesaikan permasalah konduksi panas, PINN harus memenuhi Hukum Kesetimbangan Energi yang menyatakan bahwa sistem berada dalam keadaan steady atau laju perubahan panas sama dengan nol.
Initial Thinking (Pemikiran Awal)
Sebelum membangun model PINN, penting untuk memahami dasar-dasar konduksi panas. Dalam kasus 1 dimensi, fenomena ini dapat dijelaskan oleh persamaan panas:
dengan:
- u (x, t) adalah suhu sebagai fungsi dari posisi dan waktu,
- alpha adalah koefisien difusi termal.
Kondisi batas (Boundary Conditions):
- Dirichlet: Suhu tetap di suatu titik.
- Neumann: Fluks panas tetap di batas.
Idealization (Idealisasi)
Agar PINN dapat bekerja secara efisien, kita perlu melakukan simplifikasi masalah tanpa menghilangkan esensi fisika-nya.
Simplifikasi konduksi panas: Anggap material homogen untuk menyederhanakan perhitungan.
Dalam idealisasi, kita harus menentukan boundary condition:
- Dirichlet Boundary Condition: Menentukan nilai tetap pada batas domain.
- Neumann Boundary Condition: Menentukan gradien nilai pada batas domain.
Misalnya, dalam simulasi konduksi panas di sebuah plat logam:
– Sisi kiri ditetapkan pada suhu 100ยฐC (Dirichlet).
– Sisi kanan dianggap sebagai isolator tanpa fluks panas (Neumann).
Dengan simplifikasi dan boundary condition yang jelas, kita bisa merancang model PINN dengan lebih efektif.
Instruction-Set
1. Mendefinisikan Jaringan Saraf Tiruan (Neural Network) menggunakan kode python:
import torch
import torch.nn as nn
import torch.optim as optim
class PINN(nn.Module):
def __init__(self):
super(PINN, self).__init__()
self.hidden = nn.Sequential(
nn.Linear(2, 20),
nn.Tanh(),
nn.Linear(20, 20),
nn.Tanh(),
nn.Linear(20, 1)
)
def forward(self, x):
return self.hidden(x)2. Memasukkan Hukum Fisika dalam Loss Function menggunakan kode python:
def loss_function(model, x, physics_residual):
prediction = model(x)
loss_physics = torch.mean(physics_residual(prediction))
return loss_physics3. Optimasi Model menggunakan kode python:
optimizer = optim.Adam(model.parameters(), lr=0.001)
for epoch in range(1000):
optimizer.zero_grad()
loss = loss_function(model, x_train, physics_residual)
loss.backward()
optimizer.step()4. Evaluasi dan Validasi menggunakan kode python:
mse = torch.mean((model(x_test) - ground_truth) ** 2).item()
print("MSE Error:", mse)5. Mengimplementasikan PINN ke simulasi heat conduction 1D menggunakan kode python:
import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt
import tkinter as tk
from tkinter import ttk
# 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
T0_tensor = torch.tensor([[T0]], dtype=torch.float32)
T1_tensor = torch.tensor([[T1]], dtype=torch.float32)
T_left = model(torch.tensor([[0.0]], dtype=torch.float32))
T_right = model(torch.tensor([[1.0]], dtype=torch.float32))
bc_loss = (T_left - T0_tensor)**2 + (T_right - T1_tensor)**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)
x = x.float()
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)
x = x.float()
with torch.no_grad():
T_pred = model(x).detach().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()Ketika kode python tersebut di-run, dihasilkan output berupa permintaan input dari user:
Saya sebagai user meng-input initial boundary condition seperti pada gambar tersebut, dengan banyak epoch atau iterasi 1000 kali. Setelah meng-klik tombol “Solve & Plot”, saya mendapatkan output seperti ini:
Saya dapat mencoba mengubah besaran epoch menjadi berapapun sesuai dengan keinginan saya. Makin banyak epoch yang dijalankan, makin akurat pula solusi PINN dengan solusi analitis dinilai dari banyaknya loss yang dihasilkan. Setelah saya mencoba-coba epoch yang paling pas agar loss yang dihasilkan akhirnya paling mendekati angka 0 ada pada epoch = 9000:
Berikut adalah grafik dengan epoch = 9000:
Kesimpulan
PINN adalah pendekatan numerik berbasis deep learning yang menggabungkan data dengan prinsip-prinsip fisika. Metode ini menjadi alternatif yang efektif untuk menggantikan teknik numerik tradisional seperti FDM dan FEM, karena tidak memerlukan proses meshing, sehingga lebih fleksibel dalam simulasi dengan dimensi tinggi.
Sekian yang dapat saya sampaikan pada kesempatan kali ini, kurang lebihnya mohon dimaafkan,
Wassalamualaikum Warahmatullahi Wabarakatuh (ููุงูุณููููุงู ู ุนูููููููู ู ููุฑูุญูู ูุฉู ุงูููููู ููุจูุฑูููุงุชููู)
