imputegap.recovery.imputation package¶

Submodules¶

Module contents¶

class imputegap.recovery.imputation.BaseImputer(incomp_data)[source]¶

Bases: object

Base class for imputation algorithms.

This class provides common methods for imputation tasks such as scoring, parameter checking, and optimization. Specific algorithms should inherit from this class and implement the impute method.

Methods¶

impute(params=None):: Abstract method to perform the imputation.
score(input_data, recov_data=None, downstream=None):: Compute metrics for the imputed time series.
_check_params(user_def, params):: Check and format parameters for imputation.
_optimize(parameters={}):: Optimize hyperparameters for the imputation algorithm.

__init__(incomp_data)[source]¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = ''¶

impute(params=None)[source]¶

Abstract method to perform the imputation. Must be implemented in subclasses.

Parameters¶

paramsdict, optional: Dictionary of algorithm parameters (default is None).

Raises¶

NotImplementedError: If the method is not implemented by a subclass.

logs = True¶

score(input_data, recov_data=None, downstream=None)[source]¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class imputegap.recovery.imputation.Imputation[source]¶

Bases: object

A class containing static methods for evaluating and running imputation algorithms on time series data.

Methods¶

evaluate_params(input_data, incomp_data, configuration, algorithm=”cdrec”):: Evaluate imputation performance using given parameters and algorithm.

class DeepLearning[source]¶

Bases: object

A class containing imputation algorithms for deep learning-based methods.

Subclasses¶

MRNN : Imputation method using Multi-directional Recurrent Neural Networks (MRNN). BRITS :

Imputation method using Bidirectional Recurrent Imputation for Time Series.

DeepMVI :: Imputation method using Deep Multivariate Imputation.
MPIN :: Imputation method using Multi-attribute Sensor Data Streams via Message Propagation.
PRISTI :: Imputation method using A Conditional Diffusion Framework for Spatiotemporal Imputation.
MissNet :: Imputation method using Mining of Switching Sparse Networks for Missing Value Imputation.
GAIN :: Imputation method using Generative Adversarial Nets for missing data imputation.
GRIN :: Imputation method using Graph Neural Networks for Multivariate Time Series Imputation.
BayOTIDE :: Imputation method using Bayesian Online Multivariate Time Series Imputation with functional decomposition.
HKMF_T :: Imputation method using Hankel Matrix Factorization to recover from blackouts in tagged time series.

class BRITS(incomp_data)[source]¶

Bases: BaseImputer

BRITS class to impute missing values using Bidirectional Recurrent Imputation for Time Series

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the BRITS algorithm.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'brits'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using the BRITS algorithm.

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the BRITS algorithm, if None, default ones are loaded.

Algorithm parameters:

modelstr
Specifies the type of model to use for the imputation. Options may include predefined models like ‘brits’, ‘brits-i’ or ‘brits_i_univ’.
epochint
Number of epochs for training the model. Determines how many times the algorithm processes the entire dataset during training.
batch_sizeint
Size of the batches used during training. Larger batch sizes can speed up training but may require more memory.
nbr_featuresint
Number of features, dimension in the time series.
hidden_layerint
Number of units in the hidden layer of the model. Controls the capacity of the neural network to learn complex patterns.

Returns¶

selfBRITS: The object with recov_data set.

Example¶

>>> brits_imputer = Imputation.DeepLearning.BRITS(incomp_data)
>>> brits_imputer.impute()  # default parameters for imputation > or
>>> brits_imputer.impute(params={"model": "brits", "epoch": 2, "batch_size": 10, "nbr_features": 1, "hidden_layer": 64})  # user-defined > or
>>> brits_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "ray_tune"})  # automl with ray_tune
>>> recov_data = brits_imputer.recov_data

References¶

Cao, W., Wang, D., Li, J., Zhou, H., Li, L. & Li, Y. BRITS: Bidirectional Recurrent Imputation for Time Series. Advances in Neural Information Processing Systems, 31 (2018). https://proceedings.neurips.cc/paper_files/paper/2018/file/734e6bfcd358e25ac1db0a4241b95651-Paper.pdf

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class BayOTIDE(incomp_data)[source]¶

Bases: BaseImputer

BayOTIDE class to impute missing values using Bayesian Online Multivariate Time series Imputation with functional decomposition

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the BayOTIDE

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'bay_otide'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using the Multivariate Time Series Imputation by Deep Learning

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the BayOTIDE algorithm or Auto-ML configuration, if None, default ones are loaded.

Algorithm parameters:

K_trendint, (optional) (default: 20): Number of trend factors.
K_seasonint, (optional) (default: 2): Number of seasonal factors.
n_seasonint, (optional) (default: 5): Number of seasonal components per factor.
K_biasint, (optional) (default: 1): Number of bias factors.
time_scalefloat, (optional) (default: 1): Time scaling factor.
a0float, (optional) (default: 0.6): Hyperparameter for prior distribution.
b0float, (optional) (default: 2.5): Hyperparameter for prior distribution.
vfloat, (optional) (default: 0.5): Variance parameter.
configdict, (optional) (default: None): Dictionary containing all configuration parameters, that will replace all other parameters (see documentation).
argsobject, (optional) (default: None): Arguments containing all configuration parameters, that will replace all other parameters (see documentation).

Returns¶

selfBayOTIDE: BayOTIDE object with recov_data set.

Example¶

>>> bay_otide_imputer = Imputation.DeepLearning.BayOTIDE(incomp_data)
>>> bay_otide_imputer.impute()  # default parameters for imputation > or
>>> bay_otide_imputer.impute(user_def=True, params={"K_trend":20, "K_season":2, "n_season":5, "K_bias":1, "time_scale":1, "a0":0.6, "b0":2.5, "v":0.5})  # user defined> or
>>> bay_otide_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "ray_tune"})  # auto-ml with ray_tune
>>> recov_data = bay_otide_imputer.recov_data

References¶

S. Fang, Q. Wen, Y. Luo, S. Zhe, and L. Sun, “BayOTIDE: Bayesian Online Multivariate Time Series Imputation with Functional Decomposition,” CoRR, vol. abs/2308.14906, 2024. [Online]. Available: https://arxiv.org/abs/2308.14906. https://github.com/xuangu-fang/BayOTIDE

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class DeepMVI(incomp_data)[source]¶

Bases: BaseImputer

