@elaraai/east-py-datascience 1.0.1 → 1.0.3

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

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

package/dist/src/torch/torch.js

@@ -0,0 +1,440 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * PyTorch platform functions for East.
+ *
+ * Provides neural network models using PyTorch.
+ * Uses cloudpickle for model serialization.
+ *
+ * @packageDocumentation
+ */
+import { East, StructType, VariantType, OptionType, IntegerType, FloatType, BlobType, ArrayType, NullType, } from "@elaraai/east";
+import { VectorType, MatrixType } from "../types.js";
+// Re-export shared types for convenience
+export { VectorType, MatrixType } from "../types.js";
+// ============================================================================
+// Enum Types
+// ============================================================================
+/**
+ * Activation function type for hidden layers.
+ */
+export const TorchActivationType = VariantType({
+    /** Rectified Linear Unit */
+    relu: NullType,
+    /** Hyperbolic tangent */
+    tanh: NullType,
+    /** Sigmoid function */
+    sigmoid: NullType,
+    /** Leaky ReLU */
+    leaky_relu: NullType,
+});
+/**
+ * Loss function type for training.
+ */
+export const TorchLossType = VariantType({
+    /** Mean Squared Error (regression) */
+    mse: NullType,
+    /** Mean Absolute Error (regression) */
+    mae: NullType,
+    /** Cross Entropy (multi-class classification with integer targets) */
+    cross_entropy: NullType,
+    /** KL Divergence (distribution matching, use with softmax output) */
+    kl_div: NullType,
+    /** Binary Cross Entropy (multi-label binary, requires sigmoid output) */
+    bce: NullType,
+    /** Binary Cross Entropy with Logits (more stable, applies sigmoid internally - do NOT use with sigmoid output_activation) */
+    bce_with_logits: NullType,
+});
+/**
+ * Optimizer type for training.
+ */
+export const TorchOptimizerType = VariantType({
+    /** Adam optimizer */
+    adam: NullType,
+    /** Stochastic Gradient Descent */
+    sgd: NullType,
+    /** AdamW with weight decay */
+    adamw: NullType,
+    /** RMSprop optimizer */
+    rmsprop: NullType,
+});
+/**
+ * Output activation function type for the final layer.
+ * Applied only to the output layer, not hidden layers.
+ */
+export const TorchOutputActivationType = VariantType({
+    /** No activation (linear output) - default */
+    none: NullType,
+    /** Softmax (outputs sum to 1, for probability distributions) */
+    softmax: NullType,
+    /** Sigmoid (each output independently in [0,1]) */
+    sigmoid: NullType,
+});
+// ============================================================================
+// Config Types
+// ============================================================================
+/**
+ * Configuration for MLP architecture.
+ */
+export const TorchMLPConfigType = StructType({
+    /** Hidden layer sizes, e.g., [64, 32] */
+    hidden_layers: ArrayType(IntegerType),
+    /** Activation function for hidden layers (default relu) */
+    activation: OptionType(TorchActivationType),
+    /** Output activation function (default none/linear). Ignored if output_constraints is set. */
+    output_activation: OptionType(TorchOutputActivationType),
+    /** Dropout rate (default 0.0) */
+    dropout: OptionType(FloatType),
+    /** Output dimension (default 1) */
+    output_dim: OptionType(IntegerType),
+});
+/**
+ * Configuration for training.
+ */
+export const TorchTrainConfigType = StructType({
+    /** Number of epochs (default 100) */
+    epochs: OptionType(IntegerType),
+    /** Batch size (default 32) */
+    batch_size: OptionType(IntegerType),
+    /** Learning rate (default 0.001) */
+    learning_rate: OptionType(FloatType),
+    /** Loss function (default mse) */
+    loss: OptionType(TorchLossType),
+    /** Optimizer (default adam) */
+    optimizer: OptionType(TorchOptimizerType),
+    /** Early stopping patience, 0 = disabled */
+    early_stopping: OptionType(IntegerType),
+    /** Validation split fraction (default 0.2) */
+    validation_split: OptionType(FloatType),
+    /** Random seed for reproducibility */
+    random_state: OptionType(IntegerType),
+});
+// ============================================================================
+// Result Types
+// ============================================================================
+/**
+ * Result type for training.
+ */
+export const TorchTrainResultType = StructType({
+    /** Training loss per epoch */
+    train_losses: VectorType(FloatType),
+    /** Validation loss per epoch */
+    val_losses: VectorType(FloatType),
+    /** Best epoch (for early stopping) */
+    best_epoch: IntegerType,
+});
+/**
+ * Combined result from training (model + metrics).
+ */
+export const TorchTrainOutputType = StructType({
+    /** Trained model blob */
+    model: VariantType({
+        torch_mlp: StructType({
+            data: BlobType,
+            n_features: IntegerType,
+            hidden_layers: ArrayType(IntegerType),
+            output_dim: IntegerType,
+        }),
+    }),
+    /** Training result with losses */
+    result: TorchTrainResultType,
+});
+// ============================================================================
+// Model Blob Types
+// ============================================================================
+/**
+ * Model blob type for serialized PyTorch models.
+ */
+export const TorchModelBlobType = VariantType({
+    /** PyTorch MLP model */
+    torch_mlp: StructType({
+        /** Cloudpickle serialized model */
+        data: BlobType,
+        /** Number of input features */
+        n_features: IntegerType,
+        /** Hidden layer sizes */
+        hidden_layers: ArrayType(IntegerType),
+        /** Output dimension */
+        output_dim: IntegerType,
+    }),
+});
+// ============================================================================
+// Platform Functions
+// ============================================================================
+/**
+ * Train a PyTorch MLP model.
+ *
+ * @param X - Feature matrix
+ * @param y - Target vector
+ * @param mlp_config - MLP architecture configuration
+ * @param train_config - Training configuration
+ * @returns Model blob and training result
+ */
+export const torch_mlp_train = East.platform("torch_mlp_train", [MatrixType(FloatType), VectorType(FloatType), TorchMLPConfigType, TorchTrainConfigType], TorchTrainOutputType);
+/**
+ * Make predictions with a trained PyTorch MLP.
+ *
+ * @param model - Trained MLP model blob
+ * @param X - Feature matrix
+ * @returns Predicted values
+ */
+export const torch_mlp_predict = East.platform("torch_mlp_predict", [TorchModelBlobType, MatrixType(FloatType)], VectorType(FloatType));
+/**
+ * Train a PyTorch MLP model with multi-output support.
+ *
+ * Supports multi-output regression (predicting multiple values per sample)
+ * and autoencoders (where input equals target for reconstruction learning).
+ * Output dimension is inferred from y.shape[1] unless overridden in config.
+ *
+ * @param X - Feature matrix (n_samples x n_features)
+ * @param y - Target matrix (n_samples x n_outputs)
+ * @param mlp_config - MLP architecture configuration
+ * @param train_config - Training configuration
+ * @returns Model blob and training result
+ */
+export const torch_mlp_train_multi = East.platform("torch_mlp_train_multi", [MatrixType(FloatType), MatrixType(FloatType), TorchMLPConfigType, TorchTrainConfigType], TorchTrainOutputType);
+/**
+ * Make predictions with a trained PyTorch MLP (multi-output).
+ *
+ * Returns a matrix where each row contains the predicted outputs for a sample.
+ *
+ * @param model - Trained MLP model blob
+ * @param X - Feature matrix (n_samples x n_features)
+ * @returns Predicted matrix (n_samples x n_outputs)
+ */
+export const torch_mlp_predict_multi = East.platform("torch_mlp_predict_multi", [TorchModelBlobType, MatrixType(FloatType)], MatrixType(FloatType));
+/**
+ * Extract intermediate layer activations (embeddings) from a trained MLP.
+ *
+ * For autoencoders, this allows extracting the bottleneck representation.
+ * The layer_index specifies which hidden layer's output to return (0-indexed).
+ *
+ * For an autoencoder with architecture [input -> 8 -> 2 -> 8 -> output]
+ * (hidden_layers: [8, 2, 8]):
+ * - layer_index=0: output after first hidden layer (8 features)
+ * - layer_index=1: output after second hidden layer (2 features) <- bottleneck
+ * - layer_index=2: output after third hidden layer (8 features)
+ *
+ * @param model - Trained MLP model blob
+ * @param X - Feature matrix (n_samples x n_features)
+ * @param layer_index - Which hidden layer's output to return (0-indexed)
+ * @returns Embedding matrix (n_samples x hidden_dim at that layer)
+ *
+ * @example
+ * ```ts
+ * // Train autoencoder: 4 features -> 8 -> 2 (bottleneck) -> 8 -> 4 features
+ * const mlp_config = $.let({
+ *     hidden_layers: [8n, 2n, 8n],
+ *     activation: variant('some', variant('relu', {})),
+ *     dropout: variant('none', null),
+ *     output_dim: variant('none', null),
+ * });
+ * const output = $.let(Torch.mlpTrainMulti(X, X, mlp_config, train_config));
+ *
+ * // Extract bottleneck embeddings (layer_index=1 for the 2-dim bottleneck)
+ * const embeddings = $.let(Torch.mlpEncode(output.model, X, 1n));
+ * // embeddings is now (n_samples x 2)
+ * ```
+ */
+export const torch_mlp_encode = East.platform("torch_mlp_encode", [TorchModelBlobType, MatrixType(FloatType), IntegerType], MatrixType(FloatType));
+/**
+ * Decode embeddings back through the decoder portion of an MLP.
+ *
+ * For autoencoders, this takes bottleneck activations and runs them through
+ * the decoder to reconstruct the output. This is the complement to mlpEncode.
+ *
+ * For an autoencoder with architecture [input -> 8 -> 2 -> 8 -> output]
+ * (hidden_layers: [8, 2, 8]):
+ * - layer_index=1: Start from the 2-dim bottleneck, run through layers 2+ to output
+ * - layer_index=0: Start from the 8-dim first layer, run through layers 1+ to output
+ *
+ * Use case: Compute weighted average of origin embeddings, then decode to
+ * get the reconstructed blend weight distribution.
+ *
+ * @param model - Trained MLP model blob
+ * @param embeddings - Embedding matrix (n_samples x hidden_dim at layer_index)
+ * @param layer_index - Which hidden layer the embeddings come from (0-indexed)
+ * @returns Decoded output matrix (n_samples x output_dim)
+ *
+ * @example
+ * ```ts
+ * // After training autoencoder and extracting embeddings...
+ * const origin_embeddings = $.let(Torch.mlpEncode(output.model, X_onehot, 1n));
+ *
+ * // Compute weighted blend embedding (e.g., 50% origin A + 50% origin B)
+ * const blend_embedding = $.let(...); // weighted average of origin embeddings
+ *
+ * // Decode back to weight distribution
+ * const reconstructed = $.let(Torch.mlpDecode(output.model, blend_embedding, 1n));
+ * ```
+ */
+export const torch_mlp_decode = East.platform("torch_mlp_decode", [TorchModelBlobType, MatrixType(FloatType), IntegerType], MatrixType(FloatType));
+// ============================================================================
+// Grouped Export
+// ============================================================================
+/**
+ * Type definitions for PyTorch functions.
+ */
+export const TorchTypes = {
+    /** Activation function type for hidden layers */
+    TorchActivationType,
+    /** Output activation function type */
+    TorchOutputActivationType,
+    /** Loss function type */
+    TorchLossType,
+    /** Optimizer type */
+    TorchOptimizerType,
+    /** MLP configuration type */
+    TorchMLPConfigType,
+    /** Training configuration type */
+    TorchTrainConfigType,
+    /** Training result type */
+    TorchTrainResultType,
+    /** Training output type (model + result) */
+    TorchTrainOutputType,
+    /** Model blob type for PyTorch models */
+    ModelBlobType: TorchModelBlobType,
+};
+/**
+ * PyTorch neural network models.
+ *
+ * Provides MLP training and inference using PyTorch.
+ *
+ * @example
+ * ```ts
+ * import { East, variant } from "@elaraai/east";
+ * import { Torch } from "@elaraai/east-py-datascience";
+ *
+ * const train = East.function([], Torch.Types.TorchTrainOutputType, $ => {
+ *     const X = $.let([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0]]);
+ *     const y = $.let([1.0, 2.0, 3.0, 4.0]);
+ *     const mlp_config = $.let({
+ *         hidden_layers: [32n, 16n],
+ *         activation: variant('none', null),
+ *         dropout: variant('none', null),
+ *         output_dim: variant('none', null),
+ *     });
+ *     const train_config = $.let({
+ *         epochs: variant('some', 50n),
+ *         batch_size: variant('some', 4n),
+ *         learning_rate: variant('some', 0.01),
+ *         loss: variant('none', null),
+ *         optimizer: variant('none', null),
+ *         early_stopping: variant('none', null),
+ *         validation_split: variant('some', 0.2),
+ *         random_state: variant('some', 42n),
+ *     });
+ *     return $.return(Torch.mlpTrain(X, y, mlp_config, train_config));
+ * });
+ * ```
+ */
+export const Torch = {
+    /**
+     * Train a PyTorch MLP model (single output).
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType, VectorType, variant } from "@elaraai/east";
+     * import { Torch, TorchMLPConfigType, TorchTrainConfigType } from "@elaraai/east-py-datascience";
+     *
+     * const train = East.function([], Torch.Types.TorchTrainOutputType, ($) => {
+     *     const X = $.let([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0]]);
+     *     const y = $.let(new Float64Array([1.0, 2.0, 3.0, 4.0]));
+     *     const mlp_config = $.let({
+     *         hidden_layers: new BigInt64Array([16n, 8n]),
+     *         activation: variant("some", variant("relu", null)),
+     *         dropout: variant("none", null),
+     *         output_dim: variant("none", null),
+     *         output_activation: variant("none", null),
+     *     }, TorchMLPConfigType);
+     *     const train_config = $.let({
+     *         epochs: variant("some", 50n), batch_size: variant("some", 4n),
+     *         learning_rate: variant("some", 0.01), loss: variant("none", null),
+     *         optimizer: variant("none", null), early_stopping: variant("none", null),
+     *         validation_split: variant("some", 0.2), random_state: variant("some", 42n),
+     *     }, TorchTrainConfigType);
+     *     return $.return(Torch.mlpTrain(X, y, mlp_config, train_config));
+     * });
+     * ```
+     */
+    mlpTrain: torch_mlp_train,
+    /**
+     * Make predictions with a trained PyTorch MLP (single output).
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType, VectorType } from "@elaraai/east";
+     * import { Torch } from "@elaraai/east-py-datascience";
+     *
+     * const predictFn = East.function(
+     *     [Torch.Types.ModelBlobType, MatrixType(FloatType)],
+     *     VectorType(FloatType),
+     *     ($, model, X) => {
+     *         return $.return(Torch.mlpPredict(model, X));
+     *     }
+     * );
+     * ```
+     */
+    mlpPredict: torch_mlp_predict,
+    /**
+     * Train a PyTorch MLP model with multi-output support.
+     *
+     * Supports multi-output regression and autoencoders (X = y).
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType, variant } from "@elaraai/east";
+     * import { Torch, TorchMLPConfigType, TorchTrainConfigType } from "@elaraai/east-py-datascience";
+     *
+     * const train = East.function([], Torch.Types.TorchTrainOutputType, ($) => {
+     *     const X = $.let([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]);
+     *     const y = $.let([[10.0, 20.0], [30.0, 40.0], [50.0, 60.0]]);
+     *     const mlp_config = $.let({
+     *         hidden_layers: new BigInt64Array([16n, 8n]),
+     *         activation: variant("some", variant("relu", null)),
+     *         dropout: variant("none", null),
+     *         output_dim: variant("none", null),
+     *         output_activation: variant("none", null),
+     *     }, TorchMLPConfigType);
+     *     const train_config = $.let({
+     *         epochs: variant("some", 50n), batch_size: variant("some", 4n),
+     *         learning_rate: variant("some", 0.01), loss: variant("none", null),
+     *         optimizer: variant("none", null), early_stopping: variant("none", null),
+     *         validation_split: variant("some", 0.2), random_state: variant("some", 42n),
+     *     }, TorchTrainConfigType);
+     *     return $.return(Torch.mlpTrainMulti(X, y, mlp_config, train_config));
+     * });
+     * ```
+     */
+    mlpTrainMulti: torch_mlp_train_multi,
+    /**
+     * Make predictions with a trained PyTorch MLP (multi-output).
+     *
+     * Returns a matrix where each row contains predicted outputs for a sample.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType } from "@elaraai/east";
+     * import { Torch } from "@elaraai/east-py-datascience";
+     *
+     * const predictFn = East.function(
+     *     [Torch.Types.ModelBlobType, MatrixType(FloatType)],
+     *     MatrixType(FloatType),
+     *     ($, model, X) => {
+     *         // Returns (n_samples x n_outputs) matrix
+     *         return $.return(Torch.mlpPredictMulti(model, X));
+     *     }
+     * );
+     * ```
+     */
+    mlpPredictMulti: torch_mlp_predict_multi,
+    /** Extract intermediate layer activations (embeddings) from MLP */
+    mlpEncode: torch_mlp_encode,
+    /** Decode embeddings back through decoder portion of MLP */
+    mlpDecode: torch_mlp_decode,
+    /** Type definitions */
+    Types: TorchTypes,
+};
+//# sourceMappingURL=torch.js.map

