A Survey on Missing Data Generation in Networks

Abstract

The prevalence of massive, multi-scale, high-dimensional, and dynamic data sets resulting from advances in information and network communication technologies is frequently hampered by data incompleteness, a consequence of complex network structures and constrained sensor capabilities. The necessity of complete data for effective data analysis and mining mandates robust preprocessing techniques. This comprehensive survey systematically reviews missing value interpolation methodologies specifically tailored for time series flow network data, organizing them into four principal categories: classical statistical algorithms, matrix/tensor-based interpolation methods, nearest-neighbor-weighted methods, and deep learning generative models. We detail the evolution and technical underpinnings of diverse approaches, including mean imputation, the ARMA family, matrix factorization, KNN variants, and the latest deep generative paradigms such as GANs, VAEs, normalizing flows, autoregressive models, diffusion probabilistic models, causal generative models, and reinforcement learning generative models. By delineating the strengths and weaknesses across these categories, this survey establishes a structured foundation and offers a forward-looking perspective on state-of-the-art techniques for missing data generation and imputation in complex networks.

1. Introduction

With the development of information technology, especially the development of network communication technology, data storage technology, data processing and analysis methods, and high-speed computing platforms, massive amounts of data have accumulated in various application fields. These data typically exhibit characteristics such as a large volume, a multi-scale structure, unstructured form, high dimensionality, and temporal dynamics, which provide the foundation for data-driven complex network modeling. Such characteristics not only amplify the modeling capacity of modern data-driven approaches, but also substantially increase the vulnerability of networked systems to data incompleteness, making missing data a pervasive and unavoidable issue in practice [1,2].

The popularization and development of communication networks are particularly reflected in the widespread use of various types of wireless sensors, which can rapidly and efficiently collect information from sensed nodes in the network and transmit it to the terminals of a wireless sensor network for aggregation and processing [3]. These sensor-driven networked data streams underpin a wide range of critical applications, including intelligent transportation systems, smart cities, energy networks, and large-scale cyber–physical systems, where data reliability directly affects system-level decision making and control performance [4].

Due to the complex structure and large number of nodes in sensor networks, as well as the limited power supply, computation, storage, and communication capabilities of sensor nodes, combined with external environmental interferences, it is common for some attributes of network data to become missing during data collection, transmission, or storage. Since most data analysis and mining techniques assume complete data, the presence of missing values severely affects downstream tasks. If not properly handled, missing data may lead to biased estimation, degraded prediction accuracy, and unreliable inference results, thereby significantly limiting the practical impact of network-based data analysis. Therefore, preprocessing missing data is essential before applying network data in real applications [5].

Over the past decades, a wide variety of methods have been proposed to address missing data in network and time series settings, ranging from classical statistical techniques to modern machine learning and deep generative models. However, these methods are often developed within different theoretical frameworks and application contexts, making it difficult for researchers and practitioners to obtain a unified understanding of their assumptions, capabilities, and limitations. This motivates the need for a systematic survey that organizes existing approaches, clarifies their methodological foundations, and highlights their practical impact on network data modeling and analysis.

The remainder of this survey is organized as follows. Section 2 provides a methodological overview of missing data modeling in network and time series settings, introducing a unified perspective that links missingness mechanisms with corresponding solution strategies. Classical statistical methods, matrix- and tensor-based approaches, traditional machine learning techniques, and deep learning methods are systematically reviewed to establish a foundational understanding. Section 3, Section 4, Section 5, Section 6 and Section 7 provide a detailed and structured review of the major categories of missing data handling methods introduced in Section 2, with an emphasis on their underlying assumptions, strengths, limitations, and suitable application scenarios. Finally, Section 8 concludes the paper by summarizing key insights and outlining promising directions for future research.

2. Overview of Research on Missing Data Generation in Networks

There is a close relationship between the types of missing data and the strategies used to handle them. Following the standard taxonomy, missing data can be categorized into three types: missing completely at random (MCAR), missing at random (MAR), and missing not at random (MNAR). Let X denote the complete data, which can be partitioned into the observed part $X_{\mathrm{obs}}$ and the missing part $X_{\mathrm{miss}}$. Let R denote the missingness indicator variable, where $R=1$ means observed and $R=0$ means missing.

Missing completely at random (MCAR) means that the missing mechanism does not depend on either observed or unobserved variables. That is, the occurrence of missing values is unrelated to any features of the data:

$$P(R\mid X_{\mathrm{obs}},X_{\mathrm{miss}})=P\left(R\right).$$

(1)

Missing at random (MAR) means that the missingness may depend on the observed part of the data but not on the unobserved part:

$$P(R\mid X_{\mathrm{obs}},X_{\mathrm{miss}})=P(R\mid X_{\mathrm{obs}}).$$

(2)

Missing not at random (MNAR) means that the missingness depends on the missing values themselves, i.e., the missing mechanism cannot be explained solely through the observed variables and therefore cannot be ignored.

In response to the missing data problem in the collected data set, the two most common strategies for handling missing data are direct deletion and missing value imputation. However, direct deletion further reduces the amount of available data and may result in severe information loss, especially when the proportion of missing samples is large. In contrast, missing value imputation aims to infer the missing entries by exploiting the intrinsic structure and statistical dependencies within the network data, thereby preserving as much of the original information as possible.

As shown in Table 1, the imputation methods for time series data can be broadly categorized into four groups: (1) classical statistical methods, (2) matrix- and tensor-based interpolation methods, (3) classic machine learning methods, and (4) deep learning generative models.

Table 1. Overview of methods for missing data generation in network data.

Method	Representative Algorithms	Advantages	Limitations
Classical Statistics Methods	Mean imputation (mode and constant), Statistical regression methods (LR, AR, and PR), Expectation–Maximization (EM), Bayesian PCA, Gaussian Mixture Model (GMM), and ARMA.	Simple principle, easy to implement; good for MCAR data; stable algorithms; and utilizes implicit information in missing data.	Sensitive to outliers and distribution assumptions; slow convergence; low versatility; prone to local optima; and ignores inter-attribute effects.
Matrix/Tensor-based Interpolation Method	Matrix Factorization (MF), Multiple Imputation by Chained Equations (MICE), Singular Value Decomposition (SVD), and Tucker algorithms.	Explores attribute relationships; high precision; low time/space complexity; and excellent scalability.	Difficult with high missingness; requires strict adherence to matrix/tensor rules; and highly data structure dependent.
Classic Machine Learning Methods	KNN, Weighted KNN (WKNN), Spatiotemporal WKNN (STWKNN), Grayscale Correlation Analysis (GRA), Clustering-based Imputation (CI), Kriging, and Random Forest (RF).	Applicable to continuous and categorical data; robust to outliers/noise; flexible; captures dynamic/spatiotemporal correlations (STWKNN); and models nonlinear relationships (RF).	Computationally intensive; high time/space complexity; performance drops in high-dimensional/unbalanced data; moderate interpretability; and sensitive to hyperparameters (K in KNN, number of trees in  RF).
Deep Learning Generative Models	GANs, VAE, Normalizing Flow (NF), Autoregressive Models (ARM), and Diffusion Models (DM).	Can learn complex data distributions; generates joint/posterior distributions; strong model flexibility; wide applicability; and faster convergence than traditional iterative methods,	Training is complex and slow; difficult to interpret and tune; model uncertainty may remain; and high resource requirements.
Temporal Link Prediction Methods	Heuristic Similarity-Based Methods (CN, PA, and AA), Dynamic sTochastic Block Models (DSBM), Temporal Point Processes (Hawkes), Dynamic Matrix/tensor Completion, Temporal GNNs, and Generative Graph Models.	Explicitly models structural missingness in networks; captures topological and temporal dependencies; suitable for dynamic and partially observed networks; and directly supports edge-level inference.	Primarily focuses on adjacency structure rather than attribute-level missingness; evaluation is task dependent; and scalability and interpretability remain challenging for large-scale temporal networks.

3. Classic Statistical Algorithms

