Regression

Conformal prediction methods for regression tasks.

Conformalizers

mapie.regression.TimeSeriesRegressor

TimeSeriesRegressor(
    estimator: Optional[RegressorMixin] = None,
    method: str = "enbpi",
    cv: Optional[
        Union[int, str, BaseCrossValidator]
    ] = None,
    n_jobs: Optional[int] = None,
    agg_function: Optional[str] = "mean",
    verbose: int = 0,
    conformity_score: Optional[BaseRegressionScore] = None,
    random_state: Optional[Union[int, RandomState]] = None,
)

Bases: _MapieRegressor

Prediction intervals with out-of-fold residuals for time series. This class only has two valid method : "enbpi" or "aci"

The prediction intervals are calibrated on a split of the trained data. Both strategies are estimating prediction intervals on single-output time series.

EnbPI allows you to update conformal scores using the update function. It will replace the oldest one with the newest scores. It will keep the same amount of total scores

Actually, EnbPI only corresponds to TimeSeriesRegressor if the cv argument is of type BlockBootstrap.

The ACI strategy allows you to adapt the conformal inference (i.e the quantile). If the real values are not in the coverage, the size of the intervals will grow. Conversely, if the real values are in the coverage, the size of the intervals will decrease. You can use a gamma coefficient to adjust the strength of the correction. If the quantile is equal to zero, the method will produce an infinite set size.

References

Chen Xu, and Yao Xie. "Conformal prediction for dynamic time-series." https://arxiv.org/abs/2010.09107

Isaac Gibbs, Emmanuel Candes "Adaptive conformal inference under distribution shift" https://proceedings.neurips.cc/paper/2021/file/0d441de75945e5acbc865406fc9a2559-Paper.pdf

Margaux Zaffran et al. "Adaptive Conformal Predictions for Time Series" https://arxiv.org/pdf/2202.07282.pdf

Source code in mapie/regression/time_series_regression.py

def __init__(
    self,
    estimator: Optional[RegressorMixin] = None,
    method: str = "enbpi",
    cv: Optional[Union[int, str, BaseCrossValidator]] = None,
    n_jobs: Optional[int] = None,
    agg_function: Optional[str] = "mean",
    verbose: int = 0,
    conformity_score: Optional[BaseRegressionScore] = None,
    random_state: Optional[Union[int, np.random.RandomState]] = None,
) -> None:
    super().__init__(
        estimator=estimator,
        method=method,
        cv=cv,
        n_jobs=n_jobs,
        agg_function=agg_function,
        verbose=verbose,
        conformity_score=conformity_score,
        random_state=random_state,
    )

conformity_scores property

conformity_scores: NDArray

Returns the conformity scores computed by the fit method on the out-of-resample predictions of the bootstrap ensemble.

RETURNS	DESCRIPTION
NDArray	Array of conformity scores, with shape (n_samples,).

adapt_conformal_inference

adapt_conformal_inference(
    X: ArrayLike,
    y: ArrayLike,
    gamma: float,
    confidence_level: Optional[
        Union[float, Iterable[float]]
    ] = None,
    ensemble: bool = False,
    optimize_beta: bool = False,
) -> TimeSeriesRegressor

Adapt the alpha_t attribute when new data with known labels are available.

PARAMETER	DESCRIPTION
X	Input data. TYPE: ArrayLike
y	Input labels. TYPE: ArrayLike
ensemble	Boolean determining whether the predictions are ensembled or not. If False, predictions are those of the model trained on the whole training set. If True, predictions from perturbed models are aggregated by the aggregation function specified in the agg_function attribute. If cv is "prefit" or "split", ensemble is ignored. By default False. TYPE: bool DEFAULT: False
gamma	Coefficient that decides the correction of the conformal inference. If it equals 0, there are no corrections. TYPE: float
confidence_level	Between 0 and 1, represents the confidence level of the interval. By default None. TYPE: Optional[Union[float, Iterable[float]]] DEFAULT: None
optimize_beta	Whether to optimize the PIs' width or not. By default False. TYPE: bool DEFAULT: False

RETURNS	DESCRIPTION
TimeSeriesRegressor	The model itself.

RAISES	DESCRIPTION
ValueError	If the length of y is greater than the length of the training set.

Source code in mapie/regression/time_series_regression.py

def adapt_conformal_inference(
    self,
    X: ArrayLike,
    y: ArrayLike,
    gamma: float,
    confidence_level: Optional[Union[float, Iterable[float]]] = None,
    ensemble: bool = False,
    optimize_beta: bool = False,
) -> TimeSeriesRegressor:
    """
    Adapt the `alpha_t` attribute when new data with known
    labels are available.

    Parameters
    ----------
    X: ArrayLike of shape (n_samples, n_features)
        Input data.

    y: ArrayLike of shape (n_samples_test,)
        Input labels.

    ensemble: bool
        Boolean determining whether the predictions are ensembled or not.
        If `False`, predictions are those of the model trained on the
        whole training set.
        If `True`, predictions from perturbed models are aggregated by
        the aggregation function specified in the `agg_function`
        attribute.
        If `cv` is `"prefit"` or `"split"`, `ensemble` is ignored.

        By default `False`.

    gamma: float
        Coefficient that decides the correction of the conformal inference.
        If it equals 0, there are no corrections.

    confidence_level: Optional[Union[float, Iterable[float]]]
        Between `0` and `1`, represents the confidence level of the interval.

        By default `None`.

    optimize_beta: bool
        Whether to optimize the PIs' width or not.

        By default `False`.

    Returns
    -------
    TimeSeriesRegressor
        The model itself.

    Raises
    ------
    ValueError
        If the length of `y` is greater than
        the length of the training set.
    """
    if self.method != "aci":
        raise AttributeError(
            "This method can be called only with method='aci', "
            f"not with '{self.method}'."
        )

    check_is_fitted(self)
    self._check_gamma(gamma)
    X, y = cast(NDArray, X), cast(NDArray, y)

    self._get_alpha()
    alpha = self._transform_confidence_level_to_alpha_array(confidence_level)
    if alpha is None:
        alpha = np.array(list(self.current_alpha.keys()))
    alpha_np = cast(NDArray, alpha)

    for x_row, y_row in zip(X, y):
        x = np.expand_dims(x_row, axis=0)
        _, y_pred_bounds = self.predict(
            x,
            ensemble=ensemble,
            confidence_level=1 - alpha_np,
            optimize_beta=optimize_beta,
            allow_infinite_bounds=True,
        )

        for alpha_ix, alpha_0 in enumerate(alpha_np):
            alpha_t = self.current_alpha[alpha_0]

            is_lower_bounded = y_row > y_pred_bounds[:, 0, alpha_ix]
            is_upper_bounded = y_row < y_pred_bounds[:, 1, alpha_ix]
            is_not_bounded = not (is_lower_bounded and is_upper_bounded)

            new_alpha_t = alpha_t + gamma * (alpha_0 - is_not_bounded)
            self.current_alpha[alpha_0] = np.clip(new_alpha_t, 0, 1)

    return self

update

update(
    X: ArrayLike,
    y: ArrayLike,
    ensemble: bool = False,
    confidence_level: Optional[
        Union[float, Iterable[float]]
    ] = None,
    gamma: float = 0.0,
    optimize_beta: bool = False,
) -> TimeSeriesRegressor

Update conformity scores

PARAMETER	DESCRIPTION
X	Input data. TYPE: ArrayLike
y	Input labels. TYPE: ArrayLike
ensemble	Boolean determining whether the predictions are ensembled or not. If False, predictions are those of the model trained on the whole training set. If True, predictions from perturbed models are aggregated by the aggregation function specified in the agg_function attribute. If cv is "prefit" or "split", ensemble is ignored. By default False. TYPE: bool DEFAULT: False
confidence_level	(deprecated) Between 0 and 1, represents the confidence level of the interval. By default None. TYPE: Optional[Union[float, Iterable[float]]] DEFAULT: None
gamma	(deprecated) Coefficient that decides the correction of the conformal inference. If it equals 0, there are no corrections. By default 0.. TYPE: float DEFAULT: 0.0
optimize_beta	(deprecated) Whether to optimize the PIs' width or not. By default False. TYPE: bool DEFAULT: False

RETURNS	DESCRIPTION
TimeSeriesRegressor	The model itself.

RAISES	DESCRIPTION
ValueError	If the length of y is greater than the length of the training set.

Source code in mapie/regression/time_series_regression.py

def update(
    self,
    X: ArrayLike,
    y: ArrayLike,
    ensemble: bool = False,
    confidence_level: Optional[Union[float, Iterable[float]]] = None,
    gamma: float = 0.0,
    optimize_beta: bool = False,
) -> TimeSeriesRegressor:
    """
    Update conformity scores

    Parameters
    ----------
    X: ArrayLike of shape (n_samples, n_features)
        Input data.

    y: ArrayLike of shape (n_samples_test,)
        Input labels.

    ensemble: bool
        Boolean determining whether the predictions are ensembled or not.
        If `False`, predictions are those of the model trained on the
        whole training set.
        If `True`, predictions from perturbed models are aggregated by
        the aggregation function specified in the `agg_function`
        attribute.
        If `cv` is `"prefit"` or `"split"`, `ensemble` is ignored.

        By default `False`.

    confidence_level: Optional[Union[float, Iterable[float]]]
        (deprecated)
        Between `0` and `1`, represents the confidence level of the interval.

        By default `None`.

    gamma: float
        (deprecated)
        Coefficient that decides the correction of the conformal inference.
        If it equals 0, there are no corrections.

        By default `0.`.

    optimize_beta: bool
        (deprecated)
        Whether to optimize the PIs' width or not.

        By default `False`.

    Returns
    -------
    TimeSeriesRegressor
        The model itself.

    Raises
    ------
    ValueError
        If the length of `y` is greater than
        the length of the training set.
    """
    warn("""
    This function behavior has been changed to allow updating the scores even when using ACI.
    Currently the parameters confidence_level and optimize_beta have no effect. They are kept
    for API stability and will be removed in a future release.
    If you want to adapt confidence level, use adapt_conformal_inference instead.
    """)
    self._check_method(self.method)
    if self.method not in ["enbpi", "aci"]:
        raise ValueError(
            f"Invalid method. Allowed values are {self.valid_methods_}."
        )

    return self._update_conformity_scores_with_ensemble(X, y, ensemble=ensemble)