DeepMVI class to impute missing values using Deep Multivariate Imputation

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the DeepMVI algorithm.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'deep_mvi'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using the DeepMVI algorithm.

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the BRITS algorithm, if None, default ones are loaded.

Algorithm parameters:

max_epochint, optional
Limit of training epoch (default is 1000)

patienceint, optional: Number of threshold error that can be crossed during the training (default is 2)
lrfloat, optional: Learning rate of the training (default is 0.001)

Returns¶

selfDeepMVI: The object with recov_data set.

Example¶

>>> deep_mvi_imputer = Imputation.DeepLearning.DeepMVI(incomp_data)
>>> deep_mvi_imputer.impute()  # default parameters for imputation > or
>>> deep_mvi_imputer.impute(params={"max_epoch": 10, "patience": 2})  # user-defined > or
>>> deep_mvi_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "ray_tune"})  # automl with ray_tune
>>> recov_data = deep_mvi_imputer.recov_data

References¶

P. Bansal, P. Deshpande, and S. Sarawagi. Missing value imputation on multidimensional time series. arXiv preprint arXiv:2103.01600, 2023 https://github.com/pbansal5/DeepMVI

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class GAIN(incomp_data)[source]¶

Bases: BaseImputer

GAIN class to impute missing values using Missing Data Imputation using Generative Adversarial Nets,

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the GAIN algorithm.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'gain'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using the GAIN algorithm.

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the GAIN algorithm or Auto-ML configuration, if None, default ones are loaded.

Algorithm parameters:

batch_sizeint, optional: Number of samples in each mini-batch during training. Default is 32.
hint_ratefloat, optional: Probability of providing hints for the missing data during training. Default is 0.9.
alphafloat, optional: Hyperparameter that controls the balance between the adversarial loss and the reconstruction loss. Default is 10.
epochint, optional: Number of training epochs. Default is 100.

logs : bool, optional

Returns¶

selfGAIN: GAIN object with recov_data set.

Example¶

>>> gain_imputer = Imputation.DeepLearning.GAIN(incomp_data)
>>> gain_imputer.impute()  # default parameters for imputation > or
>>> gain_imputer.impute(user_def=True, params={"batch_size":32, "hint_rate":0.9, "alpha":10, "epoch":100})  # user defined> or
>>> gain_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "ray_tune"})  # auto-ml with ray_tune
>>> recov_data = gain_imputer.recov_data

References¶

Yoon, J. Jordon, and M. van der Schaar, “GAIN: Missing Data Imputation using Generative Adversarial Nets,” CoRR, vol. abs/1806.02920, 2018. Available: http://arxiv.org/abs/1806.02920.

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class GRIN(incomp_data)[source]¶

Bases: BaseImputer

GRIN class to impute missing values using MULTIVARIATE TIME SERIES IMPUTATION BY GRAPH NEURAL NETWORKS.

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the GRIN

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'grin'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using the Multivariate Time Series Imputation by Graph Neural Networks

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the GRIN algorithm or Auto-ML configuration, if None, default ones are loaded.

Algorithm parameters:

d_hiddenint, optional, default=32: The number of hidden units in the model’s recurrent and graph layers.
lrfloat, optional, default=0.001: Learning rate for the optimizer.
batch_sizeint, optional, default=32: The number of samples per training batch.
windowint, optional, default=10: The size of the time window used for modeling temporal dependencies.
alphafloat, optional, default=10.0: The weight assigned to the adversarial loss term during training.
patienceint, optional, default=4: Number of epochs without improvement before early stopping is triggered.
epochsint, optional, default=20: The maximum number of training epochs.
workersint, optional, default=2: The number of worker processes for data loading.

Returns¶

selfGRIN: GRIN object with recov_data set.

Example¶

>>> grin_imputer = Imputation.DeepLearning.GRIN(incomp_data)
>>> grin_imputer.impute()  # default parameters for imputation > or
>>> grin_imputer.impute(user_def=True, params={"d_hidden":32, "lr":0.001, "batch_size":32, "window":1, "alpha":10.0, "patience":4, "epochs":20, "workers":2})  # user defined> or
>>> grin_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "ray_tune"})  # auto-ml with ray_tune
>>> recov_data = grin_imputer.recov_data

References¶

A. Cini, I. Marisca, and C. Alippi, “Multivariate Time Series Imputation by Graph Neural Networks,” CoRR, vol. abs/2108.00298, 2021 https://github.com/Graph-Machine-Learning-Group/grin

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class HKMF_T(incomp_data)[source]¶

Bases: BaseImputer

HKMF-T class to impute missing values using Recover From Blackouts in Tagged Time Series With Hankel Matrix Factorization

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the HKMF-T

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'hkmf_t'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using Recover From Blackouts in Tagged Time Series With Hankel Matrix Factorization

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the BayOTIDE algorithm or Auto-ML configuration, if None, default ones are loaded.

Algorithm parameters:

tagsnumpy.ndarray, optional
An array containing tags that provide additional structure or metadata about the input data. If None, no tags are used (default is None).

data_nameslist of str, optional: List of names corresponding to each row or column of the dataset for interpretability. If None, names are not used (default is None).
epochint, optional: The maximum number of training epochs for the Hankel Matrix Factorization algorithm. If convergence is reached earlier, the process stops (default is 10).

Returns¶

selfHKMF-T: HKMF-T object with recov_data set.

Example¶

>>> hkmf_t_imputer = Imputation.DeepLearning.HKMF_T(incomp_data)
>>> hkmf_t_imputer.impute()  # default parameters for imputation > or
>>> hkmf_t_imputer.impute(user_def=True, params={"tags":None, "data_names":None, "epoch":5})  # user defined> or
>>> hkmf_t_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "ray_tune"})  # auto-ml with ray_tune
>>> recov_data = hkmf_t_imputer.recov_data

References¶

L. Wang, S. Wu, T. Wu, X. Tao and J. Lu, “HKMF-T: Recover From Blackouts in Tagged Time Series With Hankel Matrix Factorization,” in IEEE Transactions on Knowledge and Data Engineering, vol. 33, no. 11, pp. 3582-3593, 1 Nov. 2021, doi: 10.1109/TKDE.2020.2971190. keywords: {Time series analysis;Matrix decomposition;Market research;Meteorology;Sparse matrices;Indexes;Software;Tagged time series;missing value imputation;blackouts;hankel matrix factorization} https://github.com/wangliang-cs/hkmf-t?tab=readme-ov-file

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class MPIN(incomp_data)[source]¶