Reference [6] first introduced mean imputation for filling missing values in data sets. For numerical data, the missing entries in each feature are replaced by the mean of the observed values in that feature so as to obtain a complete data set. Variants such as median imputation, mode imputation, forward or backward filling, and constant value filling are also commonly used, and they are generally effective only when the missing mechanism is missing completely at random (MCAR) [7]. However, these approaches ignore the relationships among different features and are sensitive to outliers and distributional skewness, often leading to substantial deviations between the imputed and true values. Consequently, their applicability is limited in practice.

Reference [8] proposed regression-based imputation methods, which estimate missing values by constructing regression models that capture the relationships among attributes. The model parameters are first learned from complete samples, and the fitted model is subsequently used to predict missing entries. Depending on the degree of dependence among variables, models can be linear or nonlinear. Linear regression models are simple and computationally efficient but often fail to capture complex real-world relationships. Nonlinear regression models fit data with more flexible functional forms and may combine multiple basis functions. Typical statistical regression methods include logistic regression, polynomial regression, stepwise regression, ridge regression, and lasso regression. Compared with mean imputation, regression-based approaches exploit more structural information in the data, resulting in improved imputation accuracy and broader applicability.

Reference [9] proposed the Expectation–Maximization (EM) algorithm for missing data imputation. EM performs maximum likelihood estimation in the presence of missing entries by iteratively executing two steps. In the E-step, the conditional expectation of the complete data log-likelihood is computed based on the observed data and current parameter estimates. In the M-step, the parameters are updated by maximizing this expected log-likelihood. The algorithm alternates between these two steps until convergence, and the estimated parameters are then used to infer the missing values, producing a completed data set. EM leverages the global statistical structure of the data and can achieve high-quality imputations. However, when the missing rate is high, EM may suffer from slow convergence or become trapped in local optima, leading to reduced imputation accuracy.

Principal component analysis (PCA) is a widely used linear statistical method for data simplification and state-space dimensionality reduction. Reference [10] proposed a Bayesian principal component analysis (BPCA)–based imputation method to fill incomplete traffic data collected from the Beijing traffic monitoring system. During the estimation of missing values, BPCA incorporates both historical information and periodic patterns, achieving a more balanced reconstruction of temporal dynamics. Experimental results demonstrated that BPCA outperforms two commonly used interpolation methods—historical average interpolation and spline interpolation.

Reference [11] further enhanced PCA-based imputation by exploiting the temporal correlations among neighboring sensors. The authors introduced a kernelized probabilistic PCA approach for time series flow data, which leverages spatiotemporal dependencies through kernel functions. Experiments on the PeMS data set confirmed that the kernel probabilistic PCA method yields superior imputation accuracy compared with standard probabilistic PCA for network traffic time series analysis.

Bayesian prediction models are another classical class of methods built upon Bayesian posterior inference. They model time series by exploiting sequential dependencies and incorporate prior distributions to regularize model estimation. Unlike conventional statistical approaches, Bayesian prediction methods first define a parametric probabilistic model, estimate its parameters by maximizing the posterior distribution, and then use the learned model for subsequent prediction. Representative Bayesian models include Gaussian mixture models (GMMs) and sparse Bayesian learning (SBL) frameworks.

Reference [12] employed a Gaussian mixture model combined with Kalman filtering for time series prediction. The GMM was used to capture the bimodal distribution of collision time samples, and the expectation–maximization (EM) algorithm was applied to estimate the maximum likelihood parameters. The combined GMM–Kalman filtering approach was shown to be both accurate and robust. Reference [13] applied a sparse Bayesian learning method for data fitting. The SBL model extended mixture-of-Gaussian formulations with sparsity-inducing priors similar to the Lasso constraint. Experiments conducted under varying signal integrity levels demonstrated that the SBL-based approach achieves the accurate estimation of missing states on the PeMS data set.

The autoregressive moving average (ARMA) model is one of the most commonly used approaches for analyzing stationary time series. As shown in Figure 1 and Figure 2. The ARMA$(p,q)$ model is defined as

$$x_t={\varphi }_0+{\varphi }_1{x}_{t-1}+\cdots +{\varphi }_p{x}_{t-p}+{\epsilon }_t+{\theta }_1{\epsilon }_{t-1}+\cdots +{\theta }_q{\epsilon }_{t-q},$$

(3)

where $x_t$ denotes the value at time t; $x_{t-i}$ represents the lag-i observations; ${\varphi }_i$ are the autoregressive (AR) coefficients; ${\epsilon }_t$ is white Gaussian noise; and ${\theta }_i$ are the moving average (MA) coefficients. The model parameters can be estimated using least squares or maximum likelihood estimation.

Figure 1. Stationary time series: the ARMA model’s building steps.

Figure 2. Non-stationary time series: the ARMA model’s difference modeling steps.

The ARMA model can be compactly written using the lag operator L as

$${\Phi }_p\left(L\right)x_t={\Theta }_q\left(L\right){\epsilon }_t,$$

(4)

where ${\Phi }_p\left(L\right)$ and ${\Theta }_q\left(L\right)$ are polynomials of orders p and q, respectively. By modeling both lagged observations and shock terms, ARMA effectively captures linear temporal dependencies in stationary time series. It is often used to interpolate missing values by generating rolling forecasts based on the observed data.

In time series analysis, the ARMA model requires the data to be stationary, and stationarity is typically assessed using tests such as the Augmented Dickey–Fuller (ADF) test, along with the examination of the autocorrelation function (ACF) and partial autocorrelation function (PACF). If the observed series is non-stationary, differencing can be applied to transform it into a stationary series, leading to the autoregressive integrated moving average (ARIMA) model. The ARIMA$(p,d,q)$ model is defined as

$${\Phi }_p\left(L\right){\Delta }^d{x}_t={\Theta }_q\left(L\right){\epsilon }_t,$$

(5)

where d is the order of differencing required to achieve stationarity, and ${\epsilon }_t$ denotes white noise.

The ARIMA model combines differencing with the ARMA structure and is effective for predicting and interpolating stationary time series. However, its performance degrades when the data exhibit strong cyclical or seasonal patterns. To handle seasonal variations in network time series data, the ARIMA$(p,d,q)$ model can be extended to the seasonal ARIMA (SARIMA) model, denoted as SARIMA$(p,d,q){(P,D,Q)}_m$ and the SARIMA algorithm is shown in Algorithm 1. Here, $(p,d,q)$ represent the non-seasonal autoregressive order, the order of non-seasonal differencing, and the non-seasonal moving-average order, respectively. The seasonal components ${(P,D,Q)}_m$ correspond to the seasonal autoregressive order, the seasonal differencing order, the seasonal moving average order, and the seasonal period m, which characterizes the length of a single seasonal cycle [14].

Algorithm 1: SARIMA Time Series Prediction Algorithm Process
Input:	Time series data $Data$ and the number of prediction steps $steps$.
Process:
1.	Handle or impute any missing values in $Data$.
2.	Perform a stationarity test (e.g., Augmented Dickey–Fuller). If the p-value < 0.05, the series is considered stationary.
3.	If the series is not stationary, apply differencing d times to make it stationary.
4.	Analyze the ACF and PACF plots of the stationary series to estimate initial values for p and q.
5.	Perform a grid search to find the optimal SARIMA parameters, as follows:
	a. For each parameter combination $(p,d,q)\times (P,D,Q,s)$, fit the model and calculate the AIC.
	b. Select the parameter set that yields the lowest AIC value.
	c. Perform diagnostic checks on the model’s residuals (e.g., for normality and autocorrelation).
	d. If the residuals fail the checks, refine the model or continue the search.
6.	Obtain the optimal model parameters $(p,d,q)\times (P,D,Q,s)$.
7.	Train the final SARIMA model using the optimal parameters.
Output:	The predicted values for the next $steps$ time periods.

4. Tensor Decomposition Methods

