diff --git a/.gitignore b/.gitignore index ddd329e6..7f1258d0 100644 --- a/.gitignore +++ b/.gitignore @@ -96,4 +96,13 @@ tests/cli_test/* docs/autoapi/* docs/_build/* -docs \ No newline at end of file +docs +tests/cli_test_parallel_kfold/temp/be_te_fcon1000.pkl +tests/cli_test_parallel_kfold/temp/be_tr_fcon1000.pkl +tests/cli_test_parallel_kfold/temp/fcon1000 +tests/cli_test_parallel_kfold/temp/X_te_fcon1000.pkl +tests/cli_test_parallel_kfold/temp/X_tr_fcon1000.pkl +tests/cli_test_parallel_kfold/temp/X_var_te_fcon1000.pkl +tests/cli_test_parallel_kfold/temp/X_var_tr_fcon1000.pkl +tests/cli_test_parallel_kfold/temp/Y_te_fcon1000.pkl +tests/cli_test_parallel_kfold/temp/Y_tr_fcon1000.pkl diff --git a/pcntoolkit/model/hbr.py b/pcntoolkit/model/hbr.py index 45b6fbe6..f1fc5d98 100644 --- a/pcntoolkit/model/hbr.py +++ b/pcntoolkit/model/hbr.py @@ -11,76 +11,22 @@ from __future__ import division from collections import OrderedDict -from ast import Param -from tkinter.font import names - import numpy as np import pymc as pm import pytensor import arviz as az import xarray - from itertools import product from functools import reduce - -from pymc import Metropolis, NUTS, Slice, HamiltonianMC from scipy import stats -import bspline -from bspline import splinelab from util.utils import create_poly_basis from util.utils import expand_all from pcntoolkit.util.utils import cartesian_product +from pcntoolkit.util.bspline import BSplineBasis from pcntoolkit.model.SHASH import * -def bspline_fit(X, order, nknots): - """ - Fit a B-spline to the data - :param X: [N×P] array of clinical covariates - :param order: order of the spline - :param nknots: number of knots - :return: a list of B-spline basis functions - """ - feature_num = X.shape[1] - bsp_basis = [] - - for i in range(feature_num): - minx = np.min(X[:, i]) - maxx = np.max(X[:, i]) - delta = maxx - minx - # Expand range by 20% (10% on both sides) - splinemin = minx - 0.1 * delta - splinemax = maxx + 0.1 * delta - knots = np.linspace(splinemin, splinemax, nknots) - k = splinelab.augknt(knots, order) - bsp_basis.append(bspline.Bspline(k, order)) - - return bsp_basis - - -def bspline_transform(X, bsp_basis): - """ - Transform the data using the B-spline basis functions - :param X: [N×P] array of clinical covariates - :param bsp_basis: a list of B-spline basis functions - :return: a [N×(P×nknots)] array of transformed data - """ - - if type(bsp_basis) != list: - temp = [] - temp.append(bsp_basis) - bsp_basis = temp - - feature_num = len(bsp_basis) - X_transformed = [] - for f in range(feature_num): - X_transformed.append(np.array([bsp_basis[f](i) for i in X[:, f]])) - X_transformed = np.concatenate(X_transformed, axis=1) - - return X_transformed - - def create_poly_basis(X, order): """ Create a polynomial basis expansion of the specified order @@ -99,7 +45,7 @@ def create_poly_basis(X, order): return Phi -def from_posterior(param, samples, shape, distribution=None, half=False, freedom=1): +def from_posterior(param, samples, shape, distribution=None, dims=None, half=False, freedom=1): """ Create a PyMC distribution from posterior samples @@ -107,10 +53,13 @@ def from_posterior(param, samples, shape, distribution=None, half=False, freedo :param samples: samples from the posterior :param shape: shape of the parameter :param distribution: distribution to use for the parameter + :param dims: dims of the parameter :param half: if true, the distribution is assumed to be defined on the positive real line :param freedom: freedom parameter for the distribution :return: a PyMC distribution """ + if dims == []: + dims = None if distribution is None: smin, smax = np.min(samples), np.max(samples) width = smax - smin @@ -126,25 +75,25 @@ def from_posterior(param, samples, shape, distribution=None, half=False, freedo if shape is None: return pm.distributions.Interpolated(param, x, y) else: - return pm.distributions.Interpolated(param, x, y, shape=shape) + return pm.distributions.Interpolated(param, x, y, shape=shape, dims=dims) elif distribution == "normal": temp = stats.norm.fit(samples) if shape is None: return pm.Normal(param, mu=temp[0], sigma=freedom * temp[1]) else: - return pm.Normal(param, mu=temp[0], sigma=freedom * temp[1], shape=shape) + return pm.Normal(param, mu=temp[0], sigma=freedom * temp[1], shape=shape, dims=dims) elif distribution == "hnormal": temp = stats.halfnorm.fit(samples) if shape is None: return pm.HalfNormal(param, sigma=freedom * temp[1]) else: - return pm.HalfNormal(param, sigma=freedom * temp[1], shape=shape) + return pm.HalfNormal(param, sigma=freedom * temp[1], shape=shape, dims=dims) elif distribution == "hcauchy": temp = stats.halfcauchy.fit(samples) if shape is None: return pm.HalfCauchy(param, freedom * temp[1]) else: - return pm.HalfCauchy(param, freedom * temp[1], shape=shape) + return pm.HalfCauchy(param, freedom * temp[1], shape=shape, dims=dims) elif distribution == "uniform": upper_bound = np.percentile(samples, 95) lower_bound = np.percentile(samples, 5) @@ -159,6 +108,7 @@ def from_posterior(param, samples, shape, distribution=None, half=False, freedo lower=lower_bound - freedom * r, upper=upper_bound + freedom * r, shape=shape, + dims=dims, ) elif distribution == "huniform": upper_bound = np.percentile(samples, 95) @@ -168,7 +118,7 @@ def from_posterior(param, samples, shape, distribution=None, half=False, freedo return pm.Uniform(param, lower=0, upper=upper_bound + freedom * r) else: return pm.Uniform( - param, lower=0, upper=upper_bound + freedom * r, shape=shape + param, lower=0, upper=upper_bound + freedom * r, shape=shape, dims=dims ) elif distribution == "gamma": @@ -183,6 +133,7 @@ def from_posterior(param, samples, shape, distribution=None, half=False, freedo alpha=freedom * alpha_fit, beta=freedom / invbeta_fit, shape=shape, + dims=dims, ) elif distribution == "igamma": @@ -193,7 +144,7 @@ def from_posterior(param, samples, shape, distribution=None, half=False, freedo ) else: return pm.InverseGamma( - param, alpha=freedom * alpha_fit, beta=freedom * beta_fit, shape=shape + param, alpha=freedom * alpha_fit, beta=freedom * beta_fit, shape=shape, dims=dims ) @@ -392,20 +343,29 @@ def get_modeler(self): """ return hbr - def transform_X(self, X): + def transform_X(self, X, adapt=False): """ Transform the covariates according to the model type :param X: N-by-P input matrix of P features for N subjects :return: transformed covariates + :adapt: Set to true when range adaptation for bspline is needed (for example in the + transfer scenario) """ if self.model_type == "polynomial": Phi = create_poly_basis(X, self.configs["order"]) elif self.model_type == "bspline": if self.bsp is None: - self.bsp = bspline_fit( - X, self.configs["order"], self.configs["nknots"]) - bspline = bspline_transform(X, self.bsp) + self.bsp = BSplineBasis(order=self.configs["order"], + nknots=self.configs["nknots"]) + self.bsp.fit(X) + #self.bsp = bspline_fit( + # X, self.configs["order"], self.configs["nknots"]) + elif adapt: + self.bsp.adapt(X) + + bspline = self.bsp.transform(X) + #bspline = bspline_transform(X, self.bsp) Phi = np.concatenate((X, bspline), axis=1) else: Phi = X @@ -447,6 +407,10 @@ def estimate(self, X, y, batch_effects, **kwargs): :return: idata. The results are also stored in the instance variable `self.idata`. """ X, y, batch_effects = expand_all(X, y, batch_effects) + + self.batch_effects_num = batch_effects.shape[1] + self.batch_effects_size = [len(np.unique(batch_effects[:,i])) for i in range(self.batch_effects_num)] + X = self.transform_X(X) modeler = self.get_modeler() if hasattr(self, 'idata'): @@ -538,7 +502,7 @@ def predict( trace=self.idata, extend_inferencedata=True, progressbar=True, - var_names=var_names, + var_names=var_names ) pred_mean = self.idata.posterior_predictive["y_like"].to_numpy().mean( axis=(0, 1)) @@ -547,12 +511,12 @@ def predict( return pred_mean, pred_var - def estimate_on_new_site(self, X, y, batch_effects): + def transfer(self, X, y, batch_effects): + """ - Estimate the model parameters using the provided data for a new site. - - This function transforms the input data, then uses the modeler to estimate the model parameters. - The results are stored in the instance variable `idata`. + This function is used to transfer a reference model (i.e. the source model that is estimated on source big datasets) + to data from new sites (i.e. target data). It uses the posterior + of the reference model as a prior for the target model. :param X: Covariates. This is the input data for the model. :param y: Outputs. This is the target data for the model. @@ -560,7 +524,12 @@ def estimate_on_new_site(self, X, y, batch_effects): :return: An inferencedata object containing samples from the posterior distribution. """ X, y, batch_effects = expand_all(X, y, batch_effects) - X = self.transform_X(X) + + self.batch_effects_num = batch_effects.shape[1] + self.batch_effects_size = [len(np.unique(batch_effects[:,i])) for i in range(self.batch_effects_num)] + + + X = self.transform_X(X, adapt=True) modeler = self.get_modeler() with modeler(X, y, batch_effects, self.configs, idata=self.idata) as m: self.idata = pm.sample( @@ -573,34 +542,30 @@ def estimate_on_new_site(self, X, y, batch_effects): cores=self.configs["cores"], nuts_sampler=self.configs["nuts_sampler"], ) - return self.idata - - def predict_on_new_site(self, X, batch_effects): - """ - Make predictions from the model for a new site. - - This function transforms the input data, then uses the modeler to make predictions. - The results are stored in the instance variable `idata`. + + self.vars_to_sample = ['y_like'] + + # This part is for data privacy + if self.configs['remove_datapoints_from_posterior']: + chain = self.idata.posterior.coords['chain'].data + draw = self.idata.posterior.coords['draw'].data + for j in self.idata.posterior.variables.mapping.keys(): + if j.endswith('_samples'): + dummy_array = xarray.DataArray(data=np.zeros((len(chain), len(draw), 1)), coords={ + 'chain': chain, 'draw': draw, 'empty': np.array([0])}, name=j) + self.idata.posterior[j] = dummy_array + self.vars_to_sample.append(j) - :param X: Covariates. This is the input data for the model. - :param batch_effects: Batch effects corresponding to X. This represents the batch effects to be considered in the model. - :return: A tuple containing the mean and variance of the predictions. The results are also stored in the instance variable `self.idata`. - """ - X, batch_effects = expand_all(X, batch_effects) - samples = self.configs["n_samples"] - y = np.zeros([X.shape[0], 1]) - X = self.transform_X(X) - modeler = self.get_modeler() - with modeler(X, y, batch_effects, self.configs, idata=self.idata): - self.idata = pm.sample_posterior_predictive( - self.idata, extend_inferencedata=True, progressbar=True, var_names=self.vars_to_sample - ) - pred_mean = self.idata.posterior_predictive["y_like"].mean(axis=(0, 1)) - pred_var = self.idata.posterior_predictive["y_like"].var(axis=(0, 1)) + # zero-out all data + for i in self.idata.constant_data.data_vars: + self.idata.constant_data[i] *= 0 + for i in self.idata.observed_data.data_vars: + self.idata.observed_data[i] *= 0 + + return self.idata - return pred_mean, pred_var - def generate(self, X, batch_effects, samples): + def generate(self, X, batch_effects, samples, batch_effects_maps, var_names=None): """ Generate samples from the posterior predictive distribution. @@ -612,18 +577,41 @@ def generate(self, X, batch_effects, samples): :return: A tuple containing the expanded and repeated X, batch_effects, and the generated samples. """ X, batch_effects = expand_all(X, batch_effects) - + y = np.zeros([X.shape[0], 1]) - X = self.transform_X(X) + X_transformed = self.transform_X(X) modeler = self.get_modeler() - with modeler(X, y, batch_effects, self.configs): - ppc = pm.sample_posterior_predictive(self.idata, progressbar=True) - generated_samples = np.reshape( - ppc.posterior_predictive["y_like"].squeeze().T, [ - X.shape[0] * samples, 1] - ) - X = np.repeat(X, samples) + + # See if a list of var_names is provided, set to self.vars_to_sample otherwise + if (var_names is None) or (var_names == ['y_like']): + var_names = self.vars_to_sample + + # Need to delete self.idata.posterior_predictive, otherwise, if it exists, it will not be overwritten + if hasattr(self.idata, 'posterior_predictive'): + del self.idata.posterior_predictive + + with modeler(X_transformed, y, batch_effects, self.configs): + # For each batch effect dim + for i in range(batch_effects.shape[1]): + # Make a map that maps batch effect values to their index + valmap = batch_effects_maps[i] + # Compute those indices for the test data + indices = list(map(lambda x: valmap[x], batch_effects[:, i])) + # Those indices need to be used by the model + pm.set_data({f"batch_effect_{i}_data": indices}) + + self.idata = pm.sample_posterior_predictive( + trace=self.idata, + extend_inferencedata=True, + progressbar=True, + var_names=var_names + ) + + generated_samples = np.reshape(self.idata.posterior_predictive["y_like"].to_numpy()[0,0:samples,:].T, + [X.shape[0] * samples, 1]) + + X = np.repeat(X, samples, axis=0) if len(X.shape) == 1: X = np.expand_dims(X, axis=1) batch_effects = np.repeat(batch_effects, samples, axis=0) @@ -631,6 +619,7 @@ def generate(self, X, batch_effects, samples): batch_effects = np.expand_dims(batch_effects, axis=1) return X, batch_effects, generated_samples + def sample_prior_predictive(self, X, batch_effects, samples, y=None, idata=None): """ Sample from the prior predictive distribution. @@ -671,35 +660,39 @@ def get_model(self, X, y, batch_effects): idata = self.idata if hasattr(self, "idata") else None return modeler(X, y, batch_effects, self.configs, idata=idata) - def create_dummy_inputs(self, covariate_ranges=[[0.1, 0.9, 0.01]]): + def create_dummy_inputs(self, X, step_size=0.05): """ - Create dummy inputs for the model. + Create dummy inputs for the model based on the input covariates. - This function generates a Cartesian product of the provided covariate ranges and repeats it for each batch effect. + This function generates a Cartesian product of the covariate ranges determined from the input X + (min and max values of each covariate). It repeats this for each batch effect. It also generates a Cartesian product of the batch effect indices and repeats it for each input sample. - :param covariate_ranges: List of lists, where each inner list represents the range and step size of a covariate. Default is [[0.1, 0.9, 0.01]]. + :param X: 2D numpy array, where rows are samples and columns are covariates. + :param step_size: Step size for generating ranges for each covariate. Default is 0.05. :return: A tuple containing the dummy input data and the dummy batch effects. """ arrays = [] - for i in range(len(covariate_ranges)): - arrays.append( - np.arange( - covariate_ranges[i][0], - covariate_ranges[i][1], - covariate_ranges[i][2], - ) - ) - X = cartesian_product(arrays) + for i in range(X.shape[1]): + cov_min = np.min(X[:, i]) + cov_max = np.max(X[:, i]) + arrays.append(np.arange(cov_min, cov_max + step_size, step_size)) + + X_dummy = cartesian_product(arrays) X_dummy = np.concatenate( - [X for i in range(np.prod(self.batch_effects_size))]) + [X_dummy for _ in range(np.prod(self.batch_effects_size))] + ) + arrays = [] for i in range(self.batch_effects_num): arrays.append(np.arange(0, self.batch_effects_size[i])) + batch_effects = cartesian_product(arrays) - batch_effects_dummy = np.repeat(batch_effects, X.shape[0], axis=0) + batch_effects_dummy = np.repeat(batch_effects, X_dummy.shape[0] // np.prod(self.batch_effects_size), axis=0) + return X_dummy, batch_effects_dummy + def Rhats(self, var_names=None, thin=1, resolution=100): """ Get Rhat of posterior samples as function of sampling iteration. @@ -796,11 +789,18 @@ def get_new_dim_size(tup): new_shape = None else: new_shape = new_shape[:-1] + + dims = [] + if self.has_random_effect: + dims = dims + pb.batch_effect_dim_names + if self.name.startswith("slope") or self.name.startswith("offset_slope"): + dims = dims + ["basis_functions"] self.dist = from_posterior( param=self.name, samples=samples.to_numpy(), shape=new_shape, distribution=dist, + dims=dims, freedom=pb.configs["freedom"], ) @@ -1147,7 +1147,8 @@ def get_design_matrix(X, nm, basis="linear"): :param basis: String representing the basis to use. Default is "linear". """ if basis == "bspline": - Phi = bspline_transform(X, nm.hbr.bsp) + Phi = nm.hbr.bsp.transform(X) + #Phi = bspline_transform(X, nm.hbr.bsp) elif basis == "polynomial": Phi = create_poly_basis(X, 3) else: diff --git a/pcntoolkit/normative.py b/pcntoolkit/normative.py index af3b77e5..3b0fdc47 100755 --- a/pcntoolkit/normative.py +++ b/pcntoolkit/normative.py @@ -676,19 +676,14 @@ def fit(covfile, respfile, **kwargs): if len(X.shape) == 1: X = X[:, np.newaxis] - # find and remove bad variables from the response variables - # note: the covariates are assumed to have already been checked - nz = np.where(np.bitwise_and(np.isfinite(Y).any(axis=0), - np.var(Y, axis=0) != 0))[0] - scaler_resp = [] scaler_cov = [] mean_resp = [] # this is just for computing MSLL std_resp = [] # this is just for computing MSLL # standardize responses and covariates, ignoring invalid entries - mY = np.mean(Y[:, nz], axis=0) - sY = np.std(Y[:, nz], axis=0) + mY = np.mean(Y, axis=0) + sY = np.std(Y, axis=0) mean_resp.append(mY) std_resp.append(sY) @@ -702,27 +697,26 @@ def fit(covfile, respfile, **kwargs): if outscaler in ['standardize', 'minmax', 'robminmax']: Yz = np.zeros_like(Y) Y_scaler = scaler(outscaler) - Yz[:, nz] = Y_scaler.fit_transform(Y[:, nz]) + Yz= Y_scaler.fit_transform(Y) scaler_resp.append(Y_scaler) else: Yz = Y # estimate the models for all subjects - for i in range(0, len(nz)): - print("Estimating model ", i+1, "of", len(nz)) - nm = norm_init(Xz, Yz[:, nz[i]], alg=alg, **kwargs) - nm = nm.estimate(Xz, Yz[:, nz[i]], **kwargs) + for i in range(Y.shape[1]): + print("Estimating model ", i+1, "of", Y.shape[1]) + nm = norm_init(Xz, Yz[:, i], alg=alg, **kwargs) + nm = nm.estimate(Xz, Yz[:, i], **kwargs) if savemodel: - nm.save('Models/NM_' + str(0) + '_' + str(nz[i]) + outputsuffix + + nm.save('Models/NM_' + str(0) + '_' + str(i) + outputsuffix + '.pkl') if savemodel: print('Saving model meta-data...') v = get_package_versions() with open('Models/meta_data.md', 'wb') as file: - pickle.dump({'valid_voxels': nz, - 'mean_resp': mean_resp, 'std_resp': std_resp, + pickle.dump({'mean_resp': mean_resp, 'std_resp': std_resp, 'scaler_cov': scaler_cov, 'scaler_resp': scaler_resp, 'regressor': alg, 'inscaler': inscaler, 'outscaler': outscaler, 'versions': v}, @@ -752,7 +746,7 @@ def predict(covfile, respfile, maskfile=None, **kwargs): automatically decided. :param outputsuffix: Text string to add to the output filenames :param batch_size: batch size (for use with normative_parallel) - :param job_id: batch id + :param job_id: batch id, 'None' when non-parallel module is used. :param fold: which cross-validation fold to use (default = 0) :param fold: list of model IDs to predict (if not specified all are computed) :param return_y: return the (transformed) response variable (default = False) @@ -773,8 +767,8 @@ def predict(covfile, respfile, maskfile=None, **kwargs): inputsuffix = kwargs.pop('inputsuffix', 'estimate') inputsuffix = "_" + inputsuffix.replace("_", "") alg = kwargs.pop('alg') - fold = kwargs.pop('fold', 0) models = kwargs.pop('models', None) + fold = kwargs.pop('fold', 0) return_y = kwargs.pop('return_y', False) if alg == 'gpr': @@ -805,7 +799,14 @@ def predict(covfile, respfile, maskfile=None, **kwargs): if batch_size is not None: batch_size = int(batch_size) + + if job_id is not None: job_id = int(job_id) - 1 + parallel = True + else: + parallel = False + job_id = 0 + # load data print("Loading data ...") @@ -821,8 +822,8 @@ def predict(covfile, respfile, maskfile=None, **kwargs): if models is not None: feature_num = len(models) else: - feature_num = len(glob.glob(os.path.join(model_path, 'NM_' + str(fold) + - '_*' + inputsuffix + '.pkl'))) + feature_num = len(glob.glob(os.path.join(model_path, 'NM_' + str(fold) + '_' + + '*' + inputsuffix + '.pkl'))) models = range(feature_num) Yhat = np.zeros([sample_num, feature_num]) @@ -830,16 +831,15 @@ def predict(covfile, respfile, maskfile=None, **kwargs): Z = np.zeros([sample_num, feature_num]) if inscaler in ['standardize', 'minmax', 'robminmax']: - Xz = scaler_cov[fold].transform(X) + Xz = scaler_cov[job_id].transform(X) else: Xz = X if respfile is not None: if outscaler in ['standardize', 'minmax', 'robminmax']: - Yz = scaler_resp[fold].transform(Y) + Yz = scaler_resp[job_id].transform(Y) else: Yz = Y - # estimate the models for all variabels for i, m in enumerate(models): print("Prediction by model ", i+1, "of", feature_num) nm = norm_init(Xz) @@ -847,18 +847,18 @@ def predict(covfile, respfile, maskfile=None, **kwargs): str(m) + inputsuffix + '.pkl')) if (alg != 'hbr' or nm.configs['transferred'] == False): yhat, s2 = nm.predict(Xz, **kwargs) - else: + else: # only for hbr and in the transfer scenario tsbefile = kwargs.get('tsbefile') batch_effects_test = fileio.load(tsbefile) yhat, s2 = nm.predict_on_new_sites(Xz, batch_effects_test) if outscaler == 'standardize': - Yhat[:, i] = scaler_resp[fold].inverse_transform(yhat, index=i) - S2[:, i] = s2.squeeze() * sY[fold][i]**2 + Yhat[:, i] = scaler_resp[job_id].inverse_transform(yhat, index=i) + S2[:, i] = s2.squeeze() * scaler_resp[job_id].s[i]**2 elif outscaler in ['minmax', 'robminmax']: - Yhat[:, i] = scaler_resp[fold].inverse_transform(yhat, index=i) - S2[:, i] = s2 * (scaler_resp[fold].max[i] - - scaler_resp[fold].min[i])**2 + Yhat[:, i] = scaler_resp[job_id].inverse_transform(yhat, index=i) + S2[:, i] = s2 * (scaler_resp[job_id].max[i] - + scaler_resp[job_id].min[i])**2 else: Yhat[:, i] = yhat.squeeze() S2[:, i] = s2.squeeze() @@ -866,7 +866,9 @@ def predict(covfile, respfile, maskfile=None, **kwargs): if alg == 'hbr': # Z scores for HBR must be computed independently for each model Z[:, i] = nm.get_mcmc_zscores(Xz, Yz[:, i:i+1], **kwargs) - + else: + Z[:, i] = np.squeeze((Yz[:, i:i+1] - Yhat[:, i:i+1]) / np.sqrt(S2[:, i:i+1])) + if respfile is None: save_results(None, Yhat, S2, None, outputsuffix=outputsuffix) @@ -875,15 +877,13 @@ def predict(covfile, respfile, maskfile=None, **kwargs): else: if models is not None and len(Y.shape) > 1: Y = Y[:, models] + # TODO: Needs simplification if meta_data: - # are we using cross-validation? - if type(mY) is list: - mY = mY[fold][models] - else: + if type(mY) is list: # This happens when non-parallel or when using meta data from batches + mY = mY[0][models] + sY = sY[0][models] + else: # This happens when parallel on collected metadata mY = mY[models] - if type(sY) is list: - sY = sY[fold][models] - else: sY = sY[models] if len(Y.shape) == 1: @@ -895,7 +895,7 @@ def predict(covfile, respfile, maskfile=None, **kwargs): Yw = np.zeros_like(Y) for i, m in enumerate(models): nm = norm_init(Xz) - nm = nm.load(os.path.join(model_path, 'NM_' + str(fold) + '_' + + nm = nm.load(os.path.join(model_path, 'NM_0_' + str(m) + inputsuffix + '.pkl')) warp_param = nm.blr.hyp[1:nm.blr.warp.get_n_params()+1] @@ -937,17 +937,19 @@ def transfer(covfile, respfile, testcov=None, testresp=None, maskfile=None, Basic usage:: - transfer(covfile, respfile [extra_arguments]) + transfer(covfile, respfile, trbefile, model_path, output_path, inputsuffix [extra_arguments]) where the variables are defined below. :param covfile: transfer covariates used to predict the response variable :param respfile: transfer response variables for the normative model :param maskfile: mask used to apply to the data (nifti only) + :param trbefile: Training batch effects file :param testcov: Test covariates :param testresp: Test responses :param model_path: Directory containing the normative model and metadata - :param trbefile: Training batch effects file + :param output_path: Address to output directory to save the transferred models + :param inputsuffix: The suffix for the inout models (default='estimate') :param batch_size: batch size (for use with normative_parallel) :param job_id: batch id @@ -966,13 +968,12 @@ def transfer(covfile, respfile, testcov=None, testresp=None, maskfile=None, # but should be for BLR (since it doesn't produce transfer models) elif ('model_path' not in list(kwargs.keys())) or \ ('trbefile' not in list(kwargs.keys())): - print(f'{kwargs=}') - print('InputError: Some general mandatory arguments are missing.') + print('InputError: model_path or trbefile are missing.') return # hbr has one additional mandatory arguments elif alg == 'hbr': if ('output_path' not in list(kwargs.keys())): - print('InputError: Some mandatory arguments for hbr are missing.') + print('InputError: output_path is missing.') return else: output_path = kwargs.pop('output_path', None) @@ -997,7 +998,7 @@ def transfer(covfile, respfile, testcov=None, testresp=None, maskfile=None, trbefile = kwargs.pop('trbefile', None) job_id = kwargs.pop('job_id', None) batch_size = kwargs.pop('batch_size', None) - fold = kwargs.pop('fold', 0) + fold = kwargs.pop('fold', 0) # This is almost always 0 in the transfer scenario. # for PCNonline automated parallel jobs loop count_jobsdone = kwargs.pop('count_jobsdone', 'False') @@ -1006,7 +1007,13 @@ def transfer(covfile, respfile, testcov=None, testresp=None, maskfile=None, if batch_size is not None: batch_size = int(batch_size) + + if job_id is not None: job_id = int(job_id) - 1 + parallel = True + else: + parallel = False + job_id = 0 if not os.path.isdir(model_path): print('Models directory does not exist!') @@ -1036,17 +1043,28 @@ def transfer(covfile, respfile, testcov=None, testresp=None, maskfile=None, X = X[:, np.newaxis] if inscaler in ['standardize', 'minmax', 'robminmax']: - scaler_cov[0].extend(X) - X = scaler_cov[0].transform(X) + if parallel: + scaler_cov[job_id][fold].extend(X) + X = scaler_cov[job_id][fold].transform(X) + else: + scaler_cov[fold].extend(X) + X = scaler_cov[fold].transform(X) + if outscaler in ['standardize', 'minmax', 'robminmax']: + if parallel: + scaler_resp[job_id][fold].extend(Y) + Y = scaler_resp[job_id][fold].transform(Y) + else: + scaler_resp[fold].extend(Y) + Y = scaler_resp[fold].transform(Y) + feature_num = Y.shape[1] + + # mean and std of training data only used for calculating the MSLL mY = np.mean(Y, axis=0) sY = np.std(Y, axis=0) - - if outscaler in ['standardize', 'minmax', 'robminmax']: - scaler_resp[0].extend(Y) - Y = scaler_resp[0].transform(Y) - + + batch_effects_train = fileio.load(trbefile) # load test data @@ -1056,13 +1074,23 @@ def transfer(covfile, respfile, testcov=None, testresp=None, maskfile=None, if len(Xte.shape) == 1: Xte = Xte[:, np.newaxis] ts_sample_num = Xte.shape[0] + if inscaler in ['standardize', 'minmax', 'robminmax']: - Xte = scaler_cov[0].transform(Xte) + if parallel: + Xte = scaler_cov[job_id][fold].transform(Xte) + else: + Xte = scaler_cov[fold].transform(Xte) if testresp is not None: Yte, testmask = load_response_vars(testresp, maskfile) if len(Yte.shape) == 1: Yte = Yte[:, np.newaxis] + if outscaler in ['standardize', 'minmax', 'robminmax']: + if parallel: + Yte = scaler_resp[job_id][fold].transform(Yte) + else: + Yte = scaler_resp[fold].transform(Yte) + else: Yte = np.zeros([ts_sample_num, feature_num]) @@ -1076,10 +1104,22 @@ def transfer(covfile, respfile, testcov=None, testresp=None, maskfile=None, Yhat = np.zeros([ts_sample_num, feature_num]) S2 = np.zeros([ts_sample_num, feature_num]) Z = np.zeros([ts_sample_num, feature_num]) - + + if meta_data: + my_meta_data['mean_resp'] = mY + my_meta_data['std_resp'] = sY + if inscaler not in ['None']: + my_meta_data['scaler_cov'] = scaler_cov + if outscaler not in ['None']: + my_meta_data['scaler_resp'] = scaler_resp + if parallel: + pickle.dump(my_meta_data, open(os.path.join('Models', 'meta_data.md'), 'wb')) + else: + pickle.dump(my_meta_data, open(os.path.join(output_path, 'meta_data.md'), 'wb')) + # estimate the models for all subjects for i in range(feature_num): - + if alg == 'hbr': print("Using HBR transform...") nm = norm_init(X) @@ -1092,12 +1132,9 @@ def transfer(covfile, respfile, testcov=None, testresp=None, maskfile=None, print("Transferring model ", i+1, "of", feature_num) nm = nm.load(os.path.join(model_path, 'NM_0_' + str(i) + inputsuffix + '.pkl')) - - nm = nm.estimate_on_new_sites(X, Y[:, i], batch_effects_train) - if meta_data: - my_meta_data['scaler_cov'] = scaler_cov[0] - my_meta_data['scaler_resp'] = scaler_resp[0] - pickle.dump(my_meta_data, open(os.path.join(output_path, 'meta_data.md'), 'wb')) + + nm = nm.transfer(X, Y[:, i], batch_effects_train) + if batch_size is not None: nm.save(os.path.join(output_path, 'NM_0_' + str(job_id*batch_size+i) + outputsuffix + '.pkl')) @@ -1107,6 +1144,8 @@ def transfer(covfile, respfile, testcov=None, testresp=None, maskfile=None, if testcov is not None: yhat, s2 = nm.predict_on_new_sites(Xte, batch_effects_test) + if testresp is not None: + Z[:, i] = nm.get_mcmc_zscores(Xte, Yte[:, i:i+1], **kwargs) # We basically use normative.predict script here. if alg == 'blr': @@ -1136,13 +1175,24 @@ def transfer(covfile, respfile, testcov=None, testresp=None, maskfile=None, if testcov is not None: if outscaler == 'standardize': - Yhat[:, i] = scaler_resp[0].inverse_transform( - yhat.squeeze(), index=i) - S2[:, i] = s2.squeeze() * sY[i]**2 + if parallel: + Yhat[:, i] = scaler_resp[job_id][fold].inverse_transform( + yhat.squeeze(), index=i) + S2[:, i] = s2.squeeze() * scaler_resp[job_id][fold].s[i]**2 + else: + Yhat[:, i] = scaler_resp[fold].inverse_transform( + yhat.squeeze(), index=i) + S2[:, i] = s2.squeeze() * scaler_resp[fold].s[i]**2 + elif outscaler in ['minmax', 'robminmax']: - Yhat[:, i] = scaler_resp[0].inverse_transform(yhat, index=i) - S2[:, i] = s2 * (scaler_resp[0].max[i] - - scaler_resp[0].min[i])**2 + if parallel: + Yhat[:, i] = scaler_resp[job_id][fold].inverse_transform(yhat, index=i) + S2[:, i] = s2 * (scaler_resp[job_id][fold].max[i] - + scaler_resp[job_id][fold].min[i])**2 + else: + Yhat[:, i] = scaler_resp[fold].inverse_transform(yhat, index=i) + S2[:, i] = s2 * (scaler_resp[fold].max[i] - + scaler_resp[fold].min[i])**2 else: Yhat[:, i] = yhat.squeeze() S2[:, i] = s2.squeeze() @@ -1165,9 +1215,9 @@ def transfer(covfile, respfile, testcov=None, testresp=None, maskfile=None, Yte = Yw else: warp = False - - # TODO Z-scores adaptation for SHASH HBR - Z = (Yte - Yhat) / np.sqrt(S2) + # For HBR the Z scores are already computed + if alg != 'hbr': + Z = (Yte - Yhat) / np.sqrt(S2) print("Evaluating the model ...") if meta_data and not warp: @@ -1198,7 +1248,7 @@ def extend(covfile, respfile, maskfile=None, **kwargs): Basic usage:: - extend(covfile, respfile [extra_arguments]) + transfer(covfile, respfile, trbefile, model_path, output_path, inputsuffix [extra_arguments]) where the variables are defined below. @@ -1210,10 +1260,9 @@ def extend(covfile, respfile, maskfile=None, **kwargs): :param batch_size: batch size (for use with normative_parallel) :param job_id: batch id :param output_path: the path for saving the the extended model + :param inputsuffix: The suffix for the input models (default='extend') :param informative_prior: use initial model prior or learn from scratch (default is False). - :param generation_factor: see below - - generation factor refers to the number of samples generated for each + :param generation_factor: generation factor refers to the number of samples generated for each combination of covariates and batch effects. Default is 10. @@ -1228,7 +1277,7 @@ def extend(covfile, respfile, maskfile=None, **kwargs): elif ('model_path' not in list(kwargs.keys())) or \ ('output_path' not in list(kwargs.keys())) or \ ('trbefile' not in list(kwargs.keys())): - print('InputError: Some mandatory arguments are missing.') + print('InputError: Please specify model_path, output_path, and trbefile.') return else: model_path = kwargs.pop('model_path') @@ -1237,15 +1286,25 @@ def extend(covfile, respfile, maskfile=None, **kwargs): outputsuffix = kwargs.pop('outputsuffix', 'extend') outputsuffix = "_" + outputsuffix.replace("_", "") - inputsuffix = kwargs.pop('inputsuffix', 'estimate') + inputsuffix = kwargs.pop('inputsuffix', 'extend') inputsuffix = "_" + inputsuffix.replace("_", "") informative_prior = kwargs.pop('informative_prior', 'False') == 'True' generation_factor = int(kwargs.pop('generation_factor', '10')) job_id = kwargs.pop('job_id', None) batch_size = kwargs.pop('batch_size', None) + fold = kwargs.pop('fold', 0) # This is almost always 0 in the extend scenario. + + + if batch_size is not None: batch_size = int(batch_size) + + if job_id is not None: job_id = int(job_id) - 1 + parallel = True + else: + parallel = False + job_id = 0 if not os.path.isdir(model_path): print('Models directory does not exist!') @@ -1254,13 +1313,15 @@ def extend(covfile, respfile, maskfile=None, **kwargs): if os.path.exists(os.path.join(model_path, 'meta_data.md')): with open(os.path.join(model_path, 'meta_data.md'), 'rb') as file: my_meta_data = pickle.load(file) - if (my_meta_data['inscaler'] != 'None' or - my_meta_data['outscaler'] != 'None'): - print('Models extention on scaled data is not possible!') - return + inscaler = my_meta_data['inscaler'] + outscaler = my_meta_data['outscaler'] + scaler_cov = my_meta_data['scaler_cov'] + scaler_resp = my_meta_data['scaler_resp'] meta_data = True else: print("No meta-data file is found!") + inscaler = 'None' + outscaler = 'None' meta_data = False if not os.path.isdir(output_path): @@ -1276,13 +1337,41 @@ def extend(covfile, respfile, maskfile=None, **kwargs): Y = Y[:, np.newaxis] if len(X.shape) == 1: X = X[:, np.newaxis] + + if inscaler in ['standardize', 'minmax', 'robminmax']: + if parallel: + scaler_cov[job_id][fold].extend(X) + X = scaler_cov[job_id][fold].transform(X) + else: + scaler_cov[fold].extend(X) + X = scaler_cov[fold].transform(X) + + if outscaler in ['standardize', 'minmax', 'robminmax']: + if parallel: + scaler_resp[job_id][fold].extend(Y) + Y = scaler_resp[job_id][fold].transform(Y) + else: + scaler_resp[fold].extend(Y) + Y = scaler_resp[fold].transform(Y) + feature_num = Y.shape[1] + if meta_data: + if inscaler not in ['None']: + my_meta_data['scaler_cov'] = scaler_cov + if outscaler not in ['None']: + my_meta_data['scaler_resp'] = scaler_resp + if parallel: + pickle.dump(my_meta_data, open(os.path.join('Models', 'meta_data.md'), 'wb')) + else: + pickle.dump(my_meta_data, open(os.path.join(output_path, 'meta_data.md'), 'wb')) + + # estimate the models for all subjects for i in range(feature_num): nm = norm_init(X) - if batch_size is not None: # when using nirmative_parallel + if parallel: # when using normative_parallel print("Extending model ", job_id*batch_size+i) nm = nm.load(os.path.join(model_path, 'NM_0_' + str(job_id*batch_size+i) + inputsuffix + @@ -1296,7 +1385,7 @@ def extend(covfile, respfile, maskfile=None, **kwargs): samples=generation_factor, informative_prior=informative_prior) - if batch_size is not None: + if parallel: # The model is save into both output_path and temporary parallel folders nm.save(os.path.join(output_path, 'NM_0_' + str(job_id*batch_size+i) + outputsuffix + '.pkl')) nm.save(os.path.join('Models', 'NM_0_' + diff --git a/pcntoolkit/normative_model/norm_hbr.py b/pcntoolkit/normative_model/norm_hbr.py index 170af404..e8a9b5d0 100644 --- a/pcntoolkit/normative_model/norm_hbr.py +++ b/pcntoolkit/normative_model/norm_hbr.py @@ -7,26 +7,21 @@ @author: augub """ -from __future__ import print_function -from __future__ import division -from sys import exit - -from itertools import product +from __future__ import division, print_function import os -import warnings import sys +from sys import exit -import xarray import arviz as az import numpy as np +import xarray from scipy import special as spp -from ast import literal_eval as make_tuple try: from pcntoolkit.dataio import fileio - from pcntoolkit.normative_model.norm_base import NormBase from pcntoolkit.model.hbr import HBR + from pcntoolkit.normative_model.norm_base import NormBase except ImportError: pass @@ -111,8 +106,9 @@ class NormHBR(NormBase): but higher values like 0.9 or 0.95 often work better for problematic posteriors. :param order: String that defines the order of bspline or polynomial model. The defauls is '3'. - :param nknots: String that defines the numbers of knots for the bspline model. - The defauls is '5'. Higher values increase the model complexity with negative + :param nknots: String that defines the numbers of interior knots for the bspline model. + The defauls is '3'. Two knots will be added to this number for boundries. So final + number of knots will be nknots+2. Higher values increase the model complexity with negative effect on the spped of estimations. :param nn_hidden_layers_num: String the specifies the number of hidden layers in neural network model. It can be either '1' or '2'. The default is set to '2'. @@ -158,7 +154,7 @@ def __init__(self, **kwargs): if self.configs["type"] == "bspline": self.configs["order"] = int(kwargs.get("order", "3")) - self.configs["nknots"] = int(kwargs.get("nknots", "5")) + self.configs["nknots"] = int(kwargs.get("nknots", "3")) elif self.configs["type"] == "polynomial": self.configs["order"] = int(kwargs.get("order", "3")) elif self.configs["type"] == "nn": @@ -286,7 +282,7 @@ def estimate(self, X, y, **kwargs): self.hbr.estimate(X, y, batch_effects_train) return self - + def predict(self, Xs, X=None, Y=None, **kwargs): """ Predict the target values for the given test data. @@ -313,22 +309,22 @@ def predict(self, Xs, X=None, Y=None, **kwargs): pred_type = self.configs["pred_type"] - if self.configs["transferred"] == False: - yhat, s2 = self.hbr.predict( - X=Xs, - batch_effects=batch_effects_test, - batch_effects_maps=self.batch_effects_maps, - pred=pred_type, - **kwargs, - ) - else: - raise ValueError( - "This is a transferred model. Please use predict_on_new_sites function." - ) + # if self.configs["transferred"] == False: + yhat, s2 = self.hbr.predict( + X=Xs, + batch_effects=batch_effects_test, + batch_effects_maps=self.batch_effects_maps, + pred=pred_type, + **kwargs, + ) + # else: + # raise ValueError( + # "This is a transferred model. Please use predict_on_new_sites function." + # ) return yhat.squeeze(), s2.squeeze() - def estimate_on_new_sites(self, X, y, batch_effects): + def transfer(self, X, y, batch_effects): """ Samples from the posterior of the Hierarchical Bayesian Regression model. @@ -342,7 +338,7 @@ def estimate_on_new_sites(self, X, y, batch_effects): - 'trbefile': File containing the batch effects for the training data. Optional. :return: The instance of the NormHBR object. """ - self.hbr.estimate_on_new_site(X, y, batch_effects) + self.hbr.transfer(X, y, batch_effects) self.configs["transferred"] = True return self @@ -357,9 +353,16 @@ def predict_on_new_sites(self, X, batch_effects): :param batch_effects: Batch effects for the new sites. :return: A tuple containing the predicted target values and the marginal variances for the test data on the new sites. """ - yhat, s2 = self.hbr.predict_on_new_site(X, batch_effects) + + yhat, s2 = self.hbr.predict( + X, + batch_effects=batch_effects, + batch_effects_maps=self.batch_effects_maps + ) + return yhat, s2 + def extend( self, X, @@ -368,7 +371,7 @@ def extend( X_dummy_ranges=[[0.1, 0.9, 0.01]], merge_batch_dim=0, samples=10, - informative_prior=False, + informative_prior=False ): """ Extend the Hierarchical Bayesian Regression model using data sampled from the posterior predictive distribution. @@ -386,11 +389,11 @@ def extend( :param informative_prior: Whether to use the adapt method for estimation. Default is False. :return: The instance of the NormHBR object. """ - X_dummy, batch_effects_dummy = self.hbr.create_dummy_inputs( - X_dummy_ranges) - + + X_dummy, batch_effects_dummy = self.hbr.create_dummy_inputs(X) + X_dummy, batch_effects_dummy, Y_dummy = self.hbr.generate( - X_dummy, batch_effects_dummy, samples + X_dummy, batch_effects_dummy, samples, batch_effects_maps=self.batch_effects_maps ) batch_effects[:, merge_batch_dim] = ( @@ -399,18 +402,20 @@ def extend( + 1 ) + X = np.concatenate((X_dummy, X)) + y = np.concatenate((Y_dummy, y)) + batch_effects = np.concatenate((batch_effects_dummy, batch_effects)) + + self.batch_effects_maps = [ {v: i for i, v in enumerate(np.unique(batch_effects[:, j]))} + for j in range(batch_effects.shape[1]) + ] + if informative_prior: - self.hbr.adapt( - np.concatenate((X_dummy, X)), - np.concatenate((Y_dummy, y)), - np.concatenate((batch_effects_dummy, batch_effects)), - ) + #raise NotImplementedError("The extension with informaitve prior is not implemented yet.") + self.hbr.transfer(X, y, batch_effects) else: - self.hbr.estimate( - np.concatenate((X_dummy, X)), - np.concatenate((Y_dummy, y)), - np.concatenate((batch_effects_dummy, batch_effects)), - ) + + self.hbr.estimate(X, y, batch_effects) return self @@ -522,44 +527,43 @@ def get_mcmc_quantiles(self, X, batch_effects=None, z_scores=None): """ # Set batch effects to zero if none are provided if batch_effects is None: - batch_effects = batch_effects_test = np.zeros([X.shape[0], 1]) + batch_effects = np.zeros([X.shape[0], 1]) # Set the z_scores for which the quantiles are computed if z_scores is None: z_scores = np.arange(-3, 4) - likelihood = self.configs["likelihood"] + elif len(z_scores.shape) == 2: + if not z_scores.shape[0] == X.shape[0]: + raise ValueError("The number of columns in z_scores must match the number of columns in X") + z_scores = z_scores.T # Determine the variables to predict - if self.configs["likelihood"] == "Normal": - var_names = ["mu_samples", "sigma_samples", "sigma_plus_samples"] - elif self.configs["likelihood"].startswith("SHASH"): - var_names = [ - "mu_samples", - "sigma_samples", - "sigma_plus_samples", - "epsilon_samples", - "delta_samples", - "delta_plus_samples", - ] - else: - exit("Unknown likelihood: " + self.configs["likelihood"]) + match self.configs["likelihood"]: + case "Normal": + var_names = ["mu_samples", "sigma_samples", "sigma_plus_samples"] + case "SHASHo" | "SHASHo2" | "SHASHb": + var_names = [ + "mu_samples", + "sigma_samples", + "sigma_plus_samples", + "epsilon_samples", + "delta_samples", + "delta_plus_samples", + ] + case _: + exit("Unknown likelihood: " + self.configs["likelihood"]) # Delete the posterior predictive if it already exists if "posterior_predictive" in self.hbr.idata.groups(): del self.hbr.idata.posterior_predictive - if self.configs["transferred"] == True: - self.predict_on_new_sites(X=X, batch_effects=batch_effects) - # var_names = ["y_like"] - else: - self.hbr.predict( - # Do a forward to get the posterior predictive in the idata - X=X, - batch_effects=batch_effects, - batch_effects_maps=self.batch_effects_maps, - pred="single", - var_names=var_names + ["y_like"], - ) + self.hbr.predict( + X=X, + batch_effects=batch_effects, + batch_effects_maps=self.batch_effects_maps, + pred="single", + var_names=var_names + ["y_like"], + ) # Extract the relevant samples from the idata post_pred = az.extract( @@ -580,8 +584,12 @@ def get_mcmc_quantiles(self, X, batch_effects=None, z_scores=None): (z_scores.shape[0], len_synth_data, n_mcmc_samples)) # Compute the quantile iteratively for each z-score + for i, j in enumerate(z_scores): - zs = np.full((len_synth_data, n_mcmc_samples), j, dtype=float) + if len(z_scores.shape) == 1: + zs = np.full((len_synth_data, n_mcmc_samples), j, dtype=float) + else: + zs = np.repeat(j[:,None], n_mcmc_samples, axis=1) quantiles[i] = xarray.apply_ufunc( quantile, *array_of_vars, diff --git a/pcntoolkit/normative_parallel.py b/pcntoolkit/normative_parallel.py index f1ed0e46..fce6aaf3 100755 --- a/pcntoolkit/normative_parallel.py +++ b/pcntoolkit/normative_parallel.py @@ -107,7 +107,8 @@ def execute_nm(processing_dir, cv_folds = kwargs.get('cv_folds', None) testcovfile_path = kwargs.get('testcovfile_path', None) testrespfile_path = kwargs.get('testrespfile_path', None) - outputsuffix = kwargs.get('outputsuffix', '_estimate') + outputsuffix = kwargs.get('outputsuffix', 'estimate') + outputsuffix = "_" + outputsuffix.replace("_", "") cluster_spec = kwargs.pop('cluster_spec', 'torque') log_path = kwargs.get('log_path', None) binary = kwargs.pop('binary', False) @@ -473,7 +474,7 @@ def collect_nm(processing_dir, collect=False, binary=False, batch_size=None, - outputsuffix='_estimate'): + outputsuffix='estimate'): '''Function to checks and collects all batches. Basic usage:: @@ -493,6 +494,8 @@ def collect_nm(processing_dir, written by (primarily) T Wolfers, (adapted) SM Kia, (adapted) S Rutherford. ''' + outputsuffix = "_" + outputsuffix.replace("_", "") + if binary: file_extentions = '.pkl' else: diff --git a/pcntoolkit/util/bspline.py b/pcntoolkit/util/bspline.py new file mode 100644 index 00000000..b3d43f6e --- /dev/null +++ b/pcntoolkit/util/bspline.py @@ -0,0 +1,149 @@ +import numpy as np +from scipy.interpolate import BSpline + + +class BSplineBasis: + def __init__( + self, order, nknots, knot_method="uniform", left_expand=0.05, right_expand=0.05 + ): + """ + Initialize the BSplineBasis object. + :param order: Degree of the B-spline + :param nknots: Number of interior knots. Mind that this is the number of interior + knots. The final number of knots will be nknotes+2 as two knots will be added at boundries. + :param knot_method: 'uniform' or 'percentile' for knot placement + :param left_expand: Fraction to expand the range on the left (default 0) + :param right_expand: Fraction to expand the range on the right (default 0) + """ + if nknots + 2 < order + 1: + raise ValueError("Number of knots+2 must be at least degree + 1.") + if knot_method not in ["uniform", "percentile"]: + raise ValueError("knot_method must be 'uniform' or 'percentile'.") + if not (0 <= left_expand <= 1 and 0 <= right_expand <= 1): + raise ValueError("left_expand and right_expand must be between 0 and 1.") + + self.degree = order + self.nknots = nknots + self.knot_method = knot_method + self.left_expand = left_expand + self.right_expand = right_expand + self.knots = None + self.feature_min = None + self.feature_max = None + + def fit(self, X, feature_min=None, feature_max=None): + """ + Fit B-spline basis functions to the dataset. + :param X: [N×P] array of covariates + :param feature_min: Minimum values for features (optional) + :param feature_max: Maximum values for features (optional) + """ + if not isinstance(X, np.ndarray): + raise ValueError("Input X must be a NumPy array.") + if X.ndim != 2: + raise ValueError("Input X must be a 2D array.") + + self.feature_min = ( + np.min(X, axis=0) if feature_min is None else np.array(feature_min) + ) + self.feature_max = ( + np.max(X, axis=0) if feature_max is None else np.array(feature_max) + ) + + feature_num = X.shape[1] + self.knots = [] + + for i in range(feature_num): + # Determine range of bspline basis + minx = self.feature_min[i] + maxx = self.feature_max[i] + delta = maxx - minx + t_min = minx - self.left_expand * delta + t_max = maxx + self.right_expand * delta + + # Determine knot locations + if self.knot_method == "uniform": + interior_knots = np.linspace(t_min, t_max, self.nknots) + elif self.knot_method == "percentile": + interior_knots = np.percentile( + X[:, i], np.linspace(0, 100, self.nknots) + ) + + # Add boundary knots + t = np.concatenate( + ([t_min] * self.degree, interior_knots, [t_max] * self.degree) + ) + + self.knots.append(t) + + def transform(self, X): + """ + Transform the dataset using the fitted B-spline basis functions. + :param X: [N×P] array of clinical covariates + :return: [N×(P×n_basis)] array of transformed data + """ + if self.knots is None: + raise ValueError( + "B-spline basis functions have not been fitted. Call 'fit' first." + ) + if not isinstance(X, np.ndarray): + raise ValueError("Input X must be a NumPy array.") + if X.ndim != 2: + raise ValueError("Input X must be a 2D array.") + if len(self.knots) != X.shape[1]: + raise ValueError( + "Number of B-spline basis functions must match the number of features in X." + ) + + transformed_features = [] + for f in range(len(self.knots)): + phi = BSpline.design_matrix( + x=X[:, f], t=self.knots[f], k=self.degree, extrapolate=True + ).toarray() + transformed_features.append(phi) + return np.concatenate(transformed_features, axis=1) + + def adapt(self, target_X): + """ + Adapt the fitted B-spline basis functions to a target dataset. + :param target_X: [N×P] array of target clinical covariates + """ + if self.knots is None: + raise ValueError( + "B-spline basis functions have not been fitted. Call 'fit' first." + ) + if not isinstance(target_X, np.ndarray): + raise ValueError("Input target_X must be a NumPy array.") + if target_X.ndim != 2: + raise ValueError("Input target_X must be a 2D array.") + if len(self.knots) != target_X.shape[1]: + raise ValueError( + "Number of B-spline basis functions must match the number of features in target_X." + ) + + # Updating feature_min and feature_max using combined datsets + combined_min = np.minimum(self.feature_min, np.min(target_X, axis=0)) + combined_max = np.maximum(self.feature_max, np.max(target_X, axis=0)) + self.feature_min = combined_min + self.feature_max = combined_max + + feature_num = target_X.shape[1] + + new_knots = [] + + for i in range(feature_num): + minx = self.feature_min[i] + maxx = self.feature_max[i] + delta = maxx - minx + t_min = minx - self.left_expand * delta + t_max = maxx + self.right_expand * delta + + # Adapt knots + source_knots = self.knots[i] + target_knots = t_min + (source_knots - source_knots[0]) * ( + t_max - t_min + ) / (source_knots[-1] - source_knots[0]) + + new_knots.append(target_knots) + + self.knots = new_knots \ No newline at end of file diff --git a/pcntoolkit/util/utils.py b/pcntoolkit/util/utils.py index 3fff987f..1e3c5114 100644 --- a/pcntoolkit/util/utils.py +++ b/pcntoolkit/util/utils.py @@ -1515,7 +1515,7 @@ def cartesian_product(arrays): la = len(arrays) dtype = np.result_type(arrays[0]) arr = np.empty([len(a) for a in arrays] + [la], dtype=dtype) - for i, a in enumerate(np.ix_(arrays)): + for i, a in enumerate(np.ix_(*arrays)): arr[..., i] = a return arr.reshape(-1, la) diff --git a/tests/cli_test/test_cli.sh b/tests/cli_test/test_cli.sh index 92aa890b..163fe4bb 100755 --- a/tests/cli_test/test_cli.sh +++ b/tests/cli_test/test_cli.sh @@ -7,7 +7,7 @@ export tempdir="$testdir/temp" mkdir $tempdir chmod -R 766 $tempdir export data_name="fcon1000" -export model_config="-a blr warp=WarpSinArcsinh optimizer=l-bfgs-b warp_reparam=True" +export model_config="-a blr warp=WarpSinArcsinh optimizer=l-bfgs-b warp_reparam=True inscaler=standardize" echo "Downloading the data..." curl -o $tempdir/$data_name https://raw.githubusercontent.com/predictive-clinical-neuroscience/PCNtoolkit-demo/refs/heads/main/data/$data_name.csv echo "Splitting the data into train and test covariates, responses and batch effects..." diff --git a/tests/cli_test_parallel_kfold/Yhat_estimate_ft0_batch1.png b/tests/cli_test_parallel_kfold/Yhat_estimate_ft0_batch1.png new file mode 100644 index 00000000..44411167 Binary files /dev/null and b/tests/cli_test_parallel_kfold/Yhat_estimate_ft0_batch1.png differ diff --git a/tests/cli_test_parallel_kfold/Yhat_estimate_ft0_batch2.png b/tests/cli_test_parallel_kfold/Yhat_estimate_ft0_batch2.png new file mode 100644 index 00000000..44411167 Binary files /dev/null and b/tests/cli_test_parallel_kfold/Yhat_estimate_ft0_batch2.png differ diff --git a/tests/cli_test_parallel_kfold/Yhat_estimate_ft1_batch1.png b/tests/cli_test_parallel_kfold/Yhat_estimate_ft1_batch1.png new file mode 100644 index 00000000..7defa3ef Binary files /dev/null and b/tests/cli_test_parallel_kfold/Yhat_estimate_ft1_batch1.png differ diff --git a/tests/cli_test_parallel_kfold/Yhat_estimate_ft1_batch2.png b/tests/cli_test_parallel_kfold/Yhat_estimate_ft1_batch2.png new file mode 100644 index 00000000..7defa3ef Binary files /dev/null and b/tests/cli_test_parallel_kfold/Yhat_estimate_ft1_batch2.png differ diff --git a/tests/cli_test_parallel_kfold/inspect_results.py b/tests/cli_test_parallel_kfold/inspect_results.py new file mode 100644 index 00000000..f8760fff --- /dev/null +++ b/tests/cli_test_parallel_kfold/inspect_results.py @@ -0,0 +1,56 @@ +import pickle +import numpy as np +import matplotlib.pyplot as plt + +import glob +import os + + + +for batch in [1,2]: + results_dir = "/project/3022000.05/projects/stijdboe/temp/parallel_processing/batch_1" + + + for func in ['fit', 'predict', 'estimate']: + print(f"Plotting {func} results...") + results = glob.glob(os.path.join(results_dir, f"*{func}.pkl")) + for result in results: + if "Z" in result: + z = pickle.load(open(result, "rb")) + n = np.random.randn(z.shape[0], 1) + sorted_z = np.sort(z, axis=0) + sorted_n = np.sort(n, axis=0) + plt.plot(sorted_z, sorted_n, label=f"Z_{func}") + plt.savefig(f"Z_{func}.png") + plt.close() + elif "yhat" in result: + x_path = "/project/3022000.05/projects/stijdboe/Projects/PCNtoolkit/tests/cli_test_parallel_kfold/temp/X_te_fcon1000.pkl" + x = pickle.load(open(x_path, "rb")).to_numpy() + sortindex = np.argsort(x[:,1]) + print(x[sortindex, 1]) + yhat = pickle.load(open(result, "rb")).to_numpy() + result = result.replace("yhat", "ys2") + s2 = pickle.load(open(result, "rb")).to_numpy() + print(x.shape) + print(yhat.shape) + print(s2.shape) + + for i in range(yhat.shape[1]): + plt.plot(x[sortindex, 1], yhat[sortindex, i], label=f"Yhat_{func}_{i}") + plt.plot(x[sortindex, 1], yhat[sortindex, i] - s2[sortindex, i], label=f"Yhat_{func}_{i} - s2") + plt.plot(x[sortindex, 1], yhat[sortindex, i] + s2[sortindex, i], label=f"Yhat_{func}_{i} + s2") + plt.savefig(f"Yhat_{func}_ft{i}_batch{batch}.png") + plt.close() + elif "S2" in result: + s2 = pickle.load(open(result, "rb")) + print(f"{s2=}") + elif "EXPV" in result: + expv = pickle.load(open(result, "rb")) + print(f"{expv=}") + elif "MSLL" in result: + msll = pickle.load(open(result, "rb")) + print(f"{msll=}") + elif "SMSE" in result: + smse = pickle.load(open(result, "rb")) + print(f"{smse=}") + diff --git a/tests/cli_test_parallel_kfold/split_data.py b/tests/cli_test_parallel_kfold/split_data.py new file mode 100644 index 00000000..55738433 --- /dev/null +++ b/tests/cli_test_parallel_kfold/split_data.py @@ -0,0 +1,77 @@ +import argparse +import os + +import numpy as np +import pandas as pd + +# Import train_test_split from sklearn +from sklearn.model_selection import train_test_split + +# Import the StandardScaler from sklearn +from sklearn.preprocessing import StandardScaler + +from pcntoolkit.util.utils import create_design_matrix + + +def main(): + + np.random.seed(42) + + parser = argparse.ArgumentParser() + parser.add_argument("--input_file", type=str, required=True) + parser.add_argument("--output_dir", type=str, required=True) + args = parser.parse_args() + infile=args.input_file.split("/")[-1] + + print(f"Splitting the data located at {args.input_file} into train and test covariates, responses and batch effects...") + df = pd.read_csv(args.input_file) + + # Select the covariates, responses and batch effects + cov = df['age'] + resp = df[['SubCortGrayVol','Left-Hippocampus','Brain-Stem','CSF']] + be = df['site'] + + # Standardize the covariates and responses + cov = StandardScaler().fit_transform(cov.to_numpy()[:,np.newaxis]) + resp = StandardScaler().fit_transform(resp.to_numpy()) + + xmin = cov.min() + xmax = cov.max() + + + # Map the batch effects to integers + be_ids = np.unique(be, return_inverse=True)[1] + + # Split the data into training and test sets + train_idx, test_idx = train_test_split(np.arange(len(cov)), test_size=0.2, stratify=be_ids) + + # Create the design matrices + mean_basis = 'linear' + var_basis = 'linear' + # Phi_tr = create_design_matrix(cov[train_idx], basis=mean_basis, intercept=False, site_ids=be_ids[train_idx]) + # Phi_var_tr = create_design_matrix(cov[train_idx], basis=var_basis) + # Phi_te = create_design_matrix(cov[test_idx], basis=mean_basis, intercept=False, site_ids=be_ids[test_idx]) + # Phi_var_te = create_design_matrix(cov[test_idx], basis=var_basis) + + Phi_tr = create_design_matrix(cov[train_idx], basis=mean_basis, intercept=True, xmin=xmin, xmax=xmax) + # Phi_var_tr = create_design_matrix(cov[train_idx], basis=var_basis, xmin=xmin, xmax=xmax) + Phi_var_tr = cov[train_idx] + Phi_te = create_design_matrix(cov[test_idx], basis=mean_basis, intercept=True, xmin=xmin, xmax=xmax) + # Phi_var_te = create_design_matrix(cov[test_idx], basis=var_basis, xmin=xmin, xmax=xmax) + Phi_var_te = cov[test_idx] + print(f"{Phi_var_te.shape=}") + + # Save everything + pd.to_pickle(pd.DataFrame(Phi_tr), os.path.join(args.output_dir, f'X_tr_{infile}.pkl')) + pd.to_pickle(Phi_var_tr, os.path.join(args.output_dir, f'X_var_tr_{infile}.pkl')) + pd.to_pickle(pd.DataFrame(Phi_te), os.path.join(args.output_dir, f'X_te_{infile}.pkl')) + pd.to_pickle(Phi_var_te, os.path.join(args.output_dir, f'X_var_te_{infile}.pkl')) + pd.to_pickle(pd.DataFrame(resp[train_idx]), os.path.join(args.output_dir, f'Y_tr_{infile}.pkl')) + pd.to_pickle(pd.DataFrame(resp[test_idx]), os.path.join(args.output_dir, f'Y_te_{infile}.pkl')) + pd.to_pickle(be[train_idx], os.path.join(args.output_dir, f'be_tr_{infile}.pkl')) + pd.to_pickle(be[test_idx], os.path.join(args.output_dir, f'be_te_{infile}.pkl')) + + print(f"Done! The files can be found in: {args.output_dir}") + +if __name__ == "__main__": + main() diff --git a/tests/cli_test_parallel_kfold/submit_jobs.py b/tests/cli_test_parallel_kfold/submit_jobs.py new file mode 100644 index 00000000..9a6b1f81 --- /dev/null +++ b/tests/cli_test_parallel_kfold/submit_jobs.py @@ -0,0 +1,54 @@ +#!/usr/bin/env python +import sys + +from pcntoolkit.normative_parallel import execute_nm + + +def execute_nm_wrapper(*args): + args_dict = {k:v for k,v in [arg.split('=') for arg in args[0]]} + + func = args_dict.get('func') + covfile_path = args_dict.get('covfile_path',None) + respfile_path = args_dict.get('respfile_path',None) + varcovfile_path = args_dict.get('varcovfile_path',None) + testcovfile_path = args_dict.get('testcovfile_path',None) + testrespfile_path = args_dict.get('testrespfile_path',None) + testvarcovfile_path = args_dict.get('testvarcovfile_path',None) + if func == "estimate": + testrespfile_path = None + + execute_nm( + python_path='/home/preclineu/stijdboe/.conda/envs/pcntk_dev/bin/python', + normative_path="/home/preclineu/stijdboe/.conda/envs/pcntk_dev/lib/python3.12/site-packages/pcntoolkit/normative.py", + job_name='test_normative_parallel', + processing_dir='/project/3022000.05/projects/stijdboe/temp/parallel_processing/', + log_path='/project/3022000.05/projects/stijdboe/temp/parallel_processing/log/', + varcovfile=varcovfile_path, + testvarcovfile=testvarcovfile_path, + func=func, + covfile_path=covfile_path, + respfile_path=respfile_path, + testcovfile_path=testcovfile_path, + testrespfile_path=testrespfile_path, + batch_size=2, + memory='4G', + duration='00:02:00', + job_id=1, + cv_folds = 5, + alg='blr', + warp='WarpSinArcsinh', + optimizer='l-bfgs-b', + warp_reparam='True', + binary='True', + cluster_spec='slurm', + saveoutput='True', + savemodel='True', + outputsuffix=f"_{func}" + ) + + +def main(*args): + execute_nm_wrapper(*args) + +if __name__ == "__main__": + main(sys.argv[1:]) diff --git a/tests/cli_test_parallel_kfold/test_cli.sh b/tests/cli_test_parallel_kfold/test_cli.sh new file mode 100755 index 00000000..bb85ce9c --- /dev/null +++ b/tests/cli_test_parallel_kfold/test_cli.sh @@ -0,0 +1,25 @@ +#! /bin/bash +set -x + +# Assign the current directory to a variable +export testdir=$(pwd) +export tempdir="$testdir/temp" +mkdir $tempdir +chmod -R 766 $tempdir +export data_name="fcon1000" +echo "Downloading the data..." +curl -o $tempdir/$data_name https://raw.githubusercontent.com/predictive-clinical-neuroscience/PCNtoolkit-demo/refs/heads/main/data/$data_name.csv +echo "Splitting the data into train and test covariates, responses and batch effects..." +python split_data.py --input_file $tempdir/$data_name --output_dir $tempdir + +# echo "Fitting the model..." +# python submit_jobs.py func=fit covfile_path=$tempdir/X_tr_$data_name.pkl respfile_path=$tempdir/Y_tr_$data_name.pkl + +# echo "Predicting the test set..." +# python submit_jobs.py func=predict covfile_path=$tempdir/X_te_$data_name.pkl respfile_path=$tempdir/Y_te_$data_name.pkl + +echo "Also doing estimate..." +python submit_jobs.py func=estimate covfile_path=$tempdir/X_tr_$data_name.pkl respfile_path=$tempdir/Y_tr_$data_name.pkl testcovfile_path=$tempdir/X_te_$data_name.pkl testrespfile_path=$tempdir/Y_te_$data_name.pkl testvarcovfile_path=$tempdir/X_var_te_$data_name.pkl varcovfile_path=$tempdir/X_var_tr_$data_name.pkl + +echo "Done!" +# rm -R $tempdirls diff --git a/tests/testHBR.py b/tests/testHBR.py index cd4e833e..0a337af5 100644 --- a/tests/testHBR.py +++ b/tests/testHBR.py @@ -27,7 +27,7 @@ random_state = 40 -working_dir = "/Users/stijndeboer/temp/HBR/" # Specify a working directory to save data and results. +working_dir = "/Users/stijndeboer/tmp/" # Specify a working directory to save data and results. simulation_method = "linear" n_features = 1 # The number of input features of X @@ -141,7 +141,7 @@ ############################################################################### -# %% + # %% for j in range(n_grps): # Showing the quantiles diff --git a/tests/testHBR_transfer.py b/tests/testHBR_transfer.py index 29ec9c96..42d44da2 100644 --- a/tests/testHBR_transfer.py +++ b/tests/testHBR_transfer.py @@ -12,14 +12,14 @@ """ import os +from warnings import filterwarnings + +import matplotlib.pyplot as plt import numpy as np + +from pcntoolkit.normative import estimate from pcntoolkit.normative_model.norm_utils import norm_init from pcntoolkit.util.utils import simulate_data -import matplotlib.pyplot as plt -from pcntoolkit.normative import estimate -from warnings import filterwarnings -from pcntoolkit.util.utils import scaler -import xarray filterwarnings('ignore') @@ -39,29 +39,29 @@ # sample numbers across different batches) n_transfer_samples = 100 -model_types = ['linear'] # models to try +model_types = ['bspline'] # models to try ############################## Data Simulation ################################ X_train, Y_train, grp_id_train, X_test, Y_test, grp_id_test, coef = \ simulate_data(simulation_method, n_samples, n_features, n_grps, - working_dir=working_dir, plot=True) + working_dir=working_dir, plot=True, noise='heteroscedastic_gaussian') X_train_transfer, Y_train_transfer, grp_id_train_transfer, X_test_transfer, Y_test_transfer, grp_id_test_transfer, coef = simulate_data( - simulation_method, n_transfer_samples, n_features=n_features, n_grps=n_transfer_groups, plot=True) + simulation_method, n_transfer_samples, n_features=n_features, n_grps=n_transfer_groups, plot=True, noise='heteroscedastic_gaussian') ################################# Methods Tests ############################### for model_type in model_types: - nm = norm_init(X_train, Y_train, alg='hbr', likelihood='Normal', model_type=model_type, - n_chains=4, cores=4, n_samples=100, n_tuning=50, freedom=5, nknots=8, target_accept="0.99", nuts_sampler='nutpie') + nm = norm_init(X_train, Y_train, alg='hbr', likelihood='Normal', model_type=model_type, linear_sigma="True", + n_chains=4, cores=4, n_samples=1500, n_tuning=500, freedom=1, nknots=8, target_accept="0.99", nuts_sampler='nutpie') print("Now Estimating on original train data ==============================================") nm.estimate(X_train, Y_train, trbefile=working_dir+'trbefile.pkl') print("Now Predicting on original test data ==============================================") - yhat, ys2 = nm.predict(X_test, tsbefile=working_dir+'tsbefile.pkl') + yhat, s2 = nm.predict(X_test, tsbefile=working_dir+'tsbefile.pkl') for i in range(n_features): sorted_idx = X_test[:, i].argsort(axis=0).squeeze() @@ -69,7 +69,7 @@ temp_Y = Y_test[sorted_idx,] temp_be = grp_id_test[sorted_idx, :].squeeze() temp_yhat = yhat[sorted_idx,] - temp_s2 = ys2[sorted_idx,] + temp_s2 = s2[sorted_idx,] plt.figure() for j in range(n_grps): @@ -86,10 +86,10 @@ plt.show() print("Now Estimating on transfer train data ==============================================") - nm.estimate_on_new_sites( + nm.transfer( X_train_transfer, Y_train_transfer, grp_id_train_transfer) print("Now Predicting on transfer test data ==============================================") - yhat, s2 = nm.predict_on_new_sites(X_test_transfer, grp_id_test_transfer) + yhat, s2 = nm.predict_on_new_sites(X = X_test_transfer, batch_effects = grp_id_test_transfer) for i in range(n_features): sorted_idx = X_test_transfer[:, i].argsort(axis=0).squeeze() @@ -97,7 +97,7 @@ temp_Y = Y_test_transfer[sorted_idx,] temp_be = grp_id_test_transfer[sorted_idx, :].squeeze() temp_yhat = yhat[sorted_idx,] - temp_s2 = ys2[sorted_idx,] + temp_s2 = s2[sorted_idx,] for j in range(n_transfer_groups): plt.scatter(temp_X[temp_be == j,], temp_Y[temp_be == j,], diff --git a/tests/test_HBR.ipynb b/tests/test_HBR.ipynb index 45ec901a..b17388dc 100644 --- a/tests/test_HBR.ipynb +++ b/tests/test_HBR.ipynb @@ -7,21 +7,26 @@ "outputs": [], "source": [ "%matplotlib inline\n", - "from IPython.display import clear_output, DisplayHandle\n", + "from IPython.display import DisplayHandle, clear_output\n", + "\n", + "\n", "def update_patch(self, obj):\n", " clear_output(wait=True)\n", " self.display(obj)\n", + "\n", + "\n", "DisplayHandle.update = update_patch\n", - "import os\n", + "from warnings import filterwarnings\n", + "\n", + "import matplotlib.pyplot as plt\n", "import numpy as np\n", + "\n", "from pcntoolkit.normative_model.norm_utils import norm_init\n", "from pcntoolkit.util.utils import simulate_data\n", - "import matplotlib.pyplot as plt\n", - "from pcntoolkit.normative import estimate\n", - "from warnings import filterwarnings\n", - "filterwarnings('ignore')\n", "\n", - "plt.rcParams.update({'font.size': 8, 'figure.figsize': (5, 3)})\n" + "filterwarnings(\"ignore\")\n", + "\n", + "plt.rcParams.update({\"font.size\": 8, \"figure.figsize\": (5, 3)})\n" ] }, { @@ -31,7 +36,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -43,25 +48,33 @@ "name": "stdout", "output_type": "stream", "text": [ - "(80000,)\n" + "(2000,)\n" ] } ], "source": [ "########################### Experiment Settings ###############################\n", "random_state = 29\n", - "working_dir = '/Users/stijndeboer/temp/' # Specify a working directory to save data and results.\n", - "simulation_method = 'linear'\n", - "n_features = 1 # The number of input features of X\n", - "n_grps = 80 # Number of batches in data\n", - "n_samples = 1000 # Number of samples in each group (use a list for different\n", + "working_dir = (\n", + " \"/Users/stijndeboer/temp/\" # Specify a working directory to save data and results.\n", + ")\n", + "simulation_method = \"linear\"\n", + "n_features = 1 # The number of input features of X\n", + "n_grps = 2 # Number of batches in data\n", + "n_samples = 1000 # Number of samples in each group (use a list for different\n", "# sample numbers across different batches)\n", - "model_type = 'bspline' # modelto try 'linear, ''polynomial', 'bspline'\n", + "model_type = \"bspline\" # modelto try 'linear, ''polynomial', 'bspline'\n", "############################## Data Simulation ################################\n", - "X_train, Y_train, grp_id_train, X_test, Y_test, grp_id_test, coef = \\\n", - " simulate_data(simulation_method, n_samples, n_features, n_grps,\n", - " working_dir=working_dir, plot=True, noise='heteroscedastic_nongaussian',\n", - " random_state=random_state)\n", + "X_train, Y_train, grp_id_train, X_test, Y_test, grp_id_test, coef = simulate_data(\n", + " simulation_method,\n", + " n_samples,\n", + " n_features,\n", + " n_grps,\n", + " working_dir=working_dir,\n", + " plot=True,\n", + " noise=\"heteroscedastic_nongaussian\",\n", + " random_state=random_state,\n", + ")\n", "# plt.tight_layout()\n", "# plt.show()\n", "print(Y_train.shape)\n", @@ -69,8 +82,7 @@ "# random_group_offsets = np.random.normal(0, 1, n_grps)\n", "# print(random_group_offsets[grp_id_train])s\n", "# Y_train += np.squeeze(np.array(random_group_offsets[grp_id_train]))\n", - "# Y_test += np.squeeze(np.array(random_group_offsets[grp_id_test]))\n", - "s" + "# Y_test += np.squeeze(np.array(random_group_offsets[grp_id_test]))" ] }, { @@ -79,8 +91,19 @@ "metadata": {}, "outputs": [], "source": [ - "nm = norm_init(X_train, Y_train, alg='hbr', model_type=model_type, likelihood='SHASHb',\n", - " random_intercept_mu='True', random_slope_mu='False', linear_sigma='True', linear_delta='False',linear_epsilon='False', nuts_sampler='nutpie')" + "nm = norm_init(\n", + " X_train,\n", + " Y_train,\n", + " alg=\"hbr\",\n", + " model_type=model_type,\n", + " likelihood=\"SHASHo\",\n", + " random_intercept_mu=\"True\",\n", + " random_slope_mu=\"False\",\n", + " linear_sigma=\"True\",\n", + " linear_delta=\"False\",\n", + " linear_epsilon=\"False\",\n", + " nuts_sampler=\"nutpie\",\n", + ")" ] }, { @@ -100,7 +123,7 @@ " Finished Chains:\n", " 1\n", "

\n", - "

Sampling for an hour

\n", + "

Sampling for 16 seconds

\n", "

\n", " Estimated Time to Completion:\n", " now\n", @@ -131,9 +154,9 @@ " \n", " \n", " 1500\n", - " 0\n", - " 0.02\n", - " 511\n", + " 981\n", + " 0.01\n", + " 120\n", " \n", " \n", " \n", @@ -142,7 +165,7 @@ "\n" ], "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -151,7 +174,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 4, @@ -161,12 +184,12 @@ ], "source": [ "# Graph is constructed here\n", - "nm.estimate(X_train, Y_train, trbefile=working_dir+'trbefile.pkl')" + "nm.estimate(X_train, Y_train, trbefile=working_dir + \"trbefile.pkl\")" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -185,270 +208,63 @@ }, "metadata": {}, "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "

\n",
-       "
\n" - ], - "text/plain": [ - "\n" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ - "yhat, ys2 = nm.predict(X_test, tsbefile=working_dir+'tsbefile.pkl')" + "yhat, ys2 = nm.predict(X_test, tsbefile=working_dir + \"tsbefile.pkl\")" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": {}, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "Sampling: [y_like]\n" - ] - }, - { - "data": { - "text/html": [ - "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
+     "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Sampling: [y_like]\n"
+      "(200, 7)\n"
      ]
     },
     {
      "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
       "text/plain": [
-       "\n"
+       ""
       ]
      },
+     "execution_count": 11,
      "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
+     "output_type": "execute_result"
     },
     {
      "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
+      "image/png": "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",
       "text/plain": [
-       "\n"
+       "
"
       ]
      },
      "metadata": {},
      "output_type": "display_data"
-    },
+    }
+   ],
+   "source": [
+    "resolution = 200\n",
+    "\n",
+    "z_scores = np.arange(-3, 4).astype(np.float32)\n",
+    "z_scores = np.tile(z_scores[None, :], (resolution, 1))\n",
+    "\n",
+    "print(z_scores.shape)\n",
+    "\n",
+    "a = np.tile(np.linspace(0, 0.2, 5)[:, None], (40, 7))\n",
+    "c = z_scores + a\n",
+    "plt.imshow(c)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
@@ -466,19 +282,6 @@
      "metadata": {},
      "output_type": "display_data"
     },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
     {
      "name": "stderr",
      "output_type": "stream",
@@ -498,2122 +301,9 @@
     },
     {
      "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
+      "image/png": "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",
       "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Sampling: [y_like]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n"
-      ],
-      "text/plain": []
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
\n",
-       "
\n"
-      ],
-      "text/plain": [
-       "\n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "
"
+       "
"
       ]
      },
      "metadata": {},
@@ -2621,7 +311,6 @@
     }
    ],
    "source": [
-    "\n",
     "for i in range(n_features):\n",
     "    sorted_idx = X_test[:, i].argsort(axis=0).squeeze()\n",
     "    temp_X = X_test[sorted_idx, i]\n",
@@ -2632,17 +321,17 @@
     "\n",
     "    plt.figure()\n",
     "    for j in range(n_grps):\n",
-    "        scat1 = plt.scatter(temp_X[temp_be == j,], temp_Y[temp_be == j,],\n",
-    "                            label='Group' + str(j))\n",
+    "        scat1 = plt.scatter(\n",
+    "            temp_X[temp_be == j,], temp_Y[temp_be == j,], label=\"Group\" + str(j)\n",
+    "        )\n",
     "        # Showing the quantiles\n",
     "        resolution = 200\n",
     "        synth_X = np.linspace(-4, 4, resolution)\n",
-    "        q = nm.get_mcmc_quantiles(\n",
-    "            synth_X, batch_effects=j*np.ones(resolution))\n",
+    "        q = nm.get_mcmc_quantiles(synth_X, batch_effects=j * np.ones(resolution))\n",
     "        col = scat1.get_facecolors()[0]\n",
-    "        plt.plot(synth_X, q.T,  linewidth=1, color=col, zorder=0)\n",
+    "        plt.plot(synth_X, q.T, linewidth=1, color=col, zorder=0)\n",
     "\n",
-    "    plt.title('Model %s, Feature %d' % (model_type, i))\n",
+    "    plt.title(\"Model %s, Feature %d\" % (model_type, i))\n",
     "    plt.legend()\n",
     "    plt.show()"
    ]
@@ -2678,7 +367,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.7"
+   "version": "3.12.0"
   }
  },
  "nbformat": 4,