Skip to content

8 1 autoencoders

Detailed Autoencoders Examples for xtorch

This document expands the "Time Series and Graph Generative Models -> Autoencoders" subcategory of examples for the xtorch library, a C++ deep learning framework that extends PyTorch’s LibTorch API with user-friendly abstractions. The goal is to provide a comprehensive set of beginner-to-intermediate examples that introduce users to autoencoder-based generative modeling tasks, with a focus on time series and graph applications to align with the broader category. These examples showcase xtorch’s capabilities in model building, training, data handling, and integration with C++ ecosystems, and are designed to be included in the xtorch-examples repository, helping users learn autoencoders in C++.

Background and Context

xtorch simplifies deep learning for C++ developers by offering high-level model classes (e.g., XTModule, ResNetExtended, XTCNN), a streamlined training loop via the Trainer module, enhanced data utilities (e.g., ImageFolderDataset, CSVDataset), extended optimizers, and model serialization tools (e.g., save_model(), export_to_jit()). The original two autoencoder examples—denoising autoencoders for image restoration and variational autoencoders (VAEs) for latent space exploration—provide a solid foundation. This expansion adds six more examples to cover additional architectures (e.g., convolutional autoencoders, LSTM autoencoders, graph autoencoders), datasets (e.g., UCI Time Series, PhysioNet ECG, Cora, QM9), and techniques (e.g., anomaly detection, graph reconstruction, transfer learning), ensuring a broad introduction to autoencoders with a focus on time series and graph generative modeling.

The current time is 11:00 AM PDT on Monday, April 21, 2025, and all considerations are based on available information from the xtorch GitHub repository (xtorch GitHub Repository) without contradicting this timeframe.

Expanded Examples

The following table provides a detailed list of eight "Time Series and Graph Generative Models -> Autoencoders" examples, including the original two and six new ones. Each example is designed to be standalone, with a clear focus on a specific autoencoder concept or xtorch feature, making it accessible for users.

Category Subcategory Example Title Description
Time Series and Graph Generative Models Autoencoders Denoising Autoencoders for Image Restoration Trains a denoising autoencoder to restore noisy images on the MNIST dataset (handwritten digits). Uses xtorch’s xtorch::nn::Conv2d to build a convolutional encoder-decoder, trains with Mean Squared Error (MSE) loss, and evaluates with reconstruction error (MSE) and visual quality.
Variational Autoencoders for Latent Space Exploration Implements a Variational Autoencoder (VAE) for generating new image samples via latent space exploration on MNIST. Uses xtorch’s xtorch::nn to model the encoder and decoder with KL-divergence and reconstruction loss, evaluates with generated sample quality (visual inspection) and log-likelihood.
Convolutional Autoencoders for Time Series Denoising Trains a convolutional autoencoder to denoise time series data from the UCI Appliances Energy Prediction dataset (energy consumption). Uses xtorch’s xtorch::nn::Conv1d to process temporal sequences, trains with MSE loss, and evaluates with reconstruction error and signal-to-noise ratio (SNR).
LSTM Autoencoders for Time Series Anomaly Detection Implements an LSTM-based autoencoder for anomaly detection in time series data from the PhysioNet ECG dataset (heart signals). Uses xtorch’s xtorch::nn::LSTM to capture temporal dependencies, trains with MSE loss, and evaluates with reconstruction error and Area Under the ROC Curve (AUC-ROC) for anomaly detection.
Graph Autoencoders for Node Embedding on Cora Trains a graph autoencoder to reconstruct node features and graph structure on the Cora dataset (citation network). Uses xtorch’s xtorch::nn for graph convolutional layers, trains with reconstruction loss (MSE for features, cross-entropy for adjacency), and evaluates with reconstruction loss and downstream node classification accuracy.
Variational Graph Autoencoders for Graph Generation Implements a Variational Graph Autoencoder (VGAE) to generate graph structures on the QM9 dataset (small molecules). Uses xtorch to model latent graph distributions with graph convolutions and KL-divergence, trains with reconstruction and KL losses, and evaluates with graph similarity metrics (e.g., graph edit distance).
Transfer Learning with Autoencoders for Image Datasets Fine-tunes a pre-trained denoising autoencoder from MNIST to another image dataset (e.g., Fashion-MNIST). Uses xtorch’s model loading utilities to adapt the model, trains with MSE loss, and evaluates with adaptation performance (reconstruction error reduction) and training efficiency.
Real-Time Autoencoder Visualization with xtorch and OpenCV Combines xtorch with OpenCV to perform real-time denoising of streaming time series data (e.g., sensor data from IoT devices). Uses a trained convolutional autoencoder to reconstruct clean signals, visualizes outputs in a GUI, and evaluates with qualitative reconstruction accuracy, highlighting C++ ecosystem integration.

