| | import numpy as np |
| | import torch |
| | import torch.nn as nn |
| | import torch.nn.functional as F |
| | from torch.nn import Conv1d, Conv2d, Linear, ReLU |
| |
|
| | from pdeinvbench.utils.types import PDE |
| |
|
| |
|
| | class ConvDownsampler(nn.Module): |
| | """ |
| | Multi-layer convolutional downsampler for spatial dimension reduction. |
| | |
| | Stacks multiple ConvBlock layers, each consisting of a convolutional layer, |
| | ReLU activation, dropout, and max pooling. Supports both 1D and 2D spatial |
| | dimensions. |
| | |
| | Parameters |
| | ---------- |
| | n_layers : int |
| | Number of convolutional blocks to stack. |
| | input_dimension : int |
| | Spatial dimensionality of the input (1 for 1D, 2 for 2D). |
| | Determines whether to use Conv1d or Conv2d operations. |
| | in_channels : int |
| | Number of input channels. Note: this stays constant across all layers |
| | in the current implementation. |
| | out_channels : int |
| | Number of output channels for each convolutional layer. |
| | kernel_size : int |
| | Size of the convolving kernel. |
| | stride : int |
| | Stride of the convolution operation. |
| | padding : int |
| | Zero-padding added to both sides of the input. |
| | dropout : float |
| | Dropout probability applied after each ReLU activation. |
| | """ |
| |
|
| | def __init__( |
| | self, |
| | n_layers: int, |
| | input_dimension: int, |
| | in_channels: int, |
| | out_channels: int, |
| | kernel_size: int, |
| | stride: int, |
| | padding: int, |
| | dropout: float, |
| | ): |
| | super(ConvDownsampler, self).__init__() |
| |
|
| | self.n_layers = n_layers |
| | self.input_dimension = input_dimension |
| | self.in_channels = in_channels |
| | self.out_channels = out_channels |
| | self.kernel_size = kernel_size |
| | self.stride = stride |
| | self.padding = padding |
| | self.dropout = dropout |
| | self.blocks = nn.ModuleList() |
| | for _ in range(n_layers): |
| | self.blocks.append( |
| | ConvBlock( |
| | input_dimension, |
| | in_channels, |
| | out_channels, |
| | kernel_size, |
| | stride, |
| | padding, |
| | dropout, |
| | ) |
| | ) |
| |
|
| | def forward(self, x): |
| | for block in self.blocks: |
| | x = block(x) |
| | return x |
| |
|
| |
|
| | class ConvBlock(nn.Module): |
| | """ |
| | Conv block with a convolutional layer, ReLU activation and maxpooling. |
| | """ |
| |
|
| | def __init__( |
| | self, |
| | input_dimension: int, |
| | in_channels: int, |
| | out_channels: int, |
| | kernel_size: int, |
| | stride: int, |
| | padding: int, |
| | dropout: float, |
| | ): |
| | super(ConvBlock, self).__init__() |
| |
|
| | if input_dimension == 2: |
| | self.conv = Conv2d( |
| | in_channels, |
| | out_channels, |
| | kernel_size=kernel_size, |
| | stride=stride, |
| | padding=(padding, padding), |
| | ) |
| | self.maxpool = nn.MaxPool2d(2) |
| | elif input_dimension == 1: |
| | self.conv = Conv1d( |
| | in_channels, |
| | out_channels, |
| | kernel_size=kernel_size, |
| | stride=stride, |
| | padding=padding, |
| | ) |
| | self.maxpool = nn.MaxPool1d(2) |
| | else: |
| | raise ValueError("Input dimension must be 1 or 2.") |
| |
|
| | self.relu = ReLU() |
| | self.dropout_layer = nn.Dropout(dropout) |
| |
|
| | def forward(self, x): |
| | x = self.conv(x) |
| | x = self.relu(x) |
| | x = self.dropout_layer(x) |
| | x = self.maxpool(x) |
| | return x |
| |
|
| |
|
| | class IdentityMap(nn.Module): |
| | """ |
| | Identity downsampler to use for darcy flow. Since Fno maps to function spaces, |
| | there is no spatial downsampling that needs to be done. |
| | """ |
| |
|
| | def __init__(self, **kwargs): |
| | super(IdentityMap, self).__init__() |
| | |
| |
|
| | def forward(self, x): |
| | return x |
| |
|