Bases: BaseImputer

MPIN class to impute missing values using Multi-attribute Sensor Data Streams via Message Propagation algorithm.

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the MPIN algorithm.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'mpin'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using the MPIN algorithm.

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the BRITS algorithm, if None, default ones are loaded.

Algorithm parameters:

incre_modestr, optional: The mode of incremental learning. Options are: ‘alone’, ‘data’, ‘state’, ‘state+transfer’, ‘data+state’, ‘data+state+transfer’ (default is “alone”).
windowint, optional: The size of the sliding window for processing data streams (default is 2).
kint, optional: The number of neighbors to consider during message propagation (default is 10).
lrfloat, optional: The learning rate for optimizing the message propagation algorithm (default is 0.01).
weight_decayfloat, optional: The weight decay (regularization) term to prevent overfitting during training (default is 0.1).
epochsint, optional: The number of epochs to run the training process (default is 200).
num_of_iterationint, optional: The number of iteration of the whole training (default is 5).
threfloat, optional: The threshold for considering a missing value as imputed (default is 0.25).
basestr, optional: The base model used for graph representation and message propagation. Common options include “SAGE” and “GCN” (default is “SAGE”).

Returns¶

selfMPIN: The object with recov_data set.

Example¶

>>> mpin_imputer = Imputation.DeepLearning.MPIN(incomp_data)
>>> mpin_imputer.impute()  # default parameters for imputation > or
>>> mpin_imputer.impute(params={"incre_mode": "data+state", "window": 1, "k": 15, "learning_rate": 0.001, "weight_decay": 0.2, "epochs": 6, "num_of_iteration": 6, "threshold": 0.50, "base": "GCN"})  # user-defined > or
>>> mpin_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "ray_tune"})  # automl with ray_tune
>>> recov_data = mpin_imputer.recov_data

References¶

Li, X., Li, H., Lu, H., Jensen, C.S., Pandey, V. & Markl, V. Missing Value Imputation for Multi-attribute Sensor Data Streams via Message Propagation (Extended Version). arXiv (2023). https://arxiv.org/abs/2311.07344 https://github.com/XLI-2020/MPIN

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class MRNN(incomp_data)[source]¶

Bases: BaseImputer

MRNN class to impute missing values using Multi-directional Recurrent Neural Networks (MRNN).

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the MRNN algorithm.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'mrnn'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using the MRNN algorithm.

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the MRNN algorithm, if None, default ones are loaded.

Algorithm parameters:

hidden_dimint
The number of hidden units in the neural network.
learning_ratefloat
Learning rate for training the neural network.
iterationsint
Number of iterations for training.
sequence_lengthint
The length of the sequences used in the recurrent neural network.

Returns¶

selfMRNN: The object with recov_data set.

Example¶

>>> mrnn_imputer = Imputation.DeepLearning.MRNN(incomp_data)
>>> mrnn_imputer.impute()  # default parameters for imputation > or
>>> mrnn_imputer.impute(user_def=True, params={'hidden_dim': 10, 'learning_rate':0.01, 'iterations':50, 'sequence_length': 7})  # user-defined > or
>>> mrnn_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "bayesian", "options": {"n_calls": 2}})  # automl with bayesian
>>> recov_data = mrnn_imputer.recov_data

References¶

Yoon, W. R. Zame and M. van der Schaar, “Estimating Missing Data in Temporal Data Streams Using Multi-Directional Recurrent Neural Networks,” in IEEE Transactions on Biomedical Engineering, vol. 66, no. 5, pp. 1477-1490, May 2019, doi: 10.1109/TBME.2018.2874712. keywords: {Time measurement;Interpolation;Estimation;Medical diagnostic imaging;Correlation;Recurrent neural networks;Biomedical measurement;Missing data;temporal data streams;imputation;recurrent neural nets}

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class MissNet(incomp_data)[source]¶

Bases: BaseImputer

MissNet class to impute missing values using Mining of Switching Sparse Networks for Missing Value: Imputation in Multivariate Time Series.

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the MissNet algorithm.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'miss_net'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using the MissNet algorithm.

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the MissNet algorithm, if None, default ones are loaded.

Algorithm parameters:

alphafloat, optional
Trade-off parameter controlling the contribution of contextual matrix and time-series. If alpha = 0, network is ignored. (default 0.5)

betafloat, optional
Regularization parameter for sparsity. (default 0.1)

Lint, optional
Hidden dimension size. (default 10)

n_clint, optional
Number of clusters. (default 1)

max_iterationint, optional
Maximum number of iterations for convergence. (default 20)

tolfloat, optional
Tolerance for early stopping criteria. (default 5)

random_initbool, optional
Whether to use random initialization for latent variables. (default False)

Returns¶

selfMissNet: The object with recov_data set.

Example¶

>>> miss_net_imputer = Imputation.DeepLearning.MissNet(incomp_data)
>>> miss_net_imputer.impute()  # default parameters for imputation > or
>>> miss_net_imputer.impute(user_def=True, params={'alpha': 0.5, 'beta':0.1, 'L':10, 'n_cl': 1, 'max_iteration':20, 'tol':5, 'random_init':False})  # user-defined > or
>>> miss_net_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "ray_tune"})  # auto-ml with ray_tune
>>> recov_data = miss_net_imputer.recov_data

References¶

Kohei Obata, Koki Kawabata, Yasuko Matsubara, and Yasushi Sakurai. 2024. Mining of Switching Sparse Networks for Missing Value Imputation in Multivariate Time Series. In Proceedings of the 30th ACM SIGKDD Conference on Knowledge Discovery and Data Mining (KDD ‘24). Association for Computing Machinery, New York, NY, USA, 2296–2306. https://doi.org/10.1145/3637528.3671760 https://github.com/KoheiObata/MissNet/tree/main

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class PRISTI(incomp_data)[source]¶

Bases: BaseImputer

PRISTI class to impute missing values using A Conditional Diffusion Framework for Spatiotemporal Imputation algorithm.

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the PRISTI algorithm.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'pristi'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using the PRISTI algorithm.

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the BRITS algorithm, if None, default ones are loaded.

Algorithm parameters:

