sdd_coh2_test.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "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/sdd_coh2_test.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive/')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3PnCGZOHV3oE",
        "outputId": "f1b20402-de5e-468a-ed81-1d77f518f6a3"
      },
      "execution_count": 1,
      "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"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install gpytorch\n",
        "!pip install botorch"
      ],
      "metadata": {
        "id": "-HICaTiurvjS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "25065f6b-0b3e-495c-d812-4b83e4933399"
      },
      "execution_count": 2,
      "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": [
        "!cd drive"
      ],
      "metadata": {
        "id": "o4WaVHKUXQUe"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "sfB0QOze1gFj"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import pandas as pd\n",
        "from sklearn.model_selection import train_test_split\n",
        "from torch.utils.data import TensorDataset, DataLoader\n",
        "import numpy as np\n",
        "import gpytorch\n",
        "from botorch.utils.transforms import normalize, standardize\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Check if GPU is available\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
      ]
    },
    {
      "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": "JKL8p2x3S2-1"
      },
      "execution_count": 5,
      "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": "wU8MCZvY1kFJ"
      },
      "execution_count": 6,
      "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": "oYgXyyiW4XEs"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Load data (by tasks)\n",
        "X, Y = loadTasks([\"narea\"])\n",
        "\n",
        "#Split into train and validation sets\n",
        "seed = 1234\n",
        "split = 1\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)\n",
        "\n",
        "# # Create TensorDatasets\n",
        "# train_dataset = TensorDataset(X_train_tensor, Y_train_tensor)\n",
        "# test_dataset = TensorDataset(X_test_tensor, Y_test_tensor)\n",
        "\n",
        "# # Create DataLoader for training and test sets\n",
        "# train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
        "# test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)"
      ],
      "metadata": {
        "id": "xw1uVMpk4l0q",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c39b09b9-2ba2-45a0-be9f-e11dab8b5537"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-8-80e7c077d3fd>:10: 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",
            "  x_train = torch.tensor(x_train, dtype=torch.float64)\n",
            "<ipython-input-8-80e7c077d3fd>:11: 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",
            "  y_train = torch.tensor(y_train, dtype=torch.float64)\n",
            "<ipython-input-8-80e7c077d3fd>:12: 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",
            "  x_test = torch.tensor(x_test, dtype=torch.float64)\n",
            "<ipython-input-8-80e7c077d3fd>:13: 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",
            "  y_test = torch.tensor(y_test, dtype=torch.float64)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# #x points for plot\n",
        "# space_x = np.linspace(350, 2500, 500)\n",
        "# mesh_x, mesh_y = np.meshgrid(space_x, space_x)\n",
        "# x_pred = np.vstack([mesh_x.ravel(), mesh_y.ravel()]).T"
      ],
      "metadata": {
        "id": "4cn9wGb2StwJ"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#subsection of data\n",
        "N = 3000\n",
        "\n",
        "#todo: change to mixed dataset\n",
        "x_train = x_train[:N, 1:] #remove task feature\n",
        "x_train = normalize(x_train, torch.tensor([[0,0],[2150,2150]])).numpy()\n",
        "y_train = y_train [:N]\n",
        "y_train = standardize(y_train).numpy()\n",
        "\n",
        "#define kernel(s) for dataset above\n",
        "kernel = gpytorch.kernels.RBFKernel(ard_num_dims=2) #todo: change this to mixed kernel\n",
        "kernel.lengthscale = torch.tensor([0.03, 0.035])\n",
        "\n",
        "rbf = kernel.__call__\n",
        "def k(x, y, h=rbf):\n",
        "  x = torch.tensor(x, dtype=torch.float64)\n",
        "  y = torch.tensor(y, dtype=torch.float64)\n",
        "  return h(x, y).numpy()"
      ],
      "metadata": {
        "id": "tL5aOXumQ2kF"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "noise_scale = 0.04\n",
        "\n",
        "#solve (exact) kernel regression\n",
        "K = k(x_train, x_train, rbf)\n",
        "alpha_exact = np.linalg.solve(K + noise_scale ** 2 * np.eye(N), y_train)\n",
        "\n",
        "def exactMean(x_pred):\n",
        "  return k(x_pred, x_train) @ alpha_exact"
      ],
      "metadata": {
        "id": "Qcey43DoSxuN"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "surfacePlot(exactMean, title=\"Exact Mean via Kernel Regression\", n=100)"
      ],
      "metadata": {
        "id": "STb2XbINTpos",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 561
        },
        "outputId": "982d9d70-6f95-449b-cd02-863946b4ba2a"
      },
      "execution_count": 12,
      "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",
            "<ipython-input-10-85f5d26e5fb9>:16: 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",
            "  x = torch.tensor(x, dtype=torch.float64)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Using SDD method (refer: https://anonymous.4open.science/r/sdd-gps-5486/sdd.ipynb\n",
        ")"
      ],
      "metadata": {
        "id": "imToRKKEdAc6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lr = 0.0001\n",
        "momentum = 0.9\n",
        "polyak = 1e-2\n",
        "iterations = 3500\n",
        "B = 10\n",
        "\n",
        "#intialize variables\n",
        "alpha = np.zeros((N,))\n",
        "alpha_polyak = np.zeros((N,))\n",
        "v = np.zeros((N,))\n",
        "\n",
        "\n",
        "#dual objective\n",
        "def g(params, idx, k, N, B, noise_scale):\n",
        "    K_batch = k(x_train[idx], x_train)\n",
        "    grad = np.zeros((N,))\n",
        "    grad[idx] = K_batch @ params - y_train[idx] + (noise_scale ** 2) * params[idx]\n",
        "    return (N / B) * grad\n",
        "\n",
        "#update parameter\n",
        "def update(params_polyak, velocity, params, idx, k,  N, B, noise_scale):\n",
        "    grad = g(params=params, idx=idx, k=k, N=N, B=B, noise_scale=noise_scale)\n",
        "    velocity = momentum * velocity - lr * grad\n",
        "    params = params + velocity\n",
        "    params_polyak = polyak * params + (1.0 - polyak) * params_polyak\n",
        "    return params, params_polyak, velocity"
      ],
      "metadata": {
        "id": "PHq3bhmBqvyd"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(iterations):\n",
        "    idx = np.random.choice(N, size=(B,), replace=False)\n",
        "    alpha, alpha_polyak, v = update(params_polyak=alpha_polyak,\n",
        "                                    velocity=v,\n",
        "                                    params=alpha,\n",
        "                                    idx=idx, k=k, N=N, B=B,noise_scale=noise_scale)"
      ],
      "metadata": {
        "id": "tHi5xzK7Wa9Y"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def sddMean(x_pred):\n",
        "  return k(x_pred, x_train) @ alpha_polyak"
      ],
      "metadata": {
        "id": "W23uv-8BXZ92"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "surfacePlot(sddMean, title=\"Sdd Mean\", n=100)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 527
        },
        "id": "C18xNYqnZwa2",
        "outputId": "0c6d2e89-8095-4ac1-9364-e13d407077d8"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-10-85f5d26e5fb9>:16: 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",
            "  x = torch.tensor(x, dtype=torch.float64)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}