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

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

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