SS.MachineLearning 1.5.0

export function appendAttentionCache(AttentionCache cache, double[] keys, double[] values, int tokens)->AttentionCache

export function assessGeneralization(double[] trainingExpected, double[] trainingPredicted, double[] validationExpected, double[] validationPredicted, double allowedGap) -> GeneralizationReport

export function attentionBackward(double[] query, double[] key, double[] values, bool[] allowed, int queryTokens, int keyTokens, int width, int heads, double[] outputGradients, double differentiationStep)->AttentionBackwardResult

export record AttentionBackwardResult(public double[] queryGradients, public double[] keyGradients, public double[] valueGradients, public double loss)

export record AttentionCache(public double[] keys, public double[] values, public int tokens, public int width)

export function attentionRegressor(int tokens, int width, int heads, double[] queryWeights, double[] keyWeights, double[] valueWeights, double[] outputWeights, double[] readoutWeights, double readoutBias, long seed)->AttentionRegressor

export record AttentionRegressor(public int tokens, public int width, public int heads, public double[] queryWeights, public double[] keyWeights, public double[] valueWeights, public double[] outputWeights, public double[] readoutWeights, public double readoutBias, public int epochs, public double loss, public long seed)

export function attentionRegressorGradient(AttentionRegressor model, double[] input, bool[] allowed, double target)->AttentionRegressorGradient

export record AttentionRegressorGradient(public double[] queryGradients, public double[] keyGradients, public double[] valueGradients, public double[] outputGradients, public double[] readoutGradients, public double readoutBiasGradient, public double loss, public double prediction)

export record AttentionResult(public double[] values, public double[] weights, public int tokens, public int width)

export function attentionValueGradient(AttentionResult attention, double[] outputGradients, int keyTokens)->double[]

export record BoostedModel(public double baseValue, public double[] thresholds, public double[] below, public double[] above, public double learningRate)

export record BoostingTrainingReport(public BoostedModel model, public int bestTrees, public double validationError, public bool stoppedEarly)

export function causalMask(int tokens)->bool[]

export function classificationMetrics(double[] expected, double[] predicted) -> ClassificationMetrics

export record ClassificationMetrics(public int truePositive, public int trueNegative, public int falsePositive, public int falseNegative, public double accuracy, public double precision, public double recall)

export function conv1d(Conv1DLayer layer, double[] input, int samples, bool relu)->Conv1DResult

export function conv1dBackward(Conv1DLayer layer, double[] input, int samples, double[] outputGradients)->Conv1DGradient

export record Conv1DGradient(public double[] kernelGradients, public double[] biasGradients, public double[] inputGradients)

export function conv1dLayer(double[] kernels, double[] biases, int inputChannels, int outputChannels, int kernelWidth, int stride)->Conv1DLayer

export record Conv1DLayer(public double[] kernels, public double[] biases, public int inputChannels, public int outputChannels, public int kernelWidth, public int stride)

export record Conv1DResult(public double[] values, public int positions, public int channels)

export function convRegressor(Conv1DLayer layer, double[] readoutWeights, double readoutBias, int samples)->ConvRegressor

export record ConvRegressor(public Conv1DLayer layer, public double[] readoutWeights, public double readoutBias, public int samples, public int epochs, public double loss)

export function convRegressorGradient(ConvRegressor model, double[] input, double target)->ConvRegressorGradient

export record ConvRegressorGradient(public double[] kernelGradients, public double[] biasGradients, public double[] readoutGradients, public double readoutBiasGradient, public double[] inputGradients, public double loss)

export record DataSplit(public double[] trainFeatures, public double[] trainTargets, public double[] validationFeatures, public double[] validationTargets, public double[] testFeatures, public double[] testTargets)

export record DenseNetwork(public int inputs, public int hiddenUnits, public double[] inputWeights, public double[] hiddenBiases, public double[] outputWeights, public double outputBias, public int epochs, public double loss, public long seed)

export function deterministicSplit(double[] features, double[] targets, double validationFraction, double testFraction, long seed) -> DataSplit

export record DeviceTrainingQualification(public string backend, public string device, public string precision, public int samples, public bool forwardOnDevice, public bool gradientsOnDevice, public bool updateOnDevice, public bool qualified, public string diagnostic)

