ProSper -- A Python Library for Probabilistic Sparse Coding with Non-Standard Priors and Superpositions

TL;DR

ProSper is a versatile Python library that extends dictionary learning methods to handle non-linear data, flexible priors, and large-scale problems with scalable, parallel algorithms.

Contribution

The library introduces novel probabilistic algorithms for dictionary learning that go beyond standard methods like ICA and NMF, supporting non-linear components and flexible priors.

Findings

Supports large-scale dictionary learning with hundreds of CPUs.

Includes diverse algorithms like BSC, TSC, DSC, MCA, MMCA, GSC.

Enables inference of prior and noise parameters.

Abstract

ProSper is a python library containing probabilistic algorithms to learn dictionaries. Given a set of data points, the implemented algorithms seek to learn the elementary components that have generated the data. The library widens the scope of dictionary learning approaches beyond implementations of standard approaches such as ICA, NMF or standard L1 sparse coding. The implemented algorithms are especially well-suited in cases when data consist of components that combine non-linearly and/or for data requiring flexible prior distributions. Furthermore, the implemented algorithms go beyond standard approaches by inferring prior and noise parameters of the data, and they provide rich a-posteriori approximations for inference. The library is designed to be extendable and it currently includes: Binary Sparse Coding (BSC), Ternary Sparse Coding (TSC), Discrete Sparse Coding (DSC), Maximal Causes Analysis (MCA), Maximum Magnitude Causes Analysis (MMCA), and Gaussian Sparse Coding (GSC, a recent spike-and-slab sparse coding approach). The algorithms are scalable due to a combination of variational approximations and parallelization. Implementations of all algorithms allow for parallel execution on multiple CPUs and multiple machines for medium to large-scale applications. Typical large-scale runs of the algorithms can use hundreds of CPUs to learn hundreds of dictionary elements from data with tens of millions of floating-point numbers such that models with several hundred thousand parameters can be optimized. The library is designed to have minimal dependencies and to be easy to use. It targets users of dictionary learning algorithms and Machine Learning researchers.

Tables

Table 1. Table 1: List of algorithms with their superposition models for component combination and their assumed distributions for observed and hidden variables.

Model	${\int }^A$Properties${\int }^A$
Acronym	superposition	obs. variables	noise type	hidden variables	prior model
BSC	linear	real	Gaussian	binary {0,1}	Bernoulli
TSC	linear	real	Gaussian	ternary {-1,0,1}	categorical/zero-mean
DSC	linear	real	Gaussian	discrete	categorical
GSC	linear	real	Gaussian	real	spike-and-slab
MCA	$\max$	real	Gaussian	binary {0,1}	Bernoulli
MMCA	$\left|\max \right|$	real	Gaussian	binary {0,1}	Bernoulli
GMM	none	real	Gaussian	one integer	categorical
PMM	none	integer ($\ge$0)	Poisson	one integer	categorical

Table 2. Table 2: List of Prosper models together with their associated references (main ref. bold).

Model	Full Name	References (bold for main reference)
BSC	Binary Sparse Coding	Lücke & Eggert JMLR 2010
		Henniges et al., Proc. LVA/ICA 2010
		Guiraud et al., GECCO, 2018
TSC	Ternary Sparse Coding	Exarchakis et al., Proc. LVA/ICA 2012
DSC	Discrete Sparse Coding	Exarchakis et al., Neural Comp. 2017
GSC	Gaussian Sparse Coding	Lücke & Sheikh, Proc. LVA/ICA 2012
	(spike + Gaussian slab)	Sheikh et al., JMLR 2014
MCA	Maximal Causes Analysis	Lücke & Sahani, JMLR 2008
		Lücke & Eggert JMLR 2010
		Puertas et al., NIPS 2010
		Sheikh et al., PLOS Comp. Bio. 2019.
MMCA	Max Magnitude MCA	Bornschein et al., PLOS Comp. Bio., 2013
GMM	Gaussian Mixture Model	standard EM for GMM algorithm
PMM	Poisson Mixture Model	standard EM for a Poisson mixture

Equations

$$p(\vec{s}|\Theta )$$

$$p(\vec{y}|\vec{s},\Theta )$$

Full text

∗contributed equally, *†*now at DeepMind, London, UK

Keywords: Python, parallel computing, software library, expectation-maximization, sparse coding, feature learning, latent variable models, variational approximations

1 Introduction

Dictionary learning is a broad subfield of Machine Learning with numerous applications in different data domains. It addresses the unsupervised extraction of latent components or factors of observed data samples. Classical examples of dictionary learning methods include deterministic approaches such as K-SVD, ICA, projection pursuit, NMF among many others. In contrast to deterministic approaches, probabilistic methodologies for dictionary learning are based on a generative data model to yield a probabilistic objective (typically the data likelihood) for optimization. While some probabilistic approaches such as sparse coding with a Gaussian noise model and Laplace prior (Olshausen and Field, 1996) closely link to popular deterministic $L_{1}$-regularized sparse coding, many other choices of priors do not have a corresponding counterpart. Similarly, it is straight-forward to define non-standard probabilistic data models, e.g., by choosing the component superposition assumption to be different from linear, which can be a more reasonable choice for many types of data (Bornschein et al., 2013; Dai et al., 2013; Sheikh et al., 2019). In several contributions, it was shown over the past years that such non-standard sparse coding models can efficiently be trained at large scales and with large data sets. Furthermore, parameters other than basis functions (i.e., dictionary elements) can be learned using recent approximate learning methods, notably the sparsity level and the data noise. The ProSper library contains such novel and non-standard sparse coding algorithms in a unified python software framework. Most notably, the used priors are binary, ternary, categorical or follow a spike-and-slab distribution, and the superposition models of components are linear or non-linear. Based on truncated posterior approximations (Lücke and Eggert, 2010) and MPI parallelization for many CPU nodes and cores, all algorithms can be efficiently applied to large data sets and large dictionary sizes (Henniges et al., 2010; Guiraud et al., 2018; Exarchakis et al., 2012; Exarchakis and Lücke, 2017; Lücke and Sheikh, 2012; Sheikh et al., 2014; Puertas et al., 2010; Sheikh et al., 2019; Bornschein et al., 2013). The software uses the NumPy and SciPy packages to define data and parameter containers and apply elementary numerical operations. ProSper algorithms are also enabled for parallel computing using the MPI for Python package and a data logging utility built on top of the PyTables package.

