@elaraai/east-py-datascience 0.0.2-beta.8 → 0.0.2-beta.80

package/dist/src/mapie/mapie.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapie.d.ts","sourceRoot":"","sources":["../../../src/mapie/mapie.ts"],"names":[],"mappings":"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"}

package/dist/src/mapie/mapie.js

@@ -0,0 +1,616 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * MAPIE conformal prediction intervals for East.
+ *
+ * Provides prediction intervals with coverage guarantees using
+ * conformal prediction methods (MAPIE 1.2.0 API).
+ *
+ * @packageDocumentation
+ */
+import { East, StructType, VariantType, OptionType, ArrayType, IntegerType, FloatType, BlobType, NullType, } from "@elaraai/east";
+import { VectorType, MatrixType } from "../types.js";
+import { XGBoostConfigType, XGBoostModelBlobType } from "../xgboost/xgboost.js";
+import { LightGBMConfigType, LightGBMModelBlobType } from "../lightgbm/lightgbm.js";
+// Re-export shared types for convenience
+export { VectorType, MatrixType } from "../types.js";
+export { XGBoostConfigType, XGBoostModelBlobType } from "../xgboost/xgboost.js";
+export { LightGBMConfigType, LightGBMModelBlobType } from "../lightgbm/lightgbm.js";
+// ============================================================================
+// Config Types
+// ============================================================================
+/**
+ * Conformal prediction method for regression.
+ */
+export const ConformalMethodType = VariantType({
+    /** Split conformal - requires separate calibration set */
+    split: NullType,
+    /** Cross conformal - uses CV for calibration (combines train + calib) */
+    cross: NullType,
+});
+/**
+ * Base model type for MAPIE regression.
+ * Uses full XGBoost/LightGBM config types for complete parameter support.
+ */
+export const BaseModelType = VariantType({
+    /** XGBoost regressor as base model */
+    xgboost: XGBoostConfigType,
+    /** LightGBM regressor as base model */
+    lightgbm: LightGBMConfigType,
+});
+/**
+ * Configuration for MAPIE conformal prediction.
+ */
+export const MAPIEConfigType = StructType({
+    /** Base model configuration */
+    base_model: BaseModelType,
+    /** Conformal method (default: split) */
+    method: OptionType(ConformalMethodType),
+    /** Confidence level: coverage probability (default 0.9 = 90% intervals) */
+    confidence_level: OptionType(FloatType),
+    /** Number of CV folds for cross method (default 5) */
+    cv_folds: OptionType(IntegerType),
+    /** Random seed for reproducibility */
+    random_state: OptionType(IntegerType),
+    /** Conformity score consistency check tolerance (default 1e-04) */
+    conformity_eps: OptionType(FloatType),
+});
+/**
+ * Configuration for CQR (Conformalized Quantile Regression).
+ * Requires a base model that supports quantile regression (XGBoost).
+ */
+export const MAPIECQRConfigType = StructType({
+    /** XGBoost config for the base quantile model */
+    xgboost_config: XGBoostConfigType,
+    /** Confidence level: coverage probability (default 0.9 = 90% intervals) */
+    confidence_level: OptionType(FloatType),
+    /** Random seed for reproducibility */
+    random_state: OptionType(IntegerType),
+});
+// ============================================================================
+// Classification Config Types
+// ============================================================================
+/**
+ * Classification conformal method (conformity score).
+ */
+export const ClassificationMethodType = VariantType({
+    /** Least Ambiguous set-valued Classifier - smallest sets */
+    lac: NullType,
+    /** Adaptive Prediction Sets - adapts to probabilities */
+    aps: NullType,
+});
+/**
+ * Base classifier type for MAPIE classification.
+ * Uses full XGBoost/LightGBM config types for complete parameter support.
+ */
+export const BaseClassifierType = VariantType({
+    /** XGBoost classifier as base model */
+    xgboost: XGBoostConfigType,
+    /** LightGBM classifier as base model */
+    lightgbm: LightGBMConfigType,
+});
+/**
+ * Configuration for MAPIE conformal classification.
+ */
+export const MAPIEClassifierConfigType = StructType({
+    /** Base classifier configuration */
+    base_model: BaseClassifierType,
+    /** Classification conformity score method (default: lac) */
+    method: OptionType(ClassificationMethodType),
+    /** Confidence level: coverage probability (default 0.9 = 90% coverage) */
+    confidence_level: OptionType(FloatType),
+    /** Random seed for reproducibility */
+    random_state: OptionType(IntegerType),
+});
+// ============================================================================
+// Model Blob Types
+// ============================================================================
+/**
+ * Tagged model data - variant tag indicates base model type, value is the serialized blob.
+ * This pattern encodes the model type in the variant tag rather than a separate field.
+ */
+export const MAPIEBaseModelDataType = VariantType({
+    /** XGBoost-based model (structured blob with categorical metadata) */
+    xgboost: XGBoostModelBlobType,
+    /** LightGBM-based model (structured blob) */
+    lightgbm: LightGBMModelBlobType,
+    /** Histogram-based model (sklearn HistGradientBoosting, used by CQR) */
+    histogram: BlobType,
+});
+/**
+ * Model blob for MAPIE conformal regressor.
+ */
+export const MAPIERegressorBlobType = VariantType({
+    /** MAPIE regressor with split conformal */
+    mapie_split: StructType({
+        /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+        data: MAPIEBaseModelDataType,
+        /** Number of input features */
+        n_features: IntegerType,
+        /** Confidence level used during calibration */
+        confidence_level: FloatType,
+    }),
+    /** MAPIE regressor with cross conformal */
+    mapie_cross: StructType({
+        /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+        data: MAPIEBaseModelDataType,
+        /** Number of input features */
+        n_features: IntegerType,
+        /** Confidence level used during calibration */
+        confidence_level: FloatType,
+    }),
+    /** MAPIE CQR regressor (uses HistGradientBoosting internally) */
+    mapie_cqr: StructType({
+        /** Serialized model - variant tag indicates base model type */
+        data: MAPIEBaseModelDataType,
+        /** Number of input features */
+        n_features: IntegerType,
+        /** Confidence level used during calibration */
+        confidence_level: FloatType,
+    }),
+});
+/**
+ * Model blob for MAPIE conformal classifier.
+ * Uses single-case variant for consistency with MAPIERegressorBlobType and AnyModelBlobType.
+ */
+export const MAPIEClassifierBlobType = VariantType({
+    /** MAPIE classifier with split conformal */
+    mapie_classifier: StructType({
+        /** Serialized model - variant tag indicates base model type (xgboost/lightgbm) */
+        data: MAPIEBaseModelDataType,
+        /** Number of input features */
+        n_features: IntegerType,
+        /** Number of classes */
+        n_classes: IntegerType,
+        /** Class labels */
+        classes: VectorType(IntegerType),
+        /** Confidence level used during calibration */
+        confidence_level: FloatType,
+    }),
+});
+// ============================================================================
+// Uncertainty Predictor Types (for SHAP integration)
+// ============================================================================
+/**
+ * Uncertainty predictor blob type.
+ * Wraps MAPIE model to predict uncertainty measure (interval width or set size).
+ * Compatible with SHAP's KernelExplainer for explaining uncertainty.
+ */
+export const UncertaintyPredictorType = VariantType({
+    /** Predicts interval width (upper - lower) from MAPIE regressor */
+    mapie_interval_width: StructType({
+        data: BlobType,
+        n_features: IntegerType,
+    }),
+    /** Predicts prediction set size from MAPIE classifier */
+    mapie_set_size: StructType({
+        data: BlobType,
+        n_features: IntegerType,
+    }),
+});
+// ============================================================================
+// Result Types
+// ============================================================================
+/**
+ * Prediction interval result (regression).
+ */
+export const IntervalResultType = StructType({
+    /** Lower bound of prediction interval */
+    lower: VectorType(FloatType),
+    /** Point prediction (median/mean) */
+    pred: VectorType(FloatType),
+    /** Upper bound of prediction interval */
+    upper: VectorType(FloatType),
+});
+/**
+ * Prediction set result (classification).
+ * For each sample, contains the set of classes included in the prediction set.
+ */
+export const PredictionSetResultType = StructType({
+    /** Predicted class (argmax of probabilities) */
+    pred: VectorType(IntegerType),
+    /** Prediction set membership matrix (n_samples x n_classes, 1 if class in set) */
+    sets: ArrayType(ArrayType(IntegerType)),
+    /** Class probabilities (n_samples x n_classes) */
+    probabilities: MatrixType(FloatType),
+    /** Size of each prediction set */
+    set_sizes: VectorType(IntegerType),
+});
+// ============================================================================
+// Platform Functions
+// ============================================================================
+// --------------------------------
+// Regression Functions
+// --------------------------------
+/**
+ * Train a MAPIE conformal regressor.
+ *
+ * For split conformal, uses X_calib/y_calib for calibration.
+ * For cross conformal, combines train and calib data, uses CV for calibration.
+ *
+ * @param X_train - Training feature matrix
+ * @param y_train - Training target vector
+ * @param X_calib - Calibration feature matrix
+ * @param y_calib - Calibration target vector
+ * @param config - MAPIE configuration
+ * @returns Model blob containing calibrated MAPIE regressor
+ */
+export const mapie_train_conformal_regressor = East.platform("mapie_train_conformal_regressor", [MatrixType(FloatType), VectorType(FloatType), MatrixType(FloatType), VectorType(FloatType), MAPIEConfigType], MAPIERegressorBlobType);
+/**
+ * Train a MAPIE CQR (Conformalized Quantile Regression) model.
+ *
+ * CQR combines quantile regression with conformal prediction for
+ * adaptive intervals that are wider where uncertainty is higher.
+ *
+ * @param X_train - Training feature matrix
+ * @param y_train - Training target vector
+ * @param X_calib - Calibration feature matrix
+ * @param y_calib - Calibration target vector
+ * @param config - CQR configuration
+ * @returns Model blob containing calibrated CQR model
+ */
+export const mapie_train_cqr = East.platform("mapie_train_cqr", [MatrixType(FloatType), VectorType(FloatType), MatrixType(FloatType), VectorType(FloatType), MAPIECQRConfigType], MAPIERegressorBlobType);
+/**
+ * Predict with intervals using a MAPIE regressor.
+ *
+ * Returns intervals at the confidence level specified during training.
+ *
+ * @param model - Trained MAPIE regressor blob
+ * @param X - Feature matrix to predict
+ * @returns Prediction intervals (lower, pred, upper)
+ */
+export const mapie_predict_interval = East.platform("mapie_predict_interval", [MAPIERegressorBlobType, MatrixType(FloatType)], IntervalResultType);
+// --------------------------------
+// Classification Functions
+// --------------------------------
+/**
+ * Train a MAPIE conformal classifier.
+ *
+ * Uses split conformal prediction with calibration set for classification.
+ *
+ * @param X_train - Training feature matrix
+ * @param y_train - Training labels (integers)
+ * @param X_calib - Calibration feature matrix
+ * @param y_calib - Calibration labels
+ * @param config - Classifier configuration
+ * @returns Model blob containing calibrated MAPIE classifier
+ */
+export const mapie_train_conformal_classifier = East.platform("mapie_train_conformal_classifier", [MatrixType(FloatType), VectorType(IntegerType), MatrixType(FloatType), VectorType(IntegerType), MAPIEClassifierConfigType], MAPIEClassifierBlobType);
+/**
+ * Predict with prediction sets using a MAPIE classifier.
+ *
+ * Returns prediction sets at the confidence level specified during training.
+ *
+ * @param model - Trained MAPIE classifier blob
+ * @param X - Feature matrix to predict
+ * @returns Prediction sets (pred, sets, probabilities, set_sizes)
+ */
+export const mapie_predict_set = East.platform("mapie_predict_set", [MAPIEClassifierBlobType, MatrixType(FloatType)], PredictionSetResultType);
+// --------------------------------
+// SHAP Integration Functions
+// --------------------------------
+/**
+ * Create an uncertainty predictor from a MAPIE regressor.
+ *
+ * Returns a model that predicts interval width (upper - lower) instead of
+ * point predictions. Use with SHAP KernelExplainer to explain what drives
+ * prediction uncertainty.
+ *
+ * @param model - MAPIE regressor blob
+ * @returns Uncertainty predictor blob for use with SHAP KernelExplainer
+ */
+export const mapie_uncertainty_predictor_regressor = East.platform("mapie_uncertainty_predictor_regressor", [MAPIERegressorBlobType], UncertaintyPredictorType);
+/**
+ * Create an uncertainty predictor from a MAPIE classifier.
+ *
+ * Returns a model that predicts prediction set size instead of class labels.
+ * Use with SHAP KernelExplainer to explain what drives prediction uncertainty.
+ *
+ * @param model - MAPIE classifier blob
+ * @returns Uncertainty predictor blob for use with SHAP KernelExplainer
+ */
+export const mapie_uncertainty_predictor_classifier = East.platform("mapie_uncertainty_predictor_classifier", [MAPIEClassifierBlobType], UncertaintyPredictorType);
+// ============================================================================
+// Grouped Export
+// ============================================================================
+/**
+ * Type definitions for MAPIE functions.
+ */
+export const MAPIETypes = {
+    // Config types
+    ConformalMethodType,
+    XGBoostConfigType,
+    LightGBMConfigType,
+    BaseModelType,
+    MAPIEConfigType,
+    MAPIECQRConfigType,
+    ClassificationMethodType,
+    BaseClassifierType,
+    MAPIEClassifierConfigType,
+    // Model blob types
+    MAPIEBaseModelDataType,
+    MAPIERegressorBlobType,
+    MAPIEClassifierBlobType,
+    // Uncertainty predictor type (for SHAP)
+    UncertaintyPredictorType,
+    // Result types
+    IntervalResultType,
+    PredictionSetResultType,
+};
+/**
+ * MAPIE conformal prediction.
+ *
+ * Provides prediction intervals with coverage guarantees using
+ * conformal prediction methods (MAPIE 1.2.0 API).
+ *
+ * @example
+ * ```ts
+ * import { East, variant } from "@elaraai/east";
+ * import { MAPIE } from "@elaraai/east-py-datascience";
+ *
+ * const train = East.function([], MAPIE.Types.MAPIERegressorBlobType, $ => {
+ *     const X_train = $.let([[1.0], [2.0], [3.0], [4.0], [5.0]]);
+ *     const y_train = $.let([1.5, 2.5, 3.5, 4.5, 5.5]);
+ *     const X_calib = $.let([[2.5], [4.5]]);
+ *     const y_calib = $.let([3.0, 5.0]);
+ *     const config = $.let({
+ *         base_model: variant('xgboost', {
+ *             n_estimators: variant('some', 50n),
+ *             max_depth: variant('some', 3n),
+ *             learning_rate: variant('some', 0.1),
+ *             min_child_weight: variant('none', null),
+ *             subsample: variant('none', null),
+ *             colsample_bytree: variant('none', null),
+ *             reg_alpha: variant('none', null),
+ *             reg_lambda: variant('none', null),
+ *             gamma: variant('none', null),
+ *             random_state: variant('some', 42n),
+ *             n_jobs: variant('none', null),
+ *             sample_weight: variant('none', null),
+ *             categorical_features: variant('none', null),
+ *             categorical_n: variant('none', null),
+ *             max_cat_to_onehot: variant('none', null),
+ *             max_cat_threshold: variant('none', null),
+ *         }),
+ *         method: variant('some', variant('split', null)),
+ *         confidence_level: variant('some', 0.9),
+ *         cv_folds: variant('none', null),
+ *         random_state: variant('some', 42n),
+ *         conformity_eps: variant('none', null),
+ *     });
+ *     return $.return(MAPIE.trainConformalRegressor(X_train, y_train, X_calib, y_calib, config));
+ * });
+ * ```
+ */
+export const MAPIE = {
+    // Regression
+    /**
+     * Train a MAPIE conformal regressor.
+     *
+     * For split conformal, uses X_calib/y_calib for calibration.
+     * For cross conformal, combines train and calib data, uses CV.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, variant } from "@elaraai/east";
+     * import { MAPIE, MAPIEConfigType, MatrixType, VectorType } from "@elaraai/east-py-datascience";
+     *
+     * const train = East.function(
+     *     [MatrixType(FloatType), VectorType(FloatType), MatrixType(FloatType), VectorType(FloatType)],
+     *     MAPIE.Types.MAPIERegressorBlobType,
+     *     ($, X_train, y_train, X_calib, y_calib) => {
+     *         const config = $.let({
+     *             base_model: variant("xgboost", {
+     *                 n_estimators: variant("some", 50n),
+     *                 max_depth: variant("some", 3n),
+     *                 learning_rate: variant("some", 0.1),
+     *                 min_child_weight: variant("none", null),
+     *                 subsample: variant("none", null),
+     *                 colsample_bytree: variant("none", null),
+     *                 reg_alpha: variant("none", null),
+     *                 reg_lambda: variant("none", null),
+     *                 gamma: variant("none", null),
+     *                 random_state: variant("some", 42n),
+     *                 n_jobs: variant("none", null),
+     *                 sample_weight: variant("none", null),
+     *                 categorical_features: variant("none", null),
+     *                 categorical_n: variant("none", null),
+     *                 max_cat_to_onehot: variant("none", null),
+     *                 max_cat_threshold: variant("none", null),
+     *             }),
+     *             method: variant("some", variant("split", null)),
+     *             confidence_level: variant("some", 0.9),
+     *             cv_folds: variant("none", null),
+     *             random_state: variant("some", 42n),
+     *             conformity_eps: variant("none", null),
+     *         }, MAPIEConfigType);
+     *         return $.return(MAPIE.trainConformalRegressor(X_train, y_train, X_calib, y_calib, config));
+     *     }
+     * );
+     * ```
+     */
+    trainConformalRegressor: mapie_train_conformal_regressor,
+    /**
+     * Train a MAPIE CQR (Conformalized Quantile Regression) model.
+     *
+     * CQR combines quantile regression with conformal prediction for
+     * adaptive intervals that are wider where uncertainty is higher.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, variant } from "@elaraai/east";
+     * import { MAPIE, MAPIECQRConfigType, MatrixType, VectorType } from "@elaraai/east-py-datascience";
+     *
+     * const train = East.function(
+     *     [MatrixType(FloatType), VectorType(FloatType), MatrixType(FloatType), VectorType(FloatType)],
+     *     MAPIE.Types.MAPIERegressorBlobType,
+     *     ($, X_train, y_train, X_calib, y_calib) => {
+     *         const config = $.let({
+     *             xgboost_config: {
+     *                 n_estimators: variant("some", 100n),
+     *                 max_depth: variant("some", 3n),
+     *                 learning_rate: variant("some", 0.1),
+     *                 min_child_weight: variant("none", null),
+     *                 subsample: variant("none", null),
+     *                 colsample_bytree: variant("none", null),
+     *                 reg_alpha: variant("none", null),
+     *                 reg_lambda: variant("none", null),
+     *                 gamma: variant("none", null),
+     *                 random_state: variant("some", 42n),
+     *                 n_jobs: variant("none", null),
+     *                 sample_weight: variant("none", null),
+     *                 categorical_features: variant("none", null),
+     *                 categorical_n: variant("none", null),
+     *                 max_cat_to_onehot: variant("none", null),
+     *                 max_cat_threshold: variant("none", null),
+     *             },
+     *             confidence_level: variant("some", 0.9),
+     *             random_state: variant("some", 42n),
+     *         }, MAPIECQRConfigType);
+     *         return $.return(MAPIE.trainCQR(X_train, y_train, X_calib, y_calib, config));
+     *     }
+     * );
+     * ```
+     */
+    trainCQR: mapie_train_cqr,
+    /**
+     * Predict with intervals using a trained MAPIE regressor.
+     *
+     * Returns intervals at the confidence level specified during training.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType } from "@elaraai/east";
+     * import { MAPIE, MatrixType } from "@elaraai/east-py-datascience";
+     *
+     * const predict = East.function(
+     *     [MAPIE.Types.MAPIERegressorBlobType, MatrixType(FloatType)],
+     *     MAPIE.Types.IntervalResultType,
+     *     ($, model, X) => {
+     *         const result = $.let(MAPIE.predictInterval(model, X));
+     *         // result.lower => lower bound of prediction interval
+     *         // result.pred  => point prediction
+     *         // result.upper => upper bound of prediction interval
+     *         return $.return(result);
+     *     }
+     * );
+     * ```
+     */
+    predictInterval: mapie_predict_interval,
+    // Classification
+    /**
+     * Train a MAPIE conformal classifier.
+     *
+     * Uses split conformal prediction with calibration set for classification.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, IntegerType, variant } from "@elaraai/east";
+     * import { MAPIE, MAPIEClassifierConfigType, MatrixType, VectorType } from "@elaraai/east-py-datascience";
+     *
+     * const train = East.function(
+     *     [MatrixType(FloatType), VectorType(IntegerType), MatrixType(FloatType), VectorType(IntegerType)],
+     *     MAPIE.Types.MAPIEClassifierBlobType,
+     *     ($, X_train, y_train, X_calib, y_calib) => {
+     *         const config = $.let({
+     *             base_model: variant("xgboost", {
+     *                 n_estimators: variant("some", 50n),
+     *                 max_depth: variant("some", 3n),
+     *                 learning_rate: variant("some", 0.1),
+     *                 min_child_weight: variant("none", null),
+     *                 subsample: variant("none", null),
+     *                 colsample_bytree: variant("none", null),
+     *                 reg_alpha: variant("none", null),
+     *                 reg_lambda: variant("none", null),
+     *                 gamma: variant("none", null),
+     *                 random_state: variant("some", 42n),
+     *                 n_jobs: variant("none", null),
+     *                 sample_weight: variant("none", null),
+     *                 categorical_features: variant("none", null),
+     *                 categorical_n: variant("none", null),
+     *                 max_cat_to_onehot: variant("none", null),
+     *                 max_cat_threshold: variant("none", null),
+     *             }),
+     *             method: variant("some", variant("lac", null)),
+     *             confidence_level: variant("some", 0.9),
+     *             random_state: variant("some", 42n),
+     *         }, MAPIEClassifierConfigType);
+     *         return $.return(MAPIE.trainConformalClassifier(X_train, y_train, X_calib, y_calib, config));
+     *     }
+     * );
+     * ```
+     */
+    trainConformalClassifier: mapie_train_conformal_classifier,
+    /**
+     * Predict with prediction sets using a MAPIE classifier.
+     *
+     * Returns prediction sets at the confidence level specified during training.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType } from "@elaraai/east";
+     * import { MAPIE, MatrixType } from "@elaraai/east-py-datascience";
+     *
+     * const predict = East.function(
+     *     [MAPIE.Types.MAPIEClassifierBlobType, MatrixType(FloatType)],
+     *     MAPIE.Types.PredictionSetResultType,
+     *     ($, model, X) => {
+     *         const result = $.let(MAPIE.predictSet(model, X));
+     *         // result.pred       => predicted class labels
+     *         // result.sets       => prediction set membership matrix
+     *         // result.set_sizes  => size of each prediction set
+     *         return $.return(result);
+     *     }
+     * );
+     * ```
+     */
+    predictSet: mapie_predict_set,
+    // SHAP integration (uncertainty explanation)
+    /**
+     * Create an uncertainty predictor from a MAPIE regressor.
+     *
+     * Returns a model that predicts interval width (upper - lower).
+     * Use with SHAP KernelExplainer to explain what drives uncertainty.
+     *
+     * @example
+     * ```ts
+     * import { East } from "@elaraai/east";
+     * import { MAPIE } from "@elaraai/east-py-datascience";
+     *
+     * const makePredictor = East.function(
+     *     [MAPIE.Types.MAPIERegressorBlobType],
+     *     MAPIE.Types.UncertaintyPredictorType,
+     *     ($, model) => {
+     *         return $.return(MAPIE.uncertaintyPredictorRegressor(model));
+     *     }
+     * );
+     * ```
+     */
+    uncertaintyPredictorRegressor: mapie_uncertainty_predictor_regressor,
+    /**
+     * Create an uncertainty predictor from a MAPIE classifier.
+     *
+     * Returns a model that predicts prediction set size.
+     * Use with SHAP KernelExplainer to explain what drives uncertainty.
+     *
+     * @example
+     * ```ts
+     * import { East } from "@elaraai/east";
+     * import { MAPIE } from "@elaraai/east-py-datascience";
+     *
+     * const makePredictor = East.function(
+     *     [MAPIE.Types.MAPIEClassifierBlobType],
+     *     MAPIE.Types.UncertaintyPredictorType,
+     *     ($, model) => {
+     *         return $.return(MAPIE.uncertaintyPredictorClassifier(model));
+     *     }
+     * );
+     * ```
+     */
+    uncertaintyPredictorClassifier: mapie_uncertainty_predictor_classifier,
+    /** Type definitions */
+    Types: MAPIETypes,
+};
+//# sourceMappingURL=mapie.js.map

