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

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

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

package/dist/src/lightning/lightning.js

@@ -0,0 +1,468 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Lightning platform functions for East.
+ *
+ * Provides production-grade neural network training using PyTorch Lightning.
+ * Supports regression, binary classification, multiclass classification,
+ * and multi-head categorical outputs.
+ *
+ * @packageDocumentation
+ */
+import { East, StructType, VariantType, OptionType, IntegerType, FloatType, BlobType, ArrayType, NullType, BooleanType, FunctionType, StringType, } from "@elaraai/east";
+import { VectorType, MatrixType } from "../types.js";
+// Re-export shared types
+export { VectorType, MatrixType } from "../types.js";
+// ===========================================
+// Type Definitions
+// ===========================================
+/**
+ * Lightning output mode - determines loss function and output activation.
+ */
+export const LightningOutputType = VariantType({
+    /** Regression: MSE loss, no activation */
+    regression: NullType,
+    /** Binary: BCE loss, sigmoid activation */
+    binary: StructType({
+        /** Optional per-position pos_weights for class imbalance [output_dim] */
+        pos_weight: OptionType(VectorType(FloatType)),
+    }),
+    /** Multiclass: CrossEntropy loss, softmax activation */
+    multiclass: StructType({
+        /** Number of classes */
+        n_classes: IntegerType,
+        /** Optional per-class weights */
+        class_weights: OptionType(VectorType(FloatType)),
+    }),
+    /** Multi-head categorical: N independent CrossEntropy heads */
+    multi_head: StructType({
+        /** Number of heads (e.g., 84 time slots) */
+        n_heads: IntegerType,
+        /** Classes per head (e.g., 4 bins) */
+        n_classes_per_head: IntegerType,
+        /** Optional class weights matrix (n_heads, n_classes) */
+        class_weights: OptionType(MatrixType(FloatType)),
+    }),
+});
+/**
+ * Cell type for sequential architectures.
+ */
+export const CellType = VariantType({
+    lstm: NullType,
+    gru: NullType,
+});
+/**
+ * Lightning architecture type.
+ */
+export const LightningArchitectureType = VariantType({
+    /** Simple MLP: input → hidden → output */
+    mlp: StructType({
+        /** Hidden layer sizes */
+        hidden_layers: ArrayType(IntegerType),
+    }),
+    /** Autoencoder: input → encoder → latent → decoder → output */
+    autoencoder: StructType({
+        /** Encoder hidden layer sizes */
+        encoder_layers: ArrayType(IntegerType),
+        /** Latent dimension (bottleneck) */
+        latent_dim: IntegerType,
+        /** Decoder hidden layer sizes */
+        decoder_layers: ArrayType(IntegerType),
+    }),
+    /** Conv1D: 1D convolutional autoencoder for temporal patterns */
+    conv1d: StructType({
+        /** Number of channels (e.g., additive types) */
+        n_channels: IntegerType,
+        /** Sequence length (e.g., days) */
+        sequence_length: IntegerType,
+        /** Conv layer channel sizes */
+        conv_channels: ArrayType(IntegerType),
+        /** Kernel size for convolutions (must be odd) */
+        kernel_size: IntegerType,
+        /** Latent dimension after flattening */
+        latent_dim: IntegerType,
+        /** Optional condition dimension for conditional generation */
+        condition_dim: OptionType(IntegerType),
+    }),
+    /** Sequential: LSTM/GRU autoencoder for long-range dependencies */
+    sequential: StructType({
+        /** Number of channels (e.g., additive types) */
+        n_channels: IntegerType,
+        /** Sequence length (e.g., days) */
+        sequence_length: IntegerType,
+        /** RNN hidden size */
+        hidden_size: IntegerType,
+        /** Number of RNN layers */
+        n_layers: IntegerType,
+        /** Cell type: lstm or gru */
+        cell_type: CellType,
+        /** Latent dimension (from final hidden state) */
+        latent_dim: IntegerType,
+        /** Bidirectional encoder (decoder is always unidirectional) */
+        bidirectional: BooleanType,
+        /** Optional condition dimension for conditional generation */
+        condition_dim: OptionType(IntegerType),
+    }),
+    /** Transformer: attention-based autoencoder for complex patterns */
+    transformer: StructType({
+        /** Number of channels (e.g., additive types) */
+        n_channels: IntegerType,
+        /** Sequence length (e.g., days) */
+        sequence_length: IntegerType,
+        /** Model dimension */
+        d_model: IntegerType,
+        /** Number of attention heads (must divide d_model evenly) */
+        n_attention_heads: IntegerType,
+        /** Number of transformer layers */
+        n_layers: IntegerType,
+        /** Feedforward dimension (default: 4 * d_model) */
+        d_ff: OptionType(IntegerType),
+        /** Latent dimension (mean pooled output) */
+        latent_dim: IntegerType,
+        /** Optional condition dimension for conditional generation */
+        condition_dim: OptionType(IntegerType),
+    }),
+});
+/**
+ * Epoch callback function type: (epoch, train_loss, val_loss) -> void
+ */
+export const LightningEpochCallbackType = FunctionType([IntegerType, FloatType, FloatType], NullType);
+/**
+ * Lightning training configuration.
+ */
+export const LightningConfigType = StructType({
+    /** Model architecture */
+    architecture: LightningArchitectureType,
+    /** Output mode (determines loss function) */
+    output: LightningOutputType,
+    /** Learning rate (default: 1e-3) */
+    learning_rate: OptionType(FloatType),
+    /** Maximum epochs (default: 100) */
+    max_epochs: OptionType(IntegerType),
+    /** Early stopping patience (default: 10) */
+    patience: OptionType(IntegerType),
+    /** Batch size (default: 32) */
+    batch_size: OptionType(IntegerType),
+    /** Dropout rate (default: 0.1) */
+    dropout: OptionType(FloatType),
+    /** Gradient clipping value (default: 1.0) */
+    gradient_clip: OptionType(FloatType),
+    /** L2 regularization weight decay (default: 0) */
+    weight_decay: OptionType(FloatType),
+    /** Random seed for reproducibility */
+    random_state: OptionType(IntegerType),
+    /** Optional callback called each epoch */
+    epoch_callback: OptionType(LightningEpochCallbackType),
+});
+/**
+ * Lightning model blob structure.
+ */
+export const LightningModelBlobType = VariantType({
+    lightning: StructType({
+        /** Serialized model data (state_dict + hparams) */
+        data: BlobType,
+        /** Input dimension */
+        n_features: IntegerType,
+        /** Output dimension */
+        output_dim: IntegerType,
+        /** Architecture type */
+        architecture_type: StringType,
+        /** Output type */
+        output_type: StringType,
+        /** Latent dimension (autoencoder only) */
+        latent_dim: OptionType(IntegerType),
+    }),
+});
+/**
+ * Lightning training result.
+ */
+export const LightningResultType = StructType({
+    /** Trained model blob */
+    model: LightningModelBlobType,
+    /** Final training loss */
+    train_loss: FloatType,
+    /** Final validation loss */
+    val_loss: FloatType,
+    /** Best epoch (for early stopping) */
+    best_epoch: IntegerType,
+});
+/**
+ * 3D boolean tensor for masks: (n_samples, n_heads, n_classes)
+ */
+export const Tensor3DBoolType = ArrayType(ArrayType(ArrayType(BooleanType)));
+/**
+ * Group-based weights for per-sample class weighting.
+ *
+ * Instead of per-sample weights (memory-intensive), samples belong to discrete
+ * groups (e.g., grades) with different weight configurations per group.
+ */
+export const GroupWeightsType = StructType({
+    /** Weights per group - shape depends on output type */
+    weights: VariantType({
+        /** For binary: pos_weight vector per group [n_groups][output_dim] */
+        binary: ArrayType(ArrayType(FloatType)),
+        /** For multi_head: class_weight matrix per group [n_groups][n_heads][n_classes] */
+        multi_head: ArrayType(ArrayType(ArrayType(FloatType))),
+    }),
+    /** Group index per sample: [n_samples] */
+    sample_groups: ArrayType(IntegerType),
+});
+// ===========================================
+// Platform Functions
+// ===========================================
+/**
+ * Train a Lightning model.
+ *
+ * @param X - Input features matrix (n_samples, n_features)
+ * @param y - Target matrix (n_samples, output_dim)
+ * @param config - Training configuration
+ * @param masks - Optional 3D boolean masks (n_samples, n_heads, n_classes)
+ * @param group_weights - Optional group-based weights for per-sample weighting
+ * @param conditions - Optional condition matrix for conditional generation (n_samples, condition_dim)
+ * @returns Training result with model blob and metrics
+ */
+export const lightning_train = East.platform("lightning_train", [MatrixType(FloatType), MatrixType(FloatType), LightningConfigType, OptionType(Tensor3DBoolType), OptionType(GroupWeightsType), OptionType(MatrixType(FloatType))], LightningResultType);
+/**
+ * Predict using a Lightning model.
+ *
+ * @param model - Trained model blob
+ * @param X - Input features matrix (n_samples, n_features)
+ * @param masks - Optional 3D boolean masks for inference
+ * @param conditions - Optional condition matrix for conditional models (n_samples, condition_dim)
+ * @returns Predicted probabilities matrix (n_samples, output_dim)
+ */
+export const lightning_predict = East.platform("lightning_predict", [LightningModelBlobType, MatrixType(FloatType), OptionType(Tensor3DBoolType), OptionType(MatrixType(FloatType))], MatrixType(FloatType));
+/**
+ * Encode input to latent space (autoencoder only).
+ *
+ * @param model - Trained autoencoder model blob
+ * @param X - Input features matrix (n_samples, n_features)
+ * @returns Latent embeddings matrix (n_samples, latent_dim)
+ */
+export const lightning_encode = East.platform("lightning_encode", [LightningModelBlobType, MatrixType(FloatType)], MatrixType(FloatType));
+/**
+ * Decode latent to output (autoencoder only).
+ *
+ * @param model - Trained autoencoder model blob
+ * @param z - Latent embeddings matrix (n_samples, latent_dim)
+ * @returns Decoded output matrix (n_samples, output_dim)
+ */
+export const lightning_decode = East.platform("lightning_decode", [LightningModelBlobType, MatrixType(FloatType)], MatrixType(FloatType));
+/**
+ * Decode latent to output with condition (temporal architectures with condition_dim).
+ *
+ * @param model - Trained model with condition_dim set
+ * @param z - Latent embeddings matrix (n_samples, latent_dim)
+ * @param condition - Condition vectors (n_samples, condition_dim)
+ * @returns Decoded output matrix (n_samples, output_dim)
+ */
+export const lightning_decode_conditional = East.platform("lightning_decode_conditional", [LightningModelBlobType, MatrixType(FloatType), MatrixType(FloatType)], MatrixType(FloatType));
+/**
+ * Configuration for autoregressive sequence generation.
+ */
+export const LightningGenerateConfigType = StructType({
+    /** Number of steps to generate */
+    n_steps: IntegerType,
+    /** Sampling temperature: 0.0 = argmax, > 0 = scaled sampling */
+    temperature: FloatType,
+    /** If true, return probabilities. If false, return samples. */
+    return_probs: BooleanType,
+});
+/**
+ * Generate sequence autoregressively from a sequential model.
+ *
+ * Shapes:
+ * - prefix: (n_prefix_steps, n_channels) - partial history to continue from, can be empty []
+ * - condition: (1, condition_dim) - conditioning features, or none
+ * - returns: (n_steps, n_channels) - generated timesteps only (not including prefix)
+ *
+ * @param model - Trained sequential model blob
+ * @param prefix - Partial history to continue from
+ * @param condition - Optional conditioning features
+ * @param config - Generation configuration
+ * @returns Generated sequence matrix
+ */
+export const lightning_generate_sequence = East.platform("lightning_generate_sequence", [LightningModelBlobType, MatrixType(FloatType), OptionType(MatrixType(FloatType)), LightningGenerateConfigType], MatrixType(FloatType));
+// ===========================================
+// Grouped Export
+// ===========================================
+/**
+ * Lightning types namespace.
+ */
+export const LightningTypes = {
+    OutputType: LightningOutputType,
+    ArchitectureType: LightningArchitectureType,
+    CellType,
+    EpochCallbackType: LightningEpochCallbackType,
+    ConfigType: LightningConfigType,
+    ResultType: LightningResultType,
+    ModelBlobType: LightningModelBlobType,
+    Tensor3DBoolType,
+    GroupWeightsType,
+    GenerateConfigType: LightningGenerateConfigType,
+};
+/**
+ * Lightning platform functions namespace.
+ *
+ * Provides production-grade neural network training using PyTorch Lightning.
+ *
+ * @example
+ * ```typescript
+ * const result = Lightning.train(X, y, {
+ *     architecture: variant("autoencoder", {
+ *         encoder_layers: [64n],
+ *         latent_dim: 16n,
+ *         decoder_layers: [64n],
+ *     }),
+ *     output: variant("multi_head", {
+ *         n_heads: 84n,
+ *         n_classes_per_head: 4n,
+ *         class_weights: variant("none", null),
+ *     }),
+ * }, variant("none", null));
+ *
+ * const embeddings = Lightning.encode(result.model, X);
+ * const predictions = Lightning.predict(result.model, X, variant("none", null));
+ * ```
+ */
+export const Lightning = {
+    /**
+     * Train a Lightning model.
+     *
+     * Trains a neural network using PyTorch Lightning with early stopping,
+     * gradient clipping, and optional epoch callbacks.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType, variant } from "@elaraai/east";
+     * import { Lightning, LightningConfigType } from "@elaraai/east-py-datascience";
+     *
+     * const train = East.function([], Lightning.Types.ResultType, ($) => {
+     *     const X = $.let([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0]]);
+     *     const y = $.let([[1.0, 0.0], [0.0, 1.0], [1.0, 0.0], [0.0, 1.0]]);
+     *     const config = $.let({
+     *         architecture: variant("autoencoder", {
+     *             encoder_layers: new BigInt64Array([16n]),
+     *             latent_dim: 4n,
+     *             decoder_layers: new BigInt64Array([16n]),
+     *         }),
+     *         output: variant("regression", null),
+     *         max_epochs: variant("some", 50n),
+     *         batch_size: variant("some", 4n),
+     *         learning_rate: variant("some", 0.001),
+     *         patience: variant("some", 10n),
+     *         seed: variant("some", 42n),
+     *         epoch_callback: variant("none", null),
+     *         gradient_clip_val: variant("none", null),
+     *         condition_dim: variant("none", null),
+     *     }, LightningConfigType);
+     *     return $.return(Lightning.train(X, y, config, variant("none", null), variant("none", null), variant("none", null)));
+     * });
+     * ```
+     */
+    train: lightning_train,
+    /**
+     * Predict using a trained Lightning model.
+     *
+     * Returns predictions with optional mask support for multi-head outputs.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType, variant } from "@elaraai/east";
+     * import { Lightning } from "@elaraai/east-py-datascience";
+     *
+     * const predictFn = East.function(
+     *     [Lightning.Types.ModelBlobType, MatrixType(FloatType)],
+     *     MatrixType(FloatType),
+     *     ($, model, X) => {
+     *         return $.return(Lightning.predict(model, X, variant("none", null), variant("none", null)));
+     *     }
+     * );
+     * ```
+     */
+    predict: lightning_predict,
+    /**
+     * Encode inputs to latent space (autoencoder only).
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType } from "@elaraai/east";
+     * import { Lightning } from "@elaraai/east-py-datascience";
+     *
+     * const encodeFn = East.function(
+     *     [Lightning.Types.ModelBlobType, MatrixType(FloatType)],
+     *     MatrixType(FloatType),
+     *     ($, model, X) => {
+     *         // Returns (n_samples x latent_dim) embeddings
+     *         return $.return(Lightning.encode(model, X));
+     *     }
+     * );
+     * ```
+     */
+    encode: lightning_encode,
+    /**
+     * Decode latent embeddings to output space (autoencoder only).
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType } from "@elaraai/east";
+     * import { Lightning } from "@elaraai/east-py-datascience";
+     *
+     * const decodeFn = East.function(
+     *     [Lightning.Types.ModelBlobType, MatrixType(FloatType)],
+     *     MatrixType(FloatType),
+     *     ($, model, z) => {
+     *         // z is (n_samples x latent_dim), returns (n_samples x output_dim)
+     *         return $.return(Lightning.decode(model, z));
+     *     }
+     * );
+     * ```
+     */
+    decode: lightning_decode,
+    /**
+     * Decode latent embeddings with condition vector (temporal architectures).
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, MatrixType } from "@elaraai/east";
+     * import { Lightning } from "@elaraai/east-py-datascience";
+     *
+     * const decodeFn = East.function(
+     *     [Lightning.Types.ModelBlobType, MatrixType(FloatType), MatrixType(FloatType)],
+     *     MatrixType(FloatType),
+     *     ($, model, z, condition) => {
+     *         // z: (n_samples, latent_dim), condition: (n_samples, condition_dim)
+     *         return $.return(Lightning.decodeConditional(model, z, condition));
+     *     }
+     * );
+     * ```
+     */
+    decodeConditional: lightning_decode_conditional,
+    /**
+     * Generate sequence autoregressively from a sequential model.
+     *
+     * @example
+     * ```ts
+     * import { East, FloatType, IntegerType, BooleanType, MatrixType, variant } from "@elaraai/east";
+     * import { Lightning } from "@elaraai/east-py-datascience";
+     *
+     * const generateFn = East.function(
+     *     [Lightning.Types.ModelBlobType, MatrixType(FloatType)],
+     *     MatrixType(FloatType),
+     *     ($, model, prefix) => {
+     *         const config = $.let({ n_steps: 10n, temperature: 1.0, return_probs: false });
+     *         // prefix: partial history, condition: none
+     *         return $.return(Lightning.generateSequence(model, prefix, variant("none", null), config));
+     *     }
+     * );
+     * ```
+     */
+    generateSequence: lightning_generate_sequence,
+    /**
+     * Type definitions for Lightning functions.
+     */
+    Types: LightningTypes,
+};
+//# sourceMappingURL=lightning.js.map

package/dist/src/lightning/lightning.js.map

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