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

package/dist/torch/torch.d.ts

@@ -0,0 +1,658 @@
+/**
+ * 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 } from "@elaraai/east";
+export { VectorType, MatrixType } from "../types.js";
+/**
+ * Activation function type for neural networks.
+ */
+export declare const TorchActivationType: VariantType<{
+    /** Rectified Linear Unit */
+    relu: StructType<{}>;
+    /** Hyperbolic tangent */
+    tanh: StructType<{}>;
+    /** Sigmoid function */
+    sigmoid: StructType<{}>;
+    /** Leaky ReLU */
+    leaky_relu: StructType<{}>;
+}>;
+/**
+ * Loss function type for training.
+ */
+export declare const TorchLossType: VariantType<{
+    /** Mean Squared Error (regression) */
+    mse: StructType<{}>;
+    /** Mean Absolute Error (regression) */
+    mae: StructType<{}>;
+    /** Cross Entropy (classification) */
+    cross_entropy: StructType<{}>;
+}>;
+/**
+ * Optimizer type for training.
+ */
+export declare const TorchOptimizerType: VariantType<{
+    /** Adam optimizer */
+    adam: StructType<{}>;
+    /** Stochastic Gradient Descent */
+    sgd: StructType<{}>;
+    /** AdamW with weight decay */
+    adamw: StructType<{}>;
+    /** RMSprop optimizer */
+    rmsprop: StructType<{}>;
+}>;
+/**
+ * Configuration for MLP architecture.
+ */
+export declare const TorchMLPConfigType: StructType<{
+    /** Hidden layer sizes, e.g., [64, 32] */
+    hidden_layers: ArrayType<IntegerType>;
+    /** Activation function (default relu) */
+    activation: OptionType<VariantType<{
+        /** Rectified Linear Unit */
+        relu: StructType<{}>;
+        /** Hyperbolic tangent */
+        tanh: StructType<{}>;
+        /** Sigmoid function */
+        sigmoid: StructType<{}>;
+        /** Leaky ReLU */
+        leaky_relu: StructType<{}>;
+    }>>;
+    /** 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: StructType<{}>;
+        /** Mean Absolute Error (regression) */
+        mae: StructType<{}>;
+        /** Cross Entropy (classification) */
+        cross_entropy: StructType<{}>;
+    }>>;
+    /** Optimizer (default adam) */
+    optimizer: OptionType<VariantType<{
+        /** Adam optimizer */
+        adam: StructType<{}>;
+        /** Stochastic Gradient Descent */
+        sgd: StructType<{}>;
+        /** AdamW with weight decay */
+        adamw: StructType<{}>;
+        /** RMSprop optimizer */
+        rmsprop: StructType<{}>;
+    }>>;
+    /** 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 (default relu) */
+    activation: OptionType<VariantType<{
+        /** Rectified Linear Unit */
+        relu: StructType<{}>;
+        /** Hyperbolic tangent */
+        tanh: StructType<{}>;
+        /** Sigmoid function */
+        sigmoid: StructType<{}>;
+        /** Leaky ReLU */
+        leaky_relu: StructType<{}>;
+    }>>;
+    /** 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: StructType<{}>;
+        /** Mean Absolute Error (regression) */
+        mae: StructType<{}>;
+        /** Cross Entropy (classification) */
+        cross_entropy: StructType<{}>;
+    }>>;
+    /** Optimizer (default adam) */
+    optimizer: OptionType<VariantType<{
+        /** Adam optimizer */
+        adam: StructType<{}>;
+        /** Stochastic Gradient Descent */
+        sgd: StructType<{}>;
+        /** AdamW with weight decay */
+        adamw: StructType<{}>;
+        /** RMSprop optimizer */
+        rmsprop: StructType<{}>;
+    }>>;
+    /** 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>>;
+/**
+ * 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 */
+    readonly TorchActivationType: VariantType<{
+        /** Rectified Linear Unit */
+        relu: StructType<{}>;
+        /** Hyperbolic tangent */
+        tanh: StructType<{}>;
+        /** Sigmoid function */
+        sigmoid: StructType<{}>;
+        /** Leaky ReLU */
+        leaky_relu: StructType<{}>;
+    }>;
+    /** Loss function type */
+    readonly TorchLossType: VariantType<{
+        /** Mean Squared Error (regression) */
+        mse: StructType<{}>;
+        /** Mean Absolute Error (regression) */
+        mae: StructType<{}>;
+        /** Cross Entropy (classification) */
+        cross_entropy: StructType<{}>;
+    }>;
+    /** Optimizer type */
+    readonly TorchOptimizerType: VariantType<{
+        /** Adam optimizer */
+        adam: StructType<{}>;
+        /** Stochastic Gradient Descent */
+        sgd: StructType<{}>;
+        /** AdamW with weight decay */
+        adamw: StructType<{}>;
+        /** RMSprop optimizer */
+        rmsprop: StructType<{}>;
+    }>;
+    /** MLP configuration type */
+    readonly TorchMLPConfigType: StructType<{
+        /** Hidden layer sizes, e.g., [64, 32] */
+        hidden_layers: ArrayType<IntegerType>;
+        /** Activation function (default relu) */
+        activation: OptionType<VariantType<{
+            /** Rectified Linear Unit */
+            relu: StructType<{}>;
+            /** Hyperbolic tangent */
+            tanh: StructType<{}>;
+            /** Sigmoid function */
+            sigmoid: StructType<{}>;
+            /** Leaky ReLU */
+            leaky_relu: StructType<{}>;
+        }>>;
+        /** 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: StructType<{}>;
+            /** Mean Absolute Error (regression) */
+            mae: StructType<{}>;
+            /** Cross Entropy (classification) */
+            cross_entropy: StructType<{}>;
+        }>>;
+        /** Optimizer (default adam) */
+        optimizer: OptionType<VariantType<{
+            /** Adam optimizer */
+            adam: StructType<{}>;
+            /** Stochastic Gradient Descent */
+            sgd: StructType<{}>;
+            /** AdamW with weight decay */
+            adamw: StructType<{}>;
+            /** RMSprop optimizer */
+            rmsprop: StructType<{}>;
+        }>>;
+        /** 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 */
+    readonly mlpTrain: import("@elaraai/east").PlatformDefinition<[ArrayType<ArrayType<FloatType>>, ArrayType<FloatType>, StructType<{
+        /** Hidden layer sizes, e.g., [64, 32] */
+        hidden_layers: ArrayType<IntegerType>;
+        /** Activation function (default relu) */
+        activation: OptionType<VariantType<{
+            /** Rectified Linear Unit */
+            relu: StructType<{}>;
+            /** Hyperbolic tangent */
+            tanh: StructType<{}>;
+            /** Sigmoid function */
+            sigmoid: StructType<{}>;
+            /** Leaky ReLU */
+            leaky_relu: StructType<{}>;
+        }>>;
+        /** 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: StructType<{}>;
+            /** Mean Absolute Error (regression) */
+            mae: StructType<{}>;
+            /** Cross Entropy (classification) */
+            cross_entropy: StructType<{}>;
+        }>>;
+        /** Optimizer (default adam) */
+        optimizer: OptionType<VariantType<{
+            /** Adam optimizer */
+            adam: StructType<{}>;
+            /** Stochastic Gradient Descent */
+            sgd: StructType<{}>;
+            /** AdamW with weight decay */
+            adamw: StructType<{}>;
+            /** RMSprop optimizer */
+            rmsprop: StructType<{}>;
+        }>>;
+        /** 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 */
+    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>>;
+    /** 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 */
+        readonly TorchActivationType: VariantType<{
+            /** Rectified Linear Unit */
+            relu: StructType<{}>;
+            /** Hyperbolic tangent */
+            tanh: StructType<{}>;
+            /** Sigmoid function */
+            sigmoid: StructType<{}>;
+            /** Leaky ReLU */
+            leaky_relu: StructType<{}>;
+        }>;
+        /** Loss function type */
+        readonly TorchLossType: VariantType<{
+            /** Mean Squared Error (regression) */
+            mse: StructType<{}>;
+            /** Mean Absolute Error (regression) */
+            mae: StructType<{}>;
+            /** Cross Entropy (classification) */
+            cross_entropy: StructType<{}>;
+        }>;
+        /** Optimizer type */
+        readonly TorchOptimizerType: VariantType<{
+            /** Adam optimizer */
+            adam: StructType<{}>;
+            /** Stochastic Gradient Descent */
+            sgd: StructType<{}>;
+            /** AdamW with weight decay */
+            adamw: StructType<{}>;
+            /** RMSprop optimizer */
+            rmsprop: StructType<{}>;
+        }>;
+        /** MLP configuration type */
+        readonly TorchMLPConfigType: StructType<{
+            /** Hidden layer sizes, e.g., [64, 32] */
+            hidden_layers: ArrayType<IntegerType>;
+            /** Activation function (default relu) */
+            activation: OptionType<VariantType<{
+                /** Rectified Linear Unit */
+                relu: StructType<{}>;
+                /** Hyperbolic tangent */
+                tanh: StructType<{}>;
+                /** Sigmoid function */
+                sigmoid: StructType<{}>;
+                /** Leaky ReLU */
+                leaky_relu: StructType<{}>;
+            }>>;
+            /** 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: StructType<{}>;
+                /** Mean Absolute Error (regression) */
+                mae: StructType<{}>;
+                /** Cross Entropy (classification) */
+                cross_entropy: StructType<{}>;
+            }>>;
+            /** Optimizer (default adam) */
+            optimizer: OptionType<VariantType<{
+                /** Adam optimizer */
+                adam: StructType<{}>;
+                /** Stochastic Gradient Descent */
+                sgd: StructType<{}>;
+                /** AdamW with weight decay */
+                adamw: StructType<{}>;
+                /** RMSprop optimizer */
+                rmsprop: StructType<{}>;
+            }>>;
+            /** 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

package/dist/torch/torch.d.ts.map

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