ccitonline.com

Zaahir Faizi Zuhrah (2306263531)

Physics-Informed Neural Networks (PINN) adalah pendekatan dalam deep learning yang menggabungkan prinsip-prinsip fisika ke dalam jaringan saraf tiruan (Neural Networks). Tujuannya adalah untuk menyelesaikan persamaan diferensial parsial (PDE) atau persamaan diferensial biasa (ODE) tanpa perlu data eksplisit dalam jumlah besar serta kegunaannya dalam

Simulasi Fisika Tanpa Data Eksperimen
→ PINN tidak membutuhkan dataset besar, cukup dengan persamaan fisika.

Mengatasi Keterbatasan Metode Numerik
→ Metode numerik (seperti FEM atau CFD) sering mahal secara komputasi dan sulit diterapkan pada geometri kompleks.

Generalitas dan Kecepatan
→ PINN bisa menyelesaikan berbagai macam masalah fisika hanya dengan mengubah formulasi loss function.

Lalu dengan bantuan VSCODE kami mencoba untuk memasukan coding yang berisi Physics-Informed Neural Network (PINN) untuk menyelesaikan persamaan konduksi panas satu dimensi dengan kondisi batas tertentu. Kami ditugaskan untuk memahami dari setiap step by step yang program jalankan.

Dengan menggunakan DAI5 Framework,

1. Deep Awareness of I
2. Intention
3. Initial Thinking
4. Idealization
5. Instruction Set

Kita bisa menjelaskan integrasi PINN dengan 1-D Heat Conduction yang akan kita selesaikan mengunnakan coding seperti dibawah ini.

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()

Mari kita telaah satu persatu menggunakan konsep DAI 5.

1️⃣ Deep Awareness of I

Pada tahap ini, kita menyadari bahwa metode konvensional seperti perhitungan manual atau pendekatan numerik klasik memiliki keterbatasan dalam menyelesaikan persamaan diferensial parsial (PDE). Oleh karena itu, pendekatan berbasis AI dan deep learning seperti PINN dapat digunakan sebagai alternatif yang lebih efisien dalam menyelesaikan masalah ini dengan menggabungkan prinsip termodinamika dan machine learning.

2️⃣ Intention

Dalam kode yang diberikan, penerapan PINN untuk memprediksi distribusi suhu T(x) terdapat pada baris ke-9 hingga ke-22. Metode numerik berbasis PINN ini memanfaatkan jaringan saraf untuk mempelajari pola solusi tanpa memerlukan diskretisasi grid seperti pada metode numerik klasik.

import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt
import tkinter as tk
from tkinter import ttk
class PINN(nn.Module):
    def _init_(self):
        super(PINN, self)._init_()
        self.net = nn.Sequential(
            nn.Linear(1, 20),  # Lapisan input ke hidden layer pertama (1 neuron → 20 neuron)
            nn.Tanh(),         # Aktivasi non-linear
            nn.Linear(20, 20), # Hidden layer pertama ke hidden layer kedua
            nn.Tanh(),
            nn.Linear(20, 1)   # Hidden layer kedua ke output layer (1 neuron output)
        )
    
    def forward(self, x):
        return self.net(x)

3️⃣ Initial Thinking

Langkah awal dalam menyelesaikan masalah ini adalah menentukan parameter-parameter yang diperlukan, seperti domain x dari 0 hingga 1. Selanjutnya, loss function dihitung berdasarkan persamaan diferensial d2Tdx2=0\frac{d^2T}{dx^2} = 0dx2d2T​=0 menggunakan autograd di PyTorch. Selain itu, kondisi batas pada T(0) dan T(1) juga diperhitungkan dalam total loss sebagai physics_loss + bc_loss.

def compute_loss(model, x, T0, T1):
x = x.requires_grad_(True) # Membuat x dapat dihitung turunannya
T = model(x) # Prediksi temperatur dari PINN

# Menghitung turunan pertama
dT_dx = torch.autograd.grad(T, x, grad_outputs=torch.ones_like(T), create_graph=True)[0]
# Menghitung turunan kedua
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]]))  # Temperatur di x = 0
T_right = model(torch.tensor([[1.0]])) # Temperatur di x = 1
bc_loss = (T_left - T0)**2 + (T_right - T1)**2  # Loss kondisi batas

return physics_loss + bc_loss

