ccitonline.com

Assalamualaikum Wr. Wb.

Perkenalkan, nama saya Najla Fatin dengan NPM 2306265530 dari prodi Teknik Mesin angkatan 2023. Pada kesempatan kali ini, saya akan menjelaskan tentang konsep dan aplikasi dari metode PINN dalam peristiwa perpindahan panas atau heat transfer dalam arah 1 dimensi

Physics-Informed Neural Networks atau PINN merupakan salah satu jenis algoritma komputer yang berfungsi untuk menyelesaikan persamaan differensial parsial dalam arah tertentu. Salah satu contoh dari penerapan konsep persamaan differensial tersebut ialah dalam peristiwa heat transfer, yang mana merupakan suatu persamaan diferensial dari hukum Fourier yang dirumuskan sebagai berikut:

Yang mana agar persamaan tersebut menjadi relevan dalam kondisi steady state, kita mesti mengatur agar gradien distribusi temoeraturnya bernilai nol sebagai berikut:

Sehingga, disitulah peran metode pemrograman PINN untuk menemukan solusi yang membuat solusinya menjadi valid jika diterapkan dalam dunia nyata

Adapun, penerapan kerangka berpikir DAI5 dalam proses aplikasi pemrograman PINN tersebut ialah sebagai berikut:

1. Deep Awareness of I
   Saya menyadari bahwa saya sebagai makhluk ciptaan tuhan memiliki banyak kekurangan. Sehingga, saya tidak dapat mensimulasikan heat transfer secara spontan hanya dengan kaki tangan saya sendiri, maka dari itu, saya “meminta” bantuan eksternal, berupa program komputer, untuk membantu menyelesaikannya
2. Intention
   Setiap hal yang akan saya kerjakan harus dimulai dengan niat yang baik. Dalam kasus ini, saya menggunakan pendekatan metode PINN karena menurut saya metode tersebut lebih baik daripada yang lainnya. PINN dapat menghasilkan solusi dari suatu persamaan differensial secara akurat dengan proses operasi yang efisien
3. Initial thinking
   Proses pengerjaan algoritma pemrograman dimulai dengan mendefinisikan kondisi boundary pada sistem konduktor. Pada saat ini, saya membuat sistem konduktor dengan material stainless steel (konduktivitas 16,2 W/mK) yang memiliki panjang 1 meter. Temperatur mengalir dari ujung ke ujung secara bergradasi dari 100 sampai 0 derajat Celsius
4. Idealization
   Cara kerja PINN sendiri dengan meminimalisir energy loss, sebagai loss function dari hasil persamaan differensial tersebut. Loss function tersebut sendiri terdiri dari physical loss (selama perjalanan) dan boundary loss (dari pertukaran energi dengan lingkungan). Kedua parameter tersebut dijumlahkan menjadi total loss yang mana hasilnya dibuat seminimal mungkin untuk meningkatkan akurasi dari hasilnya
5. Instruction Set
   Terakhir, saya “meminta bantuan” dari Python berupa sepercik kode untuk mengkalkulasi hasil PINN tersebut. Adapun kode yang telah saya bikin untuk mengeksekusi program yang telah saya rancang sebelumnya ialah 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
from tkinter import messagebox  # Added for error messages

# Define Physics-Informed 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)

# Compute loss function for training
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²T/dx² = 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

# Train the PINN model
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

# Plot the 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  # Fixed minus sign

    plt.figure(figsize=(8, 6))
    plt.plot(x, T_pred, '--', label = "PINN Solution", color = 'red')
    plt.plot(x, T_analytical, label = "Analytical Solution", color = 'blue')
    plt.xlabel("x")
    plt.ylabel("Temperature")
    plt.title("1D Steady-State Heat Conduction")
    plt.legend()
    plt.grid(True)
    plt.show()

# GUI Application using Tkinter
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 Tkinter App
if __name__ == "__main__":
    root = tk.Tk()
    app = PINNApp(root)
    root.mainloop()

Sementara grafik yang dihasilkan dari perhitungan analitikal dan PINN menjadi seperti gambar berikut:

Yang mana saya generasikan dengan nilai iterasi (epoch) yang telah saya tentukan sebanyak 5000 kali untuk meningkatkan akurasi (semakin banyak epoch hasil semakin akurat)

Itulah hal-hal terkait PINN yang dapat saya sampaikan, sekian dari saya, mohon maaf bila ada kata-kata yang salah serta ketidaksempurnaan pada penjelasan saya ini, karena saya tahu kesempurnaan hanya milik tuhan, Wassalamualaikum Wr. Wb.