This version of FAµST updates the mex wrappers toward the R2018a API. Precisely it uses now the interleaved complex API (instead of the obsolete separate complex API).

Besides, it optimizes the Faust-matrix product by avoiding copies between the matlab wrapper and the C++ core as the figure shows below.

With this version you’ll be able to build Fausts of BSR matrices using pyfaust. This matrix format accelerates the Faust-matrix product for many Fausts that are structured in nonzero blocks. The figure below is an illustration of this acceleration for a Faust of size 1024×1024, composed of 10 factors of the same size, each of them containing 20 128×128-blocks of nonzeros. The benchmark compares the product times when the Faust is encoded as a BSR Faust, a CSR Faust (hence without explicit blocks) or into a BSR scipy Faust (that is a Python list of scipy.sparse.bsr_matrix). This benchmark shows a significant speedup of the BSR Faust relatively to the CSR Faust. Besides it demonstrates that the FAµST implementation can sometimes do much better than a scipy BSR matrix list used as a Faust.
Another interesting point is that the memory space needed to store a BSR Faust is smaller than the one needed for a CSR Faust. In the case tested here it took only 25 Mb to load the Faust in memory while the CSR Faust needed 37.54 Mb (see the Faust.nbytes function).
The benchmark script is available here and the corresponding plot script here.

Note: this new matrix format is still in beta status.

Update 1 (12/06 2021): matfaust supports BSR matrices since FAµST 3.18.0.

Update 2 (12/08 2021): since FAµST 3.19.0 it’s possible to save/restore a Faust composed of BSR matrices.

Update 3 (01/04 2022): FAµST 3.22.0 provides matfaust.rand_bsr and pyfaust.rand_bsr functions designed to easily generate random BSR Fausts.

This version fixes the issue documented in the FAQ here without disabling the PALM4MSA normalization of factors as it was first proposed. The float precision leads in some rare cases (e.g. 512×512 Hadamard matrix factorization) to errors in the 2-norm of some L or R Fausts in the PALM4MSA algorithm. By recomputing these norms in double precision it allows to avoid NaN norms to make the algorithm fail.

Note: this workaround is only available on the 2020 implementation of PALM4MSA.

This version adds the option no_lambda in the hierarchical and PALM4MSA algorithms. It allows to fix lambda to 1 in the overall algorithm without any update (and no lambda gradient calculation). Associated with the no_normalization parameter, it accelerates the algorithm without necessarily reducing the precision of the Faust approximate as the first figure below shows for the MEG matrix factorization (parameterized as shown in API doc here, section 3. along with the no_normalization and no_lambda parameters to True).

The second figure shows that disabling the normalization and keeping lambda to 1 allows also to obtain a good Faust approximate of a Hadamard matrix (actually better than with normalization and seemingly more stable when increasing the Hadamard matrix size).

Note: the options no_lambda and no_normalization are only available with the 2020 implementations of PALM4MSA and the hierarchical algorithm.

Note: This is an experimental work that needs further theoretical considerations.

This version of FAµST dropped the support of Python 3.8 in exchange to Python 3.10 (Python 3.9 is still supported).

The Windows .exe installer has also been fixed (removing a bug in the matlab part of the install).

This version of FAµST provides a new PIP wheel package built with the OpenBLAS-OpenMP support enabled. This BLAS backend makes possible to speed up some Faust operations like Faust.torray (or other Faust-matrix products). The figure below illustrates how the speedup can show up.

Installing this package is straightforward with pip: pip install pyfaust-openblaso (note that it is currently limited to Linux only).

PALM4MSA normalization is now an optional feature but it stays enabled by default in matfaust and pyfaust. Please look at this FAQ entry for further details.

A FAµST-to-Torch C++ interface has been developed. It has permitted to compare the execution times of Faust-Matrix and Faust-to-array operations of the FAµST C++ core with what is made possible in Torch through tensors. Experiments showed that using pyfaust-torch is particularly interesting on Intel CPUs (besides, a AMD CPU was tried but showed a poor performance).
Hence the pyfaust-torch experimental pip/whl packages are now publicly available for Linux and MacOS X (via the command: pip install pyfaust-torch). Nevertheless please note that the support of these packages is purely temporary and might not be continued in the long term.

Here are some API/doc references related to pyfaust-torch:

• • the pyfaust.FaustMulMode class,
  • the pyfaust.Faust.optimize_time function,
  • the jupyter notebook about Faust optimizations.

This version optimizes the Faust item access (F[i,j] in pyfaust, F(i,j) in matfaust). Take a look at the following figure to get an idea of the speedup.

N.B.: Although this optimization speeds up the Faust element indexing, please note that the use of this Faust operation in algorithms is still discouraged because contrary to matrix element indexing which is performed by a direct memory access, for a Faust it needs some calculations.

The float scalar type is now supported by the matfaust API for both CPU and GPU. Besides, the GPU features of matfaust are now compatible with CUDA 11 (in addition to CUDA 9).

Note: Matlab doesn’t support float sparse matrices, but matfaust does! Hence when you call Faust.factors on a float sparse Faust to retrieve one factor you’ll get a double sparse matrix as a copy of the float sparse matrix.