Assalamualaikum Warahmatullahi Wabarakatuh.
Pertama-tama, mari kita panjatkan puji syukur kehadirat Allah SWT atas nikmat yang dianugerahkan kepada kita semua sehingga diberi kenikmatan berupa kesehatan jasmani dan rohani untuk teman-teman dan juga Pak Dai.
Saya disini ingin menjelaskan tugas ke 5 dari metode numerik 24 maret 2025. Disini saya ingin menjelaskan mengenai PINN dan juga Prinsip & Algoritma PINN HC 1D dengan menggunakan Framework DAI5.
Penjelasaan PINN
Physics-informed neural networks (PINNs) Adalah jaringan saraf yang menggabungkan hukum fisika yang dijelaskan oleh persamaan diferensial ke dalam fungsi kerugiannya untuk memandu proses pembelajaran menuju solusi yang lebih konsisten dengan fisika yang mendasarinya. PINN dapat digunakan untuk:
- Solusi perkiraan untuk persamaan diferensial parsial (PDE) dan persamaan diferensial biasa (ODE).
- Selesaikan masalah invers, seperti memperkirakan parameter model dari data terbatas.
Manfaat dari PINN
PINN adalah kelas metode pembelajaran mesin yang diinformasikan fisika yang secara mulus mengintegrasikan pengetahuan fisika dengan data. Seringkali, PINN dibandingkan dengan metode berbasis data murni dan metode numerik tradisional untuk memecahkan masalah yang melibatkan PDE dan ODE.
Tidak seperti pendekatan berbasis data murni, yang mempelajari hubungan matematika hanya dari data input dan output, PINN:
- Gunakan pengetahuan fisika sebelumnya.
- Buat prediksi yang lebih akurat di luar kumpulan data pelatihan.
- Lebih efektif dengan data pelatihan yang terbatas atau berisik.
Tidak seperti metode numerik tradisional untuk menyelesaikan persamaan diferensial, seperti analisis elemen hingga untuk PDE, PINN:
- Bebas jaring.
- Dapat mendekati solusi PDE berdimensi tinggi.
- Dapat menyelesaikan parameter model yang hilang seperti koefisien PDE atau ODE yang tidak diketahui.
- Dapat memecahkan masalah yang diajukan dengan buruk di mana tidak ada data batas.
- Dapat dengan mudah menggabungkan pengukuran yang jarang atau berisik.
Sementara PINN menawarkan manfaat potensial dibandingkan dengan metode berbasis data murni dan metode numerik tradisional, PINN memang memiliki beberapa keterbatasan dan tantangan, termasuk:
- Teori konvergensi terbatas
- Kurangnya strategi pelatihan terpadu
- Biaya komputasi untuk menghitung derivatif tingkat tinggi
- Kesulitan mempelajari komponen frekuensi tinggi dan multiskala dari solusi PDE
Namun, PINN adalah area penelitian yang dinamis, dengan kemajuan berkelanjutan yang diharapkan dapat mengatasi dan mengatasi tantangan dan keterbatasan saat ini.
Cara Kerja PINN
PINN menggunakan algoritma pengoptimalan untuk memperbarui parameter jaringan saraf secara berulang sampai nilai fungsi kerugian yang ditentukan dan diinformasikan oleh fisika menurun ke tingkat yang dapat diterima, mendorong jaringan menuju solusi persamaan diferensial.
Aplikasi PINN
PINN memanfaatkan kekuatan pembelajaran mendalam sambil meningkatkan kepatuhan terhadap hukum fisika, menjadikannya alat serbaguna untuk aplikasi di mana fisika sepenuhnya atau sebagian diketahui, seperti kasus PDE atau ODE dengan koefisien yang tidak diketahui. Aplikasi PINN meliputi:
- Perpindahan panas, khususnya untuk pemodelan distribusi panas dan proses transfer. PINN dapat menanamkan persamaan yang mengatur yang memodelkan proses termal dalam bahan dan sistem, seperti persamaan panas, ke dalam fungsi kerugian. Pendekatan ini memastikan bahwa solusinya mematuhi hukum fisika ini, yang mengarah pada prediksi yang masuk akal secara fisik. Selain itu, PINN dapat menggantikan simulasi numerik yang mahal untuk memperkirakan distribusi suhu dengan cepat atas geometri berparameter dalam aplikasi pengoptimalan desain. Selanjutnya, PINN dapat digunakan dalam masalah terbalik untuk mengidentifikasi sifat material yang tidak diketahui, seperti konduktivitas termal.
- Dinamika fluida komputasional (CFD), khusus untuk perkiraan kecepatan, tekanan, dan medan suhu fluida dengan memasukkan persamaan Navier-Stokes dalam fungsi kerugian. PINN dapat digunakan dalam simulasi maju bebas mesh untuk memprediksi secara akurat kuantitas ini atau dalam masalah terbalik di mana tujuannya adalah untuk menyimpulkan parameter atau input yang tidak diketahui, seperti kondisi batas, istilah sumber, atau sifat fluida, dari data yang diamati.
- Mekanika struktural, untuk memecahkan masalah maju dan terbalik dengan menanamkan hukum fisika yang mengatur, seperti persamaan elastisitas dan dinamika struktural, langsung ke dalam fungsi kerugian. Integrasi ini memungkinkan PINN untuk secara akurat memprediksi respons struktural seperti deformasi, tekanan, dan regangan di bawah berbagai beban dan kondisi, serta mengidentifikasi sifat material yang tidak diketahui atau beban eksternal berdasarkan data yang diamati. Terutama berguna dalam skenario di mana solusi analitik tradisional tidak memungkinkan atau data langka, PINN mengurangi ketergantungan pada kumpulan data yang luas dengan memanfaatkan prinsip-prinsip fisik untuk memandu proses pembelajaran. Fleksibilitas PINN memungkinkan mereka untuk menangani masalah yang kompleks, termasuk perilaku material nonlinier dan pemodelan multifisika.
Penjelasan DAI5
- Deep Awareness of I (Kesadaran Mendalam tentang Diri):
Langkah dasar ini melibatkan pengingatan yang terus-menerus kepada Sang Maha Kuasa โ Yang Maha Esa, Pencipta Alam Semesta dan segala isinya. Langkah ini menekankan kesadaran individu (atau jiwa/nafs) dan kesadaran diri, menyelaraskan tindakan dengan tujuan utama untuk mengenal dan mengakui Tuhan. Ini adalah keadaan โnafs,โ yang berfungsi sebagai lapisan inti.
- Intention (Niat):
Ini adalah keputusan atau tujuan sadar yang mendorong proses pemecahan masalah. Niat berasal dari hati, yang berfungsi sebagai โheartwareโ (perangkat hati) yang mengkodekan niat untuk seluruh kerangka kerja. Niat memastikan bahwa setiap langkah pemecahan masalah selaras dengan kehendak Sang Pencipta.
- Initial Thinking (about the Problem) (Pemikiran Awal tentang Masalah):
Langkah ini mencakup analisis dan pemahaman mendalam tentang masalah, memastikan pemahaman yang komprehensif tentang sifat dan akar penyebabnya.
- Idealization (Idealisasi):
Pada langkah ini, asumsi dibuat untuk menyederhanakan dan memodelkan masalah, sambil memastikan bahwa asumsi tersebut dapat diandalkan, realistis, dan selaras dengan prinsip-prinsip yang telah ditetapkan dalam niat.
- Instruction Set (Set Instruksi):
Ini mencakup prosedur, langkah-langkah, dan metode iteratif untuk menerapkan solusi, dengan niat sadar yang terus membimbing tindakan selama pelaksanaan.
Berikut penjelasan saya mengenai prinsip dan algoritma PINN heat counduction 1D dengan framework DAI5:
- Deep Awareness of I (Kesadaran Mendalam tentang Diri):
Jadi, dalamlangkah ini kita perlu menyadari bahwa segala hukum fisika yang menjadi dasar PINNs adalah bagian dari keteraturan alam yang telah ditetapkan oleh Allah SWT. Dalam konteks ini, PINNs memungkinkan kita untuk memahami fenomena alam melalui komputasi numerik yang canggih. Namun, di balik kemajuan teknologi tersebut, kita harus tetap rendah hati dan mengakui bahwa keakuratan dan ketepatan dalam perhitungan numerik ini pada akhirnya bergantung pada hukum-hukum alam yang telah Allah ciptakan. Dengan kesadaran ini, kita dapat menggunakan PINNs untuk memperdalam pemahaman kita tentang ciptaan-Nya. Selain itu, kita juga harus memastikan bahwa pendekatan ilmiah yang kita gunakan tetap selaras dengan nilai-nilai spiritual. Hal ini mengingatkan kita bahwa ilmu pengetahuan dan teknologi adalah alat untuk mendekatkan diri kepada Sang Pencipta, bukan untuk menjauhkan diri dari-Nya. Dengan demikian, penggunaan PINNs tidak hanya sebagai alat komputasi, tetapi juga sebagai sarana untuk merenungkan kebesaran Allah SWT melalui keteraturan alam semesta yang telah diciptakan-Nya.
- Intention (Niat):
Setelah itu, saya menekankan diri untuk berniat dalam mengerjakan soal ini dan juga saya berniat untuk mempelajari mengenai PINN. Niat ini selaras dengan kebaikan karena dengan mempelajari ini kita bisa membantu masyarakat dengan menggunakan teknologi yang ramah lingkungan dan lain-lain. Dengan menggunakan pendekatan berbasis PINN, kita dapat memperoleh solusi yang lebih fleksibel dan efisien dibandingkan metode numerik konvensional. Selain itu, niat dalam pemecahan masalah ini adalah memastikan bahwa setiap tahap perhitungan tetap sesuai dengan hukum fisika yang mendasarinya, sehingga hasil yang diperoleh tetap memiliki validitas fisik dan akurasi tinggi.
- Initial Thinking (about the Problem) (Pemikiran Awal tentang Masalah):
Persamaan utama yang digunakan dalam pemodelan ini adalah persamaan panas satu dimensi:
dengan u(x,t) sebagai suhu, ฮฑฮฑ sebagai difusivitas termal, xx sebagai koordinat spasial, dan tt sebagai waktu. Dalam penerapan PINN, solusi akan ditemukan dengan memodelkan suhu sebagai fungsi jaringan saraf yang memenuhi persamaan diferensial ini. Selain itu, kita juga harus mempertimbangkan kondisi awal (distribusi suhu awal) dan kondisi batas (seperti suhu tetap di tepi atau gradien suhu nol). Pemahaman awal ini memastikan bahwa kita memiliki representasi yang jelas terhadap permasalahan sebelum masuk ke tahap implementasi.
- Idealization (Idealisasi):
Tahap idealisasi bertujuan menyederhanakan masalah untuk membuat model yang realistis dengan membuat asumsi tertentu, seperti kondisi steady-state. Asumsi harus jelas (Assumption Clarity) dan sesuai realitas alam (Physical Realism) agar solusi selaras dengan hukum fisika. Dalam PINNs, hal ini dijamin dengan memasukkan residual persamaan diferensial parsial (PDE) ke dalam fungsi loss. Pada kasus ini, kondisi diasumsikan steady-state.
- Instruction Set (Set Instruksi):
Dibawah ini merupakan code python:
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()
Penjelasan coding python diatas:
- Definisi Neural Network (PINN)
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)
Penjelasan
- PINN adalah sebuah neural network sederhana dengan arsitektur feedforward.
- Jaringan ini terdiri dari 3 lapisan linear (nn.Linear) dengan fungsi aktivasi Tanh.
- Input adalah koordinat spasial x (1D), dan output adalah prediksi suhu T(x).
- Lapisan tersembunyi memiliki 20 neuron.
2. Fungsi untuk Menghitung 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
Penjelasan:
Fungsi ini menghitung total loss yang terdiri dari dua komponen:
- Physics Loss: Memastikan solusi memenuhi persamaan diferensial (dalam hal ini, persamaan Laplace 1D: d^2T/dx^2 = 0
- Boundary Condition Loss: Memastikan solusi memenuhi kondisi batas (suhu di x=0 adalah T0 dan di x=1 adalah T1).
- Turunan pertama (dT_dx) dan kedua (d2T_dx2) dihitung menggunakan torch.autograd.grad.
3. Fungsi Pelatihan
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
Penjelasan:
- Fungsi ini melatih model PINN menggunakan optimizer Adam.
- Input x adalah grid spasial dari 0 hingga 1 dengan 100 titik.
- Pada setiap epoch, loss dihitung dan model diperbarui menggunakan backpropagation.
- Loss dicetak setiap 100 epoch untuk memantau proses pelatihan.
4. Fungsi untuk Plot Hasil
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()
Penjelasan:
- Fungsi ini membandingkan solusi dari PINN dengan solusi analitik.
- Solusi analitik untuk persamaan ini adalah T(x)=T0+(T1โT0)โ x
- Hasil plot menampilkan solusi PINN (garis biru) dan solusi analitik (garis putus-putus).
5. 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.”)
Penjelasan:
- GUI dibuat menggunakan tkinter.
- Pengguna dapat memasukkan nilai T0, T1, dan jumlah epoch.
- Tombol “Solve & Plot” akan memanggil fungsi solve, yang melatih model dan menampilkan plot hasil.
6. Menjalankan GUI
if __name__ == “__main__”:
root = tk.Tk()
app = PINNApp(root)
root.mainloop()
Penjelasan:
- Kode ini menjalankan aplikasi GUI dengan memanggil root.mainloop().
Cara Kerja Program
- Pengguna memasukkan nilai T0, T1, dan jumlah epoch melalui GUI.
- Program melatih model PINN untuk menyelesaikan persamaan konduksi panas 1D.
- Hasil pelatihan (solusi PINN) dibandingkan dengan solusi analitik dan ditampilkan dalam plot.
Output:
Demikianlah pemaparan tugas 05 metode numerik kali ini yang dapat saya sampaikan, jika ada salah kata mohon maaf, akhirul kalam wallahu muwafiq ila iqwamittorriq, Assalamuโalaikum wr.wb.