export interface DifferentiableDynamics

export function differentiableLinearEuler(double initialValue, double parameter, double duration, int steps)->DifferentiableStep

export function differentiableSimulationGradient(DifferentiableDynamics dynamics, double[] initialState, double[] parameters, double startTime, double endTime, int steps)->SimulationGradient

export record DifferentiableStep(public double value, public double parameterSensitivity, public int steps, public double stepSize)

export function expectedCalibrationError(double[] probabilities, double[] labels, int bins) -> double

export function fitStandardization(double[] values) -> Standardization

export function fitTabularPreprocessor(double[] numericValues, bool[] numericMissing, int[] categoricalCodes, int rows, int numericColumns, int[] categoricalCardinalities)->TabularPreprocessor

export record ForestModel(public double[] thresholds, public double[] below, public double[] above, public int trees, public long seed)

export record ForestTrainingReport(public ForestModel model, public double outOfBagMeanSquaredError, public int outOfBagPredictions)

export function fullMask(int queryTokens, int keyTokens)->bool[]

export record GeneralizationReport(public double trainingError, public double validationError, public double gap, public bool suspicious, public string diagnostic)

export interface GeneralPinnProblem

export record GeneralPinnResult(public double[] parameters, public double residualLoss, public double boundaryLoss, public int epochs, public bool converged, public string diagnostic)

export record LinearModel(public double intercept, public double slope, public bool trained)

export record LinearSnapshot(public double[] parameters, public string format, public int version)

export function loadLinear(LinearSnapshot snapshot) -> LinearModel

export function loadNeuralNetwork(NeuralSnapshot snapshot) -> NeuralNetwork

export function loadPortableAttentionRegressor(PortableModel value)->AttentionRegressor

export function loadPortableConvRegressor(PortableModel value)->ConvRegressor

export function loadPortableDense(PortableModel value)->DenseNetwork

export function loadPortableLstm(PortableModel value)->LstmNetwork

export function loadPortableQuadraticPinn(PortableScientificModel portable, int epochs, double loss, long seed)->PinnModel

export function loadPortableTransformer(PortableModel value)->PortableTransformer

export record LogisticModel(public double intercept, public double slope, public int epochs, public double loss, public bool converged)

export function lstmNetwork(int inputs, int hiddenUnits, double[] gateWeights, double[] gateBiases, double[] readoutWeights, double readoutBias) -> LstmNetwork

export record LstmNetwork(public int inputs, public int hiddenUnits, public double[] gateWeights, public double[] gateBiases, public double[] readoutWeights, public double readoutBias)

export function makeSequenceWindows(double[] series, int rows, int columns, int window, int targetColumn) -> SequenceWindows

export function maxPool1d(double[] values, int samples, int channels, int width, int stride)->Conv1DResult

export function meanSquaredError(double[] expected, double[] predicted) -> double

export function modelDeviceEvidence(string backend, string device, bool accelerated, int samples, string precision)->ModelDeviceEvidence

export record ModelDeviceEvidence(public string backend, public string device, public bool accelerated, public int samples, public string precision, public string limitation)

export function multiHeadAttention(double[] query, double[] key, double[] values, bool[] allowed, int queryTokens, int keyTokens, int width, int heads)->AttentionResult

export record NeuralModel(public double inputWeight, public double hiddenBias, public double outputWeight, public double outputBias, public int epochs, public double loss)

export record NeuralNetwork(public double[] inputWeights, public double[] hiddenBiases, public double[] outputWeights, public double outputBias, public int epochs, public double loss, public long seed)

export record NeuralSnapshot(public double[] inputWeights, public double[] hiddenBiases, public double[] outputWeights, public double outputBias, public int epochs, public double loss, public long seed, public string format, public int version)

export function normalizeChannels(double[] values, int samples, int channels, double epsilon)->double[]

export function pinnFirstDerivative(PinnModel model, double coordinate)->double

export function pinnInverseGradient(PinnModel model, double[] collocation, double[] observations, double[] forcing, double leftCoordinate, double leftValue, double rightCoordinate, double rightValue, double observationWeight, double boundaryWeight)->PinnInverseGradient