target_strategystr, optional: The strategy to use for targeting missing values. Options include: “hybrid”, “random”, “historical” (default is “hybrid”).
unconditionalbool, optional: Whether to use an unconditional imputation model (default is True). If False, conditional imputation models are used, depending on available data patterns.
seedint, optional: Random seed for reproducibility (default is 42).
devicestr, optional: The device to perform computation on, e.g., “cpu” or “cuda” (default is “cpu”).

Returns¶

selfPRISTI: The object with recov_data set.

Example¶

>>> pristi_imputer = Imputation.DeepLearning.PRISTI(incomp_data)
>>> pristi_imputer.impute()  # default parameters for imputation > or
>>> pristi_imputer.impute(params={"target_strategy":"hybrid", "unconditional":True, "seed":42, "device":"cpu"})  # user-defined > or
>>> pristi_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "ray_tune"})  # automl with ray_tune
>>> recov_data = pristi_imputer.recov_data

References¶

M. Liu, H. Huang, H. Feng, L. Sun, B. Du and Y. Fu, “PriSTI: A Conditional Diffusion Framework for Spatiotemporal Imputation,” 2023 IEEE 39th International Conference on Data Engineering (ICDE), Anaheim, CA, USA, 2023, pp. 1927-1939, doi: 10.1109/ICDE55515.2023.00150. https://github.com/LMZZML/PriSTI

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class MachineLearning[source]¶

Bases: object

A class containing imputation algorithms for pattern-based methods.

Subclasses¶

MissForest :: Imputation method using Miss Forest (MissForest)
MICE :: Imputation method using Multivariate imputation of chained equations (MICE).
IIM :: Imputation method using Iterative Imputation with Metric Learning (IIM).
XGBOOST :: Imputation method using Scalable Tree Boosting System (XGBOOST).

class IIM(incomp_data)[source]¶

Bases: BaseImputer

IIM class to impute missing values using Iterative Imputation with Metric Learning (IIM).

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the IIM algorithm.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'iim'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using the IIM algorithm.

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the IIM algorithm, if None, default ones are loaded.

learning_neighboursint
Number of nearest neighbors for learning.
algo_codestr
Unique code for the algorithm configuration.

Returns¶

selfIIM: The object with recov_data set.

Example¶

>>> iim_imputer = Imputation.MachineLearning.IIM(incomp_data)
>>> iim_imputer.impute()  # default parameters for imputation > or
>>> iim_imputer.impute(user_def=True, params={'learning_neighbors': 10})  # user-defined  > or
>>> iim_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "bayesian", "options": {"n_calls": 2}})  # automl with bayesian
>>> recov_data = iim_imputer.recov_data

References¶

A. Zhang, S. Song, Y. Sun and J. Wang, “Learning Individual Models for Imputation,” 2019 IEEE 35th International Conference on Data Engineering (ICDE), Macao, China, 2019, pp. 160-171, doi: 10.1109/ICDE.2019.00023. keywords: {Data models;Adaptation models;Computational modeling;Predictive models;Numerical models;Aggregates;Regression tree analysis;Missing values;Data imputation}

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class MICE(incomp_data)[source]¶

Bases: BaseImputer

MICE class to impute missing values with Multivariate imputation of chained equations (MICE).

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the STMVL algorithm.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'mice'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using the MICE algorithm.

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the STMVL algorithm, if None, default ones are loaded.

Algorithm parameters:

max_iterint, optional: Maximum number of imputation rounds to perform before returning the imputations computed during the final round. (default is 3).
tolfloat, optional: Tolerance of the stopping condition. (default is 0.001).
initial_strategystr, optional: Which strategy to use to initialize the missing values. {‘mean’, ‘median’, ‘most_frequent’, ‘constant’} (default is “means”).
seedint, optional: The seed of the pseudo random number generator to use. Randomizes selection of estimator features (default is 42).

Returns¶

selfMICE: The object with recov_data set.

Example¶

>>> mice_imputer = Imputation.MachineLearning.MICE(incomp_data)
>>> mice_imputer.impute()  # default parameters for imputation > or
>>> mice_imputer.impute(user_def=True, params={"max_iter":3, "tol":0.001, "initial_strategy":"mean", "seed": 42})  # user defined > or
>>> mice_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "ray_tune"})  # automl with ray_tune
>>> recov_data = mice_imputer.recov_data

References¶

P. Royston and I. R. White. Multiple Imputation by Chained Equations (MICE): Implementation in Stata. Journal of Statistical Software, 45(4):1–20, 2011. Available: https://www.jstatsoft.org/index.php/jss/article/view/v045i04. Stef van Buuren, Karin Groothuis-Oudshoorn (2011). “mice: Multivariate Imputation by Chained Equations in R”. Journal of Statistical Software 45: 1-67. S. F. Buck, (1960). “A Method of Estimation of Missing Values in Multivariate Data Suitable for use with an Electronic Computer”. Journal of the Royal Statistical Society 22(2): 302-306. https://scikit-learn.org/stable/modules/generated/sklearn.impute.IterativeImputer.html#sklearn.impute.IterativeImputer

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class MissForest(incomp_data)[source]¶

Bases: BaseImputer

MissForest class to impute missing values with Miss Forest.

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the Miss Forest algorithm.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'miss_forest'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using the Miss Forest algorithm.

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the miss forest algorithm, if None, default ones are loaded.

Algorithm parameters:

alphafloat, optional: Trade-off parameter controlling the contribution of contextual matrix and time-series. If alpha = 0, network is ignored. (default 0.5)
betafloat, optional: Regularization parameter for sparsity. (default 0.1)
Lint, optional: Hidden dimension size. (default 10)
n_clint, optional: Number of clusters. (default 1)
max_iterationint, optional: Maximum number of iterations for convergence. (default 20)
tolfloat, optional: Tolerance for early stopping criteria. (default 5)
random_initbool, optional: Whether to use random initialization for latent variables. (default False)

Returns¶

selfMissForest: The object with recov_data set.

Example¶

>>> mf_imputer = Imputation.MachineLearning.MissForest(incomp_data)
>>> mf_imputer.impute()  # default parameters for imputation > or
>>> mf_imputer.impute(user_def=True, params={"n_estimators":10, "max_iter":3, "max_features":"sqrt", "seed": 42})  # user defined > or
>>> mf_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "ray_tune"})  # automl with ray_tune
>>> recov_data = mf_imputer.recov_data

References¶

