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

package/dist/lightgbm/lightgbm.d.ts

@@ -0,0 +1,494 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * LightGBM platform functions for East.
+ *
+ * Provides fast gradient boosting for regression and classification.
+ * Uses cloudpickle for model serialization.
+ *
+ * @packageDocumentation
+ */
+import { StructType, VariantType, OptionType, IntegerType, FloatType, BlobType } from "@elaraai/east";
+export { VectorType, MatrixType, LabelVectorType } from "../types.js";
+/**
+ * Configuration for LightGBM models.
+ */
+export declare const LightGBMConfigType: StructType<{
+    /** Number of boosting rounds (default 100) */
+    n_estimators: OptionType<IntegerType>;
+    /** Maximum tree depth, -1 for unlimited (default -1) */
+    max_depth: OptionType<IntegerType>;
+    /** Learning rate / step size shrinkage (default 0.1) */
+    learning_rate: OptionType<FloatType>;
+    /** Maximum number of leaves in one tree (default 31) */
+    num_leaves: OptionType<IntegerType>;
+    /** Minimum number of samples required in a leaf (default 20) */
+    min_child_samples: OptionType<IntegerType>;
+    /** Subsample ratio of training instances (default 1.0) */
+    subsample: OptionType<FloatType>;
+    /** Subsample ratio of columns when constructing trees (default 1.0) */
+    colsample_bytree: OptionType<FloatType>;
+    /** L1 regularization term (default 0) */
+    reg_alpha: OptionType<FloatType>;
+    /** L2 regularization term (default 0) */
+    reg_lambda: OptionType<FloatType>;
+    /** Random seed for reproducibility */
+    random_state: OptionType<IntegerType>;
+    /** Number of parallel threads (default -1 for all cores) */
+    n_jobs: OptionType<IntegerType>;
+}>;
+/**
+ * Model blob type for serialized LightGBM models.
+ *
+ * Each model type has its own variant case containing cloudpickle bytes and metadata.
+ */
+export declare const LightGBMModelBlobType: VariantType<{
+    /** LightGBM regressor model */
+    lightgbm_regressor: StructType<{
+        /** Cloudpickle serialized model */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** LightGBM classifier model */
+    lightgbm_classifier: StructType<{
+        /** Cloudpickle serialized model */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+        /** Number of classes */
+        n_classes: IntegerType;
+    }>;
+}>;
+/**
+ * Train a LightGBM regression model.
+ *
+ * @param X - Feature matrix
+ * @param y - Target vector
+ * @param config - LightGBM configuration
+ * @returns Model blob containing trained regressor
+ */
+export declare const lightgbm_train_regressor: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>, import("@elaraai/east").ArrayType<FloatType>, StructType<{
+    /** Number of boosting rounds (default 100) */
+    n_estimators: OptionType<IntegerType>;
+    /** Maximum tree depth, -1 for unlimited (default -1) */
+    max_depth: OptionType<IntegerType>;
+    /** Learning rate / step size shrinkage (default 0.1) */
+    learning_rate: OptionType<FloatType>;
+    /** Maximum number of leaves in one tree (default 31) */
+    num_leaves: OptionType<IntegerType>;
+    /** Minimum number of samples required in a leaf (default 20) */
+    min_child_samples: OptionType<IntegerType>;
+    /** Subsample ratio of training instances (default 1.0) */
+    subsample: OptionType<FloatType>;
+    /** Subsample ratio of columns when constructing trees (default 1.0) */
+    colsample_bytree: OptionType<FloatType>;
+    /** L1 regularization term (default 0) */
+    reg_alpha: OptionType<FloatType>;
+    /** L2 regularization term (default 0) */
+    reg_lambda: OptionType<FloatType>;
+    /** Random seed for reproducibility */
+    random_state: OptionType<IntegerType>;
+    /** Number of parallel threads (default -1 for all cores) */
+    n_jobs: OptionType<IntegerType>;
+}>], VariantType<{
+    /** LightGBM regressor model */
+    lightgbm_regressor: StructType<{
+        /** Cloudpickle serialized model */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** LightGBM classifier model */
+    lightgbm_classifier: StructType<{
+        /** Cloudpickle serialized model */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+        /** Number of classes */
+        n_classes: IntegerType;
+    }>;
+}>>;
+/**
+ * Train a LightGBM classification model.
+ *
+ * @param X - Feature matrix
+ * @param y - Label vector (integer class labels)
+ * @param config - LightGBM configuration
+ * @returns Model blob containing trained classifier
+ */
+export declare const lightgbm_train_classifier: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>, import("@elaraai/east").ArrayType<IntegerType>, StructType<{
+    /** Number of boosting rounds (default 100) */
+    n_estimators: OptionType<IntegerType>;
+    /** Maximum tree depth, -1 for unlimited (default -1) */
+    max_depth: OptionType<IntegerType>;
+    /** Learning rate / step size shrinkage (default 0.1) */
+    learning_rate: OptionType<FloatType>;
+    /** Maximum number of leaves in one tree (default 31) */
+    num_leaves: OptionType<IntegerType>;
+    /** Minimum number of samples required in a leaf (default 20) */
+    min_child_samples: OptionType<IntegerType>;
+    /** Subsample ratio of training instances (default 1.0) */
+    subsample: OptionType<FloatType>;
+    /** Subsample ratio of columns when constructing trees (default 1.0) */
+    colsample_bytree: OptionType<FloatType>;
+    /** L1 regularization term (default 0) */
+    reg_alpha: OptionType<FloatType>;
+    /** L2 regularization term (default 0) */
+    reg_lambda: OptionType<FloatType>;
+    /** Random seed for reproducibility */
+    random_state: OptionType<IntegerType>;
+    /** Number of parallel threads (default -1 for all cores) */
+    n_jobs: OptionType<IntegerType>;
+}>], VariantType<{
+    /** LightGBM regressor model */
+    lightgbm_regressor: StructType<{
+        /** Cloudpickle serialized model */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** LightGBM classifier model */
+    lightgbm_classifier: StructType<{
+        /** Cloudpickle serialized model */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+        /** Number of classes */
+        n_classes: IntegerType;
+    }>;
+}>>;
+/**
+ * Make predictions with a trained LightGBM regressor.
+ *
+ * @param model - Trained regressor model blob
+ * @param X - Feature matrix
+ * @returns Predicted values
+ */
+export declare const lightgbm_predict: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** LightGBM regressor model */
+    lightgbm_regressor: StructType<{
+        /** Cloudpickle serialized model */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** LightGBM classifier model */
+    lightgbm_classifier: StructType<{
+        /** Cloudpickle serialized model */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+        /** Number of classes */
+        n_classes: IntegerType;
+    }>;
+}>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], import("@elaraai/east").ArrayType<FloatType>>;
+/**
+ * Predict class labels with a trained LightGBM classifier.
+ *
+ * @param model - Trained classifier model blob
+ * @param X - Feature matrix
+ * @returns Predicted class labels
+ */
+export declare const lightgbm_predict_class: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** LightGBM regressor model */
+    lightgbm_regressor: StructType<{
+        /** Cloudpickle serialized model */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** LightGBM classifier model */
+    lightgbm_classifier: StructType<{
+        /** Cloudpickle serialized model */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+        /** Number of classes */
+        n_classes: IntegerType;
+    }>;
+}>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], import("@elaraai/east").ArrayType<IntegerType>>;
+/**
+ * Get class probabilities from a trained LightGBM classifier.
+ *
+ * @param model - Trained classifier model blob
+ * @param X - Feature matrix
+ * @returns Probability matrix (n_samples x n_classes)
+ */
+export declare const lightgbm_predict_proba: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** LightGBM regressor model */
+    lightgbm_regressor: StructType<{
+        /** Cloudpickle serialized model */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+    }>;
+    /** LightGBM classifier model */
+    lightgbm_classifier: StructType<{
+        /** Cloudpickle serialized model */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+        /** Number of classes */
+        n_classes: IntegerType;
+    }>;
+}>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>>;
+/**
+ * Type definitions for LightGBM functions.
+ */
+export declare const LightGBMTypes: {
+    /** Vector type (array of floats) */
+    readonly VectorType: import("@elaraai/east").ArrayType<FloatType>;
+    /** Matrix type (2D array of floats) */
+    readonly MatrixType: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
+    /** Label vector type (array of integers) */
+    readonly LabelVectorType: import("@elaraai/east").ArrayType<IntegerType>;
+    /** LightGBM configuration type */
+    readonly LightGBMConfigType: StructType<{
+        /** Number of boosting rounds (default 100) */
+        n_estimators: OptionType<IntegerType>;
+        /** Maximum tree depth, -1 for unlimited (default -1) */
+        max_depth: OptionType<IntegerType>;
+        /** Learning rate / step size shrinkage (default 0.1) */
+        learning_rate: OptionType<FloatType>;
+        /** Maximum number of leaves in one tree (default 31) */
+        num_leaves: OptionType<IntegerType>;
+        /** Minimum number of samples required in a leaf (default 20) */
+        min_child_samples: OptionType<IntegerType>;
+        /** Subsample ratio of training instances (default 1.0) */
+        subsample: OptionType<FloatType>;
+        /** Subsample ratio of columns when constructing trees (default 1.0) */
+        colsample_bytree: OptionType<FloatType>;
+        /** L1 regularization term (default 0) */
+        reg_alpha: OptionType<FloatType>;
+        /** L2 regularization term (default 0) */
+        reg_lambda: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        random_state: OptionType<IntegerType>;
+        /** Number of parallel threads (default -1 for all cores) */
+        n_jobs: OptionType<IntegerType>;
+    }>;
+    /** Model blob type for LightGBM models */
+    readonly ModelBlobType: VariantType<{
+        /** LightGBM regressor model */
+        lightgbm_regressor: StructType<{
+            /** Cloudpickle serialized model */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** LightGBM classifier model */
+        lightgbm_classifier: StructType<{
+            /** Cloudpickle serialized model */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+            /** Number of classes */
+            n_classes: IntegerType;
+        }>;
+    }>;
+};
+/**
+ * LightGBM gradient boosting.
+ *
+ * Provides fast regression and classification with gradient boosted decision trees.
+ */
+export declare const LightGBM: {
+    /** Train LightGBM regressor */
+    readonly trainRegressor: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>, import("@elaraai/east").ArrayType<FloatType>, StructType<{
+        /** Number of boosting rounds (default 100) */
+        n_estimators: OptionType<IntegerType>;
+        /** Maximum tree depth, -1 for unlimited (default -1) */
+        max_depth: OptionType<IntegerType>;
+        /** Learning rate / step size shrinkage (default 0.1) */
+        learning_rate: OptionType<FloatType>;
+        /** Maximum number of leaves in one tree (default 31) */
+        num_leaves: OptionType<IntegerType>;
+        /** Minimum number of samples required in a leaf (default 20) */
+        min_child_samples: OptionType<IntegerType>;
+        /** Subsample ratio of training instances (default 1.0) */
+        subsample: OptionType<FloatType>;
+        /** Subsample ratio of columns when constructing trees (default 1.0) */
+        colsample_bytree: OptionType<FloatType>;
+        /** L1 regularization term (default 0) */
+        reg_alpha: OptionType<FloatType>;
+        /** L2 regularization term (default 0) */
+        reg_lambda: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        random_state: OptionType<IntegerType>;
+        /** Number of parallel threads (default -1 for all cores) */
+        n_jobs: OptionType<IntegerType>;
+    }>], VariantType<{
+        /** LightGBM regressor model */
+        lightgbm_regressor: StructType<{
+            /** Cloudpickle serialized model */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** LightGBM classifier model */
+        lightgbm_classifier: StructType<{
+            /** Cloudpickle serialized model */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+            /** Number of classes */
+            n_classes: IntegerType;
+        }>;
+    }>>;
+    /** Train LightGBM classifier */
+    readonly trainClassifier: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>, import("@elaraai/east").ArrayType<IntegerType>, StructType<{
+        /** Number of boosting rounds (default 100) */
+        n_estimators: OptionType<IntegerType>;
+        /** Maximum tree depth, -1 for unlimited (default -1) */
+        max_depth: OptionType<IntegerType>;
+        /** Learning rate / step size shrinkage (default 0.1) */
+        learning_rate: OptionType<FloatType>;
+        /** Maximum number of leaves in one tree (default 31) */
+        num_leaves: OptionType<IntegerType>;
+        /** Minimum number of samples required in a leaf (default 20) */
+        min_child_samples: OptionType<IntegerType>;
+        /** Subsample ratio of training instances (default 1.0) */
+        subsample: OptionType<FloatType>;
+        /** Subsample ratio of columns when constructing trees (default 1.0) */
+        colsample_bytree: OptionType<FloatType>;
+        /** L1 regularization term (default 0) */
+        reg_alpha: OptionType<FloatType>;
+        /** L2 regularization term (default 0) */
+        reg_lambda: OptionType<FloatType>;
+        /** Random seed for reproducibility */
+        random_state: OptionType<IntegerType>;
+        /** Number of parallel threads (default -1 for all cores) */
+        n_jobs: OptionType<IntegerType>;
+    }>], VariantType<{
+        /** LightGBM regressor model */
+        lightgbm_regressor: StructType<{
+            /** Cloudpickle serialized model */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** LightGBM classifier model */
+        lightgbm_classifier: StructType<{
+            /** Cloudpickle serialized model */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+            /** Number of classes */
+            n_classes: IntegerType;
+        }>;
+    }>>;
+    /** Make predictions with regressor */
+    readonly predict: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** LightGBM regressor model */
+        lightgbm_regressor: StructType<{
+            /** Cloudpickle serialized model */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** LightGBM classifier model */
+        lightgbm_classifier: StructType<{
+            /** Cloudpickle serialized model */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+            /** Number of classes */
+            n_classes: IntegerType;
+        }>;
+    }>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], import("@elaraai/east").ArrayType<FloatType>>;
+    /** Predict class labels with classifier */
+    readonly predictClass: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** LightGBM regressor model */
+        lightgbm_regressor: StructType<{
+            /** Cloudpickle serialized model */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** LightGBM classifier model */
+        lightgbm_classifier: StructType<{
+            /** Cloudpickle serialized model */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+            /** Number of classes */
+            n_classes: IntegerType;
+        }>;
+    }>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], import("@elaraai/east").ArrayType<IntegerType>>;
+    /** Get class probabilities from classifier */
+    readonly predictProba: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** LightGBM regressor model */
+        lightgbm_regressor: StructType<{
+            /** Cloudpickle serialized model */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+        }>;
+        /** LightGBM classifier model */
+        lightgbm_classifier: StructType<{
+            /** Cloudpickle serialized model */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+            /** Number of classes */
+            n_classes: IntegerType;
+        }>;
+    }>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>>;
+    /** Type definitions */
+    readonly Types: {
+        /** Vector type (array of floats) */
+        readonly VectorType: import("@elaraai/east").ArrayType<FloatType>;
+        /** Matrix type (2D array of floats) */
+        readonly MatrixType: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>;
+        /** Label vector type (array of integers) */
+        readonly LabelVectorType: import("@elaraai/east").ArrayType<IntegerType>;
+        /** LightGBM configuration type */
+        readonly LightGBMConfigType: StructType<{
+            /** Number of boosting rounds (default 100) */
+            n_estimators: OptionType<IntegerType>;
+            /** Maximum tree depth, -1 for unlimited (default -1) */
+            max_depth: OptionType<IntegerType>;
+            /** Learning rate / step size shrinkage (default 0.1) */
+            learning_rate: OptionType<FloatType>;
+            /** Maximum number of leaves in one tree (default 31) */
+            num_leaves: OptionType<IntegerType>;
+            /** Minimum number of samples required in a leaf (default 20) */
+            min_child_samples: OptionType<IntegerType>;
+            /** Subsample ratio of training instances (default 1.0) */
+            subsample: OptionType<FloatType>;
+            /** Subsample ratio of columns when constructing trees (default 1.0) */
+            colsample_bytree: OptionType<FloatType>;
+            /** L1 regularization term (default 0) */
+            reg_alpha: OptionType<FloatType>;
+            /** L2 regularization term (default 0) */
+            reg_lambda: OptionType<FloatType>;
+            /** Random seed for reproducibility */
+            random_state: OptionType<IntegerType>;
+            /** Number of parallel threads (default -1 for all cores) */
+            n_jobs: OptionType<IntegerType>;
+        }>;
+        /** Model blob type for LightGBM models */
+        readonly ModelBlobType: VariantType<{
+            /** LightGBM regressor model */
+            lightgbm_regressor: StructType<{
+                /** Cloudpickle serialized model */
+                data: BlobType;
+                /** Number of input features */
+                n_features: IntegerType;
+            }>;
+            /** LightGBM classifier model */
+            lightgbm_classifier: StructType<{
+                /** Cloudpickle serialized model */
+                data: BlobType;
+                /** Number of input features */
+                n_features: IntegerType;
+                /** Number of classes */
+                n_classes: IntegerType;
+            }>;
+        }>;
+    };
+};
+//# sourceMappingURL=lightgbm.d.ts.map

