ccitonline.com

PINN (Physcial Information Neural Network) merupakan sebuah pendekatan analisis yang mengintegrasikan deep learning dengan ilmu pengetahuan fisika yang kita miliki. Karena mengintegrasikn dua jenis hal yang saling mendukung, hasil analisis yang diberikan oleh PINN cenderung dapat memprediksi data simulasi dengan hasil riil lebih akurat.

Pada minggu menjelang ujian tengah semester, kami memanfaatkan VSCode, Python, Numpy, PyTorch, dan Matplotlib untuk melakukan plotting grafik perbandingan suhu (T) dengan posisi (x). Berikut ini adalah codingan python yang telah disediakan oleh Pak DAI untuk plottingannya.

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

Dengan menggunakan DAI5 Framework,

1. Deep Awarenees 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.

1. Deep Awareness of I
   – Kita sadar bahwa penyelesaian masalah ini tidak bisa dilakukan dengan metode konvensional atau perhitungan manual. Kita membutuhkan bantuan software CFD dan AI untuk menyelesaikannya.
   – PINN dapat menjadi alternatif untuk memecahkan masalah ini dengan menggabungkan deep learning serta ilmu termodinamika.
   
2. Intention
   – Jika kita mengacu pada codingan yang diberikan, Baris ke-9 hingga ke-22 merupakan bagian yang mengaplikasikan PINN untuk memprediksi fungsi T(x).
   – Metode numerik berbasis PINN

3. Initial Thinking
– Kita menentukan parameter-parameter yang diperlukan untuk memecahkan permasalahan ini.
– DI sini, kita menggunakan domain x dari 1 hingga 100.
– Kita juga menghitung loss function d^2 T/ dx^2 menggunakan python autograd, di mana loss function dapat dihitung dengan pendekatan d^2T / dx^2 = 0.
– Setelah melakukan perhitungan loss function, kita menghitung juga boundary loss condition agar model T(0) dan T(1) memenuhi kondisi di atas.
– physics_loss + bc_loss adalah total loss akhir.

4. Idealization
– Selanjutnya, kita akan melakukan training pada model
– Adam Optimizer digunakan dalam codingan ini untuk menyesuaikan bobot jaringan, untuk mempercepat menghasilkan hasil yang konvergen, serta meningkatkan stabilitas adaptasi.

5. Instruction Set
– 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:

Credit to: Muhammad Sulthan Alam.

• Dapat dilihat, solusi PINN (biru) sangat jauh dari solusi analitikal nya (merah)
• Bila epoch kita perbanyak 3000 dan semakin besar, hasil PINN akan semakin mendekati hasil analitik.
  

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

Kesimpulan:

Integrasi DAI5 Framework dengan implementasi Physics-Informed Neural Networks (PINN) untuk menyelesaikan persamaan panas 1D memberikan pendekatan yang sistematis dalam metode numerik berbasis AI.

(1) Deep Awareness (of) I
– Tahapan ini membantu dalam memahami konsep fisika dan keterbatasan metode numerik klasik seperti FDM dan FEM.
(2) Intention
– Tahap ini memungkinkan pemilihan PINN sebagai metode alternatif yang tidak memerlukan diskretisasi grid dan cocok untuk sistem kompleks.
(3) Initial Thinking
– Tahap ini lebih mengarah pada identifikasi parameter penting, termasuk domain, syarat batas, dan formulasi loss function berdasarkan PDE.
(4) Idealization
– Tahap ini memastikan solusi optimal melalui pemilihan arsitektur jaringan, fungsi aktivasi, dan algoritma optimasi yang efisien.
(5) Instruction Set
– Tahap ini memungkinkan implementasi yang dapat dieksekusi di VS Code dengan PyTorch untuk komputasi numerik dan Matplotlib untuk visualisasi hasil.

Pendekatan PINN dan DAI5 Framework ini menunjukkan bahwa PINN dapat digunakan sebagai metode alternatif dalam menyelesaikan PDE, dengan potensi penerapan lebih lanjut pada masalah CFD (Computational Fluid Dynamics), atau termodinamika kompleks. Dengan mengikuti DAI5 Framework, kita dapat merancang, mengimplementasikan, dan mengevaluasi solusi numerik secara akurat, sistematis dan lebih optimal.