@elaraai/east-py-datascience 0.0.2-beta.6 → 0.0.2-beta.61

package/dist/torch/torch.d.ts

@@ -10,136 +10,169 @@
  *
  * @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<{}>;
+    readonly relu: NullType;
     /** Hyperbolic tangent */
-    tanh: StructType<{}>;
+    readonly tanh: NullType;
     /** Sigmoid function */
-    sigmoid: StructType<{}>;
+    readonly sigmoid: NullType;
     /** Leaky ReLU */
-    leaky_relu: StructType<{}>;
+    readonly leaky_relu: NullType;
 }>;
 /**
  * Loss function type for training.
  */
 export declare const TorchLossType: VariantType<{
     /** Mean Squared Error (regression) */
-    mse: StructType<{}>;
+    readonly mse: NullType;
     /** Mean Absolute Error (regression) */
-    mae: StructType<{}>;
-    /** Cross Entropy (classification) */
-    cross_entropy: StructType<{}>;
+    readonly mae: NullType;
+    /** Cross Entropy (multi-class classification with integer targets) */
+    readonly cross_entropy: NullType;
+    /** KL Divergence (distribution matching, use with softmax output) */
+    readonly kl_div: NullType;
+    /** Binary Cross Entropy (multi-label binary, requires sigmoid output) */
+    readonly bce: NullType;
+    /** Binary Cross Entropy with Logits (more stable, applies sigmoid internally - do NOT use with sigmoid output_activation) */
+    readonly bce_with_logits: NullType;
 }>;
 /**
  * Optimizer type for training.
  */
 export declare const TorchOptimizerType: VariantType<{
     /** Adam optimizer */
-    adam: StructType<{}>;
+    readonly adam: NullType;
     /** Stochastic Gradient Descent */
-    sgd: StructType<{}>;
+    readonly sgd: NullType;
     /** AdamW with weight decay */
-    adamw: StructType<{}>;
+    readonly adamw: NullType;
     /** RMSprop optimizer */
-    rmsprop: StructType<{}>;
+    readonly 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 */
+    readonly none: NullType;
+    /** Softmax (outputs sum to 1, for probability distributions) */
+    readonly softmax: NullType;
+    /** Sigmoid (each output independently in [0,1]) */
+    readonly sigmoid: NullType;
 }>;
 /**
  * Configuration for MLP architecture.
  */
 export declare const TorchMLPConfigType: StructType<{
     /** Hidden layer sizes, e.g., [64, 32] */
-    hidden_layers: ArrayType<IntegerType>;
-    /** Activation function (default relu) */
-    activation: OptionType<VariantType<{
+    readonly hidden_layers: ArrayType<IntegerType>;
+    /** Activation function for hidden layers (default relu) */
+    readonly activation: OptionType<VariantType<{
         /** Rectified Linear Unit */
-        relu: StructType<{}>;
+        readonly relu: NullType;
         /** Hyperbolic tangent */
-        tanh: StructType<{}>;
+        readonly tanh: NullType;
         /** Sigmoid function */
-        sigmoid: StructType<{}>;
+        readonly sigmoid: NullType;
         /** Leaky ReLU */
-        leaky_relu: StructType<{}>;
+        readonly leaky_relu: NullType;
+    }>>;
+    /** Output activation function (default none/linear). Ignored if output_constraints is set. */
+    readonly output_activation: OptionType<VariantType<{
+        /** No activation (linear output) - default */
+        readonly none: NullType;
+        /** Softmax (outputs sum to 1, for probability distributions) */
+        readonly softmax: NullType;
+        /** Sigmoid (each output independently in [0,1]) */
+        readonly sigmoid: NullType;
     }>>;
     /** Dropout rate (default 0.0) */
-    dropout: OptionType<FloatType>;
+    readonly dropout: OptionType<FloatType>;
     /** Output dimension (default 1) */
-    output_dim: OptionType<IntegerType>;
+    readonly output_dim: OptionType<IntegerType>;
 }>;
 /**
  * Configuration for training.
  */
 export declare const TorchTrainConfigType: StructType<{
     /** Number of epochs (default 100) */
-    epochs: OptionType<IntegerType>;
+    readonly epochs: OptionType<IntegerType>;
     /** Batch size (default 32) */
-    batch_size: OptionType<IntegerType>;
+    readonly batch_size: OptionType<IntegerType>;
     /** Learning rate (default 0.001) */
-    learning_rate: OptionType<FloatType>;
+    readonly learning_rate: OptionType<FloatType>;
     /** Loss function (default mse) */
-    loss: OptionType<VariantType<{
+    readonly loss: OptionType<VariantType<{
         /** Mean Squared Error (regression) */
-        mse: StructType<{}>;
+        readonly mse: NullType;
         /** Mean Absolute Error (regression) */
-        mae: StructType<{}>;
-        /** Cross Entropy (classification) */
-        cross_entropy: StructType<{}>;
+        readonly mae: NullType;
+        /** Cross Entropy (multi-class classification with integer targets) */
+        readonly cross_entropy: NullType;
+        /** KL Divergence (distribution matching, use with softmax output) */
+        readonly kl_div: NullType;
+        /** Binary Cross Entropy (multi-label binary, requires sigmoid output) */
+        readonly bce: NullType;
+        /** Binary Cross Entropy with Logits (more stable, applies sigmoid internally - do NOT use with sigmoid output_activation) */
+        readonly bce_with_logits: NullType;
     }>>;
     /** Optimizer (default adam) */
-    optimizer: OptionType<VariantType<{
+    readonly optimizer: OptionType<VariantType<{
         /** Adam optimizer */
-        adam: StructType<{}>;
+        readonly adam: NullType;
         /** Stochastic Gradient Descent */
-        sgd: StructType<{}>;
+        readonly sgd: NullType;
         /** AdamW with weight decay */
-        adamw: StructType<{}>;
+        readonly adamw: NullType;
         /** RMSprop optimizer */
-        rmsprop: StructType<{}>;
+        readonly rmsprop: NullType;
     }>>;
     /** Early stopping patience, 0 = disabled */
-    early_stopping: OptionType<IntegerType>;
+    readonly early_stopping: OptionType<IntegerType>;
     /** Validation split fraction (default 0.2) */
-    validation_split: OptionType<FloatType>;
+    readonly validation_split: OptionType<FloatType>;
     /** Random seed for reproducibility */
-    random_state: OptionType<IntegerType>;
+    readonly random_state: OptionType<IntegerType>;
 }>;
 /**
  * Result type for training.
  */
 export declare const TorchTrainResultType: StructType<{
     /** Training loss per epoch */
-    train_losses: ArrayType<FloatType>;
+    readonly train_losses: ArrayType<FloatType>;
     /** Validation loss per epoch */
-    val_losses: ArrayType<FloatType>;
+    readonly val_losses: ArrayType<FloatType>;
     /** Best epoch (for early stopping) */
-    best_epoch: IntegerType;
+    readonly best_epoch: IntegerType;
 }>;
 /**
  * Combined result from training (model + metrics).
  */
 export declare const TorchTrainOutputType: StructType<{
     /** Trained model blob */
-    model: VariantType<{
-        torch_mlp: StructType<{
-            data: BlobType;
-            n_features: IntegerType;
-            hidden_layers: ArrayType<IntegerType>;
-            output_dim: IntegerType;
+    readonly model: VariantType<{
+        readonly torch_mlp: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+            readonly hidden_layers: ArrayType<IntegerType>;
+            readonly output_dim: IntegerType;
         }>;
     }>;
     /** Training result with losses */
-    result: StructType<{
+    readonly result: StructType<{
         /** Training loss per epoch */
-        train_losses: ArrayType<FloatType>;
+        readonly train_losses: ArrayType<FloatType>;
         /** Validation loss per epoch */
-        val_losses: ArrayType<FloatType>;
+        readonly val_losses: ArrayType<FloatType>;
         /** Best epoch (for early stopping) */
-        best_epoch: IntegerType;
+        readonly best_epoch: IntegerType;
     }>;
 }>;
 /**
@@ -147,15 +180,15 @@ export declare const TorchTrainOutputType: StructType<{
  */
 export declare const TorchModelBlobType: VariantType<{
     /** PyTorch MLP model */
-    torch_mlp: StructType<{
+    readonly torch_mlp: StructType<{
         /** Cloudpickle serialized model */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
         /** Hidden layer sizes */
-        hidden_layers: ArrayType<IntegerType>;
+        readonly hidden_layers: ArrayType<IntegerType>;
         /** Output dimension */
-        output_dim: IntegerType;
+        readonly output_dim: IntegerType;
     }>;
 }>;
 /**
@@ -169,73 +202,88 @@ 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: OptionType<VariantType<{
+    readonly hidden_layers: ArrayType<IntegerType>;
+    /** Activation function for hidden layers (default relu) */
+    readonly activation: OptionType<VariantType<{
         /** Rectified Linear Unit */
-        relu: StructType<{}>;
+        readonly relu: NullType;
         /** Hyperbolic tangent */
-        tanh: StructType<{}>;
+        readonly tanh: NullType;
         /** Sigmoid function */
-        sigmoid: StructType<{}>;
+        readonly sigmoid: NullType;
         /** Leaky ReLU */
-        leaky_relu: StructType<{}>;
+        readonly leaky_relu: NullType;
+    }>>;
+    /** Output activation function (default none/linear). Ignored if output_constraints is set. */
+    readonly output_activation: OptionType<VariantType<{
+        /** No activation (linear output) - default */
+        readonly none: NullType;
+        /** Softmax (outputs sum to 1, for probability distributions) */
+        readonly softmax: NullType;
+        /** Sigmoid (each output independently in [0,1]) */
+        readonly sigmoid: NullType;
     }>>;
     /** Dropout rate (default 0.0) */
-    dropout: OptionType<FloatType>;
+    readonly dropout: OptionType<FloatType>;
     /** Output dimension (default 1) */
-    output_dim: OptionType<IntegerType>;
+    readonly output_dim: OptionType<IntegerType>;
 }>, StructType<{
     /** Number of epochs (default 100) */
-    epochs: OptionType<IntegerType>;
+    readonly epochs: OptionType<IntegerType>;
     /** Batch size (default 32) */
-    batch_size: OptionType<IntegerType>;
+    readonly batch_size: OptionType<IntegerType>;
     /** Learning rate (default 0.001) */
-    learning_rate: OptionType<FloatType>;
+    readonly learning_rate: OptionType<FloatType>;
     /** Loss function (default mse) */
-    loss: OptionType<VariantType<{
+    readonly loss: OptionType<VariantType<{
         /** Mean Squared Error (regression) */
-        mse: StructType<{}>;
+        readonly mse: NullType;
         /** Mean Absolute Error (regression) */
-        mae: StructType<{}>;
-        /** Cross Entropy (classification) */
-        cross_entropy: StructType<{}>;
+        readonly mae: NullType;
+        /** Cross Entropy (multi-class classification with integer targets) */
+        readonly cross_entropy: NullType;
+        /** KL Divergence (distribution matching, use with softmax output) */
+        readonly kl_div: NullType;
+        /** Binary Cross Entropy (multi-label binary, requires sigmoid output) */
+        readonly bce: NullType;
+        /** Binary Cross Entropy with Logits (more stable, applies sigmoid internally - do NOT use with sigmoid output_activation) */
+        readonly bce_with_logits: NullType;
     }>>;
     /** Optimizer (default adam) */
-    optimizer: OptionType<VariantType<{
+    readonly optimizer: OptionType<VariantType<{
         /** Adam optimizer */
-        adam: StructType<{}>;
+        readonly adam: NullType;
         /** Stochastic Gradient Descent */
-        sgd: StructType<{}>;
+        readonly sgd: NullType;
         /** AdamW with weight decay */
-        adamw: StructType<{}>;
+        readonly adamw: NullType;
         /** RMSprop optimizer */
-        rmsprop: StructType<{}>;
+        readonly rmsprop: NullType;
     }>>;
     /** Early stopping patience, 0 = disabled */
-    early_stopping: OptionType<IntegerType>;
+    readonly early_stopping: OptionType<IntegerType>;
     /** Validation split fraction (default 0.2) */
-    validation_split: OptionType<FloatType>;
+    readonly validation_split: OptionType<FloatType>;
     /** Random seed for reproducibility */
-    random_state: OptionType<IntegerType>;
+    readonly 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;
+    readonly model: VariantType<{
+        readonly torch_mlp: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+            readonly hidden_layers: ArrayType<IntegerType>;
+            readonly output_dim: IntegerType;
         }>;
     }>;
     /** Training result with losses */
-    result: StructType<{
+    readonly result: StructType<{
         /** Training loss per epoch */
-        train_losses: ArrayType<FloatType>;
+        readonly train_losses: ArrayType<FloatType>;
         /** Validation loss per epoch */
-        val_losses: ArrayType<FloatType>;
+        readonly val_losses: ArrayType<FloatType>;
         /** Best epoch (for early stopping) */
-        best_epoch: IntegerType;
+        readonly best_epoch: IntegerType;
     }>;
 }>>;
 /**
@@ -247,15 +295,15 @@ export declare const torch_mlp_train: import("@elaraai/east").PlatformDefinition
  */
 export declare const torch_mlp_predict: import("@elaraai/east").PlatformDefinition<[VariantType<{
     /** PyTorch MLP model */
-    torch_mlp: StructType<{
+    readonly torch_mlp: StructType<{
         /** Cloudpickle serialized model */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
         /** Hidden layer sizes */
-        hidden_layers: ArrayType<IntegerType>;
+        readonly hidden_layers: ArrayType<IntegerType>;
         /** Output dimension */
-        output_dim: IntegerType;
+        readonly output_dim: IntegerType;
     }>;
 }>, ArrayType<ArrayType<FloatType>>], ArrayType<FloatType>>;
 /**
@@ -273,73 +321,88 @@ export declare const torch_mlp_predict: import("@elaraai/east").PlatformDefiniti
  */
 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 (default relu) */
-    activation: OptionType<VariantType<{
+    readonly hidden_layers: ArrayType<IntegerType>;
+    /** Activation function for hidden layers (default relu) */
+    readonly activation: OptionType<VariantType<{
         /** Rectified Linear Unit */
-        relu: StructType<{}>;
+        readonly relu: NullType;
         /** Hyperbolic tangent */
-        tanh: StructType<{}>;
+        readonly tanh: NullType;
         /** Sigmoid function */
-        sigmoid: StructType<{}>;
+        readonly sigmoid: NullType;
         /** Leaky ReLU */
-        leaky_relu: StructType<{}>;
+        readonly leaky_relu: NullType;
+    }>>;
+    /** Output activation function (default none/linear). Ignored if output_constraints is set. */
+    readonly output_activation: OptionType<VariantType<{
+        /** No activation (linear output) - default */
+        readonly none: NullType;
+        /** Softmax (outputs sum to 1, for probability distributions) */
+        readonly softmax: NullType;
+        /** Sigmoid (each output independently in [0,1]) */
+        readonly sigmoid: NullType;
     }>>;
     /** Dropout rate (default 0.0) */
-    dropout: OptionType<FloatType>;
+    readonly dropout: OptionType<FloatType>;
     /** Output dimension (default 1) */
-    output_dim: OptionType<IntegerType>;
+    readonly output_dim: OptionType<IntegerType>;
 }>, StructType<{
     /** Number of epochs (default 100) */
-    epochs: OptionType<IntegerType>;
+    readonly epochs: OptionType<IntegerType>;
     /** Batch size (default 32) */
-    batch_size: OptionType<IntegerType>;
+    readonly batch_size: OptionType<IntegerType>;
     /** Learning rate (default 0.001) */
-    learning_rate: OptionType<FloatType>;
+    readonly learning_rate: OptionType<FloatType>;
     /** Loss function (default mse) */
-    loss: OptionType<VariantType<{
+    readonly loss: OptionType<VariantType<{
         /** Mean Squared Error (regression) */
-        mse: StructType<{}>;
+        readonly mse: NullType;
         /** Mean Absolute Error (regression) */
-        mae: StructType<{}>;
-        /** Cross Entropy (classification) */
-        cross_entropy: StructType<{}>;
+        readonly mae: NullType;
+        /** Cross Entropy (multi-class classification with integer targets) */
+        readonly cross_entropy: NullType;
+        /** KL Divergence (distribution matching, use with softmax output) */
+        readonly kl_div: NullType;
+        /** Binary Cross Entropy (multi-label binary, requires sigmoid output) */
+        readonly bce: NullType;
+        /** Binary Cross Entropy with Logits (more stable, applies sigmoid internally - do NOT use with sigmoid output_activation) */
+        readonly bce_with_logits: NullType;
     }>>;
     /** Optimizer (default adam) */
-    optimizer: OptionType<VariantType<{
+    readonly optimizer: OptionType<VariantType<{
         /** Adam optimizer */
-        adam: StructType<{}>;
+        readonly adam: NullType;
         /** Stochastic Gradient Descent */
-        sgd: StructType<{}>;
+        readonly sgd: NullType;
         /** AdamW with weight decay */
-        adamw: StructType<{}>;
+        readonly adamw: NullType;
         /** RMSprop optimizer */
-        rmsprop: StructType<{}>;
+        readonly rmsprop: NullType;
     }>>;
     /** Early stopping patience, 0 = disabled */
-    early_stopping: OptionType<IntegerType>;
+    readonly early_stopping: OptionType<IntegerType>;
     /** Validation split fraction (default 0.2) */
-    validation_split: OptionType<FloatType>;
+    readonly validation_split: OptionType<FloatType>;
     /** Random seed for reproducibility */
-    random_state: OptionType<IntegerType>;
+    readonly 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;
+    readonly model: VariantType<{
+        readonly torch_mlp: StructType<{
+            readonly data: BlobType;
+            readonly n_features: IntegerType;
+            readonly hidden_layers: ArrayType<IntegerType>;
+            readonly output_dim: IntegerType;
         }>;
     }>;
     /** Training result with losses */
-    result: StructType<{
+    readonly result: StructType<{
         /** Training loss per epoch */
-        train_losses: ArrayType<FloatType>;
+        readonly train_losses: ArrayType<FloatType>;
         /** Validation loss per epoch */
-        val_losses: ArrayType<FloatType>;
+        readonly val_losses: ArrayType<FloatType>;
         /** Best epoch (for early stopping) */
-        best_epoch: IntegerType;
+        readonly best_epoch: IntegerType;
     }>;
 }>>;
 /**
@@ -353,15 +416,15 @@ export declare const torch_mlp_train_multi: import("@elaraai/east").PlatformDefi
  */
 export declare const torch_mlp_predict_multi: import("@elaraai/east").PlatformDefinition<[VariantType<{
     /** PyTorch MLP model */
-    torch_mlp: StructType<{
+    readonly torch_mlp: StructType<{
         /** Cloudpickle serialized model */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
         /** Hidden layer sizes */
-        hidden_layers: ArrayType<IntegerType>;
+        readonly hidden_layers: ArrayType<IntegerType>;
         /** Output dimension */
-        output_dim: IntegerType;
+        readonly output_dim: IntegerType;
     }>;
 }>, ArrayType<ArrayType<FloatType>>], ArrayType<ArrayType<FloatType>>>;
 /**
@@ -399,15 +462,15 @@ export declare const torch_mlp_predict_multi: import("@elaraai/east").PlatformDe
  */
 export declare const torch_mlp_encode: import("@elaraai/east").PlatformDefinition<[VariantType<{
     /** PyTorch MLP model */
-    torch_mlp: StructType<{
+    readonly torch_mlp: StructType<{
         /** Cloudpickle serialized model */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
         /** Hidden layer sizes */
-        hidden_layers: ArrayType<IntegerType>;
+        readonly hidden_layers: ArrayType<IntegerType>;
         /** Output dimension */
-        output_dim: IntegerType;
+        readonly output_dim: IntegerType;
     }>;
 }>, ArrayType<ArrayType<FloatType>>, IntegerType], ArrayType<ArrayType<FloatType>>>;
 /**
@@ -443,15 +506,15 @@ export declare const torch_mlp_encode: import("@elaraai/east").PlatformDefinitio
  */
 export declare const torch_mlp_decode: import("@elaraai/east").PlatformDefinition<[VariantType<{
     /** PyTorch MLP model */
-    torch_mlp: StructType<{
+    readonly torch_mlp: StructType<{
         /** Cloudpickle serialized model */
-        data: BlobType;
+        readonly data: BlobType;
         /** Number of input features */
-        n_features: IntegerType;
+        readonly n_features: IntegerType;
         /** Hidden layer sizes */
-        hidden_layers: ArrayType<IntegerType>;
+        readonly hidden_layers: ArrayType<IntegerType>;
         /** Output dimension */
-        output_dim: IntegerType;
+        readonly output_dim: IntegerType;
     }>;
 }>, ArrayType<ArrayType<FloatType>>, IntegerType], ArrayType<ArrayType<FloatType>>>;
 /**
@@ -462,134 +525,164 @@ 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<{}>;
+        readonly relu: NullType;
         /** Hyperbolic tangent */
-        tanh: StructType<{}>;
+        readonly tanh: NullType;
         /** Sigmoid function */
-        sigmoid: StructType<{}>;
+        readonly sigmoid: NullType;
         /** Leaky ReLU */
-        leaky_relu: StructType<{}>;
+        readonly leaky_relu: NullType;
+    }>;
+    /** Output activation function type */
+    readonly TorchOutputActivationType: VariantType<{
+        /** No activation (linear output) - default */
+        readonly none: NullType;
+        /** Softmax (outputs sum to 1, for probability distributions) */
+        readonly softmax: NullType;
+        /** Sigmoid (each output independently in [0,1]) */
+        readonly sigmoid: NullType;
     }>;
     /** Loss function type */
     readonly TorchLossType: VariantType<{
         /** Mean Squared Error (regression) */
-        mse: StructType<{}>;
+        readonly mse: NullType;
         /** Mean Absolute Error (regression) */
-        mae: StructType<{}>;
-        /** Cross Entropy (classification) */
-        cross_entropy: StructType<{}>;
+        readonly mae: NullType;
+        /** Cross Entropy (multi-class classification with integer targets) */
+        readonly cross_entropy: NullType;
+        /** KL Divergence (distribution matching, use with softmax output) */
+        readonly kl_div: NullType;
+        /** Binary Cross Entropy (multi-label binary, requires sigmoid output) */
+        readonly bce: NullType;
+        /** Binary Cross Entropy with Logits (more stable, applies sigmoid internally - do NOT use with sigmoid output_activation) */
+        readonly bce_with_logits: NullType;
     }>;
     /** Optimizer type */
     readonly TorchOptimizerType: VariantType<{
         /** Adam optimizer */
-        adam: StructType<{}>;
+        readonly adam: NullType;
         /** Stochastic Gradient Descent */
-        sgd: StructType<{}>;
+        readonly sgd: NullType;
         /** AdamW with weight decay */
-        adamw: StructType<{}>;
+        readonly adamw: NullType;
         /** RMSprop optimizer */
-        rmsprop: StructType<{}>;
+        readonly rmsprop: NullType;
     }>;
     /** MLP configuration type */
     readonly TorchMLPConfigType: StructType<{
         /** Hidden layer sizes, e.g., [64, 32] */
-        hidden_layers: ArrayType<IntegerType>;
-        /** Activation function (default relu) */
-        activation: OptionType<VariantType<{
+        readonly hidden_layers: ArrayType<IntegerType>;
+        /** Activation function for hidden layers (default relu) */
+        readonly activation: OptionType<VariantType<{
             /** Rectified Linear Unit */
-            relu: StructType<{}>;
+            readonly relu: NullType;
             /** Hyperbolic tangent */
-            tanh: StructType<{}>;
+            readonly tanh: NullType;
             /** Sigmoid function */
-            sigmoid: StructType<{}>;
+            readonly sigmoid: NullType;
             /** Leaky ReLU */
-            leaky_relu: StructType<{}>;
+            readonly leaky_relu: NullType;
+        }>>;
+        /** Output activation function (default none/linear). Ignored if output_constraints is set. */
+        readonly output_activation: OptionType<VariantType<{
+            /** No activation (linear output) - default */
+            readonly none: NullType;
+            /** Softmax (outputs sum to 1, for probability distributions) */
+            readonly softmax: NullType;
+            /** Sigmoid (each output independently in [0,1]) */
+            readonly sigmoid: NullType;
         }>>;
         /** Dropout rate (default 0.0) */
-        dropout: OptionType<FloatType>;
+        readonly dropout: OptionType<FloatType>;
         /** Output dimension (default 1) */
-        output_dim: OptionType<IntegerType>;
+        readonly output_dim: OptionType<IntegerType>;
     }>;
     /** Training configuration type */
     readonly TorchTrainConfigType: StructType<{
         /** Number of epochs (default 100) */
-        epochs: OptionType<IntegerType>;
+        readonly epochs: OptionType<IntegerType>;
         /** Batch size (default 32) */
-        batch_size: OptionType<IntegerType>;
+        readonly batch_size: OptionType<IntegerType>;
         /** Learning rate (default 0.001) */
-        learning_rate: OptionType<FloatType>;
+        readonly learning_rate: OptionType<FloatType>;
         /** Loss function (default mse) */
-        loss: OptionType<VariantType<{
+        readonly loss: OptionType<VariantType<{
             /** Mean Squared Error (regression) */
-            mse: StructType<{}>;
+            readonly mse: NullType;
             /** Mean Absolute Error (regression) */
-            mae: StructType<{}>;
-            /** Cross Entropy (classification) */
-            cross_entropy: StructType<{}>;
+            readonly mae: NullType;
+            /** Cross Entropy (multi-class classification with integer targets) */
+            readonly cross_entropy: NullType;
+            /** KL Divergence (distribution matching, use with softmax output) */
+            readonly kl_div: NullType;
+            /** Binary Cross Entropy (multi-label binary, requires sigmoid output) */
+            readonly bce: NullType;
+            /** Binary Cross Entropy with Logits (more stable, applies sigmoid internally - do NOT use with sigmoid output_activation) */
+            readonly bce_with_logits: NullType;
         }>>;
         /** Optimizer (default adam) */
-        optimizer: OptionType<VariantType<{
+        readonly optimizer: OptionType<VariantType<{
             /** Adam optimizer */
-            adam: StructType<{}>;
+            readonly adam: NullType;
             /** Stochastic Gradient Descent */
-            sgd: StructType<{}>;
+            readonly sgd: NullType;
             /** AdamW with weight decay */
-            adamw: StructType<{}>;
+            readonly adamw: NullType;
             /** RMSprop optimizer */
-            rmsprop: StructType<{}>;
+            readonly rmsprop: NullType;
         }>>;
         /** Early stopping patience, 0 = disabled */
-        early_stopping: OptionType<IntegerType>;
+        readonly early_stopping: OptionType<IntegerType>;
         /** Validation split fraction (default 0.2) */
-        validation_split: OptionType<FloatType>;
+        readonly validation_split: OptionType<FloatType>;
         /** Random seed for reproducibility */
-        random_state: OptionType<IntegerType>;
+        readonly random_state: OptionType<IntegerType>;
     }>;
     /** Training result type */
     readonly TorchTrainResultType: StructType<{
         /** Training loss per epoch */
-        train_losses: ArrayType<FloatType>;
+        readonly train_losses: ArrayType<FloatType>;
         /** Validation loss per epoch */
-        val_losses: ArrayType<FloatType>;
+        readonly val_losses: ArrayType<FloatType>;
         /** Best epoch (for early stopping) */
-        best_epoch: IntegerType;
+        readonly best_epoch: IntegerType;
     }>;
     /** Training output type (model + result) */
     readonly TorchTrainOutputType: StructType<{
         /** Trained model blob */
-        model: VariantType<{
-            torch_mlp: StructType<{
-                data: BlobType;
-                n_features: IntegerType;
-                hidden_layers: ArrayType<IntegerType>;
-                output_dim: IntegerType;
+        readonly model: VariantType<{
+            readonly torch_mlp: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+                readonly hidden_layers: ArrayType<IntegerType>;
+                readonly output_dim: IntegerType;
             }>;
         }>;
         /** Training result with losses */
-        result: StructType<{
+        readonly result: StructType<{
             /** Training loss per epoch */
-            train_losses: ArrayType<FloatType>;
+            readonly train_losses: ArrayType<FloatType>;
             /** Validation loss per epoch */
-            val_losses: ArrayType<FloatType>;
+            readonly val_losses: ArrayType<FloatType>;
             /** Best epoch (for early stopping) */
-            best_epoch: IntegerType;
+            readonly best_epoch: IntegerType;
         }>;
     }>;
     /** Model blob type for PyTorch models */
     readonly ModelBlobType: VariantType<{
         /** PyTorch MLP model */
-        torch_mlp: StructType<{
+        readonly torch_mlp: StructType<{
             /** Cloudpickle serialized model */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
             /** Hidden layer sizes */
-            hidden_layers: ArrayType<IntegerType>;
+            readonly hidden_layers: ArrayType<IntegerType>;
             /** Output dimension */
-            output_dim: IntegerType;
+            readonly output_dim: IntegerType;
         }>;
     }>;
 };
@@ -630,201 +723,231 @@ export declare const Torch: {
     /** 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: OptionType<VariantType<{
+        readonly hidden_layers: ArrayType<IntegerType>;
+        /** Activation function for hidden layers (default relu) */
+        readonly activation: OptionType<VariantType<{
             /** Rectified Linear Unit */
-            relu: StructType<{}>;
+            readonly relu: NullType;
             /** Hyperbolic tangent */
-            tanh: StructType<{}>;
+            readonly tanh: NullType;
             /** Sigmoid function */
-            sigmoid: StructType<{}>;
+            readonly sigmoid: NullType;
             /** Leaky ReLU */
-            leaky_relu: StructType<{}>;
+            readonly leaky_relu: NullType;
+        }>>;
+        /** Output activation function (default none/linear). Ignored if output_constraints is set. */
+        readonly output_activation: OptionType<VariantType<{
+            /** No activation (linear output) - default */
+            readonly none: NullType;
+            /** Softmax (outputs sum to 1, for probability distributions) */
+            readonly softmax: NullType;
+            /** Sigmoid (each output independently in [0,1]) */
+            readonly sigmoid: NullType;
         }>>;
         /** Dropout rate (default 0.0) */
-        dropout: OptionType<FloatType>;
+        readonly dropout: OptionType<FloatType>;
         /** Output dimension (default 1) */
-        output_dim: OptionType<IntegerType>;
+        readonly output_dim: OptionType<IntegerType>;
     }>, StructType<{
         /** Number of epochs (default 100) */
-        epochs: OptionType<IntegerType>;
+        readonly epochs: OptionType<IntegerType>;
         /** Batch size (default 32) */
-        batch_size: OptionType<IntegerType>;
+        readonly batch_size: OptionType<IntegerType>;
         /** Learning rate (default 0.001) */
-        learning_rate: OptionType<FloatType>;
+        readonly learning_rate: OptionType<FloatType>;
         /** Loss function (default mse) */
-        loss: OptionType<VariantType<{
+        readonly loss: OptionType<VariantType<{
             /** Mean Squared Error (regression) */
-            mse: StructType<{}>;
+            readonly mse: NullType;
             /** Mean Absolute Error (regression) */
-            mae: StructType<{}>;
-            /** Cross Entropy (classification) */
-            cross_entropy: StructType<{}>;
+            readonly mae: NullType;
+            /** Cross Entropy (multi-class classification with integer targets) */
+            readonly cross_entropy: NullType;
+            /** KL Divergence (distribution matching, use with softmax output) */
+            readonly kl_div: NullType;
+            /** Binary Cross Entropy (multi-label binary, requires sigmoid output) */
+            readonly bce: NullType;
+            /** Binary Cross Entropy with Logits (more stable, applies sigmoid internally - do NOT use with sigmoid output_activation) */
+            readonly bce_with_logits: NullType;
         }>>;
         /** Optimizer (default adam) */
-        optimizer: OptionType<VariantType<{
+        readonly optimizer: OptionType<VariantType<{
             /** Adam optimizer */
-            adam: StructType<{}>;
+            readonly adam: NullType;
             /** Stochastic Gradient Descent */
-            sgd: StructType<{}>;
+            readonly sgd: NullType;
             /** AdamW with weight decay */
-            adamw: StructType<{}>;
+            readonly adamw: NullType;
             /** RMSprop optimizer */
-            rmsprop: StructType<{}>;
+            readonly rmsprop: NullType;
         }>>;
         /** Early stopping patience, 0 = disabled */
-        early_stopping: OptionType<IntegerType>;
+        readonly early_stopping: OptionType<IntegerType>;
         /** Validation split fraction (default 0.2) */
-        validation_split: OptionType<FloatType>;
+        readonly validation_split: OptionType<FloatType>;
         /** Random seed for reproducibility */
-        random_state: OptionType<IntegerType>;
+        readonly 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;
+        readonly model: VariantType<{
+            readonly torch_mlp: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+                readonly hidden_layers: ArrayType<IntegerType>;
+                readonly output_dim: IntegerType;
             }>;
         }>;
         /** Training result with losses */
-        result: StructType<{
+        readonly result: StructType<{
             /** Training loss per epoch */
-            train_losses: ArrayType<FloatType>;
+            readonly train_losses: ArrayType<FloatType>;
             /** Validation loss per epoch */
-            val_losses: ArrayType<FloatType>;
+            readonly val_losses: ArrayType<FloatType>;
             /** Best epoch (for early stopping) */
-            best_epoch: IntegerType;
+            readonly best_epoch: IntegerType;
         }>;
     }>>;
     /** Make predictions with MLP (single output) */
     readonly mlpPredict: import("@elaraai/east").PlatformDefinition<[VariantType<{
         /** PyTorch MLP model */
-        torch_mlp: StructType<{
+        readonly torch_mlp: StructType<{
             /** Cloudpickle serialized model */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
             /** Hidden layer sizes */
-            hidden_layers: ArrayType<IntegerType>;
+            readonly hidden_layers: ArrayType<IntegerType>;
             /** Output dimension */
-            output_dim: IntegerType;
+            readonly 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 (default relu) */
-        activation: OptionType<VariantType<{
+        readonly hidden_layers: ArrayType<IntegerType>;
+        /** Activation function for hidden layers (default relu) */
+        readonly activation: OptionType<VariantType<{
             /** Rectified Linear Unit */
-            relu: StructType<{}>;
+            readonly relu: NullType;
             /** Hyperbolic tangent */
-            tanh: StructType<{}>;
+            readonly tanh: NullType;
             /** Sigmoid function */
-            sigmoid: StructType<{}>;
+            readonly sigmoid: NullType;
             /** Leaky ReLU */
-            leaky_relu: StructType<{}>;
+            readonly leaky_relu: NullType;
+        }>>;
+        /** Output activation function (default none/linear). Ignored if output_constraints is set. */
+        readonly output_activation: OptionType<VariantType<{
+            /** No activation (linear output) - default */
+            readonly none: NullType;
+            /** Softmax (outputs sum to 1, for probability distributions) */
+            readonly softmax: NullType;
+            /** Sigmoid (each output independently in [0,1]) */
+            readonly sigmoid: NullType;
         }>>;
         /** Dropout rate (default 0.0) */
-        dropout: OptionType<FloatType>;
+        readonly dropout: OptionType<FloatType>;
         /** Output dimension (default 1) */
-        output_dim: OptionType<IntegerType>;
+        readonly output_dim: OptionType<IntegerType>;
     }>, StructType<{
         /** Number of epochs (default 100) */
-        epochs: OptionType<IntegerType>;
+        readonly epochs: OptionType<IntegerType>;
         /** Batch size (default 32) */
-        batch_size: OptionType<IntegerType>;
+        readonly batch_size: OptionType<IntegerType>;
         /** Learning rate (default 0.001) */
-        learning_rate: OptionType<FloatType>;
+        readonly learning_rate: OptionType<FloatType>;
         /** Loss function (default mse) */
-        loss: OptionType<VariantType<{
+        readonly loss: OptionType<VariantType<{
             /** Mean Squared Error (regression) */
-            mse: StructType<{}>;
+            readonly mse: NullType;
             /** Mean Absolute Error (regression) */
-            mae: StructType<{}>;
-            /** Cross Entropy (classification) */
-            cross_entropy: StructType<{}>;
+            readonly mae: NullType;
+            /** Cross Entropy (multi-class classification with integer targets) */
+            readonly cross_entropy: NullType;
+            /** KL Divergence (distribution matching, use with softmax output) */
+            readonly kl_div: NullType;
+            /** Binary Cross Entropy (multi-label binary, requires sigmoid output) */
+            readonly bce: NullType;
+            /** Binary Cross Entropy with Logits (more stable, applies sigmoid internally - do NOT use with sigmoid output_activation) */
+            readonly bce_with_logits: NullType;
         }>>;
         /** Optimizer (default adam) */
-        optimizer: OptionType<VariantType<{
+        readonly optimizer: OptionType<VariantType<{
             /** Adam optimizer */
-            adam: StructType<{}>;
+            readonly adam: NullType;
             /** Stochastic Gradient Descent */
-            sgd: StructType<{}>;
+            readonly sgd: NullType;
             /** AdamW with weight decay */
-            adamw: StructType<{}>;
+            readonly adamw: NullType;
             /** RMSprop optimizer */
-            rmsprop: StructType<{}>;
+            readonly rmsprop: NullType;
         }>>;
         /** Early stopping patience, 0 = disabled */
-        early_stopping: OptionType<IntegerType>;
+        readonly early_stopping: OptionType<IntegerType>;
         /** Validation split fraction (default 0.2) */
-        validation_split: OptionType<FloatType>;
+        readonly validation_split: OptionType<FloatType>;
         /** Random seed for reproducibility */
-        random_state: OptionType<IntegerType>;
+        readonly 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;
+        readonly model: VariantType<{
+            readonly torch_mlp: StructType<{
+                readonly data: BlobType;
+                readonly n_features: IntegerType;
+                readonly hidden_layers: ArrayType<IntegerType>;
+                readonly output_dim: IntegerType;
             }>;
         }>;
         /** Training result with losses */
-        result: StructType<{
+        readonly result: StructType<{
             /** Training loss per epoch */
-            train_losses: ArrayType<FloatType>;
+            readonly train_losses: ArrayType<FloatType>;
             /** Validation loss per epoch */
-            val_losses: ArrayType<FloatType>;
+            readonly val_losses: ArrayType<FloatType>;
             /** Best epoch (for early stopping) */
-            best_epoch: IntegerType;
+            readonly best_epoch: IntegerType;
         }>;
     }>>;
-    /** Make predictions with MLP (multi-output) */
+    /** Make predictions with MLP (multi-output, with optional sample_masks) */
     readonly mlpPredictMulti: import("@elaraai/east").PlatformDefinition<[VariantType<{
         /** PyTorch MLP model */
-        torch_mlp: StructType<{
+        readonly torch_mlp: StructType<{
             /** Cloudpickle serialized model */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
             /** Hidden layer sizes */
-            hidden_layers: ArrayType<IntegerType>;
+            readonly hidden_layers: ArrayType<IntegerType>;
             /** Output dimension */
-            output_dim: IntegerType;
+            readonly 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<{
+        readonly torch_mlp: StructType<{
             /** Cloudpickle serialized model */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
             /** Hidden layer sizes */
-            hidden_layers: ArrayType<IntegerType>;
+            readonly hidden_layers: ArrayType<IntegerType>;
             /** Output dimension */
-            output_dim: IntegerType;
+            readonly 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<{
+        readonly torch_mlp: StructType<{
             /** Cloudpickle serialized model */
-            data: BlobType;
+            readonly data: BlobType;
             /** Number of input features */
-            n_features: IntegerType;
+            readonly n_features: IntegerType;
             /** Hidden layer sizes */
-            hidden_layers: ArrayType<IntegerType>;
+            readonly hidden_layers: ArrayType<IntegerType>;
             /** Output dimension */
-            output_dim: IntegerType;
+            readonly output_dim: IntegerType;
         }>;
     }>, ArrayType<ArrayType<FloatType>>, IntegerType], ArrayType<ArrayType<FloatType>>>;
     /** Type definitions */
@@ -833,134 +956,164 @@ export declare const Torch: {
         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<{}>;
+            readonly relu: NullType;
             /** Hyperbolic tangent */
-            tanh: StructType<{}>;
+            readonly tanh: NullType;
             /** Sigmoid function */
-            sigmoid: StructType<{}>;
+            readonly sigmoid: NullType;
             /** Leaky ReLU */
-            leaky_relu: StructType<{}>;
+            readonly leaky_relu: NullType;
+        }>;
+        /** Output activation function type */
+        readonly TorchOutputActivationType: VariantType<{
+            /** No activation (linear output) - default */
+            readonly none: NullType;
+            /** Softmax (outputs sum to 1, for probability distributions) */
+            readonly softmax: NullType;
+            /** Sigmoid (each output independently in [0,1]) */
+            readonly sigmoid: NullType;
         }>;
         /** Loss function type */
         readonly TorchLossType: VariantType<{
             /** Mean Squared Error (regression) */
-            mse: StructType<{}>;
+            readonly mse: NullType;
             /** Mean Absolute Error (regression) */
-            mae: StructType<{}>;
-            /** Cross Entropy (classification) */
-            cross_entropy: StructType<{}>;
+            readonly mae: NullType;
+            /** Cross Entropy (multi-class classification with integer targets) */
+            readonly cross_entropy: NullType;
+            /** KL Divergence (distribution matching, use with softmax output) */
+            readonly kl_div: NullType;
+            /** Binary Cross Entropy (multi-label binary, requires sigmoid output) */
+            readonly bce: NullType;
+            /** Binary Cross Entropy with Logits (more stable, applies sigmoid internally - do NOT use with sigmoid output_activation) */
+            readonly bce_with_logits: NullType;
         }>;
         /** Optimizer type */
         readonly TorchOptimizerType: VariantType<{
             /** Adam optimizer */
-            adam: StructType<{}>;
+            readonly adam: NullType;
             /** Stochastic Gradient Descent */
-            sgd: StructType<{}>;
+            readonly sgd: NullType;
             /** AdamW with weight decay */
-            adamw: StructType<{}>;
+            readonly adamw: NullType;
             /** RMSprop optimizer */
-            rmsprop: StructType<{}>;
+            readonly rmsprop: NullType;
         }>;
         /** MLP configuration type */
         readonly TorchMLPConfigType: StructType<{
             /** Hidden layer sizes, e.g., [64, 32] */
-            hidden_layers: ArrayType<IntegerType>;
-            /** Activation function (default relu) */
-            activation: OptionType<VariantType<{
+            readonly hidden_layers: ArrayType<IntegerType>;
+            /** Activation function for hidden layers (default relu) */
+            readonly activation: OptionType<VariantType<{
                 /** Rectified Linear Unit */
-                relu: StructType<{}>;
+                readonly relu: NullType;
                 /** Hyperbolic tangent */
-                tanh: StructType<{}>;
+                readonly tanh: NullType;
                 /** Sigmoid function */
-                sigmoid: StructType<{}>;
+                readonly sigmoid: NullType;
                 /** Leaky ReLU */
-                leaky_relu: StructType<{}>;
+                readonly leaky_relu: NullType;
+            }>>;
+            /** Output activation function (default none/linear). Ignored if output_constraints is set. */
+            readonly output_activation: OptionType<VariantType<{
+                /** No activation (linear output) - default */
+                readonly none: NullType;
+                /** Softmax (outputs sum to 1, for probability distributions) */
+                readonly softmax: NullType;
+                /** Sigmoid (each output independently in [0,1]) */
+                readonly sigmoid: NullType;
             }>>;
             /** Dropout rate (default 0.0) */
-            dropout: OptionType<FloatType>;
+            readonly dropout: OptionType<FloatType>;
             /** Output dimension (default 1) */
-            output_dim: OptionType<IntegerType>;
+            readonly output_dim: OptionType<IntegerType>;
         }>;
         /** Training configuration type */
         readonly TorchTrainConfigType: StructType<{
             /** Number of epochs (default 100) */
-            epochs: OptionType<IntegerType>;
+            readonly epochs: OptionType<IntegerType>;
             /** Batch size (default 32) */
-            batch_size: OptionType<IntegerType>;
+            readonly batch_size: OptionType<IntegerType>;
             /** Learning rate (default 0.001) */
-            learning_rate: OptionType<FloatType>;
+            readonly learning_rate: OptionType<FloatType>;
             /** Loss function (default mse) */
-            loss: OptionType<VariantType<{
+            readonly loss: OptionType<VariantType<{
                 /** Mean Squared Error (regression) */
-                mse: StructType<{}>;
+                readonly mse: NullType;
                 /** Mean Absolute Error (regression) */
-                mae: StructType<{}>;
-                /** Cross Entropy (classification) */
-                cross_entropy: StructType<{}>;
+                readonly mae: NullType;
+                /** Cross Entropy (multi-class classification with integer targets) */
+                readonly cross_entropy: NullType;
+                /** KL Divergence (distribution matching, use with softmax output) */
+                readonly kl_div: NullType;
+                /** Binary Cross Entropy (multi-label binary, requires sigmoid output) */
+                readonly bce: NullType;
+                /** Binary Cross Entropy with Logits (more stable, applies sigmoid internally - do NOT use with sigmoid output_activation) */
+                readonly bce_with_logits: NullType;
             }>>;
             /** Optimizer (default adam) */
-            optimizer: OptionType<VariantType<{
+            readonly optimizer: OptionType<VariantType<{
                 /** Adam optimizer */
-                adam: StructType<{}>;
+                readonly adam: NullType;
                 /** Stochastic Gradient Descent */
-                sgd: StructType<{}>;
+                readonly sgd: NullType;
                 /** AdamW with weight decay */
-                adamw: StructType<{}>;
+                readonly adamw: NullType;
                 /** RMSprop optimizer */
-                rmsprop: StructType<{}>;
+                readonly rmsprop: NullType;
             }>>;
             /** Early stopping patience, 0 = disabled */
-            early_stopping: OptionType<IntegerType>;
+            readonly early_stopping: OptionType<IntegerType>;
             /** Validation split fraction (default 0.2) */
-            validation_split: OptionType<FloatType>;
+            readonly validation_split: OptionType<FloatType>;
             /** Random seed for reproducibility */
-            random_state: OptionType<IntegerType>;
+            readonly random_state: OptionType<IntegerType>;
         }>;
         /** Training result type */
         readonly TorchTrainResultType: StructType<{
             /** Training loss per epoch */
-            train_losses: ArrayType<FloatType>;
+            readonly train_losses: ArrayType<FloatType>;
             /** Validation loss per epoch */
-            val_losses: ArrayType<FloatType>;
+            readonly val_losses: ArrayType<FloatType>;
             /** Best epoch (for early stopping) */
-            best_epoch: IntegerType;
+            readonly best_epoch: IntegerType;
         }>;
         /** Training output type (model + result) */
         readonly TorchTrainOutputType: StructType<{
             /** Trained model blob */
-            model: VariantType<{
-                torch_mlp: StructType<{
-                    data: BlobType;
-                    n_features: IntegerType;
-                    hidden_layers: ArrayType<IntegerType>;
-                    output_dim: IntegerType;
+            readonly model: VariantType<{
+                readonly torch_mlp: StructType<{
+                    readonly data: BlobType;
+                    readonly n_features: IntegerType;
+                    readonly hidden_layers: ArrayType<IntegerType>;
+                    readonly output_dim: IntegerType;
                 }>;
             }>;
             /** Training result with losses */
-            result: StructType<{
+            readonly result: StructType<{
                 /** Training loss per epoch */
-                train_losses: ArrayType<FloatType>;
+                readonly train_losses: ArrayType<FloatType>;
                 /** Validation loss per epoch */
-                val_losses: ArrayType<FloatType>;
+                readonly val_losses: ArrayType<FloatType>;
                 /** Best epoch (for early stopping) */
-                best_epoch: IntegerType;
+                readonly best_epoch: IntegerType;
             }>;
         }>;
         /** Model blob type for PyTorch models */
         readonly ModelBlobType: VariantType<{
             /** PyTorch MLP model */
-            torch_mlp: StructType<{
+            readonly torch_mlp: StructType<{
                 /** Cloudpickle serialized model */
-                data: BlobType;
+                readonly data: BlobType;
                 /** Number of input features */
-                n_features: IntegerType;
+                readonly n_features: IntegerType;
                 /** Hidden layer sizes */
-                hidden_layers: ArrayType<IntegerType>;
+                readonly hidden_layers: ArrayType<IntegerType>;
                 /** Output dimension */
-                output_dim: IntegerType;
+                readonly output_dim: IntegerType;
             }>;
         }>;
     };