ccitonline.com

بِسْمِ اللَّهِ الرَّحْمَنِ الرَّحِيم

ٱلسَّلَامُ عَلَيْكُمْ وَرَحْمَةُ ٱللَّٰهِ وَبَرَكَاتُهُ

Salam sehat teman-teman dan Pak Dai semoga senantiasa diberi kesempatan untuk menjalani hidup dengan normal dan berbahagia. Pada kesempatan kali ini izinkan saya membahas tentang PINN dengan framework DAI5.

Pendahuluan

Physics-Informed Neural Networks (PINN) telah muncul sebagai pendekatan revolusioner dalam menyelesaikan persamaan diferensial parsial, khususnya untuk masalah konduksi panas satu dimensi. Metode ini menggabungkan kekuatan jaringan saraf tiruan dengan hukum fisika dasar, menawarkan solusi yang lebih fleksibel dibandingkan metode numerik tradisional seperti Finite Difference Method (FDM) atau Finite Element Method (FEM). Dalam implementasinya, PINN tidak memerlukan pembagian grid atau mesh yang rumit, sehingga lebih efisien secara komputasi terutama untuk geometri kompleks. Inti dari pendekatan ini terletak pada kemampuan neural network untuk mempelajari solusi persamaan diferensial sambil tetap mematuhi prinsip-prinsip fisika yang mendasarinya, yang diwujudkan melalui fungsi loss khusus yang menggabungkan physics loss dan boundary condition loss.

Penerapan PINN untuk masalah konduksi panas 1D dilakukan melalui kerangka kerja DAI5 yang sistematis, dimulai dari kesadaran akan keterbatasan metode konvensional dan potensi solusi berbasis AI, penetapan tujuan yang jelas untuk mengembangkan solusi PDE yang lebih baik, analisis mendalam terhadap persamaan dasar dan kondisi batas, perancangan arsitektur neural network yang optimal, hingga implementasi teknis menggunakan Python dan PyTorch. Hasil eksperimen menunjukkan bahwa akurasi solusi PINN meningkat seiring jumlah epoch pelatihan, dimana dengan 1000 epoch masih terlihat deviasi yang signifikan dari solusi analitik, tetapi pada 8000 epoch atau lebih, solusi PINN hampir identik dengan solusi eksak berbentuk linear. Temuan ini tidak hanya membuktikan efektivitas PINN sebagai alat komputasi, tetapi juga mencerminkan harmoni antara kecerdasan buatan dengan hukum-hukum fisika alam yang telah ditetapkan.

Saat Epochs: 1.000

Loss yang dihasilkan sangat tinggi, yaitu sekitar 6417,33

Saat Epochs: 10.000

Loss yang dihasilkan mendekati nol, yaitu sekitar 0,14

Secara lebih luas, pendekatan ini membuka peluang aplikasi di berbagai bidang seperti rekayasa termal, dinamika fluida, dan ilmu material. Proses pembelajaran melalui kerangka DAI5 juga memberikan perspektif holistik yang mengintegrasikan aspek teknis, filosofis, dan spiritual, mengingatkan kita bahwa setiap penemuan ilmiah pada hakikatnya adalah upaya untuk memahami keteraturan alam semesta yang telah diciptakan. Dengan terus berkembangnya metode komputasi seperti PINN, kita tidak hanya memperoleh alat yang lebih powerful untuk memecahkan masalah teknik yang kompleks, tetapi juga semakin menghargai keindahan dan kedalaman ilmu pengetahuan yang terkandung dalam hukum-hukum fisika dasar.

Berikut Coding yang dipakai

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 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]], dtype=torch.float32))
    T_right = model(torch.tensor([[1.0]], dtype=torch.float32))
    bc_loss = (T_left - T0)**2 + (T_right - T1)**2  # Fixed boundary condition loss calculation

    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).to(torch.float32)
    
    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).to(torch.float32)
    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 GUI
if __name__ == "__main__":
    root = tk.Tk()
    app = PINNApp(root)
    root.mainloop()

Framework DAI5

1. Deep Awareness of I (Kesadaran Diri yang Mendalam)
Pada tahap ini, kita mengembangkan kesadaran mendalam tentang:

• Keterbatasan metode numerik konvensional (FDM/FEM) yang membutuhkan grid/mesh dan komputasi intensif
• Potensi PINN sebagai solusi alternatif yang menggabungkan fisika dan deep learning
• Tanggung jawab moral sebagai peneliti untuk mengembangkan solusi yang bermanfaat
• Penyadaran bahwa hukum fisika adalah ciptaan Tuhan yang perlu dipelajari dengan sikap rendah hati

2. Intention (Niat dan Tujuan)
Kita menetapkan tujuan yang jelas:

• Memahami implementasi PINN untuk persamaan panas 1D
• Membandingkan hasil PINN dengan solusi analitik
• Mengembangkan solusi yang lebih efisien dibanding metode tradisional
• Menciptakan implementasi praktis yang dapat diaplikasikan di industri
• Memastikan penelitian ini memberi manfaat bagi masyarakat luas

3. Initial Thinking (Pemikiran Awal)
Melakukan analisis mendalam tentang:

• Persamaan dasar konduksi panas 1D: d²T/dx² = 0
• Kondisi batas yang berlaku: T(0) = T0, T(1) = T1
• Konsep neural network dan backpropagation
• Perhitungan turunan menggunakan autograd
• Formulasi physics loss dan boundary loss
• Pemilihan domain dan parameter numerik

4. Idealization (Penyempurnaan Ide)
Mengembangkan solusi optimal melalui:

• Arsitektur neural network sederhana (3 layer, 20 neuron/layer)
• Fungsi aktivasi tanh untuk keseimbangan stabilitas dan non-linearitas
• Adam optimizer dengan learning rate 0.001
• Formulasi loss function yang menggabungkan:
  • Physics loss (berdasarkan persamaan diferensial)
  • Boundary loss (untuk memenuhi kondisi batas)
• Sistem pelatihan dengan epoch yang dapat disesuaikan

5. Instruction Set (Implementasi)
Langkah-langkah teknis implementasi:

1. Membangun model neural network dengan PyTorch
2. Implementasi autograd untuk menghitung turunan
3. Definisi fungsi loss komposit
4. Proses training dengan optimasi
5. Validasi hasil terhadap solusi analitik
6. Pengembangan GUI interaktif menggunakan Tkinter
7. Visualisasi hasil dengan Matplotlib
8. Analisis pengaruh jumlah epoch terhadap akurasi

Setelah mempelajari PINN dengan landasan DAI5, DAI5 membantu dalam proses pembelajaran PINN dan juga dapat menghubungkan aspek teknis dengan aspek filosofis yang nantinya meluruskan niat dan tujuan kita. Terima kasih yang telah membaca.

Wassalamualaikum warohmatullahi wabarokatuh.