package/dist/src/torch/torch.js.map

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

package/dist/src/types.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Shared type definitions for East Data Science.
+ *
+ * Provides common East type definitions used across data science modules
+ * including vectors, matrices, and scalar function types.
+ *
+ * @packageDocumentation
+ */
+import { FloatType, FunctionType, VectorType } from "@elaraai/east";
+export { ArrayType, StructType, VariantType, OptionType, FloatType, IntegerType, BooleanType, StringType, FunctionType, VectorType, MatrixType, } from "@elaraai/east";
+/**
+ * Scalar objective function type: Vector<Float> -> Float.
+ *
+ * Used for optimization objectives, constraints, and loss functions
+ * that take a vector of decision variables and return a scalar value.
+ *
+ * @example
+ * ```ts
+ * const sumSquares = East.function([VectorType(FloatType)], FloatType, ($, x) => {
+ *     return x.reduce((acc, xi) => acc.add(xi.multiply(xi)), East.value(0.0));
+ * });
+ * ```
+ */
+export declare const ScalarObjectiveType: FunctionType<[VectorType<FloatType>], FloatType>;
+/**
+ * Vector objective function type: Vector<Float> -> Vector<Float>.
+ *
+ * Used for multi-output predictions and transformations.
+ *
+ * @example
+ * ```ts
+ * const predict = East.function([VectorType(FloatType)], VectorType(FloatType), ($, x) => {
+ *     // Return multiple predictions
+ *     return $.return([...]);
+ * });
+ * ```
+ */
+export declare const VectorObjectiveType: FunctionType<[VectorType<FloatType>], VectorType<FloatType>>;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;GAOG;AAEH,OAAO,EACH,SAAS,EACT,YAAY,EACZ,UAAU,EACb,MAAM,eAAe,CAAC;AAGvB,OAAO,EACH,SAAS,EACT,UAAU,EACV,WAAW,EACX,UAAU,EACV,SAAS,EACT,WAAW,EACX,WAAW,EACX,UAAU,EACV,YAAY,EACZ,UAAU,EACV,UAAU,GACb,MAAM,eAAe,CAAC;AAEvB;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,mBAAmB,kDAAmD,CAAC;AAEpF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,mBAAmB,8DAA+D,CAAC"}