Rationale for Each Example

  • Denoising Autoencoders for Image Restoration: Introduces denoising autoencoders, a foundational generative model, using MNIST for its simplicity. It’s beginner-friendly and teaches reconstruction basics.
  • Variational Autoencoders for Latent Space Exploration: Demonstrates VAEs, a probabilistic generative model, using MNIST to teach latent space sampling and image generation.
  • Convolutional Autoencoders for Time Series Denoising: Extends autoencoders to time series, using UCI data to teach temporal denoising, aligning with the time series focus of the category.
  • LSTM Autoencoders for Time Series Anomaly Detection: Introduces LSTM-based autoencoders for anomaly detection, using ECG data to teach temporal dependency modeling and practical applications in time series.
  • Graph Autoencoders for Node Embedding on Cora: Demonstrates graph autoencoders, using Cora to teach graph structure reconstruction and node embeddings, aligning with the graph generative focus.
  • Variational Graph Autoencoders for Graph Generation: Introduces VGAEs for probabilistic graph generation, using QM9 to teach molecular graph modeling, relevant for cheminformatics.
  • Transfer Learning with Autoencoders for Image Datasets: Teaches transfer learning, a practical technique for reusing models, using MNIST and Fashion-MNIST to show adaptation efficiency.
  • Real-Time Autoencoder Visualization with xtorch and OpenCV: Demonstrates real-time generative modeling, integrating xtorch with OpenCV to visualize time series denoising, relevant for IoT applications.

Implementation Details

Each example should be implemented as a standalone C++ program in the xtorch-examples repository, with the following structure: - Source Code: A main.cpp file containing the example code, using xtorch’s API (e.g., xtorch::nn, xtorch::data, xtorch::optim) and, where applicable, OpenCV for visualization. - Build Instructions: A CMakeLists.txt file to compile the example, linking against xtorch, LibTorch, and OpenCV (if needed). - README.md: A detailed guide explaining the example’s purpose, prerequisites (e.g., LibTorch, dataset downloads, OpenCV), steps to run, and expected outputs (e.g., MSE, AUC-ROC, log-likelihood, graph similarity, or visualized outputs). - Dependencies: Ensure users have xtorch, LibTorch, and datasets (e.g., MNIST, UCI Appliances, PhysioNet ECG, Cora, QM9, Fashion-MNIST) installed, with download instructions in each README. For OpenCV integration or graph data handling, include setup instructions. Graph datasets may require custom utilities or integration with C++ graph libraries.

For example, the “LSTM Autoencoders for Time Series Anomaly Detection” might include: - Code: Define an LSTM autoencoder with xtorch::nn::LSTM for encoder and decoder, process ECG data from PhysioNet, train with MSE loss using xtorch::optim::Adam, and evaluate reconstruction error and AUC-ROC using xtorch’s metrics module. - Build: Use CMake to link against xtorch and LibTorch, specifying paths to PhysioNet ECG data. - README: Explain LSTM autoencoders and their role in anomaly detection, provide compilation commands, and show sample output (e.g., AUC-ROC of ~0.90 on ECG test set).

Why These Examples?

