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

package/dist/torch/torch.d.ts

@@ -10,44 +10,58 @@
  *
  * @packageDocumentation
  */
-import { StructType, VariantType, OptionType, IntegerType, FloatType, BlobType, ArrayType } from "@elaraai/east";
+import { StructType, VariantType, OptionType, IntegerType, FloatType, BlobType, ArrayType, NullType } from "@elaraai/east";
 export { VectorType, MatrixType } from "../types.js";
 /**
- * Activation function type for neural networks.
+ * Activation function type for hidden layers.
  */
 export declare const TorchActivationType: VariantType<{
     /** Rectified Linear Unit */
-    relu: StructType<{}>;
+    relu: NullType;
     /** Hyperbolic tangent */
-    tanh: StructType<{}>;
+    tanh: NullType;
     /** Sigmoid function */
-    sigmoid: StructType<{}>;
+    sigmoid: NullType;
     /** Leaky ReLU */
-    leaky_relu: StructType<{}>;
+    leaky_relu: NullType;
 }>;
 /**
  * Loss function type for training.
  */
 export declare const TorchLossType: VariantType<{
     /** Mean Squared Error (regression) */
-    mse: StructType<{}>;
+    mse: NullType;
     /** Mean Absolute Error (regression) */
-    mae: StructType<{}>;
+    mae: NullType;
     /** Cross Entropy (classification) */
-    cross_entropy: StructType<{}>;
+    cross_entropy: NullType;
+    /** KL Divergence (distribution matching, use with softmax output) */
+    kl_div: NullType;
 }>;
 /**
  * Optimizer type for training.
  */
 export declare const TorchOptimizerType: VariantType<{
     /** Adam optimizer */
-    adam: StructType<{}>;
+    adam: NullType;
     /** Stochastic Gradient Descent */
-    sgd: StructType<{}>;
+    sgd: NullType;
     /** AdamW with weight decay */
-    adamw: StructType<{}>;
+    adamw: NullType;
     /** RMSprop optimizer */
-    rmsprop: StructType<{}>;
+    rmsprop: NullType;
+}>;
+/**
+ * Output activation function type for the final layer.
+ * Applied only to the output layer, not hidden layers.
+ */
+export declare 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;
 }>;
 /**
  * Configuration for MLP architecture.
@@ -55,16 +69,25 @@ export declare const TorchOptimizerType: VariantType<{
 export declare const TorchMLPConfigType: StructType<{
     /** Hidden layer sizes, e.g., [64, 32] */
     hidden_layers: ArrayType<IntegerType>;
-    /** Activation function (default relu) */
+    /** Activation function for hidden layers (default relu) */
     activation: OptionType<VariantType<{
         /** Rectified Linear Unit */
-        relu: StructType<{}>;
+        relu: NullType;
         /** Hyperbolic tangent */
-        tanh: StructType<{}>;
+        tanh: NullType;
         /** Sigmoid function */
-        sigmoid: StructType<{}>;
+        sigmoid: NullType;
         /** Leaky ReLU */
-        leaky_relu: StructType<{}>;
+        leaky_relu: NullType;
+    }>>;
+    /** Output activation function (default none/linear) */
+    output_activation: OptionType<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;
     }>>;
     /** Dropout rate (default 0.0) */
     dropout: OptionType<FloatType>;