Daniel J. Stekhoven, Peter Bühlmann, MissForest—non-parametric missing value imputation for mixed-type data, Bioinformatics, Volume 28, Issue 1, January 2012, Pages 112–118, https://doi.org/10.1093/bioinformatics/btr597 https://github.com/yuenshingyan/MissForest https://pypi.org/project/MissForest/

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class XGBOOST(incomp_data)[source]¶

Bases: BaseImputer

XGBOOST class to impute missing values with Extreme Gradient Boosting (XGBOOST).

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the XGBOOST algorithm.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'xgboost'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using the XGBOOST algorithm.

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the STMVL algorithm, if None, default ones are loaded.

Algorithm parameters:

n_estimatorsint, optional: The number of trees in the Random Forest model used for imputation (default is 10).
seedint, optional: The seed of the pseudo random number generator to use. Randomizes selection of estimator features (default is 42).

Returns¶

selfXGBOOST: The object with recov_data set.

Example¶

>>> mxgboost_imputer = Imputation.MachineLearning.MICE(incomp_data)
>>> mxgboost_imputer.impute()  # default parameters for imputation > or
>>> mxgboost_imputer.impute(user_def=True, params={"n_estimators":3, "seed": 42})  # user defined > or
>>> mxgboost_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "ray_tune"})  # automl with ray_tune
>>> recov_data = mxgboost_imputer.recov_data

References¶

Tianqi Chen and Carlos Guestrin. 2016. XGBoost: A Scalable Tree Boosting System. In Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (KDD ‘16). Association for Computing Machinery, New York, NY, USA, 785–794. https://doi.org/10.1145/2939672.2939785 https://dl.acm.org/doi/10.1145/2939672.2939785 https://medium.com/@tzhaonj/imputing-missing-data-using-xgboost-802757cace6d

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class MatrixCompletion[source]¶

Bases: object

A class containing imputation algorithms for matrix decomposition methods.

Subclasses¶

CDRec :: Imputation method using Centroid Decomposition.
IterativeSVD :: Imputation method using Iterative Singular Value Decomposition.
GROUSE :: Imputation method using Grassmannian Rank-One Update Subspace Estimation.
ROSL :: Imputation method using Robust Online Subspace Learning.
SoftImpute :: Imputation method using Soft Impute algorithm.
SPIRIT :: Imputation method using Streaming Pattern Discovery in Multiple Time-Series.
SVT :: Imputation method using Singular Value Thresholding algorithm.
TRMF :: Imputation method using Temporal Regularized Matrix Factorization.

class CDRec(incomp_data)[source]¶

Bases: BaseImputer

CDRec class to impute missing values using Centroid Decomposition (CDRec).

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the CDRec algorithm.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'cdrec'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using the CDRec algorithm.

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the CDRec algorithm or Auto-ML configuration, if None, default ones are loaded.

Algorithm parameters:

rankint
Rank of matrix reduction, which should be higher than 1 and smaller than the number of series.
epsilonfloat
The learning rate used for the algorithm.
iterationsint
The number of iterations to perform.

Auto-ML parameters:

input_datanumpy.ndarray
The original time series dataset without contamination.
optimizerstr
The optimizer to use for parameter optimization. Valid values are “bayesian”, “greedy”, “pso”, or “sh”.
optionsdict, optional
Optional parameters specific to the optimizer.

Bayesian:
- n_callsint, optional
  Number of calls to the objective function. Default is 3.
- metricslist, optional
  List of selected metrics to consider for optimization. Default is [“RMSE”].
- n_random_startsint, optional
  Number of initial calls to the objective function, from random points. Default is 50.
- acq_funcstr, optional
  Acquisition function to minimize over the Gaussian prior. Valid values: ‘LCB’, ‘EI’, ‘PI’, ‘gp_hedge’ (default is ‘gp_hedge’).
Greedy:
- n_callsint, optional
  Number of calls to the objective function. Default is 3.
- metricslist, optional
  List of selected metrics to consider for optimization. Default is [“RMSE”].
PSO:
- n_particlesint, optional
  Number of particles used.
- c1float, optional
  PSO learning coefficient c1 (personal learning).
- c2float, optional
  PSO learning coefficient c2 (global learning).
- wfloat, optional
  PSO inertia weight.
- iterationsint, optional
  Number of iterations for the optimization.
- n_processesint, optional
  Number of processes during optimization.
Successive Halving (SH):
- num_configsint, optional
  Number of configurations to try.
- num_iterationsint, optional
  Number of iterations to run the optimization.
- reduction_factorint, optional
  Reduction factor for the number of configurations kept after each iteration.
RAY TUNE (ray_tune):
- n_callsint, optional
  Number of calls to the objective function (default is 10).
- max_concurrent_trialsint, optional
  Number of trials run in parallel, related to your total memory / cpu / gpu (default is 2). Please increase the value if you have more resources

Returns¶

selfCDRec: CDRec object with recov_data set.

Example¶

>>> cdrec_imputer = Imputation.MatrixCompletion.CDRec(incomp_data)
>>> cdrec_imputer.impute()  # default parameters for imputation > or
>>> cdrec_imputer.impute(user_def=True, params={'rank': 5, 'epsilon': 0.01, 'iterations': 100})  # user-defined > or
>>> cdrec_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "bayesian", "options": {"n_calls": 2}})  # automl with bayesian
>>> recov_data = cdrec_imputer.recov_data

References¶

Khayati, M., Cudré-Mauroux, P. & Böhlen, M.H. Scalable recovery of missing blocks in time series with high and low cross-correlations. Knowl Inf Syst 62, 2257–2280 (2020). https://doi.org/10.1007/s10115-019-01421-7

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class GROUSE(incomp_data)[source]¶

Bases: BaseImputer

GROUSE class to impute missing values using GROUSE.

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the GROUSE algorithm.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'grouse'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using the GROUSE algorithm.

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the GROUSE algorithm or Auto-ML configuration, if None, default ones are loaded.

Algorithm parameters:

max_rankint
Max rank of matrix reduction, which should be higher than 1 and smaller than the number of series.

Returns¶

selfGROUSE: GROUSE object with recov_data set.

Example¶

>>> grouse_imputer = Imputation.MatrixCompletion.GROUSE(incomp_data)
>>> grouse_imputer.impute()  # default parameters for imputation > or
>>> grouse_imputer.impute(params={'max_rank': 5}) # user-defined  > or
>>> grouse_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "ray_tune"})  # automl with ray_tune
>>> recov_data = grouse_imputer.recov_data