predict

predict(
    X: ArrayLike,
    ensemble: bool = False,
    confidence_level: Optional[
        Union[float, Iterable[float]]
    ] = None,
    optimize_beta: bool = False,
    allow_infinite_bounds: bool = False,
    **predict_params,
) -> Union[NDArray, Tuple[NDArray, NDArray]]

Predict target on new samples with confidence intervals.

PARAMETER	DESCRIPTION
X	Test data. TYPE: ArrayLike
ensemble	Boolean determining whether the predictions are ensembled or not. If False, predictions are those of the model trained on the whole training set. If True, predictions from perturbed models are aggregated by the aggregation function specified in the agg_function attribute. If cv is "prefit" or "split", ensemble is ignored. By default False. TYPE: bool DEFAULT: False
confidence_level	Between 0 and 1, represents the confidence level of the interval. By default None. TYPE: Optional[Union[float, Iterable[float]]] DEFAULT: None
optimize_beta	Whether to optimize the PIs' width or not. By default False. TYPE: bool DEFAULT: False
allow_infinite_bounds	Allow infinite prediction intervals to be produced. TYPE: bool DEFAULT: False
predict_params	Additional predict parameters. TYPE: dict DEFAULT: {}

RETURNS	DESCRIPTION
Union[NDArray, Tuple[NDArray, NDArray]]	NDArray of shape (n_samples,) if alpha is None. Tuple[NDArray, NDArray] of shapes (n_samples,) and (n_samples, 2, n_alpha) if alpha is not None. [:, 0, :]: Lower bound of the prediction interval. [:, 1, :]: Upper bound of the prediction interval.

Source code in mapie/regression/time_series_regression.py

def predict(  # type: ignore[override]
    self,
    X: ArrayLike,
    ensemble: bool = False,
    confidence_level: Optional[Union[float, Iterable[float]]] = None,
    optimize_beta: bool = False,
    allow_infinite_bounds: bool = False,
    **predict_params,
) -> Union[NDArray, Tuple[NDArray, NDArray]]:
    """
    Predict target on new samples with confidence intervals.

    Parameters
    ----------
    X: ArrayLike of shape (n_samples, n_features)
        Test data.

    ensemble: bool
        Boolean determining whether the predictions are ensembled or not.
        If `False`, predictions are those of the model trained on the
        whole training set.
        If `True`, predictions from perturbed models are aggregated by
        the aggregation function specified in the `agg_function`
        attribute.
        If `cv` is `"prefit"` or `"split"`, `ensemble` is ignored.

        By default `False`.

    confidence_level: Optional[Union[float, Iterable[float]]]
        Between `0` and `1`, represents the confidence level of the interval.

        By default `None`.

    optimize_beta: bool
        Whether to optimize the PIs' width or not.

        By default `False`.

    allow_infinite_bounds: bool
        Allow infinite prediction intervals to be produced.

    predict_params : dict
        Additional predict parameters.

    Returns
    -------
    Union[NDArray, Tuple[NDArray, NDArray]]
        - NDArray of shape (n_samples,) if `alpha` is `None`.
        - Tuple[NDArray, NDArray] of shapes (n_samples,) and
          (n_samples, 2, n_alpha) if `alpha` is not `None`.
          - [:, 0, :]: Lower bound of the prediction interval.
          - [:, 1, :]: Upper bound of the prediction interval.
    """
    alpha = self._transform_confidence_level_to_alpha_array(confidence_level)
    if alpha is None:
        super().predict(
            X,
            ensemble=ensemble,
            alpha=alpha,
            optimize_beta=optimize_beta,
            **predict_params,
        )
    if self.method == "aci":
        alpha = self._get_alpha(alpha)

    return super().predict(
        X,
        ensemble=ensemble,
        alpha=alpha,
        optimize_beta=optimize_beta,
        allow_infinite_bounds=allow_infinite_bounds,
        **predict_params,
    )

---

mapie.regression.SplitConformalRegressor

SplitConformalRegressor(
    estimator: RegressorMixin = LinearRegression(),
    confidence_level: Union[float, Iterable[float]] = 0.9,
    conformity_score: Union[
        str, BaseRegressionScore
    ] = "absolute",
    prefit: bool = True,
    n_jobs: Optional[int] = None,
    verbose: int = 0,
)

Computes prediction intervals using the split conformal regression technique:

1. The fit method (optional) fits the base regressor to the training data.
2. The conformalize method estimates the uncertainty of the base regressor by computing conformity scores on the conformalization set.
3. The predict_interval method predicts points and intervals.

PARAMETER	DESCRIPTION
estimator	The base regressor used to predict points. TYPE: RegressorMixin DEFAULT: LinearRegression()
confidence_level	The confidence level(s) for the prediction intervals, indicating the desired coverage probability of the prediction intervals. If a float is provided, it represents a single confidence level. If a list, multiple prediction intervals for each specified confidence level are returned. TYPE: Union[float, List[float]] DEFAULT: 0.9
conformity_score	The method used to compute conformity scores Valid options: "absolute" "gamma" "residual_normalized" Any subclass of BaseRegressionScore A custom score function inheriting from BaseRegressionScore may also be provided. See theory (conformity scores). TYPE: Union[str, BaseRegressionScore] DEFAULT: "absolute"
prefit	If True, the base regressor must be fitted, and the fit method must be skipped. If False, the base regressor will be fitted during the fit method. TYPE: bool DEFAULT: True
n_jobs	The number of jobs to run in parallel when applicable. TYPE: Optional[int] DEFAULT: None
verbose	Controls the verbosity level. Higher values increase the output details. TYPE: int DEFAULT: 0

Examples:

>>> from mapie.regression import SplitConformalRegressor
>>> from mapie.utils import train_conformalize_test_split
>>> from sklearn.datasets import make_regression
>>> from sklearn.linear_model import Ridge

>>> X, y = make_regression(n_samples=500, n_features=2, noise=1.0)
>>> (
...     X_train, X_conformalize, X_test,
...     y_train, y_conformalize, y_test
... ) = train_conformalize_test_split(
...     X, y, train_size=0.6, conformalize_size=0.2, test_size=0.2, random_state=1
... )

>>> mapie_regressor = SplitConformalRegressor(
...     estimator=Ridge(),
...     confidence_level=0.95,
...     prefit=False,
... ).fit(X_train, y_train).conformalize(X_conformalize, y_conformalize)

>>> predicted_points, predicted_intervals = mapie_regressor.predict_interval(X_test)

Source code in mapie/regression/regression.py

def __init__(
    self,
    estimator: RegressorMixin = LinearRegression(),
    confidence_level: Union[float, Iterable[float]] = 0.9,
    conformity_score: Union[str, BaseRegressionScore] = "absolute",
    prefit: bool = True,
    n_jobs: Optional[int] = None,
    verbose: int = 0,
) -> None:
    _check_estimator_fit_predict(estimator)
    self._estimator = estimator
    self._prefit = prefit
    self._is_fitted = prefit
    self._is_conformalized = False
    self._conformity_score = check_and_select_conformity_score(
        conformity_score,
        BaseRegressionScore,
    )

    # Note to developers: to implement this v1 class without touching the
    # v0 backend, we're for now using a hack. We always set cv="prefit",
    # and we fit the estimator if needed. See the .fit method below.
    self._mapie_regressor = _MapieRegressor(
        estimator=self._estimator,
        method="base",
        cv="prefit",
        n_jobs=n_jobs,
        verbose=verbose,
        conformity_score=self._conformity_score,
    )

    self._alphas = _transform_confidence_level_to_alpha_list(confidence_level)
    self._predict_params: dict = {}

conformity_scores property

conformity_scores: NDArray

Returns the conformity scores computed by the conformalize method on the conformalization set.

RETURNS	DESCRIPTION
NDArray	Array of conformity scores, with shape (n_samples,).

fit

fit(
    X_train: ArrayLike,
    y_train: ArrayLike,
    fit_params: Optional[dict] = None,
) -> SplitConformalRegressor

Fits the base regressor to the training data.

PARAMETER	DESCRIPTION
X_train	Training data features. TYPE: ArrayLike
y_train	Training data targets. TYPE: ArrayLike
fit_params	Parameters to pass to the fit method of the base regressor. TYPE: Optional[dict] DEFAULT: None

RETURNS	DESCRIPTION
Self	The fitted SplitConformalRegressor instance.

Source code in mapie/regression/regression.py

def fit(
    self,
    X_train: ArrayLike,
    y_train: ArrayLike,
    fit_params: Optional[dict] = None,
) -> SplitConformalRegressor:
    """
    Fits the base regressor to the training data.

    Parameters
    ----------
    X_train : ArrayLike
        Training data features.

    y_train : ArrayLike
        Training data targets.

    fit_params : Optional[dict], default=None
        Parameters to pass to the `fit` method of the base regressor.

    Returns
    -------
    Self
        The fitted SplitConformalRegressor instance.
    """
    _raise_error_if_fit_called_in_prefit_mode(self._prefit)
    _raise_error_if_method_already_called("fit", self._is_fitted)

    cloned_estimator = clone(self._estimator)
    fit_params_ = _prepare_params(fit_params)
    _fit_estimator(cloned_estimator, X_train, y_train, **fit_params_)
    self._mapie_regressor.estimator = cloned_estimator

    self._is_fitted = True
    return self

conformalize

conformalize(
    X_conformalize: ArrayLike,
    y_conformalize: ArrayLike,
    predict_params: Optional[dict] = None,
) -> SplitConformalRegressor

Estimates the uncertainty of the base regressor by computing conformity scores on the conformalization set.

PARAMETER	DESCRIPTION
X_conformalize	Features of the conformalization set. TYPE: ArrayLike
y_conformalize	Targets of the conformalization set. TYPE: ArrayLike
predict_params	Parameters to pass to the predict method of the base regressor. These parameters will also be used in the predict_interval and predict methods of this SplitConformalRegressor. TYPE: Optional[dict] DEFAULT: None

RETURNS	DESCRIPTION
Self	The conformalized SplitConformalRegressor instance.

Source code in mapie/regression/regression.py

