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

package/LICENSE.md

@@ -0,0 +1,18 @@
+Copyright (c) 2025 Elara AI Pty Ltd
+
+DUAL LICENSING
+
+This software is available under two licenses. You may choose which license
+applies to your use:
+
+OPEN SOURCE LICENSE (AGPL-3.0)
+You may use, modify, and distribute this software under the terms of the
+GNU Affero General Public License v3.0. This requires that if you use this
+software in a network service, you must make your complete source code
+available under AGPL-3.0.
+
+COMMERCIAL LICENSE
+If you wish to use this software without the source code disclosure requirements
+of AGPL-3.0, you must obtain a separate commercial license from Elara AI Pty Ltd.
+
+Contact: support@elara.ai

package/README.md

@@ -0,0 +1,104 @@
+# East Data Science
+
+> Data science and ML platform functions for the East language
+
+[![License](https://img.shields.io/badge/license-AGPL--3.0-blue.svg)](LICENSE.md)
+[![Node Version](https://img.shields.io/badge/node-%3E%3D22.0.0-brightgreen.svg)](https://nodejs.org)
+
+**East Data Science** provides machine learning and optimization platform functions for the [East language](https://github.com/elaraai/East).
+
+## Installation
+
+```bash
+npm install @elaraai/east-py-datascience @elaraai/east
+```
+
+## Quick Start
+
+```typescript
+import { East, FloatType, variant } from "@elaraai/east";
+import { MADS } from "@elaraai/east-py-datascience";
+
+// Define objective function: minimize sum of squares
+const objective = East.function([MADS.Types.VectorType], FloatType, ($, x) => {
+    const x0 = $.let(x.get(0n));
+    const x1 = $.let(x.get(1n));
+    return $.return(x0.multiply(x0).add(x1.multiply(x1)));
+});
+
+// Optimize
+const optimize = East.function([], MADS.Types.ResultType, $ => {
+    const x0 = $.let([0.5, 0.5]);
+    const bounds = $.let({
+        lower: [-1.0, -1.0],
+        upper: [1.0, 1.0],
+    });
+    const config = $.let({
+        max_bb_eval: variant('some', 100n),
+        display_degree: variant('some', 0n),
+        direction_type: variant('none', null),
+        initial_mesh_size: variant('none', null),
+        min_mesh_size: variant('none', null),
+        seed: variant('some', 42n),
+    });
+
+    return $.return(MADS.optimize(objective, x0, bounds, variant('none', null), config));
+});
+```
+
+## Modules
+
+### Optimization
+
+| Module | Description | Use Cases |
+|--------|-------------|-----------|
+| **MADS** | Derivative-free blackbox optimization using NOMAD algorithm | Functions without derivatives, expensive evaluations, noisy/discontinuous objectives |
+| **Optuna** | Bayesian optimization with TPE sampler | Hyperparameter tuning, mixed-type parameters, efficient search with few evaluations |
+| **SimAnneal** | Simulated annealing for discrete optimization | TSP, scheduling, subset selection, knapsack, assignment problems |
+| **Scipy** | Scientific optimization and curve fitting | Gradient-based minimization, curve fitting, interpolation, statistics |
+
+### Machine Learning
+
+| Module | Description | Use Cases |
+|--------|-------------|-----------|
+| **Sklearn** | Core ML utilities from scikit-learn | Train/test split, preprocessing (StandardScaler, MinMaxScaler), metrics, multi-target regression |
+| **XGBoost** | Gradient boosting with XGBoost | Regression, classification, feature importance, fast training |
+| **LightGBM** | Fast gradient boosting with leaf-wise growth | Large datasets, high cardinality features, faster than XGBoost on big data |
+| **NGBoost** | Natural gradient boosting with uncertainty | Probabilistic predictions, confidence intervals, uncertainty quantification |
+| **Torch** | Neural networks with PyTorch | MLP regression/classification, deep learning, custom architectures |
+| **GP** | Gaussian Process regression | Small datasets, uncertainty quantification, Bayesian optimization surrogate |
+
+### Explainability
+
+| Module | Description | Use Cases |
+|--------|-------------|-----------|
+| **Shap** | SHAP values for model interpretation | Feature importance, model explanations, debugging predictions |
+
+## Documentation
+
+See [USAGE.md](./USAGE.md) for detailed API reference with examples.
+
+## Development
+
+```bash
+npm run build     # Compile TypeScript
+npm run test      # Run test suite
+npm run lint      # Check code quality
+```
+
+## License
+
+Dual-licensed:
+- **Open Source**: [AGPL-3.0](LICENSE.md) - Free for open source use
+- **Commercial**: Available for proprietary use - contact support@elara.ai
+
+## Links
+
+- **Website**: [https://elaraai.com/](https://elaraai.com/)
+- **East Repository**: [https://github.com/elaraai/East](https://github.com/elaraai/East)
+- **Issues**: [https://github.com/elaraai/east-py/issues](https://github.com/elaraai/east-py/issues)
+- **Email**: support@elara.ai
+
+---
+
+*Developed by [Elara AI Pty Ltd](https://elaraai.com/)*

package/dist/gp/gp.d.ts

@@ -0,0 +1,398 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Gaussian Process platform functions for East.
+ *
+ * Provides Gaussian Process regression using scikit-learn.
+ * Uses cloudpickle for model serialization.
+ *
+ * @packageDocumentation
+ */
+import { StructType, VariantType, OptionType, IntegerType, FloatType, BooleanType, BlobType, StringType } from "@elaraai/east";
+export { VectorType, MatrixType } from "../types.js";
+/**
+ * Kernel type for Gaussian Process.
+ */
+export declare const GPKernelType: VariantType<{
+    /** Radial Basis Function (squared exponential) */
+    rbf: StructType<{}>;
+    /** Matern with nu=1/2 (exponential) */
+    matern_1_2: StructType<{}>;
+    /** Matern with nu=3/2 */
+    matern_3_2: StructType<{}>;
+    /** Matern with nu=5/2 */
+    matern_5_2: StructType<{}>;
+    /** Rational Quadratic */
+    rational_quadratic: StructType<{}>;
+    /** Dot Product (linear) */
+    dot_product: StructType<{}>;
+}>;
+/**
+ * Configuration for Gaussian Process Regressor.
+ */
+export declare const GPConfigType: StructType<{
+    /** Kernel type (default rbf) */
+    kernel: OptionType<VariantType<{
+        /** Radial Basis Function (squared exponential) */
+        rbf: StructType<{}>;
+        /** Matern with nu=1/2 (exponential) */
+        matern_1_2: StructType<{}>;
+        /** Matern with nu=3/2 */
+        matern_3_2: StructType<{}>;
+        /** Matern with nu=5/2 */
+        matern_5_2: StructType<{}>;
+        /** Rational Quadratic */
+        rational_quadratic: StructType<{}>;
+        /** Dot Product (linear) */
+        dot_product: StructType<{}>;
+    }>>;
+    /** Noise level added to diagonal (default 1e-10) */
+    alpha: OptionType<FloatType>;
+    /** Number of restarts for optimizer (default 0) */
+    n_restarts_optimizer: OptionType<IntegerType>;
+    /** Whether to normalize target values (default false) */
+    normalize_y: OptionType<BooleanType>;
+    /** Random seed for reproducibility */
+    random_state: OptionType<IntegerType>;
+}>;
+/**
+ * Result type for GP prediction with uncertainty.
+ */
+export declare const GPPredictResultType: StructType<{
+    /** Predicted mean values */
+    mean: import("@elaraai/east").ArrayType<FloatType>;
+    /** Predicted standard deviation (uncertainty) */
+    std: import("@elaraai/east").ArrayType<FloatType>;
+}>;
+/**
+ * Model blob type for serialized GP models.
+ */
+export declare const GPModelBlobType: VariantType<{
+    /** Gaussian Process Regressor */
+    gp_regressor: StructType<{
+        /** Cloudpickle serialized model */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+        /** Kernel type name for reference */
+        kernel_type: StringType;
+    }>;
+}>;
+/**
+ * Train a Gaussian Process Regressor.
+ *
+ * @param X - Feature matrix
+ * @param y - Target vector
+ * @param config - GP configuration
+ * @returns Trained GP model blob
+ */
+export declare const gp_train: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>, import("@elaraai/east").ArrayType<FloatType>, StructType<{
+    /** Kernel type (default rbf) */
+    kernel: OptionType<VariantType<{
+        /** Radial Basis Function (squared exponential) */
+        rbf: StructType<{}>;
+        /** Matern with nu=1/2 (exponential) */
+        matern_1_2: StructType<{}>;
+        /** Matern with nu=3/2 */
+        matern_3_2: StructType<{}>;
+        /** Matern with nu=5/2 */
+        matern_5_2: StructType<{}>;
+        /** Rational Quadratic */
+        rational_quadratic: StructType<{}>;
+        /** Dot Product (linear) */
+        dot_product: StructType<{}>;
+    }>>;
+    /** Noise level added to diagonal (default 1e-10) */
+    alpha: OptionType<FloatType>;
+    /** Number of restarts for optimizer (default 0) */
+    n_restarts_optimizer: OptionType<IntegerType>;
+    /** Whether to normalize target values (default false) */
+    normalize_y: OptionType<BooleanType>;
+    /** Random seed for reproducibility */
+    random_state: OptionType<IntegerType>;
+}>], VariantType<{
+    /** Gaussian Process Regressor */
+    gp_regressor: StructType<{
+        /** Cloudpickle serialized model */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+        /** Kernel type name for reference */
+        kernel_type: StringType;
+    }>;
+}>>;
+/**
+ * Make predictions with a trained Gaussian Process.
+ *
+ * Returns point predictions (mean only).
+ *
+ * @param model - Trained GP model blob
+ * @param X - Feature matrix
+ * @returns Predicted values
+ */
+export declare const gp_predict: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** Gaussian Process Regressor */
+    gp_regressor: StructType<{
+        /** Cloudpickle serialized model */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+        /** Kernel type name for reference */
+        kernel_type: StringType;
+    }>;
+}>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], import("@elaraai/east").ArrayType<FloatType>>;
+/**
+ * Make predictions with uncertainty estimates.
+ *
+ * Returns both mean and standard deviation.
+ *
+ * @param model - Trained GP model blob
+ * @param X - Feature matrix
+ * @returns Prediction result with mean and std
+ */
+export declare const gp_predict_std: import("@elaraai/east").PlatformDefinition<[VariantType<{
+    /** Gaussian Process Regressor */
+    gp_regressor: StructType<{
+        /** Cloudpickle serialized model */
+        data: BlobType;
+        /** Number of input features */
+        n_features: IntegerType;
+        /** Kernel type name for reference */
+        kernel_type: StringType;
+    }>;
+}>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], StructType<{
+    /** Predicted mean values */
+    mean: import("@elaraai/east").ArrayType<FloatType>;
+    /** Predicted standard deviation (uncertainty) */
+    std: import("@elaraai/east").ArrayType<FloatType>;
+}>>;
+/**
+ * Type definitions for GP functions.
+ */
+export declare const GPTypes: {
+    /** 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>>;
+    /** Kernel type */
+    readonly GPKernelType: VariantType<{
+        /** Radial Basis Function (squared exponential) */
+        rbf: StructType<{}>;
+        /** Matern with nu=1/2 (exponential) */
+        matern_1_2: StructType<{}>;
+        /** Matern with nu=3/2 */
+        matern_3_2: StructType<{}>;
+        /** Matern with nu=5/2 */
+        matern_5_2: StructType<{}>;
+        /** Rational Quadratic */
+        rational_quadratic: StructType<{}>;
+        /** Dot Product (linear) */
+        dot_product: StructType<{}>;
+    }>;
+    /** Configuration type */
+    readonly GPConfigType: StructType<{
+        /** Kernel type (default rbf) */
+        kernel: OptionType<VariantType<{
+            /** Radial Basis Function (squared exponential) */
+            rbf: StructType<{}>;
+            /** Matern with nu=1/2 (exponential) */
+            matern_1_2: StructType<{}>;
+            /** Matern with nu=3/2 */
+            matern_3_2: StructType<{}>;
+            /** Matern with nu=5/2 */
+            matern_5_2: StructType<{}>;
+            /** Rational Quadratic */
+            rational_quadratic: StructType<{}>;
+            /** Dot Product (linear) */
+            dot_product: StructType<{}>;
+        }>>;
+        /** Noise level added to diagonal (default 1e-10) */
+        alpha: OptionType<FloatType>;
+        /** Number of restarts for optimizer (default 0) */
+        n_restarts_optimizer: OptionType<IntegerType>;
+        /** Whether to normalize target values (default false) */
+        normalize_y: OptionType<BooleanType>;
+        /** Random seed for reproducibility */
+        random_state: OptionType<IntegerType>;
+    }>;
+    /** Prediction result type with uncertainty */
+    readonly GPPredictResultType: StructType<{
+        /** Predicted mean values */
+        mean: import("@elaraai/east").ArrayType<FloatType>;
+        /** Predicted standard deviation (uncertainty) */
+        std: import("@elaraai/east").ArrayType<FloatType>;
+    }>;
+    /** Model blob type for GP models */
+    readonly ModelBlobType: VariantType<{
+        /** Gaussian Process Regressor */
+        gp_regressor: StructType<{
+            /** Cloudpickle serialized model */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+            /** Kernel type name for reference */
+            kernel_type: StringType;
+        }>;
+    }>;
+};
+/**
+ * Gaussian Process regression.
+ *
+ * Provides probabilistic regression with uncertainty quantification.
+ *
+ * @example
+ * ```ts
+ * import { East, variant } from "@elaraai/east";
+ * import { GP } from "@elaraai/east-py-datascience";
+ *
+ * const train = East.function([], GP.Types.ModelBlobType, $ => {
+ *     const X = $.let([[1.0], [2.0], [3.0], [4.0]]);
+ *     const y = $.let([1.0, 4.0, 9.0, 16.0]);
+ *     const config = $.let({
+ *         kernel: variant('some', variant('rbf', {})),
+ *         alpha: variant('some', 1e-10),
+ *         n_restarts_optimizer: variant('some', 5n),
+ *         normalize_y: variant('some', true),
+ *         random_state: variant('some', 42n),
+ *     });
+ *     return $.return(GP.train(X, y, config));
+ * });
+ * ```
+ */
+export declare const GP: {
+    /** Train GP regressor */
+    readonly train: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>, import("@elaraai/east").ArrayType<FloatType>, StructType<{
+        /** Kernel type (default rbf) */
+        kernel: OptionType<VariantType<{
+            /** Radial Basis Function (squared exponential) */
+            rbf: StructType<{}>;
+            /** Matern with nu=1/2 (exponential) */
+            matern_1_2: StructType<{}>;
+            /** Matern with nu=3/2 */
+            matern_3_2: StructType<{}>;
+            /** Matern with nu=5/2 */
+            matern_5_2: StructType<{}>;
+            /** Rational Quadratic */
+            rational_quadratic: StructType<{}>;
+            /** Dot Product (linear) */
+            dot_product: StructType<{}>;
+        }>>;
+        /** Noise level added to diagonal (default 1e-10) */
+        alpha: OptionType<FloatType>;
+        /** Number of restarts for optimizer (default 0) */
+        n_restarts_optimizer: OptionType<IntegerType>;
+        /** Whether to normalize target values (default false) */
+        normalize_y: OptionType<BooleanType>;
+        /** Random seed for reproducibility */
+        random_state: OptionType<IntegerType>;
+    }>], VariantType<{
+        /** Gaussian Process Regressor */
+        gp_regressor: StructType<{
+            /** Cloudpickle serialized model */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+            /** Kernel type name for reference */
+            kernel_type: StringType;
+        }>;
+    }>>;
+    /** Make predictions (mean only) */
+    readonly predict: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** Gaussian Process Regressor */
+        gp_regressor: StructType<{
+            /** Cloudpickle serialized model */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+            /** Kernel type name for reference */
+            kernel_type: StringType;
+        }>;
+    }>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], import("@elaraai/east").ArrayType<FloatType>>;
+    /** Make predictions with uncertainty */
+    readonly predictStd: import("@elaraai/east").PlatformDefinition<[VariantType<{
+        /** Gaussian Process Regressor */
+        gp_regressor: StructType<{
+            /** Cloudpickle serialized model */
+            data: BlobType;
+            /** Number of input features */
+            n_features: IntegerType;
+            /** Kernel type name for reference */
+            kernel_type: StringType;
+        }>;
+    }>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], StructType<{
+        /** Predicted mean values */
+        mean: import("@elaraai/east").ArrayType<FloatType>;
+        /** Predicted standard deviation (uncertainty) */
+        std: 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>>;
+        /** Kernel type */
+        readonly GPKernelType: VariantType<{
+            /** Radial Basis Function (squared exponential) */
+            rbf: StructType<{}>;
+            /** Matern with nu=1/2 (exponential) */
+            matern_1_2: StructType<{}>;
+            /** Matern with nu=3/2 */
+            matern_3_2: StructType<{}>;
+            /** Matern with nu=5/2 */
+            matern_5_2: StructType<{}>;
+            /** Rational Quadratic */
+            rational_quadratic: StructType<{}>;
+            /** Dot Product (linear) */
+            dot_product: StructType<{}>;
+        }>;
+        /** Configuration type */
+        readonly GPConfigType: StructType<{
+            /** Kernel type (default rbf) */
+            kernel: OptionType<VariantType<{
+                /** Radial Basis Function (squared exponential) */
+                rbf: StructType<{}>;
+                /** Matern with nu=1/2 (exponential) */
+                matern_1_2: StructType<{}>;
+                /** Matern with nu=3/2 */
+                matern_3_2: StructType<{}>;
+                /** Matern with nu=5/2 */
+                matern_5_2: StructType<{}>;
+                /** Rational Quadratic */
+                rational_quadratic: StructType<{}>;
+                /** Dot Product (linear) */
+                dot_product: StructType<{}>;
+            }>>;
+            /** Noise level added to diagonal (default 1e-10) */
+            alpha: OptionType<FloatType>;
+            /** Number of restarts for optimizer (default 0) */
+            n_restarts_optimizer: OptionType<IntegerType>;
+            /** Whether to normalize target values (default false) */
+            normalize_y: OptionType<BooleanType>;
+            /** Random seed for reproducibility */
+            random_state: OptionType<IntegerType>;
+        }>;
+        /** Prediction result type with uncertainty */
+        readonly GPPredictResultType: StructType<{
+            /** Predicted mean values */
+            mean: import("@elaraai/east").ArrayType<FloatType>;
+            /** Predicted standard deviation (uncertainty) */
+            std: import("@elaraai/east").ArrayType<FloatType>;
+        }>;
+        /** Model blob type for GP models */
+        readonly ModelBlobType: VariantType<{
+            /** Gaussian Process Regressor */
+            gp_regressor: StructType<{
+                /** Cloudpickle serialized model */
+                data: BlobType;
+                /** Number of input features */
+                n_features: IntegerType;
+                /** Kernel type name for reference */
+                kernel_type: StringType;
+            }>;
+        }>;
+    };
+};
+//# sourceMappingURL=gp.d.ts.map

package/dist/gp/gp.d.ts.map

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