diff --git a/mapie/conformity_scores.py b/mapie/conformity_scores.py
index 5d6813153..1f4684e8d 100644
--- a/mapie/conformity_scores.py
+++ b/mapie/conformity_scores.py
@@ -2,6 +2,7 @@
 
 import numpy as np
 
+from .density_ratio import DensityRatioEstimator
 from ._machine_precision import EPSILON
 from ._typing import ArrayLike, NDArray
 
@@ -39,15 +40,40 @@ def __init__(
         self,
         sym: bool,
         consistency_check: bool = True,
+        compute_score_weights: bool = False,
         eps: np.float64 = np.float64(1e-8),
     ):
+        """
+        Parameters
+        ----------
+        sym : bool
+            Whether to consider the conformity score as symmetrical or not.
+        consistency_check : bool, optional
+            Whether to check the consistency between the following methods:
+            - get_estimation_distribution and
+            - get_signed_conformity_scores
+            by default True.
+        compute_score_weights : TODO
+        eps : float, optional
+            Threshold to consider when checking the consistency between the
+            following methods:
+            - get_estimation_distribution and
+            - get_signed_conformity_scores
+            The following equality must be verified:
+            self.get_estimation_distribution(
+                y_pred, self.get_conformity_scores(y, y_pred)
+            ) == y
+            It should be specified if consistency_check==True.
+            by default sys.float_info.epsilon.
+        """
         self.sym = sym
-        self.eps = eps
         self.consistency_check = consistency_check
+        self.compute_score_weights = compute_score_weights
+        self.eps = eps
 
     @abstractmethod
     def get_signed_conformity_scores(
-        self, y: ArrayLike, y_pred: ArrayLike,
+        self, y: ArrayLike, y_pred: ArrayLike, conformity_scores: ArrayLike
     ) -> NDArray:
         """
         Placeholder for get_signed_conformity_scores.
@@ -94,7 +120,10 @@ def get_estimation_distribution(
         """
 
     def check_consistency(
-        self, y: ArrayLike, y_pred: ArrayLike, conformity_scores: ArrayLike
+        self,
+        y: NDArray,
+        y_pred: NDArray,
+        conformity_scores: NDArray,
     ) -> None:
         """
         Check consistency between the following methods:
@@ -111,15 +140,15 @@ def check_consistency(
             Observed values.
         y_pred : NDArray
             Predicted values.
+        conformity_scores: NDArray
+            Conformity scores.
 
         Raises
         ------
         ValueError
             If the two methods are not consistent.
         """
-        score_distribution = self.get_estimation_distribution(
-            y_pred, conformity_scores
-        )
+        score_distribution = self.get_estimation_distribution(y_pred, conformity_scores)
         abs_conformity_scores = np.abs(np.subtract(score_distribution, y))
         max_conf_score = np.max(abs_conformity_scores)
         if max_conf_score > self.eps:
@@ -135,9 +164,23 @@ def check_consistency(
                 "sure that the two methods are consistent."
             )
 
-    def get_conformity_scores(
-        self, y: ArrayLike, y_pred: ArrayLike
-    ) -> NDArray:
+    def get_weights(self, X: NDArray) -> NDArray:
+        """
+        Compute weights for conformity scores on calibration samples.
+
+        Parameters
+        ----------
+        X : NDArray
+            Dataset used for computing the weights
+
+        Returns
+        -------
+        NDArray
+            Estimated weights
+        """
+        return np.ones(shape=(len(X) + 1))
+
+    def get_conformity_scores(self, y: ArrayLike, y_pred: ArrayLike) -> NDArray:
         """
         Get the conformity score considering the symmetrical property if so.
 
@@ -176,7 +219,9 @@ def __init__(self) -> None:
         super().__init__(sym=True, consistency_check=True)
 
     def get_signed_conformity_scores(
-        self, y: ArrayLike, y_pred: ArrayLike,
+        self,
+        y: ArrayLike,
+        y_pred: ArrayLike,
     ) -> NDArray:
         """
         Compute the signed conformity scores from the predicted values
@@ -236,7 +281,9 @@ def _all_strictly_positive(self, y: ArrayLike) -> bool:
         return True
 
     def get_signed_conformity_scores(
-        self, y: ArrayLike, y_pred: ArrayLike,
+        self,
+        y: ArrayLike,
+        y_pred: ArrayLike,
     ) -> NDArray:
         """
         Compute samples of the estimation distribution from the predicted
@@ -258,3 +305,34 @@ def get_estimation_distribution(
         """
         self._check_predicted_data(y_pred)
         return np.multiply(y_pred, np.add(1, conformity_scores))
