Self-supervised Learning with Physics-aware Neural Networks I: Galaxy Model Fitting

TL;DR

This paper introduces a self-supervised hybrid neural network that integrates physical models to estimate parameters of galaxy light profiles without requiring true parameter labels, enabling physically interpretable unsupervised learning.

Contribution

It presents a novel semantic autoencoder architecture combining neural networks with physical models for unsupervised parameter estimation in galaxy modeling.

Findings

Successfully performs 2D galaxy light profile fitting

Estimates physically meaningful parameters without supervision

Maintains neural network robustness with explicit physical modeling

Abstract

Estimating the parameters of a model describing a set of observations using a neural network is in general solved in a supervised way. In cases when we do not have access to the model's true parameters this approach can not be applied. Standard unsupervised learning techniques on the other hand, do not produce meaningful or semantic representations that can be associated to the model's parameters. Here we introduce a self-supervised hybrid network that combines traditional neural network elements with analytic or numerical models which represent a physical process to be learned by the system. Self-supervised learning is achieved by generating an internal representation equivalent to the parameters of the physical model. This semantic representation is used to evaluate the model and compare it to the input data during training. The Semantic Autoencoder architecture described here shares the robustness of neural networks while including an explicit model of the data, learns in an unsupervised way and estimates, by construction, parameters with direct physical interpretation. As an illustrative application we perform unsupervised learning for 2D model fitting of exponential light profiles.

Equations

$$\Psi (\mathbf{p})\to \mathbf{x}\approx G(\mathbf{p}).$$

$$I(r)=I_0\exp (-r^{\prime })$$

$$r^{\prime }=\sqrt{(x^{\prime }/A{)}^2+(y^{\prime }/B{)}^2}.$$

$$x^{\prime }$$

$$y^{\prime }$$

Full text

††pagerange: Self-supervised Learning with Physics-aware Neural Networks I: Galaxy Model Fitting–LABEL:lastpage††pubyear: 2002

1 Introduction

Fitting a model to a given set of observations is a basic paradigm in science. Model fitting allows us to estimate the value of the parameters defining the model and also serves as a tool for testing its validity. Traditionally, this task has been approached as an optimization problem where we wish to minimize the error between the model $G$ and a set of observations ${\bm{x}}$ such as done in regression techniques (Legendre A. M.,, 1805). Model fitting can be a challenging task as often the result is highly sensitive to the set of initial parameters, noise and artifacts in the data.

In recent years, new techniques developed in the field of Machine Learning (ML) have been successfully applied to problems where the complexity of the data prevented the use of traditional techniques. One of the fields that has seen the largest advances is image processing, where Deep Neural Network (DNN) architectures have now reached and even surpassed human performance (LeCun Y., Bengio Y., Hilton G., 2015; Dieleman, Willett & Dambre, 2015). At the core of the ML revolution is the ability of DNN to generate an internal hierarchical representation of the patterns in the data. However, they do so at the cost of a lack of transparency. Typical DNN systems contain millions of trainable parameters with no meaningful interpretation, effectively making them black boxes. This lack of transparency in the inner workings of DNN still limits their full application in quantitative sciences. Currently, DNN are mainly used in astronomy as workhorses for classification, segmentation and regression tasks (Dieleman, Willett & Dambre, 2015; Kim & Brunner, 2017; Tuccillo D. et al., 2018; Domínguez Sánchez, Huertas-Company, Bernardi, Tuccillo & Fischer, 2018). However, their use as tools for insight extraction of physical processes remains poorly exploited. The work presented here aims to be one step forward in this direction by explicitly introducing physical models in a regular neural net architecture.

1.1 Autoencoders

Autoencoders belong to a family of neural networks that are trained to copy its input to its output. While replicating the input is a trivial task the utility of autoencoders stems form their ability to map the high-dimensional input into a low-dimensional compressed internal representation (LeCun Y.,, 1987; Bourlard H., Kamp Y.,, 1988; Hinton G., Salakhutdinov R.,, 2006).