Network data can often be represented in matrix form, where random missing values appear as unobserved matrix entries. Since network modeling typically relies on high-quality and complete data, recovering missing matrix elements becomes essential. Matrix completion methods, which are closely related to tensor decomposition techniques, constitute one of the fundamental approaches for data recovery. The key idea is that many networked systems exhibit strong structural similarity among nodes. When a node can be linearly represented by a combination of other nodes, the data matrix exhibits an approximate low-rank structure. In such cases, the matrix completion problem can be formulated as recovering a low-rank matrix from sparsely observed entries, a setting in which matrix factorization and tensor decomposition methods often achieve excellent performance [15].

Reference [16] proposed a missing value imputation approach based on matrix factorization. The method treats the original data set as a matrix and factorizes it into the product of two low-dimensional matrices; the reconstructed matrix is then used to estimate the missing entries. Reference [17] proposed a multiple imputation method based on chained equations, where missing values are iteratively imputed using model-based predictions. In each iteration, a linear regression model is fitted on the observed data and used to update the missing values. Repeated iterations significantly improve imputation accuracy.

Reference [18] introduced a tensor decomposition method based on singular value decomposition (SVD). Experiments with missing rates between $20\%$ and $80\%$ demonstrated that the method could successfully recover missing data with high accuracy under both mild and severe missing scenarios. Reference [19] applied fixed point iteration and approximate SVD to obtain a low-rank representation of large-scale road network data with missing entries and solved the recovery problem using nuclear norm minimization, achieving effective reconstruction in large transportation systems.

Tensor decomposition is a multi-dimensional extension of matrix decomposition. It can better cope with the multi-dimensional characteristics of network flow data. Reference [20] constructs data into a fourth-order tensor structure and adopts a low-rank tensor completion algorithm. Experiments show that this method works well for long-term data loss. Reference [21] proposes a short-term data flow prediction method based on dynamic tensor completion. By constructing a fourth-order tensor of network data, it can capture the spatiotemporal characteristics of data better than previous models, proving that the algorithm has better performance and performs better on incomplete data sets. Reference [22] introduces a high-order data structure into the Tucker-WGopt algorithm based on the improved Tucker algorithm, and compares it with algorithms such as CP-ALS, proving the accuracy of the algorithm on complete data sets.

5. Classic Machine Learning Methods

5.1. Random Forest Method

Random forests are a widely used ensemble learning method in machine learning, data science, and statistics. Although random forests are not generative models in the strict probabilistic sense, they have demonstrated strong capabilities in terms of missing value imputation, feature selection, and partially synthetic data generation. These properties make random forests useful tools in data preprocessing and privacy-preserving data synthesis.

Random forests enhance predictive accuracy and robustness by constructing an ensemble of decision trees and aggregating their predictions. In the context of data recovery and generation, random forests primarily offer three advantages: (1) feature importance assessment, which identifies key predictors for downstream modeling; (2) missing value imputation, achieved by recursively partitioning the data space and predicting unobserved entries; and (3) partially synthetic data generation, in which models fitted on observed data are used to stochastically simulate new values. Unlike deep generative models, the synthetic data produced by random forests aim to preserve marginal and conditional relationships without explicitly modeling the joint probability distribution.

The effectiveness of random forests in synthetic data generation has been demonstrated in several studies. Caiola and Reiter [23] proposed a partially synthetic data generation method for classification data using random forests. Their method perturbs selected variables while preserving the overall statistical structure, thereby enhancing data privacy while maintaining data utility. Horning [24] explored the use of random forests for image classification and the generation of continuous geospatial fields. The study showed that random forests can approximate spatial processes and produce synthetic spatial surfaces consistent with observed patterns. Song et al. [25] developed a well-logging data generation approach by combining random forests with an adaptive domain clustering algorithm. The method leverages the feature selection capabilities of random forests and the spatial grouping of clustering algorithms to generate realistic well-logging curves. Zhang et al. [26] proposed a framework for generating gap-free FAPAR time series data from Landsat imagery by integrating random forests with deep learning. Their method utilizes random forests for feature selection and deep learning for temporal sequence reconstruction, resulting in high-quality synthetic FAPAR time series.

Overall, random forests offer a flexible and powerful tool for data preprocessing, missing value imputation, and partially synthetic data generation. Through ensemble-based prediction and feature-driven modeling, they are capable of approximating complex data structures and producing synthetic data with strong statistical fidelity. The referenced studies highlight both the effectiveness and the versatility of random forests in generating high-quality synthetic or imputed data, particularly in applications involving complex spatial, temporal, or multivariate structures. With continued research, the role of random forests in privacy protection, data augmentation, and imputation is expected to expand further.

5.2. K-Nearest Neighbor Method

The K-Nearest Neighbor (KNN) method is a classical non-parametric algorithm widely used in data mining and pattern recognition. Reference [27] proposed a KNN-based imputation method that identifies the K samples most similar to the instance with missing values using Euclidean or Minkowski distance. The missing entries are then estimated from the attributes of the neighboring samples, for example, by averaging numerical attributes. However, classical KNN is more naturally suited for continuous variables and may perform poorly with categorical attributes unless an appropriate distance metric is designed.

To improve KNN’s applicability to discrete variables, reference [28] incorporated gray relational analysis into the distance computation. By embedding label information into the similarity measure, the method enhances the ability of KNN to impute missing values in categorical or mixed-type data. Nonetheless, a challenge remains: the nearest neighbors obtained from the distance measure may still deviate from the true underlying structure of samples with missing values.

To address this limitation, reference [29] proposed the Weighted-KNN method, which assigns weights to neighboring samples based on the derivative of their distance to the target sample. This weighting scheme enables closer neighbors to exert stronger influence in the imputation process. Furthermore, in order to reduce the sensitivity to the hyperparameter K and enhance interpolation accuracy, reference [30] introduced a kernel function into the weight computation. By adaptively adjusting the relationship between distance and weight, the method improves robustness against suboptimal K-selection and yields more accurate imputations. Similarly to mean imputation, traditional KNN does not explicitly model attribute correlations within the same instance, which limits its performance in high-dimensional data sets.

Several studies extend KNN by integrating clustering techniques. Reference [31] applied clustering algorithms to partition samples into homogeneous groups. For each missing entry, only neighbors from the same cluster are used, and the cluster-based mean of the relevant attributes is assigned to the missing position. This approach significantly improves data quality by reducing the influence of heterogeneous samples. Reference [32] combined fuzzy C-means clustering with a genetic algorithm to divide network nodes into multiple clusters and used cluster centers for imputation, achieving higher accuracy than traditional statistical models.

To incorporate the spatiotemporal characteristics of networked data, reference [33] proposed the STW-KNN algorithm, which improves the KNN search mechanism by embedding spatiotemporal correlations into the state vector and applying a distance-weighted voting scheme. This method effectively reduces the sensitivity to the choice of K and achieves substantially higher accuracy than classical KNN. From a structural perspective, reference [34] optimized missing value estimation by identifying an optimal detector node set. The method integrates time series information and network topology, combining an optimal closed-loop search strategy with Kriging interpolation. Compared with ARIMA and standard KNN, it yields a significantly improved imputation performance while maintaining computational efficiency.

6. Deep Learning Methods

Given the powerful representational learning capabilities of deep neural networks, the rapid development of deep learning methods has spawned several classic generative models for interpolating and restoring missing data values. For example, image generative models use probabilistic models to model the distribution of image data, capable of repairing missing image information and generating accurate images based on input semantic information. Deep learning is generally categorized into likelihood-based and implicit generative models. Common generative models include GANs (Gan-like networks), variational autoencoders (VAEs), normalized flow models (NFs), autoregressive models (ARMs), and diffusion processes (DMs), as shown in Figure 3.

Figure 3. Comparison of the basic process of deep learning generation models.

Generative models are generally divided into supervised and unsupervised models. Supervised generative models use given category labels or properties as conditional information to generate images that meet the requirements. In unsupervised learning, generative models are trained on unlabeled data, using low-order latent variables as the input to generate images that conform to the distribution of the real data in the training set. The data generation process of deep generative models generally involves sampling variable points Z from a known prior distribution and transforming them into sampling points X of the data distribution. Generative models can repair missing data and generate higher-quality data.