+
+
+class CovariateShiftConformityScore(ConformityScore):
+    def __init__(
+        self,
+        density_ratio_estimator: DensityRatioEstimator,
+    ) -> None:
+        super().__init__(
+            sym=True,
+            consistency_check=False,
+            compute_score_weights=True,
+        )
+        self.density_ratio_estimator = density_ratio_estimator
+
+    def get_signed_conformity_scores(self, y: NDArray, y_pred: NDArray) -> NDArray:
+        scores = np.subtract(y, y_pred)
+        return scores
+
+    def get_weights(self, X: NDArray) -> NDArray:
+        dre_test = self.density_ratio_estimator.predict(X)  # n_test
+        dre_calib = self.density_ratio_estimator.calib_dr_estimates_  # n_calib
+        denom = dre_calib.sum() + dre_test  # n_test
+        calib_weights = dre_calib[:, np.newaxis] / denom  # (n_calib, n_test)
+        test_weights = dre_test / denom  # n_test
+        weights_stacked = np.vstack([calib_weights, test_weights]).T
+        return weights_stacked  # (n_test, n_calib+1)
+
+    def get_estimation_distribution(
+        self, y_pred: NDArray, conformity_scores: NDArray
+    ) -> NDArray:
+        return np.add(y_pred, conformity_scores)
diff --git a/mapie/density_ratio.py b/mapie/density_ratio.py
new file mode 100644
index 000000000..75c34ccb8
--- /dev/null
+++ b/mapie/density_ratio.py
@@ -0,0 +1,278 @@
+from __future__ import annotations
+
+from typing import Optional
+import numpy as np
+from sklearn.base import ClassifierMixin
+from sklearn.linear_model import LogisticRegression
+from sklearn.pipeline import Pipeline
+from sklearn.utils.validation import check_is_fitted
+from mapie._typing import ArrayLike
+
+
+class DensityRatioEstimator():
+    """ Template class for density ratio estimation. """
+
+    def __init__(self) -> None:
+        raise NotImplementedError
+
+    def fit(self) -> None:
+        raise NotImplementedError
+
+    def predict(self) -> None:
+        raise NotImplementedError
+
+    def check_is_fitted(self) -> None:
+        raise NotImplementedError
+
+
+class ProbClassificationDRE(DensityRatioEstimator):
+    """
+    Density ratio estimation by classification.
+
+    This class implements the density ratio estimation by classification
+    strategy. The broad idea is to first learn a discriminative classifier to
+    distinguish between source and target datasets, and then use the class
+    probability estimates from the classifier to estimate the density ratio.
+
+    Parameters
+    ----------
+    estimator: Optional[ClassifierMixin]
+        Any classifier with scikit-learn API (i.e. with fit, predict, and
+        predict_proba methods), by default ``None``.
+        If ``None``, estimator defaults to a ``LogisticRegression`` instance.
+
+    clip_min: Optional[float]
+        Lower bound the probability estimate from the classifier to
+        ``clip_min``. If ``None``, the estimates are not lower bounded.
+
+        By default ``None``.
+
+    clip_max: Optional[float]
+        Upper bound the probability estimate from the classifier to
+        ``clip_max``. If ``None``, the estimates are not upper bounded.
+
+        By default ``None``.
+
+    Attributes
+    ----------
+    source_prob: float
+        The marginal probability of getting a datapoint from the source
+        distribution.
+
+    target_prob: float
+        The marginal probability of getting a datapoint from the target
+        distribution.
+
+    References
+    ----------
+
+    Examples
+    --------
+
+    """
+
+    def __init__(
+        self,
+        estimator: Optional[ClassifierMixin] = None,
+        clip_min: Optional[float] = None,
+        clip_max: Optional[float] = None,
+    ) -> None:
+
+        self.estimator = self._check_estimator(estimator)
+
+        if clip_max is None:
+            self.clip_max = 1
+        elif all((clip_max >= 0, clip_max <= 1)):
+            self.clip_max = clip_max
+        else:
+            raise ValueError("Expected `clip_max` to be between 0 and 1.")
+
+        if clip_min is None:
+            self.clip_min = 0
+        elif all((clip_min >= 0, clip_min <= clip_max)):
+            self.clip_min = clip_min
+        else:
+            raise ValueError(
+                "Expected `clip_min` to be between 0 and `clip_max`.")
+
+    def _check_estimator(
+        self,
+        estimator: Optional[ClassifierMixin] = None,
+    ) -> ClassifierMixin:
+        """
+        Check if estimator is ``None``,
+        and returns a ``LogisticRegression`` instance if necessary.
+
+        Parameters
+        ----------
+        estimator : Optional[ClassifierMixin], optional
+            Estimator to check, by default ``None``
+
+        Returns
+        -------
+        ClassifierMixin
+            The estimator itself or a default ``LogisticRegression`` instance.
+
+        Raises
+        ------
+        ValueError
+            If the estimator is not ``None``
+            and has no fit, predict, nor predict_proba methods.
+        """
+        if estimator is None:
+            return LogisticRegression(class_weight="balanced", random_state=0)
+
+        if isinstance(estimator, Pipeline):
+            est = estimator[-1]
+        else:
+            est = estimator
+        if (
+            not hasattr(est, "fit")
+            and not hasattr(est, "predict")
+            and not hasattr(est, "predict_proba")
+        ):
+            raise ValueError(
+                "Invalid estimator. "
+                "Please provide a classifier with fit,"
+                "predict, and predict_proba methods."
+            )
+
+        return estimator
+
+    def fit(
+        self,
+        X_source: ArrayLike,
+        X_target: ArrayLike,
+        source_prob: Optional[float] = None,
+        target_prob: Optional[float] = None,
+        sample_weight: Optional[ArrayLike] = None
+    ) -> ProbClassificationDRE:
+        """
+        Fit the discriminative classifier to source and target samples.
+
+        Parameters
+        ----------
+        X_source: ArrayLike of shape (n_source_samples, n_features)
+            Training data.
+
+        X_target: ArrayLike of shape (n_target_samples, n_features)
+            Training data.
+
+        source_prob: Optional[float]
+            The marginal probability of getting a datapoint from the source
+            distribution. If ``None``, the proportion of source examples in
+            the training dataset is used.
+
+            By default ``None``.
+
+        target_prob: Optional[float]
+            The marginal probability of getting a datapoint from the target
+            distribution. If ``None``, the proportion of target examples in
+            the training dataset is used.
+
+            By default ``None``.
+
+        sample_weight : Optional[ArrayLike] of shape (n_source + n_target,)
+            Sample weights for fitting the out-of-fold models.
+            If ``None``, then samples are equally weighted.
+            If some weights are null,
+            their corresponding observations are removed
+            before the fitting process and hence have no prediction sets.
+
+            By default ``None``.
+
+        Returns
+        -------
+        ProbClassificationDRE
+            The density ratio estimator itself.
+        """
+
+        # Find the marginal source and target probability.
+        n_source = X_source.shape[0]
+        n_target = X_target.shape[0]
+
+        if source_prob is None:
+            source_prob = n_source / (n_source + n_target)
+
+        if target_prob is None:
+            target_prob = n_target / (n_source + n_target)
+
+        if source_prob + target_prob != 1:
+            raise ValueError(
+                "``source_prob`` and ``target_prob`` do not add up to 1."
+            )
+
+        self.source_prob = source_prob
+        self.target_prob = target_prob
+
+        # Estimate the conditional probability of source/target given X.
+        X = np.concatenate((X_source, X_target), axis=0)
+        y = np.concatenate((np.zeros(n_source), np.ones(n_target)), axis=0)
+
+        if type(self.estimator) == Pipeline:
+            step_name = self.estimator.steps[-1][0]
+            self.estimator.fit(
+                X, y, **{f'{step_name}__sample_weight': sample_weight}
+            )
+        else:
+            self.estimator.fit(X, y, sample_weight=sample_weight)
+
+        return self
+
+    def predict(
+        self,
+        X: ArrayLike,
+    ) -> ArrayLike:
+        """
+        Predict the density ratio estimates for new samples.
+
+        Parameters
+        ----------
+        X: ArrayLike of shape (n_samples, n_features)
+            Samples to get the density ratio estimates for.
+
+        Returns
+        -------
+        ProbClassificationDRE
+            The density ratio estimtor itself.
+        """
+
+        # Some models in sklearn have predict_proba but not predict_log_proba.
+        if not hasattr(self.estimator, "predict_log_proba"):
+            probs = self.estimator.predict_proba(X)
+            log_probs = np.log(probs)
+        else:
+            log_probs = self.estimator.predict_log_proba(X)
+
+        # Clip prob to mitigate extremely high or low dre.
+        log_probs = np.clip(
+            log_probs, a_min=np.log(self.clip_min), a_max=np.log(self.clip_max)
+        )
+
+        return np.exp(
+            log_probs[:, 1]
+            - log_probs[:, 0]
+            + np.log(self.source_prob)
+            - np.log(self.target_prob)
+        )
+
+    def check_is_fitted(self) -> None:
+        if isinstance(self.estimator, Pipeline):
+            check_is_fitted(self.estimator[-1])
+        else:
+            check_is_fitted(self.estimator)
+
+
+def calculate_ess(weights: ArrayLike) -> float:
+    """
+    Calculates the effective sample size given importance weights for the
+    source distribution.
+
+    Parameters
+    ----------
+    weights: ArrayLike
+        Importance weights for the examples in source distribution.
+    """
+    num = weights.sum()**2
+    denom = (weights**2).sum()
+    return num/denom
diff --git a/mapie/regression.py b/mapie/regression.py
index e02c48967..fc1f6c12e 100644
--- a/mapie/regression.py
+++ b/mapie/regression.py
@@ -20,7 +20,8 @@
                     check_conformity_score, check_cv,
                     check_estimator_fit_predict, check_n_features_in,
                     check_n_jobs, check_nan_in_aposteriori_prediction,
