PINA/tutorials/tutorial4/tutorial.ipynb

{
 "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": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/matte_b/PINA/pina/solvers/__init__.py: DeprecationWarning: 'pina.solvers' is deprecated and will be removed in future versions. Please use 'pina.solver' instead.\n",
      "/home/matte_b/PINA/pina/model/layers/__init__.py: DeprecationWarning: 'pina.model.layers' is deprecated and will be removed in future versions. Please use 'pina.model.block' instead.\n"
     ]
    }
   ],
   "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.solvers import SupervisedSolver\n",
    "from pina.trainer import Trainer\n",
    "from pina import Condition, LabelTensor\n",
    "from pina.model.layers 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": [
      "/home/matte_b/.local/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 ../aten/src/ATen/native/TensorShape.cpp:3595.)\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.040]\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.733%\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": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "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"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 149: 100%|██████████| 1/1 [00:01<00:00,  0.75it/s, v_num=16, data_loss=0.0341, val_loss=0.0341, train_loss=0.0341]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "`Trainer.fit` stopped: `max_epochs=150` reached.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 149: 100%|██████████| 1/1 [00:01<00:00,  0.75it/s, v_num=16, data_loss=0.0341, val_loss=0.0341, train_loss=0.0341]\n"
     ]
    }
   ],
   "source": [
    "# define the problem\n",
    "class CircleProblem(AbstractProblem):\n",
    "    input_variables = ['x', 'y', 'f']\n",
    "    output_variables = input_variables\n",
    "    al=LabelTensor(input_data, input_variables)\n",
    "    conditions = {'data' : Condition(input_points=LabelTensor(input_data, input_variables), output_points=LabelTensor(input_data, output_variables))}\n",
    "\n",
    "# define the solver\n",
    "solver = SupervisedSolver(problem=CircleProblem(), model=net, loss=torch.nn.MSELoss(), use_lt=True)          \n",
    "\n",
    "# train\n",
    "trainer = Trainer(solver, max_epochs=150, accelerator='cpu', enable_model_summary=False) # we train on CPU and avoid model summary at beginning of training (optional)\n",
    "trainer.train()\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a98ffb20",
   "metadata": {},
   "source": [
    "Let's visualize the two solutions side by side!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "0269fedf",
   "metadata": {},
   "outputs": [],
   "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": [],
   "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": [
    {
     "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}