6.1. Generative Adversarial Network (GAN)

Generative adversarial networks (GANs), introduced by Goodfellow et al. [35], are one of the most influential deep generative models. As shown in Figure 4, a GAN consists of two neural networks trained simultaneously in an adversarial setting: a generator G that produces synthetic samples and a discriminator D that attempts to distinguish real samples from generated ones. During training, the generator aims to produce samples that are indistinguishable from real data, while the discriminator learns to classify inputs as real or fake.

Figure 4. Flowchart of the adversarial neural network model.

The discriminator $D\left(x\right)$ outputs the probability that sample x originates from the real data distribution $p_r$. The generator maps a noise vector $z\sim p_z\left(z\right)$ to a synthetic sample $G\left(z\right)$, attempting to capture the underlying distribution of real data. The training objective is a two-player minimax game defined by

$$\underset{G}{\min }\underset{D}{\max }V(D,G)={\mathbb{E}}_{x\sim p_r\left(x\right)}\left[\log D\left(x\right)\right]+{\mathbb{E}}_{z\sim p_z\left(z\right)}\left[\log (1-D\left(G\left(z\right)\right))\right].$$

(6)

For a fixed generator G, the optimal discriminator is

$$D^{\ast }\left(x\right)={\displaystyle \frac{p_r\left(x\right)}{p_r\left(x\right)+p_g\left(x\right)}},$$

(7)

where $p_g$ is the distribution induced by samples $G\left(z\right)$. Substituting $D^{\ast }$ into Equation (6) yields

$$V(G,D^{\ast })=-\log 4+2\mathrm{JS}(p_r\Vert p_g),$$

(8)

where $\mathrm{JS}(·\Vert ·)$ denotes the Jensen–Shannon divergence. Therefore, minimizing the GAN loss is equivalent to minimizing the discrepancy between the real data distribution and the generator distribution.

Training proceeds iteratively, as follows: The discriminator improves by increasing its ability to differentiate real and generated samples, while the generator improves by producing samples that can fool the discriminator. At convergence, the generator distribution satisfies

$$p_g=p_r,D^{\ast }\left(x\right)={\displaystyle \frac{1}{2}},$$

(9)

meaning the discriminator cannot distinguish real from generated samples.

Based on the GAN principle, the missing data imputation process can be described as follows:

1.

Initialize the generator G and discriminator D with random parameters.

2.

Sample real data $x\sim p_r\left(x\right)$, draw noise vectors $z\sim p_z\left(z\right)$, and obtain generated samples $\{{\tilde{x}}^1,{\tilde{x}}^2,\dots ,{\tilde{x}}^m\}=G\left(z\right)$. Train the discriminator to maximize its ability to distinguish real and synthetic samples.

3.

Train the generator by minimizing the adversarial loss so that the generated samples become closer to real data and increasingly deceive the discriminator.

4.

Repeat steps 2–3 until the discriminator’s accuracy approaches 50%, indicating that generated samples are indistinguishable from real ones.

In missing value imputation, GAN-based models can be adapted to reconstruct incomplete observations by constraining the generator to produce samples consistent with the observed components while generating plausible values for the missing entries.

6.2. Variational AutoEncoder (VAE)

As shown in Figure 5, autoencoders are fundamental unsupervised learning models used to learn low-dimensional latent representations of data [36]. A standard autoencoder maps an input x to a latent representation $z=g_{\varphi }\left(x\right)$ through an encoder, and then reconstructs the input via a decoder $f_{\theta }\left(z\right)$, i.e.,

$$\widehat{x}=f_{\theta }\left(g_{\varphi }\left(x\right)\right).$$

(10)

The model parameters $(\theta ,\varphi )$ are optimized by minimizing the reconstruction error, as follows:

$${\mathcal{L}}_{\mathrm{AE}}(\theta ,\varphi )={\displaystyle \frac{1}{n}}\sum _{i=1}^n{∥x^{\left(i\right)}-f_{\theta }\left(g_{\varphi }\left(x^{\left(i\right)}\right)\right)∥}^{\gamma },$$

(11)

where $\gamma$ is typically 1 or 2. A limitation of classical autoencoders is that they may simply memorize the training data and do not explicitly model the underlying data distribution, thus being prone to overfitting when data are scarce.

Figure 5. Schematic diagram of the variational autoencoder model.

To improve robustness, Vincent et al. [37] introduced the denoising autoencoder (DAE), where each input is partially corrupted by a noise process,

$${\tilde{x}}^{\left(i\right)}\sim M_D(\tilde{x}\mid x^{\left(i\right)}),$$

(12)

before being passed to the encoder. The model is trained to recover the clean input, as follows:

$${\mathcal{L}}_{\mathrm{DAE}}(\theta ,\varphi )={\displaystyle \frac{1}{n}}\sum _{i=1}^n{∥x^{\left(i\right)}-f_{\theta }\left(g_{\varphi }\left({\tilde{x}}^{\left(i\right)}\right)\right)∥}^{\gamma }.$$

(13)

DAEs effectively learn the correlations among input dimensions and thus can infer missing components in partially observed data.

Sparse autoencoders further improve generalization by constraining the average activation of hidden units. Let $a_j^{\left(l\right)}\left(x\right)$ denote the activation of the j-th neuron in layer l. Its empirical average activation is

$${\widehat{\rho }}_j^{\left(l\right)}={\displaystyle \frac{1}{n}}\sum _{i=1}^n{a}_j^{\left(l\right)}\left(x^{\left(i\right)}\right),$$

(14)

and sparsity is encouraged by enforcing ${\widehat{\rho }}_j^{\left(l\right)}\approx \rho$, where $\rho$ is a small target activation. This reduces co-adaptation among neurons and enhances robustness.

Other variants introduce more explicit sparsity structures such as the k-sparse autoencoder, which keeps only the k largest activations in the bottleneck layer, and the contrastive autoencoder [38], which penalizes sensitivity to small perturbations around training data.

While classical autoencoders learn deterministic encodings, they do not define a generative model. As shown in Figure 5, variational autoencoders (VAEs) extend autoencoders by learning a probabilistic latent variable model. VAEs assume a prior distribution $p\left(z\right)$ (typically $\mathcal{N}(0,I)$), and approximate the intractable posterior $p(z\mid x)$ with an encoder-defined variational distribution $q_{\varphi }(z\mid x)$. The decoder defines a likelihood model $p_{\theta }(x\mid z)$. Training maximizes the evidence lower bound (ELBO), as follows:

$${\mathcal{L}}_{\mathrm{VAE}}(\theta ,\varphi )={\mathbb{E}}_{z\sim q_{\varphi }(z\mid x)}\left[\log p_{\theta }(x\mid z)\right]-\mathrm{KL}\left(q_{\varphi }(z\mid x)\parallel p\left(z\right)\right),$$

(15)

where the first term encourages accurate reconstruction and the KL divergence regularizes the approximate posterior.

VAEs are particularly suited for missing data interpolation: the probabilistic latent space captures dependencies among data dimensions, allowing the decoder to generate plausible values for missing entries conditioned on observed ones. As a result, VAEs and their variants have become widely used tools in generative imputation frameworks.

To improve the robustness and generative capability of classical autoencoders, numerous variants have been developed. This section reviews several representative extensions relevant to missing data imputation.

Dropout Autoencoder. To mitigate overfitting caused by overly expressive autoencoder models, the dropout autoencoder [39] randomly removes connections or units during training. This stochastic regularization prevents co-adaptation among neurons and enhances generalization, enabling the network to better recover missing components in partially observed data.

Adversarial Autoencoder (AAE). The adversarial autoencoder [40] introduces an additional discriminator D to enforce that the aggregated posterior,

$$q_{\varphi }\left(z\right)=\int q_{\varphi }(z\mid x)p_{\mathrm{data}}\left(x\right)dx,$$

(16)