@@ -84,22 +107,24 @@ export declare const TorchTrainConfigType: StructType<{
     /** Loss function (default mse) */
     loss: OptionType<VariantType<{
         /** Mean Squared Error (regression) */
-        mse: StructType<{}>;
+        mse: NullType;
         /** Mean Absolute Error (regression) */
-        mae: StructType<{}>;
+        mae: NullType;
         /** Cross Entropy (classification) */
-        cross_entropy: StructType<{}>;
+        cross_entropy: NullType;
+        /** KL Divergence (distribution matching, use with softmax output) */
+        kl_div: NullType;
     }>>;
     /** Optimizer (default adam) */
     optimizer: OptionType<VariantType<{
         /** Adam optimizer */
-        adam: StructType<{}>;
+        adam: NullType;
         /** Stochastic Gradient Descent */
-        sgd: StructType<{}>;
+        sgd: NullType;
         /** AdamW with weight decay */
-        adamw: StructType<{}>;
+        adamw: NullType;
         /** RMSprop optimizer */
-        rmsprop: StructType<{}>;
+        rmsprop: NullType;
     }>>;
     /** Early stopping patience, 0 = disabled */
     early_stopping: OptionType<IntegerType>;
@@ -170,16 +195,25 @@ export declare const TorchModelBlobType: VariantType<{
 export declare const torch_mlp_train: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<FloatType>, StructType<{
     /** Hidden layer sizes, e.g., [64, 32] */
     hidden_layers: ArrayType<IntegerType>;
-    /** Activation function (default relu) */
+    /** Activation function for hidden layers (default relu) */
     activation: OptionType<VariantType<{
         /** Rectified Linear Unit */
-        relu: StructType<{}>;
+        relu: NullType;
         /** Hyperbolic tangent */
-        tanh: StructType<{}>;
+        tanh: NullType;
         /** Sigmoid function */
-        sigmoid: StructType<{}>;
+        sigmoid: NullType;
         /** Leaky ReLU */
-        leaky_relu: StructType<{}>;
+        leaky_relu: NullType;
+    }>>;
+    /** Output activation function (default none/linear) */
+    output_activation: OptionType<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;
     }>>;
     /** Dropout rate (default 0.0) */
     dropout: OptionType<FloatType>;
@@ -195,22 +229,24 @@ export declare const torch_mlp_train: import("@elaraai/east").PlatformDefinition
     /** Loss function (default mse) */
     loss: OptionType<VariantType<{
         /** Mean Squared Error (regression) */
-        mse: StructType<{}>;
+        mse: NullType;
         /** Mean Absolute Error (regression) */
-        mae: StructType<{}>;
+        mae: NullType;
         /** Cross Entropy (classification) */
-        cross_entropy: StructType<{}>;
+        cross_entropy: NullType;
+        /** KL Divergence (distribution matching, use with softmax output) */
+        kl_div: NullType;
     }>>;
     /** Optimizer (default adam) */
     optimizer: OptionType<VariantType<{
         /** Adam optimizer */
-        adam: StructType<{}>;
+        adam: NullType;
         /** Stochastic Gradient Descent */
-        sgd: StructType<{}>;
+        sgd: NullType;
         /** AdamW with weight decay */
-        adamw: StructType<{}>;
+        adamw: NullType;
         /** RMSprop optimizer */
-        rmsprop: StructType<{}>;
+        rmsprop: NullType;
     }>>;
     /** Early stopping patience, 0 = disabled */
     early_stopping: OptionType<IntegerType>;
@@ -258,6 +294,213 @@ export declare const torch_mlp_predict: import("@elaraai/east").PlatformDefiniti
         output_dim: IntegerType;
     }>;
 }>, ArrayType<ArrayType<FloatType>>], ArrayType<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 declare const torch_mlp_train_multi: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<ArrayType<FloatType>>, StructType<{
+    /** Hidden layer sizes, e.g., [64, 32] */
+    hidden_layers: ArrayType<IntegerType>;
+    /** Activation function for hidden layers (default relu) */
+    activation: OptionType<VariantType<{
+        /** Rectified Linear Unit */
+        relu: NullType;
+        /** Hyperbolic tangent */
+        tanh: NullType;
+        /** Sigmoid function */
+        sigmoid: NullType;
+        /** Leaky ReLU */
+        leaky_relu: NullType;
+    }>>;
+    /** Output activation function (default none/linear) */
+    output_activation: OptionType<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;
+    }>>;
+    /** Dropout rate (default 0.0) */
+    dropout: OptionType<FloatType>;
+    /** Output dimension (default 1) */
+    output_dim: OptionType<IntegerType>;
+}>, 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<VariantType<{
+        /** Mean Squared Error (regression) */
+        mse: NullType;
+        /** Mean Absolute Error (regression) */
+        mae: NullType;
+        /** Cross Entropy (classification) */
+        cross_entropy: NullType;
+        /** KL Divergence (distribution matching, use with softmax output) */
+        kl_div: NullType;
+    }>>;
+    /** Optimizer (default adam) */
+    optimizer: OptionType<VariantType<{
+        /** Adam optimizer */
+        adam: NullType;
+        /** Stochastic Gradient Descent */
+        sgd: NullType;
+        /** AdamW with weight decay */
+        adamw: NullType;
+        /** RMSprop optimizer */
+        rmsprop: NullType;
+    }>>;
+    /** 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>;
+}>], 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: StructType<{
+        /** Training loss per epoch */
+        train_losses: ArrayType<FloatType>;
+        /** Validation loss per epoch */
+        val_losses: ArrayType<FloatType>;
+        /** Best epoch (for early stopping) */
+        best_epoch: IntegerType;
+    }>;
+}>>;
+/**
+ * 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 declare const torch_mlp_predict_multi: import("@elaraai/east").PlatformDefinition<[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;
+    }>;
+}>, ArrayType<ArrayType<FloatType>>], ArrayType<ArrayType<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 declare const torch_mlp_encode: import("@elaraai/east").PlatformDefinition<[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;
+    }>;
+}>, ArrayType<ArrayType<FloatType>>, IntegerType], ArrayType<ArrayType<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 declare const torch_mlp_decode: import("@elaraai/east").PlatformDefinition<[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;
+    }>;
+}>, ArrayType<ArrayType<FloatType>>, IntegerType], ArrayType<ArrayType<FloatType>>>;
 /**
  * Type definitions for PyTorch functions.
  */
