ccitonline.com

Sebelum masuk ke aspek teknis PINN, Prof. Ahmad Indra selalu mengingatkan kami bahwa hukum-hukum fisika yang kita pelajari bukanlah sekadar alat matematis, melainkan manifestasi dari keteraturan ilahi yang mendasari alam semesta. 

Ketika saya memahami persamaan diferensial untuk konduksi panas: 

Saya merenungkan bahwa panas selalu mengalir dari suhu tinggi ke suhu rendah, sebagaimana air mengalir dari tempat tinggi ke rendah, sebuah keseimbangan yang telah ditetapkan oleh Sang Pencipta. 

Dalam penerapan PINN, kesadaran ini menuntun saya untuk memahami bahwa model yang saya bangun bukan hanya tentang meminimalkan loss, tetapi juga tentang memastikan bahwa solusi yang dihasilkan tetap sesuai dengan hukum fisika yang telah tertanam dalam alam ini. 

Kesadaran ini juga mengajarkan saya bahwa: 

– Setiap error dalam model adalah bagian dari pembelajaran, sebagaimana manusia yang selalu belajar dari kesalahan. 

– Simulasi ini bukan hanya perhitungan numerik, tetapi refleksi dari mekanisme alam yang telah Allah SWT tetapkan. 

– Ketundukan terhadap hukum fisika dalam model PINN selaras dengan ketundukan manusia kepada aturan-Nya. 

Saat model mengalami divergensi, saya berhenti sejenak, merenungkan bahwa kecerdasan manusia terbatas, dan hanya dengan kesabaran serta refleksi, solusi yang lebih baik akan ditemukan.

Dalam dunia machine learning, sering kali model dibuat hanya untuk mendapatkan akurasi tinggi, tanpa mempertimbangkan apakah solusi tersebut benar secara fisika. Niat saya dalam proyek ini bukan hanya membuat model yang mencapai loss rendah, tetapi memastikan bahwa solusi yang dihasilkan tetap valid dalam kerangka hukum alam. 

Saya bertanya pada diri sendiri: 

– Apakah tujuan utama saya hanya untuk menyelesaikan proyek ini, ataukah untuk benar-benar memahami bagaimana machine learning dapat digunakan untuk meningkatkan akurasi dalam simulasi fisik?

– Apakah saya hanya mengikuti prosedur teknis, ataukah saya sadar bahwa setiap iterasi dalam training model adalah bagian dari perjalanan belajar yang lebih dalam? 

Niat ini mengarahkan saya pada pendekatan yang lebih bertanggung jawab dalam membangun model PINN: 

– Tidak sekadar melakukan fitting data, tetapi memastikan bahwa loss function yang digunakan benar-benar merepresentasikan konservasi energi dalam sistem. 

– Menggunakan physics loss sebagai bagian dari optimasi, bukan hanya error berbasis data. 

– Menyesuaikan arsitektur neural network agar tidak hanya mencapai akurasi tinggi, tetapi juga tetap konsisten dengan solusi analitik. 

Dengan niat ini, saya tidak hanya melihat PINN sebagai alat numerik, tetapi sebagai sarana untuk memahami lebih dalam bagaimana machine learning dapat digunakan untuk menyelaraskan ilmu pengetahuan dengan hukum alam. 

Dalam tahap ini, saya mempelajari persamaan diferensial konduksi panas dan bagaimana PINN dapat digunakan untuk menyelesaikannya. 

Beberapa pertanyaan mendasar yang saya ajukan: 

– Mengapa kita menggunakan PINN dibandingkan metode numerik klasik seperti beda hingga atau elemen hingga?

– Bagaimana neural network dapat “belajar” hukum fisika tanpa bergantung pada banyak data eksperimen? 

– Bagaimana cara merancang loss function yang mencerminkan persamaan diferensial yang harus dipenuhi?

Dalam proses ini, saya memahami bahwa Physics Loss dalam PINN berasal dari residual persamaan diferensial parsial (PDE): 

Yang memastikan bahwa solusi yang ditemukan oleh jaringan saraf tetap mematuhi hukum fisika. 

Saya juga melakukan analisis numerik untuk memahami bagaimana gradien suhu menentukan perpindahan panas dalam sistem. Dengan numpy dan PyTorch, saya mengekstrak fitur-fitur dari solusi analitik, lalu membandingkannya dengan hasil dari PINN untuk memastikan bahwa model yang saya buat benar-benar bekerja sesuai dengan hukum fisika.

Dalam tahap ini, saya harus membuat beberapa asumsi yang memungkinkan solusi PINN tetap efisien tanpa kehilangan validitas. 

Beberapa idealisasi yang saya buat dalam proyek ini: 

– Menganggap konduktivitas termal (k) sebagai konstan, meskipun dalam kenyataannya bisa bergantung pada suhu. 

– Menggunakan arsitektur neural network sederhana (hanya beberapa hidden layers) untuk menghindari overfitting pada solusi numerik. 

– Menggunakan kondisi batas sederhana

Agar model lebih mudah dibandingkan dengan solusi analitik. 

Idealasi ini memungkinkan saya untuk menganalisis hasil model secara lebih intuitif, sambil tetap menjaga agar solusi tetap realistis.

Langkah terakhir adalah mengimplementasikan model PINN menggunakan PyTorch, dengan proses sebagai berikut: 

1. Mendefinisikan Neural Network yang memprediksi suhu T(x). 

2. Menghitung Physics Loss berdasarkan residual persamaan diferensial: 

3. Menambahkan Boundary Loss untuk memastikan kondisi batas tetap terpenuhi. 

4. Menggunakan optimizer Adam untuk melatih model. 

5. Mengevaluasi hasil dan membandingkan dengan solusi analitik menggunakan Matplotlib. 

Kode yang digunakan adalah sebagai berikut:

import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt
import tkinter as tk
from tkinter import ttk
import tkinter.messagebox

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