Selamat pagi,siang, dan malam Pak Dai dan teman-teman. Pada blog kali ini saya akan menjelaskan tentang prinsip dan algoritma PINN heat conduction 1D dengan menggunakan framework DAI5. Namun sebelumnya, saya akan menjelaskan dahulu apa yang dimaksud dengan PINN.
Physics-Informed Neural Networks (PINN) adalah pendekatan dalam pembelajaran mesin yang menggabungkan jaringan saraf tiruan (Neural Networks) dengan hukum fisika dalam bentuk persamaan diferensial.
PINN menggunakan jaringan saraf dalam (Deep Neural Networks) untuk mendekati solusi dari suatu sistem fisika yang dinyatakan dalam bentuk Persamaan Diferensial Biasa (Ordinary Differential Equations) atau Persamaan Diferensial Parsial (Partial Differential Equations).
Berikut penjelasan saya mengenai prinsip dan algoritma PINN heat counduction 1D dengan framework DAI5:
1.Deep Awareness Of I
Seperti penjelasan diatas, PINN merupakan metode berbasis jaringan saraf tiruan (Neural Network, NN) yang digunakan untuk menyelesaikan persamaan diferensial biasa (ODE) dan persamaan diferensial parsial (PDE) tanpa memerlukan metode numerik tradisional. Dalam hal ini, kita diberikan kesadaran pada diri sendiri, bahwa manusia memiliki keterbatasan dalam melakukan perhitungan-perhitungan numerik. Sehingga kesadaran tersebut membuat kita berpikir untuk menggunakan bantuan seperti AI dalam menyelesaikan permasalahan perhitungan numerik.
2. Intention
Dalam menyelesaikan permasalahan heat conduction 1D, PINN bertujuan dalam beberapa hal.Pertama, menyelesaikan persamaan secara kontinu tanpa diskretisasi grid.Berikutnya, PINN mengintegrasikan data eksperimental dengan hukum fisika untuk meningkatkan akurasi prediksi dan mampu mengisi area tanpa data dengan solusi yang tetap konsisten dengan persamaan fisika.Berikutnya, PINN memecahkan masalah inversi dengan memperkirakan parameter yang tidak diketahui langsung dari data suhu yang terbatas.
3. Intial Thinking
Persamaan konduksi panas 1D dalam bentuk difrensial adalah persamaan difusi panas seperti berikut:
PINN menggunakan persamaan tersebut dan di masukkan sebagai bagian dari fungsi loss.Lalu, Optimasi dilakukan dengan Gradient Descent untuk meminimalkan loss function hingga persamaan diferensial dipenuhi.
4. Idealization
PINN dalam penyelesaian kasus heat conduction 1D, memiliki idealisasi sebagai berikut. Pertama, melakukan prediksi terhadap u(x,t). Neural Network dipakai untuk memetakan x,t→u(x,t).Lalu berikutnya,PINN memanfaatkan persamaan diferensial untuk memastikan prediksi tetap sesuai dengan hukum fisika dan memanfaatkan persamaan diferensial sebagai loss function. Berikutnya, PINN melakukan pelatihan model dengan data dan fisika. Data tambahan dalam eksperimen, membantu PINN dalam meningkatkan akurasi dan jaringan dilatih menggunakan adam optimizer hingga mendapat loss minimal. Dan yang terakhir, setelah training, model dapat memprediksi suhu u(x,t)untuk berbagai kondisi.Dengan idealisasi PINN tersebut, memudahkan saya dalam menyelesaikan permasalahan rumit yang terdapat dalam heat conduction 1D dengan efisien dibandingkan metode numerik yang konvensional.
5.Instruction Set
Berikut adalah struktur umum Instruction Set untuk menyelesaikan persamaan diferensial parsial (PDE) menggunakan PINN, khususnya untuk masalah konduksi panas 1D.
1).Mendefinisikan model neural network
Jaringan saraf akan menerima (x, t) sebagai input dan mengeluarkan u(x, t) sebagai prediksi suhu.
2).Mendefinisikan Loss Function Berdasarkan PDE
PINN menggunakan persamaan diferensial sebagai bagian dari fungsi loss, yang disebut Physics Loss. Menghitung residual loss berdasarkan persamaan panas menggunakan autogradient TensorFlow.
3).Implementasi Boundary Condition dan Initial Condition Loss
– Boundary Loss memastikan solusi memenuhi kondisi batas suhu
– Initial Condition Loss memastikan solusi sesuai dengan kondisi awal temperatur.
4). Membuat dataset untuk training model
Mendefinisikan titik-titik dalam domain (x, t) yang akan digunakan untuk training dan menetapkan kondisi batas dan kondisi awal.
5).Training Model
Melatih model PINN dengan optimasi Adam dan Loss total dihitung dari Physics Loss + Boundary Loss + Initial Condition Loss.
Berikut python dari PINN yang telah saya pelajari:
import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt
import tkinter as tk
from tkinter import ttk, messagebox
# Define the Physics-Informed Neural Network (PINN)
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)
# Compute the loss function
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
# Train the PINN model
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
# Plot the 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:
messagebox.showerror("Error", "Please enter valid numerical values.")
# Run the application
if __name__ == "__main__":
root = tk.Tk()
app = PINNApp(root)
root.mainloop()