matches a chosen prior distribution $p\left(z\right)$. The discriminator receives samples from both $q_{\varphi }\left(z\right)$ (labeled as fake) and $p\left(z\right)$ (labeled as real), and the encoder is trained adversarially to fool the discriminator. This yields a regularized latent space similar to VAEs but without requiring an explicit KL divergence term. The AAE thus supports both the reconstruction of observed data and sampling from the prior for generating new or imputed samples.

Disentangled Representation Models: $\mathit{\beta }$-VAE. Higgins et al. [41] proposed the $\beta$-VAE, which encourages disentangled latent factors by up-weighting the KL penalty in the ELBO, as follows:

$${\mathcal{L}}_{\beta -\mathrm{VAE}}(\theta ,\varphi )=-{\mathbb{E}}_{z\sim q_{\varphi }(z\mid x)}\left[\log p_{\theta }(x\mid z)\right]+\beta \mathrm{KL}\left(q_{\varphi }(z\mid x)\Vert p\left(z\right)\right),\beta >1.$$

(17)

The increased KL term forces each latent dimension to be more independent and sensitive to only one generative factor. Such disentanglement often improves interpolation stability and interpretability, which is beneficial for structured missing data recovery.

Wasserstein Autoencoder (WAE). The Wasserstein autoencoder replaces the KL divergence with a Wasserstein distance (or other optimal transport metrics) between the aggregated posterior and the prior. Its optimization problem follows:

$$\underset{\theta ,\varphi }{\min }{\mathbb{E}}_{x\sim p_{\mathrm{data}}}{\mathbb{E}}_{z\sim q_{\varphi }(z\mid x)}[-\log p_{\theta }(x\mid z)]+\lambda D\left(q_{\varphi }\left(z\right)\parallel p\left(z\right)\right),$$

(18)

where $D(·\parallel ·)$ is typically an MMD or adversarial OT penalty. WAEs produce smoother latent spaces and higher-quality generated samples, thereby improving the plausibility of the imputed data.

Conditional VAE (CVAE). The conditional VAE [42] extends VAE by conditioning both the encoder and decoder on auxiliary variables c:

$$q_{\varphi }(z\mid x,c),p_{\theta }(x\mid z,c).$$

(19)

By providing labels or contextual attributes, CVAE can generate more accurate and structured imputations in semi-supervised or side-information-rich environments.

Vector Quantized VAE (VQ-VAE). VQ-VAE [43] learns discrete latent variables by mapping the encoder output to the nearest vector in a learned codebook. Formally,

$$z_e\left(x\right)\in {\mathbb{R}}^K\to z_q\left(x\right)=\underset{e_i}{\mathrm{argmin}}{\parallel z_e\left(x\right)-e_i\parallel }_2,$$

(20)

where $\left\{e_i\right\}$ is a discrete set of embeddings. Discrete representations are especially effective in speech, symbolic reasoning, and categorical missing data generation.

TD-VAE. The TD-VAE [44] models’ temporal processes by learning a sequence of latent belief states that summarize past information. It adopts a state-space perspective, as follows:

$$z_t\sim p(z_t\mid z_{t-1}),x_t\sim p(x_t\mid z_t),$$

(21)

and performs temporal difference learning on belief states. Such a structure enables TD-VAE to infer future states or impute missing segments in sequential data efficiently.

Overall, VAE-based models provide flexible probabilistic frameworks for missing data imputation by explicitly modeling dependencies among features and enabling sampling-based reconstruction.

6.3. Normalizing Flows

Normalizing flows (flows) are a class of deep generative models that enable exact density evaluation and efficient sampling by constructing an invertible, differentiable mapping between a simple base distribution and the data distribution, as ahown in Figure 6 [45,46]. Let $z_0$ be a latent variable with a simple prior $p_Z\left(z_0\right)$ (e.g., Gaussian). A flow defines a sequence of invertible transformations,

$$z_i=f_i\left(z_{i-1}\right),i=1,\dots ,K,$$

(22)

and the observed data is obtained as $x=z_K=f_K\circ \cdots \circ f_1\left(z_0\right)$. By the change-of-variables formula, the exact data density $p_X\left(x\right)$ can be computed from the base density and the Jacobian determinants of the transformations, as follows:

$$p_X\left(x\right)=p_Z\left(z_0\right)\prod _{i=1}^K\left|\det {\displaystyle \frac{\partial f_i^{-1}}{\partial z_i}}\right|=p_Z\left(z_0\right)\prod _{i=1}^K{\left|\det {\displaystyle \frac{\partial f_i}{\partial z_{i-1}}}\right|}^{-1}.$$

(23)

Or, equivalently, in log form, this is expressed as follows:

$$\log p_X\left(x\right)=\log p_Z\left(z_0\right)-\sum _{i=1}^K\log \left|\det {\displaystyle \frac{\partial f_i}{\partial z_{i-1}}}\right|.$$

(24)

To make Equation (24) tractable, each $f_i$ must be invertible and its Jacobian determinant must be efficient to compute.

Figure 6. Schematic diagram of the standardized flow model.

Early flow architectures exploit simple, tractable bijections. NICE [47] uses additive coupling layers of the following form:

$$\begin{array}{cc}\hfill y_{1:d}& =x_{1:d},\hfill \\ \hfill y_{d+1:D}& =x_{d+1:D}+m\left(x_{1:d}\right),\hfill \end{array}$$

(25)

whose Jacobian is triangular with unit determinant (so the log determinant is zero), and the inverse is trivial. RealNVP [48] generalizes this by using affine coupling layers:

$$\begin{array}{cc}\hfill y_{1:d}& =x_{1:d},\hfill \\ \hfill y_{d+1:D}& =x_{d+1:D}\odot \exp \left(s\left(x_{1:d}\right)\right)+t\left(x_{1:d}\right),\hfill \end{array}$$

(26)

where $s(·)$ and $t(·)$ are scale and translation networks and “⊙” denotes element-wise multiplication. The triangular Jacobian makes $\log |\det \partial f/\partial x|$ equal to the sum of the outputs of $s(·)$, which is cheap to evaluate. Glow [49] further improved flow architectures by introducing invertible $1\times 1$ convolutions and actnorm layers, yielding expressive yet tractable bijections suitable for high-dimensional data such as images.

Normalizing flows provide exact log-likelihood evaluation (no variational bound or adversarial training required) and allow both efficient sampling and exact density computation. The main design challenge is constructing sufficiently expressive invertible layers whose Jacobian determinants remain computationally efficient. In practice, flows often trade off expressivity and computational cost via coupling layers, invertible convolutions, and careful architectural choices.

Flows can be adapted for imputation in several ways. One approach is to learn a conditional flow $p(x_{\mathrm{miss}}\mid x_{\mathrm{obs}})$ by conditioning coupling networks on observed components; then, missing entries can be sampled directly from the conditional distribution. Another approach is to maximize the conditional likelihood of observed entries while sampling latent z to produce imputations (e.g., conditional sampling or Gibbs-like procedures that alternate between latent and observed spaces). Because flows give exact likelihoods, they permit principled model selection and likelihood-based uncertainty estimates for imputed values. Conditional coupling layers and masked flows are practical mechanisms commonly used to implement such conditional densities for structured imputation tasks.

In summary, normalizing flow models are a powerful likelihood-based family for modeling complex, high-dimensional data distributions; with conditional architectures, they are well suited for probabilistic imputation and uncertainty-aware reconstruction of missing network flow data.

6.4. Autoregressive Models

Autoregressive (AR) models are classical tools for modeling time series, where the value of a variable is predicted using its past observations. Traditional statistical autoregressive models include AR, MA, ARIMA, and SARIMA, which assume linear dependence among past values. When combined with deep neural networks, autoregressive principles have led to a wide class of powerful generative models that can capture highly nonlinear temporal or structural dependencies in complex data.

Germain et al. [50] proposed MADE (Masked Autoencoder for Distribution Estimation), which integrates autoregressive constraints into an autoencoder architecture. Instead of feeding sampled values back into the network, MADE enforces autoregressive factorization,