def conformalize(
    self,
    X_conformalize: ArrayLike,
    y_conformalize: ArrayLike,
    predict_params: Optional[dict] = None,
) -> SplitConformalRegressor:
    """
    Estimates the uncertainty of the base regressor by computing
    conformity scores on the conformalization set.

    Parameters
    ----------
    X_conformalize : ArrayLike
        Features of the conformalization set.

    y_conformalize : ArrayLike
        Targets of the conformalization set.

    predict_params : Optional[dict], default=None
        Parameters to pass to the `predict` method of the base regressor.
        These parameters will also be used in the `predict_interval`
        and `predict` methods of this SplitConformalRegressor.

    Returns
    -------
    Self
        The conformalized SplitConformalRegressor instance.
    """
    _raise_error_if_previous_method_not_called(
        "conformalize",
        "fit",
        self._is_fitted,
    )
    _raise_error_if_method_already_called(
        "conformalize",
        self._is_conformalized,
    )

    self._predict_params = _prepare_params(predict_params)
    self._mapie_regressor.fit(
        X_conformalize, y_conformalize, predict_params=self._predict_params
    )

    self._is_conformalized = True
    return self

predict_interval

predict_interval(
    X: ArrayLike,
    minimize_interval_width: bool = False,
    allow_infinite_bounds: bool = False,
) -> Tuple[NDArray, NDArray]

Predicts points (using the base regressor) and intervals.

If several confidence levels were provided during initialisation, several intervals will be predicted for each sample. See the return signature.

PARAMETER	DESCRIPTION
X	Features TYPE: ArrayLike
minimize_interval_width	If True, attempts to minimize the intervals width. TYPE: bool DEFAULT: False
allow_infinite_bounds	If True, allows prediction intervals with infinite bounds. TYPE: bool DEFAULT: False

RETURNS	DESCRIPTION
Tuple[NDArray, NDArray]	Two arrays: Prediction points, of shape (n_samples,) Prediction intervals, of shape (n_samples, 2, n_confidence_levels)

Source code in mapie/regression/regression.py

def predict_interval(
    self,
    X: ArrayLike,
    minimize_interval_width: bool = False,
    allow_infinite_bounds: bool = False,
) -> Tuple[NDArray, NDArray]:
    """
    Predicts points (using the base regressor) and intervals.

    If several confidence levels were provided during initialisation, several
    intervals will be predicted for each sample. See the return signature.

    Parameters
    ----------
    X : ArrayLike
        Features

    minimize_interval_width : bool, default=False
        If True, attempts to minimize the intervals width.

    allow_infinite_bounds : bool, default=False
        If True, allows prediction intervals with infinite bounds.

    Returns
    -------
    Tuple[NDArray, NDArray]
        Two arrays:

        - Prediction points, of shape `(n_samples,)`
        - Prediction intervals, of shape `(n_samples, 2, n_confidence_levels)`
    """
    _raise_error_if_previous_method_not_called(
        "predict_interval",
        "conformalize",
        self._is_conformalized,
    )
    predictions = self._mapie_regressor.predict(
        X,
        alpha=self._alphas,
        optimize_beta=minimize_interval_width,
        allow_infinite_bounds=allow_infinite_bounds,
        **self._predict_params,
    )
    return _cast_predictions_to_ndarray_tuple(predictions)

predict

predict(X: ArrayLike) -> NDArray

Predicts points.

PARAMETER	DESCRIPTION
X	Features TYPE: ArrayLike

RETURNS	DESCRIPTION
NDArray	Array of point predictions, with shape (n_samples,).

Source code in mapie/regression/regression.py

def predict(
    self,
    X: ArrayLike,
) -> NDArray:
    """
    Predicts points.

    Parameters
    ----------
    X : ArrayLike
        Features

    Returns
    -------
    NDArray
        Array of point predictions, with shape (n_samples,).
    """
    _raise_error_if_previous_method_not_called(
        "predict",
        "conformalize",
        self._is_conformalized,
    )
    predictions = self._mapie_regressor.predict(
        X, alpha=None, **self._predict_params
    )
    return _cast_point_predictions_to_ndarray(predictions)

---

mapie.regression.CrossConformalRegressor

CrossConformalRegressor(
    estimator: RegressorMixin = LinearRegression(),
    confidence_level: Union[float, Iterable[float]] = 0.9,
    conformity_score: Union[
        str, BaseRegressionScore
    ] = "absolute",
    method: str = "plus",
    cv: Union[int, BaseCrossValidator] = 5,
    n_jobs: Optional[int] = None,
    verbose: int = 0,
    random_state: Optional[Union[int, RandomState]] = None,
)

Computes prediction intervals using the cross conformal regression technique:

1. The fit_conformalize method estimates the uncertainty of the base regressor in a cross-validation style. It fits the base regressor on folds of the dataset and computes conformity scores on the out-of-fold data.
2. The predict_interval computes prediction points and intervals.

PARAMETER	DESCRIPTION
estimator	The base regressor used to predict points. TYPE: RegressorMixin DEFAULT: LinearRegression()
confidence_level	The confidence level(s) for the prediction intervals, indicating the desired coverage probability of the prediction intervals. If a float is provided, it represents a single confidence level. If a list, multiple prediction intervals for each specified confidence level are returned. TYPE: Union[float, List[float]] DEFAULT: 0.9
conformity_score	The method used to compute conformity scores Valid options: "absolute" "gamma" The corresponding subclasses of BaseRegressionScore A custom score function inheriting from BaseRegressionScore may also be provided. See theory (conformity scores). TYPE: Union[str, BaseRegressionScore] DEFAULT: "absolute"
method	The method used to compute prediction intervals. Options are: "base": Based on the conformity scores from each fold. "plus": Based on the conformity scores from each fold and the test set predictions. "minmax": Based on the conformity scores from each fold and the test set predictions, using the minimum and maximum among each fold models. TYPE: str DEFAULT: "plus"
cv	The cross-validator used to compute conformity scores. Valid options: integer, to specify the number of folds any sklearn.model_selection.BaseCrossValidator suitable for regression, or a custom cross-validator inheriting from it. Main variants in the cross conformal setting are: sklearn.model_selection.KFold (vanilla cross conformal) sklearn.model_selection.LeaveOneOut (jackknife) TYPE: Union[int, BaseCrossValidator] DEFAULT: 5
n_jobs	The number of jobs to run in parallel when applicable. TYPE: Optional[int] DEFAULT: None
verbose	Controls the verbosity level. Higher values increase the output details. TYPE: int DEFAULT: 0
random_state	A seed or random state instance to ensure reproducibility in any random operations within the regressor. TYPE: Optional[Union[int, RandomState]] DEFAULT: None

Examples:

>>> from mapie.regression import CrossConformalRegressor
>>> from sklearn.datasets import make_regression
>>> from sklearn.model_selection import train_test_split
>>> from sklearn.linear_model import Ridge

>>> X_full, y_full = make_regression(n_samples=500,n_features=2,noise=1.0)
>>> X, X_test, y, y_test = train_test_split(X_full, y_full)

>>> mapie_regressor = CrossConformalRegressor(
...     estimator=Ridge(),
...     confidence_level=0.95,
...     cv=10
... ).fit_conformalize(X, y)

>>> predicted_points, predicted_intervals = mapie_regressor.predict_interval(X_test)

Source code in mapie/regression/regression.py

def __init__(
    self,
    estimator: RegressorMixin = LinearRegression(),
    confidence_level: Union[float, Iterable[float]] = 0.9,
    conformity_score: Union[str, BaseRegressionScore] = "absolute",
    method: str = "plus",
    cv: Union[int, BaseCrossValidator] = 5,
    n_jobs: Optional[int] = None,
    verbose: int = 0,
    random_state: Optional[Union[int, np.random.RandomState]] = None,
) -> None:
    _check_if_param_in_allowed_values(
        method, "method", CrossConformalRegressor._VALID_METHODS
    )
    _check_cv_not_string(cv)
    _check_cv_not_subsample(cv)

    self._mapie_regressor = _MapieRegressor(
        estimator=estimator,
        method=method,
        cv=cv,
        n_jobs=n_jobs,
        verbose=verbose,
        conformity_score=check_and_select_conformity_score(
            conformity_score,
            BaseRegressionScore,
        ),
        random_state=random_state,
    )

    self._alphas = _transform_confidence_level_to_alpha_list(confidence_level)
    self.is_fitted_and_conformalized = False

    self._predict_params: dict = {}

conformity_scores property

conformity_scores: NDArray

Returns the conformity scores computed by the fit_conformalize method, on the out-of-fold predictions produced during cross-validation.

RETURNS	DESCRIPTION
NDArray	Array of conformity scores, with shape (n_samples,).

reset

reset() -> CrossConformalRegressor

Discard previously computed conformity scores so that fit_conformalize can be called again with new data.

RETURNS	DESCRIPTION
Self	This CrossConformalRegressor instance, reset to its pre-fit state.

Source code in mapie/regression/regression.py

def reset(self) -> CrossConformalRegressor:
    """
    Discard previously computed conformity scores so that
    `fit_conformalize` can be called again with new data.

    Returns
    -------
    Self
        This CrossConformalRegressor instance, reset to its pre-fit state.
    """
    self.is_fitted_and_conformalized = False
    self._predict_params = {}
    return self

fit_conformalize

fit_conformalize(
    X: ArrayLike,
    y: ArrayLike,
    groups: Optional[ArrayLike] = None,
    fit_params: Optional[dict] = None,
    predict_params: Optional[dict] = None,
) -> CrossConformalRegressor

Estimates the uncertainty of the base regressor in a cross-validation style: fits the base regressor on different folds of the dataset and computes conformity scores on the corresponding out-of-fold data.

If called on an instance that has already been fitted, a UserWarning is emitted and the previously computed conformity scores are discarded before the new fit. Call reset() explicitly to suppress the warning.

PARAMETER	DESCRIPTION
X	Features TYPE: ArrayLike
y	Targets TYPE: ArrayLike
groups	Groups to pass to the cross-validator. TYPE: Optional[ArrayLike] DEFAULT: None
fit_params	Parameters to pass to the fit method of the base regressor. TYPE: Optional[dict] DEFAULT: None
predict_params	Parameters to pass to the predict method of the base regressor. These parameters will also be used in the predict_interval and predict methods of this CrossConformalRegressor. TYPE: Optional[dict] DEFAULT: None

RETURNS	DESCRIPTION
Self	This CrossConformalRegressor instance, fitted and conformalized.

Source code in mapie/regression/regression.py

