Andrew_GNN.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Andrew GNN.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        ""
      ],
      "metadata": {
        "id": "-DujY0Gqn5YU"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0UhFT8bks3Nb",
        "outputId": "f01c049b-c9b3-47b0-f302-0eda87668f5f"
      },
      "source": [
        "!pip install torch-scatter\n",
        "!pip install torch-sparse\n",
        "!pip install torch-geometric"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting torch-scatter\n",
            "  Downloading torch_scatter-2.0.9.tar.gz (21 kB)\n",
            "Building wheels for collected packages: torch-scatter\n",
            "  Building wheel for torch-scatter (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for torch-scatter: filename=torch_scatter-2.0.9-cp37-cp37m-linux_x86_64.whl size=282114 sha256=36e3baecd038323fc309e9f5a0956e9cd8422bb798d569253087426199f00d5e\n",
            "  Stored in directory: /root/.cache/pip/wheels/dd/57/a3/42ea193b77378ce634eb9454c9bc1e3163f3b482a35cdee4d1\n",
            "Successfully built torch-scatter\n",
            "Installing collected packages: torch-scatter\n",
            "Successfully installed torch-scatter-2.0.9\n",
            "Collecting torch-sparse\n",
            "  Downloading torch_sparse-0.6.12.tar.gz (43 kB)\n",
            "\u001b[K     |████████████████████████████████| 43 kB 1.4 MB/s \n",
            "\u001b[?25hRequirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from torch-sparse) (1.4.1)\n",
            "Requirement already satisfied: numpy>=1.13.3 in /usr/local/lib/python3.7/dist-packages (from scipy->torch-sparse) (1.19.5)\n",
            "Building wheels for collected packages: torch-sparse\n",
            "  Building wheel for torch-sparse (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for torch-sparse: filename=torch_sparse-0.6.12-cp37-cp37m-linux_x86_64.whl size=505740 sha256=28573b4be22bf632d195005012998f470321d158505ec721fb098c898c9fbd8d\n",
            "  Stored in directory: /root/.cache/pip/wheels/fb/e2/2f/44956c61e3299573ffe12da9d1374c7576ca0c5fb1fe1ed38c\n",
            "Successfully built torch-sparse\n",
            "Installing collected packages: torch-sparse\n",
            "Successfully installed torch-sparse-0.6.12\n",
            "Collecting torch-geometric\n",
            "  Downloading torch_geometric-2.0.2.tar.gz (325 kB)\n",
            "\u001b[K     |████████████████████████████████| 325 kB 29.2 MB/s \n",
            "\u001b[?25hRequirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (1.19.5)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (4.62.3)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (1.4.1)\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (2.6.3)\n",
            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (1.0.1)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (2.23.0)\n",
            "Requirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (1.1.5)\n",
            "Collecting rdflib\n",
            "  Downloading rdflib-6.0.2-py3-none-any.whl (407 kB)\n",
            "\u001b[K     |████████████████████████████████| 407 kB 58.4 MB/s \n",
            "\u001b[?25hRequirement already satisfied: googledrivedownloader in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (0.4)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (2.11.3)\n",
            "Requirement already satisfied: pyparsing in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (3.0.6)\n",
            "Collecting yacs\n",
            "  Downloading yacs-0.1.8-py3-none-any.whl (14 kB)\n",
            "Requirement already satisfied: PyYAML in /usr/local/lib/python3.7/dist-packages (from torch-geometric) (3.13)\n",
            "Requirement already satisfied: MarkupSafe>=0.23 in /usr/local/lib/python3.7/dist-packages (from jinja2->torch-geometric) (2.0.1)\n",
            "Requirement already satisfied: pytz>=2017.2 in /usr/local/lib/python3.7/dist-packages (from pandas->torch-geometric) (2018.9)\n",
            "Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.7/dist-packages (from pandas->torch-geometric) (2.8.2)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.7.3->pandas->torch-geometric) (1.15.0)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from rdflib->torch-geometric) (57.4.0)\n",
            "Collecting isodate\n",
            "  Downloading isodate-0.6.0-py2.py3-none-any.whl (45 kB)\n",
            "\u001b[K     |████████████████████████████████| 45 kB 3.0 MB/s \n",
            "\u001b[?25hRequirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->torch-geometric) (2021.10.8)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->torch-geometric) (3.0.4)\n",
            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->torch-geometric) (1.24.3)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->torch-geometric) (2.10)\n",
            "Requirement already satisfied: joblib>=0.11 in /usr/local/lib/python3.7/dist-packages (from scikit-learn->torch-geometric) (1.1.0)\n",
            "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from scikit-learn->torch-geometric) (3.0.0)\n",
            "Building wheels for collected packages: torch-geometric\n",
            "  Building wheel for torch-geometric (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for torch-geometric: filename=torch_geometric-2.0.2-py3-none-any.whl size=535570 sha256=a7c3f8490b675ac7d684cbf61e69495d3ea96338c783318d0e715f6b779a24f4\n",
            "  Stored in directory: /root/.cache/pip/wheels/3f/08/13/2321517088bb2e95bfd0e45033bb9c923189e5b2078e0be4ef\n",
            "Successfully built torch-geometric\n",
            "Installing collected packages: isodate, yacs, rdflib, torch-geometric\n",
            "Successfully installed isodate-0.6.0 rdflib-6.0.2 torch-geometric-2.0.2 yacs-0.1.8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AwhjHPlSs556"
      },
      "source": [
        "import numpy as np\n",
        "import os\n",
        "import copy\n",
        "\n",
        "import torch\n",
        "import torch_geometric as geo\n",
        "from torch.autograd import Variable, grad\n",
        "import torch.utils.data as Data\n",
        "import matplotlib.pyplot as plt\n",
        "from torch.autograd.functional import jacobian, hessian"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wpJFLAzLwcGP"
      },
      "source": [
        "Load database:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1UnPff9JwbdF",
        "outputId": "35f0852a-5f18-4871-af7f-3df393a82feb"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/gdrive', force_remount=True)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /gdrive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Vh6udF0zwi-R",
        "outputId": "e8804e13-bd52-48bb-e6ca-9e9c162c03b5"
      },
      "source": [
        "# change directory from your top level google drive to the RL folder (make sure step 1 is already done!)\n",
        "%cd /gdrive/My\\ Drive/MMLDT_graduate_short_course/Instructor_Steve_Sun_Jupyter_notebook/Lab3C_Geometric_learning_for_hyperelasticity_pyTorch/"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/gdrive/.shortcut-targets-by-id/1rPDbVGz2lJwbzwXYyEpJn2BszNcSZhBU/MMLDT_graduate_short_course/Instructor_Steve_Sun_Jupyter_notebook/Lab3C_Geometric_learning_for_hyperelasticity_pyTorch\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "70U6uFMovyRr"
      },
      "source": [
        "# name of polycrystal features\n",
        "items = ['vol','neighnb','area','diameq','sphericity','dihangleav','facenb','euler_1','euler_2','euler_3']\n",
        "n_features = len(items)\n",
        "# placeholders for graph data\n",
        "gnn_data_list = []\n",
        "gnn_feature_list = []\n",
        "\n",
        "os.chdir('graph_process/database/tesselations/RVE_1')\n",
        "for k in range(1,151):\n",
        "    working_dir = '../RVE_'+str(k)+'/'\n",
        "    os.chdir(working_dir)\n",
        "    \n",
        "    # load graph connectivity from the stored adjacency matrix\n",
        "    A = np.load('A.npy').astype(np.int32)\n",
        "    n_nodes = A.shape[0]\n",
        "    n_edges = A.sum() // 2\n",
        "    edge_index = np.zeros((2,n_edges), dtype=np.int32)\n",
        "    # write to edge_list\n",
        "    cnt = 0\n",
        "    for i in range(n_nodes):\n",
        "        for j in range(i, n_nodes):\n",
        "            if A[i,j] > 0:\n",
        "                edge_index[0,cnt] = i\n",
        "                edge_index[1,cnt] = j\n",
        "                cnt += 1\n",
        "    \n",
        "    # load crystal data from txt file\n",
        "    X = np.zeros((n_nodes,n_features), dtype=np.double)\n",
        "    for i in range(n_features):\n",
        "        X[:,i] = np.loadtxt('poly/' + items[i] + '.txt')\n",
        "    \n",
        "    gnn_feature_list.append( torch.tensor(X, dtype=torch.double) )\n",
        "    gnn_data_list.append( geo.data.Data(torch.tensor(X, dtype=torch.double), torch.tensor(edge_index,dtype=torch.long), torch.tensor([k-1])) )\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UTC6rRtwx8c6"
      },
      "source": [
        "\"\"\"\n",
        "    for large deformation cases\n",
        "    convert F, P to C, S\n",
        "\"\"\"\n",
        "def convert_Defgrad_and_PKStress( dF_ , P_ ):\n",
        "    # F = dF + I\n",
        "    n_samples = dF_.shape[0]\n",
        "    F_ = dF_.reshape(n_samples, 3,3)\n",
        "    P_ = P_.reshape(n_samples, 3,3)\n",
        "    C_ = np.zeros_like(F_)\n",
        "    S_ = np.zeros_like(C_)\n",
        "    for i in range(n_samples):\n",
        "        F_[i,:,:] += np.eye(3)\n",
        "        Fi = F_[i,:,:]\n",
        "        C_[i,:,:] = Fi.transpose() @ Fi\n",
        "        S_[i,:,:] = np.linalg.inv(Fi) @ P_[i,:,:]\n",
        "    C_ = C_.reshape(n_samples, 9)\n",
        "    S_ = S_.reshape(n_samples, 9)\n",
        "    return C_, S_\n",
        "\n",
        "# placeholders for energy data\n",
        "energy_data_list = []\n",
        "stretch_data_list = []\n",
        "PKStress_data_list = []\n",
        "\n",
        "os.chdir('../../../../elasticity/RVE_1')\n",
        "for k in range(1,151):\n",
        "    working_dir = '../RVE_'+str(k)+'/'\n",
        "    os.chdir(working_dir)\n",
        "    \n",
        "    psi = np.load('psi.npy')\n",
        "    # the input from 'deformation_gradient.npy' is actually F - I\n",
        "    dF_ = np.load('deformation_gradient.npy')\n",
        "    P_ = np.load('PKstress.npy')\n",
        "    \n",
        "    # compute C = F^T * F and S = F^-1 * P\n",
        "    C_, S_ = convert_Defgrad_and_PKStress( dF_ , P_ )\n",
        "    # because S = 2* d\\psi / dC\n",
        "    # we should use 0.5*S as the supervision on gradients\n",
        "    S_ /= 2.\n",
        "    energy_data_list.append(psi)\n",
        "    stretch_data_list.append(C_)\n",
        "    PKStress_data_list.append(S_)\n",
        "os.chdir('../..')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BHGR9jaQ6Zj6"
      },
      "source": [
        "Standardization:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Co6iNTN76Efa"
      },
      "source": [
        "from sklearn.preprocessing import StandardScaler, MinMaxScaler\n",
        "# scalers for normalization\n",
        "gnn_data_scaler = StandardScaler()\n",
        "energy_data_scaler   = StandardScaler()\n",
        "stretch_data_scaler  = StandardScaler()\n",
        "PKStress_data_scaler = StandardScaler()\n",
        "PKStress_scaler_alt = MinMaxScaler()\n",
        "gnn_data_scaler.fit(torch.cat(gnn_feature_list,dim=0).numpy().reshape(-1,n_features))\n",
        "energy_data_scaler.fit  (np.concatenate(energy_data_list  , axis=0).reshape(-1,1))\n",
        "stretch_data_scaler.fit (np.concatenate(stretch_data_list , axis=0).reshape(-1,9))\n",
        "PKStress_data_scaler.fit(np.concatenate(PKStress_data_list, axis=0).reshape(-1,9))\n",
        "# alternative min max scaler to check the validation acc\n",
        "PKStress_scaler_alt.fit(np.concatenate(PKStress_data_list, axis=0).reshape(-1,9))\n",
        "\n",
        "for k in range(150):\n",
        "    # normalize GNN nodal features and energy model data\n",
        "    tmp_gnn_features = gnn_data_scaler.transform(gnn_data_list[k].x)\n",
        "    gnn_data_list[k].x = torch.tensor(tmp_gnn_features, dtype=torch.double) #####\n",
        "    energy_data_list[k]   = energy_data_scaler  .transform(energy_data_list[k])\n",
        "    energy_data_list[k]   = torch.tensor(energy_data_list[k], dtype=torch.double) #####\n",
        "    stretch_data_list[k]  = stretch_data_scaler .transform(stretch_data_list[k])\n",
        "    stretch_data_list[k]  = torch.tensor(stretch_data_list[k], dtype=torch.double) #####\n",
        "    PKStress_data_list[k] = PKStress_data_scaler.transform(PKStress_data_list[k])\n",
        "    PKStress_data_list[k] = torch.tensor(PKStress_data_list[k])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lR89HbFZ6fip",
        "outputId": "6c63c07f-c7b6-4502-f377-fc7adacaba57"
      },
      "source": [
        "# collect train_X, train_Y for each gnn batch\n",
        "energy_scale  = torch.tensor(1. / energy_data_scaler.scale_, dtype=torch.double)\n",
        "strain_scales = torch.tensor(stretch_data_scaler.scale_, dtype=torch.double)\n",
        "stress_scales = torch.tensor(PKStress_data_scaler.scale_, dtype=torch.double)\n",
        "stress_limits = torch.tensor(PKStress_data_scaler.mean_, dtype=torch.double)\n",
        "data_scales = (strain_scales, energy_scale, stress_scales, stress_limits)\n",
        "trainX_list = []\n",
        "trainY_list = []\n",
        "for bch in range(10):\n",
        "    masks = [torch.full( (stretch_data_list[15*bch+m]. shape[0], 1), m, dtype=torch.int32 ) for m in range(15)]\n",
        "    train_X = torch.stack(stretch_data_list[15*bch : 15*(bch+1)]).reshape((-1,9))\n",
        "    train_X = torch.cat( (train_X, torch.stack(masks).reshape(-1,1)), axis=1 )\n",
        "    trainX_list.append(Variable(train_X))\n",
        "    train_Y = torch.cat( (torch.stack(energy_data_list[15*bch : 15*(bch+1)]).reshape(-1,1),\\\n",
        "        torch.stack(PKStress_data_list[15*bch : 15*(bch+1)]).reshape(-1,9) ), axis=1)\n",
        "    trainY_list.append(Variable(train_Y))\n",
        "\n",
        "# config parameters\n",
        "BATCH_SIZE = 64\n",
        "EPOCH = 160\n",
        "MODEL_PATH = 'gnn_elas.pt'\n",
        "\n",
        "# construct the dataloaders\n",
        "train_loaders = []\n",
        "valid_loaders = []\n",
        "valid_split = .2\n",
        "gnn_loaders = []\n",
        "for bch in range(10):\n",
        "    gnn_loaders.append( geo.data.DataLoader(gnn_data_list[15*bch : 15*(bch+1)], batch_size=15) )\n",
        "    dataset_len = trainX_list[bch].shape[0]\n",
        "    indices = list(range(dataset_len))\n",
        "    # Randomly splitting indices:\n",
        "    valid_idx = np.random.choice(indices, size=int(np.floor(valid_split * dataset_len)), replace=False)\n",
        "    train_idx = list(set(indices) - set(valid_idx))\n",
        "    # Defining the samplers for each phase based on the random indices:\n",
        "    train_sampler = Data.SubsetRandomSampler(train_idx)\n",
        "    valid_sampler = Data.SubsetRandomSampler(valid_idx)\n",
        "\n",
        "    torch_dataset = Data.TensorDataset(trainX_list[bch], trainY_list[bch])\n",
        "    train_loader = Data.DataLoader(torch_dataset, batch_size=BATCH_SIZE, sampler=train_sampler)\n",
        "    valid_loader = Data.DataLoader(torch_dataset, batch_size=BATCH_SIZE, sampler=valid_sampler)\n",
        "    train_loaders.append(train_loader)\n",
        "    valid_loaders.append(valid_loader)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/torch_geometric/deprecation.py:13: UserWarning: 'data.DataLoader' is deprecated, use 'loader.DataLoader' instead\n",
            "  warnings.warn(out)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XbT9VmggHxw_"
      },
      "source": [
        "import torch\n",
        "from torch.autograd import Variable, grad\n",
        "import torch.utils.data as Data\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F_\n",
        "from torch.nn.init import xavier_uniform_\n",
        "import numpy as np, copy\n",
        "loss_func = nn.MSELoss()\n",
        "DEBUG = False\n",
        "\n",
        "class Multiply(nn.Module):\n",
        "\n",
        "    def __init__(self):\n",
        "        super(Multiply, self).__init__()\n",
        "\n",
        "    def forward(self, inp_list):\n",
        "        result = torch.ones(inp_list[0].size(), dtype=torch.double)\n",
        "        for x in inp_list:\n",
        "            result *= x\n",
        "\n",
        "        return result\n",
        "\n",
        "\n",
        "import torch_geometric as torchG\n",
        "from torch_geometric.nn import GCNConv, global_mean_pool, GATv2Conv"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class GNN(nn.Module):\n",
        "\n",
        "    def __init__(self, inp, out, hidden):\n",
        "        super(GNN, self).__init__()\n",
        "        self.conv1 = GATv2Conv(inp, hidden)\n",
        "        self.conv2 = GATv2Conv(hidden, hidden)\n",
        "        self.conv3 = GATv2Conv(hidden, hidden)\n",
        "        self.conv4 = GATv2Conv(hidden, hidden)\n",
        "        self.conv5 = GATv2Conv(hidden, hidden)\n",
        "        self.bn1 = nn.BatchNorm1d(hidden)\n",
        "        self.bn3 = nn.BatchNorm1d(hidden)\n",
        "        self.bn4 = nn.BatchNorm1d(hidden)\n",
        "        self.drop1 = nn.Dropout(p=0.5)\n",
        "        self.lin1 = nn.Linear(hidden, (hidden // 2), bias=True)\n",
        "        self.bn2 = nn.BatchNorm1d(hidden // 2)\n",
        "        self.drop2 = nn.Dropout(p=0.5)\n",
        "        xavier_uniform_(self.lin1.weight)\n",
        "        self.lin2 = nn.Linear((hidden // 2), out, bias=True)\n",
        "        self.bn3 = nn.BatchNorm1d(out)\n",
        "        xavier_uniform_(self.lin2.weight)\n",
        "\n",
        "    def forward(self, x, edge_index, batch):\n",
        "        x = self.conv1(x, edge_index)\n",
        "        x = self.bn1(x)\n",
        "        x = F_.relu(x)\n",
        "        x = self.drop1(x)\n",
        "        x = self.conv2(x, edge_index)\n",
        "        x = F_.relu(x)\n",
        "        #x = self.bn3(x)\n",
        "        x = self.conv3(x, edge_index)\n",
        "        x = F_.relu(x)\n",
        "        x = self.conv4(x, edge_index)\n",
        "        x = F_.relu(x)\n",
        "        #x = self.bn4(x)\n",
        "        x = self.conv5(x, edge_index)\n",
        "        x = global_mean_pool(x, batch)\n",
        "        x = self.lin1(x)\n",
        "        x = self.bn2(x)\n",
        "        x = F_.relu(x)\n",
        "        x = self.drop2(x)\n",
        "        x = self.lin2(x)\n",
        "        x = self.bn3(x)\n",
        "        return x\n",
        "\n",
        "\n",
        "class MixGNN(nn.Module):\n",
        "\n",
        "    def __init__(self, inp, out, hidden, gnn_inp, gnn_out, gnn_hidden):\n",
        "        super(MixGNN, self).__init__()\n",
        "        self.gnn = GNN(gnn_inp, gnn_out, gnn_hidden)\n",
        "        self.fc1 = nn.Linear((inp + gnn_out), hidden, bias=True)\n",
        "        self.bn4 = nn.BatchNorm1d(hidden)\n",
        "        self.drop4 = nn.Dropout(p=0.5)\n",
        "        xavier_uniform_(self.fc1.weight)\n",
        "        self.mult1 = Multiply()\n",
        "        self.fc2 = nn.Linear(hidden, (hidden // 4), bias=True)\n",
        "        self.bn5 = nn.BatchNorm1d(hidden // 4)\n",
        "        self.drop5 = nn.Dropout(p=0.3)\n",
        "        xavier_uniform_(self.fc2.weight)\n",
        "        self.mult2 = Multiply()\n",
        "        self.mult3 = Multiply()\n",
        "        self.fc3 = nn.Linear((hidden // 4), out, bias=True)\n",
        "\n",
        "    def forward(self, x, masks, gnn_x, edge_index, gnn_batch, debug=False):\n",
        "        gnn_x = self.gnn(gnn_x, edge_index, gnn_batch)\n",
        "        gnn_x = gnn_x[masks, :]\n",
        "        h = torch.cat((x, gnn_x), axis=1)\n",
        "        h = self.fc1(h)\n",
        "        h = self.bn4(h)\n",
        "        h = F_.relu(h)\n",
        "        h = self.mult1([h, h])\n",
        "        h = self.drop4(h)\n",
        "        h = self.fc2(h)\n",
        "        h = self.bn5(h)\n",
        "        h = F_.relu(h)\n",
        "        h = self.mult2([h, h])\n",
        "        h = self.mult3([h, h])\n",
        "        h = self.drop5(h)\n",
        "        h = self.fc3(h)\n",
        "        return h\n",
        "\n",
        "    def predict_energy(self, x, masks, gnn_x, edge_index, gnn_batch, data_scales):\n",
        "        in_scales, out_scale, grad_scales, grad_limits = data_scales\n",
        "        y = self(x, masks, gnn_x, edge_index, gnn_batch)\n",
        "        grad_y, = grad((y.sum()), x, create_graph=True)\n",
        "        grad_y /= torch.tensor(in_scales) * out_scale\n",
        "        grad_y -= torch.tensor(grad_limits)\n",
        "        grad_y /= torch.tensor(grad_scales)\n",
        "        return (x.detach().numpy(), y.detach().numpy(), grad_y.detach().numpy())"
      ],
      "metadata": {
        "id": "Hv3g7t_k9ywi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B_hk92DoFAAH"
      },
      "source": [
        "\n",
        "def train_H1_scaled_hybrid(net, train_loaders, valid_loaders, graph_loaders, EPOCH, BATCH_SIZE, optimizer, scheduler, data_scales, lam1):\n",
        "    best_loss = np.inf\n",
        "    num_train_data = np.array([len(train_loader.dataset) for train_loader in train_loaders], dtype=(np.int32)).sum()\n",
        "    num_valid_data = np.array([len(val_loader.dataset) for val_loader in valid_loaders], dtype=(np.int32)).sum()\n",
        "    in_scales, out_scale, grad_scales, grad_limits = data_scales\n",
        "    lossTotal = np.zeros((EPOCH, 1))\n",
        "    lossVal = np.zeros((EPOCH, 1))\n",
        "    lossGrad = np.zeros((EPOCH, 1))\n",
        "    vlossTotal = np.zeros((EPOCH, 1))\n",
        "    vlossVal = np.zeros((EPOCH, 1))\n",
        "    vlossGrad = np.zeros((EPOCH, 1))\n",
        "    terminate_training = False\n",
        "    eps = 1e-06\n",
        "    for epoch in range(EPOCH):\n",
        "        epoch_mse0 = 0.0\n",
        "        epoch_mse1 = 0.0\n",
        "        epoch_val_mse0 = 0.0\n",
        "        epoch_val_mse1 = 0.0\n",
        "        for bch in range(len(train_loaders)):\n",
        "            train_loader = train_loaders[bch]\n",
        "            valid_loader = valid_loaders[bch]\n",
        "            graph_loader = graph_loaders[bch]\n",
        "            num_gnn_batch = 0\n",
        "            for _, temp_data in enumerate(graph_loader):\n",
        "                num_gnn_batch += 1\n",
        "\n",
        "            assert num_gnn_batch == 1\n",
        "            gnn_data = copy.deepcopy(temp_data)\n",
        "            for cnt, (batch_x, batch_y) in enumerate(train_loader):\n",
        "                b_x = Variable((batch_x[:, :-1]), requires_grad=True)\n",
        "                b_y = Variable(batch_y)\n",
        "                masks = batch_x[:, -1].long()\n",
        "                net.eval()\n",
        "\n",
        "                output0 = net(b_x, masks, (gnn_data.x), (gnn_data.edge_index), (gnn_data.batch), debug=DEBUG)\n",
        "                output1, = grad((output0.sum()), b_x, create_graph=True)\n",
        "                b_x.requires_grad = False\n",
        "                output1 /= torch.tensor(in_scales) * out_scale\n",
        "                output1 -= torch.tensor(grad_limits)\n",
        "                output1 /= torch.tensor(grad_scales)\n",
        "                net.train()\n",
        "                mse0 = loss_func(output0, b_y[:, 0:1])\n",
        "                mse1 = loss_func(output1, b_y[:, 1:])\n",
        "                epoch_mse0 += mse0.detach().item() * BATCH_SIZE\n",
        "                epoch_mse1 += mse1.detach().item() * BATCH_SIZE\n",
        "                loss = mse0 + lam1 * mse1\n",
        "                optimizer.zero_grad()\n",
        "                loss.backward()\n",
        "                optimizer.step()\n",
        "\n",
        "            for _, (batch_x, batch_y) in enumerate(valid_loader):\n",
        "                b_x = Variable((batch_x[:, :-1]), requires_grad=True)\n",
        "                b_y = Variable(batch_y)\n",
        "                masks = batch_x[:, -1].long()\n",
        "                num_gnn_batch = 0\n",
        "                for _, temp_data in enumerate(graph_loader):\n",
        "                    num_gnn_batch += 1\n",
        "\n",
        "                assert num_gnn_batch == 1\n",
        "                gnn_data = copy.deepcopy(temp_data)\n",
        "                net.eval()\n",
        "                output0 = net(b_x, masks, gnn_data.x, gnn_data.edge_index, gnn_data.batch)\n",
        "                output1, = grad((output0.sum()), b_x, create_graph=True)\n",
        "                b_x.requires_grad = False\n",
        "                output1 /= torch.tensor(in_scales) * out_scale\n",
        "                output1 -= torch.tensor(grad_limits)\n",
        "                output1 /= torch.tensor(grad_scales)\n",
        "                epoch_val_mse0 += loss_func(output0, b_y[:, 0:1]).detach().item() * BATCH_SIZE\n",
        "                epoch_val_mse1 += loss_func(output1, b_y[:, 1:]).detach().item() * BATCH_SIZE\n",
        "\n",
        "        epoch_mse0 /= num_train_data\n",
        "        epoch_mse1 /= num_train_data\n",
        "        epoch_loss = epoch_mse0 + lam1 * epoch_mse1\n",
        "        epoch_val_mse0 /= num_valid_data\n",
        "        epoch_val_mse1 /= num_valid_data\n",
        "        epoch_val_loss = epoch_val_mse0 + lam1 * epoch_val_mse1\n",
        "        scheduler.step()\n",
        "        lossTotal[epoch] = epoch_loss\n",
        "        lossVal[epoch] = epoch_mse0\n",
        "        lossGrad[epoch] = epoch_mse1\n",
        "        vlossTotal[epoch] = epoch_val_loss\n",
        "        vlossVal[epoch] = epoch_val_mse0\n",
        "        vlossGrad[epoch] = epoch_val_mse1\n",
        "        if  (epoch) % 5 == 0:\n",
        "            print('    epoch {:4d}'.format(epoch + 1), 'lr: {:.7f}'.format(optimizer.param_groups[0]['lr']), 'train val loss: {:.3e}'.format(epoch_mse0), 'train grad loss: {:.3e}'.format(epoch_mse1), 'train total loss: {:.3e}'.format(epoch_loss), 'valid val loss: {:.3e}'.format(epoch_val_mse0), 'valid grad loss: {:.3e}'.format(epoch_val_mse1), 'valid total loss: {:.3e}'.format(epoch_val_loss))\n",
        "            if epoch_loss < best_loss:\n",
        "                best_loss = epoch_loss\n",
        "                state = copy.deepcopy(net.state_dict())\n",
        "\n",
        "    print('Best score:', best_loss)\n",
        "    return (state, lossTotal, lossVal, lossGrad, vlossTotal, vlossVal, vlossGrad)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QPiB4NVN67SY"
      },
      "source": [
        "net = MixGNN(inp=9, out=1, hidden=256, gnn_inp=n_features, gnn_out=9, gnn_hidden=64).double()\n",
        "optimizer = torch.optim.Adam(net.parameters(), lr=2e-3, weight_decay=1e-6)\n",
        "scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=40, gamma=0.7)\n",
        "# reserve the last 15 RVEs for test purpose\n",
        "\n",
        "#torch.save(state_energy, MODEL_PATH)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MZ4Y3OuR7jVQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "acd025bd-3116-4c79-d8fe-8c3647d5fc3b"
      },
      "source": [
        "state_energy, lossTotal, lossVal, lossGrad, vlossTotal, vlossVal, vlossGrad =\\\n",
        "train_H1_scaled_hybrid(net.double(), train_loaders, valid_loaders, gnn_loaders, EPOCH, BATCH_SIZE, optimizer, scheduler, data_scales, lam1=.5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:39: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:40: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:41: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:66: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:67: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:68: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "    epoch    1 lr: 0.0020000 train val loss: 8.199e-03 train grad loss: 4.045e-02 train total loss: 2.843e-02 valid val loss: 3.958e-04 valid grad loss: 4.339e-03 valid total loss: 2.565e-03\n",
            "    epoch    6 lr: 0.0020000 train val loss: 8.499e-03 train grad loss: 4.028e-02 train total loss: 2.864e-02 valid val loss: 4.211e-04 valid grad loss: 4.035e-03 valid total loss: 2.438e-03\n",
            "    epoch   11 lr: 0.0014000 train val loss: 4.599e-03 train grad loss: 2.343e-02 train total loss: 1.631e-02 valid val loss: 2.551e-04 valid grad loss: 2.680e-03 valid total loss: 1.595e-03\n",
            "    epoch   16 lr: 0.0014000 train val loss: 2.710e-03 train grad loss: 1.526e-02 train total loss: 1.034e-02 valid val loss: 1.417e-04 valid grad loss: 1.919e-03 valid total loss: 1.101e-03\n",
            "    epoch   21 lr: 0.0014000 train val loss: 2.337e-03 train grad loss: 1.308e-02 train total loss: 8.879e-03 valid val loss: 1.039e-04 valid grad loss: 1.521e-03 valid total loss: 8.644e-04\n",
            "    epoch   26 lr: 0.0014000 train val loss: 2.094e-03 train grad loss: 1.052e-02 train total loss: 7.355e-03 valid val loss: 1.017e-04 valid grad loss: 1.121e-03 valid total loss: 6.621e-04\n",
            "    epoch   31 lr: 0.0014000 train val loss: 1.637e-03 train grad loss: 8.514e-03 train total loss: 5.895e-03 valid val loss: 7.093e-05 valid grad loss: 8.373e-04 valid total loss: 4.896e-04\n",
            "    epoch   36 lr: 0.0014000 train val loss: 1.602e-03 train grad loss: 7.522e-03 train total loss: 5.363e-03 valid val loss: 7.059e-05 valid grad loss: 6.983e-04 valid total loss: 4.198e-04\n",
            "    epoch   41 lr: 0.0014000 train val loss: 1.320e-03 train grad loss: 6.470e-03 train total loss: 4.555e-03 valid val loss: 6.450e-05 valid grad loss: 6.008e-04 valid total loss: 3.649e-04\n",
            "    epoch   46 lr: 0.0014000 train val loss: 1.215e-03 train grad loss: 6.000e-03 train total loss: 4.215e-03 valid val loss: 5.409e-05 valid grad loss: 5.761e-04 valid total loss: 3.421e-04\n",
            "    epoch   51 lr: 0.0009800 train val loss: 1.335e-03 train grad loss: 6.147e-03 train total loss: 4.409e-03 valid val loss: 5.198e-05 valid grad loss: 5.609e-04 valid total loss: 3.324e-04\n",
            "    epoch   56 lr: 0.0009800 train val loss: 7.493e-04 train grad loss: 3.601e-03 train total loss: 2.550e-03 valid val loss: 3.120e-05 valid grad loss: 3.602e-04 valid total loss: 2.113e-04\n",
            "    epoch   61 lr: 0.0009800 train val loss: 6.460e-04 train grad loss: 3.276e-03 train total loss: 2.284e-03 valid val loss: 2.574e-05 valid grad loss: 3.219e-04 valid total loss: 1.867e-04\n",
            "    epoch   66 lr: 0.0009800 train val loss: 7.258e-04 train grad loss: 3.484e-03 train total loss: 2.468e-03 valid val loss: 2.929e-05 valid grad loss: 3.505e-04 valid total loss: 2.045e-04\n",
            "    epoch   71 lr: 0.0009800 train val loss: 6.324e-04 train grad loss: 3.089e-03 train total loss: 2.177e-03 valid val loss: 3.569e-05 valid grad loss: 3.444e-04 valid total loss: 2.079e-04\n",
            "    epoch   76 lr: 0.0009800 train val loss: 6.202e-04 train grad loss: 3.201e-03 train total loss: 2.221e-03 valid val loss: 2.921e-05 valid grad loss: 3.038e-04 valid total loss: 1.811e-04\n",
            "    epoch   81 lr: 0.0009800 train val loss: 5.524e-04 train grad loss: 2.909e-03 train total loss: 2.007e-03 valid val loss: 2.303e-05 valid grad loss: 2.829e-04 valid total loss: 1.645e-04\n",
            "    epoch   86 lr: 0.0009800 train val loss: 5.998e-04 train grad loss: 2.726e-03 train total loss: 1.963e-03 valid val loss: 2.435e-05 valid grad loss: 2.694e-04 valid total loss: 1.590e-04\n",
            "    epoch   91 lr: 0.0006860 train val loss: 4.597e-04 train grad loss: 2.347e-03 train total loss: 1.633e-03 valid val loss: 2.992e-05 valid grad loss: 2.535e-04 valid total loss: 1.567e-04\n",
            "    epoch   96 lr: 0.0006860 train val loss: 2.951e-04 train grad loss: 1.641e-03 train total loss: 1.116e-03 valid val loss: 1.641e-05 valid grad loss: 2.057e-04 valid total loss: 1.192e-04\n",
            "    epoch  101 lr: 0.0006860 train val loss: 3.409e-04 train grad loss: 1.693e-03 train total loss: 1.187e-03 valid val loss: 1.901e-05 valid grad loss: 2.066e-04 valid total loss: 1.223e-04\n",
            "    epoch  106 lr: 0.0006860 train val loss: 3.041e-04 train grad loss: 1.603e-03 train total loss: 1.105e-03 valid val loss: 1.627e-05 valid grad loss: 1.933e-04 valid total loss: 1.129e-04\n",
            "    epoch  111 lr: 0.0006860 train val loss: 2.914e-04 train grad loss: 1.520e-03 train total loss: 1.051e-03 valid val loss: 1.483e-05 valid grad loss: 1.942e-04 valid total loss: 1.119e-04\n",
            "    epoch  116 lr: 0.0006860 train val loss: 2.461e-04 train grad loss: 1.385e-03 train total loss: 9.385e-04 valid val loss: 1.354e-05 valid grad loss: 1.680e-04 valid total loss: 9.753e-05\n",
            "    epoch  121 lr: 0.0006860 train val loss: 2.717e-04 train grad loss: 1.399e-03 train total loss: 9.710e-04 valid val loss: 1.320e-05 valid grad loss: 1.783e-04 valid total loss: 1.024e-04\n",
            "    epoch  126 lr: 0.0006860 train val loss: 2.566e-04 train grad loss: 1.373e-03 train total loss: 9.432e-04 valid val loss: 1.549e-05 valid grad loss: 1.713e-04 valid total loss: 1.011e-04\n",
            "    epoch  131 lr: 0.0004802 train val loss: 2.148e-04 train grad loss: 1.187e-03 train total loss: 8.082e-04 valid val loss: 1.347e-05 valid grad loss: 1.529e-04 valid total loss: 8.991e-05\n",
            "    epoch  136 lr: 0.0004802 train val loss: 1.858e-04 train grad loss: 1.008e-03 train total loss: 6.897e-04 valid val loss: 1.224e-05 valid grad loss: 1.384e-04 valid total loss: 8.144e-05\n",
            "    epoch  141 lr: 0.0004802 train val loss: 1.874e-04 train grad loss: 9.944e-04 train total loss: 6.846e-04 valid val loss: 1.264e-05 valid grad loss: 1.352e-04 valid total loss: 8.025e-05\n",
            "    epoch  146 lr: 0.0004802 train val loss: 1.600e-04 train grad loss: 8.998e-04 train total loss: 6.099e-04 valid val loss: 1.120e-05 valid grad loss: 1.400e-04 valid total loss: 8.122e-05\n",
            "    epoch  151 lr: 0.0004802 train val loss: 1.794e-04 train grad loss: 9.076e-04 train total loss: 6.332e-04 valid val loss: 1.225e-05 valid grad loss: 1.263e-04 valid total loss: 7.542e-05\n",
            "    epoch  156 lr: 0.0004802 train val loss: 1.520e-04 train grad loss: 8.422e-04 train total loss: 5.731e-04 valid val loss: 1.034e-05 valid grad loss: 1.284e-04 valid total loss: 7.454e-05\n",
            "Best score: 0.0005730861652495185\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "duTROfALZCuK",
        "outputId": "0b5d4688-3c23-4ed6-d9b6-463405e59cd8"
      },
      "source": [
        "# test graph data from gnn_loader[0]\n",
        "num_gnn_batch = 0\n",
        "for _, temp_data in enumerate(gnn_loaders[1]):\n",
        "    num_gnn_batch += 1\n",
        "assert(num_gnn_batch == 1)\n",
        "gnn_data = copy.deepcopy(temp_data)\n",
        "\n",
        "\n",
        "# prepare test X\n",
        "test_X = Variable(trainX_list[1][:,:-1], requires_grad = True)\n",
        "test_masks = trainX_list[1][:,-1].long()\n",
        "\n",
        "test_true_strain = stretch_data_scaler.inverse_transform( test_X.detach().numpy() )\n",
        "test_true_energy = energy_data_scaler.inverse_transform( trainY_list[1][:,0:1].detach().numpy() )\n",
        "test_true_stress = PKStress_data_scaler.inverse_transform( trainY_list[1][:,1:].detach().numpy() )\n",
        "\n",
        "# test routine\n",
        "net.load_state_dict(state_energy)\n",
        "net.eval()\n",
        "test_Y = net(test_X, test_masks, gnn_data.x, gnn_data.edge_index, gnn_data.batch)\n",
        "test_YGrad, = grad(test_Y.sum(), test_X, create_graph=True)\n",
        "test_YGrad /= (torch.tensor(strain_scales) * energy_scale)\n",
        "test_pred_stress = test_YGrad.detach().numpy()\n",
        "\n",
        "from sklearn.metrics import mean_squared_error\n",
        "test_loss = mean_squared_error( PKStress_data_scaler.transform(test_pred_stress),\\\n",
        "    PKStress_data_scaler.transform(test_true_stress) )\n",
        "print('test MSE: ', test_loss)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "test MSE:  0.005979488086594809\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:22: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5pi9dYc47_wZ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 333
        },
        "outputId": "33e7d6f0-9449-4f1c-d84d-d007fd7d9e75"
      },
      "source": [
        "test_plot_range = range(0,10)\n",
        "strain_hist = test_true_strain[test_plot_range,:]\n",
        "stress_hist_true = test_true_stress[test_plot_range,:]\n",
        "stress_hist_pred = test_pred_stress[test_plot_range,:]\n",
        "\n",
        "fig, axs = plt.subplots(1, 3, figsize=(18,4.5),\\\n",
        "        gridspec_kw={'wspace': 0.4, 'hspace': 0.2})\n",
        "ax = axs[0]\n",
        "ax.plot(strain_hist[:,0], stress_hist_true[:,0], 'r-', label='gound truth')\n",
        "ax.plot(strain_hist[:,0], stress_hist_pred[:,0], 'b--', label='prediction')\n",
        "ax.set_xlabel(\"F11\", fontsize=15)\n",
        "ax.set_ylabel(\"S11\", fontsize=15)\n",
        "ax.set_ylim([0,0.2])\n",
        "ax.legend(fontsize=12)\n",
        "\n",
        "ax = axs[1]\n",
        "ax.plot(strain_hist[:,0], stress_hist_true[:,4], 'r-', label='gound truth')\n",
        "ax.plot(strain_hist[:,0], stress_hist_pred[:,4], 'b--', label='prediction')\n",
        "ax.set_xlabel(\"F11\", fontsize=15)\n",
        "ax.set_ylabel(\"S22\", fontsize=15)\n",
        "ax.set_ylim([0,0.2])\n",
        "ax.legend(fontsize=12)\n",
        "\n",
        "ax = axs[2]\n",
        "ax.plot(strain_hist[:,0], stress_hist_true[:,1], 'r-', label='gound truth')\n",
        "ax.plot(strain_hist[:,0], stress_hist_pred[:,1], 'b--', label='prediction')\n",
        "ax.set_xlabel(\"F11\", fontsize=15)\n",
        "ax.set_ylabel(\"S12\", fontsize=15)\n",
        "ax.set_ylim([0,0.2])\n",
        "ax.legend(fontsize=12)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7f0e8e4cc910>"
            ]
          },
          "metadata": {},
          "execution_count": 22
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1296x324 with 3 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tg3oZ3F_Y96g"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}