$$p\left(x\right)=\prod _{i=1}^{D}p(x_i\mid x_{<i}),$$

(27)

through carefully designed binary masking matrices applied to the weight tensors. By permuting input dimensions, MADE can implement any autoregressive ordering, providing flexibility and scalability while avoiding the architectural rigidity of classical autoencoders.

Van den Oord et al. [51] extended autoregressive modeling to images via PixelCNN and PixelRNN. For an image with $n\times n$ pixels flattened into a sequence $\{x_1,\dots ,x_{n^2}\}$, the joint density is factorized as follows:

$$p\left(x\right)=\prod _{i=1}^{n^2}p(x_i\mid x_1,\dots ,x_{i-1}).$$

(28)

PixelCNN enforces this causality using masked convolution kernels, ensuring that each pixel is predicted only from previously generated pixels. PixelRNN adopts recurrent architectures (e.g., LSTM) to model long-range pixel dependencies. During generation, pixels are produced sequentially according to Equation (28), enabling high-quality image synthesis with explicit likelihood evaluation.

For audio and long-range temporal data, the WaveNet architecture [52] uses stacks of causal and dilated convolutions. Causality ensures that the output at time t depends only on inputs from times $t^{\prime }\le t$. Dilated convolutions exponentially increase the receptive field, enabling the model to capture dependencies over hundreds or thousands of time steps while maintaining tractable computation. WaveNet has achieved strong performance in audio interpolation, speech synthesis, and long-horizon time series prediction.

Papamakarios et al. [53] extended autoregressive networks to likelihood-based generative modeling by combining autoregressive density estimation with normalizing flows. For a data vector $x=(x_1,\dots ,x_D)$, a masked autoregressive flow specifies the conditional densities as affine transformations:

$$x_i={\mu }_i\left(x_{<i}\right)+{\sigma }_i\left(x_{<i}\right)\odot z_i,z_i\sim p\left(z_i\right),$$

(29)

where ${\mu }_i$ and ${\sigma }_i$ are outputs of an autoregressive neural network, and $p\left(z\right)$ is typically a standard Gaussian. Because the Jacobian of (29) is triangular, the log-density

$$p\left(x\right)=\prod _{i=1}^{D}p(x_i\mid x_{<i})$$

(30)

is tractable, and the transformation is invertible. MAF thus inherits the expressive power of autoregressive models and the exact likelihood evaluation capability of normalizing flows.

Reference [54] proposed the Inverse Autoregressive Flow (IAF), which can be viewed as the reverse-direction counterpart of MAF. While MAF allows efficient likelihood evaluation but slow sampling (due to its sequential generation in the forward direction), IAF reverses the computation so that sampling becomes parallelizable and fast, as shown in Figure 7.

Figure 7. Schematic diagram of Masked Autoregressive Flow and Inverse Autoregressive Flow.

For a data vector $x=(x_1,\dots ,x_D)$, MAF defines the forward autoregressive transformation as follows:

$$x_i={\mu }_i\left(x_{<i}\right)+{\sigma }_i\left(x_{<i}\right)\odot z_i,z_i\sim p\left(z_i\right).$$

(31)

IAF instead applies the inverse affine transformation as follows:

$$z_i={\displaystyle \frac{x_i-{\mu }_i\left(x_{<i}\right)}{{\sigma }_i\left(x_{<i}\right)}}=-{\displaystyle \frac{{\mu }_i\left(x_{<i}\right)}{{\sigma }_i\left(x_{<i}\right)}}+x_i\odot {\displaystyle \frac{1}{{\sigma }_i\left(x_{<i}\right)}}.$$

(32)

Let $f:x\mapsto z$ denote this inverse transformation, and $f^{-1}:z\mapsto x$ its corresponding forward mapping. The inverse transformation can also be written in autoregressive affine form with parameters, as follows:

$${\tilde{\mu }}_i\left(z_{<i}\right)=-{\displaystyle \frac{{\mu }_i\left(x_{<i}\right)}{{\sigma }_i\left(x_{<i}\right)}},{\tilde{\sigma }}_i\left(z_{<i}\right)={\displaystyle \frac{1}{{\sigma }_i\left(x_{<i}\right)}}.$$

(33)

Thus the forward generative step of IAF becomes

$$x_i={\tilde{\mu }}_i\left(z_{<i}\right)+{\tilde{\sigma }}_i\left(z_{<i}\right)\odot z_i,$$

(34)

where all $z_i$ can be sampled in parallel from the base distribution $p\left(z\right)$. Because the Jacobian of (34) remains triangular, the model admits tractable density estimation similarly to MAF.

Although the autoregressive structure still defines a dependency ordering, IAF enables efficient sampling because the latent variables $\left\{z_i\right\}$ do not depend on previously generated $x_i$. Once z is sampled, all $x_i$ can be computed simultaneously using (34). This makes IAF particularly effective as a variational posterior in VAEs, where fast sampling from $q_{\varphi }(z\mid x)$ is essential for optimization.

In the context of missing value reconstruction, autoregressive models can condition each variable on previously observed entries, either following a fixed permutation or sampling multiple random orderings to improve robustness. By estimating the conditional distribution $p(x_i\mid x_{<i})$, such models can generate plausible missing values sequentially or produce uncertainty-aware imputations via sampling from the conditional density. Autoregressive flows (e.g., MAF) further enable thr exact likelihood evaluation of completed data, supporting probabilistic imputation and confidence estimation.

6.5. Diffusion Probabilistic Model

Generative models can be broadly divided into likelihood-based and implicit generative approaches [55]. However, both paradigms have inherent limitations: likelihood-based models such as normalizing flows and VAEs often require strong architectural constraints or rely on surrogate objectives to approximate maximum likelihood, while implicit models frequently need adversarial training, resulting in instability and limited robustness. To overcome these challenges, Reference [56] introduced a diffusion-based generative framework. By modeling the gradient of the log-density, namely the score function, the diffusion probabilistic model defines a forward noising process and a learned reverse denoising process, forming a tractable Markov chain for data generation, as shown in Figure 8.

Figure 8. Schematic diagram of the forward and backward diffusion process of the diffusion model.

Forward diffusion process. Assume data samples $x_0\sim q\left(x\right)$. The forward diffusion gradually perturbs the data with small Gaussian noise over T steps, producing a sequence $x_1,x_2,\dots ,x_T$ according to the Markov transition, as follows:

$$q(x_t\mid x_{t-1})=\mathcal{N}\left(x_t;\sqrt{1-{\beta }_t}{x}_{t-1},{\beta }_{t}I\right),q(x_{1:T}\mid x_0)=\prod _{t=1}^{T}q(x_t\mid x_{t-1}).$$

(35)

As the noise level accumulates, the sample loses all semantic structure, and for sufficiently large T, the marginal $x_T$ approaches an isotropic Gaussian. Using the reparameterization trick with ${\alpha }_t=1-{\beta }_t$ and ${\tilde{\alpha }}_t={\prod }_{i=1}^t{\alpha }_i$, one obtains the following closed-form expression:

$$x_t=\sqrt{{\tilde{\alpha }}_t}{x}_0+\sqrt{1-{\tilde{\alpha }}_t}z,z\sim \mathcal{N}(0,I).$$

(36)

This expression allows sampling $x_t$ at any time step directly, without simulating all intermediate states.

Reverse diffusion process. The generative process reconstructs data by reversing the noising chain, starting from $x_T\sim \mathcal{N}(0,I)$. Since the forward transitions inject small Gaussian noise, the reverse process is also Gaussian and Markovian:

$$p_{\theta }(x_{t-1}\mid x_t)=\mathcal{N}\left(x_{t-1};{\mu }_{\theta }(x_t,t),{\Sigma }_{\theta }(x_t,t)\right),p_{\theta }\left(x_{0:T}\right)=p\left(x_T\right)\prod _{t=1}^T{p}_{\theta }(x_{t-1}\mid x_t).$$

(37)

When conditioning on the original sample $x_0$, the true posterior