def fit_conformalize(
    self,
    X: ArrayLike,
    y: ArrayLike,
    groups: Optional[ArrayLike] = None,
    fit_params: Optional[dict] = None,
    predict_params: Optional[dict] = None,
) -> CrossConformalRegressor:
    """
    Estimates the uncertainty of the base regressor in a cross-validation style:
    fits the base regressor on different folds of the dataset
    and computes conformity scores on the corresponding out-of-fold data.

    If called on an instance that has already been fitted, a `UserWarning` is
    emitted and the previously computed conformity scores are discarded before
    the new fit. Call `reset()` explicitly to suppress the warning.

    Parameters
    ----------
    X : ArrayLike
        Features

    y : ArrayLike
        Targets

    groups: Optional[ArrayLike] of shape (n_samples,), default=None
        Groups to pass to the cross-validator.

    fit_params : Optional[dict], default=None
        Parameters to pass to the `fit` method of the base regressor.

    predict_params : Optional[dict], default=None
        Parameters to pass to the `predict` method of the base regressor.
        These parameters will also be used in the `predict_interval`
        and `predict` methods of this CrossConformalRegressor.

    Returns
    -------
    Self
        This CrossConformalRegressor instance, fitted and conformalized.
    """
    if self.is_fitted_and_conformalized:
        warnings.warn(
            "CrossConformalRegressor.fit_conformalize was already called; "
            "conformity scores from the previous fit will be discarded. "
            "Call .reset() explicitly before fit_conformalize to suppress "
            "this warning.",
            UserWarning,
            stacklevel=2,
        )
        self.reset()

    fit_params_ = _prepare_params(fit_params)
    self._predict_params = _prepare_params(predict_params)
    self._mapie_regressor.fit(
        X,
        y,
        groups=groups,
        fit_params=fit_params_,
        predict_params=self._predict_params,
    )

    self.is_fitted_and_conformalized = True
    return self

predict_interval

predict_interval(
    X: ArrayLike,
    aggregate_point_predictions: Optional[str] = "mean",
    minimize_interval_width: bool = False,
    allow_infinite_bounds: bool = False,
    aggregate_predictions: Any = _UNSET,
) -> Tuple[NDArray, NDArray]

Predicts points and intervals.

If several confidence levels were provided during initialisation, several intervals will be predicted for each sample. See the return signature.

By default, points are predicted using an aggregation. See the aggregate_point_predictions parameter.

PARAMETER	DESCRIPTION
X	Features TYPE: ArrayLike
aggregate_point_predictions	The method to predict a point. Options: None: a point is predicted using the regressor trained on the entire data "mean": Averages the predictions of the regressors trained on each cross-validation fold "median": Aggregates (using median) the predictions of the regressors trained on each cross-validation fold TYPE: Optional[str] DEFAULT: "mean"
minimize_interval_width	If True, attempts to minimize the interval width. TYPE: bool DEFAULT: False
allow_infinite_bounds	If True, allows prediction intervals with infinite bounds. TYPE: bool DEFAULT: False
aggregate_predictions	.. deprecated:: Renamed to aggregate_point_predictions. Passing aggregate_predictions still works but emits a FutureWarning and will be removed in a future release. TYPE: Optional[str] DEFAULT: _UNSET

RETURNS	DESCRIPTION
Tuple[NDArray, NDArray]	Two arrays: Prediction points, of shape (n_samples,) Prediction intervals, of shape (n_samples, 2, n_confidence_levels)

Source code in mapie/regression/regression.py

def predict_interval(
    self,
    X: ArrayLike,
    aggregate_point_predictions: Optional[str] = "mean",
    minimize_interval_width: bool = False,
    allow_infinite_bounds: bool = False,
    aggregate_predictions: Any = _UNSET,
) -> Tuple[NDArray, NDArray]:
    """
    Predicts points and intervals.

    If several confidence levels were provided during initialisation, several
    intervals will be predicted for each sample. See the return signature.

    By default, points are predicted using an aggregation.
    See the `aggregate_point_predictions` parameter.

    Parameters
    ----------
    X : ArrayLike
        Features

    aggregate_point_predictions : Optional[str], default="mean"
        The method to predict a point. Options:

        - None: a point is predicted using the regressor trained on the entire data
        - "mean": Averages the predictions of the regressors trained on each
          cross-validation fold
        - "median": Aggregates (using median) the predictions of the regressors
          trained on each cross-validation fold

    minimize_interval_width : bool, default=False
        If True, attempts to minimize the interval width.

    allow_infinite_bounds : bool, default=False
        If True, allows prediction intervals with infinite bounds.

    aggregate_predictions : Optional[str]
        .. deprecated::
            Renamed to `aggregate_point_predictions`. Passing
            `aggregate_predictions` still works but emits a
            `FutureWarning` and will be removed in a future release.

    Returns
    -------
    Tuple[NDArray, NDArray]
        Two arrays:

        - Prediction points, of shape `(n_samples,)`
        - Prediction intervals, of shape `(n_samples, 2, n_confidence_levels)`
    """
    aggregate_point_predictions = _resolve_renamed_parameter(
        "aggregate_point_predictions",
        aggregate_point_predictions,
        "aggregate_predictions",
        aggregate_predictions,
    )
    _raise_error_if_previous_method_not_called(
        "predict_interval",
        "fit_conformalize",
        self.is_fitted_and_conformalized,
    )

    ensemble = self._set_aggregate_point_predictions_and_return_ensemble(
        aggregate_point_predictions
    )
    predictions = self._mapie_regressor.predict(
        X,
        alpha=self._alphas,
        optimize_beta=minimize_interval_width,
        allow_infinite_bounds=allow_infinite_bounds,
        ensemble=ensemble,
        **self._predict_params,
    )
    return _cast_predictions_to_ndarray_tuple(predictions)

predict

predict(
    X: ArrayLike,
    aggregate_point_predictions: Optional[str] = "mean",
    aggregate_predictions: Any = _UNSET,
) -> NDArray

Predicts points.

By default, points are predicted using an aggregation. See the aggregate_point_predictions parameter.

PARAMETER	DESCRIPTION
X	Features TYPE: ArrayLike
aggregate_point_predictions	The method to predict a point. Options: None: a point is predicted using the regressor trained on the entire data "mean": Averages the predictions of the regressors trained on each cross-validation fold "median": Aggregates (using median) the predictions of the regressors trained on each cross-validation fold TYPE: Optional[str] DEFAULT: "mean"
aggregate_predictions	.. deprecated:: Renamed to aggregate_point_predictions. Passing aggregate_predictions still works but emits a FutureWarning and will be removed in a future release. TYPE: Optional[str] DEFAULT: _UNSET

RETURNS	DESCRIPTION
NDArray	Array of point predictions, with shape (n_samples,).

Source code in mapie/regression/regression.py

def predict(
    self,
    X: ArrayLike,
    aggregate_point_predictions: Optional[str] = "mean",
    aggregate_predictions: Any = _UNSET,
) -> NDArray:
    """
    Predicts points.

    By default, points are predicted using an aggregation.
    See the `aggregate_point_predictions` parameter.

    Parameters
    ----------
    X : ArrayLike
        Features

    aggregate_point_predictions : Optional[str], default="mean"
        The method to predict a point. Options:

        - None: a point is predicted using the regressor trained on the entire data
        - "mean": Averages the predictions of the regressors trained on each
          cross-validation fold
        - "median": Aggregates (using median) the predictions of the regressors
          trained on each cross-validation fold

    aggregate_predictions : Optional[str]
        .. deprecated::
            Renamed to `aggregate_point_predictions`. Passing
            `aggregate_predictions` still works but emits a
            `FutureWarning` and will be removed in a future release.

    Returns
    -------
    NDArray
        Array of point predictions, with shape `(n_samples,)`.
    """
    aggregate_point_predictions = _resolve_renamed_parameter(
        "aggregate_point_predictions",
        aggregate_point_predictions,
        "aggregate_predictions",
        aggregate_predictions,
    )
    _raise_error_if_previous_method_not_called(
        "predict",
        "fit_conformalize",
        self.is_fitted_and_conformalized,
    )

    ensemble = self._set_aggregate_point_predictions_and_return_ensemble(
        aggregate_point_predictions
    )
    predictions = self._mapie_regressor.predict(
        X,
        alpha=None,
        ensemble=ensemble,
        **self._predict_params,
    )
    return _cast_point_predictions_to_ndarray(predictions)

---

mapie.regression.JackknifeAfterBootstrapRegressor

JackknifeAfterBootstrapRegressor(
    estimator: RegressorMixin = LinearRegression(),
    confidence_level: Union[float, Iterable[float]] = 0.9,
    conformity_score: Union[
        str, BaseRegressionScore
    ] = "absolute",
    method: str = "plus",
    resampling: Union[int, Subsample] = 30,
    aggregation_method: str = "mean",
    n_jobs: Optional[int] = None,
    verbose: int = 0,
    random_state: Optional[Union[int, RandomState]] = None,
)

Computes prediction intervals using the jackknife-after-bootstrap technique:

1. The fit_conformalize method estimates the uncertainty of the base regressor using bootstrap sampling. It fits the base regressor on samples of the dataset and computes conformity scores on the out-of-sample data.
2. The predict_interval computes prediction points and intervals.

PARAMETER	DESCRIPTION
estimator	The base regressor used to predict points. TYPE: RegressorMixin DEFAULT: LinearRegression()
confidence_level	The confidence level(s) for the prediction intervals, indicating the desired coverage probability of the prediction intervals. If a float is provided, it represents a single confidence level. If a list, multiple prediction intervals for each specified confidence level are returned. TYPE: Union[float, List[float]] DEFAULT: 0.9
conformity_score	The method used to compute conformity scores Valid options: "absolute" "gamma" The corresponding subclasses of BaseRegressionScore A custom score function inheriting from BaseRegressionScore may also be provided. See theory (conformity scores). TYPE: Union[str, BaseRegressionScore] DEFAULT: "absolute"
method	The method used to compute prediction intervals. Options are: "plus": Based on the conformity scores from each bootstrap sample and the testing prediction. "minmax": Based on the minimum and maximum conformity scores from each bootstrap sample. Note: The "base" method is not mentioned in the conformal inference literature for Jackknife after bootstrap strategies, hence not provided here. TYPE: str DEFAULT: "plus"
resampling	Number of bootstrap resamples or an instance of Subsample for custom sampling strategy. TYPE: Union[int, Subsample] DEFAULT: 30
aggregation_method	Aggregation method for predictions across bootstrap samples. Options: "mean" "median" TYPE: str DEFAULT: "mean"
n_jobs	The number of jobs to run in parallel when applicable. TYPE: Optional[int] DEFAULT: None
verbose	Controls the verbosity level. Higher values increase the output details. TYPE: int DEFAULT: 0
random_state	A seed or random state instance to ensure reproducibility in any random operations within the regressor. TYPE: Optional[Union[int, RandomState]] DEFAULT: None