A standard autoencoder is composed of an encoder and a decoder joined at a bottleneck (see Fig. 1). The encoder is a neural network $f_{\lambda}$ (described by a set of trainable parameters $\lambda$ consisting of weights and biases) that maps the input ${\bm{x}}\in\mathbb{R}^{m}$ into a code ${\bm{c}}=f_{\lambda}({\bm{x}})\in\mathbb{R}^{l}$. The code is then fed into a decoder neural network $g_{\lambda}$ that “decompresses” it back to input space producing a reconstruction of the input: $\hat{\bm{x}}=g_{\lambda}({\bm{c}})=g_{\lambda}(f_{\lambda}({\bm{x}}))\in\mathbb{R}^{m}$. Learning the optimal $\lambda$ is performed by minimizing the loss function $L({\bm{x}},\hat{\bm{x}})$ chosen to quantify the difference between the input and the reconstructed output.

In order for autoencoders to produce a compressed representation they are, by construction, undercomplete i.e. the dimensionality of the code is lower than that of the input ($m>l$). One consequence of this is that the reconstruction will not be an exact copy of the input data. In fact, it can be desirable that the reconstructed output is a simplified version of the input, meaning that only the relevant aspects of the input image are encoded (Vincent P. et al., 2010).

Autoencoders are attractive architectures for data encoding due to their ability to create a compressed representation at their bottleneck. This representation is in general not semantically meaningful (although it has been shown that sparcity can lead to semantical encoding for simple physical models (Iten R., et al.,, 2018)). In general sparsity is a required but not sufficient condition for semantic encoding. This is also the case of other dimensionality reduction techniches such as Principal Component Analysis, for which the linear autoencoder produces equivalent encodings (Bourlard H., Kamp Y.,, 1988).

1.2 Semantic autoencoders

The lack of semantic encoding in regular autoencoders is a consequence, in part, of their generality as both the encoder and decoder are based on universal trainable systems (Cybenko G.,, 1989). One way of enforcing semantic encoding would be to impose meaningful constraints on the autoencoder. Consider a physical process $\Psi$ from which we take a set of measurements ${\bm{x}}$. The process $\Psi$ can be described or approximated by a (mathematical) model $G$ expressed as a function of a set of parameters ${\bm{p}}$:

[TABLE]

We now feed ${\bm{x}}$ to an autoencoder that will encode ${\bm{x}}$ into the parameters $\hat{{\bm{p}}}=f_{\lambda}({\bm{x}})$ at its bottleneck and then decode it back to produce the reconstructed input $\hat{\bm{x}}=g_{\lambda}(\hat{{\bm{p}}})$. If we somehow force $\hat{{\bm{p}}}$ and ${\bm{p}}$ to be semantically equivalent (${\bm{p}}\Leftrightarrow\hat{{\bm{p}}}$) then the decoder $g_{\lambda}$ will effectively learn to mimic the behavior of the process $\Psi$.

We can then replace the decoder $g_{\lambda}$ by the model $G$ as they are functionally equivalent ($g_{\lambda}\Leftrightarrow G$). The constraints imposed on the autoencoder by $G$ force the encoder $f_{\lambda}$ to generate a semantic encoding of the input. Note that the model $G$ can be any function such as a modeling equation, a numerical code like an N-body solver, or even an actual physical system such as a mechanical arm. Semantic autoencoders do not require to be provided the “true” code ${\bm{p}}$ during training (we may not even have access to the code). Instead the rely on the validity of the model $G$ in order to generate reconstructed observations ${\hat{\bm{x}}}$ and learn in a self-supervised way.

The semantic autoencoder described here is a system combining trainable with non-trainable elements. In this approach we consider neural networks as special cases of a larger family of differentiable functions with trainable or non trainable parameters that can learn via gradient descent Wengert, R. E, (1964); Bischof C. H., (1996).

2 Self-supervised exponential profile fitting