These examples are designed to: - Cover Core Concepts: From basic denoising autoencoders and VAEs to advanced LSTM and graph autoencoders, they introduce key generative modeling paradigms, covering image, time series, and graph data. - Leverage xtorch’s Strengths: They highlight xtorch’s high-level API, data utilities, and C++ performance, particularly for temporal and graph-based models and real-time applications. - Be Progressive: Examples start with simpler models (denoising autoencoders) and progress to complex ones (LSTM autoencoders, VGAEs), supporting a learning path. - Address Practical Needs: Techniques like anomaly detection, graph generation, transfer learning, and real-time visualization are widely used in real-world applications, from healthcare to cheminformatics. - Encourage Exploration: Examples like VGAEs and LSTM autoencoders expose users to cutting-edge generative modeling techniques, fostering innovation.

Feasibility and Alignment with xtorch

The examples are feasible given xtorch’s features, as outlined in its GitHub repository: - Model Building: xtorch::nn::Sequential, Conv2d, Conv1d, LSTM, and custom modules support defining denoising autoencoders, VAEs, LSTM autoencoders, and graph autoencoders. - Data Handling: xtorch::data::CSVDataset and custom utilities handle image, time series, and graph datasets (e.g., MNIST, UCI, Cora, QM9), with support for preprocessing (e.g., noise addition, temporal windows, adjacency matrices). - Training: The Trainer API and optimizers (e.g., xtorch::optim::Adam) simplify training and support losses like MSE, KL-divergence, and graph reconstruction losses. - Evaluation: xtorch’s metrics module supports MSE, AUC-ROC, log-likelihood, graph similarity (e.g., graph edit distance), and downstream task performance, critical for autoencoder evaluation. - C++ Integration: xtorch’s compatibility with OpenCV enables real-time visualization of reconstructed outputs.

The examples align with xtorch’s goal of simplifying deep learning in C++ and fit the "Time Series and Graph Generative Models" context by including time series and graph-specific applications, making them ideal for the xtorch-examples repository’s autoencoders section.

Comparison with Existing Practices

Popular deep learning libraries like PyTorch provide autoencoder tutorials, such as “Variational Autoencoders” (PyTorch Tutorials), which covers VAEs on MNIST. The proposed xtorch examples mirror this approach but adapt it to C++, emphasizing xtorch’s unique features like the Trainer API, real-time performance, and OpenCV integration. They also include time series and graph-specific applications (e.g., LSTM autoencoders, VGAEs) to align with the category and modern generative modeling trends, as seen in repositories like “pyg-team/pytorch_geometric” for graph-based models (GitHub - pyg-team/pytorch_geometric).

Implementation Notes

  • Directory Structure: Organize xtorch-examples with a time_series_and_graph_generative_models/autoencoders/ directory, containing subdirectories for each example (e.g., denoising_mnist/, vae_mnist/).
  • User Guidance: The main README.md should list all examples, suggest a learning path (e.g., start with denoising autoencoders, then VAEs, then graph autoencoders), and link to xtorch’s documentation.
  • C++ Focus: Ensure code uses modern C++ practices (e.g., smart pointers, exception handling) and includes detailed comments for clarity.
  • Dependencies: Note that users need LibTorch, xtorch, datasets (e.g., MNIST, UCI Appliances, PhysioNet ECG, Cora, QM9, Fashion-MNIST), and optionally OpenCV installed, with download and setup instructions in each README. Graph data handling may require custom utilities or integration with C++ graph libraries.

Conclusion

The expanded list of eight "Time Series and Graph Generative Models -> Autoencoders" examples provides a comprehensive introduction to autoencoder-based generative modeling with xtorch, covering denoising autoencoders, VAEs, convolutional and LSTM autoencoders for time series, graph autoencoders, VGAEs, transfer learning, and real-time visualization. These examples are beginner-to-intermediate friendly, leverage xtorch’s strengths, and align with its goal of making deep learning accessible in C++ while addressing time series and graph applications. By including them in xtorch-examples, you can help users build a solid foundation in autoencoder-based generative modeling, fostering adoption and engagement with the xtorch community.

Key Citations