Examples:

>>> from mapie.regression import JackknifeAfterBootstrapRegressor
>>> from sklearn.datasets import make_regression
>>> from sklearn.model_selection import train_test_split
>>> from sklearn.linear_model import Ridge

>>> X_full, y_full = make_regression(n_samples=500,n_features=2,noise=1.0)
>>> X, X_test, y, y_test = train_test_split(X_full, y_full)

>>> mapie_regressor = JackknifeAfterBootstrapRegressor(
...     estimator=Ridge(),
...     confidence_level=0.95,
...     resampling=25,
... ).fit_conformalize(X, y)

>>> predicted_points, predicted_intervals = mapie_regressor.predict_interval(X_test)

Source code in mapie/regression/regression.py

def __init__(
    self,
    estimator: RegressorMixin = LinearRegression(),
    confidence_level: Union[float, Iterable[float]] = 0.9,
    conformity_score: Union[str, BaseRegressionScore] = "absolute",
    method: str = "plus",
    resampling: Union[int, Subsample] = 30,
    aggregation_method: str = "mean",
    n_jobs: Optional[int] = None,
    verbose: int = 0,
    random_state: Optional[Union[int, np.random.RandomState]] = None,
) -> None:
    _check_if_param_in_allowed_values(
        method, "method", JackknifeAfterBootstrapRegressor._VALID_METHODS
    )
    _check_if_param_in_allowed_values(
        aggregation_method,
        "aggregation_method",
        JackknifeAfterBootstrapRegressor._VALID_AGGREGATION_METHODS,
    )

    cv = self._check_and_convert_resampling_to_cv(resampling, random_state)

    self._mapie_regressor = _MapieRegressor(
        estimator=estimator,
        method=method,
        cv=cv,
        n_jobs=n_jobs,
        verbose=verbose,
        agg_function=aggregation_method,
        conformity_score=check_and_select_conformity_score(
            conformity_score,
            BaseRegressionScore,
        ),
        random_state=random_state,
    )

    self._alphas = _transform_confidence_level_to_alpha_list(confidence_level)

    self.is_fitted_and_conformalized = False
    self._predict_params: dict = {}

conformity_scores property

conformity_scores: NDArray

Returns the conformity scores computed by the fit_conformalize method, on the out-of-fold predictions produced during cross-validation.

RETURNS	DESCRIPTION
NDArray	Array of conformity scores, with shape (n_samples,).

reset

reset() -> JackknifeAfterBootstrapRegressor

Discard previously computed conformity scores so that fit_conformalize can be called again with new data.

RETURNS	DESCRIPTION
Self	This JackknifeAfterBootstrapRegressor instance, reset to its pre-fit state.

Source code in mapie/regression/regression.py

def reset(self) -> JackknifeAfterBootstrapRegressor:
    """
    Discard previously computed conformity scores so that
    `fit_conformalize` can be called again with new data.

    Returns
    -------
    Self
        This JackknifeAfterBootstrapRegressor instance, reset to its
        pre-fit state.
    """
    self.is_fitted_and_conformalized = False
    self._predict_params = {}
    return self

fit_conformalize

fit_conformalize(
    X: ArrayLike,
    y: ArrayLike,
    fit_params: Optional[dict] = None,
    predict_params: Optional[dict] = None,
) -> JackknifeAfterBootstrapRegressor

Estimates the uncertainty of the base regressor using bootstrap sampling: fits the base regressor on (potentially overlapping) samples of the dataset, and computes conformity scores on the corresponding out of samples data.

If called on an instance that has already been fitted, a UserWarning is emitted and the previously computed conformity scores are discarded before the new fit. Call reset() explicitly to suppress the warning.

PARAMETER	DESCRIPTION
X	Features. Must be the same X used in .fit TYPE: ArrayLike
y	Targets. Must be the same y used in .fit TYPE: ArrayLike
fit_params	Parameters to pass to the fit method of the base regressor. TYPE: Optional[dict] DEFAULT: None
predict_params	Parameters to pass to the predict method of the base regressor. These parameters will also be used in the predict_interval and predict methods of this JackknifeAfterBootstrapRegressor. TYPE: Optional[dict] DEFAULT: None

RETURNS	DESCRIPTION
Self	This JackknifeAfterBootstrapRegressor instance, fitted and conformalized.

Source code in mapie/regression/regression.py

def fit_conformalize(
    self,
    X: ArrayLike,
    y: ArrayLike,
    fit_params: Optional[dict] = None,
    predict_params: Optional[dict] = None,
) -> JackknifeAfterBootstrapRegressor:
    """
    Estimates the uncertainty of the base regressor using bootstrap sampling:
    fits the base regressor on (potentially overlapping) samples of the dataset,
    and computes conformity scores on the corresponding out of samples data.

    If called on an instance that has already been fitted, a `UserWarning` is
    emitted and the previously computed conformity scores are discarded before
    the new fit. Call `reset()` explicitly to suppress the warning.

    Parameters
    ----------
    X : ArrayLike
        Features. Must be the same X used in .fit

    y : ArrayLike
        Targets. Must be the same y used in .fit

    fit_params : Optional[dict], default=None
        Parameters to pass to the `fit` method of the base regressor.

    predict_params : Optional[dict], default=None
        Parameters to pass to the `predict` method of the base regressor.
        These parameters will also be used in the `predict_interval`
        and `predict` methods of this JackknifeAfterBootstrapRegressor.

    Returns
    -------
    Self
        This JackknifeAfterBootstrapRegressor instance, fitted and conformalized.
    """
    if self.is_fitted_and_conformalized:
        warnings.warn(
            "JackknifeAfterBootstrapRegressor.fit_conformalize was already "
            "called; conformity scores from the previous fit will be "
            "discarded. Call .reset() explicitly before fit_conformalize "
            "to suppress this warning.",
            UserWarning,
            stacklevel=2,
        )
        self.reset()

    fit_params_ = _prepare_params(fit_params)
    self._predict_params = _prepare_params(predict_params)
    self._mapie_regressor.fit(
        X,
        y,
        fit_params=fit_params_,
        predict_params=self._predict_params,
    )

    self.is_fitted_and_conformalized = True
    return self

predict_interval

predict_interval(
    X: ArrayLike,
    aggregate_point_predictions: bool = True,
    minimize_interval_width: bool = False,
    allow_infinite_bounds: bool = False,
    ensemble: Any = _UNSET,
) -> Tuple[NDArray, NDArray]

Predicts points and intervals.

If several confidence levels were provided during initialisation, several intervals will be predicted for each sample. See the return signature.

By default, points are predicted using an aggregation. See the aggregate_point_predictions parameter.

PARAMETER	DESCRIPTION
X	Test data for prediction intervals. TYPE: ArrayLike
aggregate_point_predictions	If True, a predicted point is an aggregation of the predictions of the regressors trained on each bootstrap samples. This aggregation depends on the aggregation_method provided during initialisation. If False, a point is predicted using the regressor trained on the entire data TYPE: bool DEFAULT: True
minimize_interval_width	If True, attempts to minimize the interval width. TYPE: bool DEFAULT: False
allow_infinite_bounds	If True, allows prediction intervals with infinite bounds. TYPE: bool DEFAULT: False
ensemble	.. deprecated:: Renamed to aggregate_point_predictions. Passing ensemble still works but emits a FutureWarning and will be removed in a future release. TYPE: bool DEFAULT: _UNSET

RETURNS	DESCRIPTION
Tuple[NDArray, NDArray]	Two arrays: Prediction points, of shape (n_samples,) Prediction intervals, of shape (n_samples, 2, n_confidence_levels)

Source code in mapie/regression/regression.py

def predict_interval(
    self,
    X: ArrayLike,
    aggregate_point_predictions: bool = True,
    minimize_interval_width: bool = False,
    allow_infinite_bounds: bool = False,
    ensemble: Any = _UNSET,
) -> Tuple[NDArray, NDArray]:
    """
    Predicts points and intervals.

    If several confidence levels were provided during initialisation, several
    intervals will be predicted for each sample. See the return signature.

    By default, points are predicted using an aggregation.
    See the `aggregate_point_predictions` parameter.

    Parameters
    ----------
    X : ArrayLike
        Test data for prediction intervals.

    aggregate_point_predictions : bool, default=True
        If True, a predicted point is an aggregation of the predictions of the
        regressors trained on each bootstrap samples. This aggregation depends on
        the `aggregation_method` provided during initialisation.

        If False, a point is predicted using the regressor trained on the entire
        data

    minimize_interval_width : bool, default=False
        If True, attempts to minimize the interval width.

    allow_infinite_bounds : bool, default=False
        If True, allows prediction intervals with infinite bounds.

    ensemble : bool
        .. deprecated::
            Renamed to `aggregate_point_predictions`. Passing `ensemble`
            still works but emits a `FutureWarning` and will be removed in
            a future release.

    Returns
    -------
    Tuple[NDArray, NDArray]
        Two arrays:

        - Prediction points, of shape `(n_samples,)`
        - Prediction intervals, of shape `(n_samples, 2, n_confidence_levels)`
    """
    aggregate_point_predictions = _resolve_renamed_parameter(
        "aggregate_point_predictions",
        aggregate_point_predictions,
        "ensemble",
        ensemble,
    )
    _raise_error_if_previous_method_not_called(
        "predict_interval",
        "fit_conformalize",
        self.is_fitted_and_conformalized,
    )

    predictions = self._mapie_regressor.predict(
        X,
        alpha=self._alphas,
        optimize_beta=minimize_interval_width,
        allow_infinite_bounds=allow_infinite_bounds,
        ensemble=aggregate_point_predictions,
        **self._predict_params,
    )
    return _cast_predictions_to_ndarray_tuple(predictions)

