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

package/dist/{gp → src/gp}/gp.d.ts

@@ -11,73 +11,74 @@
  * @packageDocumentation
  */
 import { StructType, VariantType, OptionType, IntegerType, FloatType, BooleanType, BlobType, StringType, NullType } from "@elaraai/east";
+import { VectorType, MatrixType } from "../types.js";
 export { VectorType, MatrixType } from "../types.js";
 /**
  * Kernel type for Gaussian Process.
  */
 export declare const GPKernelType: VariantType<{
     /** Radial Basis Function (squared exponential) */
-    rbf: NullType;
+    readonly rbf: NullType;
     /** Matern with nu=1/2 (exponential) */
-    matern_1_2: NullType;
+    readonly matern_1_2: NullType;
     /** Matern with nu=3/2 */
-    matern_3_2: NullType;
+    readonly matern_3_2: NullType;
     /** Matern with nu=5/2 */
-    matern_5_2: NullType;
+    readonly matern_5_2: NullType;
     /** Rational Quadratic */
-    rational_quadratic: NullType;
+    readonly rational_quadratic: NullType;
     /** Dot Product (linear) */
-    dot_product: NullType;
+    readonly dot_product: NullType;
 }>;
 /**
  * Configuration for Gaussian Process Regressor.
  */
 export declare const GPConfigType: StructType<{
     /** Kernel type (default rbf) */
-    kernel: OptionType<VariantType<{
+    readonly kernel: OptionType<VariantType<{
         /** Radial Basis Function (squared exponential) */
-        rbf: NullType;
+        readonly rbf: NullType;
         /** Matern with nu=1/2 (exponential) */
-        matern_1_2: NullType;
+        readonly matern_1_2: NullType;
         /** Matern with nu=3/2 */
-        matern_3_2: NullType;
+        readonly matern_3_2: NullType;
         /** Matern with nu=5/2 */
-        matern_5_2: NullType;
+        readonly matern_5_2: NullType;
         /** Rational Quadratic */
-        rational_quadratic: NullType;
+        readonly rational_quadratic: NullType;
         /** Dot Product (linear) */
-        dot_product: NullType;
+        readonly dot_product: NullType;
     }>>;
     /** Noise level added to diagonal (default 1e-10) */
-    alpha: OptionType<FloatType>;
+    readonly alpha: OptionType<FloatType>;
     /** Number of restarts for optimizer (default 0) */
-    n_restarts_optimizer: OptionType<IntegerType>;
+    readonly n_restarts_optimizer: OptionType<IntegerType>;
     /** Whether to normalize target values (default false) */
-    normalize_y: OptionType<BooleanType>;
+    readonly normalize_y: OptionType<BooleanType>;
     /** Random seed for reproducibility */
-    random_state: OptionType<IntegerType>;
+    readonly 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>;
+    readonly mean: VectorType<FloatType>;
     /** Predicted standard deviation (uncertainty) */
-    std: import("@elaraai/east").ArrayType<FloatType>;
+    readonly std: VectorType<FloatType>;
 }>;
 /**
  * Model blob type for serialized GP models.
  */
 export declare const GPModelBlobType: VariantType<{
     /** Gaussian Process Regressor */
-    gp_regressor: StructType<{
+    readonly gp_regressor: StructType<{
         /** Cloudpickle serialized model */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
         /** Kernel type name for reference */
-        kernel_type: StringType;
+        readonly kernel_type: StringType;
     }>;
 }>;
 /**
@@ -88,39 +89,39 @@ export declare const GPModelBlobType: VariantType<{
  * @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<{
+export declare const gp_train: import("@elaraai/east").PlatformDefinition<[MatrixType<FloatType>, VectorType<FloatType>, StructType<{
     /** Kernel type (default rbf) */
-    kernel: OptionType<VariantType<{
+    readonly kernel: OptionType<VariantType<{
         /** Radial Basis Function (squared exponential) */
-        rbf: NullType;
+        readonly rbf: NullType;
         /** Matern with nu=1/2 (exponential) */
-        matern_1_2: NullType;
+        readonly matern_1_2: NullType;
         /** Matern with nu=3/2 */
-        matern_3_2: NullType;
+        readonly matern_3_2: NullType;
         /** Matern with nu=5/2 */
-        matern_5_2: NullType;
+        readonly matern_5_2: NullType;
         /** Rational Quadratic */
-        rational_quadratic: NullType;
+        readonly rational_quadratic: NullType;
         /** Dot Product (linear) */
-        dot_product: NullType;
+        readonly dot_product: NullType;
     }>>;
     /** Noise level added to diagonal (default 1e-10) */
-    alpha: OptionType<FloatType>;
+    readonly alpha: OptionType<FloatType>;
     /** Number of restarts for optimizer (default 0) */
-    n_restarts_optimizer: OptionType<IntegerType>;
+    readonly n_restarts_optimizer: OptionType<IntegerType>;
     /** Whether to normalize target values (default false) */
-    normalize_y: OptionType<BooleanType>;
+    readonly normalize_y: OptionType<BooleanType>;
     /** Random seed for reproducibility */
-    random_state: OptionType<IntegerType>;
+    readonly random_state: OptionType<IntegerType>;
 }>], VariantType<{
     /** Gaussian Process Regressor */
-    gp_regressor: StructType<{
+    readonly gp_regressor: StructType<{
         /** Cloudpickle serialized model */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
         /** Kernel type name for reference */
-        kernel_type: StringType;
+        readonly kernel_type: StringType;
     }>;
 }>>;
 /**
@@ -134,15 +135,15 @@ export declare const gp_train: import("@elaraai/east").PlatformDefinition<[impor
  */
 export declare const gp_predict: import("@elaraai/east").PlatformDefinition<[VariantType<{
     /** Gaussian Process Regressor */
-    gp_regressor: StructType<{
+    readonly gp_regressor: StructType<{
         /** Cloudpickle serialized model */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
         /** Kernel type name for reference */
-        kernel_type: StringType;
+        readonly kernel_type: StringType;
     }>;
-}>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], import("@elaraai/east").ArrayType<FloatType>>;
+}>, MatrixType<FloatType>], VectorType<FloatType>>;
 /**
  * Make predictions with uncertainty estimates.
  *
@@ -154,86 +155,82 @@ export declare const gp_predict: import("@elaraai/east").PlatformDefinition<[Var
  */
 export declare const gp_predict_std: import("@elaraai/east").PlatformDefinition<[VariantType<{
     /** Gaussian Process Regressor */
-    gp_regressor: StructType<{
+    readonly gp_regressor: StructType<{
         /** Cloudpickle serialized model */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
         /** Kernel type name for reference */
-        kernel_type: StringType;
+        readonly kernel_type: StringType;
     }>;
-}>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], StructType<{
+}>, MatrixType<FloatType>], StructType<{
     /** Predicted mean values */
-    mean: import("@elaraai/east").ArrayType<FloatType>;
+    readonly mean: VectorType<FloatType>;
     /** Predicted standard deviation (uncertainty) */
-    std: import("@elaraai/east").ArrayType<FloatType>;
+    readonly std: VectorType<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: NullType;
+        readonly rbf: NullType;
         /** Matern with nu=1/2 (exponential) */
-        matern_1_2: NullType;
+        readonly matern_1_2: NullType;
         /** Matern with nu=3/2 */
-        matern_3_2: NullType;
+        readonly matern_3_2: NullType;
         /** Matern with nu=5/2 */
-        matern_5_2: NullType;
+        readonly matern_5_2: NullType;
         /** Rational Quadratic */
-        rational_quadratic: NullType;
+        readonly rational_quadratic: NullType;
         /** Dot Product (linear) */
-        dot_product: NullType;
+        readonly dot_product: NullType;
     }>;
     /** Configuration type */
     readonly GPConfigType: StructType<{
         /** Kernel type (default rbf) */
-        kernel: OptionType<VariantType<{
+        readonly kernel: OptionType<VariantType<{
             /** Radial Basis Function (squared exponential) */
-            rbf: NullType;
+            readonly rbf: NullType;
             /** Matern with nu=1/2 (exponential) */
-            matern_1_2: NullType;
+            readonly matern_1_2: NullType;
             /** Matern with nu=3/2 */
-            matern_3_2: NullType;
+            readonly matern_3_2: NullType;
             /** Matern with nu=5/2 */
-            matern_5_2: NullType;
+            readonly matern_5_2: NullType;
             /** Rational Quadratic */
-            rational_quadratic: NullType;
+            readonly rational_quadratic: NullType;
             /** Dot Product (linear) */
-            dot_product: NullType;
+            readonly dot_product: NullType;
         }>>;
         /** Noise level added to diagonal (default 1e-10) */
-        alpha: OptionType<FloatType>;
+        readonly alpha: OptionType<FloatType>;
         /** Number of restarts for optimizer (default 0) */
-        n_restarts_optimizer: OptionType<IntegerType>;
+        readonly n_restarts_optimizer: OptionType<IntegerType>;
         /** Whether to normalize target values (default false) */
-        normalize_y: OptionType<BooleanType>;
+        readonly normalize_y: OptionType<BooleanType>;
         /** Random seed for reproducibility */
-        random_state: OptionType<IntegerType>;
+        readonly random_state: OptionType<IntegerType>;
     }>;
     /** Prediction result type with uncertainty */
     readonly GPPredictResultType: StructType<{
         /** Predicted mean values */
-        mean: import("@elaraai/east").ArrayType<FloatType>;
+        readonly mean: VectorType<FloatType>;
         /** Predicted standard deviation (uncertainty) */
-        std: import("@elaraai/east").ArrayType<FloatType>;
+        readonly std: VectorType<FloatType>;
     }>;
     /** Model blob type for GP models */
     readonly ModelBlobType: VariantType<{
         /** Gaussian Process Regressor */
-        gp_regressor: StructType<{
+        readonly gp_regressor: StructType<{
             /** Cloudpickle serialized model */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
             /** Kernel type name for reference */
-            kernel_type: StringType;
+            readonly kernel_type: StringType;
         }>;
     }>;
 };
@@ -262,135 +259,187 @@ export declare const GPTypes: {
  * ```
  */
 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<{
+    /**
+     * Train a Gaussian Process regression model.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType, VectorType, variant } from "@elaraai/east";
+     * import { GP, GPConfigType } 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(new Float64Array([1.0, 4.0, 9.0, 16.0]));
+     *     const config = $.let({
+     *         kernel: variant("some", variant("rbf", null)),
+     *         alpha: variant("some", 1e-10),
+     *         n_restarts_optimizer: variant("some", 5n),
+     *         normalize_y: variant("some", true),
+     *         random_state: variant("some", 42n),
+     *     }, GPConfigType);
+     *     return $.return(GP.train(X, y, config));
+     * });
+     * ```
+     */
+    readonly train: import("@elaraai/east").PlatformDefinition<[MatrixType<FloatType>, VectorType<FloatType>, StructType<{
         /** Kernel type (default rbf) */
-        kernel: OptionType<VariantType<{
+        readonly kernel: OptionType<VariantType<{
             /** Radial Basis Function (squared exponential) */
-            rbf: NullType;
+            readonly rbf: NullType;
             /** Matern with nu=1/2 (exponential) */
-            matern_1_2: NullType;
+            readonly matern_1_2: NullType;
             /** Matern with nu=3/2 */
-            matern_3_2: NullType;
+            readonly matern_3_2: NullType;
             /** Matern with nu=5/2 */
-            matern_5_2: NullType;
+            readonly matern_5_2: NullType;
             /** Rational Quadratic */
-            rational_quadratic: NullType;
+            readonly rational_quadratic: NullType;
             /** Dot Product (linear) */
-            dot_product: NullType;
+            readonly dot_product: NullType;
         }>>;
         /** Noise level added to diagonal (default 1e-10) */
-        alpha: OptionType<FloatType>;
+        readonly alpha: OptionType<FloatType>;
         /** Number of restarts for optimizer (default 0) */
-        n_restarts_optimizer: OptionType<IntegerType>;
+        readonly n_restarts_optimizer: OptionType<IntegerType>;
         /** Whether to normalize target values (default false) */
-        normalize_y: OptionType<BooleanType>;
+        readonly normalize_y: OptionType<BooleanType>;
         /** Random seed for reproducibility */
-        random_state: OptionType<IntegerType>;
+        readonly random_state: OptionType<IntegerType>;
     }>], VariantType<{
         /** Gaussian Process Regressor */
-        gp_regressor: StructType<{
+        readonly gp_regressor: StructType<{
             /** Cloudpickle serialized model */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
             /** Kernel type name for reference */
-            kernel_type: StringType;
+            readonly kernel_type: StringType;
         }>;
     }>>;
-    /** Make predictions (mean only) */
+    /**
+     * Make predictions (mean only) with a trained GP model.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType, VectorType } from "@elaraai/east";
+     * import { GP } from "@elaraai/east-py-datascience";
+     *
+     * const predictFn = East.function(
+     *     [GP.Types.ModelBlobType, MatrixType(FloatType)],
+     *     VectorType(FloatType),
+     *     ($, model, X) => {
+     *         return $.return(GP.predict(model, X));
+     *     }
+     * );
+     * ```
+     */
     readonly predict: import("@elaraai/east").PlatformDefinition<[VariantType<{
         /** Gaussian Process Regressor */
-        gp_regressor: StructType<{
+        readonly gp_regressor: StructType<{
             /** Cloudpickle serialized model */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
             /** Kernel type name for reference */
-            kernel_type: StringType;
+            readonly kernel_type: StringType;
         }>;
-    }>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], import("@elaraai/east").ArrayType<FloatType>>;
-    /** Make predictions with uncertainty */
+    }>, MatrixType<FloatType>], VectorType<FloatType>>;
+    /**
+     * Make predictions with uncertainty estimates (mean + std).
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType } from "@elaraai/east";
+     * import { GP } from "@elaraai/east-py-datascience";
+     *
+     * const predictFn = East.function(
+     *     [GP.Types.ModelBlobType, MatrixType(FloatType)],
+     *     GP.Types.GPPredictResultType,
+     *     ($, model, X) => {
+     *         const result = $.let(GP.predictStd(model, X));
+     *         // result.mean => predicted values
+     *         // result.std  => uncertainty (standard deviation)
+     *         return $.return(result);
+     *     }
+     * );
+     * ```
+     */
     readonly predictStd: import("@elaraai/east").PlatformDefinition<[VariantType<{
         /** Gaussian Process Regressor */
-        gp_regressor: StructType<{
+        readonly gp_regressor: StructType<{
             /** Cloudpickle serialized model */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
             /** Kernel type name for reference */
-            kernel_type: StringType;
+            readonly kernel_type: StringType;
         }>;
-    }>, import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<FloatType>>], StructType<{
+    }>, MatrixType<FloatType>], StructType<{
         /** Predicted mean values */
-        mean: import("@elaraai/east").ArrayType<FloatType>;
+        readonly mean: VectorType<FloatType>;
         /** Predicted standard deviation (uncertainty) */
-        std: import("@elaraai/east").ArrayType<FloatType>;
+        readonly std: VectorType<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: NullType;
+            readonly rbf: NullType;
             /** Matern with nu=1/2 (exponential) */
-            matern_1_2: NullType;
+            readonly matern_1_2: NullType;
             /** Matern with nu=3/2 */
-            matern_3_2: NullType;
+            readonly matern_3_2: NullType;
             /** Matern with nu=5/2 */
-            matern_5_2: NullType;
+            readonly matern_5_2: NullType;
             /** Rational Quadratic */
-            rational_quadratic: NullType;
+            readonly rational_quadratic: NullType;
             /** Dot Product (linear) */
-            dot_product: NullType;
+            readonly dot_product: NullType;
         }>;
         /** Configuration type */
         readonly GPConfigType: StructType<{
             /** Kernel type (default rbf) */
-            kernel: OptionType<VariantType<{
+            readonly kernel: OptionType<VariantType<{
                 /** Radial Basis Function (squared exponential) */
-                rbf: NullType;
+                readonly rbf: NullType;
                 /** Matern with nu=1/2 (exponential) */
-                matern_1_2: NullType;
+                readonly matern_1_2: NullType;
                 /** Matern with nu=3/2 */
-                matern_3_2: NullType;
+                readonly matern_3_2: NullType;
                 /** Matern with nu=5/2 */
-                matern_5_2: NullType;
+                readonly matern_5_2: NullType;
                 /** Rational Quadratic */
-                rational_quadratic: NullType;
+                readonly rational_quadratic: NullType;
                 /** Dot Product (linear) */
-                dot_product: NullType;
+                readonly dot_product: NullType;
             }>>;
             /** Noise level added to diagonal (default 1e-10) */
-            alpha: OptionType<FloatType>;
+            readonly alpha: OptionType<FloatType>;
             /** Number of restarts for optimizer (default 0) */
-            n_restarts_optimizer: OptionType<IntegerType>;
+            readonly n_restarts_optimizer: OptionType<IntegerType>;
             /** Whether to normalize target values (default false) */
-            normalize_y: OptionType<BooleanType>;
+            readonly normalize_y: OptionType<BooleanType>;
             /** Random seed for reproducibility */
-            random_state: OptionType<IntegerType>;
+            readonly random_state: OptionType<IntegerType>;
         }>;
         /** Prediction result type with uncertainty */
         readonly GPPredictResultType: StructType<{
             /** Predicted mean values */
-            mean: import("@elaraai/east").ArrayType<FloatType>;
+            readonly mean: VectorType<FloatType>;
             /** Predicted standard deviation (uncertainty) */
-            std: import("@elaraai/east").ArrayType<FloatType>;
+            readonly std: VectorType<FloatType>;
         }>;
         /** Model blob type for GP models */
         readonly ModelBlobType: VariantType<{
             /** Gaussian Process Regressor */
-            gp_regressor: StructType<{
+            readonly gp_regressor: StructType<{
                 /** Cloudpickle serialized model */
-                data: BlobType;
+                readonly data: BlobType;
                 /** Number of input features */
-                n_features: IntegerType;
+                readonly n_features: IntegerType;
                 /** Kernel type name for reference */
-                kernel_type: StringType;
+                readonly kernel_type: StringType;
             }>;
         }>;
     };

package/dist/src/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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"}

package/dist/{gp → src/gp}/gp.js

@@ -60,9 +60,9 @@ export const GPConfigType = StructType({
  */
 export const GPPredictResultType = StructType({
     /** Predicted mean values */
-    mean: VectorType,
+    mean: VectorType(FloatType),
     /** Predicted standard deviation (uncertainty) */
-    std: VectorType,
+    std: VectorType(FloatType),
 });
 // ============================================================================
 // Model Blob Types
@@ -92,7 +92,7 @@ export const GPModelBlobType = VariantType({
  * @param config - GP configuration
  * @returns Trained GP model blob
  */
-export const gp_train = East.platform("gp_train", [MatrixType, VectorType, GPConfigType], GPModelBlobType);
+export const gp_train = East.platform("gp_train", [MatrixType(FloatType), VectorType(FloatType), GPConfigType], GPModelBlobType);
 /**
  * Make predictions with a trained Gaussian Process.
  *
@@ -102,7 +102,7 @@ export const gp_train = East.platform("gp_train", [MatrixType, VectorType, GPCon
  * @param X - Feature matrix
  * @returns Predicted values
  */
-export const gp_predict = East.platform("gp_predict", [GPModelBlobType, MatrixType], VectorType);
+export const gp_predict = East.platform("gp_predict", [GPModelBlobType, MatrixType(FloatType)], VectorType(FloatType));
 /**
  * Make predictions with uncertainty estimates.
  *
@@ -112,7 +112,7 @@ export const gp_predict = East.platform("gp_predict", [GPModelBlobType, MatrixTy
  * @param X - Feature matrix
  * @returns Prediction result with mean and std
  */
-export const gp_predict_std = East.platform("gp_predict_std", [GPModelBlobType, MatrixType], GPPredictResultType);
+export const gp_predict_std = East.platform("gp_predict_std", [GPModelBlobType, MatrixType(FloatType)], GPPredictResultType);
 // ============================================================================
 // Grouped Export
 // ============================================================================
@@ -120,10 +120,6 @@ export const gp_predict_std = East.platform("gp_predict_std", [GPModelBlobType,
  * Type definitions for GP functions.
  */
 export const GPTypes = {
-    /** Vector type (array of floats) */
-    VectorType,
-    /** Matrix type (2D array of floats) */
-    MatrixType,
     /** Kernel type */
     GPKernelType,
     /** Configuration type */
@@ -158,11 +154,67 @@ export const GPTypes = {
  * ```
  */
 export const GP = {
-    /** Train GP regressor */
+    /**
+     * Train a Gaussian Process regression model.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType, VectorType, variant } from "@elaraai/east";
+     * import { GP, GPConfigType } 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(new Float64Array([1.0, 4.0, 9.0, 16.0]));
+     *     const config = $.let({
+     *         kernel: variant("some", variant("rbf", null)),
+     *         alpha: variant("some", 1e-10),
+     *         n_restarts_optimizer: variant("some", 5n),
+     *         normalize_y: variant("some", true),
+     *         random_state: variant("some", 42n),
+     *     }, GPConfigType);
+     *     return $.return(GP.train(X, y, config));
+     * });
+     * ```
+     */
     train: gp_train,
-    /** Make predictions (mean only) */
+    /**
+     * Make predictions (mean only) with a trained GP model.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType, VectorType } from "@elaraai/east";
+     * import { GP } from "@elaraai/east-py-datascience";
+     *
+     * const predictFn = East.function(
+     *     [GP.Types.ModelBlobType, MatrixType(FloatType)],
+     *     VectorType(FloatType),
+     *     ($, model, X) => {
+     *         return $.return(GP.predict(model, X));
+     *     }
+     * );
+     * ```
+     */
     predict: gp_predict,
-    /** Make predictions with uncertainty */
+    /**
+     * Make predictions with uncertainty estimates (mean + std).
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType } from "@elaraai/east";
+     * import { GP } from "@elaraai/east-py-datascience";
+     *
+     * const predictFn = East.function(
+     *     [GP.Types.ModelBlobType, MatrixType(FloatType)],
+     *     GP.Types.GPPredictResultType,
+     *     ($, model, X) => {
+     *         const result = $.let(GP.predictStd(model, X));
+     *         // result.mean => predicted values
+     *         // result.std  => uncertainty (standard deviation)
+     *         return $.return(result);
+     *     }
+     * );
+     * ```
+     */
     predictStd: gp_predict_std,
     /** Type definitions */
     Types: GPTypes,