diff --git a/csiborgtools/flow/__init__.py b/csiborgtools/flow/__init__.py index 53f11aa..5ad69c1 100644 --- a/csiborgtools/flow/__init__.py +++ b/csiborgtools/flow/__init__.py @@ -17,4 +17,4 @@ from .flow_model import (DataLoader, radial_velocity_los, dist2redshift, SD_PV_validation_model, SN_PV_validation_model, # noqa TF_PV_validation_model, radec_to_galactic, # noqa sample_prior, make_loss, get_model, # noqa - optimize_model_with_jackknife) # noqa + optimize_model_with_jackknife, distmodulus2dist) # noqa diff --git a/csiborgtools/flow/flow_model.py b/csiborgtools/flow/flow_model.py index e80c1d2..f011e1e 100644 --- a/csiborgtools/flow/flow_model.py +++ b/csiborgtools/flow/flow_model.py @@ -19,7 +19,7 @@ References ---------- [1] https://arxiv.org/abs/1912.09383. """ -from abc import ABC +from abc import ABC, abstractmethod from datetime import datetime from warnings import catch_warnings, simplefilter, warn @@ -35,11 +35,12 @@ from jax import numpy as jnp from jax import vmap from jax.lax import cond, scan from jax.random import PRNGKey +from numdifftools import Hessian from numpyro.infer import Predictive, util +from scipy.interpolate import interp1d from scipy.optimize import fmin_powell from sklearn.model_selection import KFold from tqdm import trange -from numdifftools import Hessian from ..params import simname2Omega_m @@ -426,17 +427,45 @@ def dist2distmodulus(dist, Omega_m): return 5 * jnp.log10(luminosity_distance) + 25 -# def distmodulus2dist(distmodulus, Omega_m): -# """ -# Copied from Supranta. Make sure this actually works. -# -# -# """ -# dL = 10 ** ((distmodulus - 25.) / 5.) -# r_hMpc = dL -# for i in range(4): -# r_hMpc = dL / (1.0 + dist2redshift(r_hMpc, Omega_m)) -# return r_hMpc +def distmodulus2dist(mu, Omega_m, ninterp=10000, zmax=0.1, mu2comoving=None, + return_interpolator=False): + """ + Convert distance modulus to comoving distance. Note that this is a costly + implementation, as it builts up the interpolator every time it is called + unless it is provided. + + Parameters + ---------- + mu : float or 1-dimensional array + Distance modulus. + Omega_m : float + Matter density parameter. + ninterp : int, optional + Number of points to interpolate the mapping from distance modulus to + comoving distance. + zmax : float, optional + Maximum redshift for the interpolation. + mu2comoving : callable, optional + Interpolator from distance modulus to comoving distance. If not + provided, it is built up every time the function is called. + return_interpolator : bool, optional + Whether to return the interpolator as well. + + Returns + ------- + float (or 1-dimensional array) and callable (optional) + """ + if mu2comoving is None: + zrange = np.linspace(1e-15, zmax, ninterp) + cosmo = FlatLambdaCDM(H0=100, Om0=Omega_m) + mu2comoving = interp1d( + cosmo.distmod(zrange).value, cosmo.comoving_distance(zrange).value, + kind="cubic") + + if return_interpolator: + return mu2comoving(mu), mu2comoving + + return mu2comoving(mu) def project_Vext(Vext_x, Vext_y, Vext_z, RA, dec): @@ -549,6 +578,29 @@ def calculate_ll_zobs(zobs, zobs_pred, sigma_v): return jnp.exp(-0.5 * (dcz / sigma_v)**2) / jnp.sqrt(2 * np.pi) / sigma_v +def stack_normal(mus, stds): + """ + Stack the normal distributions and approximate the stacked distribution + by a single Gaussian. + + Parameters + ---------- + mus : 1-dimensional array + Means of the normal distributions. + stds : 1-dimensional array + Standard deviations of the normal distributions. + + Returns + ------- + mu, std : floats + """ + if mus.ndim > 1 or stds.ndim > 1 and mus.shape != stds.shape: + raise ValueError("Shape of `mus` and `stds` must be the same and 1D.") + mu = np.mean(mus) + std = (np.sum(stds**2 + (mus - mu)**2) / len(mus))**0.5 + return mu, std + + class BaseFlowValidationModel(ABC): """ Base class for the flow validation models. @@ -556,8 +608,90 @@ class BaseFlowValidationModel(ABC): @property def ndata(self): + """ + Number of PV objects in the catalogue. + + Returns + ------- + int + """ return len(self._RA) + @abstractmethod + def predict_zobs_single(self, **kwargs): + pass + + def predict_zobs(self, samples): + """ + Predict the observed redshifts given the samples from the posterior. + + Parameters + ---------- + samples : dict of 1-dimensional arrays + Posterior samples. + + Returns + ------- + zobs_mean : 2-dimensional array of shape (ndata, nsamples) + Mean of the predicted redshifts. + zobs_std : 2-dimensional array of shape (ndata, nsamples) + Standard deviation of the predicted redshifts. + """ + keys = list(samples.keys()) + nsamples = len(samples[keys[0]]) + + zobs_mean = np.empty((self.ndata, nsamples), dtype=np.float32) + zobs_std = np.empty_like(zobs_mean) + + # JIT compile the function, it is called many times. + f = jit(self.predict_zobs_single) + + for i in trange(nsamples): + x = {key: samples[key][i] for key in keys} + if "alpha" not in keys: + x["alpha"] = 1.0 + + e_z = samples["sigma_v"][i] / SPEED_OF_LIGHT + + mu, var = f(**x) + zobs_mean[:, i] = mu + zobs_std[:, i] = (var + e_z**2)**0.5 + + return zobs_mean, zobs_std + + def summarize_zobs_pred(self, zobs_mean, zobs_pred): + """ + Summarize the predicted observed redshifts from each posterior sample + by stacking their Gaussian distribution and approximating the stacked + distribution by a single Gaussian. + + Parameters + ---------- + zobs_mean : 2-dimensional array of shape (ndata, nsamples) + Mean of the predicted redshifts. + zobs_pred : 2-dimensional array of shape (ndata, nsamples) + Predicted redshifts. + + Returns + ------- + mu : 1-dimensional array + Mean of predicted redshift, averaged over the posterior samples. + std : 1-dimensional array + Standard deviation of the predicted redshift, averaged over the + posterior samples. + """ + mu = np.empty(self.ndata, dtype=np.float32) + std = np.empty_like(mu) + + for i in range(self.ndata): + mu[i], std[i] = stack_normal(zobs_mean[i], zobs_pred[i]) + + return mu, std + + @abstractmethod + def __call__(self, **kwargs): + pass + class SD_PV_validation_model(BaseFlowValidationModel): """ @@ -625,6 +759,9 @@ class SD_PV_validation_model(BaseFlowValidationModel): # Distribution of velocity uncertainty sigma_v self._sv = dist.LogNormal(*lognorm_mean_std_to_loc_scale(150, 100)) + def predict_zobs_single(self, **kwargs): + raise NotImplementedError("This method is not implemented yet.") + def __call__(self, sample_alpha=False): """ The simple distance NumPyro PV validation model. @@ -714,11 +851,15 @@ class SN_PV_validation_model(BaseFlowValidationModel): raise ValueError("The radial step size must be constant.") dr = dr[0] - # Get the various vmapped functions + # Get the various functions, also vmapped self._f_ptilde_wo_bias = lambda mu, err: calculate_ptilde_wo_bias(mu_xrange, mu, err, r2_xrange, True) # noqa self._f_simps = lambda y: simps(y, dr) # noqa self._f_zobs = lambda beta, Vr, vpec_rad: predict_zobs(r_xrange, beta, Vr, vpec_rad, Omega_m) # noqa + self._vmap_ptilde_wo_bias = vmap(lambda mu, err: calculate_ptilde_wo_bias(mu_xrange, mu, err, r2_xrange, True)) # noqa + self._vmap_simps = vmap(lambda y: simps(y, dr)) + self._vmap_zobs = vmap(lambda beta, Vr, vpec_rad: predict_zobs(r_xrange, beta, Vr, vpec_rad, Omega_m), in_axes=(None, 0, 0)) # noqa + # Distribution of external velocity components self._Vext = dist.Uniform(-500, 500) # Distribution of velocity and density bias parameters @@ -733,6 +874,83 @@ class SN_PV_validation_model(BaseFlowValidationModel): self._beta_cal = dist.Normal(3.112, 1.0) self._e_mu = dist.LogNormal(*lognorm_mean_std_to_loc_scale(0.1, 0.05)) + self._Omega_m = Omega_m + self._r_xrange = r_xrange + + def mu(self, mag_cal, alpha_cal, beta_cal): + """ + Distance modulus of each object the given SALT2 calibration parameters. + + Parameters + ---------- + mag_cal, alpha_cal, beta_cal : floats + SALT2 calibration parameters. + + Returns + ------- + 1-dimensional array + """ + return self._mB - mag_cal + alpha_cal * self._x1 - beta_cal * self._c + + def squared_e_mu(self, alpha_cal, beta_cal, e_mu_intrinsic): + """ + Linearly-propagated squared error on the SALT2 distance modulus. + + Parameters + ---------- + alpha_cal, beta_cal, e_mu_intrinsic : floats + SALT2 calibration parameters. + + Returns + ------- + 1-dimensional array + """ + return (self._e2_mB + alpha_cal**2 * self._e2_x1 + + beta_cal**2 * self._e2_c + e_mu_intrinsic**2) + + def predict_zobs_single(self, Vext_x, Vext_y, Vext_z, alpha, beta, + e_mu_intrinsic, mag_cal, alpha_cal, beta_cal, + **kwargs): + """ + Predict the observed redshifts given the samples from the posterior. + + Parameters + ---------- + Vext_x, Vext_y, Vext_z : floats + Components of the external velocity. + alpha, beta : floats + Density and velocity bias parameters. + e_mu_intrinsic, mag_cal, alpha_cal, beta_cal : floats + Calibration parameters. + kwargs : dict + Additional arguments (for compatibility). + + Returns + ------- + zobs_mean : 1-dimensional array + Mean of the predicted redshifts. + zobs_var : 1-dimensional array + Variance of the predicted redshifts. + """ + mu = self.mu(mag_cal, alpha_cal, beta_cal) + squared_e_mu = self.squared_e_mu(alpha_cal, beta_cal, e_mu_intrinsic) + Vext_rad = project_Vext(Vext_x, Vext_y, Vext_z, self._RA, self._dec) + + # Calculate p(r) (Malmquist bias) + ptilde = self._vmap_ptilde_wo_bias(mu, squared_e_mu) + ptilde *= self._los_density**alpha + ptilde /= self._vmap_simps(ptilde).reshape(-1, 1) + + # Predicted mean z_obs + zobs_pred = self._vmap_zobs(beta, Vext_rad, self._los_velocity) + zobs_mean = self._vmap_simps(zobs_pred * ptilde) + + # Variance of the predicted z_obs + zobs_pred -= zobs_mean.reshape(-1, 1) + zobs_var = self._vmap_simps(zobs_pred**2 * ptilde) + + return zobs_mean, zobs_var + def __call__(self, sample_alpha=True, fix_calibration=False): """ The supernova NumPyro PV validation model with SALT2 calibration. @@ -777,9 +995,8 @@ class SN_PV_validation_model(BaseFlowValidationModel): Vext_rad = project_Vext(Vx, Vy, Vz, self._RA, self._dec) - mu = self._mB - mag_cal + alpha_cal * self._x1 - beta_cal * self._c - squared_e_mu = (self._e2_mB + alpha_cal**2 * self._e2_x1 - + beta_cal**2 * self._e2_c + e_mu_intrinsic**2) + mu = self.mu(mag_cal, alpha_cal, beta_cal) + squared_e_mu = self.squared_e_mu(alpha_cal, beta_cal, e_mu_intrinsic) def scan_body(ll, i): # Calculate p(r) and multiply it by the galaxy bias @@ -857,6 +1074,10 @@ class TF_PV_validation_model(BaseFlowValidationModel): self._f_simps = lambda y: simps(y, dr) # noqa self._f_zobs = lambda beta, Vr, vpec_rad: predict_zobs(r_xrange, beta, Vr, vpec_rad, Omega_m) # noqa + self._vmap_ptilde_wo_bias = vmap(lambda mu, err: calculate_ptilde_wo_bias(mu_xrange, mu, err, r2_xrange, True)) # noqa + self._vmap_simps = vmap(lambda y: simps(y, dr)) + self._vmap_zobs = vmap(lambda beta, Vr, vpec_rad: predict_zobs(r_xrange, beta, Vr, vpec_rad, Omega_m), in_axes=(None, 0, 0)) # noqa + # Distribution of external velocity components self._Vext = dist.Uniform(-1000, 1000) # Distribution of velocity and density bias parameters @@ -870,6 +1091,83 @@ class TF_PV_validation_model(BaseFlowValidationModel): self._b = dist.Normal(-5.95, 0.1) self._e_mu = dist.LogNormal(*lognorm_mean_std_to_loc_scale(0.3, 0.1)) # noqa + self._Omega_m = Omega_m + self._r_xrange = r_xrange + + def mu(self, a, b): + """ + Distance modulus of each object the given Tully-Fisher calibration. + + Parameters + ---------- + a, b : floats + Tully-Fisher calibration parameters. + + Returns + ------- + 1-dimensional array + """ + + return self._mag - (a + b * self._eta) + + def squared_e_mu(self, b, e_mu_intrinsic): + """ + Squared error on the Tully-Fisher distance modulus. + + Parameters + ---------- + b, e_mu_intrinsic : floats + Tully-Fisher calibration parameters. + + Returns + ------- + 1-dimensional array + """ + return (self._e2_mag + b**2 * self._e2_eta + e_mu_intrinsic**2) + + def predict_zobs_single(self, Vext_x, Vext_y, Vext_z, alpha, beta, + e_mu_intrinsic, a, b, **kwargs): + """ + Predict the observed redshifts given the samples from the posterior. + + Parameters + ---------- + Vext_x, Vext_y, Vext_z : floats + Components of the external velocity. + alpha, beta : floats + Density and velocity bias parameters. + e_mu_intrinsic, a, b : floats + Calibration parameters. + kwargs : dict + Additional arguments (for compatibility). + + Returns + ------- + zobs_mean : 1-dimensional array + Mean of the predicted redshifts. + zobs_var : 1-dimensional array + Variance of the predicted redshifts. + """ + mu = self.mu(a, b) + squared_e_mu = self.squared_e_mu(b, e_mu_intrinsic) + + Vext_rad = project_Vext(Vext_x, Vext_y, Vext_z, self._RA, self._dec) + + # Calculate p(r) (Malmquist bias) + ptilde = self._vmap_ptilde_wo_bias(mu, squared_e_mu) + ptilde *= self._los_density**alpha + ptilde /= self._vmap_simps(ptilde).reshape(-1, 1) + + # Predicted mean z_obs + zobs_pred = self._vmap_zobs(beta, Vext_rad, self._los_velocity) + zobs_mean = self._vmap_simps(zobs_pred * ptilde) + + # Variance of the predicted z_obs + zobs_pred -= zobs_mean.reshape(-1, 1) + zobs_var = self._vmap_simps(zobs_pred**2 * ptilde) + + return zobs_mean, zobs_var + def __call__(self, sample_alpha=True): """ The Tully-Fisher NumPyro PV validation model. @@ -893,9 +1191,8 @@ class TF_PV_validation_model(BaseFlowValidationModel): Vext_rad = project_Vext(Vx, Vy, Vz, self._RA, self._dec) - mu = self._mag - (a + b * self._eta) - squared_e_mu = (self._e2_mag + b**2 * self._e2_eta - + e_mu_intrinsic**2) + mu = self.mu(a, b) + squared_e_mu = self.squared_e_mu(b, e_mu_intrinsic) def scan_body(ll, i): # Calculate p(r) and multiply it by the galaxy bias diff --git a/notebooks/flow_calibration.ipynb b/notebooks/flow_calibration.ipynb index db6f6c6..6937be0 100644 --- a/notebooks/flow_calibration.ipynb +++ b/notebooks/flow_calibration.ipynb @@ -132,17 +132,35 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 715, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "16:37:06: reading the catalogue.\n", + "16:37:06: reading the interpolated field.\n", + "16:37:07: calculating the radial velocity.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/mnt/users/rstiskalek/csiborgtools/csiborgtools/flow/flow_model.py:112: UserWarning: The number of radial steps is even. Skipping the first step at 0.0 because Simpson's rule requires an odd number of steps.\n", + " warn(f\"The number of radial steps is even. Skipping the first \"\n" + ] + } + ], "source": [ "fpath_data = \"/mnt/extraspace/rstiskalek/catalogs/PV_compilation_Supranta2019.hdf5\"\n", "# fpath_data = \"/mnt/extraspace/rstiskalek/catalogs/A2.h5\"\n", "\n", "simname = \"Carrick2015\"\n", - "catalogue = \"LOSS\"\n", + "catalogue = \"2MTF\"\n", "loader = csiborgtools.flow.DataLoader(simname, 0, catalogue, fpath_data, paths, ksmooth=0)\n", - "get_model_kwargs = {\"zcmb_max\": 0.06}" + "get_model_kwargs = {\"zcmb_max\": 0.07}" ] }, { @@ -154,30 +172,46 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 716, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Selected 1248/1248 galaxies.\n" + ] + } + ], "source": [ "model = csiborgtools.flow.get_model(loader, **get_model_kwargs)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 717, "metadata": {}, "outputs": [], "source": [ "kernel = NUTS(model, init_strategy=init_to_median(num_samples=100))\n", - "mcmc = MCMC(kernel, num_warmup=250, num_samples=2500)\n", + "mcmc = MCMC(kernel, num_warmup=250, num_samples=500)\n", "\n", "rng_key = jax.random.PRNGKey(5)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 718, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "sample: 100%|██████████| 750/750 [02:44<00:00, 4.57it/s, 7 steps of size 4.96e-01. acc. prob=0.91] \n" + ] + } + ], "source": [ "model_kwargs = {\"sample_alpha\": True}\n", "mcmc.run(rng_key, **model_kwargs)" @@ -185,20 +219,51 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 719, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " mean std median 5.0% 95.0% n_eff r_hat\n", + " Vext_x -106.65 16.42 -107.21 -131.51 -76.54 730.09 1.00\n", + " Vext_y -103.97 18.51 -103.36 -135.46 -74.95 564.72 1.00\n", + " Vext_z -114.45 18.16 -115.19 -145.14 -86.94 398.98 1.00\n", + " a -22.28 0.02 -22.28 -22.31 -22.25 451.84 1.00\n", + " alpha 1.53 0.08 1.53 1.40 1.64 625.30 1.00\n", + " b -6.28 0.09 -6.28 -6.42 -6.12 685.29 1.00\n", + " beta 0.40 0.03 0.40 0.37 0.45 607.03 1.00\n", + " e_mu_intrinsic 0.41 0.01 0.41 0.39 0.42 469.01 1.00\n", + " sigma_v 116.06 11.30 115.85 99.31 134.60 715.52 1.00\n", + "\n", + "Number of divergences: 0\n" + ] + } + ], "source": [ "mcmc.print_summary()\n", "samples = mcmc.get_samples(group_by_chain=False)\n", - "print(csiborgtools.numpyro_gof(model, mcmc, len(loader.cat), model_kwargs))" + "# print(csiborgtools.numpyro_gof(model, mcmc, len(loader.cat), model_kwargs))" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 227, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "|V| = 292.9063720703125 +- 53.499855041503906\n", + "l = 254.50001033175045 +- 14.125642497928322\n", + "b = 19.794461051654427 +- 10.697396482974687\n", + "beta = 0.31970617175102234 +- 0.07021637260913849\n" + ] + } + ], "source": [ "Vmag = np.sqrt(samples[\"Vext_x\"]**2 + samples[\"Vext_y\"]**2 + samples[\"Vext_z\"]**2)\n", "\n", @@ -215,9 +280,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 228, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "if \"alpha\" in samples:\n", " data = np.vstack([samples[\"alpha\"], samples[\"beta\"], l, b, Vmag]).T\n", @@ -245,11 +321,40 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Reading Foundation fitted to Carrick2015 with ksmooth = 0.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "BIC = 1852.867188 +- 0.000000\n", + "AIC = 1824.664429 +- 0.000000\n", + "logZ = -897.537476 +- 0.000000\n", + "chi2 = 0.000000 +- 0.000000\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "data, names, gof = read_samples(\"2MTF\", \"Carrick2015\", 0)\n", + "data, names, gof = read_samples(\"Foundation\", \"Carrick2015\", 0)\n", "\n", "fig = corner.corner(data, labels=names_to_latex(names, True), show_titles=True,\n", " title_fmt=\".3f\", title_kwargs={\"fontsize\": 12}, smooth=1)" diff --git a/notebooks/flow_calibration.py b/notebooks/flow_calibration.py index 0c81d2c..6af337a 100644 --- a/notebooks/flow_calibration.py +++ b/notebooks/flow_calibration.py @@ -30,7 +30,7 @@ def read_samples(catalogue, simname, ksmooth, include_calibration=False, nsims = paths.get_ics(simname) Vx, Vy, Vz, beta, sigma_v, alpha = [], [], [], [], [], [] - BIC, AIC, logZ = [], [], [] + BIC, AIC, logZ, chi2 = [], [], [], [] if catalogue in ["LOSS", "Foundation", "Pantheon+"]: alpha_cal, beta_cal, mag_cal, e_mu_intrinsic = [], [], [], [] @@ -69,6 +69,10 @@ def read_samples(catalogue, simname, ksmooth, include_calibration=False, BIC.append(f[f"sim_{nsim}/BIC"][...]) AIC.append(f[f"sim_{nsim}/AIC"][...]) logZ.append(f[f"sim_{nsim}/logZ"][...]) + try: + chi2.append(f[f"sim_{nsim}/chi2"][...]) + except KeyError: + chi2.append([0.]) if catalogue in ["LOSS", "Foundation", "Pantheon+"]: alpha_cal.append(f[f"sim_{nsim}/alpha_cal"][:]) @@ -84,7 +88,7 @@ def read_samples(catalogue, simname, ksmooth, include_calibration=False, Vx, Vy, Vz, alpha, beta, sigma_v = np.hstack(Vx), np.hstack(Vy), np.hstack(Vz), np.hstack(alpha), np.hstack(beta), np.hstack(sigma_v) # noqa - gof = np.hstack(BIC), np.hstack(AIC), np.hstack(logZ) + gof = np.hstack(BIC), np.hstack(AIC), np.hstack(logZ), np.hstack(chi2) if catalogue in ["LOSS", "Foundation", "Pantheon+"]: alpha_cal, beta_cal, mag_cal, e_mu_intrinsic = np.hstack(alpha_cal), np.hstack(beta_cal), np.hstack(mag_cal), np.hstack(e_mu_intrinsic) # noqa @@ -116,6 +120,7 @@ def read_samples(catalogue, simname, ksmooth, include_calibration=False, print("BIC = {:4f} +- {:4f}".format(np.mean(gof[0]), np.std(gof[0]))) print("AIC = {:4f} +- {:4f}".format(np.mean(gof[1]), np.std(gof[1]))) print("logZ = {:4f} +- {:4f}".format(np.mean(gof[2]), np.std(gof[2]))) + print("chi2 = {:4f} +- {:4f}".format(np.mean(gof[3]), np.std(gof[3]))) data = np.vstack(data).T diff --git a/scripts/flow_validation.py b/scripts/flow_validation.py index f216ef8..d1a7664 100644 --- a/scripts/flow_validation.py +++ b/scripts/flow_validation.py @@ -104,11 +104,19 @@ def run_model(model, nsteps, nburn, nchains, nsim, dump_folder, samples = mcmc.get_samples() thinned_samples = csiborgtools.thin_samples_by_acl(samples) + # Calculate the chi2 + keys = list(thinned_samples.keys()) + nsamples = len(thinned_samples[keys[0]]) + zobs_mean, zobs_std = model.predict_zobs(thinned_samples) + nu = model.ndata - len(keys) + chi2 = [np.sum((zobs_mean[:, i] - model._z_obs)**2 / zobs_std[:, i]**2) / nu # noqa + for i in range(nsamples)] + gof = csiborgtools.numpyro_gof(model, mcmc, model_kwargs) # Save the samples to the temporary folder. fname = join(dump_folder, f"samples_{nsim}.npz") - np.savez(fname, **thinned_samples, **gof) + np.savez(fname, **thinned_samples, **gof, chi2=chi2) def combine_from_simulations(catalogue_name, simname, nsims, outfolder, diff --git a/scripts/flow_validation.sh b/scripts/flow_validation.sh index 3275f43..72c09be 100755 --- a/scripts/flow_validation.sh +++ b/scripts/flow_validation.sh @@ -1,5 +1,5 @@ memory=4 -on_login=0 +on_login=1 nthreads=${1} ksmooth=${2} @@ -7,8 +7,8 @@ queue="berg" env="/mnt/users/rstiskalek/csiborgtools/venv_csiborg/bin/python" file="flow_validation.py" -catalogue="Pantheon+" -simname="csiborg2_main" +catalogue="LOSS" +simname="Carrick2015" pythoncm="$env $file --catalogue $catalogue --simname $simname --ksmooth $ksmooth"