2 Learning Algorithm and Data Models

All the models included in ProSper are based on the following data generative process:

[TABLE]

where $\Theta$ is the set of model parameters (typically containing the dictionary $W$ but also prior and noise parameters). The models can be fully specified by defining Eq. 1 and 2, i.e., they are categorized based on the noise distribution, the prior distribution, and the function $\vec{f}$ that determines the influence of the latent variables on the observed variables ($\vec{f}$ can be thought of as a link function). The most common instance of the function $\vec{f}$ for dictionary learning is a linear function, e.g. $\vec{f}(\Theta,\vec{s})=W\vec{s}$, but the library allows for alternative choices. Tab. 1 lists the data models of the currently implemented algorithms.

All algorithms use expectation maximization for parameter optimization and truncated posteriors as efficient approximation (Lücke and Eggert, 2010). The approximation method has been successfully applied in numerous contexts to the models listed in Tab. 1. A list of scientific publications describing the models along with their specific implementation details for inference and learning can be found in Tab. 2.

3 User Interface and Documentation

The interface is designed to be as reusable and flexible as possible. We use three objects that compose a learning algorithm: Annealing, Model, and EM. The learned parameters are contained in a python dictionary that is shared among these objects. The Annealing object is responsible for the schedule of the learning algorithm and defines methods next, and reset to specify the step and technical interventions of the training process. The Model object, probably the most crucial element of our library, defines methods step and standard_init which respectively define one optimization step of the algorithm, and the initialization of the parameters. The run method of the EM object combines Annealing and Model by running a loop over the optimization step of the model modified as specified in the Annealing object.

Annealing schedules are specified by objects that inherit from the abstract Annealing class. As an example, we provide the class LinearAnnealing that controls the number of iterations of the training algorithm, parameter noise, and deterministic annealing of the approximate posterior. Similarly, Model instances inherit from the abstract Model class and implement the relevant methods. We provide implementations for the models listed in Tab. 2.

To run an algorithm, we start by instantiating a model with corresponding hyperparameters, e.g. model = BSC_ET(D, H, Hprime, gamma) were D and H are observed and latent dimensions respectively and Hprime and gamma approximation parameters. We proceed by initializing the annealing class, e.g. anneal = LinearAnnealing(150). Using a dictionary to store the data under the key ‘y’ we call the standard_init method to randomly initialize the parameters, e.g. params = model.standard_init({"y":data}). The EM class is initialized as em = EM(model=model, anneal=anneal) and we train the model with em.run(). We can then apply the inference method to extract approximate posterior information about the data, e.g. res=model.inference(anneal,em.lparams,data). This yields, e.g. the (estimated) most likely latent variable configurations (res["s"]) and corresponding approximate posterior probabilities (res["p"]) for each data point as well as additional information specific for each model.

4 Related Software Libraries

Most libraries for sparse coding or dictionary learning are based on deterministic objectives: The SPAMS library (Mairal et al., 2010, 2009) contains a collection of deterministic sparse coding algorithms with $L_{1}$, $L_{2}$ and $L_{\infty}$ regularization (C++ based, interfaces to Matlab, R and Python). Similarly MLPack (Curtin et al., 2018) contains standard $L_{1}$/$L_{2}$ regularized sparse coding. Scikit-learn (Pedregosa et al., 2011) also contains a standard (deterministic and $L_{1}$ regularized) sparse coding version and provides standard NMF or LDA implementations. Sparsenet and glm-ie both use a continuous and probabilistic sparse coding data model, and both require the data model to provide monomodal a-posterior distributions for convex optimization. The data models used by Sparsenet or glm-ie consequently do not overlap nor do the parameter optimization methods. Sparsenet implements the original algorithm by Olshausen and Field (1996) based on MAP, and glm-ie (Nickisch, 2012) provides sophisticated inference for the generalized (sparse) linear model. libDAI (Mooij, 2010) and Libra (Lowd and Rooshenas, 2015) are libraries for inference and learning in general graphical models. None of the libraries is as optimized for probabilistic sparse coding as ProSper or provide its efficient variational EM approach. But libDAI and Libra are much more general in the graphical data models that can be treated. While libDAI focuses more on inference, Libra focuses more on learning and structure learning.

Acknowledgments

We would like to thank Julian Eggert for the many discussions. We would also like to acknowledge support by the DFG in grants SFB 1330 (HAPPAA, ID 352015383) and EXC 2177/1 (Hearing4A, ID 390895286). Early stages of the work were funded by the DFG (grant LU 1196/4-2) and the BMBF (grant 01GQ0840).