{ "cells": [ { "cell_type": "markdown", "id": "48dd2795", "metadata": {}, "source": [ "# Tutorial: Unstructured Convolutional Autoencoders with Continuous Convolution\n", "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial4/tutorial.ipynb)" ] }, { "cell_type": "markdown", "id": "25770254", "metadata": {}, "source": [ "In this tutorial, we will show how to use the Continuous Convolutional Filter, and how to build common Deep Learning architectures with it. The implementation of the filter follows the original work [*A Continuous Convolutional Trainable Filter for Modelling Unstructured Data*](https://arxiv.org/abs/2210.13416).\n", "\n", "First of all we import the modules needed for the tutorial:" ] }, { "cell_type": "code", "execution_count": null, "id": "5ae7c0e8", "metadata": {}, "outputs": [], "source": [ "## routine needed to run the notebook on Google Colab\n", "try:\n", " import google.colab\n", "\n", " IN_COLAB = True\n", "except:\n", " IN_COLAB = False\n", "if IN_COLAB:\n", " !pip install \"pina-mathlab[tutorial]\"\n", "\n", "import torch\n", "import matplotlib.pyplot as plt\n", "import torchvision # for MNIST dataset\n", "import warnings\n", "\n", "from pina import Trainer\n", "from pina.problem.zoo import SupervisedProblem\n", "from pina.solver import SupervisedSolver\n", "from pina.trainer import Trainer\n", "from pina.model.block import ContinuousConvBlock\n", "from pina.model import FeedForward # for building AE and MNIST classification\n", "\n", "warnings.filterwarnings(\"ignore\")" ] }, { "cell_type": "markdown", "id": "4094758f", "metadata": {}, "source": [ "## Tutorial Structure\n", "\n", "The tutorial is structured as follows:\n", "\n", "- [🔹 Continuous Filter Background](#continuous-filter-background): \n", " Understand how the convolutional filter works and how to use it.\n", "\n", "- [🔹 Building a MNIST Classifier](#building-a-mnist-classifier): \n", " Learn how to build a simple classifier using the MNIST dataset, and how to combine a continuous convolutional layer with a feedforward neural network.\n", "\n", "- [🔹 Building a Continuous Convolutional Autoencoder](#building-a-continuous-convolutional-autoencoder): \n", " Explore how to use the continuous filter to work with unstructured data for autoencoding and up-sampling.\n" ] }, { "cell_type": "markdown", "id": "87327478", "metadata": {}, "source": [ "## Continuous Filter Background\n", "\n", "As reported by the authors in the original paper, in contrast to discrete convolution, **continuous convolution** is mathematically defined as:\n", "\n", "$$\n", " \\mathcal{I}_{\\rm{out}}(\\mathbf{x}) = \\int_{\\mathcal{X}} \\mathcal{I}(\\mathbf{x} + \\mathbf{\\tau}) \\cdot \\mathcal{K}(\\mathbf{\\tau}) d\\mathbf{\\tau},\n", "$$\n", "\n", "where:\n", "- $\\mathcal{K} : \\mathcal{X} \\rightarrow \\mathbb{R}$ is the **continuous filter** function,\n", "- $\\mathcal{I} : \\Omega \\subset \\mathbb{R}^N \\rightarrow \\mathbb{R}$ is the input function.\n", "\n", "The **continuous filter function** is approximated using a **FeedForward Neural Network**, which is **trainable** during the training phase. The way in which the integral is approximated can vary. In the **PINA** framework, we approximate it using a simple sum, as suggested by the authors. Thus, given the points $\\{\\mathbf{x}_i\\}_{i=1}^{n}$ in $\\mathbb{R}^N$ mapped onto the filter domain $\\mathcal{X}$, we approximate the equation as:\n", "\n", "$$\n", " \\mathcal{I}_{\\rm{out}}(\\mathbf{\\tilde{x}}_i) = \\sum_{{\\mathbf{x}_i}\\in\\mathcal{X}} \\mathcal{I}(\\mathbf{x}_i + \\mathbf{\\tau}) \\cdot \\mathcal{K}(\\mathbf{x}_i),\n", "$$\n", "\n", "where $\\mathbf{\\tau} \\in \\mathcal{S}$, with $\\mathcal{S}$ being the set of available strides, represents the current stride position of the filter. The $\\mathbf{\\tilde{x}}_i$ points are obtained by taking the **centroid** of the filter position mapped onto the domain $\\Omega$.\n", "\n", "### Working with the Continuous Filter\n", "\n", "From the above definition, what is needed is:\n", "1. A **domain** and a **function** defined on that domain (the input),\n", "2. A **stride**, corresponding to the positions where the filter needs to be applied (this is the `stride` variable in `ContinuousConv`),\n", "3. The **filter's rectangular domain**, which corresponds to the `filter_dim` variable in `ContinuousConv`.\n", "\n", "### Input Function\n", "\n", "The input function for the continuous filter is defined as a tensor of shape:\n", "\n", "$$[B \\times N_{\\text{in}} \\times N \\times D]$$\n", "\n", "where:\n", "- $B$ is the **batch size**,\n", "- $N_{\\text{in}}$ is the number of input fields,\n", "- $N$ is the number of points in the mesh,\n", "- $D$ is the dimension of the problem. \n", "\n", "In particular:\n", "- $D$ represents the **number of spatial variables** + 1. The last column must contain the field value. For example, for 2D problems, $D=3$ and the tensor will look like `[first coordinate, second coordinate, field value]`.\n", "- $N_{\\text{in}}$ represents the number of vectorial functions presented. For example, a vectorial function $f = [f_1, f_2]$ will have $N_{\\text{in}}=2$.\n", "\n", "#### Example: Input Function for a Vectorial Field\n", "\n", "Let’s see an example to clarify the idea. Suppose we wish to create the function:\n", "\n", "$$\n", "f(x, y) = [\\sin(\\pi x) \\sin(\\pi y), -\\sin(\\pi x) \\sin(\\pi y)] \\quad (x,y)\\in[0,1]\\times[0,1]\n", "$$\n", "\n", "We can do this with a **batch size** equal to 1. This function consists of two components (vectorial field), so $N_{\\text{in}}=2$. For each $(x,y)$ pair in the domain $[0,1] \\times [0,1]$, we will compute the corresponding field values:\n", "\n", "1. $\\sin(\\pi x) \\sin(\\pi y)$\n", "2. $-\\sin(\\pi x) \\sin(\\pi y)$" ] }, { "cell_type": "code", "execution_count": 2, "id": "447bb133", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Domain has shape: torch.Size([1, 2, 200, 2])\n", "Filter input data has shape: torch.Size([1, 2, 200, 3])\n" ] } ], "source": [ "# batch size fixed to 1\n", "batch_size = 1\n", "\n", "# points in the mesh fixed to 200\n", "N = 200\n", "\n", "# vectorial 2 dimensional function, number_input_fields=2\n", "number_input_fields = 2\n", "\n", "# 2 dimensional spatial variables, D = 2 + 1 = 3\n", "D = 3\n", "\n", "# create the function f domain as random 2d points in [0, 1]\n", "domain = torch.rand(size=(batch_size, number_input_fields, N, D - 1))\n", "print(f\"Domain has shape: {domain.shape}\")\n", "\n", "# create the functions\n", "pi = torch.acos(torch.tensor([-1.0])) # pi value\n", "f1 = torch.sin(pi * domain[:, 0, :, 0]) * torch.sin(pi * domain[:, 0, :, 1])\n", "f2 = -torch.sin(pi * domain[:, 1, :, 0]) * torch.sin(pi * domain[:, 1, :, 1])\n", "\n", "# stacking the input domain and field values\n", "data = torch.empty(size=(batch_size, number_input_fields, N, D))\n", "data[..., :-1] = domain # copy the domain\n", "data[:, 0, :, -1] = f1 # copy first field value\n", "data[:, 1, :, -1] = f1 # copy second field value\n", "print(f\"Filter input data has shape: {data.shape}\")" ] }, { "cell_type": "markdown", "id": "e93d6afd", "metadata": {}, "source": [ "### Stride\n", "\n", "The **stride** is passed as a dictionary `stride` that dictates where the filter should move. Here's an example for the domain $[0,1] \\times [0,5]$:\n", "\n", "```python\n", "# stride definition\n", "stride = {\"domain\": [1, 5],\n", " \"start\": [0, 0],\n", " \"jump\": [0.1, 0.3],\n", " \"direction\": [1, 1],\n", " }\n", "```\n", "This tells the filter:\n", "1. `domain`: The domain over which the filter operates. In this case, the filter works over the $[0,1] \\times [0,5]$ domain. The minimum value is always zero, and the maximum value is specified by the user.\n", "2. `start`: The starting position of the filter's centroid. In this example, the filter starts at the position $(0, 0)$.\n", "3. `jump`: The steps or jumps of the filter’s centroid to the next position. In this example, the filter moves by $(0.1, 0.3)$ along the x and y axes respectively.\n", "4. `direction`: The directions of the jumps for each coordinate. A value of 1 indicates the filter moves right, 0 means no movement, and -1 indicates the filter moves left with respect to its current position.\n", "\n", "### Filter definition\n", "\n", "Now that we have defined the stride, we can move on to construct the continuous filter.\n", "Let’s assume we want the output to contain only one field, and we will set the filter dimension to be $[0.1, 0.1]$." ] }, { "cell_type": "code", "execution_count": 3, "id": "b78c08b8", "metadata": {}, "outputs": [], "source": [ "# filter dim\n", "filter_dim = [0.1, 0.1]\n", "\n", "# stride\n", "stride = {\n", " \"domain\": [1, 1],\n", " \"start\": [0, 0],\n", " \"jump\": [0.08, 0.08],\n", " \"direction\": [1, 1],\n", "}\n", "\n", "# creating the filter\n", "cConv = ContinuousConvBlock(\n", " input_numb_field=number_input_fields,\n", " output_numb_field=1,\n", " filter_dim=filter_dim,\n", " stride=stride,\n", ")" ] }, { "cell_type": "markdown", "id": "49ccc992", "metadata": {}, "source": [ "That's it! In just one line of code, we have successfully created the continuous convolutional filter. By default, the `pina.model.FeedForward` neural network is initialized, which can be further customized according to your needs.\n", "\n", "Additionally, if the mesh does not change during training, we can set the `optimize` flag to `True` to leverage optimizations for efficiently finding the points to convolve. This feature helps in improving the performance by reducing redundant calculations when the mesh remains constant." ] }, { "cell_type": "code", "execution_count": 4, "id": "0fbe67dc", "metadata": {}, "outputs": [], "source": [ "# creating the filter + optimization\n", "cConv = ContinuousConvBlock(\n", " input_numb_field=number_input_fields,\n", " output_numb_field=1,\n", " filter_dim=filter_dim,\n", " stride=stride,\n", " optimize=True,\n", ")" ] }, { "cell_type": "markdown", "id": "f99c290e", "metadata": {}, "source": [ "Let's try to do a forward pass:" ] }, { "cell_type": "code", "execution_count": 5, "id": "07580a3c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Filter input data has shape: torch.Size([1, 2, 200, 3])\n", "Filter output data has shape: torch.Size([1, 1, 169, 3])\n" ] } ], "source": [ "print(f\"Filter input data has shape: {data.shape}\")\n", "\n", "# input to the filter\n", "output = cConv(data)\n", "\n", "print(f\"Filter output data has shape: {output.shape}\")" ] }, { "cell_type": "markdown", "id": "886cf50f", "metadata": {}, "source": [ "If you don't want to use the default `FeedForward` neural network, you can pass a custom PyTorch model by specifying it in the `model` keyword. Here's an example of how to do it:" ] }, { "cell_type": "code", "execution_count": 6, "id": "0e234c69", "metadata": {}, "outputs": [], "source": [ "class SimpleKernel(torch.nn.Module):\n", " def __init__(self) -> None:\n", " super().__init__()\n", " self.model = torch.nn.Sequential(\n", " torch.nn.Linear(2, 20),\n", " torch.nn.ReLU(),\n", " torch.nn.Linear(20, 20),\n", " torch.nn.ReLU(),\n", " torch.nn.Linear(20, 1),\n", " )\n", "\n", " def forward(self, x):\n", " return self.model(x)\n", "\n", "\n", "cConv = ContinuousConvBlock(\n", " input_numb_field=number_input_fields,\n", " output_numb_field=1,\n", " filter_dim=filter_dim,\n", " stride=stride,\n", " optimize=True,\n", " model=SimpleKernel,\n", ")" ] }, { "cell_type": "markdown", "id": "2d4318ab", "metadata": {}, "source": [ "Notice that we pass the **class** of the model and not an already built object! This is important because the `ContinuousConv` filter will automatically instantiate the model class when needed during training. \n", "\n", "## Building a MNIST Classifier\n", "\n", "Let's see how we can build a MNIST classifier using a continuous convolutional filter. We will use the MNIST dataset from PyTorch. In order to keep small training times we use only 6000 samples for training and 1000 samples for testing." ] }, { "cell_type": "code", "execution_count": 7, "id": "6d816e7a", "metadata": {}, "outputs": [], "source": [ "numb_training = 6000 # get just 6000 images for training\n", "numb_testing = 1000 # get just 1000 images for training\n", "seed = 111 # for reproducibility\n", "batch_size = 8 # setting batch size\n", "\n", "# setting the seed\n", "torch.manual_seed(seed)\n", "\n", "# downloading the dataset\n", "train_data = torchvision.datasets.MNIST(\n", " \"./tutorial_logs/\",\n", " download=True,\n", " train=False,\n", " transform=torchvision.transforms.Compose(\n", " [\n", " torchvision.transforms.ToTensor(),\n", " torchvision.transforms.Normalize((0.1307,), (0.3081,)),\n", " ]\n", " ),\n", ")" ] }, { "cell_type": "markdown", "id": "7f076010", "metadata": {}, "source": [ "Now, let's proceed to build a simple classifier for the MNIST dataset. The MNIST dataset consists of vectors with the shape `[batch, 1, 28, 28]`, but we can treat them as field functions where each pixel at coordinates $i,j$ corresponds to a point in a $[0, 27] \\times [0, 27]$ domain. The pixel values represent the field values.\n", "\n", "To use the continuous convolutional filter, we need to transform the regular tensor into a format compatible with the filter. Here's a function that will help with this transformation:" ] }, { "cell_type": "code", "execution_count": 8, "id": "a872fb2d", "metadata": {}, "outputs": [], "source": [ "def transform_input(x):\n", " batch_size = x.shape[0]\n", " dim_grid = tuple(x.shape[:-3:-1])\n", "\n", " # creating the n dimensional mesh grid for a single channel image\n", " values_mesh = [torch.arange(0, dim).float() for dim in dim_grid]\n", " mesh = torch.meshgrid(values_mesh)\n", " coordinates_mesh = [m.reshape(-1, 1).to(x.device) for m in mesh]\n", " coordinates = (\n", " torch.cat(coordinates_mesh, dim=1)\n", " .unsqueeze(0)\n", " .repeat((batch_size, 1, 1))\n", " .unsqueeze(1)\n", " )\n", "\n", " return torch.cat((coordinates, x.flatten(2).unsqueeze(-1)), dim=-1)" ] }, { "cell_type": "markdown", "id": "850b45c4", "metadata": {}, "source": [ "We can now build a simple classifier! We will use just one convolutional filter followed by a feedforward neural network" ] }, { "cell_type": "code", "execution_count": 9, "id": "889c1592", "metadata": {}, "outputs": [], "source": [ "# setting the seed\n", "torch.manual_seed(seed)\n", "\n", "\n", "class ContinuousClassifier(torch.nn.Module):\n", " def __init__(self):\n", " super().__init__()\n", "\n", " # number of classes for classification\n", " numb_class = 10\n", "\n", " # convolutional block\n", " self.convolution = ContinuousConvBlock(\n", " input_numb_field=1,\n", " output_numb_field=4,\n", " stride={\n", " \"domain\": [27, 27],\n", " \"start\": [0, 0],\n", " \"jumps\": [4, 4],\n", " \"direction\": [1, 1.0],\n", " },\n", " filter_dim=[4, 4],\n", " optimize=True,\n", " )\n", " # feedforward net\n", " self.nn = FeedForward(\n", " input_dimensions=196,\n", " output_dimensions=numb_class,\n", " layers=[120, 64],\n", " func=torch.nn.ReLU,\n", " )\n", "\n", " def forward(self, x):\n", " # transform input + convolution\n", " x = transform_input(x)\n", " x = self.convolution(x)\n", " # feed forward classification\n", " return self.nn(x[..., -1].flatten(1))" ] }, { "cell_type": "markdown", "id": "4374c15c", "metadata": {}, "source": [ "We now aim to solve a classification problem. For this we will use the `SupervisedSolver` and the `SupervisedProblem`. The input of the supervised problems are the images, while the output the corresponding class. We will train with `CrossEntropyLoss`." ] }, { "cell_type": "code", "execution_count": 10, "id": "0446afe0", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (mps), used: False\n", "TPU available: False, using: 0 TPU cores\n", "HPU available: False, using: 0 HPUs\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "a70679a4feaa449db15d18c17588cf51", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: | | 0/? [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# create inputs\n", "def circle_grid(N=100):\n", " \"\"\"Generate points withing a unit 2D circle centered in (0.5, 0.5)\n", "\n", " :param N: number of points\n", " :type N: float\n", " :return: [x, y] array of points\n", " :rtype: torch.tensor\n", " \"\"\"\n", "\n", " PI = torch.acos(torch.zeros(1)).item() * 2\n", " R = 0.5\n", " centerX = 0.5\n", " centerY = 0.5\n", "\n", " r = R * torch.sqrt(torch.rand(N))\n", " theta = torch.rand(N) * 2 * PI\n", "\n", " x = centerX + r * torch.cos(theta)\n", " y = centerY + r * torch.sin(theta)\n", "\n", " return torch.stack([x, y]).T\n", "\n", "\n", "# create the grid\n", "grid = circle_grid(500)\n", "\n", "# create input\n", "input_data = torch.empty(size=(1, 1, grid.shape[0], 3))\n", "input_data[0, 0, :, :-1] = grid\n", "input_data[0, 0, :, -1] = torch.sin(pi * grid[:, 0]) * torch.sin(\n", " pi * grid[:, 1]\n", ")\n", "\n", "# visualize data\n", "plt.title(\"Training sample with 500 points\")\n", "plt.scatter(grid[:, 0], grid[:, 1], c=input_data[0, 0, :, -1])\n", "plt.colorbar()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "ab6f5987", "metadata": {}, "source": [ "Now, let's create a simple autoencoder using the continuous convolutional filter. Since the data is inherently unstructured, a standard convolutional filter may not be effective without some form of projection or interpolation. We'll begin by building an `Encoder` and `Decoder` class, and then combine them into a unified `Autoencoder` class.\n" ] }, { "cell_type": "code", "execution_count": 13, "id": "13e8ae0e", "metadata": {}, "outputs": [], "source": [ "class Encoder(torch.nn.Module):\n", " def __init__(self, hidden_dimension):\n", " super().__init__()\n", "\n", " # convolutional block\n", " self.convolution = ContinuousConvBlock(\n", " input_numb_field=1,\n", " output_numb_field=2,\n", " stride={\n", " \"domain\": [1, 1],\n", " \"start\": [0, 0],\n", " \"jumps\": [0.05, 0.05],\n", " \"direction\": [1, 1.0],\n", " },\n", " filter_dim=[0.15, 0.15],\n", " optimize=True,\n", " )\n", " # feedforward net\n", " self.nn = FeedForward(\n", " input_dimensions=400,\n", " output_dimensions=hidden_dimension,\n", " layers=[240, 120],\n", " )\n", "\n", " def forward(self, x):\n", " # convolution\n", " x = self.convolution(x)\n", " # feed forward pass\n", " return self.nn(x[..., -1])\n", "\n", "\n", "class Decoder(torch.nn.Module):\n", " def __init__(self, hidden_dimension):\n", " super().__init__()\n", "\n", " # convolutional block\n", " self.convolution = ContinuousConvBlock(\n", " input_numb_field=2,\n", " output_numb_field=1,\n", " stride={\n", " \"domain\": [1, 1],\n", " \"start\": [0, 0],\n", " \"jumps\": [0.05, 0.05],\n", " \"direction\": [1, 1.0],\n", " },\n", " filter_dim=[0.15, 0.15],\n", " optimize=True,\n", " )\n", " # feedforward net\n", " self.nn = FeedForward(\n", " input_dimensions=hidden_dimension,\n", " output_dimensions=400,\n", " layers=[120, 240],\n", " )\n", "\n", " def forward(self, weights, grid):\n", " # feed forward pass\n", " x = self.nn(weights)\n", " # transpose convolution\n", " return torch.sigmoid(self.convolution.transpose(x, grid))" ] }, { "cell_type": "markdown", "id": "eb097e34", "metadata": {}, "source": [ "Great! In the `Decoder` class, during the `forward` pass, we used the `.transpose()` method of the `ContinuousConvolution` class. This method takes the `weights` for upsampling and the `grid` on which to perform the upsampling. Now, let's go ahead and build the autoencoder! We'll define the hidden dimension with the `hidden_dimension` variable, and apply the sigmoid function on the output since the field values are constrained within the range $[0, 1]$." ] }, { "cell_type": "code", "execution_count": 14, "id": "a4db89a7", "metadata": {}, "outputs": [], "source": [ "class Autoencoder(torch.nn.Module):\n", " def __init__(self, hidden_dimension=10):\n", " super().__init__()\n", "\n", " self.encoder = Encoder(hidden_dimension)\n", " self.decoder = Decoder(hidden_dimension)\n", "\n", " def forward(self, x):\n", " # saving grid for later upsampling\n", " grid = x.clone().detach()\n", " # encoder\n", " weights = self.encoder(x)\n", " # decoder\n", " out = self.decoder(weights, grid)\n", " return out" ] }, { "cell_type": "markdown", "id": "2df482a7", "metadata": {}, "source": [ "Now, let's proceed with training the autoencoder by minimizing the mean squared error (MSE) loss and optimizing using the Adam optimizer. We'll use the `SupervisedSolver` for the training, and the problem will be defined as a simple problem inherited from `AbstractProblem`." ] }, { "cell_type": "code", "execution_count": 15, "id": "700a7cf3", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "GPU available: True (mps), used: False\n", "TPU available: False, using: 0 TPU cores\n", "HPU available: False, using: 0 HPUs\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "2b5c90e63e5649a09132869ff4ffcd47", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Training: | | 0/? [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "solver.eval()\n", "\n", "# get output and detach from computational graph for plotting\n", "output = solver(input_data).detach()\n", "\n", "# visualize data\n", "fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(8, 3))\n", "pic1 = axes[0].scatter(grid[:, 0], grid[:, 1], c=input_data[0, 0, :, -1])\n", "axes[0].set_title(\"Real\")\n", "fig.colorbar(pic1)\n", "plt.subplot(1, 2, 2)\n", "pic2 = axes[1].scatter(grid[:, 0], grid[:, 1], c=output[0, 0, :, -1])\n", "axes[1].set_title(\"Autoencoder\")\n", "fig.colorbar(pic2)\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "206141f9", "metadata": {}, "source": [ "As observed, the two solutions are nearly identical! We can also compute the $l_2$ error between the real solution and the autoencoder's reconstruction quite easily:" ] }, { "cell_type": "code", "execution_count": 17, "id": "ded8f91b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "l2 error: 4.78%\n" ] } ], "source": [ "def l2_error(input_, target):\n", " return torch.linalg.norm(input_ - target, ord=2) / torch.linalg.norm(\n", " input_, ord=2\n", " )\n", "\n", "\n", "print(f\"l2 error: {l2_error(input_data[0, 0, :, -1], output[0, 0, :, -1]):.2%}\")" ] }, { "cell_type": "markdown", "id": "c30996c4", "metadata": {}, "source": [ "The $l_2$ error is approximately $4\\%$, which is quite low considering that we only use **one** convolutional layer and a simple feedforward network to reduce the dimension. Now, let's explore some of the unique features of the filter.\n", "\n", "### Upsampling with the Filter\n", "\n", "Suppose we have a hidden representation and we want to upsample it on a different grid with more points. Let's see how we can achieve that:" ] }, { "cell_type": "code", "execution_count": 18, "id": "fcbbaec6", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# setting the seed\n", "torch.manual_seed(seed)\n", "\n", "grid2 = circle_grid(1500) # triple number of points\n", "input_data2 = torch.zeros(size=(1, 1, grid2.shape[0], 3))\n", "input_data2[0, 0, :, :-1] = grid2\n", "input_data2[0, 0, :, -1] = torch.sin(pi * grid2[:, 0]) * torch.sin(\n", " pi * grid2[:, 1]\n", ")\n", "\n", "# get the hidden representation from original input\n", "latent = solver.model.encoder(input_data)\n", "\n", "# upsample on the second input_data2\n", "output = solver.model.decoder(latent, input_data2).detach()\n", "\n", "# show the picture\n", "fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(8, 3))\n", "pic1 = axes[0].scatter(grid2[:, 0], grid2[:, 1], c=input_data2[0, 0, :, -1])\n", "axes[0].set_title(\"Real\")\n", "fig.colorbar(pic1)\n", "plt.subplot(1, 2, 2)\n", "pic2 = axes[1].scatter(grid2[:, 0], grid2[:, 1], c=output[0, 0, :, -1])\n", "axes[1].set_title(\"Up-sampling\")\n", "fig.colorbar(pic2)\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "2cbf14b5", "metadata": {}, "source": [ "As we can see, we have a very good approximation of the original function, although some noise is present. Let's now calculate the error:" ] }, { "cell_type": "code", "execution_count": 19, "id": "ab505b75", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "l2 error: 9.72%\n" ] } ], "source": [ "print(\n", " f\"l2 error: {l2_error(input_data2[0, 0, :, -1], output[0, 0, :, -1]):.2%}\"\n", ")" ] }, { "cell_type": "markdown", "id": "8e720e55", "metadata": {}, "source": [ "## What's Next?\n", "\n", "Congratulations on completing the tutorial on using the Continuous Convolutional Filter in **PINA**! Now that you have the basics, there are several exciting directions you can explore:\n", "\n", "1. **Train using Physics-Informed strategies**: Leverage physics-based knowledge to improve model performance for solving real-world problems.\n", "\n", "2. **Use the filter to build an unstructured convolutional autoencoder**: Explore reduced-order modeling by implementing unstructured convolutional autoencoders.\n", "\n", "3. **Experiment with upsampling at different resolutions**: Try encoding or upsampling on different grids to see how the model generalizes across multiple resolutions.\n", "\n", "4. **...and many more!**: There are endless possibilities, from improving model architecture to testing with more complex datasets.\n", "\n", "For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/)." ] } ], "metadata": { "kernelspec": { "display_name": "pina", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.21" } }, "nbformat": 4, "nbformat_minor": 5 }