Fungsi:
✅ Menghitung loss berdasarkan hukum fisika
✅ Menambahkan kondisi batas T(0)=T0T(0) = T_0T(0)=T0​ dan T(1)=T1T(1) = T_1T(1)=T1​

4️⃣ Idealization

Setelah mendefinisikan model, tahap berikutnya adalah melatih jaringan saraf untuk memperoleh solusi optimal. Optimizer Adam digunakan dalam proses ini karena mampu mempercepat konvergensi dan meningkatkan stabilitas model selama pembelajaran.

5️⃣ Instruction Set

def train_pinn(T0, T1, epochs=1000):
model = PINN() # Membuat model
optimizer = torch.optim.Adam(model.parameters(), lr=0.001) # Optimizer Adam
x = torch.linspace(0, 1, 100).reshape(-1, 1) # Membuat 100 titik x antara 0 dan 1

for epoch in range(epochs):
    optimizer.zero_grad()  # Reset gradient
    loss = compute_loss(model, x, T0, T1)  # Hitung loss
    loss.backward()  # Backpropagation
    optimizer.step()  # Update parameter model

    if epoch % 100 == 0:
        print(f"Epoch {epoch}, Loss: {loss.item():.6f}")

return model

Hasil perhitungan kemudian divisualisasikan dalam bentuk grafik menggunakan Matplotlib untuk membandingkan solusi PINN dengan solusi analitik.

Jika kita menetapkan T(0) = 100°C dan T(1) = 0°C, serta melatih model dengan 1.000 epoch, hasil prediksi PINN masih memiliki perbedaan yang cukup besar dibandingkan solusi analitik. Namun, dengan meningkatkan jumlah epoch hingga 3.000 atau lebih, solusi PINN akan semakin mendekati solusi analitik. Pada 8.000 epoch, hasil yang diperoleh hampir sesuai dengan solusi teoritisnya.

def plot_results(model, T0, T1):
x = torch.linspace(0, 1, 100).reshape(-1, 1)
with torch.no_grad():
T_pred = model(x).numpy() # Hasil prediksi PINN
x = x.numpy()
T_analytical = T0 + (T1 – T0) * x # Solusi analitik

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()

– Menampilkan hasil dalam bentuk plot menggunakan matplotlib.

Jika kita melakukan input T(0) sebesar 100°C dan T(1) sebesar 0°C dan meng-input epoch atau iterasi sebanyak 1000 kali, maka diperoleh plot seperti:

Dapat dilihat, bila iterasi atau epoch sebanyak 8000 kali digunakan, hasil akhir PINN akan semakin mendekati hasil analitikalnya

• Untuk 8000 Epoch

Kita dapat melihat bahwa solusi PINN semakin mendekati solusi analitik seiring bertambahnya jumlah epoch. Hal ini terjadi karena setiap epoch membantu model semakin mendekati solusi optimal dengan meminimalkan physics loss dan boundary loss. Melalui proses optimasi berbasis gradien, model secara bertahap menyesuaikan bobotnya sehingga semakin lama dilatih, semakin tinggi akurasi solusinya.

Kesimpulan

Integrasi DAI5 Framework dengan PINN memberikan pendekatan sistematis dalam menyelesaikan persamaan diferensial parsial (PDE) berbasis AI.

1. Deep Awareness of I → Memahami keterbatasan metode klasik seperti FDM atau FEM, serta potensi pendekatan berbasis AI.
2. Intention → Memilih PINN sebagai metode alternatif yang tidak bergantung pada diskretisasi grid, sehingga cocok untuk sistem yang kompleks.
3. Initial Thinking → Menentukan domain, kondisi batas, serta formulasi loss function berbasis PDE.
4. Idealization → Memilih arsitektur jaringan, fungsi aktivasi, dan algoritma optimasi yang tepat untuk mendapatkan solusi optimal.
5. Instruction Set → Menerapkan kode dalam VS Code menggunakan PyTorch untuk perhitungan numerik dan Matplotlib untuk visualisasi hasil.

Pendekatan ini menunjukkan bahwa PINN dapat digunakan sebagai alternatif dalam penyelesaian PDE, dengan potensi penerapan lebih luas pada bidang CFD (Computational Fluid Dynamics) dan termodinamika kompleks. Melalui DAI5 Framework, kita dapat mengembangkan solusi numerik yang lebih akurat, terstruktur, dan optimal.