$$q(x_{t-1}\mid x_t,x_0)=\mathcal{N}\left(x_{t-1};\tilde{\mu }(x_t,x_0),{\tilde{\beta }}_{t}I\right)$$

(38)

admits closed-form parameters,

$${\tilde{\beta }}_t={\displaystyle \frac{1-{\tilde{\alpha }}_{t-1}}{1-{\tilde{\alpha }}_t}}{\beta }_t,\tilde{\mu }(x_t,x_0)={\displaystyle \frac{1}{\sqrt{{\alpha }_t}}}\left(x_t-{\displaystyle \frac{{\beta }_t}{\sqrt{1-{\tilde{\alpha }}_t}}}{z}_t\right),$$

(39)

where $z_t$ denotes the noise injected in the forward process. The learning objective of diffusion models is to make the parameterized reverse kernel $p_{\theta }(x_{t-1}\mid x_t)$ closely approximate the true posterior $q(x_{t-1}\mid x_t,x_0)$.

Score-based modeling and generative capability. Let $p\left(x\right)$ denote the unknown data distribution. Instead of modeling $p\left(x\right)$ directly, diffusion methods learn its score

$$s_{\theta }\left(x\right)\approx {\nabla }_x\log p\left(x\right),$$

(40)

which avoids the difficulties associated with normalizing constants. By learning either the score function or the reverse transition kernel, diffusion models can generate new samples that follow the data distribution and thus restore or impute missing values in corrupted data. Based on this diffusion principle, several influential variants have been developed, including diffusion probabilistic models [57], noise-conditioned score networks [58], and denoising diffusion probabilistic models (DDPM) [59], significantly broadening the applicability of diffusion-based generative modeling.

6.6. Causal Generative Models

Causal generative models constitute an emerging research direction that integrates causal inference with deep generative modeling. By introducing causal structures into the generative process, these models not only synthesize high-quality data but also preserve explicit causal semantics, thereby enabling controllable, explainable, and intervention-aware generation. Such properties offer broad potential in applications including robustness enhancement, counterfactual reasoning, and scientific discovery.

Kocaoglu et al. proposed CausalGAN [60], a representative model that incorporates a causal graph into the generator architecture. A causal graph, represented as a directed acyclic graph (DAG), encodes the causal dependencies among variables. CausalGAN utilizes a causal implicit generative model (CIGM), where the generator is constructed to respect the parent–child relations dictated by the DAG. Given an input noise vector z, the generator produces samples $G\left(z\right)$ through a sequence of neural transformations aligned with the causal graph, ensuring that the synthesized variables inherit the correct structural relationships. The discriminator distinguishes generated samples from real observations, and adversarial training jointly optimizes both components. Because the generator explicitly follows the causal graph, interventions can be naturally incorporated: fixing a variable X to a specific value via a do-operation $\mathrm{do}(X=x^{\ast })$ allows the model to generate counterfactual samples in which causal descendants of X adjust accordingly.

Building upon this framework, Sauer and Geiger introduced counterfactual generative networks (CGN) [61], which employ causal factorization to disentangle content, style, and semantics. By allowing explicit interventions on causal factors, CGNs can synthesize samples outside the support of the training distribution—an important capability for mitigating shortcut learning and improving model robustness. Yang et al. further combined causal inference with variational autoencoders and proposed CausalVAE [62]. By embedding a structured causal model (SCM) within the latent representation, CausalVAE enables causal disentanglement and facilitates the generation of images consistent with underlying causal mechanisms.

Beyond image generation, causal generative models have also advanced in broader domains. Goudet et al. introduced a neural approach for learning functional causal models [63], using generative networks to approximate the joint distribution of observed variables and thereby support causal discovery. Pawlowski et al. extended structural causal models to deep architectures, enabling more expressive counterfactual reasoning [64]. These developments deepen the theoretical and practical foundations of causal representation learning.

Causal generative models have also demonstrated significant potential in biological data modeling. For instance, Zinati et al. proposed GRouNdGAN [65], a causal generative adversarial network based on gene regulatory networks (GRNs) for simulating single-cell RNA-seq data. Through causal graph constraints, the model preserves gene identities, regulatory relationships, and dynamic behaviors, providing valuable support for biomedical analysis and disease mechanism research.

Another important application lies in privacy-preserving synthetic data. Chandrasekaran et al. developed a causally consistent deep generative model, based on a VAE architecture, to produce synthetic data sets that maintain causal structure while ensuring privacy [66]. Jin and Syrgkanis investigated the identifiability and ambiguity of learning causal representations across heterogeneous environments [67], offering theoretical insights into causal generative modeling. More recently, Sanchez and Tsaftaris explored diffusion-based causal generative models for counterfactual estimation [68], demonstrating the capability of integrating diffusion processes with causal semantics for complex data generation tasks.

Collectively, these studies form a comprehensive theoretical and methodological framework for causal generative models. By combining causal interpretability with the expressive power of deep generative modeling, they greatly enhance the controllability, robustness, and explainability of data generation, offering significant potential for future applications in scientific discovery, trustworthy AI, and privacy-aware data synthesis.

6.7. Reinforcement Learning Generative Models

Reinforcement learning (RL) has recently become an important paradigm for generative modeling, offering a dynamic decision-making mechanism that enables models to generate data aligned with specific objectives or human preferences. In contrast with likelihood-based generative models, RL formulates data generation as a sequential decision process, where an agent iteratively produces content and receives evaluative feedback from an environment. This process is typically modeled as a Markov decision process (MDP), in which the agent selects actions based on its current state and updates its policy to maximize cumulative reward.

Traditional RL-based generative methods rely on predefined reward functions. However, manually designed rewards often fail to capture nuanced human judgments regarding quality, usefulness, or safety. To overcome this limitation, Bai et al. introduced reinforcement learning from human feedback (RLHF) [69], incorporating human evaluations as reward signals for guiding the generator. In this framework, a generator—commonly implemented using Transformer architectures—produces sequential outputs such as text or time series. A learned reward model, trained from human preference data, assigns scores to generated sequences. The generator is then optimized via RL (e.g., PPO), adjusting its policy to maximize these human-aligned rewards. This approach effectively enhances both the quality and value alignment of the generated content.

RL-based generative methods have found increasing use in domain-specific data generation. In healthcare, Yu et al. surveyed RL applications in medical decision-making and synthetic data generation [70], demonstrating its potential for generating clinically meaningful data and optimizing treatment strategies. In graph generation, Rupp and Eckert proposed G-PCGRL [71], which employs RL over graph adjacency matrices to produce synthetic graphs satisfying structural constraints, offering high-quality training data for graph neural networks. In natural language interfaces, Zhong et al. applied RL to generate structured SQL queries from text descriptions [72], where RL feedback improved query accuracy and execution efficiency.

RL has also been leveraged for data augmentation. Zhou et al. introduced FlipDA [73], an RL-based augmentation method that produces effective synthetic samples for few-shot learning, significantly improving model robustness. Zhu et al. developed Texygen [74], a benchmarking platform demonstrating how RL techniques can be used to optimize sequence generation through reward-driven learning. In adversarial example generation, Zhang et al. proposed PAWS [75], using RL to generate high-quality synonym-based adversarial samples, thereby enhancing the robustness of language models. Similarly, Zhou et al. used RL to generate temporally plausible sequences adhering to common-sense temporal constraints [76], enabling models to synthesize time series consistent with human cognitive patterns.

Overall, reinforcement learning provides a flexible and powerful framework for generative modeling. By integrating dynamic decision processes, reward shaping, and human feedback, RL-based generative models substantially improve the quality, diversity, and value alignment of generated data. These developments demonstrate strong performance across domains including natural language processing, healthcare, graph generation, and time series modeling, offering important theoretical and practical insights for future research.

7. Temporal Link Prediction as Missing Data Modeling in Dynamic Networks

In temporal networks, missing data often manifests as unobserved, censored, or future edges, rather than missing node attributes. This form of structural incompleteness arises naturally in dynamic systems due to limited observation windows, asynchronous data collection, or evolving network topologies. From this perspective, temporal link prediction can be regarded as a missing data modeling problem on the adjacency structure of networks, aiming to infer latent or future interactions by leveraging temporal and topological dependencies.

