Methods

struct RandomFeatureMethod{S<:AbstractString, USorM<:Union{AbstractMatrix, LinearAlgebra.UniformScaling}}

Holds configuration for the random feature fit

• random_feature::RandomFeature: The random feature object

• batch_sizes::Dict{S, Int64} where S<:AbstractString: A dictionary specifying the batch sizes. Must contain "train", "test", and "feature" keys

• regularization::Union{AbstractMatrix, LinearAlgebra.UniformScaling}: A positive definite matrix used during the fit method to regularize the linear solve, interpreted as the inverse of the observational noise covariance

• tullio_threading::Bool: Use multithreading provided by Tullio

struct Fit{V<:(AbstractVector), USorM<:Union{AbstractMatrix, LinearAlgebra.UniformScaling}}

Holds the coefficients and matrix decomposition that describe a set of fitted random features.

• feature_factors::Decomposition: The LinearAlgreba matrix decomposition of (1 / m) * Feature^T * regularization^-1 * Feature + I

• coeffs::AbstractVector: Coefficients of the fit to data

• regularization::Union{AbstractMatrix, LinearAlgebra.UniformScaling}: output-dim regularization used during fit

get_random_feature(
    rfm::RandomFeatureMethod
) -> RandomFeature

gets the random_feature field

get_batch_sizes(
    rfm::RandomFeatureMethod
) -> Dict{S, Int64} where S<:AbstractString

gets the batch_sizes field

get_batch_size(
    rfm::RandomFeatureMethod,
    key::AbstractString
) -> Int64

get the specified batch size from batch_sizes field

get_regularization(
    rfm::RandomFeatureMethod
) -> Union{AbstractMatrix, LinearAlgebra.UniformScaling}

gets the regularization field, this is the inverse of the provided matrix if keyword regularization_inverted = false

get_regularization(
    f::Fit
) -> Union{AbstractMatrix, LinearAlgebra.UniformScaling}

gets the regularization field (note this is the outputdim regularization)

sample(rfm::RandomFeatureMethod) -> Any

samples the random_feature field

get_feature_factors(f::Fit) -> Decomposition

gets the feature_factors field

get_coeffs(f::Fit) -> AbstractVector

gets the coeffs field

fit(
    rfm::RandomFeatureMethod,
    input_output_pairs::EnsembleKalmanProcesses.DataContainers.PairedDataContainer;
    decomposition_type
) -> Fit

Fits a RandomFeatureMethod to input-output data, optionally provide a preferred LinearAlgebra matrix decomposition. Returns a Fit object.

predict(
    rfm::RandomFeatureMethod,
    fit::Fit,
    new_inputs::EnsembleKalmanProcesses.DataContainers.DataContainer;
    kwargs...
) -> Tuple{Any, Any}

Makes a prediction of mean and (co)variance of fitted features on new input data

predict!(
    rfm::RandomFeatureMethod,
    fit::Fit,
    new_inputs::EnsembleKalmanProcesses.DataContainers.DataContainer,
    mean_store::AbstractMatrix{<:AbstractFloat},
    cov_store::AbstractArray{<:AbstractFloat, 3},
    buffer::AbstractArray{<:AbstractFloat, 3};
    kwargs...
)

Makes a prediction of mean and (co)variance of fitted features on new input data, overwriting the provided stores.

• meanstore:`outputdimxn_samples`
• covstore:`outputdimxoutputdimxnsamples`
• buffer:n_samples x output_dim x n_features

predictive_mean(
    rfm::RandomFeatureMethod,
    fit::Fit,
    new_inputs::EnsembleKalmanProcesses.DataContainers.DataContainer;
    kwargs...
) -> Tuple{Any, Any}

Makes a prediction of mean of fitted features on new input data. Returns a output_dim x n_samples array.

predictive_mean!(
    rfm::RandomFeatureMethod,
    fit::Fit,
    new_inputs::EnsembleKalmanProcesses.DataContainers.DataContainer,
    mean_store::Matrix{<:AbstractFloat};
    kwargs...
) -> Any

Makes a prediction of mean of fitted features on new input data. Writes into a provided output_dim x n_samples array: mean_store.

predictive_cov(
    rfm::RandomFeatureMethod,
    fit::Fit,
    new_inputs::EnsembleKalmanProcesses.DataContainers.DataContainer,
    prebuilt_features::AbstractArray{<:AbstractFloat, 3};
    kwargs...
) -> Any

Makes a prediction of (co)variance of fitted features on new input data.

Returns a output_dim x output_dim x n_samples array

predictive_cov!(
    rfm::RandomFeatureMethod,
    fit::Fit,
    new_inputs::EnsembleKalmanProcesses.DataContainers.DataContainer,
    cov_store::AbstractArray{<:AbstractFloat, 3},
    buffer::AbstractArray{<:AbstractFloat, 3},
    prebuilt_features::AbstractArray{<:AbstractFloat, 3};
    tullio_threading,
    kwargs...
)

Makes a prediction of (co)variance of fitted features on new input data.

Writes into a provided output_dim x output_dim x n_samples array: cov_store, and uses provided n_samples x output_dim x n_features buffer.

predict_prior(
    rfm::RandomFeatureMethod,
    new_inputs::EnsembleKalmanProcesses.DataContainers.DataContainer;
    kwargs...
) -> Tuple{Any, Any}

Makes a prediction of mean and (co)variance with unfitted features on new input data

predict_prior_mean(
    rfm::RandomFeatureMethod,
    new_inputs::EnsembleKalmanProcesses.DataContainers.DataContainer;
    kwargs...
) -> Tuple{Any, Any}

Makes a prediction of mean with unfitted features on new input data

predict_prior_cov(
    rfm::RandomFeatureMethod,
    new_inputs::EnsembleKalmanProcesses.DataContainers.DataContainer;
    kwargs...
) -> Tuple{Any, Any}

Makes a prediction of (co)variance with unfitted features on new input data