In this section we present an illustrative application of a semantic autoencoder trained to estimate the parameters defining an exponential profile commonly used to describe the light distribution of late-type galaxies (Sérsic, 1963; Peng C. et al., 2002; Simard, Mendel, Patton, Ellison & McConnachie, 2011; Barden, Häußler, Peng, McIntosh & Guo, 2012). Model fitting can be addressed as a standard supervised problem providing both the input image and the model’s parameters (Tuccillo D. et al., 2018). In this work we are interested instead in training a network in a self-supervised way, i.e. without providing information on the true model’s parameters. A general exponential profile of a galaxy observed with some inclination and position angle can be expressed as:

[TABLE]

where the radius $r^{\prime}$ is computed as:

[TABLE]

The major and minor semi-axis $A,B$ of the ellipsoid are related to the ellipticity as $e=1-B/A$. The rotated coordinates $x^{\prime}$ and $y^{\prime}$ are given by:

[TABLE]

where $\theta$ corresponds to the position angle of the ellipsoid. For simplicity we set in our analysis $I_{0}=1$ and $x_{0},y_{0}=0$.

2.1 Network Implementation

The full model was implemented using the Keras library (Chollet F. et al.,, 2015) with the tensorflow backend (Abadi, M. et al.,, 2015). Keras offers a clean API for boilerplate code such as setting up a convolutional layer while allowing direct access to tensorflow for non standard tasks.

Figure 2 shows an overview of the architecture proposed here. In practice this particular network has three inputs: the image we wish to encode and two 2D arrays containing $x$ and $y$ coordinates used to evaluate the 2D exponential profile. Coordinates could be computed on the fly using the eager programming mode in tensorflow 2.0. However, passing the pre-computed coordinates may be computationally more efficient at the expense of increased memory consumption. For the application presented here this is not an issue.

2.1.1 Encoder

The encoder consists of 3 convolutional blocks containing each two convolutional layers with rectified linear unit (ReLU) activations followed by a $2\times 2$ max-pooling operation. The number of kernels in the layers of each of the three convolutional blocks is $32,64$ and 128 respectively. The output of the last convolutional block has 128 channels of $8\times 8$ pixel activation images. This layer is flattened to a $8192$ vector which is connected to three dense layers with sigmoid activations containing 64, 32 and 3 neurons respectively. The last three neurons output the values of the predicted parameters $\hat{A},\hat{e},\hat{\theta}$ (one neuron per parameter). We use dense layers as a convenient way to generate any desired number of output parameters. The encoder contains all the trainable parameters in the network with $812,963$ parameters of which $526,531$ correspond to the dense network.

The above architecture was chosen after performing a basic manual hyperparameter exploration in order to find the smallest network that would be able to accurately encode the input images. Larger networks produce lower errors at at higher computational cost.

2.1.2 Decoder

The output of the encoder, the parameters $\hat{A},\hat{e}$ and $\hat{\theta}$, are evaluated by the 2D exponential model in eq. 2 acting as a decoder. In order to “expand” the model’s parameters into a 2D image we evaluate the exponential function with the predicted parameters $\hat{A},\hat{e},\hat{\theta}$, and the two auxiliary arrays (of the same size as the original image) containing the $x$ and $y$ coordinates with origin at the center of the image and running in the range (-1,1). The decoder was implemented as a custom tensorflow layer with three inputs: the list of parameters ($\hat{A},\hat{e},\hat{\theta}$) coming from the encoder and the 2D arrays containing the coordinates $x$ and $y$ (see Fig. 2). The output of the decoder layer is the reconstructed image $\hat{\bm{x}}$. The exponential profile in eq. 2 was implemented using native tensorflow functions in order to allow tensorflow to automatically compute derivatives during backpropagation at training.

2.1.3 Training

Training data consisted of a set of $10,000$ synthetic images of exponential profiles with a resolution of $64\times 64$ pixels. The parameters $A,e,\theta$ of each image were sampled from uniform distributions in the ranges $0.01<A<0.05$, $0.2<e<0.75$ and $0^{\circ}<\theta<180^{\circ}$. The position angle $\theta$ was normalized in the range $(0,1)$ to bring it inside the range of the sigmoid functions used as activations in the neurons leading to the bottleneck. In order to have a more realistic setting and to test the denoising properties of the semantic autoencoder we added Gaussian noise with dispersion $\sigma_{G}=0.05$ to each image.