-                    check_null_weight, check_verbose, fit_estimator)
+                    check_null_weight, check_verbose, fit_estimator, weighted_quantile
+)
 
 
 class MapieRegressor(BaseEstimator, RegressorMixin):
@@ -469,6 +470,29 @@ def _pred_multi(self, X: ArrayLike) -> NDArray:
         y_pred_multi = self._aggregate_with_mask(y_pred_multi, self.k_)
         return y_pred_multi
 
+    def _quantile(
+        self,
+        a: ArrayLike,
+        q: ArrayLike,
+        axis: int = 1,
+        method: str = "lower",
+        weights: Optional[ArrayLike] = None
+    ) -> ArrayLike:
+
+        if weights is None:
+            return np_nanquantile(
+                a,
+                q,
+                axis=axis,
+                method=method,
+            )
+        else:
+            return weighted_quantile(
+                a,
+                q,
+                weights=weights
+            )
+
     def fit(
         self,
         X: ArrayLike,
@@ -687,6 +711,20 @@ def predict(
             )
         )
 
+        if self.conformity_score_function_.compute_score_weights:
+            self.score_weights_ = (
+                self.conformity_score_function_.get_weights(X)
+            )
+            lower_bounds = np.hstack(
+                [lower_bounds, np.full((len(X), 1), -np.inf)]
+            )
+            upper_bounds = np.hstack(
+                [upper_bounds, np.full((len(X), 1), np.inf)]
+            )
+
+        else:
+            self.score_weights_ = None
+
         # get desired confidence intervals according to alpha
         y_pred_low = np.column_stack(
             [
@@ -695,6 +733,7 @@ def predict(
                     _alpha,
                     axis=1,
                     method="lower",
+                    weights=self.score_weights_
                 )
                 for _alpha in alpha_np
             ]
@@ -706,6 +745,7 @@ def predict(
                     1 - _alpha,
                     axis=1,
                     method="higher",
+                    weights=self.score_weights_
                 )
                 for _alpha in alpha_np
             ]