export record PinnInverseGradient(public double constantGradient, public double linearGradient, public double quadraticGradient, public double equationParameterGradient, public double residualLoss, public double observationLoss, public double boundaryLoss)

export record PinnModel(public double constant, public double linear, public double quadratic, public double equationParameter, public int epochs, public double loss, public long seed)

export function pinnPredict(PinnModel model, double coordinate)->double

export function pinnResidual(PinnModel model, double coordinate, double forcing)->double

export function pinnSecondDerivative(PinnModel model, double coordinate)->double

export record PinnTrainingReport(public PinnModel model, public double residualLoss, public double boundaryLoss, public bool converged, public string diagnostic)

export function portableAttentionRegressor(AttentionRegressor model, string sourceDigest)->PortableModel

export function portableConvRegressor(ConvRegressor model, string sourceDigest)->PortableModel

export function portableDense(DenseNetwork model, string sourceDigest)->PortableModel

export function portableLstm(LstmNetwork model, string sourceDigest)->PortableModel

export record PortableModel(public string schema, public string kind, public int version, public int[] dimensions, public double[] parameters, public double[] metrics, public long seed, public string sourceDigest)

export function portableQuadraticPinn(PinnModel model, string sourceDigest)->PortableScientificModel

export record PortableScientificModel(public string schema, public string kind, public int version, public int inputs, public int outputs, public double[] parameters, public string sourceDigest)

export function portableTransformer(TransformerBlock block, double[] readoutWeights, double readoutBias, string sourceDigest)->PortableModel

export record PortableTransformer(public TransformerBlock block, public double[] readoutWeights, public double readoutBias)

export function positionalEncoding(int tokens, int width)->double[]

export function predictAttentionRegressor(AttentionRegressor model, double[] input, bool[] allowed)->double

export function predictBoosted(BoostedModel model, double feature) -> double

export function predictClass(LogisticModel model, double feature, double threshold) -> double

export function predictConvRegressor(ConvRegressor model, double[] input)->double

export function predictDenseNetwork(DenseNetwork model, double[] features) -> double

export function predictForest(ForestModel model, double feature) -> double

export function predictLinear(LinearModel model, double[] features) -> double[]

export function predictLstm(LstmNetwork model, double[] sequence, int steps) -> double

export function predictNeural(NeuralModel model, double feature) -> double

export function predictNeuralNetwork(NeuralNetwork model, double feature) -> double

export function predictProbability(LogisticModel model, double feature) -> double

export function predictRidge(RidgeModel model, double[] features) -> double[]

export function predictStump(Stump model, double feature) -> double

export record PreparedFeatures(public double[] values, public int rows, public int columns)

export function qualifyDeviceTraining(string backend, string device, string precision, int samples, bool forwardOnDevice, bool gradientsOnDevice, bool updateOnDevice)->DeviceTrainingQualification

export function regressionMetrics(double[] expected, double[] predicted) -> RegressionMetrics

export record RegressionMetrics(public double meanSquaredError, public double meanAbsoluteError, public double rSquared)

export function residualAdd(double[] input, double[] residual)->double[]

export record RidgeModel(public double intercept, public double slope, public double penalty, public bool trained)

export function saveLinear(LinearModel model) -> LinearSnapshot

export function saveNeuralNetwork(NeuralNetwork model) -> NeuralSnapshot

export function scaledDotProductAttention(double[] query, double[] key, double[] values, bool[] allowed, int queryTokens, int keyTokens, int width)->AttentionResult

export record SequenceWindows(public double[] features, public double[] targets, public int count, public int window, public int columns)

export record SimulationGradient(public double[] finalState, public double[][] parameterSensitivities, public int steps, public double stepSize, public string method)

export record Standardization(public double mean, public double scale)

export record Stump(public double threshold, public double below, public double above)

export record TabularPreprocessor(public int numericColumns, public int[] categoricalCardinalities, public double[] means, public double[] scales, public int outputColumns)

export function tensor(double[] values, int[] shape)->Tensor

export record Tensor(public double[] values, public int[] shape)

export function trainAttentionRegressor(double[] sequences, double[] targets, int observations, bool[] allowed, AttentionRegressor initial, int epochs, double learningRate)->AttentionRegressor

export function trainConvRegressor(double[] sequences, double[] targets, int observations, ConvRegressor initial, int epochs, double learningRate)->ConvRegressor