predict

predict(
    X: ArrayLike,
    aggregate_point_predictions: bool = True,
    ensemble: Any = _UNSET,
) -> NDArray

Predicts points.

By default, points are predicted using an aggregation. See the aggregate_point_predictions parameter.

PARAMETER	DESCRIPTION
X	Data features for generating point predictions. TYPE: ArrayLike
aggregate_point_predictions	If True, a predicted point is an aggregation of the predictions of the regressors trained on each bootstrap samples. This aggregation depends on the aggregation_method provided during initialisation. If False, a point is predicted using the regressor trained on the entire data TYPE: bool DEFAULT: True
ensemble	.. deprecated:: Renamed to aggregate_point_predictions. Passing ensemble still works but emits a FutureWarning and will be removed in a future release. TYPE: bool DEFAULT: _UNSET

RETURNS	DESCRIPTION
NDArray	Array of point predictions, with shape (n_samples,).

Source code in mapie/regression/regression.py

def predict(
    self,
    X: ArrayLike,
    aggregate_point_predictions: bool = True,
    ensemble: Any = _UNSET,
) -> NDArray:
    """
    Predicts points.

    By default, points are predicted using an aggregation.
    See the `aggregate_point_predictions` parameter.

    Parameters
    ----------
    X : ArrayLike
        Data features for generating point predictions.

    aggregate_point_predictions : bool, default=True
        If True, a predicted point is an aggregation of the predictions of the
        regressors trained on each bootstrap samples. This aggregation depends on
        the `aggregation_method` provided during initialisation.
        If False, a point is predicted using the regressor trained on the entire
        data

    ensemble : bool
        .. deprecated::
            Renamed to `aggregate_point_predictions`. Passing `ensemble`
            still works but emits a `FutureWarning` and will be removed in
            a future release.

    Returns
    -------
    NDArray
        Array of point predictions, with shape `(n_samples,)`.
    """
    aggregate_point_predictions = _resolve_renamed_parameter(
        "aggregate_point_predictions",
        aggregate_point_predictions,
        "ensemble",
        ensemble,
    )
    _raise_error_if_previous_method_not_called(
        "predict",
        "fit_conformalize",
        self.is_fitted_and_conformalized,
    )

    predictions = self._mapie_regressor.predict(
        X,
        alpha=None,
        ensemble=aggregate_point_predictions,
        **self._predict_params,
    )
    return _cast_point_predictions_to_ndarray(predictions)

---

mapie.regression.ConformalizedQuantileRegressor

ConformalizedQuantileRegressor(
    estimator: Optional[
        Union[
            RegressorMixin,
            Pipeline,
            List[Union[RegressorMixin, Pipeline]],
        ]
    ] = None,
    confidence_level: float = 0.9,
    prefit: bool = False,
)

Computes prediction intervals using the conformalized quantile regression technique:

1. The fit method fits three models to the training data using the provided regressor: a model to predict the target, and models to predict upper and lower quantiles around the target.
2. The conformalize method estimates the uncertainty of the quantile models using the conformalization set.
3. The predict_interval computes prediction points and intervals.

PARAMETER	DESCRIPTION
estimator	The regressor used to predict points and quantiles. When prefit=False (default), a single regressor that supports the quantile loss must be passed. Valid options: sklearn.linear_model.QuantileRegressor sklearn.ensemble.GradientBoostingRegressor sklearn.ensemble.HistGradientBoostingRegressor lightgbm.LGBMRegressor When prefit=True, a list of three fitted quantile regressors predicting the lower, upper, and median quantiles must be passed (in that order). These quantiles must be: lower quantile = (1 - confidence_level) / 2 upper quantile = (1 + confidence_level) / 2 median quantile = 0.5 TYPE: Union[`RegressorMixin`, `Pipeline`, `List[Union[RegressorMixin, Pipeline]]`] DEFAULT: None
confidence_level	The confidence level for the prediction intervals, indicating the desired coverage probability of the prediction intervals. TYPE: float default=0.9 DEFAULT: 0.9
prefit	If True, three fitted quantile regressors must be provided, and the fit method must be skipped. If False, the three regressors will be fitted during the fit method. TYPE: bool DEFAULT: False

Examples:

>>> from mapie.regression import ConformalizedQuantileRegressor
>>> from mapie.utils import train_conformalize_test_split
>>> from sklearn.datasets import make_regression
>>> from sklearn.model_selection import train_test_split
>>> from sklearn.linear_model import QuantileRegressor

>>> X, y = make_regression(n_samples=500, n_features=2, noise=1.0)
>>> (
...     X_train, X_conformalize, X_test,
...     y_train, y_conformalize, y_test
... ) = train_conformalize_test_split(
...     X, y, train_size=0.6, conformalize_size=0.2, test_size=0.2, random_state=1
... )

>>> mapie_regressor = ConformalizedQuantileRegressor(
...     estimator=QuantileRegressor(),
...     confidence_level=0.95,
... ).fit(X_train, y_train).conformalize(X_conformalize, y_conformalize)

>>> predicted_points, predicted_intervals = mapie_regressor.predict_interval(X_test)

References

Yaniv Romano, Evan Patterson and Emmanuel J. Candès. "Conformalized Quantile Regression" Advances in neural information processing systems 32 (2019).

Source code in mapie/regression/quantile_regression.py

def __init__(
    self,
    estimator: Optional[
        Union[RegressorMixin, Pipeline, List[Union[RegressorMixin, Pipeline]]]
    ] = None,
    confidence_level: float = 0.9,
    prefit: bool = False,
) -> None:
    self._alpha = _transform_confidence_level_to_alpha(confidence_level)
    self._prefit = prefit
    self._is_fitted = prefit
    self._is_conformalized = False

    self._mapie_quantile_regressor = _MapieQuantileRegressor(
        estimator=estimator,
        method="quantile",
        cv="prefit" if prefit else "split",
        alpha=self._alpha,
    )

    self._predict_params: dict = {}

conformity_scores property

conformity_scores: NDArray

Returns the conformity scores computed by the conformalize method on the conformalization set.

For conformalized quantile regression, three scores are stored per sample: the signed residual against the lower-quantile estimator, the signed residual against the upper-quantile estimator, and their pointwise maximum.

RETURNS	DESCRIPTION
NDArray	Array of conformity scores, with shape (3, n_samples).

fit

fit(
    X_train: ArrayLike,
    y_train: ArrayLike,
    fit_params: Optional[dict] = None,
) -> ConformalizedQuantileRegressor

Fits three models using the regressor provided at initialisation:

• a model to predict the target
• a model to predict the upper quantile of the target
• a model to predict the lower quantile of the target

PARAMETER	DESCRIPTION
X_train	Training data features. TYPE: ArrayLike
y_train	Training data targets. TYPE: ArrayLike
fit_params	Parameters to pass to the fit method of the regressors. TYPE: Optional[dict] DEFAULT: None

RETURNS	DESCRIPTION
Self	The fitted ConformalizedQuantileRegressor instance.

Source code in mapie/regression/quantile_regression.py

def fit(
    self,
    X_train: ArrayLike,
    y_train: ArrayLike,
    fit_params: Optional[dict] = None,
) -> ConformalizedQuantileRegressor:
    """
    Fits three models using the regressor provided at initialisation:

    - a model to predict the target
    - a model to predict the upper quantile of the target
    - a model to predict the lower quantile of the target

    Parameters
    ----------
    X_train : ArrayLike
        Training data features.

    y_train : ArrayLike
        Training data targets.

    fit_params : Optional[dict], default=None
        Parameters to pass to the `fit` method of the regressors.

    Returns
    -------
    Self
        The fitted ConformalizedQuantileRegressor instance.
    """
    _raise_error_if_fit_called_in_prefit_mode(self._prefit)
    _raise_error_if_method_already_called("fit", self._is_fitted)

    fit_params_ = _prepare_params(fit_params)
    self._mapie_quantile_regressor._initialize_fit_conformalize()
    self._mapie_quantile_regressor._fit_estimators(
        X=X_train,
        y=y_train,
        **fit_params_,
    )

    self._is_fitted = True
    return self

conformalize

conformalize(
    X_conformalize: ArrayLike,
    y_conformalize: ArrayLike,
    predict_params: Optional[dict] = None,
) -> ConformalizedQuantileRegressor

Estimates the uncertainty of the quantile regressors by computing conformity scores on the conformalization set.

PARAMETER	DESCRIPTION
X_conformalize	Features of the conformalization set. TYPE: ArrayLike
y_conformalize	Targets of the conformalization set. TYPE: ArrayLike
predict_params	Parameters to pass to the predict method of the regressors. These parameters will also be used in the predict_interval and predict methods of this SplitConformalRegressor. TYPE: Optional[dict] DEFAULT: None

RETURNS	DESCRIPTION
Self	The ConformalizedQuantileRegressor instance.

Source code in mapie/regression/quantile_regression.py

def conformalize(
    self,
    X_conformalize: ArrayLike,
    y_conformalize: ArrayLike,
    predict_params: Optional[dict] = None,
) -> ConformalizedQuantileRegressor:
    """
    Estimates the uncertainty of the quantile regressors by computing
    conformity scores on the conformalization set.

    Parameters
    ----------
    X_conformalize : ArrayLike
        Features of the conformalization set.

    y_conformalize : ArrayLike
        Targets of the conformalization set.

    predict_params : Optional[dict], default=None
        Parameters to pass to the `predict` method of the regressors.
        These parameters will also be used in the `predict_interval`
        and `predict` methods of this SplitConformalRegressor.

    Returns
    -------
    Self
        The ConformalizedQuantileRegressor instance.
    """
    _raise_error_if_previous_method_not_called(
        "conformalize",
        "fit",
        self._is_fitted,
    )
    _raise_error_if_method_already_called(
        "conformalize",
        self._is_conformalized,
    )

    self._predict_params = _prepare_params(predict_params)
    self._mapie_quantile_regressor.conformalize(
        X_conformalize, y_conformalize, **self._predict_params
    )

    self._is_conformalized = True
    return self

predict_interval

predict_interval(
    X: ArrayLike,
    minimize_interval_width: bool = False,
    allow_infinite_bounds: bool = False,
    symmetric_correction: bool = False,
) -> Tuple[NDArray, NDArray]

Predicts points (using the base regressor) and intervals.

