Deep Convolutional Neural Networks as strong gravitational lens detectors

TL;DR

This paper introduces a convolutional neural network-based method for automatically detecting strong gravitational lenses in large astronomical datasets, achieving high accuracy and recall in simulated surveys, thus enabling efficient analysis of upcoming large-scale imaging data.

Contribution

The paper develops and evaluates a CNN architecture with variations for automated strong lens detection, demonstrating state-of-the-art performance on simulated space- and ground-based survey data.

Findings

Achieved AUC scores up to 0.977 for ground-based data.

Attained a recall of 0.50 at zero false positives for ground-based data.

Committee of 5 CNNs improves recall and AUC scores.

Abstract

Future large-scale surveys with high resolution imaging will provide us with a few $10^5$ new strong galaxy-scale lenses. These strong lensing systems however will be contained in large data amounts which are beyond the capacity of human experts to visually classify in a unbiased way. We present a new strong gravitational lens finder based on convolutional neural networks (CNNs). The method was applied to the Strong Lensing challenge organised by the Bologna Lens Factory. It achieved first and third place respectively on the space-based data-set and the ground-based data-set. The goal was to find a fully automated lens finder for ground-based and space-based surveys which minimizes human inspect. We compare the results of our CNN architecture and three new variations ("invariant" "views" and "residual") on the simulated data of the challenge. Each method has been trained separately 5 times on 17 000 simulated images, cross-validated using 3 000 images and then applied to a 100 000 image test set. We used two different metrics for evaluation, the area under the receiver operating characteristic curve (AUC) score and the recall with no false positive ($\mathrm{Recall}_{\mathrm{0FP}}$). For ground based data our best method achieved an AUC score of $0.977$ and a $\mathrm{Recall}_{\mathrm{0FP}}$ of $0.50$. For space-based data our best method achieved an AUC score of $0.940$ and a $\mathrm{Recall}_{\mathrm{0FP}}$ of $0.32$. On space-based data adding dihedral invariance to the CNN architecture diminished the overall score but achieved a higher no contamination recall. We found that using committees of 5 CNNs produce the best recall at zero contamination and consistenly score better AUC than a single CNN. We found that for every variation of our CNN lensfinder, we achieve AUC scores close to $1$ within $6\%$.

Figures

Tables

Table 1. Table 1: Training results: Each architecture was run five separate times. The training and validation AUC scores are the mean of these runs. The error is the standard deviation.

Space	Training	Validation
baseline	$0.9920\pm 0.0020$	$0.9764\pm 0.0017$
views	$0.9898\pm 0.0030$	$0.9753\pm 0.0021$
residual	$0.9958\pm 0.0028$	$0.9765\pm 0.0024$
invariant	$0.9997\pm 0.0003$	$0.9719\pm 0.0016$
Ground	Training	Validation
baseline	$0.9953\pm 0.0090$	$0.9905\pm 0.0082$
views	$0.9980\pm 0.0010$	$0.9924\pm 0.0006$
residual	$0.9990\pm 0.0023$	$0.9932\pm 0.0027$
invariant	$0.9999\pm 3\times {10}^{-6}$	$0.9880\pm 0.0030$

Table 2. Table 2: Confusion matrix (baseline architecture, GGSLC challenge) for TPR0. The TPR0 threshold was chosen by the GGSLC organizers for no false-positive in the first 10 000 images of the test set.)

Space-based	Classified as non-lens	Classified as lens
Non-lens	59742	40
lens	20957	19264
Ground-based	Classified as non-lens	Classified as lens
Non-lens	50042	17
lens	21754	28194

Table 3. Table 3: Test, Recall 0 ​ F ​ P subscript Recall 0 F P \mathrm{Recall}_{\mathrm{0FP}} , and Recall 1 ​ F ​ P subscript Recall 1 F P \mathrm{Recall}_{\mathrm{1FP}} results. Each architecture was run five times. The test scores are the mean of these runs.