References¶

Zhang and L. Balzano. Global convergence of a grassmannian gradient descent algorithm for subspace estimation. In Proceedings of the 19th International Conference on Artificial Intelligence and Statistics, AISTATS 2016, Cadiz, Spain, May 9-11, 2016, pages 1460–1468, 2016.

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class IterativeSVD(incomp_data)[source]¶

Bases: BaseImputer

IterativeSVD class to impute missing values using Iterative SVD.

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the Iterative SDV algorithm.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'iterative_svd'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using the Iterative SVD algorithm.

Parameters¶

user_defbool, optional
Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the Iterative SVD algorithm or Auto-ML configuration, if None, default ones are loaded.

Algorithm parameters:

rankint
Rank of matrix reduction, which should be higher than 1 and smaller than the number of series.

Returns¶

selfIterativeSVD: IterativeSVD object with recov_data set.

Example¶

>>> i_svd_imputer = Imputation.MatrixCompletion.IterativeSVD(incomp_data)
>>> i_svd_imputer.impute()  # default parameters for imputation > or
>>> i_svd_imputer.impute(params={'rank': 5}) # user-defined  > or
>>> i_svd_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "ray_tune"})  # automl with ray_tune
>>> recov_data = i_svd_imputer.recov_data

References¶

Olga Troyanskaya, Michael Cantor, Gavin Sherlock, Pat Brown, Trevor Hastie, Robert Tibshirani, David Botstein, Russ B. Altman, Missing value estimation methods for DNA microarrays , Bioinformatics, Volume 17, Issue 6, June 2001, Pages 520–525, https://doi.org/10.1093/bioinformatics/17.6.520

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class ROSL(incomp_data)[source]¶

Bases: BaseImputer

ROSL class to impute missing values using Robust Online Subspace Learning algorithm.

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the ROSL algorithm.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'rosl'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using the ROSL algorithm.

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the ROSL algorithm or Auto-ML configuration, if None, default ones are loaded.

Algorithm parameters:

rankint
The rank of the low-dimensional subspace for matrix decomposition. Must be greater than 0 and less than or equal to the number of columns in the matrix.

regularizationfloat
The regularization parameter to control the trade-off between reconstruction accuracy and robustness. Higher values enforce sparsity or robustness against noise in the data.

Returns¶

selfROSL: ROSL object with recov_data set.

Example¶

>>> rosl_imputer = Imputation.MatrixCompletion.ROSL(incomp_data)
>>> rosl_imputer.impute()  # default parameters for imputation > or
>>> rosl_imputer.impute(params={'rank': 5, 'regularization': 10}) # user-defined  > or
>>> rosl_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "ray_tune"})  # automl with ray_tune
>>> recov_data = rosl_imputer.recov_data

References¶

Shu, F. Porikli, and N. Ahuja. Robust orthonormal subspace learning: Efficient recovery of corrupted low-rank matrices. In 2014 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2014, Columbus, OH, USA, June 23-28, 2014, pages 3874–3881, 2014.

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class SPIRIT(incomp_data)[source]¶

Bases: BaseImputer

SPIRIT class to impute missing values using SPIRIT algorithm.

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the SPIRIT algorithm.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'spirit'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using the SPIRIT algorithm.

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the SPIRIT algorithm or Auto-ML configuration, if None, default ones are loaded.

Algorithm parameters:

kint: The number of eigencomponents (principal components) to retain for dimensionality reduction. Example: 2, 5, 10.
wint: The window size for capturing temporal dependencies. Example: 5 (short-term), 20 (long-term).
lambda_valuefloat: The forgetting factor controlling how quickly past data is “forgotten”. Example: 0.8 (fast adaptation), 0.95 (stable systems).

Returns¶

selfSPIRIT: SPIRIT object with recov_data set.

Example¶

>>> spirit_imputer = Imputation.MatrixCompletion.SPIRIT(incomp_data)
>>> spirit_imputer.impute()  # default parameters for imputation > or
>>> spirit_imputer.impute(params={'k': 2, 'w': 5, 'lambda_value': 0.85}) # user-defined  > or
>>> spirit_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "ray_tune"})  # automl with ray_tune
>>> recov_data = spirit_imputer.recov_data

References¶

Papadimitriou, J. Sun, and C. Faloutsos. Streaming pattern discovery in multiple time-series. In Proceedings of the 31st International Conference on Very Large Data Bases, Trondheim, Norway, August 30 - September 2, 2005, pages 697–708, 2005.

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class SVT(incomp_data)[source]¶

Bases: BaseImputer

SVT class to impute missing values using Singular Value Thresholding algorithm.

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the SVT algorithm.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'svt'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using the SVT algorithm.

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the SVT algorithm or Auto-ML configuration, if None, default ones are loaded.

Algorithm parameters:

taufloat: The thresholding parameter for singular values. Controls how singular values are shrunk during the decomposition process. Larger values encourage a sparser, lower-rank solution, while smaller values retain more detail.

Returns¶

selfSVT: SVT object with recov_data set.

Example¶

>>> svt_imputer = Imputation.MatrixCompletion.SVT(incomp_data)
>>> svt_imputer.impute()  # default parameters for imputation > or
>>> svt_imputer.impute(params={'tau': 1}) # user-defined  > or
>>> svt_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "ray_tune"})  # automl with ray_tune
>>> recov_data = svt_imputer.recov_data

References¶

Cai, E. J. Candès, and Z. Shen. A singular value thresholding algorithm for matrix completion. SIAM Journal on Optimization, 20(4):1956–1982, 2010. [8] J. Cambronero, J. K. Feser, M. J. Smith, and

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class SoftImpute(incomp_data)[source]¶

Bases: BaseImputer

SoftImpute class to impute missing values using Soft Impute algorithm.

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the Soft Impute algorithm.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'soft_impute'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using the Soft Impute algorithm.

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the Soft Impute algorithm or Auto-ML configuration, if None, default ones are loaded.

Algorithm parameters:

max_rankint
The max rank of the low-dimensional subspace for matrix decomposition. Must be greater than 0 and less than or equal to the number of columns in the matrix.

Returns¶

selfSoftImpute: SoftImpute object with recov_data set.

Example¶

