| 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 |
|
|
