{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# 1. Exoplanet characterisation based on a single light curve\n", "\n", "## Introduction\n", "\n", "This is a first part of a set of tutorials covering Bayesian exoplanet characterisation using wide-band photometry (transit light curves), radial velocities, and, later, transmission spectroscopy. The tutorials use freely available open source tools built around the scientific python ecosystem, and also demonstrate the use of ``PyTransit`` and ``LDTk``.\n", "\n", "The tutorials are mainly targeted to graduate students working in exoplanet characterisation who already have some experience of Python and Bayesian statistics. \n", "\n", "## Prerequisites\n", "\n", "This tutorial requires the basic Python packages for scientific computing and data analysis\n", "- NumPy, SciPy, IPython, astropy, pandas, matplotlib, and [seaborn](http://stanford.edu/~mwaskom/software/seaborn/)\n", "\n", "The MCMC sampling requires the [*emcee*](https://github.com/dfm/emcee) and [acor](https://github.com/dfm/acor) packages by D. Foreman-Mackey. These can either be installed from github or from [PyPI](https://pypi.python.org/pypi).\n", "\n", "The transit modelling is carried out with [PyTransit](https://github.com/hpparvi/PyTransit), and global optimisation with PyDE. PyTransit can be installed easily from github. First ``cd`` into the directory you want to clone the code, and then\n", "\n", " git clone https://github.com/hpparvi/PyTransit.git; cd PyTransit\n", " python setup.py install; cd -\n", " \n", "What comes to assumed prior knowledge, well... I assume you already know a bit about Bayesian statistics (I'll start with a very rough overview of the basics of Bayesian parameter estimation, though), Python (and especially the scientific packages), have a rough idea of MCMC sampling (and how *emcee* works), and, especially, have the grasp of basic concepts of exoplanets, transits, and photometry.\n", "\n", "## Bayesian parameter estimation\n", "\n", "This first tutorial covers the simple case of an exoplanet system characterisation based on a single photometric timeseries of an exoplanet transit (transit light curve). The system characterisation is a *parameter estimation* problem, where we assume we have an adequate model to describe the observations, and we want to infer the model parameters with their uncertainties.\n", "\n", "We take a [*Bayesian*](http://en.wikipedia.org/wiki/Bayesian_probability) approach to the parameter estimation, where we want to estimate the [*posterior probability*](http://en.wikipedia.org/wiki/Posterior_probability) for the model parameters given their [*prior probabilities*](http://en.wikipedia.org/wiki/Prior_probability) and a set of observations. The posterior probability density given a parameter vector $\\theta$ and observational data $D$ is described by the [*Bayes' theorem*](http://en.wikipedia.org/wiki/Bayes%27_theorem) as\n", "\n", "$$\n", "P(\\theta|D) = \\frac{P(\\theta) P(D|\\theta)}{P(D)}, \\qquad P(D|\\theta) = \\prod P(D_i|\\theta),\n", "$$\n", "\n", "where $P(\\theta)$ is the prior, $P(D|\\theta)$ is the [*likelihood*](http://en.wikipedia.org/wiki/Likelihood_function) for the data, and $P(D)$ is a [*normalising factor*](http://en.wikipedia.org/wiki/Marginal_likelihood) we don't need to bother with during MCMC-based parameter estimation. \n", "\n", "The likelihood is a product of individual observation probabilities, and has the unfortunate tendency to end up being either very small or very big. This causes computational headaches, and it is better to work with log probabilities instead, so that\n", "\n", "$$\n", "\\log P(\\theta|D) = \\log P(\\theta) + \\log P(D|\\theta), \\qquad \\log P(D|\\theta) = \\sum \\log P(D_i|\\theta)\n", "$$\n", "\n", "where we have omitted the $P(D)$ term from the posterior density.\n", "\n", "Now we still need to decide our likelihood density. If we can assume normally distributed white noise--that is, the errors in the observations are independent and identically distributed--we end up with a log likelihood function\n", "\n", "$$\n", " \\log P(D|\\theta) = -N\\log(\\sigma) -\\frac{N\\log 2\\pi}{2} - \\sum_{i=0}^N \\frac{(o_i-m_i)^2}{2\\sigma^2},\n", "$$\n", "\n", "where $N$ is the number of datapoints, $\\sigma$ is the white noise standard deviation, $o$ is the observed data, and $m$ is the model. \n", "\n", "*Note:* Unfortunately, the noise is rarely white, but contains systematic components from instrumental and astrophysical sources that should be accounted for by the noise model for robust parameter estimation. This, however, goes beyond a basic tutorial.\n", "\n", "## Implementation\n", "\n", "### Initialisation" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Populating the interactive namespace from numpy and matplotlib\n" ] } ], "source": [ "%pylab inline " ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import math as mt\n", "import pandas as pd\n", "import seaborn as sb\n", "import warnings\n", "\n", "with warnings.catch_warnings():\n", " cp = sb.color_palette()\n", "\n", "from pathlib import Path\n", "from IPython.display import display, HTML\n", "from numba import njit, prange\n", "from astropy.io import fits as pf\n", "from emcee import EnsembleSampler\n", "from tqdm.auto import tqdm\n", "from corner import corner\n", "\n", "from pytransit import QuadraticModel\n", "from pytransit.utils.de import DiffEvol\n", "from pytransit.orbits.orbits_py import as_from_rhop, i_from_ba\n", "from pytransit.param.parameter import (ParameterSet, GParameter, PParameter, LParameter,\n", " NormalPrior as NP, \n", " UniformPrior as UP)\n", "seterr('ignore')\n", "random.seed(0)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "@njit(parallel=True, cache=False, fastmath=True)\n", "def lnlike_normal_v(o, m, e):\n", " m = atleast_2d(m)\n", " npv = m.shape[0]\n", " npt = o.size\n", " lnl = zeros(npv)\n", " for i in prange(npv):\n", " for j in range(npt):\n", " lnl[i] += -log(e[i]) - 0.5*log(2*pi) - 0.5*((o[j]-m[i,j])/e[i])**2\n", " return lnl" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Log posterior function\n", "\n", "The log posterior function is the workhorse of the analysis. I implement it as a class that stores the observation data and the priors, contains the methods to calculate the model and evaluate the log posterior probability density, and encapsulates the optimisation and MCMC sampling routines." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "class LPFunction:\n", " def __init__(self, name: str, times: ndarray = None, fluxes: ndarray = None):\n", " self.tm = QuadraticModel(klims=(0.05, 0.25), nk=512, nz=512)\n", "\n", " # LPF name\n", " # --------\n", " self.name = name\n", " \n", " # Declare high-level objects\n", " # --------------------------\n", " self.ps = None # Parametrisation\n", " self.de = None # Differential evolution optimiser\n", " self.sampler = None # MCMC sampler\n", "\n", " # Initialize data\n", " # ---------------\n", " self.times = asarray(times)\n", " self.fluxes = asarray(fluxes)\n", " self.tm.set_data(self.times)\n", "\n", " # Define the parametrisation\n", " # --------------------------\n", " self.ps = ParameterSet([\n", " GParameter('tc', 'zero_epoch', 'd', NP(0.0, 0.1), (-inf, inf)),\n", " GParameter('pr', 'period', 'd', NP(1.0, 1e-5), (0, inf)),\n", " GParameter('rho', 'stellar_density', 'g/cm^3', UP(0.1, 25.0), (0, inf)),\n", " GParameter('b', 'impact_parameter', 'R_s', UP(0.0, 1.0), (0, 1)),\n", " GParameter('k2', 'area_ratio', 'A_s', UP(0.05**2, 0.25**2), (0.05**2, 0.25**2)),\n", " GParameter('q1', 'q1_coefficient', '', UP(0, 1), bounds=(0, 1)),\n", " GParameter('q2', 'q2_coefficient', '', UP(0, 1), bounds=(0, 1)),\n", " GParameter('loge', 'log10_error', '', UP(-4, 0), bounds=(-4, 0))])\n", " self.ps.freeze()\n", "\n", " def create_pv_population(self, npop=50):\n", " return self.ps.sample_from_prior(npop)\n", " \n", " def baseline(self, pv):\n", " \"\"\"Multiplicative baseline\"\"\"\n", " return 1.\n", "\n", " def transit_model(self, pv, copy=True):\n", " pv = atleast_2d(pv)\n", " \n", " # Map from sampling parametrisation to the transit model parametrisation\n", " # ----------------------------------------------------------------------\n", " k = sqrt(pv[:, 4]) # Radius ratio\n", " tc = pv[:, 0] # Zero epoch\n", " p = pv[:, 1] # Orbital period\n", " sa = as_from_rhop(pv[:, 2], p) # Scaled semi-major axis\n", " i = i_from_ba(pv[:, 3], sa) # Orbital inclination\n", " \n", " # Map the limb darkening\n", " # ----------------------\n", " ldc = zeros((pv.shape[0],2))\n", " a, b = sqrt(pv[:,5]), 2.*pv[:,6]\n", " ldc[:,0] = a * b\n", " ldc[:,1] = a * (1. - b)\n", " \n", " return squeeze(self.tm.evaluate(k, ldc, tc, p, sa, i))\n", "\n", " def flux_model(self, pv):\n", " return self.transit_model(pv) * self.baseline(pv)\n", "\n", " def residuals(self, pv):\n", " return self.fluxes - self.flux_model(pv)\n", "\n", " def set_prior(self, pid: int, prior) -> None:\n", " self.ps[pid].prior = prior\n", "\n", " def lnprior(self, pv):\n", " return self.ps.lnprior(pv)\n", "\n", " def lnlikelihood(self, pv):\n", " flux_m = self.flux_model(pv)\n", " wn = 10**(atleast_2d(pv)[:, 7])\n", " return lnlike_normal_v(self.fluxes, flux_m, wn)\n", "\n", " def lnposterior(self, pv):\n", " lnp = self.lnprior(pv) + self.lnlikelihood(pv)\n", " return where(isfinite(lnp), lnp, -inf)\n", "\n", " def __call__(self, pv):\n", " return self.lnposterior(pv)\n", "\n", " def optimize(self, niter=200, npop=50, population=None, label='Global optimisation', leave=False):\n", " if self.de is None:\n", " self.de = DiffEvol(self.lnposterior, clip(self.ps.bounds, -1, 1), npop, maximize=True, vectorize=True)\n", " if population is None:\n", " self.de._population[:, :] = self.create_pv_population(npop)\n", " else:\n", " self.de._population[:,:] = population\n", " for _ in tqdm(self.de(niter), total=niter, desc=label, leave=leave):\n", " pass\n", "\n", " def sample(self, niter=500, thin=5, label='MCMC sampling', reset=True, leave=True):\n", " if self.sampler is None:\n", " self.sampler = EnsembleSampler(self.de.n_pop, self.de.n_par, self.lnposterior, vectorize=True)\n", " pop0 = self.de.population\n", " else:\n", " pop0 = self.sampler.chain[:,-1,:].copy()\n", " if reset:\n", " self.sampler.reset()\n", " for _ in tqdm(self.sampler.sample(pop0, iterations=niter, thin=thin), total=niter, desc=label, leave=False):\n", " pass\n", "\n", " def posterior_samples(self, burn: int=0, thin: int=1):\n", " fc = self.sampler.chain[:, burn::thin, :].reshape([-1, self.de.n_par])\n", " return pd.DataFrame(fc, columns=self.ps.names)\n", "\n", " def plot_mcmc_chains(self, pid: int=0, alpha: float=0.1, thin: int=1, ax=None):\n", " fig, ax = (None, ax) if ax is not None else subplots()\n", " ax.plot(self.sampler.chain[:, ::thin, pid].T, 'k', alpha=alpha)\n", " fig.tight_layout()\n", " return fig\n", "\n", " def plot_light_curve(self, model: str = 'de', figsize: tuple = (13, 4)):\n", " fig, ax = subplots(figsize=figsize, constrained_layout=True)\n", " cp = sb.color_palette()\n", "\n", " if model == 'de':\n", " pv = self.de.minimum_location\n", " err = 10**pv[7]\n", " elif model == 'mc':\n", " fc = array(self.posterior_samples())\n", " pv = permutation(fc)[:300]\n", " err = 10**median(pv[:, 7], 0)\n", "\n", " ax.errorbar(self.times, self.fluxes, err, fmt='.', c=cp[4], alpha=0.75)\n", "\n", " if model == 'de':\n", " ax.plot(self.times, self.flux_model(pv), c=cp[0])\n", " if model == 'mc':\n", " flux_pr = self.flux_model(fc[permutation(fc.shape[0])[:1000]])\n", " flux_pc = array(percentile(flux_pr, [50, 0.15,99.85, 2.5,97.5, 16,84], 0))\n", " [ax.fill_between(self.times, *flux_pc[i:i+2,:], alpha=0.2,facecolor=cp[0]) for i in range(1,6,2)]\n", " ax.plot(self.times, flux_pc[0], c=cp[0])\n", " setp(ax, xlim=self.times[[0,-1]], xlabel='Time', ylabel='Normalised flux')\n", " return fig, axs\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Priors\n", "\n", "The priors are contained in a ``ParameterSet`` object from ``pytransit.param.parameter``. ``ParameterSet`` is a utility class containing a function for calculating the joint prior, etc. We're using only two basic priors: a normal prior ``NP``, for which $x \\sim N(\\mu,\\sigma)$, a uniform prior ``UP``, for which $x \\sim U(a,b)$.\n", "\n", "We could use an informative prior on the planet-star area ratio (squared radius ratio) that we base on the observed NIR transit depth (see below). This is justified since the limb darkening, which affects the observed transit depth, is sufficiently weak in NIR. We would either need to use significantly wider informative prior, or an uninformative one, if we didn't have NIR data.\n", "\n", "#### Model\n", "\n", "The model has two components: a multiplicative constant baseline, and a transit shape modelled using the quadratic Mandel & Agol transit model implemented in ``PyTransit``. The sampling parameterisation is different than the parameterisation used by the transit model, so we need to map the parameters from the sampling space to the model space. Also, we're keeping things simple and assuming a circular orbit. Eccentric orbits will be considered in later tutorials. \n", "\n", "#### Limb darkening\n", "\n", "The **limb darkening** uses the parameterisation by [Kipping (2013, MNRAS, 435(3), 2152–2160)](http://mnras.oxfordjournals.org/content/435/3/2152), where the quadratic limb darkening coefficients $u$ and $v$ are mapped from sampling parameters $q_1$ and $q_2$ as\n", "\n", "$$\n", "u = 2\\sqrt{q_1}q_2,\n", "$$\n", "\n", "$$\n", "v = \\sqrt{q_1}(1-2q_2).\n", "$$\n", "\n", "This parameterisation allows us to use uniform priors from 0 to 1 to cover the whole physically sensible $(u,v)$-space.\n", "\n", "#### Log likelihood\n", "\n", "The *log likelihood* calculation is carried out by the ``ll_normal_es`` function that evaluates the normal log likelihood given a single error value.\n", "\n", "### Read in the data\n", "\n", "First we need to read in the (mock) observation data stored in ``obs_data.fits``. The data corresponds to a single transit observed simultaneously in eight passbands (filters). The photometry is saved in extension 1 as a binary table, and we want to read the mid-exposure times and flux values corresponding to different passbands. The time is stored in the ``time`` column, and fluxes are stored in the ``f_wn_*`` columns, where ``*`` is the filter name." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Filter names: u, g, r, i, z, J2, H2, Ks\n" ] } ], "source": [ "dfile = Path('data').joinpath('obs_data.fits')\n", "data = pf.getdata(dfile, ext=1)\n", "\n", "flux_keys = [n for n in data.names if 'f_wn' in n]\n", "filter_names = [k.split('_')[-1] for k in flux_keys]\n", "\n", "time = data['time'].astype('d')\n", "fluxes = [data[k].astype('d') for k in flux_keys]\n", "\n", "print ('Filter names: ' + ', '.join(filter_names))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "First, let's have a quick look at our data, and plot the blue- and redmost passbands. " ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "with sb.axes_style('white'):\n", " fig, axs = subplots(1,2, figsize=(13,5), sharey=True)\n", " axs[0].plot(time,fluxes[0], drawstyle='steps-mid', c=cp[0])\n", " axs[1].plot(time,fluxes[-1], drawstyle='steps-mid', c=cp[2])\n", " setp(axs, xlim=time[[0,-1]])\n", " fig.tight_layout()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here we see what we'd expect to see. The stronger limb darkening in blue makes the bluemost transit round, while we can spot the end of ingress and the beginning of egress directly by eye from the redmost light curve. Also, the transit is deeper in *u'* than in *Ks*, which tells that the impact parameter *b* is smallish (the transit would be deeper in red than in blue for large *b*).\n", "\n", "## Parameter estimation\n", "\n", "First, we create an instance of the log posterior function with the redmost light curve data.\n", "\n", "Next, we run the *DE* optimiser for ``de_iter`` iterations to clump the parameter vector population close to the global posterior maximum, use the *DE* population to initialise the *emcee* sampler, and run the sampler for ``mc_iter`` iterations to obtain a posterior sample." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "npop, de_iter, mc_reps, mc_iter, thin = 100, 200, 3, 500, 10\n", "lpf = LPFunction('Ks', time, fluxes[-1])" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Global optimisation: 0%| | 0/200 [00:00" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "lpf.plot_light_curve();" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "scrolled": false }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "MCMC sampling: 0%| | 0/500 [00:00" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "lpf.plot_light_curve('mc');" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Analysis: overview\n", "\n", "The MCMC chains are now stored in ``lpf.sampler.chain``. Let's first have a look into how the chain populations evolved to see if we have any problems with our setup, whether we have converged to sample the true posterior distribution, and, if so, what was the burn-in time." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "with sb.axes_style('white'):\n", " fig, axs = subplots(2,4, figsize=(13,5), sharex=True)\n", " ls, lc = ['-','--','--'], ['k', '0.5', '0.5']\n", " percs = [percentile(lpf.sampler.chain[:,:,i], [50,16,84], 0) for i in range(8)]\n", " [axs.flat[i].plot(lpf.sampler.chain[:,:,i].T, 'k', alpha=0.01) for i in range(8)]\n", " [[axs.flat[i].plot(percs[i][j], c=lc[j], ls=ls[j]) for j in range(3)] for i in range(8)]\n", " setp(axs, yticks=[], xlim=[0,mc_iter//10])\n", " fig.tight_layout()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ok, everything looks good. The 16th, 50th and 84th percentiles of the parameter vector population are stable and don't show any significant long-term trends. Now we can flatten the individual chains into one long chain ``fc`` and calculate the median parameter vector." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "fc = lpf.sampler.chain.reshape([-1,lpf.sampler.chain.shape[-1]])\n", "mp = median(fc, 0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's also plot the model and the data to see if this all makes sense. To do this, we calculate the conditional distribution of flux using the posterior samples (here, we're using a random subset of samples, although this isn't really necessary), and plot the distribution median and it's median-centred 68%, 95%, and 99.7% central posterior intervals (corresponding approximately to 1, 2, and 3$\\sigma$ intervals if the distribution is normal). " ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "flux_pr = lpf.flux_model(fc[permutation(fc.shape[0])[:1000]])\n", "flux_pc = array(percentile(flux_pr, [50, 0.15,99.85, 2.5,97.5, 16,84], 0))" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "with sb.axes_style('white'):\n", " zx1,zx2,zy1,zy2 = 0.958,0.98, 0.9892, 0.992\n", " fig, ax = subplots(1,1, figsize=(13,4))\n", " cp = sb.color_palette()\n", " ax.errorbar(lpf.times, lpf.fluxes, 10**mp[7], fmt='.', c=cp[4], alpha=0.75)\n", " [ax.fill_between(lpf.times,*flux_pc[i:i+2,:],alpha=0.2,facecolor=cp[0]) for i in range(1,6,2)]\n", " ax.plot(lpf.times, flux_pc[0], c=cp[0])\n", " setp(ax, xlim=lpf.times[[0,-1]], xlabel='Time', ylabel='Normalised flux')\n", " fig.tight_layout()\n", " \n", " az = fig.add_axes([0.075,0.18,0.20,0.46])\n", " ax.add_patch(Rectangle((zx1,zy1),zx2-zx1,zy2-zy1,fill=False,edgecolor='k',lw=1,ls='dashed'))\n", " [az.fill_between(lpf.times,*flux_pc[i:i+2,:],alpha=0.2,facecolor=cp[0]) for i in range(1,6,2)]\n", " setp(az, xlim=(zx1,zx2), ylim=(zy1,zy2), yticks=[], xticks=[])\n", " az.plot(lpf.times, flux_pc[0], c=cp[0])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We could (should) also plot the residuals, but I've left them out from the plot for clarity. The plot looks fine, and we can continue to have a look at the parameter estimates." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Analysis" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We start the analysis by making a Pandas data frame ``df``, using the ``df.describe`` to gen an overview of the estimates, and plotting the posteriors for the most interesting parameters as violin plots." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
tcprrhobq1q2logekuv
count5.0000e+035.0000e+035000.00005000.00005000.00005.0000e+035000.00005000.00005.0000e+035000.0000
mean-1.2803e-041.0000e+000.64600.49970.06523.7032e-01-3.14930.10051.5204e-010.0917
std1.4924e-041.0478e-050.05230.04940.04022.7985e-010.01820.00079.7109e-020.1448
min-7.3628e-049.9997e-010.46380.25100.00072.0254e-06-3.20750.09681.4954e-06-0.2084
25%-2.2365e-049.9999e-010.60830.46890.03521.2678e-01-3.16180.10016.8668e-02-0.0303
50%-1.3018e-041.0000e+000.64300.50350.05683.0644e-01-3.14920.10051.4198e-010.0901
75%-2.7947e-051.0000e+000.68000.53530.08615.8091e-01-3.13700.10102.2456e-010.2054
max4.1530e-041.0000e+000.88610.64930.32429.9971e-01-3.08180.10264.4236e-010.5444
\n", "
" ], "text/plain": [ " tc pr rho b q1 q2 \\\n", "count 5.0000e+03 5.0000e+03 5000.0000 5000.0000 5000.0000 5.0000e+03 \n", "mean -1.2803e-04 1.0000e+00 0.6460 0.4997 0.0652 3.7032e-01 \n", "std 1.4924e-04 1.0478e-05 0.0523 0.0494 0.0402 2.7985e-01 \n", "min -7.3628e-04 9.9997e-01 0.4638 0.2510 0.0007 2.0254e-06 \n", "25% -2.2365e-04 9.9999e-01 0.6083 0.4689 0.0352 1.2678e-01 \n", "50% -1.3018e-04 1.0000e+00 0.6430 0.5035 0.0568 3.0644e-01 \n", "75% -2.7947e-05 1.0000e+00 0.6800 0.5353 0.0861 5.8091e-01 \n", "max 4.1530e-04 1.0000e+00 0.8861 0.6493 0.3242 9.9971e-01 \n", "\n", " loge k u v \n", "count 5000.0000 5000.0000 5.0000e+03 5000.0000 \n", "mean -3.1493 0.1005 1.5204e-01 0.0917 \n", "std 0.0182 0.0007 9.7109e-02 0.1448 \n", "min -3.2075 0.0968 1.4954e-06 -0.2084 \n", "25% -3.1618 0.1001 6.8668e-02 -0.0303 \n", "50% -3.1492 0.1005 1.4198e-01 0.0901 \n", "75% -3.1370 0.1010 2.2456e-01 0.2054 \n", "max -3.0818 0.1026 4.4236e-01 0.5444 " ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pd.set_option('display.precision',4)\n", "df = pd.DataFrame(data=fc.copy(), columns=lpf.ps.names)\n", "df['k'] = sqrt(df.k2)\n", "df['u'] = 2*sqrt(df.q1)*df.q2\n", "df['v'] = sqrt(df.q1)*(1-2*df.q2)\n", "df = df.drop('k2', axis=1)\n", "df.describe()" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "with sb.axes_style('white'):\n", " fig, axs = subplots(2,3, figsize=(13,5))\n", " pars = 'tc rho b k u v'.split()\n", " [sb.violinplot(y=df[p], inner='quartile', ax=axs.flat[i]) for i,p in enumerate(pars)]\n", " [axs.flat[i].text(0.05,0.9, p, transform=axs.flat[i].transAxes) for i,p in enumerate(pars)]\n", " setp(axs, xticks=[], ylabel='')\n", " fig.tight_layout()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "While we're at it, let's plot some correlation plots. The limb darkening coefficients are correlated, and we'd also expect to see a correlation between the impact parameter and radius ratio." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "WARNING:root:Pandas support in corner is deprecated; use ArviZ directly\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "corner(df[['k', 'rho', 'b', 'q1', 'q2']]);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Calculating the parameter estimates for all the filters" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ok, now, let's do the parameter estimation for all the filters. We wouldn't be doing separate per-filter parameter estimation in real life, since it's much better use of the data to do a simultaneous joint modelling of all the data together (this is something that will be shown in a later tutorial). This will take some time..." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Global optimisation: 0%| | 0/200 [00:00\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
tcprrhobq1q2logeeskuv
count15000.00001.5000e+0415000.000015000.000015000.000015000.000015000.00000.015000.000015000.000015000.0000
mean0.00031.0000e+000.73470.40150.66900.5742-3.1235NaN0.09800.8981-0.0883
std0.00021.0235e-050.09520.12180.18380.15110.0175NaN0.00280.11810.2131
min-0.00049.9996e-010.45070.00050.26760.2228-3.1887NaN0.09060.3949-0.6377
25%0.00029.9999e-010.66480.33500.51960.4569-3.1353NaN0.09600.8185-0.2470
50%0.00031.0000e+000.73020.42150.66530.5447-3.1235NaN0.09790.8962-0.0726
75%0.00041.0000e+000.80210.48980.82220.6709-3.1115NaN0.10010.98150.0777
max0.00111.0000e+001.02090.66931.00000.9996-3.0567NaN0.10731.28170.5310
\n", "" ], "text/plain": [ " tc pr rho b q1 q2 \\\n", "count 15000.0000 1.5000e+04 15000.0000 15000.0000 15000.0000 15000.0000 \n", "mean 0.0003 1.0000e+00 0.7347 0.4015 0.6690 0.5742 \n", "std 0.0002 1.0235e-05 0.0952 0.1218 0.1838 0.1511 \n", "min -0.0004 9.9996e-01 0.4507 0.0005 0.2676 0.2228 \n", "25% 0.0002 9.9999e-01 0.6648 0.3350 0.5196 0.4569 \n", "50% 0.0003 1.0000e+00 0.7302 0.4215 0.6653 0.5447 \n", "75% 0.0004 1.0000e+00 0.8021 0.4898 0.8222 0.6709 \n", "max 0.0011 1.0000e+00 1.0209 0.6693 1.0000 0.9996 \n", "\n", " loge es k u v \n", "count 15000.0000 0.0 15000.0000 15000.0000 15000.0000 \n", "mean -3.1235 NaN 0.0980 0.8981 -0.0883 \n", "std 0.0175 NaN 0.0028 0.1181 0.2131 \n", "min -3.1887 NaN 0.0906 0.3949 -0.6377 \n", "25% -3.1353 NaN 0.0960 0.8185 -0.2470 \n", "50% -3.1235 NaN 0.0979 0.8962 -0.0726 \n", "75% -3.1115 NaN 0.1001 0.9815 0.0777 \n", "max -3.0567 NaN 0.1073 1.2817 0.5310 " ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dft.loc['u'].describe()" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "scrolled": false }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "with sb.axes_style('white'):\n", " fig, axs = subplots(2,3, figsize=(13,6), sharex=True)\n", " pars = 'tc rho u b k v'.split()\n", " for i,p in enumerate(pars):\n", " sb.violinplot(data=dft[p].unstack().T, inner='quartile', scale='width', \n", " ax=axs.flat[i], order=filter_names)\n", " axs.flat[i].text(0.95,0.9, p, transform=axs.flat[i].transAxes, ha='right')\n", " fig.tight_layout()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As it is, the posterior distributions for different filters agree well with each other. However, the uncertainty in the radius ratio estimate decreases towards redder wavelengths. This is due to the reduced limb darkening, which allows us to estimate the true geometric radius ratio more accurately.\n", "\n", "Finally, let's print the parameter estimates for each filter. We'll print the posterior medians with uncertainty estimates based on the central 68% posterior intervals. This matches the posterior mean and its 1-$\\sigma$ uncertainty if the posterior is normal (which isn't really the case for many of the posteriors here). In real life, you'd want to report separate + and - uncertainties for the asymmetric posteriors, etc." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "def ms(df,p,f):\n", " p = array(percentile(df[p][f], [50,16,84]))\n", " return p[0], abs(p[1:]-p[0]).mean()\n", "\n", "def create_row(df,f,pars):\n", " return ('{:}'.format(f)+\n", " ''.join(['{:5.4f} ± {:5.4f}'.format(*ms(dft,p,f)) for p in pars])+\n", " '')\n", "\n", "def create_table(df): \n", " pars = 'tc rho b k u v'.split()\n", " return (''+\n", " ''.join([''.format(p) for p in pars])+\n", " ''.join([create_row(df,f,pars) for f in filter_names])+\n", " '
Filter{:}
')" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
Filtertcrhobkuv
u0.0003 ± 0.00020.7302 ± 0.10030.4215 ± 0.11710.0979 ± 0.00290.8962 ± 0.1200-0.0726 ± 0.2282
g0.0001 ± 0.00020.6390 ± 0.08240.5111 ± 0.08190.1010 ± 0.00260.7428 ± 0.1651-0.0836 ± 0.3044
r-0.0001 ± 0.00020.7320 ± 0.12420.3723 ± 0.18810.0971 ± 0.00250.3637 ± 0.13840.5289 ± 0.1957
i-0.0000 ± 0.00020.7361 ± 0.09850.3749 ± 0.15050.0974 ± 0.00230.4337 ± 0.15130.2524 ± 0.3166
z-0.0001 ± 0.00020.7309 ± 0.10820.3987 ± 0.15610.0988 ± 0.00190.1232 ± 0.12220.4261 ± 0.2857
J2-0.0000 ± 0.00020.5243 ± 0.05070.5985 ± 0.04590.1011 ± 0.00110.1491 ± 0.13950.2313 ± 0.2271
H20.0001 ± 0.00020.8122 ± 0.06640.2091 ± 0.14600.0959 ± 0.00130.1000 ± 0.08630.6786 ± 0.2009
Ks-0.0001 ± 0.00010.6443 ± 0.05350.5037 ± 0.05050.1006 ± 0.00070.1379 ± 0.10190.0927 ± 0.1568
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "display(HTML(create_table(dft)))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "
© Hannu Parviainen 2014--2021
" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.9" } }, "nbformat": 4, "nbformat_minor": 1 }