Training was done by feeding the model with images in batches of $20$ samples for $1000$ epochs. Weights were updated using the ADADELTA optimizer (Zeiler, 2012) with the default values of initial learning rate $l_{r}=1$ and Adadelta decay factor $\rho=0.95$. We used the mean absolute error (mae) between the input and reconstructed images as the loss function. The mae produces losses that are less sensitive to the high dynamic range of the exponential profiles compared to the more commonly used mean squared error. Training took 3.9 hours on an nvidia 1050 GPU card.

2.2 Results

After training the network we tested it with $1000$ images not included in the training process. Prediction took a few seconds. The network produces two outputs: the reconstructed 2D profile and the model’s parameters at the network’s bottleneck. The parameters were extracted from the network as the activations at the last three neurons in the decoder. Figure 3 shows the comparison between the true and predicted parameters. The three parameters are recovered with excellent agreement. The network had difficulty predicting position angles close to $0^{\circ}$ and $180^{\circ}$ ($\sim 1$ percent of the images) due to the discontinuous nature of the position angle. The dispersion of the errors between the true and predicted parameters is $\sigma_{A}=0.00055$, $\sigma_{e}=0.0091$ and $\sigma_{\theta}=0.92^{\circ}$. We computed $\sigma_{\theta}$ using only points in the interval $10^{\circ}<\theta<170^{\circ}$ in order to avoid the ambiguous predictions at angles close to $0^{\circ}$ and $180^{\circ}$

Figure 4 shows a comparison between images feed to the semantic autoencoder and the images reconstructed from the predicted parameters $A,e,\theta$. Visually, the original images without noise are indistinguishable from the reconstructed images as already indicated by the tight correlation between true and predicted parameters in Fig. 3. The residual of the reconstructed and the input image ($\hat{{\bm{x}}}-{\bm{x}}$) shows only the Gaussian noise applied to the original images. In a sense, the semantic autoencoder presented here acts as an ideal denoising autoencoder provided that the model $G$ encodes the relevant features in the input images.

3 Discussion and future work

We presented Semantic Autoencoders, a hybrid Deep Learning architecture that combines standard neural network elements with an explicit model describing the measured input data. We applied this architecture to the problem of self-supervised 2D exponential profile fitting with excellent results. The network is able to accurately estimate the parameters of the model with the only exception of position angles close to the ambiguous case of $0^{\circ}\sim\theta\sim 180^{\circ}$. This is not a limitation of the architecture presented here but the result of the network trying to interpolate in the discontinuous interval.

Semantic autoencoders act as ideal denoising autoencoders, in the sense that they reconstruct the input image as a function of the features we consider most relevant. As such, their efficacy fully depends on the model used as decoder. This “Bayesian” twist on the standard autoencoder can be exploited for model testing, assuming that the encoder is sufficiently complex to learn to estimate the model’s parameters.

In general, problems that can be solved with Semantic Autoencoders can also be solved with standard recursive optimization methods. What the proposed architecture offers is a model that can solve, in an unsupervised way, for all the possible cases (within the region in feature space covered by the training sample) in a fast and efficient way. A machine learning approach trades network complexity and long training time for robustness and speed at prediction time.

The work presented here highlights the possibility of constructing of more general neural networks that combine standard artificial neurons with general algorithms or even physical systems. The decoder function $G$ could be any process that is differentiable including analytic functions, numerical algorithms (Li T.-M. et al., 2018) and even real-world physical systems.

While this work was being independently developed google released the TENSORFLOW GRAPHICS deep learning framework (Valentin, J., et al., 2019) which is an implementation of the basic architecture presented here applied to computer graphics.

4 Acknowledgments

The author would like to thank Mark Neyrinck for useful comments on the manuscript. This work was funded in part by “Programa de Apoyo a Proyectos de Investigación e Innovación Tecnológica” grant DGAPA-PAPIIT IA104818.