package/dist/src/mapie/mapie.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapie.js","sourceRoot":"","sources":["../../../src/mapie/mapie.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;GAOG;AAEH,OAAO,EACH,IAAI,EACJ,UAAU,EACV,WAAW,EACX,UAAU,EACV,SAAS,EACT,WAAW,EACX,SAAS,EACT,QAAQ,EACR,QAAQ,GACX,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAChF,OAAO,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEpF,yCAAyC;AACzC,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAChF,OAAO,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEpF,+EAA+E;AAC/E,eAAe;AACf,+EAA+E;AAE/E;;GAEG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,WAAW,CAAC;IAC3C,0DAA0D;IAC1D,KAAK,EAAE,QAAQ;IACf,yEAAyE;IACzE,KAAK,EAAE,QAAQ;CAClB,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,WAAW,CAAC;IACrC,sCAAsC;IACtC,OAAO,EAAE,iBAAiB;IAC1B,uCAAuC;IACvC,QAAQ,EAAE,kBAAkB;CAC/B,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CAAC;IACtC,+BAA+B;IAC/B,UAAU,EAAE,aAAa;IACzB,wCAAwC;IACxC,MAAM,EAAE,UAAU,CAAC,mBAAmB,CAAC;IACvC,2EAA2E;IAC3E,gBAAgB,EAAE,UAAU,CAAC,SAAS,CAAC;IACvC,sDAAsD;IACtD,QAAQ,EAAE,UAAU,CAAC,WAAW,CAAC;IACjC,sCAAsC;IACtC,YAAY,EAAE,UAAU,CAAC,WAAW,CAAC;IACrC,mEAAmE;IACnE,cAAc,EAAE,UAAU,CAAC,SAAS,CAAC;CACxC,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC;IACzC,iDAAiD;IACjD,cAAc,EAAE,iBAAiB;IACjC,2EAA2E;IAC3E,gBAAgB,EAAE,UAAU,CAAC,SAAS,CAAC;IACvC,sCAAsC;IACtC,YAAY,EAAE,UAAU,CAAC,WAAW,CAAC;CACxC,CAAC,CAAC;AAEH,+EAA+E;AAC/E,8BAA8B;AAC9B,+EAA+E;AAE/E;;GAEG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,WAAW,CAAC;IAChD,4DAA4D;IAC5D,GAAG,EAAE,QAAQ;IACb,yDAAyD;IACzD,GAAG,EAAE,QAAQ;CAChB,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,WAAW,CAAC;IAC1C,uCAAuC;IACvC,OAAO,EAAE,iBAAiB;IAC1B,wCAAwC;IACxC,QAAQ,EAAE,kBAAkB;CAC/B,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,UAAU,CAAC;IAChD,oCAAoC;IACpC,UAAU,EAAE,kBAAkB;IAC9B,4DAA4D;IAC5D,MAAM,EAAE,UAAU,CAAC,wBAAwB,CAAC;IAC5C,0EAA0E;IAC1E,gBAAgB,EAAE,UAAU,CAAC,SAAS,CAAC;IACvC,sCAAsC;IACtC,YAAY,EAAE,UAAU,CAAC,WAAW,CAAC;CACxC,CAAC,CAAC;AAEH,+EAA+E;AAC/E,mBAAmB;AACnB,+EAA+E;AAE/E;;;GAGG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,WAAW,CAAC;IAC9C,sEAAsE;IACtE,OAAO,EAAE,oBAAoB;IAC7B,6CAA6C;IAC7C,QAAQ,EAAE,qBAAqB;IAC/B,wEAAwE;IACxE,SAAS,EAAE,QAAQ;CACtB,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,WAAW,CAAC;IAC9C,2CAA2C;IAC3C,WAAW,EAAE,UAAU,CAAC;QACpB,kFAAkF;QAClF,IAAI,EAAE,sBAAsB;QAC5B,+BAA+B;QAC/B,UAAU,EAAE,WAAW;QACvB,+CAA+C;QAC/C,gBAAgB,EAAE,SAAS;KAC9B,CAAC;IACF,2CAA2C;IAC3C,WAAW,EAAE,UAAU,CAAC;QACpB,kFAAkF;QAClF,IAAI,EAAE,sBAAsB;QAC5B,+BAA+B;QAC/B,UAAU,EAAE,WAAW;QACvB,+CAA+C;QAC/C,gBAAgB,EAAE,SAAS;KAC9B,CAAC;IACF,iEAAiE;IACjE,SAAS,EAAE,UAAU,CAAC;QAClB,+DAA+D;QAC/D,IAAI,EAAE,sBAAsB;QAC5B,+BAA+B;QAC/B,UAAU,EAAE,WAAW;QACvB,+CAA+C;QAC/C,gBAAgB,EAAE,SAAS;KAC9B,CAAC;CACL,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,WAAW,CAAC;IAC/C,4CAA4C;IAC5C,gBAAgB,EAAE,UAAU,CAAC;QACzB,kFAAkF;QAClF,IAAI,EAAE,sBAAsB;QAC5B,+BAA+B;QAC/B,UAAU,EAAE,WAAW;QACvB,wBAAwB;QACxB,SAAS,EAAE,WAAW;QACtB,mBAAmB;QACnB,OAAO,EAAE,UAAU,CAAC,WAAW,CAAC;QAChC,+CAA+C;QAC/C,gBAAgB,EAAE,SAAS;KAC9B,CAAC;CACL,CAAC,CAAC;AAEH,+EAA+E;AAC/E,qDAAqD;AACrD,+EAA+E;AAE/E;;;;GAIG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,WAAW,CAAC;IAChD,mEAAmE;IACnE,oBAAoB,EAAE,UAAU,CAAC;QAC7B,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE,WAAW;KAC1B,CAAC;IACF,yDAAyD;IACzD,cAAc,EAAE,UAAU,CAAC;QACvB,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE,WAAW;KAC1B,CAAC;CACL,CAAC,CAAC;AAEH,+EAA+E;AAC/E,eAAe;AACf,+EAA+E;AAE/E;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC;IACzC,yCAAyC;IACzC,KAAK,EAAE,UAAU,CAAC,SAAS,CAAC;IAC5B,qCAAqC;IACrC,IAAI,EAAE,UAAU,CAAC,SAAS,CAAC;IAC3B,yCAAyC;IACzC,KAAK,EAAE,UAAU,CAAC,SAAS,CAAC;CAC/B,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,UAAU,CAAC;IAC9C,gDAAgD;IAChD,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC;IAC7B,kFAAkF;IAClF,IAAI,EAAE,SAAS,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;IACvC,kDAAkD;IAClD,aAAa,EAAE,UAAU,CAAC,SAAS,CAAC;IACpC,kCAAkC;IAClC,SAAS,EAAE,UAAU,CAAC,WAAW,CAAC;CACrC,CAAC,CAAC;AAEH,+EAA+E;AAC/E,qBAAqB;AACrB,+EAA+E;AAE/E,mCAAmC;AACnC,uBAAuB;AACvB,mCAAmC;AAEnC;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,IAAI,CAAC,QAAQ,CACxD,iCAAiC,EACjC,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,EAAE,eAAe,CAAC,EAC7G,sBAAsB,CACzB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,IAAI,CAAC,QAAQ,CACxC,iBAAiB,EACjB,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,EAAE,kBAAkB,CAAC,EAChH,sBAAsB,CACzB,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,IAAI,CAAC,QAAQ,CAC/C,wBAAwB,EACxB,CAAC,sBAAsB,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC,EAC/C,kBAAkB,CACrB,CAAC;AAEF,mCAAmC;AACnC,2BAA2B;AAC3B,mCAAmC;AAEnC;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,gCAAgC,GAAG,IAAI,CAAC,QAAQ,CACzD,kCAAkC,EAClC,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC,WAAW,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC,WAAW,CAAC,EAAE,yBAAyB,CAAC,EAC3H,uBAAuB,CAC1B,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,IAAI,CAAC,QAAQ,CAC1C,mBAAmB,EACnB,CAAC,uBAAuB,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC,EAChD,uBAAuB,CAC1B,CAAC;AAEF,mCAAmC;AACnC,6BAA6B;AAC7B,mCAAmC;AAEnC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,qCAAqC,GAAG,IAAI,CAAC,QAAQ,CAC9D,uCAAuC,EACvC,CAAC,sBAAsB,CAAC,EACxB,wBAAwB,CAC3B,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,sCAAsC,GAAG,IAAI,CAAC,QAAQ,CAC/D,wCAAwC,EACxC,CAAC,uBAAuB,CAAC,EACzB,wBAAwB,CAC3B,CAAC;AAEF,+EAA+E;AAC/E,iBAAiB;AACjB,+EAA+E;AAE/E;;GAEG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG;IACtB,eAAe;IACf,mBAAmB;IACnB,iBAAiB;IACjB,kBAAkB;IAClB,aAAa;IACb,eAAe;IACf,kBAAkB;IAClB,wBAAwB;IACxB,kBAAkB;IAClB,yBAAyB;IACzB,mBAAmB;IACnB,sBAAsB;IACtB,sBAAsB;IACtB,uBAAuB;IACvB,wCAAwC;IACxC,wBAAwB;IACxB,eAAe;IACf,kBAAkB;IAClB,uBAAuB;CACjB,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG;IACjB,aAAa;IACb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACH,uBAAuB,EAAE,+BAA+B;IACxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,QAAQ,EAAE,eAAe;IACzB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,eAAe,EAAE,sBAAsB;IACvC,iBAAiB;IACjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,wBAAwB,EAAE,gCAAgC;IAC1D;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,UAAU,EAAE,iBAAiB;IAC7B,6CAA6C;IAC7C;;;;;;;;;;;;;;;;;;;OAmBG;IACH,6BAA6B,EAAE,qCAAqC;IACpE;;;;;;;;;;;;;;;;;;;OAmBG;IACH,8BAA8B,EAAE,sCAAsC;IACtE,uBAAuB;IACvB,KAAK,EAAE,UAAU;CACX,CAAC"}