>>> soft_impute_imputer = Imputation.MatrixCompletion.SoftImpute(incomp_data)
>>> soft_impute_imputer.impute()  # default parameters for imputation > or
>>> soft_impute_imputer.impute(params={'max_rank': 5}) # user-defined  > or
>>> soft_impute_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "ray_tune"})  # automl with ray_tune
>>> recov_data = soft_impute_imputer.recov_data

References¶

Mazumder, T. Hastie, and R. Tibshirani. Spectral regularization algorithms for learning large incomplete matrices. Journal of Machine Learning Research, 11:2287–2322, 2010.

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class TRMF(incomp_data)[source]¶

Bases: BaseImputer

TRMF class to impute missing values using Temporal Regularized Matrix Factorization.

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the TRMF algorithm.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'trmf'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using the TRMF algorithm.

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the TRMF algorithm or Auto-ML configuration, if None, default ones are loaded.

Algorithm parameters:

lagsarray-like, optional: Set of lag indices to use in model.
Kint, optional: Length of latent embedding dimension
lambda_ffloat, optional: Regularization parameter used for matrix F.
lambda_xfloat, optional: Regularization parameter used for matrix X.
lambda_wfloat, optional: Regularization parameter used for matrix W.
alphafloat, optional: Regularization parameter used for make the sum of lag coefficient close to 1. That helps to avoid big deviations when forecasting.
etafloat, optional: Regularization parameter used for X when undercovering autoregressive dependencies.
max_iterint, optional: Number of iterations of updating matrices F, X and W.
logsbool, optional: Whether to log the execution time (default is True).

Returns¶

selfTRMF: TRMF object with recov_data set.

Example¶

>>> trmf_imputer = Imputation.MatrixCompletion.SVT(incomp_data)
>>> trmf_imputer.impute()  # default parameters for imputation > or
>>> trmf_imputer.impute(params={"lags":[], "K":-1, "lambda_f":1.0, "lambda_x":1.0, "lambda_w":1.0, "eta":1.0, "alpha":1000.0, "max_iter":100}) # user-defined > or
>>> trmf_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "ray_tune"})  # automl with ray_tune
>>> recov_data = trmf_imputer.recov_data

References¶

H.-F. Yu, N. Rao, and I. S. Dhillon, “Temporal Regularized Matrix Factorization for High-dimensional Time Series Prediction,” in Advances in Neural Information Processing Systems, vol. 29, 2016. [Online]. Available: https://proceedings.neurips.cc/paper_files/paper/2016/file/85422afb467e9456013a2a51d4dff702-Paper.pdf

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class PatternSearch[source]¶

Bases: object

A class containing imputation algorithms for pattern-based methods.

Subclasses¶

STMVL :: Imputation method using Spatio-Temporal Matrix Variational Learning (STMVL).
DynaMMo :: Imputation method using Dynamic Multi-Mode modeling with Missing Observations algorithm (DynaMMo).
TKCM :: TKCM class to impute missing values using Tensor Kernelized Coupled Matrix Completion algorithm. (TKCM).

class DynaMMo(incomp_data)[source]¶

Bases: BaseImputer

DynaMMo class to impute missing values using Dynamic Multi-Mode modeling with Missing Observations algorithm.

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the DynaMMo algorithm.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'dynammo'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using the DynaMMo algorithm.

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the DynaMMo algorithm or Auto-ML configuration, if None, default ones are loaded.

Algorithm parameters:

hint
The time window (H) parameter for modeling temporal dynamics.

max_iterationint
The maximum number of iterations for the imputation process.

approximationbool
If True, enables faster approximate processing.

Returns¶

selfDynaMMo: DynaMMo object with recov_data set.

Example¶

>>> dynammo_imputer = Imputation.PatternSearch.DynaMMo(incomp_data)
>>> dynammo_imputer.impute()  # default parameters for imputation > or
>>> dynammo_imputer.impute(params={'h': 5, 'max_iteration': 100, 'approximation': True}) # user-defined  > or
>>> dynammo_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "ray_tune"})  # automl with ray_tune
>>> recov_data = dynammo_imputer.recov_data

References¶

Li, J. McCann, N. S. Pollard, and C. Faloutsos. Dynammo: mining and summarization of coevolving sequences with missing values. In Proceedings of the 15th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, Paris, France, June 28 - July 1, 2009, pages 507–516, 2009.

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class STMVL(incomp_data)[source]¶

Bases: BaseImputer

STMVL class to impute missing values using Spatio-Temporal Matrix Variational Learning (STMVL).

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the STMVL algorithm.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'stmvl'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using the STMVL algorithm.

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the STMVL algorithm, if None, default ones are loaded.

window_sizeint
The size of the temporal window for imputation.
gammafloat
Smoothing parameter for temporal weights.
alphafloat
Power for spatial weights.

Returns¶

selfSTMVL: The object with recov_data set.

Example¶

>>> stmvl_imputer = Imputation.PatternSearch.STMVL(incomp_data)
>>> stmvl_imputer.impute()  # default parameters for imputation > or
>>> stmvl_imputer.impute(user_def=True, params={'window_size': 7, 'learning_rate':0.01, 'gamma':0.85, 'alpha': 7})  # user-defined  > or
>>> stmvl_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "bayesian", "options": {"n_calls": 2}})  # automl with bayesian
>>> recov_data = stmvl_imputer.recov_data

References¶

Yi, X., Zheng, Y., Zhang, J., & Li, T. ST-MVL: Filling Missing Values in Geo-Sensory Time Series Data. School of Information Science and Technology, Southwest Jiaotong University; Microsoft Research; Shenzhen Institutes of Advanced Technology, Chinese Academy of Sciences.

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class TKCM(incomp_data)[source]¶

Bases: BaseImputer

TKCM class to impute missing values using Tensor Kernelized Coupled Matrix Completion algorithm.

Methods¶

impute(self, user_def=True, params=None):: Perform imputation using the TKCM algorithm.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'tkcm'¶

impute(user_def=True, params=None)[source]¶

Perform imputation using the TKCM algorithm.

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the TKCM algorithm or Auto-ML configuration, if None, default ones are loaded.

Algorithm parameters:

rankint: The rank for matrix decomposition (must be greater than 1 and smaller than the number of series).

Returns¶

selfTKCM: TKCM object with recov_data set.

Example¶

>>> tkcm_imputer = Imputation.PatternSearch.TKCM(incomp_data)
>>> tkcm_imputer.impute()  # default parameters for imputation > or
>>> tkcm_imputer.impute(params={'rank': 5})  # user-defined > or
>>> tkcm_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "ray_tune"})  # automl with ray_tune
>>> recov_data = tkcm_imputer.recov_data

