Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/gramian/hapod
HAPOD - Hierarchical Approximate Proper Orthogonal Decomposition
https://github.com/gramian/hapod
data-driven data-reduction data-science datascience dimension-reduction distributed-memory high-performance-computing hpc limited-memory mapreduce mapreduce-algorithm model-order-reduction model-reduction pca pod proper-orthogonal-decomposition svd unsupervised-learning
Last synced: 6 days ago
JSON representation
HAPOD - Hierarchical Approximate Proper Orthogonal Decomposition
- Host: GitHub
- URL: https://github.com/gramian/hapod
- Owner: gramian
- License: bsd-2-clause
- Archived: true
- Created: 2017-05-29T12:48:14.000Z (over 7 years ago)
- Default Branch: main
- Last Pushed: 2021-08-23T09:29:54.000Z (about 3 years ago)
- Last Synced: 2024-05-18T21:47:16.121Z (6 months ago)
- Topics: data-driven, data-reduction, data-science, datascience, dimension-reduction, distributed-memory, high-performance-computing, hpc, limited-memory, mapreduce, mapreduce-algorithm, model-order-reduction, model-reduction, pca, pod, proper-orthogonal-decomposition, svd, unsupervised-learning
- Language: MATLAB
- Homepage: https://git.io/hapod
- Size: 26.4 KB
- Stars: 14
- Watchers: 4
- Forks: 4
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
- Citation: CITATION
Awesome Lists containing this project
README
HAPOD - Hierarchical Approximate Proper Orthogonal Decomposition
================================================================
* HAPOD - Hierarchical Approximate POD
* version: 3.2 (2021-05-05)
* by: C. Himpe (0000-0003-2194-6754), S. Rave (0000-0003-0439-7212)
* under: BSD 2-Clause License (opensource.org/licenses/BSD-2-Clause)
* summary: Fast distributed or incremental POD computation.
## About
The HAPOD is an algorithm to compute the POD (left singular vectors, and
singular values of a matrix) hierarchically for (column-wise partitioned)
large-scale matrices, allowing to balance accuracy with performance. As a
POD-of-PODs method, the HAPOD can be parallelized and further accelerated by
user supplied SVD implementations.
## Scope
* Proper Orthogonal Decomposition (POD)
* Singular Value Decomposition (SVD)
* Principal Axis Transformation (PAT)
* Principal Component Analysis (PCA)
* Empirical Orthogonal Functions (EOF)
* Empirical Eigenfunctions (EEF)
* Karhunen-Loeve Transformation (KLT)
## Applications
* Dimension Reduction
* Model Reduction
* Low-Rank Approximation
* Data Compression
* Unsupervised Learning
## Features
* Error-driven
* Rigorous bounds
* Single pass (each data vector is needed only once)
* Column-wise data partitions (inducing parallelizability)
* Custom SVD backends
## Functionality
* Standard POD
* Incremental HAPOD -> for memory-limited environments, e.g. single-board-computers
* Distributed HAPOD -> for distributd memory environments, e.g. super-computers
* Distributed-of-Incremental HAPOD
## Algorithm
C. Himpe, T. Leibner, S. Rave:
"[Hierarchical Approximate Proper Orthogonal Decomposition](http://hdl.handle.net/21.11116/0000-0002-5342-6)";
SIAM Journal on Scientific Computing, 40(5): A3267--A3292, 2018.
## Compatibility
* GNU Octave >= 4.0
* Mathworks MATLAB >= 2013b
## Basic Usage
```
[svec,sval,meta] = hapod(data,bound,topo,relax,meta,depth,mysvd)
```
## Arguments
* `data` {cell} - snapshot data set, partitioned by column (blocks)
* `bound` {scalar} - mean L_2 projection error bound
* `topo` {string} - tree topology (see **Topology**)
* `relax` {scalar} - relaxation parameter in (0,1) (see **Relaxation**)
* `depth` {scalar} - total number of levels in tree (only required for `incr_1`)
* `meta` {struct} - meta information structure (see **Meta-Information**)
* `mysvd` {handle} - custom SVD backend (see **Custom SVD**)
## Return Values
* `svec` {matrix} POD modes (column vectors)
* `sval` {vector} Singular values (column vector)
* `meta` {struct} Meta-information structure
## Topology
The HAPOD is computed based on a tree topology `topo`, with the data partitions
at the tree's leafs. The following topologies are available:
* `'none'` Standard POD
* `'incr'` Incremental HAPOD (Complete)
* `'incr_1'` Incremental HAPOD (Child nodes)
* `'incr_r'` Incremental HAPOD (Root node)
* `'dist'` Distributed HAPOD (Complete)
* `'dist_1'` Distributed HAPOD (Child nodes)
* `'dist_r'` Distributed HAPOD (Root node)
If all data partitions can be passed as the data argument, the types: `none`
(standard POD), `incr`(emental) HAPOD or `dist`(ributed) HAPOD are applicable.
In case only a single partition is passed at a time, the types: `incr_1` and
`dist_1` should be used for the child nodes of the associated HAPOD tree, while
the types: `incr_r` and `dist_r` should be used for the root nodes. The returned
meta-information structure (or a cell-array thereof) has to be passed to the
parent node in the associated HAPOD tree.
## Relaxation
The relaxation parameter `w` (`0 < w < 1`) balances accuracy versus speed.
Larger `w` near one means be more accurate, while `w` near zero means faster
computation. The default value is `w = 0.5`.
## Meta-Information
The `meta` structure contains the following meta-information of the completed
sub-tree:
* `nSnapshots` - Number of data columns passed to this HAPOD and its children.
* `nModes` - Number of intermediate modes.
* `tNode` - Computational time at this HAPOD's branch.
The argument `meta` only needs to be passed for topology types `incr_r`,
`dist_r` and `incr_1`, unless it is first leaf. Especially, this means the user
never has to create such a structure, since if it is required it is given as a
previous HAPOD's return value.
## Custom SVD
Via the `mysvd` argument a custom SVD function can be provided via a function
handle with the following signature:
```
[U,d] = mysvd(X)
```
for a data matrix `X`, and returning left singular vectors in matrix `U` and
singular values in column vector `d`. By default (or `mysvd` = `eco`) a standard
rank-revealing SVD is used. Additionally, by `mysvd` = `mos` the method of
snapshots can be selected.
## Getting Started
Run the sample code:
```
RUNME()
```
which demonstrates the different implemented HAPOD variants and can be used
as a template.
### MapReduce
The distributed HAPOD is well suited for the [MapReduce](https://en.wikipedia.org/wiki/MapReduce)
big data processing model. A basic MapReduce wrapper using the MATLAB (>=2020b)
[mapreduce](https://www.mathworks.com/help/matlab/ref/mapreduce.html) function
is provided by:
```
MAPRED()
```
## Cite As
C. Himpe, T. Leibner and S. Rave:
"[Hierarchical Approximate Proper Orthogonal Decomposition](https://doi.org/10.1137/16M1085413)";
SIAM Journal on Scientific Computing, 40(5): A3267--A3292, 2018.
## Used In
* P. Benner, C. Himpe:
"[Cross-Gramian-Based Dominant Subspaces](https://doi.org/10.1007/s10444-019-09724-7)";
Advances in Computational Mathematics, 45(5): 2533--2553, 2019.
* B.J. Beach:
"[An Implementation-Based Exploration of HAPOD: Hierarchical Approximate Proper Orthogonal Decomposition](http://hdl.handle.net/10919/81938)";
Virgina Tech, Master Thesis, 2018.
* C. Himpe, T. Leibner, S. Rave, J. Saak:
"[Fast Low-Rank Empirical Cross Gramians](https://doi.org/10.1002/pamm.201710388)";
Proceedings in Applied Mathematics and Mechanics, 17: 841--842, 2017.
## See Also
* C. Himpe, T. Leibner, S. Rave:
"[HAPOD - Fast, Simple and Reliable Distributed POD Computation](https://doi.org/10.11128/arep.55.a55283)";
ARGESIM Report 55 (MATHMOD 2018 Volume): 119--120, 2018.
* C. Himpe, T. Leibner, S. Rave:
"[Comprehensive Memory-Bound Simulations on Single Board Computers](https://doi.org/10.5281/zenodo.814497)";
Extended Abstract, 2nd Conference on Power Aware Computing (PACO), 2017.
* C. Himpe and S. Rave.
"[HAPOD - Hierarchical Approximate POD](https://himpe.science/poster/rave16_morml.pdf)".
Data-Driven Model Order Reduction and Machine Learning (MORML), 2016.