The returned NDArray containing the prediction intervals is of shape (n_samples, 2, 1). The third dimension is unnecessary, but kept for consistency with the other conformal regression methods available in MAPIE.

PARAMETER	DESCRIPTION
X	Features TYPE: ArrayLike
minimize_interval_width	If True, attempts to minimize the intervals width. TYPE: bool DEFAULT: False
allow_infinite_bounds	If True, allows prediction intervals with infinite bounds. TYPE: bool DEFAULT: False
symmetric_correction	To produce prediction intervals, the conformalized quantile regression technique corrects the predictions of the upper and lower quantile regressors by adding a constant. If symmetric_correction is set to False , this constant is different for the upper and the lower quantile predictions. If set to True, this constant is the same for both. TYPE: bool DEFAULT: False

RETURNS	DESCRIPTION
Tuple[NDArray, NDArray]	Two arrays: Prediction points, of shape (n_samples,) Prediction intervals, of shape (n_samples, 2, 1)

Source code in mapie/regression/quantile_regression.py

def predict_interval(
    self,
    X: ArrayLike,
    minimize_interval_width: bool = False,
    allow_infinite_bounds: bool = False,
    symmetric_correction: bool = False,
) -> Tuple[NDArray, NDArray]:
    """
    Predicts points (using the base regressor) and intervals.

    The returned NDArray containing the prediction intervals is of shape
    (n_samples, 2, 1). The third dimension is unnecessary, but kept for consistency
    with the other conformal regression methods available in MAPIE.

    Parameters
    ----------
    X : ArrayLike
        Features

    minimize_interval_width : bool, default=False
        If True, attempts to minimize the intervals width.

    allow_infinite_bounds : bool, default=False
        If True, allows prediction intervals with infinite bounds.

    symmetric_correction : bool, default=False
        To produce prediction intervals, the conformalized quantile regression
        technique corrects the predictions of the upper and lower quantile
        regressors by adding a constant.

        If `symmetric_correction` is set to `False` , this constant is different
        for the upper and the lower quantile predictions. If set to `True`,
        this constant is the same for both.

    Returns
    -------
    Tuple[NDArray, NDArray]
        Two arrays:

        - Prediction points, of shape `(n_samples,)`
        - Prediction intervals, of shape `(n_samples, 2, 1)`
    """
    _raise_error_if_previous_method_not_called(
        "predict_interval",
        "conformalize",
        self._is_conformalized,
    )

    predictions = self._mapie_quantile_regressor.predict(
        X,
        optimize_beta=minimize_interval_width,
        allow_infinite_bounds=allow_infinite_bounds,
        symmetry=symmetric_correction,
        **self._predict_params,
    )
    return _cast_predictions_to_ndarray_tuple(predictions)

predict

predict(X: ArrayLike) -> NDArray

Predicts points.

PARAMETER	DESCRIPTION
X	Features TYPE: ArrayLike

RETURNS	DESCRIPTION
NDArray	Array of point predictions with shape (n_samples,).

Source code in mapie/regression/quantile_regression.py

def predict(
    self,
    X: ArrayLike,
) -> NDArray:
    """
    Predicts points.

    Parameters
    ----------
    X : ArrayLike
        Features

    Returns
    -------
    NDArray
        Array of point predictions with shape `(n_samples,)`.
    """
    _raise_error_if_previous_method_not_called(
        "predict",
        "conformalize",
        self._is_conformalized,
    )

    estimator = self._mapie_quantile_regressor
    predictions, _ = estimator.predict(X, **self._predict_params)
    return predictions

---

mapie.regression.CrossConformalizedQuantileRegressor

CrossConformalizedQuantileRegressor(
    estimator: RegressorMixin = QuantileRegressor(),
    confidence_level: Union[float, Iterable[float]] = 0.9,
    conformity_score: Union[
        QuantileRegressionScore,
        Type[QuantileRegressionScore],
    ] = AbsoluteQuantileRegressionScore,
    method: str = "plus",
    cv: Union[int, BaseCrossValidator] = 5,
    n_jobs: Optional[int] = None,
    verbose: int = 0,
    random_state: Optional[Union[int, RandomState]] = None,
    central_estimator: Optional[RegressorMixin] = None,
    fit_central_estimator: Optional[bool] = True,
)

Bases: _QuantileConformalizer

Computes prediction intervals using the cross-conformalized quantile regression technique.

The estimator fits a cross-validated set of quantile regressors and then calibrates them on a conformalization set to produce prediction intervals. The fit_conformalize convenience method performs both steps in sequence.

PARAMETER	DESCRIPTION
estimator	Base regressor used to estimate the lower, upper and central quantiles. TYPE: RegressorMixin DEFAULT: QuantileRegressor()
confidence_level	Target confidence level of the prediction intervals. An iterable requests one interval per level, which predict_interval returns along the last axis. TYPE: float or Iterable[float] DEFAULT: 0.9
conformity_score	Conformity score used to calibrate the quantile estimates. A class is instantiated with its defaults; pass an instance to configure it. TYPE: QuantileRegressionScore or type DEFAULT: AbsoluteQuantileRegressionScore
method	Cross-conformalization strategy. Allowed values are "base", "plus" and "minmax". TYPE: str DEFAULT: "plus"
cv	Cross-validation splitter used to build the ensemble of estimators. TYPE: int or BaseCrossValidator DEFAULT: 5
n_jobs	Number of jobs used for parallel fitting. TYPE: Optional[int] DEFAULT: None
verbose	Verbosity level passed to the underlying parallel fitting routine. TYPE: int DEFAULT: 0
random_state	Controls randomness for the internal cross-validation procedures: it seeds the shuffling of the KFold built when cv is an integer. Pass an integer for reproducible folds. If None, the seed is drawn from the global numpy random state, so the folds differ from one instance to the next. Ignored when cv is a cross-validator, which carries its own randomness. TYPE: Optional[int or RandomState] DEFAULT: None
central_estimator	Optional estimator used to predict the central value directly. TYPE: Optional[RegressorMixin] DEFAULT: None
fit_central_estimator	Whether to fit an estimator dedicated to the central prediction. TYPE: bool DEFAULT: True

References

Yaniv Romano, Evan Patterson and Emmanuel J. Candès. "Conformalized Quantile Regression" Advances in neural information processing systems 32 (2019).

Source code in mapie/regression/quantile_regression.py

def __init__(
    self,
    estimator: RegressorMixin = QuantileRegressor(),
    confidence_level: Union[float, Iterable[float]] = 0.9,
    conformity_score: Union[
        QuantileRegressionScore, Type[QuantileRegressionScore]
    ] = AbsoluteQuantileRegressionScore,
    method: str = "plus",
    cv: Union[int, BaseCrossValidator] = 5,
    n_jobs: Optional[int] = None,
    verbose: int = 0,
    random_state: Optional[Union[int, np.random.RandomState]] = None,
    central_estimator: Optional[RegressorMixin] = None,
    fit_central_estimator: Optional[bool] = True,
) -> None:
    _check_if_param_in_allowed_values(
        method, "method", CrossConformalizedQuantileRegressor._VALID_METHODS
    )
    _check_cv_not_string(cv)
    _check_cv_not_subsample(cv)
    self._check_quantile_estimator(estimator)
    self._check_score(conformity_score)
    check_random_state(random_state)

    # Instantiate conformity score if it's a class
    if isinstance(conformity_score, type):
        self.score = conformity_score()
    else:
        self.score = conformity_score
    self.estimator = estimator
    self.method = method
    self.random_state = random_state
    # `random_state` seeds the shuffling of the `KFold` that an integer `cv` is
    # turned into. Without it `_check_cv` draws a seed from the global numpy
    # random state, making the folds differ from one instance to the next.
    self.cv = _check_cv(cv, random_state=random_state)
    self.n_jobs = n_jobs
    self.verbose = verbose
    self.alpha = _transform_confidence_level_to_alpha_list(confidence_level)
    self.is_fitted = self.is_conformalized = False

    self._predict_params = {}
    self._central_estimator = central_estimator
    self.fit_central_estimator = fit_central_estimator
    self.quantiles = {str(alpha): self._check_alpha(alpha) for alpha in self.alpha}
    self.agg_function = "mean"

is_fitted_and_conformalized property

is_fitted_and_conformalized: bool

Returns True if the estimator is fitted and conformalized

fit_conformalize

fit_conformalize(
    X: ArrayLike,
    y: ArrayLike,
    groups: Optional[ArrayLike] = None,
    fit_params: Optional[dict] = None,
    predict_params: Optional[dict] = None,
) -> CrossConformalizedQuantileRegressor

Estimates the uncertainty of the base regressor in a cross-validation style: fits the base regressor on different folds of the dataset and computes conformity scores on the corresponding out-of-fold data.

If called on an instance that has already been fitted, a UserWarning is emitted and the previously computed conformity scores are discarded before the new fit. Call reset() explicitly to suppress the warning.

PARAMETER	DESCRIPTION
X	Features TYPE: ArrayLike
y	Targets TYPE: ArrayLike
groups	Groups to pass to the cross-validator. TYPE: Optional[ArrayLike] DEFAULT: None
fit_params	Parameters to pass to the fit method of the base regressor. TYPE: Optional[dict] DEFAULT: None
predict_params	Parameters to pass to the predict method of the base regressor. These parameters will also be used in the predict_interval and predict methods of this CrossConformalRegressor. TYPE: Optional[dict] DEFAULT: None

RETURNS	DESCRIPTION
Self	This CrossConformalRegressor instance, fitted and conformalized.

Source code in mapie/regression/quantile_regression.py

