escnn_autoencoding.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "YauIZ8KLA7kY"
      ],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/julballa/LatentLattice/blob/main/escnn_autoencoder.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Install dependencies"
      ],
      "metadata": {
        "id": "hrjmbVb-MSMW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "\n",
        "# set current directory\n",
        "# this should be the Google Drive folder where your file(s) are located\n",
        "%cd /content/drive/MyDrive/lattices\n",
        "\n",
        "## verify current directory\n",
        "!ls /content/drive/MyDrive/lattices\n",
        "\n",
        "# choose where you want your project files to be saved\n",
        "project_folder = \"/content/drive/MyDrive/lattices\""
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d6aKrI1ZvroP",
        "outputId": "cef3af1e-45df-417d-9240-01de7d1bb8d5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n",
            "/content/drive/MyDrive/lattices\n",
            "12x12_train.pt\tising_train.pt\tten_square_test.pt   ten_square_val.pt\n",
            "12x12_val.pt\tising_val.pt\tten_square_train.pt\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install git+https://github.com/AMLab-Amsterdam/lie_learn escnn"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YGO5Cszxeyn7",
        "outputId": "5cb68068-d8da-4f95-fa46-c28b38a55a35"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting git+https://github.com/AMLab-Amsterdam/lie_learn\n",
            "  Cloning https://github.com/AMLab-Amsterdam/lie_learn to /tmp/pip-req-build-tq7j1x36\n",
            "  Running command git clone --filter=blob:none --quiet https://github.com/AMLab-Amsterdam/lie_learn /tmp/pip-req-build-tq7j1x36\n",
            "  Resolved https://github.com/AMLab-Amsterdam/lie_learn to commit 1ccc2106e402d517a29de5438c9367c959e67338\n",
            "  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
            "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
            "  Installing backend dependencies ... \u001b[?25l\u001b[?25hdone\n",
            "  Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
            "Requirement already satisfied: escnn in /usr/local/lib/python3.10/dist-packages (1.0.11)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from lie_learn==0.0.1.post1) (2.31.0)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from lie_learn==0.0.1.post1) (1.25.2)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.10/dist-packages (from lie_learn==0.0.1.post1) (1.9.3)\n",
            "Requirement already satisfied: torch>=1.3 in /usr/local/lib/python3.10/dist-packages (from escnn) (2.2.1+cu121)\n",
            "Requirement already satisfied: joblib in /usr/local/lib/python3.10/dist-packages (from escnn) (1.4.2)\n",
            "Requirement already satisfied: pymanopt in /usr/local/lib/python3.10/dist-packages (from escnn) (2.2.0)\n",
            "Requirement already satisfied: autograd in /usr/local/lib/python3.10/dist-packages (from escnn) (1.6.2)\n",
            "Requirement already satisfied: py3nj in /usr/local/lib/python3.10/dist-packages (from escnn) (0.2.1)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch>=1.3->escnn) (3.14.0)\n",
            "Requirement already satisfied: typing-extensions>=4.8.0 in /usr/local/lib/python3.10/dist-packages (from torch>=1.3->escnn) (4.11.0)\n",
            "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch>=1.3->escnn) (1.12)\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch>=1.3->escnn) (3.3)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch>=1.3->escnn) (3.1.4)\n",
            "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch>=1.3->escnn) (2023.6.0)\n",
            "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch>=1.3->escnn) (12.1.105)\n",
            "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch>=1.3->escnn) (12.1.105)\n",
            "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch>=1.3->escnn) (12.1.105)\n",
            "Requirement already satisfied: nvidia-cudnn-cu12==8.9.2.26 in /usr/local/lib/python3.10/dist-packages (from torch>=1.3->escnn) (8.9.2.26)\n",
            "Requirement already satisfied: nvidia-cublas-cu12==12.1.3.1 in /usr/local/lib/python3.10/dist-packages (from torch>=1.3->escnn) (12.1.3.1)\n",
            "Requirement already satisfied: nvidia-cufft-cu12==11.0.2.54 in /usr/local/lib/python3.10/dist-packages (from torch>=1.3->escnn) (11.0.2.54)\n",
            "Requirement already satisfied: nvidia-curand-cu12==10.3.2.106 in /usr/local/lib/python3.10/dist-packages (from torch>=1.3->escnn) (10.3.2.106)\n",
            "Requirement already satisfied: nvidia-cusolver-cu12==11.4.5.107 in /usr/local/lib/python3.10/dist-packages (from torch>=1.3->escnn) (11.4.5.107)\n",
            "Requirement already satisfied: nvidia-cusparse-cu12==12.1.0.106 in /usr/local/lib/python3.10/dist-packages (from torch>=1.3->escnn) (12.1.0.106)\n",
            "Requirement already satisfied: nvidia-nccl-cu12==2.19.3 in /usr/local/lib/python3.10/dist-packages (from torch>=1.3->escnn) (2.19.3)\n",
            "Requirement already satisfied: nvidia-nvtx-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch>=1.3->escnn) (12.1.105)\n",
            "Requirement already satisfied: triton==2.2.0 in /usr/local/lib/python3.10/dist-packages (from torch>=1.3->escnn) (2.2.0)\n",
            "Requirement already satisfied: nvidia-nvjitlink-cu12 in /usr/local/lib/python3.10/dist-packages (from nvidia-cusolver-cu12==11.4.5.107->torch>=1.3->escnn) (12.4.127)\n",
            "Requirement already satisfied: future>=0.15.2 in /usr/local/lib/python3.10/dist-packages (from autograd->escnn) (0.18.3)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->lie_learn==0.0.1.post1) (3.3.2)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->lie_learn==0.0.1.post1) (3.7)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->lie_learn==0.0.1.post1) (2.0.7)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->lie_learn==0.0.1.post1) (2024.2.2)\n",
            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch>=1.3->escnn) (2.1.5)\n",
            "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy->torch>=1.3->escnn) (1.3.0)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Define model"
      ],
      "metadata": {
        "id": "uSx8pIYWAN2W"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "import torch.nn as nn\n",
        "from escnn.nn import R3Conv, R3ConvTransposed, LeakyReLU, GroupPooling, GeometricTensor, FieldType\n",
        "from escnn.gspaces.r3 import flipRot3dOnR3\n",
        "# 2D data imports\n",
        "from escnn.nn import R2Conv, R2ConvTransposed, PointwiseAvgPool2D, R2Upsampling, PointwiseMaxPool2D\n",
        "from escnn.gspaces import flipRot2dOnR2\n",
        "\n",
        "# Encoder -- 2 layer network\n",
        "class Encoder(nn.Module):\n",
        "    def __init__(self, in_type, out_type):\n",
        "        super().__init__()\n",
        "        out_type_1 = FieldType(flipRot2dOnR2(N=4), [flipRot2dOnR2(N=4).regular_repr]*64)\n",
        "        self.conv1 = R2Conv(in_type, out_type_1, kernel_size=3, stride=1)\n",
        "        self.act1 = LeakyReLU(out_type_1)\n",
        "        out_type_2 = FieldType(flipRot2dOnR2(N=4), [flipRot2dOnR2(N=4).regular_repr]*64)\n",
        "        self.conv2 = R2Conv(out_type_2, out_type_2, kernel_size=3, stride=1)\n",
        "        self.act2 = LeakyReLU(out_type_2)\n",
        "        self.gpool = GroupPooling(out_type_2)\n",
        "        self.pool = PointwiseAvgPool2D(out_type_2, kernel_size=3, stride=1)\n",
        "\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.conv1(x)\n",
        "        x = self.act1(x)\n",
        "        x = self.pool(x)\n",
        "        x = self.conv2(x)\n",
        "        x = self.act2(x)\n",
        "        return x\n",
        "\n",
        "# Decoder\n",
        "class Decoder(nn.Module):\n",
        "    def __init__(self, in_type, out_type):\n",
        "        super().__init__()\n",
        "        in_type_1 = FieldType(flipRot2dOnR2(N=4), [flipRot2dOnR2(N=4).regular_repr]*64)\n",
        "        self.conv1 = R2ConvTransposed(in_type_1, out_type, kernel_size=3, stride=1)\n",
        "        self.act1 = LeakyReLU(out_type)\n",
        "        # in_type_2 = FieldType(flipRot2dOnR2(N=4), [flipRot2dOnR2(N=4).regular_repr]*32)\n",
        "        self.conv2 = R2ConvTransposed(out_type, out_type, kernel_size=3, stride=1)\n",
        "        self.pool = R2Upsampling(out_type, scale_factor=1.25)\n",
        "        self.gpool = GroupPooling(out_type)\n",
        "\n",
        "\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.conv1(x)\n",
        "        self.act1 = LeakyReLU(out_type)\n",
        "        x = self.pool(x)\n",
        "        x = self.conv2(x)\n",
        "        x = self.gpool(x)\n",
        "        return x\n",
        "\n",
        "class AutoEncoder(nn.Module):\n",
        "    def __init__(self, in_type, out_type, latent_type):\n",
        "        super().__init__()\n",
        "        self.in_type = in_type\n",
        "        self.out_type = out_type\n",
        "        self.latent_type = latent_type\n",
        "\n",
        "        self.encoder = Encoder(in_type, latent_type)\n",
        "        self.decoder = Decoder(latent_type, out_type)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = GeometricTensor(x, self.in_type)\n",
        "        z = self.encoder(x)\n",
        "        x_hat = self.decoder(z)\n",
        "        return x_hat.tensor"
      ],
      "metadata": {
        "id": "98hB2QoEr7os"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# import torch.nn as nn\n",
        "# from escnn.nn import R2Conv, R2ConvTransposed, LeakyReLU, GroupPooling, GeometricTensor, FieldType, IIDBatchNorm2d, PointwiseMaxPool2D, R2Upsampling, PointwiseAvgPool2D\n",
        "# from escnn.gspaces import rot2dOnR2, flipRot2dOnR2\n",
        "\n",
        "# # Encoder -- 2 layer with Batch Norm\n",
        "# class Encoder(nn.Module):\n",
        "#     def __init__(self, in_type, out_type):\n",
        "#         super().__init__()\n",
        "#         out_type_1 = FieldType(flipRot2dOnR2(N=4), [flipRot2dOnR2(N=4).regular_repr]*64)\n",
        "#         self.conv1 = R2Conv(in_type, out_type_1, kernel_size=3, stride=1)\n",
        "#         self.bn1 = IIDBatchNorm2d(out_type_1)\n",
        "#         self.act1 = LeakyReLU(out_type_1)\n",
        "#         out_type_2 = FieldType(flipRot2dOnR2(N=4), [flipRot2dOnR2(N=4).regular_repr]*64)\n",
        "#         self.conv2 = R2Conv(out_type_2, out_type_2, kernel_size=3, stride=1)\n",
        "#         self.bn2 = IIDBatchNorm2d(out_type_2)\n",
        "#         self.act2 = LeakyReLU(out_type_2)\n",
        "#         self.pool = PointwiseMaxPool2D(out_type_2, kernel_size=3, stride=1)\n",
        "#         self.gpool = GroupPooling(out_type_2)\n",
        "\n",
        "\n",
        "#     def forward(self, x):\n",
        "#         x = self.conv1(x)\n",
        "#         # print(\"Enc: after conv1\", x.shape)\n",
        "#         x = self.bn1(x)\n",
        "#         x = self.act1(x)\n",
        "#         x = self.pool(x)\n",
        "#         # x = self.gpool(x)\n",
        "\n",
        "#         # print(\"after pool\", x.shape)\n",
        "#         x = self.conv2(x)\n",
        "#         # print(\"after conv2\", x.shape)\n",
        "#         x = self.bn2(x)\n",
        "#         x = self.act2(x)\n",
        "#         return x\n",
        "\n",
        "# # Decoder\n",
        "# class Decoder(nn.Module):\n",
        "#     def __init__(self, in_type, out_type):\n",
        "#         super().__init__()\n",
        "#         in_type_1 = FieldType(flipRot2dOnR2(N=4), [flipRot2dOnR2(N=4).regular_repr]*64)\n",
        "#         self.conv1 = R2ConvTransposed(in_type_1, out_type, kernel_size=3, stride=1)\n",
        "#         self.bn1 = IIDBatchNorm2d(out_type)\n",
        "#         self.act1 = LeakyReLU(out_type)\n",
        "#         self.conv2 = R2ConvTransposed(out_type, out_type, kernel_size=3, stride=1)\n",
        "#         self.bn2 = IIDBatchNorm2d(out_type)\n",
        "#         self.pool = R2Upsampling(out_type, scale_factor=1.25)\n",
        "#         self.gpool = GroupPooling(out_type)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "#     def forward(self, x):\n",
        "#         x = self.conv1(x)\n",
        "#         # print(\"Dec: after conv1\", x.shape)\n",
        "#         x = self.bn1(x)\n",
        "#         # x = self.act1(x)\n",
        "#         x = self.pool(x)\n",
        "#         # print(\"after UN pool\", x.shape)\n",
        "#         x = self.conv2(x)\n",
        "#         x = self.gpool(x)\n",
        "#         # print(\"after conv2\", x.shape)\n",
        "#         # x = self.bn2(x)\n",
        "#         # x = self.act2(x)\n",
        "#         return x\n",
        "\n",
        "\n",
        "\n",
        "# class AutoEncoder(nn.Module):\n",
        "#     def __init__(self, in_type, out_type, latent_type):\n",
        "#         super().__init__()\n",
        "#         self.in_type = in_type\n",
        "#         self.out_type = out_type\n",
        "#         self.latent_type = latent_type\n",
        "\n",
        "#         self.encoder = Encoder(in_type, latent_type)\n",
        "#         self.decoder = Decoder(latent_type, out_type)\n",
        "\n",
        "#     def forward(self, x):\n",
        "#         x = GeometricTensor(x, self.in_type)\n",
        "#         z = self.encoder(x)\n",
        "#         x_hat = self.decoder(z)\n",
        "#         return x_hat.tensor\n"
      ],
      "metadata": {
        "id": "n7ZQNF9ntzGP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# import torch.nn as nn\n",
        "# from escnn.nn import R2Conv, R2ConvTransposed, LeakyReLU, GroupPooling, GeometricTensor, FieldType\n",
        "# from escnn.gspaces import rot2dOnR2\n",
        "\n",
        "# # Encoder -- 3 layer network\n",
        "# class Encoder(nn.Module):\n",
        "#     def __init__(self, in_type, out_type):\n",
        "#         super().__init__()\n",
        "#         self.conv1 = R2Conv(in_type, out_type, kernel_size=3, stride=1)\n",
        "#         self.act1 = LeakyReLU(out_type)\n",
        "#         self.conv2 = R2Conv(out_type, out_type, kernel_size=3, stride=1)\n",
        "#         self.act2 = LeakyReLU(out_type)\n",
        "#         self.conv3 = R2Conv(out_type, out_type, kernel_size=3, stride=1)  # Additional layer\n",
        "#         self.act3 = LeakyReLU(out_type)\n",
        "#         self.pool = GroupPooling(out_type)\n",
        "\n",
        "#     def forward(self, x):\n",
        "#         x = self.conv1(x)\n",
        "#         x = self.act1(x)\n",
        "#         x = self.pool(x)\n",
        "#         x = self.conv2(x)\n",
        "#         x = self.act2(x)\n",
        "#         x = self.pool(x)\n",
        "#         x = self.conv3(x)\n",
        "#         x = self.act3(x)\n",
        "\n",
        "#         return x\n",
        "\n",
        "# # Decoder\n",
        "# class Decoder(nn.Module):\n",
        "#     def __init__(self, in_type, out_type):\n",
        "#         super().__init__()\n",
        "#         self.conv1 = R2ConvTransposed(in_type, out_type, kernel_size=3, stride=1)\n",
        "#         self.act1 = LeakyReLU(out_type)\n",
        "#         self.conv2 = R2ConvTransposed(out_type, out_type, kernel_size=3, stride=1)\n",
        "#         self.act2 = LeakyReLU(out_type)  # Additional activation\n",
        "#         self.conv3 = R2ConvTransposed(out_type, out_type, kernel_size=3, stride=1)  # Additional layer\n",
        "\n",
        "\n",
        "#     def forward(self, x):\n",
        "#         x = self.conv1(x)\n",
        "#         self.act1 = LeakyReLU(out_type)\n",
        "#         x = self.conv2(x)\n",
        "#         self.act2 = LeakyReLU(out_type)\n",
        "#         x = self.conv3(x) # Additional layer processing\n",
        "#         return x\n",
        "\n",
        "# class AutoEncoder(nn.Module):\n",
        "#     def __init__(self, in_type, out_type, latent_type):\n",
        "#         super().__init__()\n",
        "#         self.in_type = in_type\n",
        "#         self.out_type = out_type\n",
        "#         self.latent_type = latent_type\n",
        "\n",
        "#         self.encoder = Encoder(in_type, latent_type)\n",
        "#         self.decoder = Decoder(latent_type, out_type)\n",
        "\n",
        "#     def forward(self, x):\n",
        "#         x = GeometricTensor(x, self.in_type)\n",
        "#         z = self.encoder(x)\n",
        "#         x_hat = self.decoder(z)\n",
        "#         return x_hat.tensor\n"
      ],
      "metadata": {
        "id": "EhU9W5VAlPl5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# import torch.nn as nn\n",
        "# from escnn.nn import R2Conv, R2ConvTransposed, LeakyReLU, GroupPooling, GeometricTensor, FieldType, IIDBatchNorm2d\n",
        "# from escnn.gspaces import rot2dOnR2\n",
        "\n",
        "# # Encoder -- 3 layer network with BatchNorm\n",
        "# class Encoder(nn.Module):\n",
        "#     def __init__(self, in_type, out_type):\n",
        "#         super().__init__()\n",
        "#         self.conv1 = R2Conv(in_type, out_type, kernel_size=3, stride=1)\n",
        "#         self.bn1 = IIDBatchNorm2d(out_type)\n",
        "#         self.act1 = LeakyReLU(out_type)\n",
        "#         self.conv2 = R2Conv(out_type, out_type, kernel_size=3, stride=1)\n",
        "#         self.bn2 = IIDBatchNorm2d(out_type)\n",
        "#         self.act2 = LeakyReLU(out_type)\n",
        "#         self.conv3 = R2Conv(out_type, out_type, kernel_size=3, stride=1)\n",
        "#         self.bn3 = IIDBatchNorm2d(out_type)\n",
        "#         self.act3 = LeakyReLU(out_type)\n",
        "#         self.pool = GroupPooling(out_type)\n",
        "\n",
        "#     def forward(self, x):\n",
        "#         x = self.conv1(x)\n",
        "#         x = self.bn1(x)\n",
        "#         x = self.act1(x)\n",
        "#         x = self.conv2(x)\n",
        "#         x = self.bn2(x)\n",
        "#         x = self.act2(x)\n",
        "#         x = self.conv3(x)\n",
        "#         x = self.bn3(x)\n",
        "#         x = self.act3(x)\n",
        "#         x = self.pool(x)\n",
        "#         return x\n",
        "\n",
        "# # Decoder\n",
        "# class Decoder(nn.Module):\n",
        "#     def __init__(self, in_type, out_type):\n",
        "#         super().__init__()\n",
        "#         self.conv1 = R2ConvTransposed(in_type, out_type, kernel_size=3, stride=1)\n",
        "#         self.bn1 = IIDBatchNorm2d(out_type)\n",
        "#         self.act1 = LeakyReLU(out_type)\n",
        "#         self.conv2 = R2ConvTransposed(out_type, out_type, kernel_size=3, stride=1)\n",
        "#         self.bn2 = IIDBatchNorm2d(out_type)\n",
        "#         self.act2 = LeakyReLU(out_type)\n",
        "#         self.conv3 = R2ConvTransposed(out_type, out_type, kernel_size=3, stride=1)\n",
        "#         self.bn3 = IIDBatchNorm2d(out_type)\n",
        "#         self.act3 = LeakyReLU(out_type)\n",
        "\n",
        "#     def forward(self, x):\n",
        "#         x = self.conv1(x)\n",
        "#         x = self.bn1(x)\n",
        "#         x = self.act1(x)\n",
        "#         x = self.conv2(x)\n",
        "#         x = self.bn2(x)\n",
        "#         x = self.act2(x)\n",
        "#         x = self.conv3(x)\n",
        "#         x = self.bn3(x)\n",
        "#         x = self.act3(x)\n",
        "#         return x\n",
        "\n",
        "# class AutoEncoder(nn.Module):\n",
        "#     def __init__(self, in_type, out_type, latent_type):\n",
        "#         super().__init__()\n",
        "#         self.in_type = in_type\n",
        "#         self.out_type = out_type\n",
        "#         self.latent_type = latent_type\n",
        "\n",
        "#         self.encoder = Encoder(in_type, latent_type)\n",
        "#         self.decoder = Decoder(latent_type, out_type)\n",
        "\n",
        "#     def forward(self, x):\n",
        "#         x = GeometricTensor(x, self.in_type)\n",
        "#         z = self.encoder(x)\n",
        "#         x_hat = self.decoder(z)\n",
        "#         return x_hat.tensor\n"
      ],
      "metadata": {
        "id": "vPbKp2fjrLZo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Load dataset"
      ],
      "metadata": {
        "id": "YauIZ8KLA7kY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install torch_geometric"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kMFGRFWv_Q3p",
        "outputId": "d6d3d204-7798-4339-e205-e518fc0ca895"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: torch_geometric in /usr/local/lib/python3.10/dist-packages (2.5.3)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from torch_geometric) (4.66.4)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from torch_geometric) (1.25.2)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.10/dist-packages (from torch_geometric) (1.9.3)\n",
            "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch_geometric) (2023.6.0)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch_geometric) (3.1.4)\n",
            "Requirement already satisfied: aiohttp in /usr/local/lib/python3.10/dist-packages (from torch_geometric) (3.9.5)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from torch_geometric) (2.31.0)\n",
            "Requirement already satisfied: pyparsing in /usr/local/lib/python3.10/dist-packages (from torch_geometric) (3.1.2)\n",
            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.10/dist-packages (from torch_geometric) (1.2.2)\n",
            "Requirement already satisfied: psutil>=5.8.0 in /usr/local/lib/python3.10/dist-packages (from torch_geometric) (5.9.5)\n",
            "Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.10/dist-packages (from aiohttp->torch_geometric) (1.3.1)\n",
            "Requirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->torch_geometric) (23.2.0)\n",
            "Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.10/dist-packages (from aiohttp->torch_geometric) (1.4.1)\n",
            "Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.10/dist-packages (from aiohttp->torch_geometric) (6.0.5)\n",
            "Requirement already satisfied: yarl<2.0,>=1.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->torch_geometric) (1.9.4)\n",
            "Requirement already satisfied: async-timeout<5.0,>=4.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->torch_geometric) (4.0.3)\n",
            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch_geometric) (2.1.5)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->torch_geometric) (3.3.2)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->torch_geometric) (3.7)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->torch_geometric) (2.0.7)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->torch_geometric) (2024.2.2)\n",
            "Requirement already satisfied: joblib>=1.1.1 in /usr/local/lib/python3.10/dist-packages (from scikit-learn->torch_geometric) (1.4.2)\n",
            "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn->torch_geometric) (3.5.0)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from torch.utils.data import Dataset, DataLoader\n",
        "import torch\n",
        "\n",
        "class LatticeDataset(Dataset):\n",
        "    def __init__(self, data_list, grid_size=(12, 12)):\n",
        "        \"\"\"\n",
        "        data_list is a list of data objects from PyTorch Geometric.\n",
        "        Each data object has 'x' for node types, 'pos' for node positions.\n",
        "        \"\"\"\n",
        "        self.data_list = data_list\n",
        "        self.grid_size = grid_size\n",
        "        self.bounds = self.calculate_bounds()\n",
        "\n",
        "    def calculate_bounds(self):\n",
        "        # Initialize min/max with extreme values\n",
        "        min_pos = torch.tensor([float('inf'), float('inf')])\n",
        "        max_pos = torch.tensor([-float('inf'), -float('inf')])\n",
        "\n",
        "        # Calculate the min and max positions\n",
        "        for data in self.data_list:\n",
        "            min_pos = torch.min(min_pos, torch.min(data.coords, dim=0).values)\n",
        "            max_pos = torch.max(max_pos, torch.max(data.coords, dim=0).values)\n",
        "\n",
        "        return min_pos, max_pos\n",
        "\n",
        "    def normalize_positions(self, positions):\n",
        "        # Normalize positions to fit within the grid size\n",
        "        min_pos, max_pos = self.bounds\n",
        "        scale = torch.tensor(self.grid_size) - 1\n",
        "        normalized_pos = (positions - min_pos) / (max_pos - min_pos) * scale\n",
        "        return normalized_pos.long()\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.data_list)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        data = self.data_list[idx]\n",
        "        grid = torch.zeros((1, *self.grid_size), dtype=torch.float32)\n",
        "\n",
        "        # Normalize positions\n",
        "        normalized_positions = self.normalize_positions(data.coords)\n",
        "\n",
        "        # Place features into the grid\n",
        "        for pos, feature in zip(normalized_positions, data.x):\n",
        "            x, y = pos[0], pos[1]\n",
        "            grid[0, y, x] = feature\n",
        "        return grid, grid\n",
        "\n",
        "# Usage with data\n",
        "train_data = torch.load('ising_train.pt')\n",
        "val_data = torch.load('ising_val.pt')\n",
        "\n",
        "train_dataset = LatticeDataset(train_data)\n",
        "val_dataset = LatticeDataset(val_data)\n",
        "\n",
        "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n",
        "val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)\n"
      ],
      "metadata": {
        "id": "BlB_ynMQktLr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# from torch.utils.data import Dataset, DataLoader\n",
        "# import torch\n",
        "# # dataset for Regular Repr with 8 channels\n",
        "# class LatticeDataset(Dataset):\n",
        "#     def __init__(self, data_list, grid_size=(12, 12), num_channels=8, gspace=None):\n",
        "#         \"\"\"\n",
        "#         data_list is a list of data objects from PyTorch Geometric.\n",
        "#         Each data object should have 'x' for node types, 'pos' for node positions.\n",
        "#         \"\"\"\n",
        "#         self.data_list = data_list\n",
        "#         self.grid_size = grid_size\n",
        "#         self.num_channels = num_channels\n",
        "#         self.bounds = self.calculate_bounds()\n",
        "#         self.gspace = gspace\n",
        "#         self.field_type = FieldType(self.gspace, [self.gspace.regular_repr])\n",
        "\n",
        "\n",
        "#     def calculate_bounds(self):\n",
        "#         # Initialize min/max with extreme values\n",
        "#         min_pos = torch.tensor([float('inf'), float('inf')])\n",
        "#         max_pos = torch.tensor([-float('inf'), -float('inf')])\n",
        "\n",
        "#         # Calculate the min and max positions\n",
        "#         for data in self.data_list:\n",
        "#             min_pos = torch.min(min_pos, torch.min(data.coords, dim=0).values)\n",
        "#             max_pos = torch.max(max_pos, torch.max(data.coords, dim=0).values)\n",
        "\n",
        "#         return min_pos, max_pos\n",
        "\n",
        "#     def normalize_positions(self, positions):\n",
        "#         # Normalize positions to fit within the grid size\n",
        "#         min_pos, max_pos = self.bounds\n",
        "#         scale = torch.tensor(self.grid_size) - 1\n",
        "#         normalized_pos = (positions - min_pos) / (max_pos - min_pos) * scale\n",
        "#         return normalized_pos.long()\n",
        "\n",
        "#     def __len__(self):\n",
        "#         return len(self.data_list)\n",
        "\n",
        "#     def __getitem__(self, idx):\n",
        "#         data = self.data_list[idx]\n",
        "#         grid = torch.zeros((self.num_channels, *self.grid_size), dtype=torch.float32)\n",
        "\n",
        "#         # Normalize positions\n",
        "#         normalized_positions = self.normalize_positions(data.coords)\n",
        "\n",
        "#         # Place features into the grid\n",
        "#         for pos, feature in zip(normalized_positions, data.x):\n",
        "#             x, y = pos[0], pos[1]\n",
        "#             grid[:, y, x] = feature * torch.ones(self.num_channels)  # Replicate the feature across all channels, for reg rep\n",
        "\n",
        "#        # **ADDED****: Wrap the grid in a GeometricTensor\n",
        "#         grid = GeometricTensor(grid, self.field_type)\n",
        "\n",
        "#         return grid, grid\n",
        "\n",
        "# # Usage with data\n",
        "# gspace = flipRot2dOnR2(N=4)  # For N=4 rotation symmetry\n",
        "\n",
        "# train_data = torch.load('12x12_train.pt')\n",
        "# val_data = torch.load('12x12_val.pt')\n",
        "\n",
        "# train_dataset = LatticeDataset(train_data, gspace=gspace)\n",
        "# val_dataset = LatticeDataset(val_data, gspace=gspace)\n",
        "\n",
        "# train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n",
        "# val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)\n",
        "\n"
      ],
      "metadata": {
        "id": "LEuiAb-876-j"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "# Plotting Dataset\n",
        "\n",
        "def plot_lattices(lattice_batch, num_images=6, title='Lattice Grid'):\n",
        "    \"\"\"\n",
        "    Plots a batch of lattices as images.\n",
        "\n",
        "    :param lattice_batch: A batch of lattice data as tensors.\n",
        "    :param num_images: Number of images to plot from the batch.\n",
        "    :param title: Title for the plot.\n",
        "    \"\"\"\n",
        "    fig, axes = plt.subplots(1, num_images, figsize=(15, 3))\n",
        "    for i, ax in enumerate(axes):\n",
        "        if i >= len(lattice_batch):\n",
        "            break\n",
        "        # Assume lattice_batch[i] is a tensor of shape (1, height, width)\n",
        "        # We use squeeze to drop the first dimension for plotting\n",
        "        ax.imshow(lattice_batch[i].squeeze(), cmap='viridis', interpolation='none')\n",
        "        ax.axis('off')\n",
        "    plt.suptitle(title)\n",
        "    plt.show()\n",
        "\n",
        "# Example of using the function with a DataLoader\n",
        "data_loader = DataLoader(train_dataset, batch_size=6, shuffle=True)\n",
        "for lattice_batch, _ in data_loader:\n",
        "    plot_lattices(lattice_batch, num_images=6, title='Sample Lattice Grids')\n",
        "    break  # Just plot one batch for example\n"
      ],
      "metadata": {
        "id": "i4GG3hMuxrTI",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "outputId": "69674457-0cb5-4a0e-9074-eca503d88067"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x300 with 6 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Train model"
      ],
      "metadata": {
        "id": "kQPzSvDt2z2H"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "num_params = sum(p.numel() for p in model.parameters())\n",
        "print(num_params)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zWDPyGxhetEU",
        "outputId": "929f3da5-3344-4866-fe61-ba85655ce9cf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "198100\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch.optim as optim\n",
        "from torch.optim.lr_scheduler import StepLR\n",
        "import torch.nn.functional as F\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "print(f\"Training on device: {device}\")\n",
        "\n",
        "# Init model with Trivial Rep\n",
        "in_type = FieldType(flipRot2dOnR2(N=4), [flipRot2dOnR2(N=4).trivial_repr])\n",
        "latent_type = FieldType(flipRot2dOnR2(N=4), [flipRot2dOnR2(N=4).trivial_repr])\n",
        "out_type = FieldType(flipRot2dOnR2(N=4), [flipRot2dOnR2(N=4).trivial_repr]*2)\n",
        "\n",
        "# # Initialize FieldTypes with regular representations\n",
        "# g = flipRot2dOnR2(N=4)  # Group with N-fold rotational symmetry\n",
        "# in_type = FieldType(g, [g.regular_repr])  # Using regular representation for input\n",
        "# latent_type = FieldType(g, [g.regular_repr] * 8)  # Latent space\n",
        "# out_type = FieldType(g, [g.regular_repr] * 2)  # Output\n",
        "\n",
        "model = AutoEncoder(in_type, out_type, latent_type)\n",
        "\n",
        "\n",
        "model = model.to(device)\n",
        "criterion = nn.CrossEntropyLoss()  # Loss function\n",
        "optimizer = optim.Adam(model.parameters(), lr=0.01)  # Optimizer\n",
        "\n",
        "# Define learning rate scheduler\n",
        "# scheduler = StepLR(optimizer, step_size=10, gamma=0.2)\n",
        "\n",
        "num_epochs = 50\n",
        "train_losses = []\n",
        "val_losses = []\n",
        "val_accuracies = []\n",
        "\n",
        "for epoch in range(num_epochs):\n",
        "    model.train()  # Set model to training mode\n",
        "    train_loss = 0\n",
        "\n",
        "    for inputs, targets in train_loader:\n",
        "        inputs, targets = inputs.to(device), targets.to(device).squeeze().long()\n",
        "\n",
        "        # Forward pass\n",
        "        outputs = model(inputs)\n",
        "        loss = criterion(outputs, targets)\n",
        "\n",
        "        # Backward pass and optimize\n",
        "        optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        train_loss += loss.item() * inputs.size(0)\n",
        "\n",
        "    train_loss /= len(train_loader.dataset)\n",
        "    train_losses.append(train_loss)\n",
        "\n",
        "    # Update learning rate\n",
        "    # scheduler.step()\n",
        "\n",
        "    # Validation phase\n",
        "    val_loss = 0\n",
        "    val_acc = 0\n",
        "    model.eval()  # Set model to evaluation mode\n",
        "    with torch.no_grad():\n",
        "        for inputs, targets in val_loader:\n",
        "            inputs, targets = inputs.to(device), targets.to(device).squeeze().long()\n",
        "            outputs = model(inputs)\n",
        "            loss = criterion(outputs, targets)\n",
        "            val_loss += loss.item() * inputs.size(0)\n",
        "\n",
        "            val_acc += (F.softmax(outputs, dim=1).argmax(dim=1) == targets).sum().float()\n",
        "\n",
        "    val_loss /= len(val_loader.dataset)\n",
        "    val_acc /= (len(val_loader.dataset) * 144)\n",
        "    val_losses.append(val_loss)\n",
        "    val_accuracies.append(val_acc)\n",
        "\n",
        "    # if epoch % 5 == 0:\n",
        "    print(f\"Epoch {epoch+1}/{num_epochs}, Train Loss: {train_loss:.4f}, Validation Loss: {val_loss:.4f}, Validation Node Type Accuracy: {val_acc:.4f}\")\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0eZMYuh2sQ-C",
        "outputId": "6de31719-3783-4cef-d0ca-00ea10e519e7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training on device: cpu\n",
            "Epoch 1/50, Train Loss: 0.5469, Validation Loss: 0.4669, Validation Node Type Accuracy: 0.7674\n",
            "Epoch 2/50, Train Loss: 0.4478, Validation Loss: 0.4342, Validation Node Type Accuracy: 0.7873\n",
            "Epoch 3/50, Train Loss: 0.4207, Validation Loss: 0.4123, Validation Node Type Accuracy: 0.7970\n",
            "Epoch 4/50, Train Loss: 0.4050, Validation Loss: 0.4021, Validation Node Type Accuracy: 0.8008\n",
            "Epoch 5/50, Train Loss: 0.3976, Validation Loss: 0.4004, Validation Node Type Accuracy: 0.8024\n",
            "Epoch 6/50, Train Loss: 0.3920, Validation Loss: 0.3931, Validation Node Type Accuracy: 0.8061\n",
            "Epoch 7/50, Train Loss: 0.3861, Validation Loss: 0.3945, Validation Node Type Accuracy: 0.8037\n",
            "Epoch 8/50, Train Loss: 0.3838, Validation Loss: 0.3893, Validation Node Type Accuracy: 0.8071\n",
            "Epoch 9/50, Train Loss: 0.3818, Validation Loss: 0.3962, Validation Node Type Accuracy: 0.8049\n",
            "Epoch 10/50, Train Loss: 0.3789, Validation Loss: 0.3860, Validation Node Type Accuracy: 0.8072\n",
            "Epoch 11/50, Train Loss: 0.3738, Validation Loss: 0.3893, Validation Node Type Accuracy: 0.8077\n",
            "Epoch 12/50, Train Loss: 0.3726, Validation Loss: 0.3875, Validation Node Type Accuracy: 0.8091\n",
            "Epoch 13/50, Train Loss: 0.3710, Validation Loss: 0.3886, Validation Node Type Accuracy: 0.8084\n",
            "Epoch 14/50, Train Loss: 0.3683, Validation Loss: 0.3895, Validation Node Type Accuracy: 0.8083\n",
            "Epoch 15/50, Train Loss: 0.3680, Validation Loss: 0.3828, Validation Node Type Accuracy: 0.8104\n",
            "Epoch 16/50, Train Loss: 0.3637, Validation Loss: 0.3864, Validation Node Type Accuracy: 0.8095\n",
            "Epoch 17/50, Train Loss: 0.3629, Validation Loss: 0.3925, Validation Node Type Accuracy: 0.8070\n",
            "Epoch 18/50, Train Loss: 0.3638, Validation Loss: 0.3899, Validation Node Type Accuracy: 0.8090\n",
            "Epoch 19/50, Train Loss: 0.3612, Validation Loss: 0.3855, Validation Node Type Accuracy: 0.8099\n",
            "Epoch 20/50, Train Loss: 0.3591, Validation Loss: 0.3892, Validation Node Type Accuracy: 0.8091\n",
            "Epoch 21/50, Train Loss: 0.3573, Validation Loss: 0.3862, Validation Node Type Accuracy: 0.8085\n",
            "Epoch 22/50, Train Loss: 0.3577, Validation Loss: 0.3889, Validation Node Type Accuracy: 0.8079\n",
            "Epoch 23/50, Train Loss: 0.3545, Validation Loss: 0.3843, Validation Node Type Accuracy: 0.8093\n",
            "Epoch 24/50, Train Loss: 0.3542, Validation Loss: 0.3920, Validation Node Type Accuracy: 0.8080\n",
            "Epoch 25/50, Train Loss: 0.3545, Validation Loss: 0.3863, Validation Node Type Accuracy: 0.8096\n",
            "Epoch 26/50, Train Loss: 0.3509, Validation Loss: 0.3919, Validation Node Type Accuracy: 0.8076\n",
            "Epoch 27/50, Train Loss: 0.3516, Validation Loss: 0.3869, Validation Node Type Accuracy: 0.8095\n",
            "Epoch 28/50, Train Loss: 0.3506, Validation Loss: 0.3936, Validation Node Type Accuracy: 0.8078\n",
            "Epoch 29/50, Train Loss: 0.3485, Validation Loss: 0.3879, Validation Node Type Accuracy: 0.8093\n",
            "Epoch 30/50, Train Loss: 0.3480, Validation Loss: 0.4007, Validation Node Type Accuracy: 0.8048\n",
            "Epoch 31/50, Train Loss: 0.3467, Validation Loss: 0.3894, Validation Node Type Accuracy: 0.8067\n",
            "Epoch 32/50, Train Loss: 0.3445, Validation Loss: 0.3934, Validation Node Type Accuracy: 0.8066\n",
            "Epoch 33/50, Train Loss: 0.3444, Validation Loss: 0.3904, Validation Node Type Accuracy: 0.8089\n",
            "Epoch 34/50, Train Loss: 0.3429, Validation Loss: 0.3921, Validation Node Type Accuracy: 0.8063\n",
            "Epoch 35/50, Train Loss: 0.3440, Validation Loss: 0.3932, Validation Node Type Accuracy: 0.8073\n",
            "Epoch 36/50, Train Loss: 0.3422, Validation Loss: 0.3967, Validation Node Type Accuracy: 0.8062\n",
            "Epoch 37/50, Train Loss: 0.3395, Validation Loss: 0.3983, Validation Node Type Accuracy: 0.8062\n",
            "Epoch 38/50, Train Loss: 0.3403, Validation Loss: 0.3979, Validation Node Type Accuracy: 0.8046\n",
            "Epoch 39/50, Train Loss: 0.3391, Validation Loss: 0.3973, Validation Node Type Accuracy: 0.8072\n",
            "Epoch 40/50, Train Loss: 0.3370, Validation Loss: 0.3968, Validation Node Type Accuracy: 0.8055\n",
            "Epoch 41/50, Train Loss: 0.3363, Validation Loss: 0.3978, Validation Node Type Accuracy: 0.8075\n",
            "Epoch 42/50, Train Loss: 0.3336, Validation Loss: 0.4033, Validation Node Type Accuracy: 0.8034\n",
            "Epoch 43/50, Train Loss: 0.3343, Validation Loss: 0.4038, Validation Node Type Accuracy: 0.8052\n",
            "Epoch 44/50, Train Loss: 0.3327, Validation Loss: 0.3994, Validation Node Type Accuracy: 0.8073\n",
            "Epoch 45/50, Train Loss: 0.3318, Validation Loss: 0.4031, Validation Node Type Accuracy: 0.8048\n",
            "Epoch 46/50, Train Loss: 0.3319, Validation Loss: 0.4076, Validation Node Type Accuracy: 0.8034\n",
            "Epoch 47/50, Train Loss: 0.3328, Validation Loss: 0.4044, Validation Node Type Accuracy: 0.8066\n",
            "Epoch 48/50, Train Loss: 0.3290, Validation Loss: 0.4034, Validation Node Type Accuracy: 0.8052\n",
            "Epoch 49/50, Train Loss: 0.3293, Validation Loss: 0.4105, Validation Node Type Accuracy: 0.8033\n",
            "Epoch 50/50, Train Loss: 0.3272, Validation Loss: 0.4069, Validation Node Type Accuracy: 0.8054\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plotting the training and validation loss\n",
        "plt.figure(figsize=(3,2))\n",
        "plt.plot(train_losses, label='Training Loss')\n",
        "plt.plot(val_losses, label='Validation Loss')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.title('Training and Validation Loss')\n",
        "plt.legend()\n",
        "plt.grid(True)\n",
        "plt.show()\n",
        "\n",
        "# Optionally, plot the validation accuracy\n",
        "plt.figure(figsize=(3,2))\n",
        "plt.plot(val_accuracies, label='Validation Accuracy')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.title('Validation Accuracy over Epochs')\n",
        "plt.legend()\n",
        "plt.grid(True)\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 495
        },
        "id": "G6wn3dJmAik2",
        "outputId": "bf9314df-4a4d-4a37-8709-da3c356ba6e0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 300x200 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 300x200 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# saving losses\n",
        "import pickle\n",
        "\n",
        "# Save train and validation losses\n",
        "with open('/content/train_losses.pkl', 'wb') as f:\n",
        "    pickle.dump(train_losses, f)\n",
        "\n",
        "with open('/content/val_losses.pkl', 'wb') as f:\n",
        "    pickle.dump(val_losses, f)\n"
      ],
      "metadata": {
        "id": "REM6tC_l3J0h"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import files\n",
        "\n",
        "# Download files\n",
        "files.download('/content/train_losses.pkl')\n",
        "files.download('/content/val_losses.pkl')\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 17
        },
        "id": "UIZZGss59rVn",
        "outputId": "5a53fe44-7fae-451c-c707-718b09ca9cc9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_68c85c7c-9b98-4901-aff4-256247ee4b09\", \"train_losses.pkl\", 916)"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_d79d77cd-7354-41dc-b83a-b9cc339672b9\", \"val_losses.pkl\", 916)"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "GHUnojGR9zHh"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}