diff --git a/mapie/utils.py b/mapie/utils.py
index 4918a2881..38b1916ee 100644
--- a/mapie/utils.py
+++ b/mapie/utils.py
@@ -1041,3 +1041,62 @@ def fix_number_of_classes(
         axis=1
     )
     return y_pred_full
+
+
+def argsort_ties(
+    a: ArrayLike,
+    seed: Optional[int] = None,
+    axis: Optional[int] = None
+) -> ArrayLike:
+    """
+    Returns the indices that would sort the array.
+    In case of ties, breaks them randomly.
+    """
+
+    rng = np.random.default_rng(seed)
+    pseudo_array = rng.random(a.shape)
+    return np.lexsort((pseudo_array, a), axis=axis)
+
+
+def weighted_quantile(
+    a: ArrayLike,
+    q: Iterable[float],
+    axis: int = 1,
+    weights: Optional[ArrayLike] = None,
+    sorted: bool = False,
+) -> ArrayLike:
+    """
+    Calculates the weighted empirical quantile of `values`.
+    Converted to Python from https://github.com/ryantibs/conformal/
+    """
+
+    if a.shape != weights.shape:
+        raise ValueError(
+            "Expected `values` and `weights` to have the same shape.")
+
+    if weights is None:
+        weights = np.ones_like(a, dtype=np.float64)
+    if not sorted:
+        sorted_ind = np.argsort(a, axis=axis)  # argsort_ties(a, axis=-1)
+        a = np.take_along_axis(a, sorted_ind, axis=axis)
+        weights = np.take_along_axis(weights, sorted_ind, axis=axis)
+
+    idx = np.argmin(
+        np.ma.masked_less(
+            np.cumsum(weights, axis=axis)
+            / np.sum(weights, axis=axis)[:, np.newaxis],
+            q
+        ),
+        axis=axis
+    )
+    quantiles = np.take_along_axis(a, idx.reshape(-1, 1), axis=axis)
+    # idx = np.where(
+    #     (np.cumsum(weights, axis=axis) /
+    # np.sum(weights, axis=axis)[:, np.newaxis]) >= q, weights
+    # ) # [0]
+    # np.take_along_axis(a, idx, axis=0)
+    # if idx.shape[0] == 0:
+    #     quantiles = a[-1]
+    # else:
+    #     quantiles = a[idx.min()]
+    return quantiles
diff --git a/notebooks/regression/covariate_shift_regression.ipynb b/notebooks/regression/covariate_shift_regression.ipynb
new file mode 100644
index 000000000..ec831148a
--- /dev/null
+++ b/notebooks/regression/covariate_shift_regression.ipynb
@@ -0,0 +1,986 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This notebook replicates the results of the paper [Conformal Prediction Under Covariate Shift (Tibshirani et al., 2020)](https://arxiv.org/pdf/1904.06019.pd)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from __future__ import annotations\n",
+    "\n",
+    "from copy import deepcopy\n",
+    "\n",
+    "from collections import defaultdict\n",
+    "\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.linear_model import LinearRegression, LogisticRegression\n",
+    "from sklearn.ensemble import RandomForestClassifier\n",
+    "\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "%matplotlib inline\n",
+    "\n",
+    "from mapie._typing import ArrayLike\n",
+    "from mapie.regression import MapieRegressor\n",
+    "from mapie.covariate_shift_regression import MapieCovShiftRegressor\n",
+    "from mapie.density_ratio import ProbClassificationDRE\n",
+    "from mapie.metrics import regression_coverage_score\n",
+    "from mapie.conformity_scores import (\n",
+    "    AbsoluteConformityScore, CovariateShiftConformityScore, ConformityScore\n",
+    ")\n",
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "%matplotlib inline\n",
+    "\n",
+    "palette = sns.color_palette(\"colorblind\")\n",
+    "sns.set_theme(style=\"whitegrid\", palette=palette, font_scale=1.3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Experiment Config"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "NTRIALS = 5000 # Number of times to repeat experiment\n",
+    "SEED = 2022 # Random seed\n",
+    "ALPHA = 0.1 # Targeted marginal coverage \n",
+    "TEST_PROP = 0.5 # Proportion of all data to use as test set\n",
+    "CAL_PROP = 0.5 # Proportion of training data to use for conformal calibration"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Read Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1503, 6)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Frequency</th>\n",
+       "      <th>Angle</th>\n",
+       "      <th>Chord</th>\n",
+       "      <th>Velocity</th>\n",
+       "      <th>Suction</th>\n",
+       "      <th>Sound</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>6.684612</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.3048</td>\n",
+       "      <td>71.3</td>\n",
+       "      <td>-5.928163</td>\n",
+       "      <td>126.201</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>6.907755</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.3048</td>\n",
+       "      <td>71.3</td>\n",
+       "      <td>-5.928163</td>\n",
+       "      <td>125.201</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>7.130899</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.3048</td>\n",
+       "      <td>71.3</td>\n",
+       "      <td>-5.928163</td>\n",
+       "      <td>125.951</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>7.377759</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.3048</td>\n",
+       "      <td>71.3</td>\n",
+       "      <td>-5.928163</td>\n",
+       "      <td>127.591</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>7.600902</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.3048</td>\n",
+       "      <td>71.3</td>\n",
+       "      <td>-5.928163</td>\n",
+       "      <td>127.461</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   Frequency  Angle   Chord  Velocity   Suction    Sound\n",
+       "0   6.684612    0.0  0.3048      71.3 -5.928163  126.201\n",
+       "1   6.907755    0.0  0.3048      71.3 -5.928163  125.201\n",
+       "2   7.130899    0.0  0.3048      71.3 -5.928163  125.951\n",
+       "3   7.377759    0.0  0.3048      71.3 -5.928163  127.591\n",
+       "4   7.600902    0.0  0.3048      71.3 -5.928163  127.461"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "airfoil = pd.read_csv(\n",
+    "    \"https://raw.githubusercontent.com/ryantibs/conformal/master/tibshirani2019/airfoil.txt\",\n",
+    "    sep='\\t', header=None)\n",
+    "airfoil.columns = [\"Frequency\", \"Angle\", \"Chord\", \"Velocity\", \"Suction\", \"Sound\"]\n",
+    "airfoil['Frequency'] = np.log(airfoil['Frequency'])\n",
+    "airfoil['Suction'] = np.log(airfoil['Suction'])\n",
+    "print(airfoil.shape)\n",
+    "airfoil.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Utilities for experiment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_X_y(data):\n",
+    "    return data.values[:, :-1], data.values[:, -1]\n",
+    "\n",
+    "\n",
+    "class OracleDRE():\n",
+    "    def __init__(self, beta: ArrayLike) -> None:\n",
+    "        self.beta = beta\n",
+    "    \n",
+    "    def fit(self) -> OracleDRE:\n",
+    "        return self\n",
+    "    \n",
+    "    def predict(self, X: ArrayLike) -> ArrayLike:\n",
+    "        return np.exp(X @ self.beta)\n",
+    "    \n",
+    "    def check_is_fitted(self) -> bool:\n",
+    "        return True"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Run experiment"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## First check"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Oracle density ratios\n",
+    "oracle_dr_estimator = OracleDRE(beta=np.array([-1, 0, 0, 0, 1]))\n",
+    "oracle_dr = oracle_dr_estimator.predict(get_X_y(airfoil)[0]) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(751, 6) (752, 6) (752,)\n",
+      "(188, 6)\n",
+      "(375, 5) (376, 5) (752, 5) (188, 5)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "LinearRegression()"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Partition into train and test data\n",
+    "train_data, test_data, _, test_oracle_dr = train_test_split(\n",
+    "    airfoil, oracle_dr, test_size=TEST_PROP, random_state=1\n",
+    ")\n",
+    "print(train_data.shape, test_data.shape, test_oracle_dr.shape)\n",
+    "\n",
+    "# Construct shifted data\n",
+    "shift_data = test_data.sample(frac=0.25, replace=True, weights=test_oracle_dr)\n",
+    "print(shift_data.shape)\n",
+    "\n",
+    "# Split into arrays of features and labels\n",
+    "X_train, y_train = get_X_y(train_data)\n",
+    "X_test, y_test = get_X_y(test_data)\n",
+    "X_shift, y_shift = get_X_y(shift_data)\n",
+    "\n",
+    "# Split train into fit and cal set\n",
+    "X_fit, X_cal, y_fit, y_cal = train_test_split(\n",
+    "    X_train, y_train, test_size=CAL_PROP, random_state=1\n",
+    ")\n",
+    "# 4 datasets :\n",
+    "# - X_fit -> dataset used for training the base model\n",
+    "# - X_cal -> dataset used for calibrating the conformity scores\n",
+    "# - X_test -> dataset used for testing the uncertainties\n",
+    "# - X_shift -> shifted version of the test dataset\n",
+    "print(X_fit.shape, X_cal.shape, X_test.shape, X_shift.shape)\n",
+    "\n",
+    "# Fit model to estimate E[Y|X]\n",
+    "model = LinearRegression(fit_intercept=True)\n",
+    "model.fit(X_fit, y_fit)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Fit covariate shift conformal w/ estimated weights\n",
+    "logreg_dr_estimator = ProbClassificationDRE(\n",
+    "    estimator=LogisticRegression(class_weight=\"balanced\", max_iter=1000),\n",
+    "    clip_min=0.01,\n",
+    "    clip_max=0.99\n",
+    ")\n",
+    "logreg_dr_estimator.fit(X_train, X_test, source_prob=0.5, target_prob=0.5)\n",
+    "logreg_dr_estimator.calib_dr_estimates_ = logreg_dr_estimator.predict(X_cal)\n",
+    "covshift_score = CovariateShiftConformityScore(\n",
+    "    density_ratio_estimator=logreg_dr_estimator\n",
+    ")\n",
+    "covshift_logreg_conf = MapieRegressor(\n",
+    "    estimator=model, conformity_score=covshift_score, method=\"base\", cv=\"prefit\")\n",
+    "covshift_logreg_conf.fit(X_cal, y_cal)\n",
+    "y_pred_covshift, y_pis_covshift = covshift_logreg_conf.predict(X_test, alpha=0.1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "covshift_logreg_conf = MapieRegressor(\n",
+    "    estimator=model, conformity_score=covshift_score, method=\"base\", cv=\"prefit\")\n",
+    "covshift_logreg_conf.fit(X_cal, y_cal)\n",
+    "y_pred_covshift, y_pis_covshift = covshift_logreg_conf.predict(X_test, alpha=0.1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mapie = MapieRegressor(\n",
+    "    estimator=model, method=\"base\", cv=\"prefit\")\n",
+    "mapie.fit(X_cal, y_cal)\n",
+    "y_pred, y_pis = mapie.predict(X_test, alpha=0.1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "15.605831533161277 15.605831533161277\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\n",
+    "    (y_pis[:, 1, 0] - y_pis[:, 0, 0]).mean(),\n",
+    "    (y_pis_covshift[:, 1, 0] - y_pis_covshift[:, 0, 0]).mean()\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.9002659574468085 0.9122340425531915\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\n",
+    "    regression_coverage_score(y_test, y_pis[:, 0, 0], y_pis[:, 1, 0]),\n",
+    "    regression_coverage_score(y_test, y_pis_covshift[:, 0, 0], y_pis_covshift[:, 1, 0])\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scores = np.stack([mapie.conformity_scores_ for _ in range(10)])\n",
+    "weights = np.random.uniform(0, 1, scores.shape) #np.ones(shape=scores.shape) / 5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from mapie.utils import weighted_quantile\n",
+    "weighted_quantile_ = weighted_quantile(scores, 0.9, 1, weights)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0.012213975667265231, 14.560134682776564)"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "scores.min(), scores.max()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.lines.Line2D at 0x145b79ab0>"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(scores[0, :])\n",
+    "for i in range(10):\n",
+    "    plt.axvline(weighted_quantile_[i, 0], color=\"C1\")\n",
+    "plt.axvline(np.quantile(scores, 0.9), color=\"C2\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Experiment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5000/5000 [1:41:13<00:00,  1.21s/it]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Make experiment reproducible\n",
+    "np.random.seed(SEED)\n",
+    "\n",
+    "# Track results\n",
+    "results = []\n",
+    "\n",
+    "# Repeat the experiment NTRIALS times\n",
+    "for trial_num in tqdm(range(NTRIALS)):\n",
+    "    \n",
+    "    # Partition into train and test data\n",
+    "    train_data, test_data, _, test_oracle_dr = train_test_split(\n",
+    "        airfoil, oracle_dr, test_size=TEST_PROP, random_state=trial_num\n",
+    "    )\n",
+    "    \n",
+    "    # Construct shifted data\n",
+    "    shift_data = test_data.sample(frac=0.25, replace=True, weights=test_oracle_dr)\n",
+    "    \n",
+    "    # Split into arrays of features and labels\n",
+    "    X_train, y_train = get_X_y(train_data)\n",
+    "    X_test, y_test = get_X_y(test_data)\n",
+    "    X_shift, y_shift = get_X_y(shift_data)\n",
+    "        \n",
+    "    # Split train into fit and cal set\n",
+    "    X_fit, X_cal, y_fit, y_cal = train_test_split(\n",
+    "        X_train, y_train, test_size=CAL_PROP, random_state=trial_num\n",
+    "    )\n",
+    "    # 4 datasets :\n",
+    "    # - X_fit -> dataset used for training the base model\n",
+    "    # - X_cal -> dataset used for calibrating the conformity scores\n",
+    "    # - X_test -> dataset used for testing the uncertainties\n",
+    "    # - X_shift -> shifted version of the test dataset\n",
+    "    # print(X_fit.shape, X_cal.shape, X_test.shape, X_shift.shape)\n",
+    "    \n",
+    "    # Fit model to estimate E[Y|X]\n",
+    "    model = LinearRegression(fit_intercept=True)\n",
+    "    model.fit(X_fit, y_fit)\n",
+    "    \n",
+    "    # Fit naive conformal\n",
+    "    naive_conf = MapieRegressor(estimator=model, method=\"base\", cv=\"prefit\")\n",
+    "    naive_conf.fit(X_cal, y_cal)\n",
+    "    \n",
+    "    for dist_type, test_features, test_labels in [\n",
+    "        (\"In\", X_test, y_test), (\"Out\", X_shift, y_shift)\n",
+    "    ]:\n",
+    "        \n",
+    "        if dist_type == \"In\":\n",
+    "            oracle_dr_estimator = OracleDRE(beta=np.array([0, 0, 0, 0, 0]))\n",
+    "        elif dist_type == \"Out\":\n",
+    "            oracle_dr_estimator = OracleDRE(beta=np.array([-1, 0, 0, 0, 1]))\n",
+    "        oracle_dr_estimator.residuals_dre_ = oracle_dr_estimator.predict(X_cal)\n",
+    "            \n",
+    "        # Fit covariate shift conformal w/ oracle weights\n",
+    "        covshift_oracle_score = CovariateShiftConformityScore(\n",
+    "            density_ratio_estimator=oracle_dr_estimator\n",
+    "        )\n",
+    "        covshift_oracle_conf = MapieRegressor(\n",
+    "            estimator=model, conformity_score=covshift_oracle_score, method=\"base\", cv=\"prefit\")\n",
+    "        covshift_oracle_conf.fit(X_cal, y_cal)\n",
+    "\n",
+    "        # Fit covariate shift conformal w/ estimated weights\n",
+    "        logreg_dr_estimator = ProbClassificationDRE(\n",
+    "            estimator=LogisticRegression(class_weight=\"balanced\", max_iter=1000),\n",
+    "            clip_min=0.01,\n",
+    "            clip_max=0.99\n",
+    "        )\n",
+    "        logreg_dr_estimator.fit(X_train, test_features, source_prob=0.5, target_prob=0.5)\n",
+    "        logreg_dr_estimator.residuals_dre_ = logreg_dr_estimator.predict(X_cal)\n",
+    "        covshift_lr_score = CovariateShiftConformityScore(\n",
+    "            density_ratio_estimator=logreg_dr_estimator\n",
+    "        )\n",
+    "        covshift_logreg_conf = MapieRegressor(\n",
+    "            estimator=model, conformity_score=covshift_lr_score, method=\"base\", cv=\"prefit\")\n",
+    "        covshift_logreg_conf.fit(X_cal, y_cal)\n",
+    "\n",
+    "        rf_dr_estimator = ProbClassificationDRE(\n",
+    "            estimator=RandomForestClassifier(\n",
+    "                n_estimators=500,\n",
+    "                random_state=SEED, \n",
+    "                max_depth=4,\n",
+    "                class_weight=\"balanced\"\n",
+    "            ),\n",
+    "            clip_min=0.01,\n",
+    "            clip_max=0.99\n",
+    "        )\n",
+    "        rf_dr_estimator.fit(X_train, test_features, source_prob=0.5, target_prob=0.5)\n",
+    "        rf_dr_estimator.residuals_dre_ = rf_dr_estimator.predict(X_cal)\n",
+    "        covshift_rf_score = CovariateShiftConformityScore(\n",
+    "            density_ratio_estimator=logreg_dr_estimator\n",
+    "        )\n",
+    "        covshift_rf_conf = MapieRegressor(\n",
+    "            estimator=model, conformity_score=covshift_rf_score, method=\"base\", cv=\"prefit\")\n",
+    "        covshift_rf_conf.fit(X_cal, y_cal)\n",
+    "\n",
+    "        # Predict and calculate metrics\n",
+    "        for name, conf_method in [\n",
+    "            (\"Naive\", naive_conf), \n",
+    "            (\"Weighted Oracle\", covshift_oracle_conf), \n",
+    "            (\"Weighted Logistic Regression\", covshift_logreg_conf), \n",
+    "            (\"Weighted Random Forest\", covshift_rf_conf)\n",
+    "        ]:\n",
+    "            point_pred, set_pred = conf_method.predict(test_features, alpha=ALPHA)\n",
+    "            results.append({\n",
+    "                \"Trial #\": trial_num, \n",
+    "                \"Distribution\": dist_type, \n",
+    "                \"Conformal Method\": name, \n",
+    "                \"Marginal Coverage\": regression_coverage_score(\n",
+    "                    test_labels, set_pred[:, 0], set_pred[:, 1]\n",
+    "                ),\n",
+    "                \"Width\": np.median(set_pred[:, 1] - set_pred[:, 0])\n",
+    "            })\n",
+    "            \n",
+    "results = pd.DataFrame(results)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Trial #</th>\n",
+       "      <th>Distribution</th>\n",
+       "      <th>Conformal Method</th>\n",
+       "      <th>Marginal Coverage</th>\n",
+       "      <th>Width</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0</td>\n",
+       "      <td>In</td>\n",
+       "      <td>Naive</td>\n",
+       "      <td>0.902926</td>\n",
+       "      <td>16.129158</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0</td>\n",
+       "      <td>In</td>\n",
+       "      <td>Weighted Oracle</td>\n",
+       "      <td>0.906915</td>\n",
+       "      <td>16.202551</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>0</td>\n",
+       "      <td>In</td>\n",
+       "      <td>Weighted Logistic Regression</td>\n",
+       "      <td>0.906915</td>\n",
+       "      <td>16.202551</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>0</td>\n",
+       "      <td>In</td>\n",
+       "      <td>Weighted Random Forest</td>\n",
+       "      <td>0.906915</td>\n",
+       "      <td>16.202551</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>0</td>\n",
+       "      <td>Out</td>\n",
+       "      <td>Naive</td>\n",
+       "      <td>0.750000</td>\n",
+       "      <td>16.129158</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>39995</th>\n",
+       "      <td>4999</td>\n",
+       "      <td>In</td>\n",
+       "      <td>Weighted Random Forest</td>\n",
+       "      <td>0.885638</td>\n",
+       "      <td>15.605832</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>39996</th>\n",
+       "      <td>4999</td>\n",
+       "      <td>Out</td>\n",
+       "      <td>Naive</td>\n",
+       "      <td>0.835106</td>\n",
+       "      <td>15.605832</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>39997</th>\n",
+       "      <td>4999</td>\n",
+       "      <td>Out</td>\n",
+       "      <td>Weighted Oracle</td>\n",
+       "      <td>0.893617</td>\n",
+       "      <td>19.323468</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>39998</th>\n",
+       "      <td>4999</td>\n",
+       "      <td>Out</td>\n",
+       "      <td>Weighted Logistic Regression</td>\n",
+       "      <td>0.893617</td>\n",
+       "      <td>19.323468</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>39999</th>\n",
+       "      <td>4999</td>\n",
+       "      <td>Out</td>\n",
+       "      <td>Weighted Random Forest</td>\n",
+       "      <td>0.893617</td>\n",
+       "      <td>19.323468</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>40000 rows × 5 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       Trial # Distribution              Conformal Method  Marginal Coverage  \\\n",
+       "0            0           In                         Naive           0.902926   \n",
+       "1            0           In               Weighted Oracle           0.906915   \n",
+       "2            0           In  Weighted Logistic Regression           0.906915   \n",
+       "3            0           In        Weighted Random Forest           0.906915   \n",
+       "4            0          Out                         Naive           0.750000   \n",
+       "...        ...          ...                           ...                ...   \n",
+       "39995     4999           In        Weighted Random Forest           0.885638   \n",
+       "39996     4999          Out                         Naive           0.835106   \n",
+       "39997     4999          Out               Weighted Oracle           0.893617   \n",
+       "39998     4999          Out  Weighted Logistic Regression           0.893617   \n",
+       "39999     4999          Out        Weighted Random Forest           0.893617   \n",
+       "\n",
+       "           Width  \n",
+       "0      16.129158  \n",
+       "1      16.202551  \n",
+       "2      16.202551  \n",
+       "3      16.202551  \n",
+       "4      16.129158  \n",
+       "...          ...  \n",
+       "39995  15.605832  \n",
+       "39996  15.605832  \n",
+       "39997  19.323468  \n",
+       "39998  19.323468  \n",
+       "39999  19.323468  \n",
+       "\n",
+       "[40000 rows x 5 columns]"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Visualize results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Naive conformal"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### A. Marginal Coverage"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1152x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "naive_results = results[results[\"Conformal Method\"] == \"Naive\"]\n",
+    "mean_mc = naive_results.\\\n",
+    "    groupby(\"Distribution\")[\"Marginal Coverage\"].\\\n",
+    "    agg(\"mean\")\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(16, 8))\n",
+    "\n",
+    "g = sns.histplot(data=naive_results, x=\"Marginal Coverage\",\n",
+    "                 hue=\"Distribution\", ax=ax, binwidth=0.01)\n",
+    "\n",
+    "ymin, ymax = ax.get_ylim()\n",
+    "for i, (k, v) in enumerate(mean_mc.iteritems()):\n",
+    "    ax.vlines(v, ymin, ymax, color=palette[i])\n",
+    "    ax.annotate(f\"{v:.3f}\", (v-0.005, ymax+0.5), color=palette[i])\n",
+    "    \n",
+    "ax.grid(False, axis=\"x\")\n",
+    "ax.set_xlim((0.65, 1))\n",
+    "ax.set_title(\"Marginal coverage of naive conformal method on \"\\\n",
+    "             \"in-distribution and out-of-distribution data.\");"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### B. Average length of prediction sets"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1152x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "mean_width = naive_results.groupby(\"Distribution\")[\"Width\"].agg(\"mean\")\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(16, 10))\n",
+    "\n",
+    "g = sns.histplot(data=naive_results, x=\"Width\", hue=\"Distribution\", \n",
+    "                 ax=ax, binwidth=0.5)\n",
+    "\n",
+    "ymin, ymax = ax.get_ylim()\n",
+    "for i, (k, v) in enumerate(mean_width.iteritems()):\n",
+    "    ax.vlines(v, ymin, ymax, color=palette[i])\n",
+    "    ax.annotate(f\"{v:.3f}\", (v-0.005, ymax+0.5), color=palette[i])\n",
+    "    \n",
+    "ax.grid(False, axis=\"x\")\n",
+    "ax.set_xlim((10, 40))\n",
+    "ax.set_title(\"Average width of naive conformal method on in-distribution \"\\\n",
+    "             \"and out-of-distribution data.\");"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Weighted conformal "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### A. Marginal Coverage "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def mean_line(data, metric_name, color):\n",
+    "    ax = plt.gca()\n",
+    "    metric_mean = data.groupby(\"Distribution\")[metric_name].agg(\"mean\")\n",
+    "    for i, (k, v) in enumerate(metric_mean.iteritems()):\n",
+    "        ax.axvline(v, color=palette[i])    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1241.82x864 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "g = sns.displot(data=results[(results[\"Conformal Method\"] != \"Naive\")],\n",
+    "                row=\"Conformal Method\", x=\"Marginal Coverage\", \n",
+    "                hue=\"Distribution\", height=4, aspect=4, binwidth=0.01)\n",
+    "g.map_dataframe(mean_line, metric_name=\"Marginal Coverage\")\n",
+    "g.map(lambda **kwargs: plt.gca().grid(False, axis=\"x\"))\n",
+    "g.set(xlim=(0.65, 1), \n",
+    "      title=\"Marginal coverage of weighted conformal methods on \"\\\n",
+    "            \"in-distribution and out-of-distribution data.\")\n",
+    "g.refline(x=1-ALPHA, color=\"red\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### B. Average length of prediction sets"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1241.82x864 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "g = sns.displot(data=results[(results[\"Conformal Method\"] != \"Naive\")],\n",
+    "                row=\"Conformal Method\", x=\"Width\", hue=\"Distribution\", \n",
+    "                height=4, aspect=4, binwidth=1)\n",
+    "g.map_dataframe(mean_line, metric_name=\"Width\")\n",
+    "g.map(lambda **kwargs: plt.gca().grid(False, axis=\"x\"))\n",
+    "g.set(xlim=(10, 40),\n",
+    "      title=\"Average width of weighted conformal methods on \"\\\n",
+    "            \"in-distribution and out-of-distribution data.\");"
+   ]
+  }
+ ],
+ "metadata": {
+  "interpreter": {
+   "hash": "c3eb6bba817d93fc1ea0901cfa32e48e7552dd4bdc41141d8d6f2048779cba10"
+  },
+  "kernelspec": {
+   "display_name": "mapie-notebooks",
+   "language": "python",
+   "name": "mapie-notebooks"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}