export function trainDecisionTree(double[] features, double[] targets, double[] candidateThresholds) -> Stump

export function trainDenseNetwork(double[] features, double[] targets, int rows, int inputs, int hiddenUnits, int epochs, double learningRate, double penalty, long seed) -> DenseNetwork

export function trainGeneralPinn(GeneralPinnProblem problem, double[] coordinates, double[] initialParameters, int epochs, double learningRate, double residualWeight, double initialBoundaryWeight, double finalBoundaryWeight, double gradientTolerance)->GeneralPinnResult

export function trainGradientBoosting(double[] features, double[] targets, double[] thresholds, double learningRate) -> BoostedModel

export function trainGradientBoostingEarlyStopping(double[] trainingFeatures, double[] trainingTargets, double[] validationFeatures, double[] validationTargets, double[] thresholds, double learningRate, int patience) -> BoostingTrainingReport

export function trainInverseQuadraticPinn(double[] collocation, double[] observations, double[] forcing, double leftCoordinate, double leftValue, double rightCoordinate, double rightValue, PinnModel initial, int epochs, double learningRate, double observationWeight, double boundaryWeight)->PinnTrainingReport

export function trainLinear(double[] features, double[] targets) -> LinearModel

export function trainLogistic(double[] features, double[] labels, int epochs, double learningRate, double penalty, double gradientTolerance) -> LogisticModel

export function trainLstm(double[] windows, double[] targets, int samples, int steps, int inputs, int epochs, double learningRate, long seed) -> LstmNetwork

export function trainNeural(double[] features, double[] targets, int epochs, double learningRate) -> NeuralModel

export function trainNeuralNetwork(double[] features, double[] targets, int hiddenUnits, int epochs, double learningRate, long seed) -> NeuralNetwork

export function trainQuadraticPinn(double[] collocation, double equationParameter, double forcing, double leftCoordinate, double leftValue, double rightCoordinate, double rightValue, int epochs, double learningRate, double boundaryWeight, long seed)->PinnTrainingReport

export function trainRandomForest(double[] features, double[] targets, double[] candidateThresholds, int trees, long seed) -> ForestModel

export function trainRandomForestWithOob(double[] features, double[] targets, double[] candidateThresholds, int trees, long seed) -> ForestTrainingReport

export function trainRidge(double[] features, double[] targets, double penalty) -> RidgeModel

export function trainStump(double[] features, double[] targets, double threshold) -> Stump

export function trainTransformer(double[] sequences, double[] targets, int observations, int tokens, bool[] allowed, TransformerModel initial, int epochs, double learningRate, double differentiationStep)->TransformerModel

export function trainTransformerReadout(double[] encoded, int tokens, int width, double target, double[] readoutWeights, double readoutBias, double learningRate)->TransformerTrainingResult

export function transform(double[] values, Standardization fitted) -> double[]

export function transformerBlock(int width, int heads, double[] feedForwardFirst, double[] feedForwardSecond, double[] firstBias, double[] secondBias)->TransformerBlock

export record TransformerBlock(public int width, public int heads, public double[] feedForwardFirst, public double[] feedForwardSecond, public double[] firstBias, public double[] secondBias)

export function transformerBlockBackward(TransformerBlock block, double[] tokens, int count, bool[] allowed, double[] outputGradients, double differentiationStep)->TransformerBlockGradient

export record TransformerBlockGradient(public double[] inputGradients, public double[] feedForwardFirstGradients, public double[] feedForwardSecondGradients, public double[] firstBiasGradients, public double[] secondBiasGradients, public double loss)

export function transformerDecoder(TransformerBlock block, double[] targets, int targetCount, double[] memory, int memoryCount)->double[]

export function transformerEncoder(TransformerBlock block, double[] tokens, int count, bool[] allowed)->double[]

export record TransformerModel(public TransformerBlock block, public double[] readoutWeights, public double readoutBias, public int epochs, public double loss)

export record TransformerTrainingResult(public double[] readoutWeights, public double readoutBias, public double loss, public double prediction)

export function transformTabular(TabularPreprocessor fitted, double[] numericValues, bool[] numericMissing, int[] categoricalCodes, int rows)->PreparedFeatures