Assalamualaikum wr. wb. Puji dan syukur kita panjatkan ke hadirat Allah SWT, yang telah memberikan kita nikmat ilmu, kesehatan, serta kesempatan untuk terus belajar dan mengembangkan kepribadian kita.
Melalui blog ini saya akan membahas mengenai pemahaman saya terhadap PINN (physics Informed Neural Networks) khususnya di permasalahan heat conduction 1D menggunakan framework DAI5. Sebelum itu izinkan saya menjelaskan secara garis besar apa itu PINN dan beberapa istilah lainnya yang berhubungan dengannya.
Machine learning adalah sebuah bidang atau ilmu yang memungkinkan komputer belajar dari suatu data untuk membuat prediksi atau pemecahan masalah tanpa diprogram secara eksplisit. Hal ini termasuk neural network yang digunakan dalam PINN. PINN merupakan suatu teknik machine learning yang menggabungkan neural network dengan pengetahuan fisika. Sesuai dengan namanya, PINN mempunyai 2 komponen utama yaitu neural network dan pengetahuan fisika.
Neural network (jaringan saraf tiruan) adalah sebuah model komputasi yang terinspirasi oleh struktur dan fungsi otak manusia. Jaringan saraf ini digunakan dalam AI untuk mengajari komputer mengenali pola dan membuat keputusan. Neural network umumnya terdiri dari 3 lapisan utama:
- Input layer : lapisan pertama yang menerima input
- Hidden layers : lapisan tengah yang memproses informasi serta tempat dimana learning terjadi
- Output layer : lapisan terakhir yang menghasilkan output.
Berikut ini adalah hubungan bagaimana framework DAI5 digunakan dalam PINNย heat conduction 1D:
Pada tahap ini kita perlu memiliki kesadaran atau consciousness terhadap diri kita sendiri serta masalah atau pembelajaran yang ingin kita hadapi. Dalam kasus ini adalah bagaimana penyelesaiaan masalah heat conduction 1D menggunakan PINN. Kita menyadari bahwa permasalahan ini merupakan ciptaan Allah SWT yang memiliki banyak manfaatnya dalam kehidupan manusia entah itu dalam bentuk spiritual maupun sosial. PINN berguna untuk menyelesaikan permasalahan heat conduction 1D yang mana solusi ini akan dijadikan sebagai analisis pertimbangan pemakaian material dll.
Sebagai makhluk ciptaan Allah SWT kita harus menyadari bahwa penyelesaian masalah ini melibatkan diri kita sebagai subjek bukan sebagai objek dari permasalahan kita sehingga apapun yang kita lakukan terhadap penyelesaian permasalahan ini merupakan bentuk tanggung jawab dan pilihan kita sendiri. Selalu mengingat bahwasannya penyelesaian masalah ini merupakan upaya kita untuk mendekatkan diri kepada Allah SWT. Dalam tahap ini juga kita perlu menjunjung tinggi nilai etika dan moral dalam penyelesaian masalah ini sehingga dihasilkan solusi yang akurat serta bermanfaat.
Sebelum melakukan penyelesaian masalah heat conduction 1D menggunakan PINN, kita harus memiliki niat dan tujuan yang jelas. Niat harus relevan dengan suatu permasalahan yang terjadi serta memiliki dampak positif dalam jangka panjang. Dengan adanya niat yang jelas ini, kita memiliki motivasi dan tindakan yang sejalan dengan hal tersebut. Niat atau motivasi ini harus menciptakan hasil yang bermanfaat dan juga memenuhi kualitas yang terbaik.
Dalam penyelesaian masalah heat conduction 1D menggunakan PINN kita ingin mengetahui bagaimana persamaan heat conduction 1D serta bagaimana cara kerja kodingan serta algoritmanya. Dengan menetapkan tujuan tersebut kita dapat memahami cara kerja PINN dan juga menerapkan PINN ke masalah fisika lainnya.
Melakukan analisis terhadap masalah seperti halnya menggali akar masalah, mengetahui konteks analisis, relevansi analisis, serta stakeholder awareness.
Akar masalah dalam permasalahan ini adalah bagaimana kita menyelesaikan permasalahan heat conduction 1D tanpa perlu menggunakan metode numerik tradisional. Maka dari itu melalui pemikiran akar masalah ini, PINN menjadi salah satu solusi yang ditawarkan. Penyelesaian heat conduction 1D menggunakan PINN memiliki beberapa konteks analisis sesuai dengan definisi dari PINN itu sendiri. Dalam konteks fisika, persamaan panas adalah persamaan diferensial parsial yang menggambarkan penyebaran panas dalam material. Sedangkan dalam konteks komputasi, PINN adalah pendekatan berbasis machine learning yang tidak lepas dari suatu kodingan dan juga neural network.
PINN dapat menyelesaikan persamaan panas dengan akurasi yang tinggi sehingga PINN dapat diterapkan dalam berbagai industri oleh pengembang teknologi dan ilmuwan data yang tertarik dalam bidang fisika. ย
Membuat asumsi terhadap masalah ini dengan menghubungkan berbagai aspek seperti kreativitas dan inovasi, simpel dan elegan, serta realisme fisik dan adaptibilitas sehingga membantu mempermudah penyelesaian masalah.
Dalam permasalahan ini, PINN harus secara ketat mematuhi prinsip fisika sebagai bentuk physical realism yang dapat menyelesaikan segala permasalahan heat conduction baik 1D maupun 2D.
Di dalam PINN terdapat sebuah loss function. Loss function adalah komponen utama yang memberikan ukuran kesalahan (error) yang dapat digunakan untuk mengoptimalkan parameter model selama proses pelatihan. Proses pelatihan ini adalah iterasi berulang di mana model machine learning belajar dari data atau prinsip fisika sehingga mampu memprediksi output yang memenuhi prinsip fisika. Loss function yang mencakup physics loss, boundary loss, dan initial loss akan mempermudah penyelesaian heat conduction 1D ini.
Kita juga ingin membuat arsitektur neural network yang simpel dan elegan dengan cara menggunakan 3-4 layer dengan 20-50 neuron per layer. Selain itu kita juga akan menggunakan aktivasi tanh untuk menyeimbangkan nonlinearitas dan stabilitas pelatihan.
1. Memahami masalah fisika dari heat conduction
Secara fisika, persamaan heat conduction 1D pada batang (dalam keadaan tunak) adalah sebagai berikut:
Kondisi batas di atas menunjukkan bahwa di masing-masing ujung batang diberikan suhu yang berbeda.
2. Mempersiapkan kodingan
Menginstall library lalu mengimport modul yang diperlukan
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.messagebox3. Membangun neural network
Mendefinisikan jaringan saraf untuk merepresentasikan fungsi suhu T(x) yang sudah dijelaskan sebelumnya (pengetahuan fisika) menggunakan pytorch. Pytorch memiliki kemampuan automatic differentiation (autograd) yang berfungsi untuk menghitung gradien dalam PINN.
class PINN(nn.Module):
def __init__(self):
super(PINN, self).__init__()
self.net = nn.Sequential(
nn.Linear(1, 20), # Input x, 20 neuron
nn.Tanh(),
nn.Linear(20, 20), # Hidden layer, 20 neuron
nn.Tanh(),
nn.Linear(20, 1) # Output T(x)
)
def forward(self, x):
return self.net(x)
Kodingan di atas ini merupakan neural network yang memiliki input, output, dan 3 hidden layers yang masing-masing dengan 20 neuron dan aktivasi tanh
4. Menentukan fungsi loss
Agar PINN belajar menyelesaikan persamaan diferensial, kita akan meminimalisir loss yang terdiri dari physics loss dan boundary condition loss.
def compute_loss(model, x, T0, T1):
x = x.requires_grad_(True) # Agar bisa dihitung turunannya
T = model(x) # Hitung suhu dari neural network
# Turunan pertama dT/dx
dT_dx = torch.autograd.grad(T, x, grad_outputs=torch.ones_like(T), create_graph=True)[0]
# Turunan kedua dยฒT/dxยฒ
d2T_dx2 = torch.autograd.grad(dT_dx, x, grad_outputs=torch.ones_like(dT_dx), create_graph=True)[0]
# Loss dari hukum fisika (harus mendekati nol)
physics_loss = torch.mean(d2T_dx2**2)
# Loss dari kondisi batas
T_left = model(torch.tensor([[0.0]], dtype=torch.float32)) # Prediksi T(0)
T_right = model(torch.tensor([[1.0]], dtype=torch.float32)) # Prediksi T(1)
bc_loss = (T_left - T0)**2 + (T_right - T1)**2
return physics_loss + bc_loss # Total loss5. Melatih model
Kita ingin melatih model menggunakan optimasi adam untuk meminimalkan loss. Model dilatih ย sesuai dengan input epoch user. Setiap 100 epoch, nilai loss akan ditampilkan supaya bisa dipantau.
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).float() # Membuat grid titik x
for epoch in range(epochs):
optimizer.zero_grad()
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 # Mengembalikan model yang telah dilatih6. Memvisualisasikan hasil
Menampilkan plot dengan matplotlib lalu membandingkan dengan solusi analitik
def plot_results(model, T0, T1):
x = torch.linspace(0, 1, 100).reshape(-1, 1).float()
with torch.no_grad():
T_pred = model(x).cpu().numpy() # Prediksi dari model
x = x.numpy()
T_analytical = T0 + (T1 - T0) * x # Solusi analitik
plt.figure(figsize=(8, 6))
plt.plot(x, T_pred, label="PINN Solution") # Plot hasil PINN
plt.plot(x, T_analytical, '--', label="Analytical Solution") # Plot solusi analitik
plt.xlabel("x")
plt.ylabel("Temperature")
plt.title("1D Steady-State Heat Conduction")
plt.legend()
plt.grid(True)
plt.show()
7. Menggunakan GUI untuk input
Membuat GUI dengan tkinter. GUI ini berfungsi untuk menampilkan antarmuka grafis yang membuat user atau kita bisa berinteraksi dengan komputer.ย Maksud dari interaksi ini adalah kita bisa mengubah niali T0, T1, dan epoch yang kita inginkan tanpa perlu mengedit kodenya lagi.
class PINNApp:
def __init__(self, root):
self.root = root
self.root.title("PINN 1D Heat Conduction Solver")
# Input T0
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")
# Input T1
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")
# Input Epochs
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")
# Tombol Solve
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):
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)KESIMPULAN
Physics Informed Neural Networks (PINN) dapat digunakan untuk menyelesaikan permasalahan heat conduction 1D dengan menggabungkan konsep machine learning dan prinsip fisika. Framework DAI5 digunakan dalam implementasi ini untuk memahami dan menyelesaikan persamaan diferensial parsial yang menggambarkan penyebaran panas dalam material.
PINN dapat menjadi alternatif yang efisien untuk menyelesaikan masalah heat conduction, terutama dalam kasus di mana metode numerik tradisional sulit diterapkan atau memerlukan komputasi yang lebih kompleks. Sehingga , implementasi PINN tidak hanya relevan dalam konteks penelitian akademik, tetapi juga berpotensi diterapkan dalam berbagai bidang teknik dan industri yang memerlukan solusi berbasis fisika dengan pendekatan machine learning.
Dalam visualisasi hasil, ketika epoch yang kita berikan sedikit maka hasil yang dihasilkan oleh PINN tidak mendekati hasil secara analitik. Hal ini disebabkan karena model belum cukup belajar atau training dari data dan hukum fisika yang diterapkan sehingga hal ini menyebabkan loss function yang cukup besar.
