VanillaGPTest.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyOAYj1mxYAYcY1caGc+PcDN",
      "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/ruhanaazam/gp_transfer/blob/main/VanillaGPTest.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VP0bM4HbO1f8",
        "outputId": "e3c07da2-7337-49a6-89a5-3afcc81fb09b"
      },
      "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"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive/')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!cd drive"
      ],
      "metadata": {
        "id": "k_eXSNtIO_Zt"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install gpytorch\n",
        "!pip install botorch"
      ],
      "metadata": {
        "id": "egHIkDIoPldz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a89214f5-3373-4dbd-bbe2-fb583bd80450"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: gpytorch in /usr/local/lib/python3.10/dist-packages (1.11)\n",
            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.10/dist-packages (from gpytorch) (1.2.2)\n",
            "Requirement already satisfied: linear-operator>=0.5.0 in /usr/local/lib/python3.10/dist-packages (from gpytorch) (0.5.1)\n",
            "Requirement already satisfied: torch>=1.11 in /usr/local/lib/python3.10/dist-packages (from linear-operator>=0.5.0->gpytorch) (2.1.0+cu121)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.10/dist-packages (from linear-operator>=0.5.0->gpytorch) (1.11.4)\n",
            "Requirement already satisfied: jaxtyping>=0.2.9 in /usr/local/lib/python3.10/dist-packages (from linear-operator>=0.5.0->gpytorch) (0.2.25)\n",
            "Requirement already satisfied: typeguard~=2.13.3 in /usr/local/lib/python3.10/dist-packages (from linear-operator>=0.5.0->gpytorch) (2.13.3)\n",
            "Requirement already satisfied: numpy>=1.17.3 in /usr/local/lib/python3.10/dist-packages (from scikit-learn->gpytorch) (1.23.5)\n",
            "Requirement already satisfied: joblib>=1.1.1 in /usr/local/lib/python3.10/dist-packages (from scikit-learn->gpytorch) (1.3.2)\n",
            "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn->gpytorch) (3.2.0)\n",
            "Requirement already satisfied: typing-extensions>=3.7.4.1 in /usr/local/lib/python3.10/dist-packages (from jaxtyping>=0.2.9->linear-operator>=0.5.0->gpytorch) (4.5.0)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch>=1.11->linear-operator>=0.5.0->gpytorch) (3.13.1)\n",
            "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch>=1.11->linear-operator>=0.5.0->gpytorch) (1.12)\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch>=1.11->linear-operator>=0.5.0->gpytorch) (3.2.1)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch>=1.11->linear-operator>=0.5.0->gpytorch) (3.1.3)\n",
            "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch>=1.11->linear-operator>=0.5.0->gpytorch) (2023.6.0)\n",
            "Requirement already satisfied: triton==2.1.0 in /usr/local/lib/python3.10/dist-packages (from torch>=1.11->linear-operator>=0.5.0->gpytorch) (2.1.0)\n",
            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch>=1.11->linear-operator>=0.5.0->gpytorch) (2.1.4)\n",
            "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy->torch>=1.11->linear-operator>=0.5.0->gpytorch) (1.3.0)\n",
            "Requirement already satisfied: botorch in /usr/local/lib/python3.10/dist-packages (0.9.5)\n",
            "Requirement already satisfied: multipledispatch in /usr/local/lib/python3.10/dist-packages (from botorch) (1.0.0)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.10/dist-packages (from botorch) (1.11.4)\n",
            "Requirement already satisfied: torch>=1.13.1 in /usr/local/lib/python3.10/dist-packages (from botorch) (2.1.0+cu121)\n",
            "Requirement already satisfied: pyro-ppl>=1.8.4 in /usr/local/lib/python3.10/dist-packages (from botorch) (1.8.6)\n",
            "Requirement already satisfied: gpytorch==1.11 in /usr/local/lib/python3.10/dist-packages (from botorch) (1.11)\n",
            "Requirement already satisfied: linear-operator==0.5.1 in /usr/local/lib/python3.10/dist-packages (from botorch) (0.5.1)\n",
            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.10/dist-packages (from gpytorch==1.11->botorch) (1.2.2)\n",
            "Requirement already satisfied: jaxtyping>=0.2.9 in /usr/local/lib/python3.10/dist-packages (from linear-operator==0.5.1->botorch) (0.2.25)\n",
            "Requirement already satisfied: typeguard~=2.13.3 in /usr/local/lib/python3.10/dist-packages (from linear-operator==0.5.1->botorch) (2.13.3)\n",
            "Requirement already satisfied: numpy>=1.7 in /usr/local/lib/python3.10/dist-packages (from pyro-ppl>=1.8.4->botorch) (1.23.5)\n",
            "Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.10/dist-packages (from pyro-ppl>=1.8.4->botorch) (3.3.0)\n",
            "Requirement already satisfied: pyro-api>=0.1.1 in /usr/local/lib/python3.10/dist-packages (from pyro-ppl>=1.8.4->botorch) (0.1.2)\n",
            "Requirement already satisfied: tqdm>=4.36 in /usr/local/lib/python3.10/dist-packages (from pyro-ppl>=1.8.4->botorch) (4.66.1)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch>=1.13.1->botorch) (3.13.1)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from torch>=1.13.1->botorch) (4.5.0)\n",
            "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch>=1.13.1->botorch) (1.12)\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch>=1.13.1->botorch) (3.2.1)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch>=1.13.1->botorch) (3.1.3)\n",
            "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch>=1.13.1->botorch) (2023.6.0)\n",
            "Requirement already satisfied: triton==2.1.0 in /usr/local/lib/python3.10/dist-packages (from torch>=1.13.1->botorch) (2.1.0)\n",
            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch>=1.13.1->botorch) (2.1.4)\n",
            "Requirement already satisfied: joblib>=1.1.1 in /usr/local/lib/python3.10/dist-packages (from scikit-learn->gpytorch==1.11->botorch) (1.3.2)\n",
            "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn->gpytorch==1.11->botorch) (3.2.0)\n",
            "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy->torch>=1.13.1->botorch) (1.3.0)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import pandas as pd\n",
        "from sklearn.model_selection import train_test_split\n",
        "import numpy as np\n",
        "import gpytorch\n",
        "from botorch.utils.transforms import normalize, standardize\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "from botorch import fit_gpytorch_model\n",
        "from botorch.models import SingleTaskGP, MixedSingleTaskGP\n",
        "from gpytorch.mlls import ExactMarginalLogLikelihood\n",
        "from botorch.models.transforms import Standardize, Normalize\n",
        "from botorch.utils.transforms import normalize, standardize\n",
        "from botorch.fit import fit_gpytorch_mll\n",
        "\n",
        "import pickle\n",
        "\n",
        "# Check if GPU is available\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
      ],
      "metadata": {
        "id": "ra70LWXBPFRL"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "  base_path = \"/content/drive/My Drive/Colab Notebooks/Transfer_Coh2\""
      ],
      "metadata": {
        "id": "nW5cjpMSN8QW"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def surfacePlot(model, title = \"Your Function\" ,n=900):\n",
        "    '''\n",
        "    Plots your (true or estimated) coheritability function.\n",
        "    model: function that takes in two wavelength and outputs coh2 (estimate)\n",
        "    n: n**2 is the number of points to plot the surface\n",
        "    '''\n",
        "    # Generate data for the plot\n",
        "    x1 = torch.linspace(0, 1, n)\n",
        "    x2 = torch.linspace(0, 1, n)\n",
        "    X1, X2 = torch.meshgrid(x1, x2)\n",
        "    X = torch.stack([X1.reshape((-1)),X2.reshape((-1))]).T\n",
        "\n",
        "    Z = model(X.to(device)).cpu().detach().numpy()\n",
        "\n",
        "    # Create a contour plot\n",
        "    plt.contourf(X1, X2, Z.reshape(n, n), cmap='viridis')\n",
        "    plt.colorbar(label='Function Value')\n",
        "\n",
        "    #plot top 1%\n",
        "    #threshold = np.percentile(Z, 99)\n",
        "    #threshold = torch.kthvalue(Z.flatten(), int(0.99 * n * n)).values\n",
        "    #plt.contour(X1, X2, Z.reshape(n, n), levels=[threshold], colors='red', linewidths=2)\n",
        "\n",
        "    # Add labels and title\n",
        "    plt.xlabel('Wavelength 1')\n",
        "    plt.ylabel('Wavelength 2')\n",
        "    plt.title(title)\n",
        "\n",
        "    # Show the plot\n",
        "    plt.show()\n",
        "    return"
      ],
      "metadata": {
        "id": "PXDaiVe5PHr5"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def getTaskID(trait, crop=\"Sorghum\"):\n",
        "    assert crop == \"Sorghum\", \"Does not handles ids for from that are not Sorghum yet.\"\n",
        "    ids = {\"narea\": 1, \"sla\": 2, \"pn\": 3, \"ps\": 4}\n",
        "    return ids[trait]"
      ],
      "metadata": {
        "id": "fXXuL2OGPLZS"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def loadTasks(tasks):\n",
        "    taskData = []\n",
        "    for trait in tasks:\n",
        "        #read raw task file\n",
        "        data = pd.read_csv(f\"/content/drive/My Drive/Colab Notebooks/Transfer_Coh2/data/{trait}_coh2.csv\")\n",
        "        data = torch.tensor(data.values)\n",
        "\n",
        "        #format data for supervised training, each row (taskid, wave1, wave2, coh2)\n",
        "        n = torch.ones(data.shape[0], dtype=torch.float32)\n",
        "        col_index =  torch.arange(data.shape[0], dtype=torch.float32)\n",
        "        col_index = torch.outer(n, col_index)\n",
        "        row_index = col_index.T\n",
        "\n",
        "        #stack wave1, wave2 and coh2 tensors together\n",
        "        task_ids = torch.ones(data.shape) * getTaskID(trait)\n",
        "        flat_data = torch.stack([task_ids.flatten(), col_index.flatten(), row_index.flatten(), data.flatten()])\n",
        "        flat_data = flat_data.T\n",
        "\n",
        "        #remove all rows with nans\n",
        "        nan_mask = torch.isnan(flat_data)\n",
        "        nan_in_rows = torch.any(nan_mask, dim=1)\n",
        "        clean = flat_data[~nan_in_rows]\n",
        "\n",
        "        taskData.append(clean)\n",
        "\n",
        "    #combine all tasks\n",
        "    all_tasks = torch.cat(taskData)\n",
        "    return all_tasks[:, :3], all_tasks[:, -1]"
      ],
      "metadata": {
        "id": "PQ6jsov2PQsD"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# #Load data (by tasks)\n",
        "# X, Y = loadTasks([\"narea\", \"sla\", \"pn\", \"ps\"])\n",
        "\n",
        "# #Split into train and validation sets\n",
        "# seed = 1234\n",
        "# split = 0.85\n",
        "# x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=split, random_state=seed)\n",
        "\n",
        "# # Convert NumPy arrays to PyTorch tensors\n",
        "# x_train = torch.tensor(x_train, dtype=torch.float64)\n",
        "# y_train = torch.tensor(y_train, dtype=torch.float64)\n",
        "# x_test = torch.tensor(x_test, dtype=torch.float64)\n",
        "# y_test = torch.tensor(y_test, dtype=torch.float64)"
      ],
      "metadata": {
        "id": "jsRiYk1ZPR7L"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#should have one result dictionary for each task...\n",
        "seed = 1234\n",
        "split = 0.85\n",
        "\n",
        "#option_n = [i for i in range(500, 1500+1, 500)]\n",
        "option_n = [750, 900]\n",
        "M = 1000 #validation set size\n",
        "tasks = [\"narea\", \"sla\", \"pn\", \"ps\"]"
      ],
      "metadata": {
        "id": "x9o2RM4UPAMw"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#train SingleTaskGP\n",
        "\n",
        "results = {}\n",
        "for task in tasks:\n",
        "  #load data for single task and split into training and test\n",
        "  X, Y = loadTasks([task])\n",
        "  x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=split, random_state=seed)\n",
        "  x_train, x_test, y_train, y_test = x_train[:option_n[-1]], x_test[:M], y_train[:option_n[-1]], y_test[:M]\n",
        "  del X\n",
        "  del Y\n",
        "\n",
        "  # normalize input, standardize y\n",
        "  c_xtest = normalize(x_test[:M, 1:], torch.tensor([[0,0],[2150,2150]])) #continous part\n",
        "  y_test_standardized = standardize(y_test[:M]).reshape(-1,1)\n",
        "\n",
        "  c_xtrain = normalize(x_train[:, 1:], torch.tensor([[0,0],[2150,2150]])) #continous part\n",
        "  y_train_standardized = standardize(y_train).reshape(-1,1)\n",
        "\n",
        "\n",
        "  task_result = {\"val_loss\":[],\n",
        "           \"train_loss\": []\n",
        "           }\n",
        "  for N in option_n:\n",
        "    # Train the model ...\n",
        "    model = SingleTaskGP(c_xtrain[:N], y_train_standardized[:N])\n",
        "\n",
        "    # Use Exact Marginal Log Likelihood as the loss\n",
        "    mll = ExactMarginalLogLikelihood(model.likelihood, model)\n",
        "\n",
        "    # Fit the model\n",
        "    fit_gpytorch_mll(mll, )\n",
        "\n",
        "    #save the losses\n",
        "    y_hat = model.posterior(c_xtest).mean\n",
        "    val_loss = torch.mean((y_test_standardized - y_hat)**2).item()\n",
        "    task_result[\"val_loss\"].append(val_loss)\n",
        "\n",
        "    y_hat = model.posterior(c_xtrain).mean\n",
        "    train_loss = torch.mean((y_train_standardized - y_hat)**2).item()\n",
        "    task_result[\"train_loss\"].append(train_loss)\n",
        "\n",
        "  results[task] = task_result\n",
        "\n",
        "  #save results\n",
        "  with open(f'{base_path}/results/vanillaGP_single.pkl', 'wb') as pickle_file:\n",
        "    pickle.dump(results, pickle_file)\n",
        "\n",
        "  #save model\n",
        "  torch.save(model.state_dict(), f'{base_path}/models/vanilla_gp_{N}.pth')"
      ],
      "metadata": {
        "id": "gPsLYSEKNGMd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2ccd3bf1-1885-4cd1-f03a-8c3456973ca4"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/botorch/models/utils/assorted.py:202: InputDataWarning: Input data is not standardized (mean = tensor([0.0122], dtype=torch.float64), std = tensor([0.9818], dtype=torch.float64)). Please consider scaling the input to zero mean and unit variance.\n",
            "  warnings.warn(msg, InputDataWarning)\n",
            "/usr/local/lib/python3.10/dist-packages/botorch/models/utils/assorted.py:202: InputDataWarning: Input data is not standardized (mean = tensor([0.0075], dtype=torch.float64), std = tensor([0.9804], dtype=torch.float64)). Please consider scaling the input to zero mean and unit variance.\n",
            "  warnings.warn(msg, InputDataWarning)\n",
            "/usr/local/lib/python3.10/dist-packages/botorch/models/utils/assorted.py:202: InputDataWarning: Input data is not standardized (mean = tensor([0.0108], dtype=torch.float64), std = tensor([0.9737], dtype=torch.float64)). Please consider scaling the input to zero mean and unit variance.\n",
            "  warnings.warn(msg, InputDataWarning)\n",
            "/usr/local/lib/python3.10/dist-packages/botorch/models/utils/assorted.py:202: InputDataWarning: Input data is not standardized (mean = tensor([0.0064], dtype=torch.float64), std = tensor([0.9802], dtype=torch.float64)). Please consider scaling the input to zero mean and unit variance.\n",
            "  warnings.warn(msg, InputDataWarning)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#re-load your results\n",
        "with open(f'{base_path}/results/vanillaGP_single.pkl', 'rb') as pickle_file:\n",
        "    results = pickle.load(pickle_file)\n",
        "\n",
        "#re-load model here\n",
        "model_N = option_n[-1] # num training data in desired model\n",
        "state_dict = torch.load(f'{base_path}/models/vanilla_gp_{model_N}.pth')\n",
        "model = SingleTaskGP(c_xtrain, y_train_standardized)  # Create a new GP model\n",
        "model.load_state_dict(state_dict)"
      ],
      "metadata": {
        "id": "ygBuMhuJaAGU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2bf3eb9c-9a85-46c2-b53a-6ce038076d10"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<All keys matched successfully>"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#plot training and validation loss\n",
        "for task in [\"ps\"]:\n",
        "  task_dic = results[task]\n",
        "\n",
        "  # Create a line plot\n",
        "  plt.plot(option_n, task_dic[\"val_loss\"], label = \"val_loss\")\n",
        "  plt.plot(option_n, task_dic[\"train_loss\"], label = \"train_loss\")\n",
        "\n",
        "# Add labels and title\n",
        "plt.xlabel('N points')\n",
        "plt.ylabel('MSE Loss')\n",
        "plt.title('Samples vs Loss')\n",
        "plt.legend()\n",
        "\n",
        "# Show the plot\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "5U4KBRziNKMQ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "outputId": "d4d81462-ca38-47f2-c930-ff037453250f"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for task in tasks:\n",
        "  def modelWrapper(X):\n",
        "    inp = X\n",
        "    return model.posterior(inp).mean\n",
        "\n",
        "  surfacePlot(modelWrapper, title=f\"GP for task {task}, {N} points\", n=100)"
      ],
      "metadata": {
        "id": "O_cgsFULuWij",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "7d1933ee-d33f-4c90-eb51-9feb8fa846be"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/torch/functional.py:504: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at ../aten/src/ATen/native/TensorShape.cpp:3526.)\n",
            "  return _VF.meshgrid(tensors, **kwargs)  # type: ignore[attr-defined]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}