07_Generating_light_curves_using_Gaussian_Processes.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "07_Generating_light_curves_using_Gaussian_Processes.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm",
      "authorship_tag": "ABX9TyN6juqWAgVTtaaDHlkt/9hO",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/SoumyaShreeram/Microlensing_with_NeuralNets/blob/master/07_Generating_light_curves_using_Gaussian_Processes.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Iv0iBoEj6qK3",
        "colab_type": "text"
      },
      "source": [
        "# 07. Generating the light curves that are fitted using Gaussian Processes Regression\n",
        "\n",
        "In this notebook, all the light-curves with season gaps and fitted completely using Gaussian Processes Regression. \n",
        "\n",
        "Note: This notebook can be further optimized by running the code parallely due to the long duration required for fitting each curve.\n",
        "\n",
        "Author: Soumya Shreeram <br>\n",
        "Date: 15th May 2020"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "deDcrZnEPlzz",
        "colab_type": "text"
      },
      "source": [
        "Import all required python libraries"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hIOkLVF5WNgW",
        "colab_type": "code",
        "outputId": "af242190-d82b-4ac5-c931-1c21712c96d8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "from google.colab import drive\n",
        "import os, sys\n",
        "from time import sleep\n",
        "import pickle\n",
        "import importlib\n",
        "import itertools\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "plt.rcParams.update({'font.size': 16})\n",
        "import random\n",
        "import os\n",
        "from IPython.display import Image, SVG\n",
        "from scipy.interpolate import interp1d \n",
        "\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import classification_report\n",
        "from sklearn.metrics import confusion_matrix\n",
        "import sklearn.gaussian_process as gp\n",
        "from sklearn.gaussian_process.kernels import RBF, Matern, WhiteKernel, RationalQuadratic\n",
        "from sklearn.gaussian_process.kernels import ConstantKernel\n",
        "\n",
        "%tensorflow_version 1.x\n",
        "import tensorflow as tf\n",
        "\n",
        "from tensorflow.keras.models import Model, Sequential\n",
        "from tensorflow.keras.layers import Input, Activation, InputSpec\n",
        "from tensorflow.python.keras.layers import Conv1D, Conv2D\n",
        "from tensorflow.python.keras.layers import MaxPooling1D, MaxPooling2D, GlobalMaxPooling2D\n",
        "from tensorflow.keras.layers import Dense, Dropout, Flatten, Add, BatchNormalization, Concatenate\n",
        "from tensorflow.keras.optimizers import SGD, Adam\n",
        "from tensorflow.keras.utils import plot_model\n",
        "from tensorflow.keras import backend as K\n",
        "from tensorflow.keras.layers import Layer"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "TensorFlow 1.x selected.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jDf-kPS_OvVQ",
        "colab_type": "text"
      },
      "source": [
        "Mount google drive"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V7aoHjFTP2s9",
        "colab_type": "code",
        "outputId": "b1a67d19-34a8-47b8-b740-aafc16bbdd88",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 122
        }
      },
      "source": [
        "drive.mount('/content/gdrive')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Go to this URL in a browser: https://accounts.google.com/o/oauth2/auth?client_id=947318989803-6bn6qk8qdgf4n4g3pfee6491hc0brc4i.apps.googleusercontent.com&redirect_uri=urn%3aietf%3awg%3aoauth%3a2.0%3aoob&response_type=code&scope=email%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdocs.test%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive.photos.readonly%20https%3a%2f%2fwww.googleapis.com%2fauth%2fpeopleapi.readonly\n",
            "\n",
            "Enter your authorization code:\n",
            "··········\n",
            "Mounted at /content/gdrive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CFu89FBF3rYM",
        "colab_type": "text"
      },
      "source": [
        "Directory where the `python` files are stored on Google Drive. These imported files are also available in `.ipynb` format on the GitHub repo with same names (without the dr; <strike>`dr`</strike>`0X_sameFileName`). dr stands for drive. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aQmHoYFN3sX1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "os.chdir('/content/gdrive/My Drive/Colab Notebooks')\n",
        "\n",
        "import nb_02i_preprocessing_data as dat\n",
        "import nb_03_neural_network_designs as nnet"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DJbzcl4A8xJQ",
        "colab_type": "text"
      },
      "source": [
        "Setting up the path to the data directory"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gl3kJxIDwwxH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "current_dir = os.getcwd()\n",
        "data_dir = r'/content/gdrive/My Drive/training_set_microlensing/'\n",
        "save_image_dir = r'/content/gdrive/My Drive/Colab Notebooks/Images/'\n",
        "save_model_dir = r'/content/gdrive/My Drive/Colab Notebooks/Models/'\n",
        "save_data_dir = r'/content/gdrive/My Drive/Colab Notebooks/Data/'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mF4SshagaAw2",
        "colab_type": "text"
      },
      "source": [
        "## 1. Input parameters"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xYQFOUe7Z-98",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "v_t = [500, 300] # transverse velcity\n",
        "v_t_idx = 0 # choose index value for the velocity you would like (0 or 1)\n",
        "r_0 = (2,4,10,15,20,30,40,60,80,100) # scale radius\n",
        "output_class_names = [str(r) for r in r_0 ]\n",
        "\n",
        "# select type of Interpolation\n",
        "cubic, linear = False, True\n",
        "\n",
        "# data loaded with season gaps\n",
        "season_gaps = True\n",
        "\n",
        "# if using the new data set generated by Eric (v_500_new, v_500_gaps_new)\n",
        "new_data_set = True\n",
        "\n",
        "# generates new interpolated light curves? OR Use previously saved light curves?\n",
        "generate_new_files, use_saved_file = True, False"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E9x31ZGmsWsD",
        "colab_type": "text"
      },
      "source": [
        "## 2. Load the data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f58qKFoTr0TS",
        "colab_type": "text"
      },
      "source": [
        "There are 10 categories into which the light-curves are classified. Each category is represented by the scale radius `r_0`. For every scale radius, there exists a light-curve whose data points are stored in the 3D array `l_curves`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EwCb_eMa9AlY",
        "colab_type": "code",
        "outputId": "6d738659-a3f6-4900-ff5e-faf0c6b48a87",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# sets the sampling parameters\n",
        "sample_params = dat.setSamplingParameters(v_t[v_t_idx], data_dir, season_gaps)\n",
        "\n",
        "# initializes data arrays\n",
        "class_cat, l_curves, out_catergories, out_radii = dat.initializer(r_0, \\\n",
        "                                                                  sample_params)\n",
        "\n",
        "for idx, rad in enumerate(r_0):\n",
        "  filename = dat.getFilename(data_dir, idx, rad, v_t[v_t_idx], sample_params, \\\n",
        "                             season_gaps, new_data_set)\n",
        "  \n",
        "  # load data from the file\n",
        "  l_curves, _, _ = dat.loadData(filename, idx, l_curves, sample_params, idx,\\\n",
        "                                  season_gaps, new_data_set)\n",
        "  out_catergories[idx*sample_params[0][idx]:(idx+1)*sample_params[0][idx]] = class_cat[1][idx]\n",
        "  out_radii[idx*sample_params[0][idx]:(idx+1)*sample_params[0][idx]] = r_0[idx]\n",
        "\n",
        "print('Shape of light curves vector:', np.shape(l_curves))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Shape of light curves vector: (50000, 955, 1)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JPX2BPsI_fAC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# load time array, and error of light curves array from 1 sample file for J0158\n",
        "mjhd = np.load(data_dir+'Light_Curves/mjhd.npy')\n",
        "l_curves_err = np.load(data_dir+'Light_Curves/lcurves_error.npy')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SGSowb2c0jXT",
        "colab_type": "text"
      },
      "source": [
        "Loads the ligths arrays (if not generated again)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RktEbVudjmRi",
        "colab_type": "text"
      },
      "source": [
        "## 3. Implementing Gaussian Processes\n",
        "### 3.1 Setting up the Kernel for Gaussian Processor \n",
        "\n",
        "The *prior function*, $y$, is specified by the mean, $m(x_i)$, and corvariance function, $k(x_i, x_j)$. Additionally, idependent and identically distributed (iid) Gaussian noise can be added to the prior function; this is specified by the signal variance,  $\\sigma^2$. Overall, the labels for the gaussian processor are defined as:\n",
        "\n",
        "$$y \\sim GP(m(x_i), k(x_i, x_j) + \\delta_{ij} \\sigma^2)$$\n",
        "\n",
        "The form of $m(x_i)$ and $k(x_i, x_j)$ is chosen during model selection. There are different types of kernels (or covariance functions) that are used here:\n",
        "\n",
        "1. [**Constant kernel**](https://scikit-learn.org/stable/modules/generated/sklearn.gaussian_process.kernels.ConstantKernel.html): It is used as part of a product-kernel where it scales the magnitude of the other factor (kernel) or as part of a sum-kernel, where it modifies the mean of the Gaussian process.\n",
        "2. [**Radial-basis function kernel**](https://scikit-learn.org/stable/modules/generated/sklearn.gaussian_process.kernels.RBF.html#sklearn.gaussian_process.kernels.RBF) (**RBF**; aka squared-exponential kernel): It is parameterized by a length scale parameter, $l>0$, and is given as:\n",
        "$$k(x_i, x_j) = exp\\Big(- \\frac{d(x_i, x_j)^2}{2l^2}\\Big),$$\n",
        "where $d(x_i, x_j)$ is the Euclidean distance.\n",
        "3. [**Matérn kernel**](https://scikit-learn.org/stable/modules/generated/sklearn.gaussian_process.kernels.Matern.html#sklearn.gaussian_process.kernels.Matern): It is a generalization of the RBF kernel and it has an additional parameter, $\\nu$,  which controls the smoothness of the resulting function. As $\\nu \\rightarrow \\inf$, this kernel becomes RBF. \n",
        "4. [**Rational Quadratic kernel**](https://scikit-learn.org/stable/modules/generated/sklearn.gaussian_process.kernels.RationalQuadratic.html#sklearn.gaussian_process.kernels.RationalQuadratic): The RationalQuadratic kernel can be seen as a scale mixture (an infinite sum) of RBF kernels with different characteristic length scales. It is parameterized by a length scale parameter $l>0$  and a scale mixture parameter $\\alpha > 0$. The kernel is given by:\n",
        "$$k(x_i, x_j) = \\Bigg[1+ exp\\Big(- \\frac{d(x_i, x_j)^2}{2\\alpha l^2}\\Big)\\Bigg]^{-\\alpha}.$$\n",
        "5. [**White kernel**](https://scikit-learn.org/stable/modules/generated/sklearn.gaussian_process.kernels.WhiteKernel.html): The main use-case of this kernel is as part of a sum-kernel where it explains the noise of the signal as independently and identically normally-distributed. The parameter noise_level equals the variance of this noise.\n",
        "\n",
        "\n",
        "\n",
        "The three different types of kernels tested here are with the corresponding keywords are the following:\n",
        "1. '*matern*': Constant kernel + Matérn kernel + White Kernel\n",
        "2. '*RBF*': Constant kernel + RBF kernel + White Kernel\n",
        "3. '*RationalQuadratic*': Constant kernel + Rational Quadratic kernel + White Kernel\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oKGPH9DBye4I",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# smoothness parameter of the matérn kernel\n",
        "nu = 1.5\n",
        "amplitude = 2.0\n",
        "\n",
        "# scale mixture parameter\n",
        "alpha = 1.5\n",
        "\n",
        "# length-scale parameter\n",
        "length_scale = 200.0\n",
        "\n",
        "# white noise level parameter\n",
        "noise_level = 5.0\n",
        "\n",
        "kernel_types = [\"matern\", \"RBF\", \"rational_quadratic\"]\n",
        "# choose a kernel from kernel_types\n",
        "covkernel = kernel_types[0]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NMRsoUTwjNsB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def defineKernel(length_scale, nu, alpha, amplitude, covkernel):\n",
        "  \"\"\"\n",
        "  Function to define the kernel\n",
        "  @length_scale:: length-scale parameter in the kernel\n",
        "  @nu:: smoothness parameter for the matérn kernel\n",
        "  @alpha:: the scale mixture parameter\n",
        "  @amplitude:: multiplicative factor for the kernels\n",
        "  @covkernel :: keyword specifying the choise of kernel\n",
        "\n",
        "  Returns\n",
        "  @kernel\n",
        "  \"\"\"\n",
        "  background_kernel = ConstantKernel() + WhiteKernel(noise_level=noise_level)\n",
        "\n",
        "  if covkernel == \"matern\":\n",
        "    kernel =  amplitude*Matern(length_scale=length_scale, nu=nu)\n",
        "  elif covkernel ==\"RBF\": \n",
        "    kernel =  amplitude*RBF(length_scale=length_scale)\n",
        "  elif covkernel == \"rational_quadratic\":\n",
        "    kernel = amplitude*RationalQuadratic(length_scale=length_scale, alpha=alpha)\n",
        "  return kernel+background_kernel\n",
        "\n",
        "def gprOnSingleLCurve(idx, l_curves, mjhd, l_curves_err, kernel, noise_level):\n",
        "  \"\"\"\n",
        "  Function interpolates the season gaps for a single light curves using Gaussian Processes\n",
        "  Input parameters:\n",
        "  @idx :: iterating index\n",
        "  @l_curves :: y-array corresponding to the magnitude of the light curve (a single spectrum)\n",
        "  @mjhd :: x-time array\n",
        "  @l_curves_err :: y-error array corresponding to the error on the magnitude of the y-points\n",
        "  @kernel :: defines the types of kernel (covariance function) used for model fitting\n",
        "  @noise_level :: rescaling the error with a factor\n",
        "\n",
        "  Returns:\n",
        "  @y_gpr :: the new y-array generated using Gaussian processes regressor\n",
        "  @y_std :: values representing the standard deviation for the new y-array points\n",
        "  \"\"\"  \n",
        "  y, x, yerr = l_curves[idx,:,0], mjhd.reshape(-1, 1), l_curves_err\n",
        "  # rescaling yerr with the added noise; x *= y is equivalent to x = x*y\n",
        "  yerr *= noise_level \n",
        "\n",
        "  # builds and fits the regression model used for interpolation\n",
        "  model = gp.GaussianProcessRegressor(kernel, alpha=yerr).fit(x, y)\n",
        "\n",
        "  # defines the new reshuffled x-array \n",
        "  x_new = np.linspace(x[0], x[-1], num=len(x))\n",
        "\n",
        "  # predicting the new 'y-array' and 1-sigma 'y_std' array using Gaussian process regressor\n",
        "  y_gpr, y_std = model.predict(x_new, return_std=True) \n",
        "  \n",
        "  return y_gpr, y_std"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X3FuRsWDMByk",
        "colab_type": "text"
      },
      "source": [
        "Interpolates all the light curves using Gaussian processes regressor\n",
        "\n",
        "*Todo Note*: The `l_curves_err` array gets changed after every iteration, which is why it is reloaded again after every iteration. Need to sort out where the bug is coming from. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RKtjitw33-xQ",
        "colab_type": "code",
        "outputId": "f48cfcb3-ef72-4b52-debc-371c485d64a4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# initializing a light curve array to store the gaussian proccesses regressed curves\n",
        "l_curves_gpr = np.array([]),  np.array([])\n",
        "l_curves_gpr.shape = (0, len(l_curves[0,:,0]),1)\n",
        "\n",
        "# defines the kernel\n",
        "kernel = defineKernel(length_scale, nu, alpha, amplitude, covkernel)\n",
        "\n",
        "# performs gpr on all the light curves\n",
        "if generate_new_files:\n",
        "  for num in range(len(r_0)):\n",
        "    # generate separate idx array for the interpolated light curves as per radius\n",
        "    idx_array = np.arange(num*sample_params[0][num],(num+1)*sample_params[0][num])\n",
        "    print('Processing radius: %d, No. of light curves: %d'%(out_radii[num*sample_params[0][num]], len(idx_array)))    \n",
        "    \n",
        "    for i, idx in enumerate(idx_array):\n",
        "      # reloads the array to make sure no inf errors pop up *[arr gets changed after every loop]\n",
        "      l_curves_err = np.load(data_dir+'Light_Curves/lcurves_error.npy')\n",
        "\n",
        "      y_gpr, _ = gprOnSingleLCurve(idx, l_curves, mjhd, l_curves_err, kernel, noise_level)\n",
        "\n",
        "      # setting the shape same as that on l_curves array\n",
        "      y_gpr.shape = (len(y_gpr), 1)\n",
        "      \n",
        "      # appending the y-gpr and y-std arrays\n",
        "      l_curves_gpr = np.append(l_curves_gpr, [y_gpr], axis=0)\n",
        "      \n",
        "      # shows the progress\n",
        "      dat.showProgress(i, 5000)\n",
        "      \n",
        "    # save file\n",
        "    dat.saveFile(data_dir, 'Light_Curves/v500_GP/lcurves_SeasonGaps_GPR_radii_%d'%out_radii[num*sample_params[0][num]], l_curves_gpr)\n",
        "  \n",
        "  # prints the light curves array shape\n",
        "  dat.printLcurvesShape(l_curves_gpr)\n",
        "    \n",
        "# the new reshuffled time-array \n",
        "mjhd_gpr = np.linspace(mjhd[0], mjhd[-1], num=len(mjhd))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[====================] 100%"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1xxqs6VCK2Oi",
        "colab_type": "text"
      },
      "source": [
        "### 3.2 Reloads and save the light curves as one file"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I48jf-4jkKZj",
        "colab_type": "code",
        "outputId": "0f6d75be-e5c0-46c8-a7f1-c73de3dd3cad",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        }
      },
      "source": [
        "# initializing a light curve array to store the gaussian proccesses regressed curves\n",
        "l_curves_gpr = np.array([])\n",
        "l_curves_gpr.shape = (0, len(l_curves[0,:,0]),1)\n",
        "for i in range(len(r_0)):\n",
        "  # loads the file\n",
        "  filename = 'Light_Curves/v500_GP/lcurves_SeasonGaps_GPR_radii_%d'%r_0[i]\n",
        "  y_gpr = dat.loadFile(data_dir,filename)\n",
        "  \n",
        "  print(np.shape(y_gpr), ' : ', r_0[i])\n",
        "  # appends the light curves\n",
        "  l_curves_gpr = np.row_stack((l_curves_gpr, y_gpr))\n",
        "\n",
        "# prints the light curves shape\n",
        "dat.printLcurvesShape(l_curves_gpr) \n",
        "\n",
        "# save file\n",
        "dat.saveFile(data_dir, 'Light_Curves/lcurves_SeasonGaps_GPR_%d'%len(l_curves_gpr), l_curves_gpr)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(5000, 955, 1)  :  2\n",
            "(5000, 955, 1)  :  4\n",
            "(5000, 955, 1)  :  10\n",
            "(5000, 955, 1)  :  15\n",
            "(5000, 955, 1)  :  20\n",
            "(5000, 955, 1)  :  30\n",
            "(5000, 955, 1)  :  40\n",
            "(5000, 955, 1)  :  60\n",
            "(5000, 955, 1)  :  80\n",
            "(4999, 955, 1)  :  100\n",
            "shape of light curves arrays: (49999, 955, 1)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HEfpAxfEMHwK",
        "colab_type": "text"
      },
      "source": [
        "### 3.2 Plots some random light curves"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZPm4VZ2bLb-c",
        "colab_type": "code",
        "outputId": "d3627c00-50c3-4515-e756-fc8395677688",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 402
        }
      },
      "source": [
        "fig, ax = plt.subplots(1, 1, figsize=(10,5))\n",
        "\n",
        "# choosen light curves\n",
        "n = [2990, 9900]\n",
        "y_gpr, y_std = [], []\n",
        "colors = ['#f70008',  '#f70008']\n",
        "\n",
        "importlib.reload(dat)\n",
        "\n",
        "for i in range(len(n)):\n",
        "  l_curves_err = np.load(data_dir+'Light_Curves/lcurves_error.npy')\n",
        "  y_gpr, y_std = gprOnSingleLCurve(n[i], l_curves, mjhd, l_curves_err, kernel, noise_level) \n",
        "\n",
        "  # plots the data for chosen indicies in n\n",
        "  dat.plotGaussianProcessesRegressor(ax, n[i], l_curves, y_gpr, y_std, mjhd_gpr,\\\n",
        "                                     mjhd, l_curves_err, out_radii)\n",
        "\n",
        "# axis labels\n",
        "dat.setLabels(ax, 'HJD (days)', 'Magnitude', ticks=True, legend=True)\n",
        "\n",
        "# saves figures\n",
        "fig.savefig(save_image_dir+'/GP_interpolated_lcurves.png') \n",
        "  \n",
        "[print(out_radii[number]) for number in n]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2.0\n",
            "4.0\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[None, None]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 48
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}