References¶

Wellenzohn, M. H. Böhlen, A. Dignös, J. Gamper, and H. Mitterer. Continuous imputation of missing values in streams of pattern-determining time series. In Proceedings of the 20th International Conference on Extending Database Technology, EDBT 2017, Venice, Italy, March 21-24, 2017., pages 330–341, 2017.

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class Statistics[source]¶

Bases: object

A class containing specific imputation algorithms for statistical methods.

Subclasses¶

ZeroImpute :: Imputation method that replaces missing values with zeros.
MinImpute :: Imputation method that replaces missing values with the minimum value of the ground truth.
MeanImputeBySeries :: Imputation method that replaces missing values with the minimum value of the ground truth by series.
Interpolation :: Imputation method that replaces missing values with the Interpolation
KNN :: Imputation method that replaces missing values with KNN logic

class Interpolation(incomp_data)[source]¶

Bases: BaseImputer

Interpolation class to impute missing values with interpolation-based algorithm

Methods¶

impute(self, params=None):: Perform imputation by replacing missing values with interpolation-based algorithm

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'interpolation'¶

impute(user_def=True, params=None)[source]¶

Impute missing values by replacing them with the interpolation-based algorithm

Parameters¶

user_defbool, optional: Whether to use user-defined or default parameters (default is True).
paramsdict, optional: Parameters of the interpolation algorithm, if None, default ones are loaded.

Returns¶

selfInterpolation: The object with recov_data set.

Example¶

>>> interpolation_imputer = Imputation.Statistics.Interpolation(incomp_data)
>>> interpolation_imputer.impute()  # default parameters for imputation > or
>>> interpolation_imputer.impute(user_def=True, params={"method":"linear", "poly_order":2})  # user-defined > or
>>> interpolation_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "ray_tune"})  # automl with ray_tune
>>> recov_data = interpolation_imputer.recov_data

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class KNN(incomp_data)[source]¶

Bases: BaseImputer

KNN class to impute missing values with K-Nearest Neighbor algorithm

Methods¶

impute(self, params=None):: Perform imputation by replacing missing values with K-Nearest Neighbor

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'knn'¶

impute(user_def=True, params=None)[source]¶

Impute missing values by replacing them with the K-Nearest Neighbor value

Parameters¶

user_defbool, optional

Whether to use user-defined or default parameters (default is True).

paramsdict, optional

Parameters of the KNN algorithm, if None, default ones are loaded.

Algorithm parameters: k : int, optional

Number of nearest neighbor (default is 5).

weightsstr, optional: “uniform” for mean, “distance” for inverse-distance weighting.

Returns¶

selfKNN: The object with recov_data set.

Example¶

>>> knn_imputer = Imputation.Statistics.KNN(incomp_data)
>>> knn_imputer.impute()  # default parameters for imputation > or
>>> knn_imputer.impute(user_def=True, params={'k': 5, 'weights': "uniform"})  # user-defined > or
>>> knn_imputer.impute(user_def=False, params={"input_data": ts_1.data, "optimizer": "ray_tune"})  # automl with ray_tune
>>> recov_data = knn_imputer.recov_data

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class MeanImpute(incomp_data)[source]¶

Bases: BaseImputer

MeanImpute class to impute missing values with the mean value of the ground truth.

Methods¶

impute(self, params=None):: Perform imputation by replacing missing values with the mean value of the ground truth.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'mean_impute'¶

impute(params=None)[source]¶

Impute missing values by replacing them with the mean value of the ground truth. Template for adding external new algorithm

Parameters¶

paramsdict, optional: Dictionary of algorithm parameters (default is None).

Returns¶

selfMinImpute: The object with recov_data set.

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class MeanImputeBySeries(incomp_data)[source]¶

Bases: BaseImputer

MeanImputeBySeries class to impute missing values with the mean value by series.

Methods¶

impute(self, params=None):: Perform imputation by replacing missing values with the mean value by series

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'mean_impute'¶

impute()[source]¶

Impute missing values by replacing them with the mean value of the series.

Returns¶

selfMeanImputeBySeries: The object with recov_data set.

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class MinImpute(incomp_data)[source]¶

Bases: BaseImputer

MinImpute class to impute missing values with the minimum value of the ground truth.

Methods¶

impute(self, params=None):: Perform imputation by replacing missing values with the minimum value of the ground truth.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'min_impute'¶

impute(params=None)[source]¶

Impute missing values by replacing them with the minimum value of the ground truth. Template for adding external new algorithm

Parameters¶

paramsdict, optional: Dictionary of algorithm parameters (default is None).

Returns¶

selfMinImpute: The object with recov_data set.

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

class ZeroImpute(incomp_data)[source]¶

Bases: BaseImputer

ZeroImpute class to impute missing values with zeros.

Methods¶

impute(self, params=None):: Perform imputation by replacing missing values with zeros.

__init__(incomp_data)¶

Initialize the BaseImputer with an infected time series matrix.

Parameters¶

incomp_datanumpy.ndarray: Matrix used during the imputation of the time series.

algorithm = 'zero_impute'¶

impute(params=None)[source]¶

Impute missing values by replacing them with zeros. Template for adding external new algorithm

Parameters¶

paramsdict, optional: Dictionary of algorithm parameters (default is None).

Returns¶

selfZeroImpute: The object with recov_data set.

logs = True¶

score(input_data, recov_data=None, downstream=None)¶

Compute evaluation metrics for the imputed time series.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
recov_datanumpy.ndarray, optional: The imputed time series (default is None).
downstreamdict, optional: Dictionary that calls, if active, the downstream evaluation. (default is None). format : {“model”: “forcaster”, “params”: parameters}

Returns¶

None

evaluate_params(incomp_data, configuration, algorithm='cdrec')[source]¶

Evaluate various metrics for given parameters and imputation algorithm.

Parameters¶

input_datanumpy.ndarray: The original time series without contamination.
incomp_datanumpy.ndarray: The time series with contamination.
configurationtuple: Tuple of the configuration of the algorithm.
algorithmstr, optional: Imputation algorithm to use. Valid values: ‘cdrec’, ‘mrnn’, ‘stmvl’, ‘iim’ (default is ‘cdrec’).

Returns¶

dict: A dictionary of computed evaluation metrics.