Assalaamu’alaikum wa rahmatullahi wa barakaatuh.
Pertama tama, marilah kita semua panjatkan puji syukur kehadirat Allah SWT yang telah memberikan kita rahmat-Nya kepada kita semua. kita bersyukur dapat meluangkan waktu kita untuk membaca blog saya hari ini dengan nikmat kesehatan yang diberikan-Nya.
pada minggu ini, saya akan membahas mengenai apa yang saya pelajari mengenai PINN ( physical information neural network ) dengan bantuan framework DAI5.
PINN merupakan semacam neural network yang menggabungkan hukum fisika kedalam proses pembelajarannya, berbeda dengan neural network yang hanya mendapatkan informasi melalui data saja, PINN juga menggunakan persamaan fisika seperti hukum konservasi, persamaan differensial,dll kedalam fungsinya. metode ini membua PINN lebih bisa diandalkan dengan data yang sedikit. beberapa kegunaan dari PINN sudah diterapkan pada bidang fisika tertentu seperti dinamika fluida dan prediksi material.
FRAMEWORK DAI5
sebelum kita mulai berpikir mengenai apa itu PINN, kita perlu merefleksikan diri terhadap PINN dan relevansinya di bidang teknik. sebagai mahasiswa teknik, kita perlu berpikir apa manfaat yang akan didapatkan dengan mempelajari PINN dan apa dampak yang akan kita alami setelah mempelajari ilmu yang dimaksud. selain melihat sebab dan akibat, kita perlu menyadari bahwa PINN merupakan karunia Allah SWT yang diberikan kepada kita untuk mengembangkan ilmu pengetahuan demi memanfaatkannya untuk kesejahteraan sosial.
sebagai mahasiswa teknik, kita juga perlu memikirkan niat serta tujuan kita untuk mempelajari ilmu ini. Dengan niat yang terarah kita dapat menjaga motivasi dan memastikan tindakan yang dilakukan selaras dengan tujuan tersebut. Niat dan motivasi ini juga harus menghasilkan solusi yang bermanfaat untuk diri kita dan masyarakat sekitar.
pada konteks ini, kita akan menggunakan PINN untuk mempelajari 1D Heat Conduction, fungsi fungsi dari baris baris kode, serta arti dari grafik yang dihasilkan.
sebelum kita mencoba untuk memahami kegunaan PINN dalam menyelesaikan masalah 1D Heat Conduction, sebagai mahasiswa teknik kita perlu mempelajari terlebih dahulu dasar dasar dari teori yang ingin kita telusuri.
1D heat conduction atau konduksi panas pada bidang satu dimensi merupakan perpindahan panas dalam suatu material yang terjadi pada satu sumbu (arah) tanpa ada perpindahan dalam arahnya, 1D Heat Conduction dapat dengan mudah dijelaskan dalam bentuk persamaan differensial parsial (PDE) dengan kondisi luas penampang konstan :
integrasi dari persamaan tersebut dapat menghasilkan distribusi suhu linear dimana T1 dan T2 merupakan suhu pada kedua ujung plat, dan L merupakan panjang plat.
dan fluks panas dalam kasus ini diberikan oleh :
dimana k adalah konduktivitas termal pada material plat.
dengan PINN, kitaa dpaat menyelesaikan PDE ini dengan akurat, presisi, dan dalam waktu yang cepat. maka dari itu PINN sering digunakan dalam berbagai kasus seperti seperti desain insulasi termal, analisis pendinginan komponen elektronik, dan perhitungan perpindahan panas pada dinding atau pipa.
setelah mengetahui prinsip prinsip dasar dari 1D Heat Conduction, tahap selanjutnya merupakan memastikan agar PINN memahami apa yang kita inginkan guna menghindari error/miskalkulasi pada tahap training pada model PINN.
terdapat dua komponen yang memastikan PINN melakukan training secara akurat. physic loss dan boundary condition loss :
a. Physic Loss (Mematuhi aturan persamaan panas)
aturan utama dari PINN merupakan persamaan steady-state 1D Heat Conduction :
yang dipastikan dengan kode :
# 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)b. Boundary condition loss
yang pada konteks ini, memiliki batas x=0, dan x=1
fungsi ini memastikan ketika prediksi suhu dari PINN tidak sesuai dengan kondisi batas, maka prediksi tersebut dikategorikan salah. batas batas ini dijabarkan dalam kode :
# 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
dan kedua loss ini kemudian akan digabungkan dalam bentuk :
return physics_loss + bc_losstahap selanjutnya merupakan membuat kodingan PINN berdasarkan apa yang baru saja kita pelajari. kode akan dibagi menjadi 7 tahap, yang berupa :
A. mengimport python libraries
python libraries merupakan kumpulan kode dan fungsi yang sebelumnya sudah dibuat untuk membantu berbagai perintah pemrograman, libraries yang kita akan gunakan berupa,
import torch #torch
import torch.nn as nn #neural network
import numpy as np #numerical computation
import matplotlib.pyplot as plt #data visualization
import tkinter as tk #GUI(user input)
from tkinter import ttk #GUI(display)
import tkinter.messagebox #GUI(error handling)B. mendefinisikan 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) C. Fungsi komputasi loss
def compute_loss(model, x, T0, T1):
x = x.requires_grad_(True)
T = model(x)
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 = torch.mean(d2T_dx2**2)
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_lossD. Fungsi Training
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 = torch.tensor(x, dtype=torch.float32)
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 modelE. Fungsi hasil plot
def plot_results(model, T0, T1):
x = torch.linspace(0, 1, 100).reshape(-1, 1)
x_tensor = torch.tensor(x, dtype=torch.float32)
with torch.no_grad():
T_pred = model(x_tensor).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()F. Aplikasi GUI
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.")G. Untuk menjalankan GUI
if __name__ == "__main__":
root = tk.Tk()
app = PINNApp(root)
root.mainloop()dan jika kode ini dijalankan dengan bantuan code editor, kita akan mendapatkan output berupa :
Physics-Informed Neural Networks (PINN) merupakan semacam jenis neural network yang mengimplementasikan hukum fisika kedalam proses pembelajarannya. Berbeda dengan model machine learning konvensional yang hanya mengandalkan data, PINN juga menggunakan persamaan diferensial parsial (PDE) dan hukum konservasi untuk memastikan hasil yang presisi dan akurat. Dalam konteks ini, PINN digunakan untuk memodelkan 1D Heat Conduction dengan mempertimbangkan konduktivitas material serta kondisi batas yang telah ditentukan.
Untuk memastikan PINN bekerja dengan baik, terdapat dua komponen utama dalam perhitungan loss: physics loss dan boundary condition loss. Physics loss memastikan model mengikuti persamaan steady-state heat conduction, sementara boundary condition loss menjaga agar prediksi suhu sesuai dengan kondisi batas. Proses pelatihan dilakukan menggunakan optimasi berbasis gradien, di mana model terus diperbaiki hingga loss seminimal mungkin. Dengan pendekatan ini, PINN dapat menyelesaikan persamaan dengan lebih cepat dan efisien dibandingkan metode numerik lainnya.
Implementasi PINN terdiri dari beberapa tahap, mulai dari membangun neural network, mendefinisikan fungsi loss, melatih model, hingga menampilkan hasil dalam bentuk grafik. Selain itu, antarmuka GUI juga dibuat untuk memudahkan pengguna dalam memasukkan parameter dan melihat hasil simulasi. Dengan kemampuannya yang unggul dalam menyelesaikan PDE, PINN banyak diterapkan dalam bidang teknik, termasuk desain insulasi termal, analisis pendinginan komponen elektronik, serta perhitungan perpindahan panas pada berbagai struktur.