package/dist/lightgbm/lightgbm.d.ts.map

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

package/dist/lightgbm/lightgbm.js

@@ -0,0 +1,155 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * LightGBM platform functions for East.
+ *
+ * Provides fast gradient boosting for regression and classification.
+ * Uses cloudpickle for model serialization.
+ *
+ * @packageDocumentation
+ */
+import { East, StructType, VariantType, OptionType, IntegerType, FloatType, BlobType, } from "@elaraai/east";
+import { VectorType, MatrixType, LabelVectorType } from "../types.js";
+// Re-export shared types for convenience
+export { VectorType, MatrixType, LabelVectorType } from "../types.js";
+// ============================================================================
+// Config Types
+// ============================================================================
+/**
+ * Configuration for LightGBM models.
+ */
+export const LightGBMConfigType = StructType({
+    /** Number of boosting rounds (default 100) */
+    n_estimators: OptionType(IntegerType),
+    /** Maximum tree depth, -1 for unlimited (default -1) */
+    max_depth: OptionType(IntegerType),
+    /** Learning rate / step size shrinkage (default 0.1) */
+    learning_rate: OptionType(FloatType),
+    /** Maximum number of leaves in one tree (default 31) */
+    num_leaves: OptionType(IntegerType),
+    /** Minimum number of samples required in a leaf (default 20) */
+    min_child_samples: OptionType(IntegerType),
+    /** Subsample ratio of training instances (default 1.0) */
+    subsample: OptionType(FloatType),
+    /** Subsample ratio of columns when constructing trees (default 1.0) */
+    colsample_bytree: OptionType(FloatType),
+    /** L1 regularization term (default 0) */
+    reg_alpha: OptionType(FloatType),
+    /** L2 regularization term (default 0) */
+    reg_lambda: OptionType(FloatType),
+    /** Random seed for reproducibility */
+    random_state: OptionType(IntegerType),
+    /** Number of parallel threads (default -1 for all cores) */
+    n_jobs: OptionType(IntegerType),
+});
+// ============================================================================
+// Model Blob Types
+// ============================================================================
+/**
+ * Model blob type for serialized LightGBM models.
+ *
+ * Each model type has its own variant case containing cloudpickle bytes and metadata.
+ */
+export const LightGBMModelBlobType = VariantType({
+    /** LightGBM regressor model */
+    lightgbm_regressor: StructType({
+        /** Cloudpickle serialized model */
+        data: BlobType,
+        /** Number of input features */
+        n_features: IntegerType,
+    }),
+    /** LightGBM classifier model */
+    lightgbm_classifier: StructType({
+        /** Cloudpickle serialized model */
+        data: BlobType,
+        /** Number of input features */
+        n_features: IntegerType,
+        /** Number of classes */
+        n_classes: IntegerType,
+    }),
+});
+// ============================================================================
+// Platform Functions
+// ============================================================================
+/**
+ * Train a LightGBM regression model.
+ *
+ * @param X - Feature matrix
+ * @param y - Target vector
+ * @param config - LightGBM configuration
+ * @returns Model blob containing trained regressor
+ */
+export const lightgbm_train_regressor = East.platform("lightgbm_train_regressor", [MatrixType, VectorType, LightGBMConfigType], LightGBMModelBlobType);
+/**
+ * Train a LightGBM classification model.
+ *
+ * @param X - Feature matrix
+ * @param y - Label vector (integer class labels)
+ * @param config - LightGBM configuration
+ * @returns Model blob containing trained classifier
+ */
+export const lightgbm_train_classifier = East.platform("lightgbm_train_classifier", [MatrixType, LabelVectorType, LightGBMConfigType], LightGBMModelBlobType);
+/**
+ * Make predictions with a trained LightGBM regressor.
+ *
+ * @param model - Trained regressor model blob
+ * @param X - Feature matrix
+ * @returns Predicted values
+ */
+export const lightgbm_predict = East.platform("lightgbm_predict", [LightGBMModelBlobType, MatrixType], VectorType);
+/**
+ * Predict class labels with a trained LightGBM classifier.
+ *
+ * @param model - Trained classifier model blob
+ * @param X - Feature matrix
+ * @returns Predicted class labels
+ */
+export const lightgbm_predict_class = East.platform("lightgbm_predict_class", [LightGBMModelBlobType, MatrixType], LabelVectorType);
+/**
+ * Get class probabilities from a trained LightGBM classifier.
+ *
+ * @param model - Trained classifier model blob
+ * @param X - Feature matrix
+ * @returns Probability matrix (n_samples x n_classes)
+ */
+export const lightgbm_predict_proba = East.platform("lightgbm_predict_proba", [LightGBMModelBlobType, MatrixType], MatrixType);
+// ============================================================================
+// Grouped Export
+// ============================================================================
+/**
+ * Type definitions for LightGBM functions.
+ */
+export const LightGBMTypes = {
+    /** Vector type (array of floats) */
+    VectorType,
+    /** Matrix type (2D array of floats) */
+    MatrixType,
+    /** Label vector type (array of integers) */
+    LabelVectorType,
+    /** LightGBM configuration type */
+    LightGBMConfigType,
+    /** Model blob type for LightGBM models */
+    ModelBlobType: LightGBMModelBlobType,
+};
+/**
+ * LightGBM gradient boosting.
+ *
+ * Provides fast regression and classification with gradient boosted decision trees.
+ */
+export const LightGBM = {
+    /** Train LightGBM regressor */
+    trainRegressor: lightgbm_train_regressor,
+    /** Train LightGBM classifier */
+    trainClassifier: lightgbm_train_classifier,
+    /** Make predictions with regressor */
+    predict: lightgbm_predict,
+    /** Predict class labels with classifier */
+    predictClass: lightgbm_predict_class,
+    /** Get class probabilities from classifier */
+    predictProba: lightgbm_predict_proba,
+    /** Type definitions */
+    Types: LightGBMTypes,
+};
+//# sourceMappingURL=lightgbm.js.map

package/dist/lightgbm/lightgbm.js.map

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