Unlike traditional time series imputation, which focuses on recovering missing values on fixed entities, link prediction explicitly models relations among nodes, requiring the joint consideration of network structure, temporal evolution, and relational patterns. In recent years, it has become a core research direction for missing data modeling in temporal networks.

7.1. Structure- and Similarity-Based Modeling Approaches

Early link prediction methods rely on structural similarity heuristics, which estimate the likelihood of missing or future edges using local or global topological measures. Representative examples include Common Neighbors (CN), Preferential Attachment (PA), and Adamic–Adar (AA) indices [77,78,79]. In temporal settings, these measures are often extended with time-aware weighting or decay mechanisms to emphasize recent interactions.

Beyond heuristic methods, dynamic stochastic block models (DSBMs) provide a probabilistic framework for modeling temporal networks by allowing community structures and inter-community connection probabilities to evolve over time [80,81]. Missing edges are treated as latent variables generated according to evolving block-level interaction patterns. These models offer strong interpretability and naturally capture structural missingness, but may face scalability challenges in large and rapidly evolving networks.

Together, similarity-based heuristics and probabilistic block models form a class of approaches that emphasize explicit structural assumptions, making them suitable for the interpretable modeling of missing links in moderately sized temporal networks.

7.2. Temporal Process and Matrix/Tensor-Based Methods

Another important class of link prediction approaches models temporal networks through event-driven or latent factor representations. Temporal point process models, particularly Hawkes processes, represent interactions as time-stamped events and capture temporal dependencies through self- and mutual-excitation mechanisms [82,83]. In this setting, missing links correspond to unobserved interaction events governed by an underlying intensity function.

Alternatively, dynamic matrix and tensor completion methods represent temporal networks as sequences of adjacency matrices or higher-order tensors with missing entries [84,85]. By enforcing low-rank, smoothness, or structured constraints across time, these methods infer missing edges as part of a global completion problem. Such formulations provide a natural connection between classical missing data imputation and link prediction, and are particularly effective when temporal correlations and global structural patterns are strong.

While these approaches offer solid theoretical foundations, their performance depends on modeling assumptions such as low-rank structure or event stationarity, which may limit their flexibility in highly non-stationary or sparse networks.

7.3. Learning-Based and Generative Graph Models

Recent advances in representation learning have led to temporal graph neural networks (TGNNs) that jointly model network topology, node attributes, and temporal dynamics [86,87]. In link prediction tasks, TGNNs learn time-evolving node embeddings through message passing and temporal encoding mechanisms, enabling them to infer missing or future edges from partially observed network states.

In parallel, generative graph models, including variational graph autoencoders and diffusion-based graph generation approaches, provide probabilistic frameworks for modeling the joint distribution of network structure and temporal evolution [88,89,90]. From a missing data perspective, these models treat missing links as latent variables and aim to reconstruct or generate complete network realizations consistent with observed data.

Learning-based and generative methods offer strong expressive power and adaptability to large-scale networks, but often require substantial computational resources and careful training, and their interpretability remains an open challenge.

7.4. Relationship to Traditional Time Series Imputation

Compared with traditional time series imputation methods, temporal link prediction differs fundamentally in its modeling objectives and assumptions. Rather than recovering missing attribute values, link prediction focuses on inferring missing structural relationships. It must simultaneously account for temporal dependencies and network topology, leading to more complex dependency structures and evaluation criteria. These distinctions underscore the necessity of treating temporal link prediction as a dedicated category of missing data modeling in networked systems.

8. Conclusions and Future Prospects

This paper presents a comprehensive survey of missing data generation and imputation methods for networked and temporal data, spanning a broad methodological spectrum that includes classical statistical approaches, matrix and tensor decomposition methods, traditional machine learning techniques, deep generative models, and temporal link prediction methods. Rather than treating these approaches in isolation, the survey systematically compares them from the perspectives of missingness mechanisms, modeling assumptions, application scenarios, and scalability, thereby highlighting their respective strengths and limitations in practical settings.

As shown in Table 2, traditional methods, such as classical statistical techniques and low-rank matrix or tensor decomposition, benefit from explicit structural assumptions, interpretability, and computational efficiency, making them well suited for MCAR or MAR settings and moderately sized networks. However, their reliance on linearity or low-rank structure limits their effectiveness when facing complex nonlinear patterns or severe data sparsity. Neighborhood-based and classical machine learning methods provide flexible, assumption-light alternatives that can capture local dependencies, yet they often suffer from scalability challenges and degraded performance in high-dimensional or large-scale networks.

Table 2. Comparative summary of missing data generation methods for network data.

Method Category	Representative Methods	Suitable Missingness	Core Assumptions	Typical Applications	Large-Scale Networks
Classical Statistical Methods	Regression Imputation, EM, Bayesian PCA, GMM, and ARMA.	MCAR, partially MAR.	Linear or parametric distributions; weak inter-node dependency.	Sensor readings, low-dimensional monitoring data.	No
Matrix/Tensor-based Methods	MF, SVD, Tucker, and Dynamic Tensor Completion	MCAR and MAR.	Low-rank structure; global correlation patterns.	Traffic networks and spatiotemporal measurements.	Yes
Classic Machine Learning Methods	KNN/WKNN, STWKNN, RF, Kriging, and Clustering-based Imputation.	MCAR and MAR.	Local similarity or neighborhood consistency.	Environmental sensing and geospatial networks.	Partially
Deep Learning Generative Models	VAE, GAN, Normalizing Flow, and Diffusion Models.	MAR and MNAR.	Learnable latent distributions; sufficient training data.	High-dimensional network attributes; multimodal data.	Partially
Temporal Link Prediction Methods	CN/PA/AA, DSBM, Hawkes Processes, Temporal GNNs, and Graph Diffusion Models.	Structural missingness (missing edges).	Temporal and topological dependencies in evolving networks.	Dynamic social networks; communication and interaction graphs.	Yes

Deep generative models substantially expand the modeling capacity by learning complex nonlinear representations and joint data distributions. Variational autoencoders and normalizing flows offer probabilistic and likelihood-based formulations, while autoregressive models explicitly capture conditional dependencies. Diffusion probabilistic models further improve generation stability and fidelity through multi-scale noise modeling, albeit at the cost of a higher computational overhead. These approaches are particularly effective under MAR and MNAR mechanisms, but they typically require large training data sets and substantial computational resources.

In addition, temporal link prediction methods constitute a distinct and increasingly important class of missing data modeling techniques, focusing on structural missingness in dynamic networks. By leveraging topological and temporal dependencies through heuristic similarity measures, stochastic block models, temporal point processes, dynamic matrix/tensor completion, temporal graph neural networks, and generative graph models, these methods enable principled inference of missing or future edges in evolving networks. Their scalability and direct alignment with network dynamics make them especially suitable for large-scale temporal applications.

Despite these advances, several fundamental challenges remain. Real-world missingness often arises from complex, non-random mechanisms that are difficult to observe or model explicitly. At the same time, there exists an inherent trade-off between interpretability, computational efficiency, and generative fidelity: highly expressive models tend to be resource intensive, while simpler or more interpretable methods rely on assumptions that may not hold in practice. Moreover, the absence of unified evaluation protocols complicates fair comparison across different method families, particularly when reconstructed data are used for downstream tasks rather than direct reconstruction accuracy.

Looking forward, future research is expected to move toward integrated frameworks that jointly model data distributions, missingness mechanisms, and network dynamics. Improving scalability and inference efficiency—especially for diffusion- and flow-based models—will be essential for real-world deployment on large networks. Furthermore, the integration of causal reasoning, temporal structure, and human-in-the-loop optimization offers promising directions for enhancing robustness, interpretability, and alignment with domain knowledge. Continued progress along these dimensions will be critical for advancing missing data generation methods into reliable, transparent, and practically impactful tools across diverse networked systems.