package/dist/src/types.js

@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Shared type definitions for East Data Science.
+ *
+ * Provides common East type definitions used across data science modules
+ * including vectors, matrices, and scalar function types.
+ *
+ * @packageDocumentation
+ */
+import { FloatType, FunctionType, VectorType, } from "@elaraai/east";
+// Re-export commonly used types for convenience
+export { ArrayType, StructType, VariantType, OptionType, FloatType, IntegerType, BooleanType, StringType, FunctionType, VectorType, MatrixType, } from "@elaraai/east";
+/**
+ * Scalar objective function type: Vector<Float> -> Float.
+ *
+ * Used for optimization objectives, constraints, and loss functions
+ * that take a vector of decision variables and return a scalar value.
+ *
+ * @example
+ * ```ts
+ * const sumSquares = East.function([VectorType(FloatType)], FloatType, ($, x) => {
+ *     return x.reduce((acc, xi) => acc.add(xi.multiply(xi)), East.value(0.0));
+ * });
+ * ```
+ */
+export const ScalarObjectiveType = FunctionType([VectorType(FloatType)], FloatType);
+/**
+ * Vector objective function type: Vector<Float> -> Vector<Float>.
+ *
+ * Used for multi-output predictions and transformations.
+ *
+ * @example
+ * ```ts
+ * const predict = East.function([VectorType(FloatType)], VectorType(FloatType), ($, x) => {
+ *     // Return multiple predictions
+ *     return $.return([...]);
+ * });
+ * ```
+ */
+export const VectorObjectiveType = FunctionType([VectorType(FloatType)], VectorType(FloatType));
+//# sourceMappingURL=types.js.map

package/dist/src/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;GAOG;AAEH,OAAO,EACH,SAAS,EACT,YAAY,EACZ,UAAU,GACb,MAAM,eAAe,CAAC;AAEvB,gDAAgD;AAChD,OAAO,EACH,SAAS,EACT,UAAU,EACV,WAAW,EACX,UAAU,EACV,SAAS,EACT,WAAW,EACX,WAAW,EACX,UAAU,EACV,YAAY,EACZ,UAAU,EACV,UAAU,GACb,MAAM,eAAe,CAAC;AAEvB;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,YAAY,CAAC,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;AAEpF;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,YAAY,CAAC,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC"}