Space	Test AUC	${\mathrm{Recall}}_{0FP}$	${\mathrm{Recall}}_{1FP}$
baseline	$0.9322\pm 0.0016$	$0.01\pm 0.02$	$0.04\pm 0.04$
committee b.	$0.9326$	$0.01$	$0.01$
views	$0.9324\pm 0.0013$	$0.26\pm 0.06$	$0.28\pm 0.07$
committee v.	$0.9343$	$0.30$	$0.32$
residual	$0.9322\pm 0.0006$	$0.23\pm 0.04$	$0.29\pm 0.03$
committee r.	$0.9346$	$0.29$	$0.30$
invariant	$0.9332\pm 0.0006$	$0.27\pm 0.04$	$0.28\pm 0.05$
committee i.	$0.9399$	$0.32$	$0.33$
Ground	Test AUC	${\mathrm{Recall}}_{0FP}$	${\mathrm{Recall}}_{1FP}$
baseline	$0.9761\pm 0.0011$	$0.44\pm 0.13$	$0.49\pm 0.08$
committee b.	$0.9773$	$0.50$	$0.55$
views	$0.9746\pm 0.0011$	$0.35\pm 0.19$	$0.43\pm 0.17$
committee v.	$0.9759$	$0.35$	$0.39$
residual	$0.9775\pm 0.0006$	$0.44\pm 0.06$	$0.46\pm 0.07$
committee r.	$0.9795$	$0.50$	$0.55$
invariant	$0.9774\pm 0.002$	$0.39\pm 0.11$	$0.45\pm 0.05$
committee i.	$0.9813$	$0.49$	$0.49$

Equations

$$y(\text{@vec}x)=a\left(\sum _{i=1}^N{w}_i{x}_i+b\right),$$

$$y_i=\gamma \frac{x_i-{\mu }_B}{{\sigma }_B^2}+\beta ,$$

$$f(x)=\frac{1}{\sqrt{\pi -1}}\left(\sqrt{2\pi }\max (0,x)-1\right).$$

$$H(\text{@vec}x)=F(\text{@vec}x).$$

$$H(\text{@vec}x)=F(\text{@vec}x)+\text{@vec}x,$$

