@elaraai/east-py-datascience 0.0.2-beta.1

package/dist/shap/shap.d.ts

@@ -0,0 +1,657 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * SHAP platform functions for East.
+ *
+ * Provides model-agnostic feature importance and explainability using SHAP values.
+ * Uses cloudpickle for explainer serialization.
+ *
+ * @packageDocumentation
+ */
+import { StructType, VariantType, OptionType, IntegerType, FloatType, StringType, ArrayType, BlobType } from "@elaraai/east";
+export { VectorType, MatrixType } from "../types.js";
+/** String vector type for feature names */
+export declare const StringVectorType: ArrayType<StringType>;
+/**
+ * Result type for SHAP value computation.
+ */
+export declare const ShapResultType: StructType<{
+    /** SHAP values matrix (n_samples x n_features) */
+    shap_values: ArrayType<ArrayType<FloatType>>;
+    /** Base value (expected model output) */
+    base_value: FloatType;
+    /** Feature names */
+    feature_names: ArrayType<StringType>;
+}>;
+/**
+ * Result type for feature importance.
+ */
+export declare const FeatureImportanceType: StructType<{
+    /** Feature names */
+    feature_names: ArrayType<StringType>;
+    /** Mean absolute SHAP value for each feature */
+    importances: ArrayType<FloatType>;
+    /** Standard deviation of absolute SHAP values */
+    std: OptionType<ArrayType<FloatType>>;
+}>;
+/**
+ * Model blob type for serialized SHAP explainers.
+ */
+export declare const ShapModelBlobType: VariantType<{
+    /** SHAP TreeExplainer for tree-based models */
+    shap_tree_explainer: StructType<{
+        /** Cloudpickle serialized explainer */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** SHAP KernelExplainer for any model */
+    shap_kernel_explainer: StructType<{
+        /** Cloudpickle serialized explainer */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+}>;
+/**
+ * Tree-based model blob type - accepts XGBoost and LightGBM models.
+ */
+export declare const TreeModelBlobType: VariantType<{
+    /** XGBoost regressor */
+    xgboost_regressor: StructType<{
+        data: BlobType;
+        n_features: IntegerType;
+    }>;
+    /** XGBoost classifier */
+    xgboost_classifier: StructType<{
+        data: BlobType;
+        n_features: IntegerType;
+        n_classes: IntegerType;
+    }>;
+    /** LightGBM regressor */
+    lightgbm_regressor: StructType<{
+        data: BlobType;
+        n_features: IntegerType;
+    }>;
+    /** LightGBM classifier */
+    lightgbm_classifier: StructType<{
+        data: BlobType;
+        n_features: IntegerType;
+        n_classes: IntegerType;
+    }>;
+}>;
+/**
+ * Any model blob type - accepts any model for kernel explainer.
+ * Includes all tree-based models plus NGBoost, GP, and Torch.
+ */
+export declare const AnyModelBlobType: VariantType<{
+    xgboost_regressor: StructType<{
+        data: BlobType;
+        n_features: IntegerType;
+    }>;
+    xgboost_classifier: StructType<{
+        data: BlobType;
+        n_features: IntegerType;
+        n_classes: IntegerType;
+    }>;
+    lightgbm_regressor: StructType<{
+        data: BlobType;
+        n_features: IntegerType;
+    }>;
+    lightgbm_classifier: StructType<{
+        data: BlobType;
+        n_features: IntegerType;
+        n_classes: IntegerType;
+    }>;
+    ngboost_regressor: StructType<{
+        data: BlobType;
+        distribution: VariantType<{
+            normal: StructType<{}>;
+            lognormal: StructType<{}>;
+        }>;
+        n_features: IntegerType;
+    }>;
+    gp_regressor: StructType<{
+        data: BlobType;
+        n_features: IntegerType;
+        kernel_type: StringType;
+    }>;
+    torch_mlp: StructType<{
+        data: BlobType;
+        n_features: IntegerType;
+        hidden_layers: ArrayType<IntegerType>;
+        output_dim: IntegerType;
+    }>;
+}>;
+/**
+ * Create a SHAP TreeExplainer for tree-based models.
+ *
+ * Works with XGBoost and LightGBM models (regressor and classifier).
+ *
+ * @param model - Tree-based model blob (XGBoost or LightGBM)
+ * @returns SHAP TreeExplainer blob
+ */
+export declare const shap_tree_explainer_create: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** XGBoost regressor */
+    xgboost_regressor: StructType<{
+        data: BlobType;
+        n_features: IntegerType;
+    }>;
+    /** XGBoost classifier */
+    xgboost_classifier: StructType<{
+        data: BlobType;
+        n_features: IntegerType;
+        n_classes: IntegerType;
+    }>;
+    /** LightGBM regressor */
+    lightgbm_regressor: StructType<{
+        data: BlobType;
+        n_features: IntegerType;
+    }>;
+    /** LightGBM classifier */
+    lightgbm_classifier: StructType<{
+        data: BlobType;
+        n_features: IntegerType;
+        n_classes: IntegerType;
+    }>;
+}>], VariantType<{
+    /** SHAP TreeExplainer for tree-based models */
+    shap_tree_explainer: StructType<{
+        /** Cloudpickle serialized explainer */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** SHAP KernelExplainer for any model */
+    shap_kernel_explainer: StructType<{
+        /** Cloudpickle serialized explainer */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+}>>;
+/**
+ * Create a SHAP KernelExplainer for any model.
+ *
+ * Works with any model that has a predict method (NGBoost, GP, Torch, etc.).
+ * Requires background data for computing expected values.
+ *
+ * @param model - Any model blob
+ * @param X_background - Background data for computing expected values
+ * @returns SHAP KernelExplainer blob
+ */
+export declare const shap_kernel_explainer_create: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    xgboost_regressor: StructType<{
+        data: BlobType;
+        n_features: IntegerType;
+    }>;
+    xgboost_classifier: StructType<{
+        data: BlobType;
+        n_features: IntegerType;
+        n_classes: IntegerType;
+    }>;
+    lightgbm_regressor: StructType<{
+        data: BlobType;
+        n_features: IntegerType;
+    }>;
+    lightgbm_classifier: StructType<{
+        data: BlobType;
+        n_features: IntegerType;
+        n_classes: IntegerType;
+    }>;
+    ngboost_regressor: StructType<{
+        data: BlobType;
+        distribution: VariantType<{
+            normal: StructType<{}>;
+            lognormal: StructType<{}>;
+        }>;
+        n_features: IntegerType;
+    }>;
+    gp_regressor: StructType<{
+        data: BlobType;
+        n_features: IntegerType;
+        kernel_type: StringType;
+    }>;
+    torch_mlp: StructType<{
+        data: BlobType;
+        n_features: IntegerType;
+        hidden_layers: ArrayType<IntegerType>;
+        output_dim: IntegerType;
+    }>;
+}>, ArrayType<ArrayType<FloatType>>], VariantType<{
+    /** SHAP TreeExplainer for tree-based models */
+    shap_tree_explainer: StructType<{
+        /** Cloudpickle serialized explainer */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** SHAP KernelExplainer for any model */
+    shap_kernel_explainer: StructType<{
+        /** Cloudpickle serialized explainer */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+}>>;
+/**
+ * Compute SHAP values for samples.
+ *
+ * @param explainer - SHAP explainer blob
+ * @param X - Feature matrix to explain
+ * @param feature_names - Names of features
+ * @returns SHAP values, base value, and feature names
+ */
+export declare const shap_compute_values: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** SHAP TreeExplainer for tree-based models */
+    shap_tree_explainer: StructType<{
+        /** Cloudpickle serialized explainer */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** SHAP KernelExplainer for any model */
+    shap_kernel_explainer: StructType<{
+        /** Cloudpickle serialized explainer */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+}>, ArrayType<ArrayType<FloatType>>, ArrayType<StringType>], StructType<{
+    /** SHAP values matrix (n_samples x n_features) */
+    shap_values: ArrayType<ArrayType<FloatType>>;
+    /** Base value (expected model output) */
+    base_value: FloatType;
+    /** Feature names */
+    feature_names: ArrayType<StringType>;
+}>>;
+/**
+ * Compute global feature importance from SHAP values.
+ *
+ * @param shap_values - SHAP values matrix
+ * @param feature_names - Names of features
+ * @returns Feature importance with mean |SHAP| values
+ */
+export declare const shap_feature_importance: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<StringType>], StructType<{
+    /** Feature names */
+    feature_names: ArrayType<StringType>;
+    /** Mean absolute SHAP value for each feature */
+    importances: ArrayType<FloatType>;
+    /** Standard deviation of absolute SHAP values */
+    std: OptionType<ArrayType<FloatType>>;
+}>>;
+/**
+ * Type definitions for SHAP functions.
+ */
+export declare const ShapTypes: {
+    /** Vector type (array of floats) */
+    readonly VectorType: ArrayType<FloatType>;
+    /** Matrix type (2D array of floats) */
+    readonly MatrixType: ArrayType<ArrayType<FloatType>>;
+    /** String vector type */
+    readonly StringVectorType: ArrayType<StringType>;
+    /** SHAP result type */
+    readonly ShapResultType: StructType<{
+        /** SHAP values matrix (n_samples x n_features) */
+        shap_values: ArrayType<ArrayType<FloatType>>;
+        /** Base value (expected model output) */
+        base_value: FloatType;
+        /** Feature names */
+        feature_names: ArrayType<StringType>;
+    }>;
+    /** Feature importance type */
+    readonly FeatureImportanceType: StructType<{
+        /** Feature names */
+        feature_names: ArrayType<StringType>;
+        /** Mean absolute SHAP value for each feature */
+        importances: ArrayType<FloatType>;
+        /** Standard deviation of absolute SHAP values */
+        std: OptionType<ArrayType<FloatType>>;
+    }>;
+    /** SHAP explainer model blob type */
+    readonly ShapModelBlobType: VariantType<{
+        /** SHAP TreeExplainer for tree-based models */
+        shap_tree_explainer: StructType<{
+            /** Cloudpickle serialized explainer */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** SHAP KernelExplainer for any model */
+        shap_kernel_explainer: StructType<{
+            /** Cloudpickle serialized explainer */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+    }>;
+    /** Tree model blob type for input */
+    readonly TreeModelBlobType: VariantType<{
+        /** XGBoost regressor */
+        xgboost_regressor: StructType<{
+            data: BlobType;
+            n_features: IntegerType;
+        }>;
+        /** XGBoost classifier */
+        xgboost_classifier: StructType<{
+            data: BlobType;
+            n_features: IntegerType;
+            n_classes: IntegerType;
+        }>;
+        /** LightGBM regressor */
+        lightgbm_regressor: StructType<{
+            data: BlobType;
+            n_features: IntegerType;
+        }>;
+        /** LightGBM classifier */
+        lightgbm_classifier: StructType<{
+            data: BlobType;
+            n_features: IntegerType;
+            n_classes: IntegerType;
+        }>;
+    }>;
+    /** Any model blob type for kernel explainer */
+    readonly AnyModelBlobType: VariantType<{
+        xgboost_regressor: StructType<{
+            data: BlobType;
+            n_features: IntegerType;
+        }>;
+        xgboost_classifier: StructType<{
+            data: BlobType;
+            n_features: IntegerType;
+            n_classes: IntegerType;
+        }>;
+        lightgbm_regressor: StructType<{
+            data: BlobType;
+            n_features: IntegerType;
+        }>;
+        lightgbm_classifier: StructType<{
+            data: BlobType;
+            n_features: IntegerType;
+            n_classes: IntegerType;
+        }>;
+        ngboost_regressor: StructType<{
+            data: BlobType;
+            distribution: VariantType<{
+                normal: StructType<{}>;
+                lognormal: StructType<{}>;
+            }>;
+            n_features: IntegerType;
+        }>;
+        gp_regressor: StructType<{
+            data: BlobType;
+            n_features: IntegerType;
+            kernel_type: StringType;
+        }>;
+        torch_mlp: StructType<{
+            data: BlobType;
+            n_features: IntegerType;
+            hidden_layers: ArrayType<IntegerType>;
+            output_dim: IntegerType;
+        }>;
+    }>;
+};
+/**
+ * SHAP explainability functions.
+ *
+ * Provides model-agnostic feature importance and SHAP value computation.
+ *
+ * @example
+ * ```ts
+ * import { East, variant } from "@elaraai/east";
+ * import { Shap, LightGBM } from "@elaraai/east-py-datascience";
+ *
+ * const explain = East.function([LightGBM.Types.ModelBlobType, Shap.Types.MatrixType], Shap.Types.ShapResultType, ($, model, X) => {
+ *     // Create explainer
+ *     const explainer = $.let(Shap.treeExplainerCreate(model));
+ *
+ *     // Compute SHAP values
+ *     const feature_names = $.let(["feature1", "feature2"]);
+ *     const result = $.let(Shap.computeValues(explainer, X, feature_names));
+ *
+ *     return $.return(result);
+ * });
+ * ```
+ */
+export declare const Shap: {
+    /** Create TreeExplainer for tree-based models */
+    readonly treeExplainerCreate: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** XGBoost regressor */
+        xgboost_regressor: StructType<{
+            data: BlobType;
+            n_features: IntegerType;
+        }>;
+        /** XGBoost classifier */
+        xgboost_classifier: StructType<{
+            data: BlobType;
+            n_features: IntegerType;
+            n_classes: IntegerType;
+        }>;
+        /** LightGBM regressor */
+        lightgbm_regressor: StructType<{
+            data: BlobType;
+            n_features: IntegerType;
+        }>;
+        /** LightGBM classifier */
+        lightgbm_classifier: StructType<{
+            data: BlobType;
+            n_features: IntegerType;
+            n_classes: IntegerType;
+        }>;
+    }>], VariantType<{
+        /** SHAP TreeExplainer for tree-based models */
+        shap_tree_explainer: StructType<{
+            /** Cloudpickle serialized explainer */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** SHAP KernelExplainer for any model */
+        shap_kernel_explainer: StructType<{
+            /** Cloudpickle serialized explainer */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+    }>>;
+    /** Create KernelExplainer for any model */
+    readonly kernelExplainerCreate: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        xgboost_regressor: StructType<{
+            data: BlobType;
+            n_features: IntegerType;
+        }>;
+        xgboost_classifier: StructType<{
+            data: BlobType;
+            n_features: IntegerType;
+            n_classes: IntegerType;
+        }>;
+        lightgbm_regressor: StructType<{
+            data: BlobType;
+            n_features: IntegerType;
+        }>;
+        lightgbm_classifier: StructType<{
+            data: BlobType;
+            n_features: IntegerType;
+            n_classes: IntegerType;
+        }>;
+        ngboost_regressor: StructType<{
+            data: BlobType;
+            distribution: VariantType<{
+                normal: StructType<{}>;
+                lognormal: StructType<{}>;
+            }>;
+            n_features: IntegerType;
+        }>;
+        gp_regressor: StructType<{
+            data: BlobType;
+            n_features: IntegerType;
+            kernel_type: StringType;
+        }>;
+        torch_mlp: StructType<{
+            data: BlobType;
+            n_features: IntegerType;
+            hidden_layers: ArrayType<IntegerType>;
+            output_dim: IntegerType;
+        }>;
+    }>, ArrayType<ArrayType<FloatType>>], VariantType<{
+        /** SHAP TreeExplainer for tree-based models */
+        shap_tree_explainer: StructType<{
+            /** Cloudpickle serialized explainer */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** SHAP KernelExplainer for any model */
+        shap_kernel_explainer: StructType<{
+            /** Cloudpickle serialized explainer */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+    }>>;
+    /** Compute SHAP values */
+    readonly computeValues: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** SHAP TreeExplainer for tree-based models */
+        shap_tree_explainer: StructType<{
+            /** Cloudpickle serialized explainer */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** SHAP KernelExplainer for any model */
+        shap_kernel_explainer: StructType<{
+            /** Cloudpickle serialized explainer */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+    }>, ArrayType<ArrayType<FloatType>>, ArrayType<StringType>], StructType<{
+        /** SHAP values matrix (n_samples x n_features) */
+        shap_values: ArrayType<ArrayType<FloatType>>;
+        /** Base value (expected model output) */
+        base_value: FloatType;
+        /** Feature names */
+        feature_names: ArrayType<StringType>;
+    }>>;
+    /** Compute feature importance from SHAP values */
+    readonly featureImportance: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<StringType>], StructType<{
+        /** Feature names */
+        feature_names: ArrayType<StringType>;
+        /** Mean absolute SHAP value for each feature */
+        importances: ArrayType<FloatType>;
+        /** Standard deviation of absolute SHAP values */
+        std: OptionType<ArrayType<FloatType>>;
+    }>>;
+    /** Type definitions */
+    readonly Types: {
+        /** Vector type (array of floats) */
+        readonly VectorType: ArrayType<FloatType>;
+        /** Matrix type (2D array of floats) */
+        readonly MatrixType: ArrayType<ArrayType<FloatType>>;
+        /** String vector type */
+        readonly StringVectorType: ArrayType<StringType>;
+        /** SHAP result type */
+        readonly ShapResultType: StructType<{
+            /** SHAP values matrix (n_samples x n_features) */
+            shap_values: ArrayType<ArrayType<FloatType>>;
+            /** Base value (expected model output) */
+            base_value: FloatType;
+            /** Feature names */
+            feature_names: ArrayType<StringType>;
+        }>;
+        /** Feature importance type */
+        readonly FeatureImportanceType: StructType<{
+            /** Feature names */
+            feature_names: ArrayType<StringType>;
+            /** Mean absolute SHAP value for each feature */
+            importances: ArrayType<FloatType>;
+            /** Standard deviation of absolute SHAP values */
+            std: OptionType<ArrayType<FloatType>>;
+        }>;
+        /** SHAP explainer model blob type */
+        readonly ShapModelBlobType: VariantType<{
+            /** SHAP TreeExplainer for tree-based models */
+            shap_tree_explainer: StructType<{
+                /** Cloudpickle serialized explainer */
+                data: BlobType;
+                /** Number of input features */
+                n_features: IntegerType;
+            }>;
+            /** SHAP KernelExplainer for any model */
+            shap_kernel_explainer: StructType<{
+                /** Cloudpickle serialized explainer */
+                data: BlobType;
+                /** Number of input features */
+                n_features: IntegerType;
+            }>;
+        }>;
+        /** Tree model blob type for input */
+        readonly TreeModelBlobType: VariantType<{
+            /** XGBoost regressor */
+            xgboost_regressor: StructType<{
+                data: BlobType;
+                n_features: IntegerType;
+            }>;
+            /** XGBoost classifier */
+            xgboost_classifier: StructType<{
+                data: BlobType;
+                n_features: IntegerType;
+                n_classes: IntegerType;
+            }>;
+            /** LightGBM regressor */
+            lightgbm_regressor: StructType<{
+                data: BlobType;
+                n_features: IntegerType;
+            }>;
+            /** LightGBM classifier */
+            lightgbm_classifier: StructType<{
+                data: BlobType;
+                n_features: IntegerType;
+                n_classes: IntegerType;
+            }>;
+        }>;
+        /** Any model blob type for kernel explainer */
+        readonly AnyModelBlobType: VariantType<{
+            xgboost_regressor: StructType<{
+                data: BlobType;
+                n_features: IntegerType;
+            }>;
+            xgboost_classifier: StructType<{
+                data: BlobType;
+                n_features: IntegerType;
+                n_classes: IntegerType;
+            }>;
+            lightgbm_regressor: StructType<{
+                data: BlobType;
+                n_features: IntegerType;
+            }>;
+            lightgbm_classifier: StructType<{
+                data: BlobType;
+                n_features: IntegerType;
+                n_classes: IntegerType;
+            }>;
+            ngboost_regressor: StructType<{
+                data: BlobType;
+                distribution: VariantType<{
+                    normal: StructType<{}>;
+                    lognormal: StructType<{}>;
+                }>;
+                n_features: IntegerType;
+            }>;
+            gp_regressor: StructType<{
+                data: BlobType;
+                n_features: IntegerType;
+                kernel_type: StringType;
+            }>;
+            torch_mlp: StructType<{
+                data: BlobType;
+                n_features: IntegerType;
+                hidden_layers: ArrayType<IntegerType>;
+                output_dim: IntegerType;
+            }>;
+        }>;
+    };
+};
+//# sourceMappingURL=shap.d.ts.map

package/dist/shap/shap.d.ts.map

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