A Novel Network Architecture Delivering Breakthrough Performance on Physics-Informed Neural Networks (PINNs)

[FFiot]

For the benchmark dataset Burgers.npz from DeepXDE, our new architecture achieves performance equivalent to traditional networks with 33,665 trainable parameters using only 737 trainable parameters (a 97.8% reduction). This innovation significantly enhances computational efficiency while maintaining model accuracy, making it ideal for resource-constrained scenarios.

Key Highlights:

Ultra-Lightweight Design: 737 parameters vs. 33,665 in baseline models

Dynamic Topology: Adaptive focus-driven computation replaces static linear layers

Hardware-Friendly: 5-8× higher computational density for edge deployment

Project Repository: FFnormal on Gitee
Documentation: README (English)

Feedback and technical discussions are welcome! 🚀

[vl-dud]

Hi @FFiot,
Have the results been published in any article that I could take a look at? Are you considering implementing the proposed approach with DeepXDE?

[FFiot]

I am an independent developer with limited expertise in AI, so using DeepXDE might pose some challenges.
FFnormal was developed for systems with just a few kilobytes (KB), specifically designed for curve-fitting tasks.

FFnormal-Benchmark

DEEPONet 33,665

class DeepONet(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.branch = torch.nn.Sequential(
            torch.nn.Linear(1, 128),
            torch.nn.ReLU(),
            torch.nn.Linear(128, 128),
            torch.nn.ReLU()
        )
        self.trunk = torch.nn.Sequential(
            torch.nn.Linear(1, 128),
            torch.nn.ReLU(),
            torch.nn.Linear(128, 128),
            torch.nn.ReLU()
        )
        self.output_layer = torch.nn.Linear(128, 1)
        
    def forward(self, inputs):
        x = inputs[:, 0:1]
        t = inputs[:, 1:2]
        branch_out = self.branch(t)
        trunk_out = self.trunk(x)
        multiplied = branch_out * trunk_out
        return self.output_layer(multiplied)

FFnormal & DEEPONet 737
FFnormal has no parameters that need to be trained

class FFnet(torch.nn.Module):
    def __init__(self, ff_num_list=[64, 25], ndim=8, init_data=None) -> None:
        super(FFnet, self).__init__()
        self.normals = torch.nn.ModuleList()
        self.branch_normal = FFnormal(
            in_channels=1, 
            ff_num=ff_num_list[0], 
            ff_resolution=32, 
            ff_radius=1, 
            output_scatter=True, 
            init_data=init_data[:, 0:1]
        )
        self.branch_fc = torch.nn.Linear(ff_num_list[0], ndim)

        self.trunk_normal = FFnormal(
            in_channels=1, 
            ff_num=ff_num_list[1], 
            ff_resolution=32, 
            ff_radius=1, 
            output_scatter=True, 
            init_data=init_data[:, 1:2]
        )
        self.trunk_fc = torch.nn.Linear(ff_num_list[1], ndim)
        
        self.output_layer = torch.nn.Linear(ndim, 1)

    def forward(self, inputs):
        x = inputs[:, 0:1]
        x = self.branch_normal(x)
        x = self.branch_fc(x)
        
        t = inputs[:, 1:2]
        t = self.trunk_normal(t)
        t = self.trunk_fc(t)
        
        y = x * t
        y = self.output_layer(y)
        return y

Learning rate: 1e-3

MSE:

RMSE:

[lululxvi]

You are welcome to submit a PR to add this method into DeepXDE.