$$C=-\frac{1}{N}\sum \left\{y\ln (y_p)+(1-y)\left[(1-\ln (y_p)\right]\right\},$$

$$y_i=\text{Conv}(x,F_i)i\in \{0,\dots ,7\},$$

$$y_j=\sum _{i=0}^7\text{Conv}(x_i,j{F}_{j^{-1}\circ i})j\in \{0,\dots ,7\}.$$

$$\mathrm{TPR}=\frac{N_{\mathrm{True}\mathrm{positives}}}{N_{\mathrm{True}\mathrm{psitives}}+N_{\mathrm{False}\mathrm{negatives}}}.$$

$$\mathrm{FPR}=\frac{N_{\mathrm{False}\mathrm{positives}}}{N_{\mathrm{True}\mathrm{negatives}}+N_{\mathrm{False}\mathrm{positives}}}.$$

Full text

*Aims. *We present a new strong gravitational lens finder based on convolutional neural networks (CNNs). The method was applied to the strong-lensing challenge organized by the Bologna Lens Factory. It achieved first and third place, respectively, on the space-based data set and the ground-based data set. The goal was to find a fully automated lens finder for ground-based and space-based surveys that minimizes human inspection.

*Methods. *We compared the results of our CNN architecture and three new variations (”invariant” ”views” and ”residual”) on the simulated data of the challenge. Each method was trained separately five times on 17 000 simulated images, cross-validated using 3 000 images, and then applied to a test set with 100 000 images. We used two different metrics for evaluation, the area under the receiver operating characteristic curve (AUC) score, and the recall with no false positive ($\mathrm{Recall}_{\mathrm{0FP}}$).

*Results. *For ground-based data, our best method achieved an AUC score of 0.977 and a $\mathrm{Recall}_{\mathrm{0FP}}$ of 0.50. For space-based data, our best method achieved an AUC score of 0.940 and a $\mathrm{Recall}_{\mathrm{0FP}}$ of 0.32. Adding dihedral invariance to the CNN architecture diminished the overall score on space-based data, but achieved a higher no-contamination recall. We found that using committees of five CNNs produced the best recall at zero contamination and consistently scored better AUC than a single CNN.

*Conclusions. *We found that for every variation of our CNN lensfinder, we achieved AUC scores close to 1 within $6\%$. A deeper network did not outperform simpler CNN models either. This indicates that more complex networks are not needed to model the simulated lenses. To verify this, more realistic lens simulations with more lens-like structures (spiral galaxies or ring galaxies) are needed to compare the performance of deeper and shallower networks.

1 Introduction

Future strong gravitational lense (SL) studies will help further constrain cosmology and galaxy evolution. As of today, galaxy-scale lenses have been used successfully to constrain the Hubble constant by measuring the time-delay of lensed images of quasars independently of other measurement techniques (Bonvin et al., 2016; Suyu et al., 2017). The magnification of lensed source-objects allows observations and studies of background objects at much higher redshifts than are usually visible to telescopes (Kneib et al., 2004; Richard et al., 2011; Atek et al., 2015). Measurement of galaxy-scale SLs can accurately constrain the total mass of the galaxy by probing the dark matter structure. This can be used to estimate the fraction of dark matter in galaxy halos when used in combination with weak-lensing analysis (Gavazzi et al., 2007) or by itself (Jiang & Kochanek, 2007; More et al., 2011; Sonnenfeld et al., 2015). It can also be used to constrain the slope of the inner mass density profile (Treu & Koopmans, 2002a, b; More et al., 2008; Koopmans et al., 2009; Cao et al., 2016) and the initial stellar mass function (Treu et al., 2010; Ferreras et al., 2010; Leier et al., 2016). One of the largest lens catalogs was produced by the Sloan Lens ACS Survey (SLACS) with about 100 observed lenses (Bolton et al., 2008). These SLs were discovered by selecting lens candidates from the spectroscopic database of the Sloan Digital Sky Survey (SDSS). Lens candidates were chosen by identifying the spectroscopic signature of two galaxies in the spectra, one galaxy at a greater distance than the other. These candidates were then verified by follow-up observation using the Hubble Space Telescope.

Historically, SLs were found serendipitously by human inspection of data. However, a systematic search by experts is too time-consuming to be a practical proposition for future large-scale surveys unless it were to involve citizen scientists. For example, the number of new lens systems from the Euclid mission (Laureijs et al., 2011) and from the Large Synoptic Survey Telescope (LSST Science Collaboration et al., 2009) survey is expected to reach at least $10^{5}$ SLs among $10^{9}$ objects (LSST: Oguri & Marshall (2010); HST: Pawase et al. (2014); Euclid: Collett (2015)). Similarly, the amount of SLs found by the SKA survey is expected to be on the same order of magnitude (McKean et al., 2015). Efficient automated gravitational lens-finding techniques are urgently needed.

The Spacewarps project111https://spacewarps.org/ was an attempt to use and train non-experts at lens classification. Through an interactive website, amateur scientists were trained to sort through data from CFHTLS (Marshall et al., 2015). They found 29 promising new lens candidates in the survey (More et al., 2016), but this method will likely be too slow and too much subject to human error for future data sets. Semi-automated methods like arc detectors using clustering techniques have been used with some success (Lenzen et al., 2004; Cabanac et al., 2007) and have been further improved. Joseph et al. (2014) and Paraficz et al. (2016) added machine-learning to these techniques, using a Principal Component Analysis (PCA) based approach to remove the foreground galaxy from the image and facilitate the detection of arcs. Recently, Petrillo et al. (2017) and Jacobs et al. (2017) started using convolutional neural networks (CNNs) for lens detection. CNNs belong to a class of efficient image-classifier techniques that have revolutionized image processing (Lecun et al., 1998). In astrophysics, they have been applied successfully to galaxy morphology (Huertas-Company, 2015), redshift estimation (Hoyle, 2016), and spectra analysis (Hála, 2014).

The Euclid Strong-Lensing working group, in collaboration with the Bologna lens factory222https://bolognalensfactory.wordpress.com/, has started the Galaxy-Galaxy Strong-Lensing challenge333metcalf1.bo.astro.it/blf-portal/gg_challenge.html (GGSLC: Metcalf et al. 2017, in prep.) in light of future large-scale imaging surveys such as the Euclid mission. The goal was to determine the best technique for finding gravitational lenses for both ground-based and space-based imaging.

Our goal was to explore and optimize CNN architectures for lens classification. We successfully applied it to the GGSLC and were awared first and third place in the two categories of the GGSLC. In this paper, we present the CNN lens finder in detail that we created for the GGSLC challenge and discuss the advantages and disadvantages of CNN lens classifiers when applied on simulated and real data. The paper is organized as follows. Section 2 gives a brief overview of artificial neural networks (ANN) and CNNs and their usage in image processing. Section 3 outlines the details of our algorithm implementation and the two winning CNN architectures of the challenge, while in Sect. 4 we present some interesting alternative architectures. Section 5 summarizes the results of the different architectures we applied to GGSLC data, and we discuss them.

2 Theory

2.1 Artificial neural network

Artificial neural networks are machine-learning techniques inspired by the study of the human brain (Hebbian learning: Hebb, 1950). ANNs are capable of learning classification or regression tasks in $N$ dimensions by training using a set of labeled examples. This makes them easily applicable to complex problems for which explicitly programmed solutions or mathematical models are difficult to write. The main drawback of ANNs is the computation cost of the training procedure. More modern training techniques coupled with advances in GPU processing power made ANNs versatile and capable of being applied to almost any data set. They are created by stacking layers of neurons together. Each neuron implements a linear combination (using weights $w_{i}$ and a bias $b$) of its input $\@vec{x}$ followed by a nonlinear activation function $a(\@vec{x})$,

[TABLE]

where $N$ is the dimension of the inputs.

A layer consists of multiple neurons applied to the same input. Each output is passed as an input to the next layer. This cascade of nonlinear combinations of inputs ends at the output layer (see Fig. 1). In a classical ANN, all possible connections are established and exploited, in short, it is fully connected. A neuron in a given layer will transmit its outputs to all neurons in the next layer. Every layer between the input and the output layer is called a hidden layer. The initial input layer is sometimes also called a front layer. An ANN model is parametrized by the weights $w$ and biases $b$ of the neurons.

These weights and biases are trained iteratively. ANNs make predictions when presented with a training input. As the model parameters are randomly initialized, the first predictions are very different from the ground truth of the input.

The ANN then evaluates the error according to some predefined cost function and computes appropriate corrections to the parameters. These prediction errors are propagated backward through the layers, from the output to the front layer, and induce parameter updates. The technique is known as back-propagation (Rumelhart et al., 1986) and is commonly built on gradient descent for the computation of the parameter updates.

2.2 Convolutional neural network

Deep ANNs, models that have more than one or two hidden layers, perform better than shallow networks. The mathematical evidence for this statement is still scarce, but it is empirically observed. The continued growth in computation power made ANNs interesting for scientific application. However, computational cost of training increases with depth, and limitations in gradient-based procedures are challenging performance obstacles. Training with gradient methods generates a so-called vanishing-gradient problem, first identified by Hochreiter (1991). The magnitude of the gradient diminishes as it is back-propagated through the layers. The typical result is that layers close to the front layer effectively stop learning. While still affected by the vanishing-gradient problems, CNNs limit its effect by reducing the number of connections and sharing weights. This mitigation motivated the development of CNNs and their subsequent application to image recognition (Lenet-5 model, Lecun et al., 1998).

The breakthrough for CNN came when Krizhevsky et al. (2012) created an architecture that won the 2012 ImageNet Large-Scale Visual Recognition Challenge444http://image-net.org/. His submission achieved a classification error of only $15.3\%$ compared to the second-best submission with $26.2\%$ obtained by a method not based on a neural network. CNNs have been used extensively in image processing ever since.

Our CNNs (Fig. 2) are created by stacking the following layers: convolution layers convolve the input image by a number of small kernels (or features maps, typically of dimension $3\times 3$ to $7\times 7$). The parameters to be optimized during training are the individual kernels. These weights are shared by all neurons in the layers (the kernels are the same for the whole layer). Pooling layers reduce the dimensionality of the input to decrease the number of parameters and avoid overfitting. The most common pooling technique is the max-pooling method. It partitions the input image into non-overlapping quadrants and yields the maximum value in the quadrant. Fully connected (fc) layers are the classic ANN neuron layer. Every input is connected to every neuron of the layers. They are used as the final CNN layers to merge the information contained in the feature maps into the desired output form. Dropout layers are only active during training. They randomly sever half the connections between the two layers they separate (Hinton et al., 2012). This is done to reduce coadaption of the neurons (learning the same features) and reduce overfitting. Batch normalization layers normalize and shift the output along a small input sample $B=\{x_{1...m}\}$ following the equation

[TABLE]

where $\mu_{B}$ and $\sigma_{B}$ are the mean and the variance over $B$. $\gamma$ and $\beta$ are two model parameters of the layer. Batch normalization is used to increase the training speed of the CNN (Ioffe & Szegedy, 2015).

Convolution layers take advantage of the local spatial correlation in the data. Stacking multiple convolution layers implies a global treatment of the signal, making the network shift-invariant (i.e., features will be detected independently of their position). This make CNNs especially effective when treating images (Mallat, 2016).

2.3 Data set of the Galaxy-Galaxy Strong-Lensing Challenge

The data for the GGSLC was provided by the Bologna lens factory challenge. The Bologna lens factory project is a complex lens-simulation project. It is based on the Millennium simulation (Lemson & Virgo Consortium, 2006), with modeling of the gravitational lensing effect using the Glamer ray-tracing tool (Metcalf & Petkova, 2014) and with MOKA to create the multiplane dark halos and their substructures (Giocoli et al., 2012). The models and the parameters used to generate the simulations were blinded for the duration of the challenge.

Each image of the SL challenge was a 101$\times$101 pixel stamp centered around an object. Participants had to submit a confidence value $p\in[0,1]$ for each image. An object with a high confidence value was interpreted as a lens. Two categories of data were proposed with separate data sets, each with 20 000 training and 100 000 test images: (i) a space-based data set that consisted of images in a single visible band (simulating exposures of the Euclid instrument VIS), and (ii) a ground-based data set with images taken in four bands (U, G, R, and I) with a lower singal-to-noise ratio (S/N) and random masking of pixels, mimicking noisy data.

The ratio of lenses to non-lenses in the simulated data was much higher than in reality, around one-to-one, as an imbalance of examples (called skewed classes) can lead to biases. The results are have been made public, and a detailed discussion of the simulations and results will be provided in Metcalf et al. (in prep). Our baseline architecture submission to GGSLC ranked first in the space-based data category and third in the ground-based category (Fig.  9). CNNs in general dominated the challenge. CNN-based methods filled the seven best submission in both categories.

3 CNN lensfinder: architectures

For this paper, four different types of CNN architectures were applied to the training data of the GGSLC: a simple CNN architecture that forms the baseline comparison for the paper, a so-called residual architecture based on the paper by He et al. (2015), and two further architectures with additional invariant properties. The final version of each architecture was selected after a heuristic study of the parameter space.

3.1 Baseline architecture

The baseline architecture as shown in Fig. 3a was inspired from typical CNN architectures that performed well in the ImageNet competition (Simonyan & Zisserman, 2014). It is organized by stacking convolution blocks. This simple baseline architecture achieved first place in the space component of GGSLC. A convolution block is the superposition of 2 convolutional layers followed by a pooling layer to reduce the dimensionality of the image and a batch-normalization layer. The baseline architecture is comprised of 8 convolutional layers, organized into 3 convolution blocks and 2 stand-alone layers, and 3 fully connected layers at the top. There is thus a total of 11 layers. With the exception of the initial layer, every convolution layer uses $3\times 3$ convolution kernels for efficiency reasons (Simonyan & Zisserman, 2014). The first convolution layer uses a $4\times 4$ kernel to yield an even number of pixels for easier manipulation. At each convolution block, the number of features was doubled, resulting in 256 features in the last block. The fully connected layers used either 1024 or 2048 features.

For each layer, we chose a modified version of the rectifier linear unit (ReLU) activation function because of its sparse representation capability (Glorot et al., 2011; Arpit et al., 2016). The activation is given by

[TABLE]

Inputs of the networks have dimension of $101\times 101\times N_{b}$, where $N_{b}$ is the number of bands ($N_{b}=1$ for space and $N_{b}=4$ for ground). The wavelength-dependent information (in the third dimension) is handled naturally by extending the kernel dimension from two to three (spatial to spatial plus wavelengths).

3.2 Residual architecture

A common way for improving CNN is to increase the depth, that is, the number of convolutional layers. With creating increasingly deeper CNNs comes the vanishing-gradient problem detailed before. At some point in the training process, the accuracy starts to saturate and degrade, generating an upper limit to the possible depth of CNNs. To compensate for this, He et al. (2015) introduced residual learning. In the GGSLC challenge, Francois Lanusse’s deep lens classifier (Lanusse et al., 2017) used residual learning to create a 46-layer deep CNN that won the ground part of the challenge. We adapted our residual architecture to analyze the advantages and disadvantages compared to the baseline CNN.

In a classical convolution layer, the feature map is created from scratch, that is, it learns an unreferenced mapping. The end-goal of the training process is to find parameters that minimize the cost function. We denote by $H(\@vec{x})$ the optimum feature map and by $F(\@vec{x})$ the map currently held in the parameters. In other words, the training updates $F(\@vec{x})$ until

[TABLE]

In contrast, residual networks train by optimizing a residual mapping $\@vec{x}$, or the difference between the ideal and the real feature map. He et al. (2015) stated that it is easier to optimize the residual feature map than the unreferenced map,

[TABLE]

where $\@vec{x}$ is the identity mapping obtained by using shortcut connections skipping the convolution layers (Fig. 4). Our residual architecture as shown in Fig. 3b is 20-layer deep with 3 small residual blocks, 4 large residual blocks, and 3 fully connected layers with 1024 features. The small residual block is composed of 2 convolutions and 1 shortcut, keeping the same number of features. The large residual block is composed of 3 convolutions and 1 shortcut followed by a convolution layer, doubling the number of features.

3.3 Implementation details

Other than the differences in the approach to the problem, the networks shared a number of implementation details that we outline here.

• •

Cost function: we chose the binary cross-entropy cost function as the cost function $C$ driving the training,

[TABLE]

where $N$ is the number of training examples, $y$ is the ground truth, and $y_{p}$ is the classification prediction.

• •

Data augmentation: to increase the number of training samples, we used data-augmentation techniques. The goal is to generate more examples out of the original training set by exploiting physically invariant transformations, for example, rotating the image by 90 degrees. The benefit of increasing the training set size is to reduce overfitting.Taking advantage of the dihedral group symmetry (Fig. 6) of the lens problem, the training sets were augmented using 90-degree rotations and flipping operations. We did not use rotation angles different than 90 degrees to avoid having to interpolate in pixel space.

• •

Training: the challenge training set was subdivided into a training set (of 17 000 images) that was used by the networks to learn and a validation set (3 000 images strong) to check the performances on an independent set. The performance was monitored every 1000 steps by evaluating predictions made on the validation set. At each training step, we randomly selected batches of 30 images (15 lenses and 15 non-lenses) and ran the learning procedure for $\sim 250-300$ epochs using the ADAM minimization algorithm (Kingma & Ba, 2015). We trained five networks with the same architecture and selected the best-performing individual.

• •

Library: the models were implemented using the Tensorflow library (Abadi et al., 2015) on a GeForce GTX 1060 graphic card. The training time took approximately 1 hour/100 epochs for the baseline model and 2 hours/100 epochs for the residual model. The final prediction of the classification for the challenge on the 100 000 test images took approximately 20 minutes.

3.4 Image invariance

The idea behind these two next architectures was to deal with the inability of most lens finders to recognize and handle the invariant features of gravitational lenses. CNNs are, by design, already invariant to translation, but not to rotation, scaling, and flipping. The pretraining data augmentation phase renders them more robust to these symmetry operations, but not invariant. By modifying the CNN architecture so as to be invariant or more robust to different types of symmetries, we expect to reduce identification errors. The following sections describe how we increased the invariance of our models.

3.4.1 Views architecture

Several models trained to accomplish the same task form a committee. Predictions of a committee typically result in some sort of weighted combination of its members’ predictions. They have been used to improve classification results for example on the MNIST555MNIST database of handwritten digits, http://yann.lecun.com/exdb/mnist/ problem (Ciresan et al., 2011) or to detect anomalies in the predictions (Nguyen et al., 2014).

The views architecture (Fig. 5b) trains two neural networks separately to look for lenses of different sizes. The first network looks at the whole image, detecting large lenses spanning the whole image. The second uses only the central part of the image. By combining the prediction of the two networks, smaller lenses should be detected while not neglecting the detection of the larger lenses. In other words, the first network takes as input the whole image, like the baseline model, while the second only accepts a smaller stamp of $45\times 45$ pixels. To simplify the smaller network, we used only 5$\times$5 convolution layers and fewer features at each layer.

3.4.2 Invariant architecture

The invariant architecture adds additional invariant properties to the model. While relatively untested, this has been used with success for a galaxy morphology classifier on Galaxy Zoo data (Dieleman et al., 2015, 2016). The invariant architecture takes advantage of the dihedral symmetry of the lens-finding problem (Fig. 6) by using dihedral equivariant convolutional layers that we refer to as DEC layers.

At the level of the input layer, eight operations of the same convolution kernel, transformed by a different transformation of the dihedral group, are applied to the input image. The output is divided into eight different output channels (see Fig. 7),

[TABLE]

where $i$ is one of the eight specific dihedral transformation and $M_{i}$ is the filter to which a dihedral transformation has been applied.

Compared to the baseline version, for the DEC layer there are eight different convolution kernel instead of one: one kernel for each transformation of the dihedral group ($F_{i},\,i\in\{0,\dots,7\}$). Each kernel is initialized and trained separately from each other. Each output channel in a DEC layer is the sum of all the input channels convolved by all the different feature kernels of the layer transformed by one of the dihedral operations (Fig. 7). The result of the eight channels, $y_{j}$, is a dihedral invariant quantity,

[TABLE]

The two layers illustrated in Fig. 7 have the property of being invariant with respect to the dihedral group. Our invariant architecture is shown in Fig.  5a and follows the same fundamental scheme as the baseline architecture. Since using eight channels increases computation time and makes the model more prone to overfitting, the number of features of the convolutional layers is divided by four. The invariance was tested by checking that rotated and flipped versions of the same image are attributed the same score by the classifier.

4 Results

In this section we describe the results of the different architectures applied to the GGSLC data.

4.1 Performance metric

We first start by a brief overview of the performance metrics we used to quantify the performance of the lens classification.

• •

The true-positive rate (TPR) measures how well the classifier detects lenses from the whole population of objects,

[TABLE]

This metric is also known as recall. The best algorithms have a TPR close to 1.

• •

The false-positive rate (FPR) measures the contamination of the positive detections by false positives,

[TABLE]

The best algorithms have an FPR close to 0.

• •

The receiver operating characteristic (ROC) is a visual representation of the TPR and FPR. Since they depend on the threshold $t\in(0,1)$ defined to distinguish objects as lenses or non-lenses, the ROC curve (Fig. 8) is created by plotting $\mathrm{TPR}(t)$ as a function of $\mathrm{FPR}(t)$ for $t\in(0,1)$. The challenge ranked the classifiers as a function of the area under the ROC curve (AUC), which is the integral of the ROC curve between an FPR of 0 and 1. A perfect classifier would score 1, while a randomly predicting classifier would score 0.5.

4.2 Training, submission, and results

After the challenge deadline, we tested our four architectures on the GGSLC data. As for the baseline architecture, we used our 17 000-image training set and the 3000-image validation set. Each architecture was trained five separate times. In Table 1 we show the result of this committee training. The performance is also evaluated in Table 3 on the challenge test data as the ground-truth values were released to participants after the submission deadline. The standard deviation of the five runs is also given. The two metrics used to evaluate the performance of the methods are the (i) the AUC and (ii) the zero false-positives, $\mathrm{Recall}_{\mathrm{0FP}}$ (that is, the fraction of lenses recovered with zero false-positives).

The AUC results are much better for ground-based data than for space-based data (Fig. 9) although the images have a lower S/N than the space-based images. This increased performance could be due to the increased amount of information in the form of the four bands, instead of the single VIS-like band for space. The lower S/N in the ground-based data does not seem to hinder prediction.

The baseline, views, invariant and residual architectures achieved equally good AUC results on the validation set and the test set within the standard deviation of the runs. This is surprising because deeper networks, like the residual one, are expected to perform better than shallower models. The scores are too close to the optimum to confidently distinguish between the architectures. The most likely explanation is that the simulated data were too simple for the CNN lensfinder. The simulations did not include spiral galaxies or some other ring-like objects capable of confusing gravitational lens classifiers. A more complex method was therefore not needed to classify the data correctly. The difference that can be seen between the validation scores and the test scores in Tables 1 and 3 can be attributed to a slight overfitting. This is probably due to the small size of the validation set we used in comparison to the test set.

The invariant architecture has a lower validation AUC score than the others, but performs equally well on the test set. This may indicate that the invariant architecture generalizes the lens model better than other architectures. This could be due to the imposed invariant properties, as we have given the model some additional knowledge. This has no effect on the final test score but could become important when applying the CNN lensfinder to real data. Since the amount of known galaxy-scale lenses is small, a sufficiently large training set for a CNN lensfinder can only be obtained by simulated lenses (see Petrillo et al., 2017, for a CNN lensfinder applied to CHFTLS data). The caveat here is that CNNs trained on simulation might miss lenses because the simulated training set was unrealistic. The better the CNNs generalize the lens model, the lower the chance that they will missidentify objects. Ideas exist to force CNNs to focus on the lens model. One is to use multiple different simulations to create lenses (Jacobs et al., 2017). Adding dihedral invariance to CNNs could be another way of doing this.

The ground-based results are extremely encouraging, especially because of the purity of the score. In a classification problem with a 1-to-1000 ratio between lenses and non-lenses, algorithms with even a very small contamination can be dominated by false positives. The baseline model performs well on the metric $\mathrm{Recall}_{\mathrm{0FP}}=0.44$ in the ground-based test set (Table 3). In a more realistic setting with a ratio of lenses to non-lens objects, we would have found 22 out of the 50 lenses in a test set containing 100 000 images without any false positives.

Table 3 shows that the standard deviation of $\mathrm{Recall}_{\mathrm{0FP}}$ is large. Using the CNN that performed best on the validation set does not guarantee the best $\mathrm{Recall}_{\mathrm{0FP}}$ or even best AUC score (Figs. 10 and 11). The metrics vary depending on the individual result of the training run. To mitigate this, we grouped the five training runs of our model in a committee of CNNs. The committee output is taken as the average of their prediction. By compensating for each other’s shortcomings, committees stabilize the results and achieve a better-than-average result for the AUC metric as well as for the $\mathrm{Recall}_{\mathrm{0FP}}$ metric (Table 3, Figs. 12 and 13). The invariant model especially is improved by this and obtains the best scores for the space-based data.

5 Conclusions

We presented a strong gravitational lens finder based on convolutional neural networks (CNN). The method showed strong performances on simulated data. It won the first place and third place in the Strong Gravitational Lens Challenge (GGSLC), respectively, in the space-based and ground-based data category. We have also presented three other variations of that lensfinder, among which, a residual CNN based on the recent architecture developed by He et al. (2015).

We found that CNNs perform better on ground-based data than on space-based data despite the lower S/N. This is probably due to the additional bands, which add information, but this still has to be confirmed. This can be done, for instance, by limiting the ground-based data to one band and comparing to the other results. All four CNNs achieved almost perfect ROC curve scores on the simulated data, with the highest area under the ROC curve (AUC) score up to 0.9775 for ground-based and 0.933 for space-based data. They also achieved a recall with a zero false-positive ($\mathrm{Recall}_{\mathrm{0FP}}$) of $50\%$ for ground-based and of $32\%$ for space-based data. We showed that the best $\mathrm{Recall}_{\mathrm{0FP}}$ results were achieved by committees of CNNs instead of single CNNs. Committees of CNNs consistently scored the best AUC scores. We also observed that adding rotation invariance to CNNs grouped together in committees produces the best space-based $\mathrm{Recall}_{\mathrm{0FP}}$ score.

Because all results are almost equally good, more conclusions about the best CNN model cannot be drawn. Most likely the simulations did not include enough lens-like objects capable of inducing false positives in the lensfinder, that is, the simulations were likely not realistic enough. This might explain why, contrary to expectations, the residual CNN has not performed better than the others. We will further explore CNN algorithms in the future GGSLC.

Acknowledgements.

The authors would like to acknowledge Frederic Courbin, Colin Jacobs, Ben Metcalf, and Markus Rexroth for their help and advice on the subject. CS and JPK acknowledge support from the ERC advanced grant LIDA. TK acknowledges support from the Swiss National Science Foundation.