Assalamualaikum Warahmatullahi Wabarakatuh
Pada blog kali ini saya akan menjelaskan sedikit tentang prinsip & algoritma PINN Heat Conduction 1D dengan menggunakan framework DAI5. Sebelumnya, saya akan menjelaskan terlebih dahulu apa yang dimaksud dengan PINN.
PINN (Physics-Informed Neural Network) adalah sebuah pendekatan dalam pembelajaran mesin yang menggabungkan prinsip-prinsip fisika dengan jaringan saraf buatan (neural networks). Metode ini menginstruksikan jaringan saraf untuk memodelkan data yang diberikan serta mengikuti hukum fisika yang relevan, yang ditunjukkan dalam bentuk persamaan diferensial atau batasan fisik lainnya.
Tujuan utama dari PINN adalah untuk menyelesaikan masalah fisika yang memerlukan pemodelan matematis, seperti masalah aliran fluida, dinamika struktural, atau masalah lain yang dijelaskan oleh persamaan diferensial parsial (PDEs).
Berikut penjelasan saya mengenai prinsip & algoritma PINN heat & conduction 1d dengan framework DAI5 :
1. Deep Awareness of I
Physics-Informed Neural Networks (PINNs) merupakan pendekatan mutakhir dalam menyelesaikan masalah berbasis persamaan diferensial, dengan memanfaatkan kecerdasan buatan untuk memastikan solusi tetap memenuhi hukum-hukum fisika. kita harus menyadari bahwa fenomena konduksi panas bukan sekadar persoalan matematis, melainkan cerminan dari keteraturan yang telah ditetapkan oleh Allah SWT dalam hukum alam-Nya. Dalam mempelajari perpindahan panas, kita menyaksikan bagaimana energi mengalir secara teratur dari titik yang bersuhu tinggi ke titik yang bersuhu rendah, mengikuti hukum yang pasti. Kesadaran ini menumbuhkan rasa hormat terhadap ilmu, menghindarkan kita dari pendekatan mekanistik semata, dan menuntun kita untuk senantiasa menjunjung kebenaran ilmiah sebagai bagian dari kebenaran yang lebih tinggi.
2. Intention
Kita perlu menetapkan niat yang benar sebelum terjun ke dalam teknis pemodelan. Dalam mengembangkan PINN untuk memecahkan permasalahan heat conduction 1D, niat kita bukan hanya sekadar menyelesaikan persoalan numerik, tetapi juga untuk menghadirkan solusi yang bermanfaat bagi umat manusia.
3. Initial thinking
Menekankan pentingnya pemahaman dasar sebelum melangkah ke kompleksitas. Konduksi panas 1D secara matematis dijelaskan oleh Persamaan Difusi Panas (Heat Equation) berbentuk parsial, yakni โu/โt = ฮฑ โยฒu/โxยฒ, di mana u adalah suhu, t adalah waktu, dan ฮฑ adalah difusivitas termal. Prinsip dasar ini menjadi pondasi dalam penyusunan model PINN. Dalam PINN, solusi terhadap persamaan ini dicari menggunakan jaringan saraf yang dilatih tidak hanya dengan data, tetapi juga dengan menanamkan hukum fisika ke dalam fungsi loss. Pemahaman ini penting agar kita tidak terjebak pada implementasi algoritma secara buta, tetapi tetap berpijak pada realitas fisika yang ingin dimodelkan.
4. Idealization
Tahap ini merupakan penyederhanaan yang efektif terhadap masalah yang kompleks. Dalam konteks ini, kita membatasi domain menjadi satu dimensi, mengasumsikan kondisi batas tertentu, dan mengabaikan faktor eksternal yang tidak relevan. Proses idealisasi ini bertujuan agar algoritma PINN dapat bekerja secara optimal tanpa kehilangan esensi dari fenomena konduksi panas itu sendiri. Misalnya, dalam penerapan PINN, kita dapat menggunakan metode diferensiasi otomatis untuk menghitung turunan secara presisi tanpa perlu melakukan diskritisasi eksplisit. Dengan idealisasi yang tepat, model yang dihasilkan tidak hanya lebih mudah dianalisis, tetapi juga tetap akurat dalam merepresentasikan fenomena fisik yang terjadi.
5. Instruction Set
Tahap ini menekankan pada penyusunan langkah implementasi yang sistematis dan struktural. Pendekatan ini memastikan bahwa hasil yang diperoleh bukan sekadar numerik, tetapi juga bermakna secara fisika dan dapat dipercaya dalam penerapan nyata.
Berikut merupakan contoh permodelan dengan 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
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()
Kesimpulan
Sebagai penutup, Physics-Informed Neural Networks (PINN) telah terbukti sebagai pendekatan inovatif dan efektif dalam menyelesaikan masalah konduksi panas satu dimensi (1D). Keunggulan PINN terletak pada kemampuannya untuk menggabungkan pembelajaran mesin dengan hukum fisika secara langsung.
Demikian yang bisa saya sampaikan. Kurang lebihnya mohon maaf karena kesempurnaan hanya milik Allah SWT.
Wassalamualaikum Warahmatullahi Wabarakatuh