@@ -266,51 +509,71 @@ export declare const TorchTypes: {
     readonly VectorType: ArrayType<FloatType>;
     /** Matrix type (2D array of floats) */
     readonly MatrixType: ArrayType<ArrayType<FloatType>>;
-    /** Activation function type */
+    /** Activation function type for hidden layers */
     readonly TorchActivationType: VariantType<{
         /** Rectified Linear Unit */
-        relu: StructType<{}>;
+        relu: NullType;
         /** Hyperbolic tangent */
-        tanh: StructType<{}>;
+        tanh: NullType;
         /** Sigmoid function */
-        sigmoid: StructType<{}>;
+        sigmoid: NullType;
         /** Leaky ReLU */
-        leaky_relu: StructType<{}>;
+        leaky_relu: NullType;
+    }>;
+    /** Output activation function type */
+    readonly 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;
     }>;
     /** Loss function type */
     readonly TorchLossType: VariantType<{
         /** Mean Squared Error (regression) */
-        mse: StructType<{}>;
+        mse: NullType;
         /** Mean Absolute Error (regression) */
-        mae: StructType<{}>;
+        mae: NullType;
         /** Cross Entropy (classification) */
-        cross_entropy: StructType<{}>;
+        cross_entropy: NullType;
+        /** KL Divergence (distribution matching, use with softmax output) */
+        kl_div: NullType;
     }>;
     /** Optimizer type */
     readonly TorchOptimizerType: VariantType<{
         /** Adam optimizer */
-        adam: StructType<{}>;
+        adam: NullType;
         /** Stochastic Gradient Descent */
-        sgd: StructType<{}>;
+        sgd: NullType;
         /** AdamW with weight decay */
-        adamw: StructType<{}>;
+        adamw: NullType;
         /** RMSprop optimizer */
-        rmsprop: StructType<{}>;
+        rmsprop: NullType;
     }>;
     /** MLP configuration type */
     readonly TorchMLPConfigType: StructType<{
         /** Hidden layer sizes, e.g., [64, 32] */
         hidden_layers: ArrayType<IntegerType>;
-        /** Activation function (default relu) */
+        /** Activation function for hidden layers (default relu) */
         activation: OptionType<VariantType<{
             /** Rectified Linear Unit */
-            relu: StructType<{}>;
+            relu: NullType;
             /** Hyperbolic tangent */
-            tanh: StructType<{}>;
+            tanh: NullType;
             /** Sigmoid function */
-            sigmoid: StructType<{}>;
+            sigmoid: NullType;
             /** Leaky ReLU */
-            leaky_relu: StructType<{}>;
+            leaky_relu: NullType;
+        }>>;
+        /** Output activation function (default none/linear) */
+        output_activation: OptionType<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;
         }>>;
         /** Dropout rate (default 0.0) */
         dropout: OptionType<FloatType>;