def fit_conformalize(
    self,
    X: ArrayLike,
    y: ArrayLike,
    groups: Optional[ArrayLike] = None,
    fit_params: Optional[dict] = None,
    predict_params: Optional[dict] = None,
) -> CrossConformalizedQuantileRegressor:
    """
    Estimates the uncertainty of the base regressor in a cross-validation style:
    fits the base regressor on different folds of the dataset
    and computes conformity scores on the corresponding out-of-fold data.

    If called on an instance that has already been fitted, a `UserWarning` is
    emitted and the previously computed conformity scores are discarded before
    the new fit. Call `reset()` explicitly to suppress the warning.

    Parameters
    ----------
    X : ArrayLike
        Features

    y : ArrayLike
        Targets

    groups: Optional[ArrayLike] of shape (n_samples,), default=None
        Groups to pass to the cross-validator.

    fit_params : Optional[dict], default=None
        Parameters to pass to the `fit` method of the base regressor.

    predict_params : Optional[dict], default=None
        Parameters to pass to the `predict` method of the base regressor.
        These parameters will also be used in the `predict_interval`
        and `predict` methods of this CrossConformalRegressor.

    Returns
    -------
    Self
        This CrossConformalRegressor instance, fitted and conformalized.
    """
    if self.is_fitted_and_conformalized:
        warnings.warn(
            "CrossConformalRegressor.fit_conformalize was already called; "
            "conformity scores from the previous fit will be discarded. "
            "Call .reset() explicitly before fit_conformalize to suppress "
            "this warning.",
            UserWarning,
            stacklevel=2,
        )
        self.reset()

    fit_params_ = _prepare_params(fit_params)
    predict_params_ = _prepare_params(predict_params)
    self._predict_params = predict_params_
    self.fit(
        X,
        y,
        groups=groups,
        **fit_params_,
    )
    self.conformalize(X, y, groups, **predict_params_)
    return self

predict_interval

predict_interval(
    X: ArrayLike,
    aggregate_point_predictions: Optional[
        str
    ] = AGGREGATE_POINT_PREDICTIONS_AUTO,
    minimize_interval_width: bool = False,
    allow_infinite_bounds: bool = False,
) -> Tuple[NDArray, NDArray]

Predicts points and intervals.

If several confidence levels were provided during initialisation, several intervals will be predicted for each sample. See the return signature.

By default, points are predicted using an aggregation. See the aggregate_point_predictions parameter.

PARAMETER	DESCRIPTION
X	Features TYPE: ArrayLike
aggregate_point_predictions	The method to predict a point. The valid options depend on method, since only method="base" fits an estimator on the entire data while "plus" and "minmax" aggregate the cross-validation folds. Options: "auto": resolves to None if method="base", to "pinball_weighted_mean" otherwise None: a point is predicted using the regressor trained on the entire data. Only valid with method="base" "mean": Averages the predictions of the regressors trained on each cross-validation fold "median": Aggregates (using median) the predictions of the regressors trained on each cross-validation fold "pinball_weighted_mean": Aggregates the predictions of the regressors trained on each cross-validation fold using a weighted mean, where the weights are the pinball losses of each fold. The three aggregations above are invalid with method="base". TYPE: Optional[str] DEFAULT: "auto"
minimize_interval_width	If True, attempts to minimize the interval width. TYPE: bool DEFAULT: False
allow_infinite_bounds	If True, allows prediction intervals with infinite bounds. TYPE: bool DEFAULT: False

RETURNS	DESCRIPTION
Tuple[NDArray, NDArray]	Two arrays: Prediction points, of shape (n_samples,) Prediction intervals, of shape (n_samples, 2, n_confidence_levels)

Source code in mapie/regression/quantile_regression.py

def predict_interval(
    self,
    X: ArrayLike,
    aggregate_point_predictions: Optional[str] = AGGREGATE_POINT_PREDICTIONS_AUTO,
    minimize_interval_width: bool = False,
    allow_infinite_bounds: bool = False,
) -> Tuple[NDArray, NDArray]:
    """
    Predicts points and intervals.

    If several confidence levels were provided during initialisation, several
    intervals will be predicted for each sample. See the return signature.

    By default, points are predicted using an aggregation.
    See the `aggregate_point_predictions` parameter.

    Parameters
    ----------
    X : ArrayLike
        Features

    aggregate_point_predictions : Optional[str], default="auto"
        The method to predict a point. The valid options depend on `method`,
        since only `method="base"` fits an estimator on the entire data while
        `"plus"` and `"minmax"` aggregate the cross-validation folds. Options:

        - "auto": resolves to `None` if `method="base"`, to
            `"pinball_weighted_mean"` otherwise
        - None: a point is predicted using the regressor trained on the entire
            data. Only valid with `method="base"`
        - "mean": Averages the predictions of the regressors trained on each
            cross-validation fold
        - "median": Aggregates (using median) the predictions of the regressors
            trained on each cross-validation fold
        - "pinball_weighted_mean": Aggregates the predictions of the regressors
            trained on each cross-validation fold using a weighted mean, where the
            weights are the pinball losses of each fold.

        The three aggregations above are invalid with `method="base"`.

    minimize_interval_width : bool, default=False
        If True, attempts to minimize the interval width.

    allow_infinite_bounds : bool, default=False
        If True, allows prediction intervals with infinite bounds.


    Returns
    -------
    Tuple[NDArray, NDArray]
        Two arrays:

        - Prediction points, of shape `(n_samples,)`
        - Prediction intervals, of shape `(n_samples, 2, n_confidence_levels)`
    """
    _raise_error_if_previous_method_not_called(
        "predict_interval",
        "conformalize",
        self.is_conformalized,
    )

    ensemble = self._set_aggregate_point_predictions_and_return_ensemble(
        aggregate_point_predictions
    )

    # `get_bounds` vectorizes over the confidence levels of `alpha_np`, but it takes
    # a single conformity score array and a single pair of predicted bounds, shared
    # across those levels. Here every level has its own quantile estimators and its
    # own scores, so the bounds are computed level by level and stacked afterwards.
    bounds_low, bounds_up = [], []
    y_pred: Optional[NDArray] = None

    for alpha in self.alpha:
        level = str(alpha)
        alpha_np = np.array([alpha], dtype=float)
        scores = self.conformity_scores[level]

        if not allow_infinite_bounds:
            n = self.score.get_effective_calibration_samples(scores)
            _check_alpha_and_n_samples(alpha_np, n)

        # Predict the target with confidence intervals
        y_pred, y_pred_low, y_pred_up = self.score.predict_set(
            cast(NDArray, X),
            alpha_np,
            estimator=self,
            conformity_scores=scores,
            ensemble=ensemble,
            method=self.method,
            optimize_beta=minimize_interval_width,
            allow_infinite_bounds=allow_infinite_bounds,
            **self._predict_params,
        )
        # A single level is requested per call, so `get_bounds` returns bounds of
        # shape (n_samples, 1); drop that axis before stacking the levels.
        bounds_low.append(np.reshape(y_pred_low, -1))
        bounds_up.append(np.reshape(y_pred_up, -1))

    intervalles = np.stack(
        [np.stack(bounds_low, axis=-1), np.stack(bounds_up, axis=-1)], axis=1
    )

    return cast(NDArray, y_pred), intervalles

predict

predict(
    X: ArrayLike,
    aggregate_point_predictions: Optional[
        str
    ] = AGGREGATE_POINT_PREDICTIONS_AUTO,
) -> NDArray

Predicts points.

By default, points are predicted using an aggregation. See the aggregate_point_predictions parameter.

PARAMETER	DESCRIPTION
X	Features TYPE: ArrayLike
aggregate_point_predictions	The method to predict a point. The valid options depend on method, since only method="base" fits an estimator on the entire data while "plus" and "minmax" aggregate the cross-validation folds. Options: "auto": resolves to None if method="base", to "pinball_weighted_mean" otherwise None: a point is predicted using the regressor trained on the entire data. Only valid with method="base" "mean": Averages the predictions of the regressors trained on each cross-validation fold "median": Aggregates (using median) the predictions of the regressors trained on each cross-validation fold "pinball_weighted_mean": Aggregates the predictions of the regressors trained on each cross-validation fold using a weighted mean, where the weights are the pinball losses of each fold. The three aggregations above are invalid with method="base". TYPE: Optional[str] DEFAULT: "auto"

RETURNS	DESCRIPTION
NDArray	Array of point predictions, with shape (n_samples,).

Source code in mapie/regression/quantile_regression.py

def predict(
    self,
    X: ArrayLike,
    aggregate_point_predictions: Optional[str] = AGGREGATE_POINT_PREDICTIONS_AUTO,
) -> NDArray:
    """
    Predicts points.

    By default, points are predicted using an aggregation.
    See the `aggregate_point_predictions` parameter.

    Parameters
    ----------
    X : ArrayLike
        Features

    aggregate_point_predictions : Optional[str], default="auto"
        The method to predict a point. The valid options depend on `method`,
        since only `method="base"` fits an estimator on the entire data while
        `"plus"` and `"minmax"` aggregate the cross-validation folds. Options:

        - "auto": resolves to `None` if `method="base"`, to
          `"pinball_weighted_mean"` otherwise
        - None: a point is predicted using the regressor trained on the entire
          data. Only valid with `method="base"`
        - "mean": Averages the predictions of the regressors trained on each
          cross-validation fold
        - "median": Aggregates (using median) the predictions of the regressors
          trained on each cross-validation fold
        - "pinball_weighted_mean": Aggregates the predictions of the regressors
          trained on each cross-validation fold using a weighted mean, where the
          weights are the pinball losses of each fold.

        The three aggregations above are invalid with `method="base"`.

    Returns
    -------
    NDArray
        Array of point predictions, with shape `(n_samples,)`.
    """
    _raise_error_if_previous_method_not_called(
        "predict",
        "fit_conformalize",
        self.is_fitted_and_conformalized,
    )

    ensemble = self._set_aggregate_point_predictions_and_return_ensemble(
        aggregate_point_predictions
    )

    # Reached only with `method="base"
    if not ensemble:
        return np.asarray(
            self._base_central_estimator_[0]
            .predict(X, **self._predict_params)
            .ravel()
        )

    y_pred_multi = np.vstack(
        [
            self._predict_center(X, index=i, **self._predict_params)
            for i in range(len(self.central_estimators_))
        ]
    )

    # `aggregate_point_predictions` may be the `"auto"` sentinel, so read the
    # aggregation resolved above rather than the argument.
    level = str(self.alpha[0])
    if self.agg_function == "pinball_weighted_mean" and (
        self.quantiles[level].size == 3
    ):
        central_weights = 1 / (
            np.asarray(self.pinball_losses[level], dtype=float)[:, 2] + 1e-8
        )
        weights = central_weights / central_weights.sum()
        return np.asarray(np.sum((np.atleast_2d(weights).T * y_pred_multi), axis=0))
    if self.agg_function == "median":
        return np.asarray(np.median(y_pred_multi, axis=0))
    return np.asarray(np.mean(y_pred_multi, axis=0))