{ "cells": [ { "cell_type": "markdown", "id": "48dd2795", "metadata": {}, "source": [ "# Tutorial: Unstructured convolutional autoencoder via continuous convolution\n", "\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)." ] }, { "cell_type": "markdown", "id": "80e8bfac", "metadata": {}, "source": [ "First of all we import the modules needed for the tutorial:" ] }, { "cell_type": "code", "execution_count": 1, "id": "5ae7c0e8", "metadata": {}, "outputs": [], "source": [ "## routine needed to run the notebook on Google Colab\n", "try:\n", " import google.colab\n", " IN_COLAB = True\n", "except:\n", " IN_COLAB = False\n", "if IN_COLAB:\n", " !pip install \"pina-mathlab\"\n", "\n", "import torch \n", "import matplotlib.pyplot as plt \n", "plt.style.use('tableau-colorblind10')\n", "from pina.problem import AbstractProblem\n", "from pina.solver import SupervisedSolver\n", "from pina.trainer import Trainer\n", "from pina import Condition, LabelTensor\n", "from pina.model.block import ContinuousConvBlock \n", "import torchvision # for MNIST dataset\n", "from pina.model import FeedForward # for building AE and MNIST classification" ] }, { "cell_type": "markdown", "id": "4094758f", "metadata": {}, "source": [ "The tutorial is structured as follow: \n", "* [Continuous filter background](#continuous-filter-background): understand how the convolutional filter works and how to use it.\n", "* [Building a MNIST Classifier](#building-a-mnist-classifier): show how to build a simple classifier using the MNIST dataset and how to combine a continuous convolutional layer with a feedforward neural network. \n", "* [Building a Continuous Convolutional Autoencoder](#building-a-continuous-convolutional-autoencoder): show how to use the continuous filter to work with unstructured data for autoencoding and up-sampling." ] }, { "cell_type": "markdown", "id": "87327478", "metadata": {}, "source": [ "## Continuous filter background" ] }, { "cell_type": "markdown", "id": "7f1aa4ef", "metadata": {}, "source": [ "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", "where $\\mathcal{K} : \\mathcal{X} \\rightarrow \\mathbb{R}$ is the *continuous filter* function, and $\\mathcal{I} : \\Omega \\subset \\mathbb{R}^N \\rightarrow \\mathbb{R}$ is the input function. The continuous filter function is approximated using a FeedForward Neural Network, thus trainable during the training phase. The way in which the integral is approximated can be different, currently on **PINA** we approximate it using a simple sum, as suggested by the authors. Thus, given $\\{\\mathbf{x}_i\\}_{i=1}^{n}$ points in $\\mathbb{R}^N$ of the input function mapped on the $\\mathcal{X}$ filter domain, we approximate the above equation as:\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", "where $\\mathbf{\\tau} \\in \\mathcal{S}$, with $\\mathcal{S}$ the set of available strides, corresponds to the current stride position of the filter, and $\\mathbf{\\tilde{x}}_i$ points are obtained by taking the centroid of the filter position mapped on the $\\Omega$ domain. " ] }, { "cell_type": "markdown", "id": "a2ea9c78", "metadata": {}, "source": [ "We will now try to pratically see how to work with the filter. From the above definition we see that 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 $\\rightarrow$ `stride` variable in `ContinuousConv`\n", "3. The filter rectangular domain $\\rightarrow$ `filter_dim` variable in `ContinuousConv`" ] }, { "cell_type": "markdown", "id": "ac896875", "metadata": {}, "source": [ "### Input function\n", "\n", "The input function for the continuous filter is defined as a tensor of shape: $$[B \\times N_{in} \\times N \\times D]$$ where $B$ is the batch_size, $N_{in}$ is the number of input fields, $N$ the number of points in the mesh, $D$ the dimension of the problem. In particular:\n", "* $D$ is 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 be something like `[first coordinate, second coordinate, field value]`\n", "* $N_{in}$ represents the number of vectorial function presented. For example a vectorial function $f = [f_1, f_2]$ will have $N_{in}=2$ \n", "\n", "Let's see an example to clear the ideas. We will be verbose to explain in details the input form. We wish to create the function:\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", "using a batch size equal to 1." ] }, { "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.])) # 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` which tells the filter where to go. Here is an example for the $[0,1]\\times[0,5]$ domain:\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`: square domain (the only implemented) $[0,1]\\times[0,5]$. The minimum value is always zero, while the maximum is specified by the user\n", "2. `start`: start position of the filter, coordinate $(0, 0)$\n", "3. `jump`: the jumps of the centroid of the filter to the next position $(0.1, 0.3)$\n", "4. `direction`: the directions of the jump, with `1 = right`, `0 = no jump`, `-1 = left` with respect to the current position\n", "\n", "**Note**\n", "\n", "We are planning to release the possibility to directly pass a list of possible strides!" ] }, { "cell_type": "markdown", "id": "71c13ef2", "metadata": {}, "source": [ "### Filter definition\n", "\n", "Having defined all the previous blocks, we are now able to construct the continuous filter.\n", "\n", "Suppose we would like to get an output with only one field, and let us fix the filter dimension to be $[0.1, 0.1]$." ] }, { "cell_type": "code", "execution_count": 3, "id": "b78c08b8", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/var/data/python/lib/python3.12/site-packages/torch/functional.py: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at /pytorch/aten/src/ATen/native/TensorShape.cpp:3637.)\n" ] } ], "source": [ "# filter dim\n", "filter_dim = [0.1, 0.1]\n", "\n", "# stride\n", "stride = {\"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(input_numb_field=number_input_fields,\n", " output_numb_field=1,\n", " filter_dim=filter_dim,\n", " stride=stride)" ] }, { "cell_type": "markdown", "id": "49ccc992", "metadata": {}, "source": [ "That's it! In just one line of code we have created the continuous convolutional filter. By default the `pina.model.FeedForward` neural network is intitialised, more on the [documentation](https://mathlab.github.io/PINA/_rst/fnn.html). In case the mesh doesn't change during training we can set the `optimize` flag equals to `True`, to exploit optimizations for finding the points to convolve." ] }, { "cell_type": "code", "execution_count": 4, "id": "0fbe67dc", "metadata": {}, "outputs": [], "source": [ "# creating the filter + optimization\n", "cConv = ContinuousConvBlock(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 we don't want to use the default `FeedForward` neural network, we can pass a specified torch model in the `model` keyword as follow: \n" ] }, { "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", " def forward(self, x):\n", " return self.model(x)\n", "\n", "\n", "cConv = ContinuousConvBlock(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 and not an already built object!" ] }, { "cell_type": "markdown", "id": "254e8c8d", "metadata": {}, "source": [ "## 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": [ "from torch.utils.data import DataLoader, SubsetRandomSampler\n", "\n", "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('./data/', train=True, download=True,\n", " transform=torchvision.transforms.Compose([\n", " torchvision.transforms.ToTensor(),\n", " torchvision.transforms.Normalize(\n", " (0.1307,), (0.3081,))\n", " ]))\n", "subsample_train_indices = torch.randperm(len(train_data))[:numb_training]\n", "train_loader = DataLoader(train_data, batch_size=batch_size,\n", " sampler=SubsetRandomSampler(subsample_train_indices))\n", "\n", "test_data = torchvision.datasets.MNIST('./data/', train=False, download=True,\n", " transform=torchvision.transforms.Compose([\n", " torchvision.transforms.ToTensor(),\n", " torchvision.transforms.Normalize(\n", " (0.1307,), (0.3081,))\n", " ]))\n", "subsample_test_indices = torch.randperm(len(train_data))[:numb_testing]\n", "test_loader = DataLoader(train_data, batch_size=batch_size,\n", " sampler=SubsetRandomSampler(subsample_train_indices))" ] }, { "cell_type": "markdown", "id": "7f076010", "metadata": {}, "source": [ "Let's now build a simple classifier. The MNIST dataset is composed by vectors of shape `[batch, 1, 28, 28]`, but we can image them as one field functions where the pixels $ij$ are the coordinate $x=i, y=j$ in a $[0, 27]\\times[0,27]$ domain, and the pixels values are the field values. We just need a function to transform the regular tensor in a tensor compatible for the continuous filter:" ] }, { "cell_type": "code", "execution_count": 8, "id": "a872fb2d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Original MNIST image shape: torch.Size([8, 1, 28, 28])\n", "Transformed MNIST image shape: torch.Size([8, 1, 784, 3])\n" ] } ], "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 = [x.reshape(-1, 1) for x in mesh]\n", " coordinates = torch.cat(coordinates_mesh, dim=1).unsqueeze(\n", " 0).repeat((batch_size, 1, 1)).unsqueeze(1)\n", "\n", " return torch.cat((coordinates, x.flatten(2).unsqueeze(-1)), dim=-1)\n", "\n", "\n", "# let's try it out\n", "image, s = next(iter(train_loader))\n", "print(f\"Original MNIST image shape: {image.shape}\")\n", "\n", "image_transformed = transform_input(image)\n", "print(f\"Transformed MNIST image shape: {image_transformed.shape}\")\n" ] }, { "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", "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(input_numb_field=1,\n", " output_numb_field=4,\n", " stride={\"domain\": [27, 27],\n", " \"start\": [0, 0],\n", " \"jumps\": [4, 4],\n", " \"direction\": [1, 1.],\n", " },\n", " filter_dim=[4, 4],\n", " optimize=True)\n", " # feedforward net\n", " self.nn = FeedForward(input_dimensions=196,\n", " output_dimensions=numb_class,\n", " layers=[120, 64],\n", " func=torch.nn.ReLU)\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))\n", "\n", "\n", "net = ContinuousClassifier()" ] }, { "cell_type": "markdown", "id": "4374c15c", "metadata": {}, "source": [ "Let's try to train it using a simple pytorch training loop. We train for just 1 epoch using Adam optimizer with a $0.001$ learning rate." ] }, { "cell_type": "code", "execution_count": 10, "id": "0446afe0", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "batch [50/750] loss[0.161]\n", "batch [100/750] loss[0.073]\n", "batch [150/750] loss[0.063]\n", "batch [200/750] loss[0.051]\n", "batch [250/750] loss[0.044]\n", "batch [300/750] loss[0.050]\n", "batch [350/750] loss[0.053]\n", "batch [400/750] loss[0.049]\n", "batch [450/750] loss[0.046]\n", "batch [500/750] loss[0.034]\n", "batch [550/750] loss[0.036]\n", "batch [600/750] loss[0.040]\n", "batch [650/750] loss[0.028]\n", "batch [700/750] loss[0.041]\n", "batch [750/750] loss[0.040]\n" ] } ], "source": [ "# setting the seed\n", "torch.manual_seed(seed)\n", "\n", "# optimizer and loss function\n", "optimizer = torch.optim.Adam(net.parameters(), lr=0.001)\n", "criterion = torch.nn.CrossEntropyLoss()\n", "\n", "for epoch in range(1): # loop over the dataset multiple times\n", "\n", " running_loss = 0.0\n", " for i, data in enumerate(train_loader, 0):\n", " # get the inputs; data is a list of [inputs, labels]\n", " inputs, labels = data\n", "\n", " # zero the parameter gradients\n", " optimizer.zero_grad()\n", "\n", " # forward + backward + optimize\n", " outputs = net(inputs)\n", " loss = criterion(outputs, labels)\n", " loss.backward()\n", " optimizer.step()\n", "\n", " # print statistics\n", " running_loss += loss.item()\n", " if i % 50 == 49: \n", " print(\n", " f'batch [{i + 1}/{numb_training//batch_size}] loss[{running_loss / 500:.3f}]')\n", " running_loss = 0.0\n" ] }, { "cell_type": "markdown", "id": "47fa3d0e", "metadata": {}, "source": [ "Let's see the performance on the test set!" ] }, { "cell_type": "code", "execution_count": 11, "id": "b54638c1", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy of the network on the 1000 test images: 92.683%\n" ] } ], "source": [ "correct = 0\n", "total = 0\n", "with torch.no_grad():\n", " for data in test_loader:\n", " images, labels = data\n", " # calculate outputs by running images through the network\n", " outputs = net(images)\n", " # the class with the highest energy is what we choose as prediction\n", " _, predicted = torch.max(outputs.data, 1)\n", " total += labels.size(0)\n", " correct += (predicted == labels).sum().item()\n", "\n", "print(\n", " f'Accuracy of the network on the 1000 test images: {(correct / total):.3%}')\n" ] }, { "cell_type": "markdown", "id": "25cf2878", "metadata": {}, "source": [ "As we can see we have very good performance for having trained only for 1 epoch! Nevertheless, we are still using structured data... Let's see how we can build an autoencoder for unstructured data now." ] }, { "cell_type": "markdown", "id": "3ce758e9", "metadata": {}, "source": [ "## Building a Continuous Convolutional Autoencoder\n", "\n", "Just as toy problem, we will now build an autoencoder for the following function $f(x,y)=\\sin(\\pi x)\\sin(\\pi y)$ on the unit circle domain centered in $(0.5, 0.5)$. We will also see the ability to up-sample (once trained) the results without retraining. Let's first create the input and visualize it, we will use firstly a mesh of $100$ points." ] }, { "cell_type": "code", "execution_count": 12, "id": "6ca0e929", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "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", "# 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(pi * grid[:, 1])\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()\n" ] }, { "cell_type": "markdown", "id": "ab6f5987", "metadata": {}, "source": [ "Let's now build a simple autoencoder using the continuous convolutional filter. The data is clearly unstructured and a simple convolutional filter might not work without projecting or interpolating first. Let's first build and `Encoder` and `Decoder` class, and then a `Autoencoder` class that contains both." ] }, { "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(input_numb_field=1,\n", " output_numb_field=2,\n", " stride={\"domain\": [1, 1],\n", " \"start\": [0, 0],\n", " \"jumps\": [0.05, 0.05],\n", " \"direction\": [1, 1.],\n", " },\n", " filter_dim=[0.15, 0.15],\n", " optimize=True)\n", " # feedforward net\n", " self.nn = FeedForward(input_dimensions=400,\n", " output_dimensions=hidden_dimension,\n", " layers=[240, 120])\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(input_numb_field=2,\n", " output_numb_field=1,\n", " stride={\"domain\": [1, 1],\n", " \"start\": [0, 0],\n", " \"jumps\": [0.05, 0.05],\n", " \"direction\": [1, 1.],\n", " },\n", " filter_dim=[0.15, 0.15],\n", " optimize=True)\n", " # feedforward net\n", " self.nn = FeedForward(input_dimensions=hidden_dimension,\n", " output_dimensions=400,\n", " layers=[120, 240])\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))\n" ] }, { "cell_type": "markdown", "id": "eb097e34", "metadata": {}, "source": [ "Very good! Notice that in the `Decoder` class in the `forward` pass we have used the `.transpose()` method of the `ContinuousConvolution` class. This method accepts the `weights` for upsampling and the `grid` on where to upsample. Let's now build the autoencoder! We set the hidden dimension in the `hidden_dimension` variable. We apply the sigmoid on the output since the field value is between $[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\n", "\n", "net = Autoencoder()" ] }, { "cell_type": "markdown", "id": "2df482a7", "metadata": {}, "source": [ "Let's now train the autoencoder, minimizing the mean square error loss and optimizing using Adam. We use the `SupervisedSolver` as solver, and the problem is a simple problem created by inheriting from `AbstractProblem`. It takes approximately two minutes to train on CPU." ] }, { "cell_type": "code", "execution_count": 15, "id": "700a7cf3", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "GPU available: False, 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": "2906d21242d84dc8889125249c8e688f", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Sanity Checking: | | 0/? [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "net.eval()\n", "\n", "# get output and detach from computational graph for plotting\n", "output = net(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()\n" ] }, { "cell_type": "markdown", "id": "206141f9", "metadata": {}, "source": [ "As we can see, the two solutions are really similar! We can compute the $l_2$ error quite easily as well:" ] }, { "cell_type": "code", "execution_count": 17, "id": "ded8f91b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "l2 error: 4.25%\n" ] } ], "source": [ "def l2_error(input_, target):\n", " return torch.linalg.norm(input_-target, ord=2)/torch.linalg.norm(input_, ord=2)\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": [ "More or less $4\\%$ in $l_2$ error, which is really low considering the fact that we use just **one** convolutional layer and a simple feedforward to decrease the dimension. Let's see now some peculiarity of the filter." ] }, { "cell_type": "markdown", "id": "f76db3b5", "metadata": {}, "source": [ "### Filter for upsampling\n", "\n", "Suppose we have already the hidden representation and we want to upsample on a differen grid with more points. Let's see how to do it:" ] }, { "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 *\n", " grid2[:, 0]) * torch.sin(pi * grid2[:, 1])\n", "\n", "# get the hidden representation from original input\n", "latent = net.encoder(input_data)\n", "\n", "# upsample on the second input_data2\n", "output = net.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()\n" ] }, { "cell_type": "markdown", "id": "2cbf14b5", "metadata": {}, "source": [ "As we can see we have a very good approximation of the original function, even thought some noise is present. Let's calculate the error now:" ] }, { "cell_type": "code", "execution_count": 19, "id": "ab505b75", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "l2 error: 8.38%\n" ] } ], "source": [ "print(f'l2 error: {l2_error(input_data2[0, 0, :, -1], output[0, 0, :, -1]):.2%}')" ] }, { "cell_type": "markdown", "id": "465cbd16", "metadata": {}, "source": [ "### Autoencoding at different resolutions\n", "In the previous example we already had the hidden representation (of the original input) and we used it to upsample. Sometimes however we could have a finer mesh solution and we would simply want to encode it. This can be done without retraining! This procedure can be useful in case we have many points in the mesh and just a smaller part of them are needed for training. Let's see the results of this:" ] }, { "cell_type": "code", "execution_count": 20, "id": "75ed28f5", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "l2 error: 8.50%\n" ] } ], "source": [ "# setting the seed\n", "torch.manual_seed(seed)\n", "\n", "grid2 = circle_grid(3500) # very fine mesh\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 *\n", " grid2[:, 0]) * torch.sin(pi * grid2[:, 1])\n", "\n", "# get the hidden representation from finer mesh input\n", "latent = net.encoder(input_data2)\n", "\n", "# upsample on the second input_data2\n", "output = net.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(\"Autoencoder not re-trained\")\n", "fig.colorbar(pic2)\n", "plt.tight_layout()\n", "plt.show()\n", "\n", "# calculate l2 error\n", "print(f'l2 error: {l2_error(input_data2[0, 0, :, -1], output[0, 0, :, -1]):.2%}')" ] }, { "cell_type": "markdown", "id": "8e720e55", "metadata": {}, "source": [ "## What's next?\n", "\n", "We have shown the basic usage of a convolutional filter. There are additional extensions possible:\n", "\n", "1. Train using Physics Informed strategies\n", "\n", "2. Use the filter to build an unstructured convolutional autoencoder for reduced order modelling\n", "\n", "3. Many more..." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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.12.7" } }, "nbformat": 4, "nbformat_minor": 5 }