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

package/dist/torch/torch.d.ts

@@ -1,1081 +0,0 @@
-/**
- * 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";
-export { VectorType, MatrixType } from "../types.js";
-/**
- * Activation function type for hidden layers.
- */
-export declare const TorchActivationType: VariantType<{
-    /** Rectified Linear Unit */
-    relu: NullType;
-    /** Hyperbolic tangent */
-    tanh: NullType;
-    /** Sigmoid function */
-    sigmoid: NullType;
-    /** Leaky ReLU */
-    leaky_relu: NullType;
-}>;
-/**
- * Loss function type for training.
- */
-export declare const TorchLossType: VariantType<{
-    /** Mean Squared Error (regression) */
-    mse: NullType;
-    /** Mean Absolute Error (regression) */
-    mae: NullType;
-    /** Cross Entropy (classification) */
-    cross_entropy: NullType;
-    /** KL Divergence (distribution matching, use with softmax output) */
-    kl_div: NullType;
-}>;
-/**
- * Optimizer type for training.
- */
-export declare const TorchOptimizerType: VariantType<{
-    /** Adam optimizer */
-    adam: NullType;
-    /** Stochastic Gradient Descent */
-    sgd: NullType;
-    /** AdamW with weight decay */
-    adamw: NullType;
-    /** RMSprop optimizer */
-    rmsprop: NullType;
-}>;
-/**
- * Output activation function type for the final layer.
- * Applied only to the output layer, not hidden layers.
- */
-export declare const TorchOutputActivationType: VariantType<{
-    /** No activation (linear output) - default */
-    none: NullType;
-    /** Softmax (outputs sum to 1, for probability distributions) */
-    softmax: NullType;
-    /** Sigmoid (each output independently in [0,1]) */
-    sigmoid: NullType;
-}>;
-/**
- * Configuration for MLP architecture.
- */
-export declare const TorchMLPConfigType: StructType<{
-    /** Hidden layer sizes, e.g., [64, 32] */
-    hidden_layers: ArrayType<IntegerType>;
-    /** Activation function for hidden layers (default relu) */
-    activation: OptionType<VariantType<{
-        /** Rectified Linear Unit */
-        relu: NullType;
-        /** Hyperbolic tangent */
-        tanh: NullType;
-        /** Sigmoid function */
-        sigmoid: NullType;
-        /** Leaky ReLU */
-        leaky_relu: NullType;
-    }>>;
-    /** Output activation function (default none/linear) */
-    output_activation: OptionType<VariantType<{
-        /** No activation (linear output) - default */
-        none: NullType;
-        /** Softmax (outputs sum to 1, for probability distributions) */
-        softmax: NullType;
-        /** Sigmoid (each output independently in [0,1]) */
-        sigmoid: NullType;
-    }>>;
-    /** Dropout rate (default 0.0) */
-    dropout: OptionType<FloatType>;
-    /** Output dimension (default 1) */
-    output_dim: OptionType<IntegerType>;
-}>;
-/**
- * Configuration for training.
- */
-export declare const TorchTrainConfigType: StructType<{
-    /** Number of epochs (default 100) */
-    epochs: OptionType<IntegerType>;
-    /** Batch size (default 32) */
-    batch_size: OptionType<IntegerType>;
-    /** Learning rate (default 0.001) */
-    learning_rate: OptionType<FloatType>;
-    /** Loss function (default mse) */
-    loss: OptionType<VariantType<{
-        /** Mean Squared Error (regression) */
-        mse: NullType;
-        /** Mean Absolute Error (regression) */
-        mae: NullType;
-        /** Cross Entropy (classification) */
-        cross_entropy: NullType;
-        /** KL Divergence (distribution matching, use with softmax output) */
-        kl_div: NullType;
-    }>>;
-    /** Optimizer (default adam) */
-    optimizer: OptionType<VariantType<{
-        /** Adam optimizer */
-        adam: NullType;
-        /** Stochastic Gradient Descent */
-        sgd: NullType;
-        /** AdamW with weight decay */
-        adamw: NullType;
-        /** RMSprop optimizer */
-        rmsprop: NullType;
-    }>>;
-    /** Early stopping patience, 0 = disabled */
-    early_stopping: OptionType<IntegerType>;
-    /** Validation split fraction (default 0.2) */
-    validation_split: OptionType<FloatType>;
-    /** Random seed for reproducibility */
-    random_state: OptionType<IntegerType>;
-}>;
-/**
- * Result type for training.
- */
-export declare const TorchTrainResultType: StructType<{
-    /** Training loss per epoch */
-    train_losses: ArrayType<FloatType>;
-    /** Validation loss per epoch */
-    val_losses: ArrayType<FloatType>;
-    /** Best epoch (for early stopping) */
-    best_epoch: IntegerType;
-}>;
-/**
- * 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;
-        }>;
-    }>;
-    /** Training result with losses */
-    result: StructType<{
-        /** Training loss per epoch */
-        train_losses: ArrayType<FloatType>;
-        /** Validation loss per epoch */
-        val_losses: ArrayType<FloatType>;
-        /** Best epoch (for early stopping) */
-        best_epoch: IntegerType;
-    }>;
-}>;
-/**
- * Model blob type for serialized PyTorch models.
- */
-export declare const TorchModelBlobType: VariantType<{
-    /** PyTorch MLP model */
-    torch_mlp: StructType<{
-        /** Cloudpickle serialized model */
-        data: BlobType;
-        /** Number of input features */
-        n_features: IntegerType;
-        /** Hidden layer sizes */
-        hidden_layers: ArrayType<IntegerType>;
-        /** Output dimension */
-        output_dim: IntegerType;
-    }>;
-}>;
-/**
- * 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<[ArrayType<ArrayType<FloatType>>, ArrayType<FloatType>, StructType<{
-    /** Hidden layer sizes, e.g., [64, 32] */
-    hidden_layers: ArrayType<IntegerType>;
-    /** Activation function for hidden layers (default relu) */
-    activation: OptionType<VariantType<{
-        /** Rectified Linear Unit */
-        relu: NullType;
-        /** Hyperbolic tangent */
-        tanh: NullType;
-        /** Sigmoid function */
-        sigmoid: NullType;
-        /** Leaky ReLU */
-        leaky_relu: NullType;
-    }>>;
-    /** Output activation function (default none/linear) */
-    output_activation: OptionType<VariantType<{
-        /** No activation (linear output) - default */
-        none: NullType;
-        /** Softmax (outputs sum to 1, for probability distributions) */
-        softmax: NullType;
-        /** Sigmoid (each output independently in [0,1]) */
-        sigmoid: NullType;
-    }>>;
-    /** Dropout rate (default 0.0) */
-    dropout: OptionType<FloatType>;
-    /** Output dimension (default 1) */
-    output_dim: OptionType<IntegerType>;
-}>, StructType<{
-    /** Number of epochs (default 100) */
-    epochs: OptionType<IntegerType>;
-    /** Batch size (default 32) */
-    batch_size: OptionType<IntegerType>;
-    /** Learning rate (default 0.001) */
-    learning_rate: OptionType<FloatType>;
-    /** Loss function (default mse) */
-    loss: OptionType<VariantType<{
-        /** Mean Squared Error (regression) */
-        mse: NullType;
-        /** Mean Absolute Error (regression) */
-        mae: NullType;
-        /** Cross Entropy (classification) */
-        cross_entropy: NullType;
-        /** KL Divergence (distribution matching, use with softmax output) */
-        kl_div: NullType;
-    }>>;
-    /** Optimizer (default adam) */
-    optimizer: OptionType<VariantType<{
-        /** Adam optimizer */
-        adam: NullType;
-        /** Stochastic Gradient Descent */
-        sgd: NullType;
-        /** AdamW with weight decay */
-        adamw: NullType;
-        /** RMSprop optimizer */
-        rmsprop: NullType;
-    }>>;
-    /** Early stopping patience, 0 = disabled */
-    early_stopping: OptionType<IntegerType>;
-    /** Validation split fraction (default 0.2) */
-    validation_split: OptionType<FloatType>;
-    /** Random seed for reproducibility */
-    random_state: OptionType<IntegerType>;
-}>], StructType<{
-    /** Trained model blob */
-    model: VariantType<{
-        torch_mlp: StructType<{
-            data: BlobType;
-            n_features: IntegerType;
-            hidden_layers: ArrayType<IntegerType>;
-            output_dim: IntegerType;
-        }>;
-    }>;
-    /** Training result with losses */
-    result: StructType<{
-        /** Training loss per epoch */
-        train_losses: ArrayType<FloatType>;
-        /** Validation loss per epoch */
-        val_losses: ArrayType<FloatType>;
-        /** Best epoch (for early stopping) */
-        best_epoch: IntegerType;
-    }>;
-}>>;
-/**
- * Make predictions with a trained PyTorch MLP.
- *
- * @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 */
-    torch_mlp: StructType<{
-        /** Cloudpickle serialized model */
-        data: BlobType;
-        /** Number of input features */
-        n_features: IntegerType;
-        /** Hidden layer sizes */
-        hidden_layers: ArrayType<IntegerType>;
-        /** Output dimension */
-        output_dim: IntegerType;
-    }>;
-}>, ArrayType<ArrayType<FloatType>>], ArrayType<FloatType>>;
-/**
- * Train a PyTorch MLP model with multi-output support.
- *
- * Supports multi-output regression (predicting multiple values per sample)
- * and autoencoders (where input equals target for reconstruction learning).
- * Output dimension is inferred from y.shape[1] unless overridden in config.
- *
- * @param X - Feature matrix (n_samples x n_features)
- * @param y - Target matrix (n_samples x n_outputs)
- * @param mlp_config - MLP architecture configuration
- * @param train_config - Training configuration
- * @returns Model blob and training result
- */
-export declare const torch_mlp_train_multi: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<ArrayType<FloatType>>, StructType<{
-    /** Hidden layer sizes, e.g., [64, 32] */
-    hidden_layers: ArrayType<IntegerType>;
-    /** Activation function for hidden layers (default relu) */
-    activation: OptionType<VariantType<{
-        /** Rectified Linear Unit */
-        relu: NullType;
-        /** Hyperbolic tangent */
-        tanh: NullType;
-        /** Sigmoid function */
-        sigmoid: NullType;
-        /** Leaky ReLU */
-        leaky_relu: NullType;
-    }>>;
-    /** Output activation function (default none/linear) */
-    output_activation: OptionType<VariantType<{
-        /** No activation (linear output) - default */
-        none: NullType;
-        /** Softmax (outputs sum to 1, for probability distributions) */
-        softmax: NullType;
-        /** Sigmoid (each output independently in [0,1]) */
-        sigmoid: NullType;
-    }>>;
-    /** Dropout rate (default 0.0) */
-    dropout: OptionType<FloatType>;
-    /** Output dimension (default 1) */
-    output_dim: OptionType<IntegerType>;
-}>, StructType<{
-    /** Number of epochs (default 100) */
-    epochs: OptionType<IntegerType>;
-    /** Batch size (default 32) */
-    batch_size: OptionType<IntegerType>;
-    /** Learning rate (default 0.001) */
-    learning_rate: OptionType<FloatType>;
-    /** Loss function (default mse) */
-    loss: OptionType<VariantType<{
-        /** Mean Squared Error (regression) */
-        mse: NullType;
-        /** Mean Absolute Error (regression) */
-        mae: NullType;
-        /** Cross Entropy (classification) */
-        cross_entropy: NullType;
-        /** KL Divergence (distribution matching, use with softmax output) */
-        kl_div: NullType;
-    }>>;
-    /** Optimizer (default adam) */
-    optimizer: OptionType<VariantType<{
-        /** Adam optimizer */
-        adam: NullType;
-        /** Stochastic Gradient Descent */
-        sgd: NullType;
-        /** AdamW with weight decay */
-        adamw: NullType;
-        /** RMSprop optimizer */
-        rmsprop: NullType;
-    }>>;
-    /** Early stopping patience, 0 = disabled */
-    early_stopping: OptionType<IntegerType>;
-    /** Validation split fraction (default 0.2) */
-    validation_split: OptionType<FloatType>;
-    /** Random seed for reproducibility */
-    random_state: OptionType<IntegerType>;
-}>], StructType<{
-    /** Trained model blob */
-    model: VariantType<{
-        torch_mlp: StructType<{
-            data: BlobType;
-            n_features: IntegerType;
-            hidden_layers: ArrayType<IntegerType>;
-            output_dim: IntegerType;
-        }>;
-    }>;
-    /** Training result with losses */
-    result: StructType<{
-        /** Training loss per epoch */
-        train_losses: ArrayType<FloatType>;
-        /** Validation loss per epoch */
-        val_losses: ArrayType<FloatType>;
-        /** Best epoch (for early stopping) */
-        best_epoch: IntegerType;
-    }>;
-}>>;
-/**
- * Make predictions with a trained PyTorch MLP (multi-output).
- *
- * Returns a matrix where each row contains the predicted outputs for a sample.
- *
- * @param model - Trained MLP model blob
- * @param X - Feature matrix (n_samples x n_features)
- * @returns Predicted matrix (n_samples x n_outputs)
- */
-export declare const torch_mlp_predict_multi: import("@elaraai/east").PlatformDefinition<[VariantType<{
-    /** PyTorch MLP model */
-    torch_mlp: StructType<{
-        /** Cloudpickle serialized model */
-        data: BlobType;
-        /** Number of input features */
-        n_features: IntegerType;
-        /** Hidden layer sizes */
-        hidden_layers: ArrayType<IntegerType>;
-        /** Output dimension */
-        output_dim: IntegerType;
-    }>;
-}>, ArrayType<ArrayType<FloatType>>], ArrayType<ArrayType<FloatType>>>;
-/**
- * Extract intermediate layer activations (embeddings) from a trained MLP.
- *
- * For autoencoders, this allows extracting the bottleneck representation.
- * The layer_index specifies which hidden layer's output to return (0-indexed).
- *
- * For an autoencoder with architecture [input -> 8 -> 2 -> 8 -> output]
- * (hidden_layers: [8, 2, 8]):
- * - layer_index=0: output after first hidden layer (8 features)
- * - layer_index=1: output after second hidden layer (2 features) <- bottleneck
- * - layer_index=2: output after third hidden layer (8 features)
- *
- * @param model - Trained MLP model blob
- * @param X - Feature matrix (n_samples x n_features)
- * @param layer_index - Which hidden layer's output to return (0-indexed)
- * @returns Embedding matrix (n_samples x hidden_dim at that layer)
- *
- * @example
- * ```ts
- * // Train autoencoder: 4 features -> 8 -> 2 (bottleneck) -> 8 -> 4 features
- * const mlp_config = $.let({
- *     hidden_layers: [8n, 2n, 8n],
- *     activation: variant('some', variant('relu', {})),
- *     dropout: variant('none', null),
- *     output_dim: variant('none', null),
- * });
- * const output = $.let(Torch.mlpTrainMulti(X, X, mlp_config, train_config));
- *
- * // Extract bottleneck embeddings (layer_index=1 for the 2-dim bottleneck)
- * const embeddings = $.let(Torch.mlpEncode(output.model, X, 1n));
- * // embeddings is now (n_samples x 2)
- * ```
- */
-export declare const torch_mlp_encode: import("@elaraai/east").PlatformDefinition<[VariantType<{
-    /** PyTorch MLP model */
-    torch_mlp: StructType<{
-        /** Cloudpickle serialized model */
-        data: BlobType;
-        /** Number of input features */
-        n_features: IntegerType;
-        /** Hidden layer sizes */
-        hidden_layers: ArrayType<IntegerType>;
-        /** Output dimension */
-        output_dim: IntegerType;
-    }>;
-}>, ArrayType<ArrayType<FloatType>>, IntegerType], ArrayType<ArrayType<FloatType>>>;
-/**
- * Decode embeddings back through the decoder portion of an MLP.
- *
- * For autoencoders, this takes bottleneck activations and runs them through
- * the decoder to reconstruct the output. This is the complement to mlpEncode.
- *
- * For an autoencoder with architecture [input -> 8 -> 2 -> 8 -> output]
- * (hidden_layers: [8, 2, 8]):
- * - layer_index=1: Start from the 2-dim bottleneck, run through layers 2+ to output
- * - layer_index=0: Start from the 8-dim first layer, run through layers 1+ to output
- *
- * Use case: Compute weighted average of origin embeddings, then decode to
- * get the reconstructed blend weight distribution.
- *
- * @param model - Trained MLP model blob
- * @param embeddings - Embedding matrix (n_samples x hidden_dim at layer_index)
- * @param layer_index - Which hidden layer the embeddings come from (0-indexed)
- * @returns Decoded output matrix (n_samples x output_dim)
- *
- * @example
- * ```ts
- * // After training autoencoder and extracting embeddings...
- * const origin_embeddings = $.let(Torch.mlpEncode(output.model, X_onehot, 1n));
- *
- * // Compute weighted blend embedding (e.g., 50% origin A + 50% origin B)
- * const blend_embedding = $.let(...); // weighted average of origin embeddings
- *
- * // Decode back to weight distribution
- * const reconstructed = $.let(Torch.mlpDecode(output.model, blend_embedding, 1n));
- * ```
- */
-export declare const torch_mlp_decode: import("@elaraai/east").PlatformDefinition<[VariantType<{
-    /** PyTorch MLP model */
-    torch_mlp: StructType<{
-        /** Cloudpickle serialized model */
-        data: BlobType;
-        /** Number of input features */
-        n_features: IntegerType;
-        /** Hidden layer sizes */
-        hidden_layers: ArrayType<IntegerType>;
-        /** Output dimension */
-        output_dim: IntegerType;
-    }>;
-}>, ArrayType<ArrayType<FloatType>>, IntegerType], ArrayType<ArrayType<FloatType>>>;
-/**
- * Type definitions for PyTorch functions.
- */
-export declare const TorchTypes: {
-    /** Vector type (array of floats) */
-    readonly VectorType: ArrayType<FloatType>;
-    /** Matrix type (2D array of floats) */
-    readonly MatrixType: ArrayType<ArrayType<FloatType>>;
-    /** Activation function type for hidden layers */
-    readonly TorchActivationType: VariantType<{
-        /** Rectified Linear Unit */
-        relu: NullType;
-        /** Hyperbolic tangent */
-        tanh: NullType;
-        /** Sigmoid function */
-        sigmoid: NullType;
-        /** Leaky ReLU */
-        leaky_relu: NullType;
-    }>;
-    /** Output activation function type */
-    readonly TorchOutputActivationType: VariantType<{
-        /** No activation (linear output) - default */
-        none: NullType;
-        /** Softmax (outputs sum to 1, for probability distributions) */
-        softmax: NullType;
-        /** Sigmoid (each output independently in [0,1]) */
-        sigmoid: NullType;
-    }>;
-    /** Loss function type */
-    readonly TorchLossType: VariantType<{
-        /** Mean Squared Error (regression) */
-        mse: NullType;
-        /** Mean Absolute Error (regression) */
-        mae: NullType;
-        /** Cross Entropy (classification) */
-        cross_entropy: NullType;
-        /** KL Divergence (distribution matching, use with softmax output) */
-        kl_div: NullType;
-    }>;
-    /** Optimizer type */
-    readonly TorchOptimizerType: VariantType<{
-        /** Adam optimizer */
-        adam: NullType;
-        /** Stochastic Gradient Descent */
-        sgd: NullType;
-        /** AdamW with weight decay */
-        adamw: NullType;
-        /** RMSprop optimizer */
-        rmsprop: NullType;
-    }>;
-    /** MLP configuration type */
-    readonly TorchMLPConfigType: StructType<{
-        /** Hidden layer sizes, e.g., [64, 32] */
-        hidden_layers: ArrayType<IntegerType>;
-        /** Activation function for hidden layers (default relu) */
-        activation: OptionType<VariantType<{
-            /** Rectified Linear Unit */
-            relu: NullType;
-            /** Hyperbolic tangent */
-            tanh: NullType;
-            /** Sigmoid function */
-            sigmoid: NullType;
-            /** Leaky ReLU */
-            leaky_relu: NullType;
-        }>>;
-        /** Output activation function (default none/linear) */
-        output_activation: OptionType<VariantType<{
-            /** No activation (linear output) - default */
-            none: NullType;
-            /** Softmax (outputs sum to 1, for probability distributions) */
-            softmax: NullType;
-            /** Sigmoid (each output independently in [0,1]) */
-            sigmoid: NullType;
-        }>>;
-        /** Dropout rate (default 0.0) */
-        dropout: OptionType<FloatType>;
-        /** Output dimension (default 1) */
-        output_dim: OptionType<IntegerType>;
-    }>;
-    /** Training configuration type */
-    readonly TorchTrainConfigType: StructType<{
-        /** Number of epochs (default 100) */
-        epochs: OptionType<IntegerType>;
-        /** Batch size (default 32) */
-        batch_size: OptionType<IntegerType>;
-        /** Learning rate (default 0.001) */
-        learning_rate: OptionType<FloatType>;
-        /** Loss function (default mse) */
-        loss: OptionType<VariantType<{
-            /** Mean Squared Error (regression) */
-            mse: NullType;
-            /** Mean Absolute Error (regression) */
-            mae: NullType;
-            /** Cross Entropy (classification) */
-            cross_entropy: NullType;
-            /** KL Divergence (distribution matching, use with softmax output) */
-            kl_div: NullType;
-        }>>;
-        /** Optimizer (default adam) */
-        optimizer: OptionType<VariantType<{
-            /** Adam optimizer */
-            adam: NullType;
-            /** Stochastic Gradient Descent */
-            sgd: NullType;
-            /** AdamW with weight decay */
-            adamw: NullType;
-            /** RMSprop optimizer */
-            rmsprop: NullType;
-        }>>;
-        /** Early stopping patience, 0 = disabled */
-        early_stopping: OptionType<IntegerType>;
-        /** Validation split fraction (default 0.2) */
-        validation_split: OptionType<FloatType>;
-        /** Random seed for reproducibility */
-        random_state: OptionType<IntegerType>;
-    }>;
-    /** Training result type */
-    readonly TorchTrainResultType: StructType<{
-        /** Training loss per epoch */
-        train_losses: ArrayType<FloatType>;
-        /** Validation loss per epoch */
-        val_losses: ArrayType<FloatType>;
-        /** Best epoch (for early stopping) */
-        best_epoch: IntegerType;
-    }>;
-    /** 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;
-            }>;
-        }>;
-        /** Training result with losses */
-        result: StructType<{
-            /** Training loss per epoch */
-            train_losses: ArrayType<FloatType>;
-            /** Validation loss per epoch */
-            val_losses: ArrayType<FloatType>;
-            /** Best epoch (for early stopping) */
-            best_epoch: IntegerType;
-        }>;
-    }>;
-    /** Model blob type for PyTorch models */
-    readonly ModelBlobType: VariantType<{
-        /** PyTorch MLP model */
-        torch_mlp: StructType<{
-            /** Cloudpickle serialized model */
-            data: BlobType;
-            /** Number of input features */
-            n_features: IntegerType;
-            /** Hidden layer sizes */
-            hidden_layers: ArrayType<IntegerType>;
-            /** Output dimension */
-            output_dim: IntegerType;
-        }>;
-    }>;
-};
-/**
- * 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 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 for hidden layers (default relu) */
-        activation: OptionType<VariantType<{
-            /** Rectified Linear Unit */
-            relu: NullType;
-            /** Hyperbolic tangent */
-            tanh: NullType;
-            /** Sigmoid function */
-            sigmoid: NullType;
-            /** Leaky ReLU */
-            leaky_relu: NullType;
-        }>>;
-        /** Output activation function (default none/linear) */
-        output_activation: OptionType<VariantType<{
-            /** No activation (linear output) - default */
-            none: NullType;
-            /** Softmax (outputs sum to 1, for probability distributions) */
-            softmax: NullType;
-            /** Sigmoid (each output independently in [0,1]) */
-            sigmoid: NullType;
-        }>>;
-        /** Dropout rate (default 0.0) */
-        dropout: OptionType<FloatType>;
-        /** Output dimension (default 1) */
-        output_dim: OptionType<IntegerType>;
-    }>, StructType<{
-        /** Number of epochs (default 100) */
-        epochs: OptionType<IntegerType>;
-        /** Batch size (default 32) */
-        batch_size: OptionType<IntegerType>;
-        /** Learning rate (default 0.001) */
-        learning_rate: OptionType<FloatType>;
-        /** Loss function (default mse) */
-        loss: OptionType<VariantType<{
-            /** Mean Squared Error (regression) */
-            mse: NullType;
-            /** Mean Absolute Error (regression) */
-            mae: NullType;
-            /** Cross Entropy (classification) */
-            cross_entropy: NullType;
-            /** KL Divergence (distribution matching, use with softmax output) */
-            kl_div: NullType;
-        }>>;
-        /** Optimizer (default adam) */
-        optimizer: OptionType<VariantType<{
-            /** Adam optimizer */
-            adam: NullType;
-            /** Stochastic Gradient Descent */
-            sgd: NullType;
-            /** AdamW with weight decay */
-            adamw: NullType;
-            /** RMSprop optimizer */
-            rmsprop: NullType;
-        }>>;
-        /** Early stopping patience, 0 = disabled */
-        early_stopping: OptionType<IntegerType>;
-        /** Validation split fraction (default 0.2) */
-        validation_split: OptionType<FloatType>;
-        /** Random seed for reproducibility */
-        random_state: OptionType<IntegerType>;
-    }>], StructType<{
-        /** Trained model blob */
-        model: VariantType<{
-            torch_mlp: StructType<{
-                data: BlobType;
-                n_features: IntegerType;
-                hidden_layers: ArrayType<IntegerType>;
-                output_dim: IntegerType;
-            }>;
-        }>;
-        /** Training result with losses */
-        result: StructType<{
-            /** Training loss per epoch */
-            train_losses: ArrayType<FloatType>;
-            /** Validation loss per epoch */
-            val_losses: ArrayType<FloatType>;
-            /** Best epoch (for early stopping) */
-            best_epoch: IntegerType;
-        }>;
-    }>>;
-    /** Make predictions with MLP (single output) */
-    readonly mlpPredict: import("@elaraai/east").PlatformDefinition<[VariantType<{
-        /** PyTorch MLP model */
-        torch_mlp: StructType<{
-            /** Cloudpickle serialized model */
-            data: BlobType;
-            /** Number of input features */
-            n_features: IntegerType;
-            /** Hidden layer sizes */
-            hidden_layers: ArrayType<IntegerType>;
-            /** Output dimension */
-            output_dim: IntegerType;
-        }>;
-    }>, ArrayType<ArrayType<FloatType>>], ArrayType<FloatType>>;
-    /** Train MLP model (multi-output) */
-    readonly mlpTrainMulti: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<ArrayType<FloatType>>, StructType<{
-        /** Hidden layer sizes, e.g., [64, 32] */
-        hidden_layers: ArrayType<IntegerType>;
-        /** Activation function for hidden layers (default relu) */
-        activation: OptionType<VariantType<{
-            /** Rectified Linear Unit */
-            relu: NullType;
-            /** Hyperbolic tangent */
-            tanh: NullType;
-            /** Sigmoid function */
-            sigmoid: NullType;
-            /** Leaky ReLU */
-            leaky_relu: NullType;
-        }>>;
-        /** Output activation function (default none/linear) */
-        output_activation: OptionType<VariantType<{
-            /** No activation (linear output) - default */
-            none: NullType;
-            /** Softmax (outputs sum to 1, for probability distributions) */
-            softmax: NullType;
-            /** Sigmoid (each output independently in [0,1]) */
-            sigmoid: NullType;
-        }>>;
-        /** Dropout rate (default 0.0) */
-        dropout: OptionType<FloatType>;
-        /** Output dimension (default 1) */
-        output_dim: OptionType<IntegerType>;
-    }>, StructType<{
-        /** Number of epochs (default 100) */
-        epochs: OptionType<IntegerType>;
-        /** Batch size (default 32) */
-        batch_size: OptionType<IntegerType>;
-        /** Learning rate (default 0.001) */
-        learning_rate: OptionType<FloatType>;
-        /** Loss function (default mse) */
-        loss: OptionType<VariantType<{
-            /** Mean Squared Error (regression) */
-            mse: NullType;
-            /** Mean Absolute Error (regression) */
-            mae: NullType;
-            /** Cross Entropy (classification) */
-            cross_entropy: NullType;
-            /** KL Divergence (distribution matching, use with softmax output) */
-            kl_div: NullType;
-        }>>;
-        /** Optimizer (default adam) */
-        optimizer: OptionType<VariantType<{
-            /** Adam optimizer */
-            adam: NullType;
-            /** Stochastic Gradient Descent */
-            sgd: NullType;
-            /** AdamW with weight decay */
-            adamw: NullType;
-            /** RMSprop optimizer */
-            rmsprop: NullType;
-        }>>;
-        /** Early stopping patience, 0 = disabled */
-        early_stopping: OptionType<IntegerType>;
-        /** Validation split fraction (default 0.2) */
-        validation_split: OptionType<FloatType>;
-        /** Random seed for reproducibility */
-        random_state: OptionType<IntegerType>;
-    }>], StructType<{
-        /** Trained model blob */
-        model: VariantType<{
-            torch_mlp: StructType<{
-                data: BlobType;
-                n_features: IntegerType;
-                hidden_layers: ArrayType<IntegerType>;
-                output_dim: IntegerType;
-            }>;
-        }>;
-        /** Training result with losses */
-        result: StructType<{
-            /** Training loss per epoch */
-            train_losses: ArrayType<FloatType>;
-            /** Validation loss per epoch */
-            val_losses: ArrayType<FloatType>;
-            /** Best epoch (for early stopping) */
-            best_epoch: IntegerType;
-        }>;
-    }>>;
-    /** Make predictions with MLP (multi-output) */
-    readonly mlpPredictMulti: import("@elaraai/east").PlatformDefinition<[VariantType<{
-        /** PyTorch MLP model */
-        torch_mlp: StructType<{
-            /** Cloudpickle serialized model */
-            data: BlobType;
-            /** Number of input features */
-            n_features: IntegerType;
-            /** Hidden layer sizes */
-            hidden_layers: ArrayType<IntegerType>;
-            /** Output dimension */
-            output_dim: IntegerType;
-        }>;
-    }>, ArrayType<ArrayType<FloatType>>], ArrayType<ArrayType<FloatType>>>;
-    /** Extract intermediate layer activations (embeddings) from MLP */
-    readonly mlpEncode: import("@elaraai/east").PlatformDefinition<[VariantType<{
-        /** PyTorch MLP model */
-        torch_mlp: StructType<{
-            /** Cloudpickle serialized model */
-            data: BlobType;
-            /** Number of input features */
-            n_features: IntegerType;
-            /** Hidden layer sizes */
-            hidden_layers: ArrayType<IntegerType>;
-            /** Output dimension */
-            output_dim: IntegerType;
-        }>;
-    }>, ArrayType<ArrayType<FloatType>>, IntegerType], ArrayType<ArrayType<FloatType>>>;
-    /** Decode embeddings back through decoder portion of MLP */
-    readonly mlpDecode: import("@elaraai/east").PlatformDefinition<[VariantType<{
-        /** PyTorch MLP model */
-        torch_mlp: StructType<{
-            /** Cloudpickle serialized model */
-            data: BlobType;
-            /** Number of input features */
-            n_features: IntegerType;
-            /** Hidden layer sizes */
-            hidden_layers: ArrayType<IntegerType>;
-            /** Output dimension */
-            output_dim: IntegerType;
-        }>;
-    }>, ArrayType<ArrayType<FloatType>>, IntegerType], ArrayType<ArrayType<FloatType>>>;
-    /** Type definitions */
-    readonly Types: {
-        /** Vector type (array of floats) */
-        readonly VectorType: ArrayType<FloatType>;
-        /** Matrix type (2D array of floats) */
-        readonly MatrixType: ArrayType<ArrayType<FloatType>>;
-        /** Activation function type for hidden layers */
-        readonly TorchActivationType: VariantType<{
-            /** Rectified Linear Unit */
-            relu: NullType;
-            /** Hyperbolic tangent */
-            tanh: NullType;
-            /** Sigmoid function */
-            sigmoid: NullType;
-            /** Leaky ReLU */
-            leaky_relu: NullType;
-        }>;
-        /** Output activation function type */
-        readonly TorchOutputActivationType: VariantType<{
-            /** No activation (linear output) - default */
-            none: NullType;
-            /** Softmax (outputs sum to 1, for probability distributions) */
-            softmax: NullType;
-            /** Sigmoid (each output independently in [0,1]) */
-            sigmoid: NullType;
-        }>;
-        /** Loss function type */
-        readonly TorchLossType: VariantType<{
-            /** Mean Squared Error (regression) */
-            mse: NullType;
-            /** Mean Absolute Error (regression) */
-            mae: NullType;
-            /** Cross Entropy (classification) */
-            cross_entropy: NullType;
-            /** KL Divergence (distribution matching, use with softmax output) */
-            kl_div: NullType;
-        }>;
-        /** Optimizer type */
-        readonly TorchOptimizerType: VariantType<{
-            /** Adam optimizer */
-            adam: NullType;
-            /** Stochastic Gradient Descent */
-            sgd: NullType;
-            /** AdamW with weight decay */
-            adamw: NullType;
-            /** RMSprop optimizer */
-            rmsprop: NullType;
-        }>;
-        /** MLP configuration type */
-        readonly TorchMLPConfigType: StructType<{
-            /** Hidden layer sizes, e.g., [64, 32] */
-            hidden_layers: ArrayType<IntegerType>;
-            /** Activation function for hidden layers (default relu) */
-            activation: OptionType<VariantType<{
-                /** Rectified Linear Unit */
-                relu: NullType;
-                /** Hyperbolic tangent */
-                tanh: NullType;
-                /** Sigmoid function */
-                sigmoid: NullType;
-                /** Leaky ReLU */
-                leaky_relu: NullType;
-            }>>;
-            /** Output activation function (default none/linear) */
-            output_activation: OptionType<VariantType<{
-                /** No activation (linear output) - default */
-                none: NullType;
-                /** Softmax (outputs sum to 1, for probability distributions) */
-                softmax: NullType;
-                /** Sigmoid (each output independently in [0,1]) */
-                sigmoid: NullType;
-            }>>;
-            /** Dropout rate (default 0.0) */
-            dropout: OptionType<FloatType>;
-            /** Output dimension (default 1) */
-            output_dim: OptionType<IntegerType>;
-        }>;
-        /** Training configuration type */
-        readonly TorchTrainConfigType: StructType<{
-            /** Number of epochs (default 100) */
-            epochs: OptionType<IntegerType>;
-            /** Batch size (default 32) */
-            batch_size: OptionType<IntegerType>;
-            /** Learning rate (default 0.001) */
-            learning_rate: OptionType<FloatType>;
-            /** Loss function (default mse) */
-            loss: OptionType<VariantType<{
-                /** Mean Squared Error (regression) */
-                mse: NullType;
-                /** Mean Absolute Error (regression) */
-                mae: NullType;
-                /** Cross Entropy (classification) */
-                cross_entropy: NullType;
-                /** KL Divergence (distribution matching, use with softmax output) */
-                kl_div: NullType;
-            }>>;
-            /** Optimizer (default adam) */
-            optimizer: OptionType<VariantType<{
-                /** Adam optimizer */
-                adam: NullType;
-                /** Stochastic Gradient Descent */
-                sgd: NullType;
-                /** AdamW with weight decay */
-                adamw: NullType;
-                /** RMSprop optimizer */
-                rmsprop: NullType;
-            }>>;
-            /** Early stopping patience, 0 = disabled */
-            early_stopping: OptionType<IntegerType>;
-            /** Validation split fraction (default 0.2) */
-            validation_split: OptionType<FloatType>;
-            /** Random seed for reproducibility */
-            random_state: OptionType<IntegerType>;
-        }>;
-        /** Training result type */
-        readonly TorchTrainResultType: StructType<{
-            /** Training loss per epoch */
-            train_losses: ArrayType<FloatType>;
-            /** Validation loss per epoch */
-            val_losses: ArrayType<FloatType>;
-            /** Best epoch (for early stopping) */
-            best_epoch: IntegerType;
-        }>;
-        /** 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;
-                }>;
-            }>;
-            /** Training result with losses */
-            result: StructType<{
-                /** Training loss per epoch */
-                train_losses: ArrayType<FloatType>;
-                /** Validation loss per epoch */
-                val_losses: ArrayType<FloatType>;
-                /** Best epoch (for early stopping) */
-                best_epoch: IntegerType;
-            }>;
-        }>;
-        /** Model blob type for PyTorch models */
-        readonly ModelBlobType: VariantType<{
-            /** PyTorch MLP model */
-            torch_mlp: StructType<{
-                /** Cloudpickle serialized model */
-                data: BlobType;
-                /** Number of input features */
-                n_features: IntegerType;
-                /** Hidden layer sizes */
-                hidden_layers: ArrayType<IntegerType>;
-                /** Output dimension */
-                output_dim: IntegerType;
-            }>;
-        }>;
-    };
-};
-//# sourceMappingURL=torch.d.ts.map