@@ -328,22 +591,24 @@ export declare const TorchTypes: {
         /** Loss function (default mse) */
         loss: OptionType<VariantType<{
             /** Mean Squared Error (regression) */
-            mse: StructType<{}>;
+            mse: NullType;
             /** Mean Absolute Error (regression) */
-            mae: StructType<{}>;
+            mae: NullType;
             /** Cross Entropy (classification) */
-            cross_entropy: StructType<{}>;
+            cross_entropy: NullType;
+            /** KL Divergence (distribution matching, use with softmax output) */
+            kl_div: NullType;
         }>>;
         /** Optimizer (default adam) */
         optimizer: OptionType<VariantType<{
             /** Adam optimizer */
-            adam: StructType<{}>;
+            adam: NullType;
             /** Stochastic Gradient Descent */
-            sgd: StructType<{}>;
+            sgd: NullType;
             /** AdamW with weight decay */
-            adamw: StructType<{}>;
+            adamw: NullType;
             /** RMSprop optimizer */
-            rmsprop: StructType<{}>;
+            rmsprop: NullType;
         }>>;
         /** Early stopping patience, 0 = disabled */
         early_stopping: OptionType<IntegerType>;
@@ -431,20 +696,29 @@ export declare const TorchTypes: {
  * ```
  */
 export declare const Torch: {
-    /** Train MLP model */
+    /** Train MLP model (single output) */
     readonly mlpTrain: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<FloatType>, StructType<{
         /** Hidden layer sizes, e.g., [64, 32] */
         hidden_layers: ArrayType<IntegerType>;
-        /** Activation function (default relu) */
+        /** Activation function for hidden layers (default relu) */
         activation: OptionType<VariantType<{
             /** Rectified Linear Unit */
-            relu: StructType<{}>;
+            relu: NullType;
             /** Hyperbolic tangent */
-            tanh: StructType<{}>;
+            tanh: NullType;
             /** Sigmoid function */
-            sigmoid: StructType<{}>;
+            sigmoid: NullType;
             /** Leaky ReLU */
-            leaky_relu: StructType<{}>;
+            leaky_relu: NullType;
+        }>>;
+        /** Output activation function (default none/linear) */
+        output_activation: OptionType<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;
         }>>;
         /** Dropout rate (default 0.0) */
         dropout: OptionType<FloatType>;
@@ -460,22 +734,24 @@ export declare const Torch: {
         /** Loss function (default mse) */
         loss: OptionType<VariantType<{
             /** Mean Squared Error (regression) */
-            mse: StructType<{}>;
+            mse: NullType;
             /** Mean Absolute Error (regression) */
-            mae: StructType<{}>;
+            mae: NullType;
             /** Cross Entropy (classification) */
-            cross_entropy: StructType<{}>;
+            cross_entropy: NullType;
+            /** KL Divergence (distribution matching, use with softmax output) */
+            kl_div: NullType;
         }>>;
         /** Optimizer (default adam) */
         optimizer: OptionType<VariantType<{
             /** Adam optimizer */
-            adam: StructType<{}>;
+            adam: NullType;
             /** Stochastic Gradient Descent */
-            sgd: StructType<{}>;
+            sgd: NullType;
             /** AdamW with weight decay */
-            adamw: StructType<{}>;
+            adamw: NullType;
             /** RMSprop optimizer */
-            rmsprop: StructType<{}>;
+            rmsprop: NullType;
         }>>;
         /** Early stopping patience, 0 = disabled */
         early_stopping: OptionType<IntegerType>;
@@ -503,7 +779,7 @@ export declare const Torch: {
             best_epoch: IntegerType;
         }>;
     }>>;
-    /** Make predictions with MLP */
+    /** Make predictions with MLP (single output) */
     readonly mlpPredict: import("@elaraai/east").PlatformDefinition<[VariantType<{
         /** PyTorch MLP model */
         torch_mlp: StructType<{
@@ -517,57 +793,202 @@ export declare const Torch: {
             output_dim: IntegerType;
         }>;
     }>, ArrayType<ArrayType<FloatType>>], ArrayType<FloatType>>;
+    /** Train MLP model (multi-output) */
+    readonly mlpTrainMulti: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<ArrayType<FloatType>>, StructType<{
+        /** Hidden layer sizes, e.g., [64, 32] */
+        hidden_layers: ArrayType<IntegerType>;
+        /** Activation function for hidden layers (default relu) */
+        activation: OptionType<VariantType<{
+            /** Rectified Linear Unit */
+            relu: NullType;
+            /** Hyperbolic tangent */
+            tanh: NullType;
+            /** Sigmoid function */
+            sigmoid: NullType;
+            /** Leaky ReLU */
+            leaky_relu: NullType;
+        }>>;
+        /** Output activation function (default none/linear) */
+        output_activation: OptionType<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;
+        }>>;
+        /** Dropout rate (default 0.0) */
+        dropout: OptionType<FloatType>;
+        /** Output dimension (default 1) */
+        output_dim: OptionType<IntegerType>;
+    }>, 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<VariantType<{
+            /** Mean Squared Error (regression) */
+            mse: NullType;
+            /** Mean Absolute Error (regression) */
+            mae: NullType;
+            /** Cross Entropy (classification) */
+            cross_entropy: NullType;
+            /** KL Divergence (distribution matching, use with softmax output) */
+            kl_div: NullType;
+        }>>;
+        /** Optimizer (default adam) */
+        optimizer: OptionType<VariantType<{
+            /** Adam optimizer */
+            adam: NullType;
+            /** Stochastic Gradient Descent */
+            sgd: NullType;
+            /** AdamW with weight decay */
+            adamw: NullType;
+            /** RMSprop optimizer */
+            rmsprop: NullType;
+        }>>;
+        /** 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>;
+    }>], 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: StructType<{
+            /** Training loss per epoch */
+            train_losses: ArrayType<FloatType>;
+            /** Validation loss per epoch */
+            val_losses: ArrayType<FloatType>;
+            /** Best epoch (for early stopping) */
+            best_epoch: IntegerType;
+        }>;
+    }>>;
+    /** Make predictions with MLP (multi-output) */
+    readonly mlpPredictMulti: import("@elaraai/east").PlatformDefinition<[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;
+        }>;
+    }>, ArrayType<ArrayType<FloatType>>], ArrayType<ArrayType<FloatType>>>;
+    /** Extract intermediate layer activations (embeddings) from MLP */
+    readonly mlpEncode: import("@elaraai/east").PlatformDefinition<[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;
+        }>;
+    }>, ArrayType<ArrayType<FloatType>>, IntegerType], ArrayType<ArrayType<FloatType>>>;
+    /** Decode embeddings back through decoder portion of MLP */
+    readonly mlpDecode: import("@elaraai/east").PlatformDefinition<[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;
+        }>;
+    }>, ArrayType<ArrayType<FloatType>>, IntegerType], ArrayType<ArrayType<FloatType>>>;
     /** Type definitions */
     readonly Types: {
         /** Vector type (array of floats) */
         readonly VectorType: ArrayType<FloatType>;
         /** Matrix type (2D array of floats) */
         readonly MatrixType: ArrayType<ArrayType<FloatType>>;
-        /** Activation function type */
+        /** Activation function type for hidden layers */
         readonly TorchActivationType: VariantType<{
             /** Rectified Linear Unit */
-            relu: StructType<{}>;
+            relu: NullType;
             /** Hyperbolic tangent */
-            tanh: StructType<{}>;
+            tanh: NullType;
             /** Sigmoid function */
-            sigmoid: StructType<{}>;
+            sigmoid: NullType;
             /** Leaky ReLU */
-            leaky_relu: StructType<{}>;
+            leaky_relu: NullType;
+        }>;
+        /** Output activation function type */
+        readonly 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;
         }>;
         /** Loss function type */
         readonly TorchLossType: VariantType<{
             /** Mean Squared Error (regression) */
-            mse: StructType<{}>;
+            mse: NullType;
             /** Mean Absolute Error (regression) */
-            mae: StructType<{}>;
+            mae: NullType;
             /** Cross Entropy (classification) */
-            cross_entropy: StructType<{}>;
+            cross_entropy: NullType;
+            /** KL Divergence (distribution matching, use with softmax output) */
+            kl_div: NullType;
         }>;
         /** Optimizer type */
         readonly TorchOptimizerType: VariantType<{
             /** Adam optimizer */
-            adam: StructType<{}>;
+            adam: NullType;
             /** Stochastic Gradient Descent */
-            sgd: StructType<{}>;
+            sgd: NullType;
             /** AdamW with weight decay */
-            adamw: StructType<{}>;
+            adamw: NullType;
             /** RMSprop optimizer */
-            rmsprop: StructType<{}>;
+            rmsprop: NullType;
         }>;
         /** MLP configuration type */
         readonly TorchMLPConfigType: StructType<{
             /** Hidden layer sizes, e.g., [64, 32] */
             hidden_layers: ArrayType<IntegerType>;
-            /** Activation function (default relu) */
+            /** Activation function for hidden layers (default relu) */
             activation: OptionType<VariantType<{
                 /** Rectified Linear Unit */
-                relu: StructType<{}>;
+                relu: NullType;
                 /** Hyperbolic tangent */
-                tanh: StructType<{}>;
+                tanh: NullType;
                 /** Sigmoid function */
-                sigmoid: StructType<{}>;
+                sigmoid: NullType;
                 /** Leaky ReLU */
-                leaky_relu: StructType<{}>;
+                leaky_relu: NullType;
+            }>>;
+            /** Output activation function (default none/linear) */
+            output_activation: OptionType<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;
             }>>;
             /** Dropout rate (default 0.0) */
             dropout: OptionType<FloatType>;
@@ -585,22 +1006,24 @@ export declare const Torch: {
             /** Loss function (default mse) */
             loss: OptionType<VariantType<{
                 /** Mean Squared Error (regression) */
-                mse: StructType<{}>;
+                mse: NullType;
                 /** Mean Absolute Error (regression) */
-                mae: StructType<{}>;
+                mae: NullType;
                 /** Cross Entropy (classification) */
-                cross_entropy: StructType<{}>;
+                cross_entropy: NullType;
+                /** KL Divergence (distribution matching, use with softmax output) */
+                kl_div: NullType;
             }>>;
             /** Optimizer (default adam) */
             optimizer: OptionType<VariantType<{
                 /** Adam optimizer */
-                adam: StructType<{}>;
+                adam: NullType;
                 /** Stochastic Gradient Descent */
-                sgd: StructType<{}>;
+                sgd: NullType;
                 /** AdamW with weight decay */
-                adamw: StructType<{}>;
+                adamw: NullType;
                 /** RMSprop optimizer */
-                rmsprop: StructType<{}>;
+                rmsprop: NullType;
             }>>;
             /** Early stopping patience, 0 = disabled */
             early_stopping: OptionType<IntegerType>;