Draft version May 31, 2017Preprint typeset using LATEX style emulateapj v. 12/16/11

EMPIRICISN: RE-SAMPLING OBSERVED SUPERNOVA/HOST GALAXY POPULATIONS USING AN XDGAUSSIAN MIXTURE MODEL

Thomas W.-S. Holoien1,2,3,4, Philip J. Marshall3,4, Risa H. Wechsler3,4

Draft version May 31, 2017

ABSTRACT

We describe two new open-source tools written in Python for performing extreme deconvolutionGaussian mixture modeling (XDGMM) and using a conditioned model to re-sample observed super-nova and host galaxy populations. XDGMM is new program for using Gaussian mixtures to dodensity estimation of noisy data using extreme deconvolution (XD) algorithms that has functionalitynot available in other XD tools. It allows the user to select between the AstroML (Vanderplas et al.2012; Ivezic et al. 2015) and Bovy et al. (2011) fitting methods and is compatible with scikit-learnmachine learning algorithms (Pedregosa et al. 2011). Most crucially, it allows the user to condition amodel based on the known values of a subset of parameters. This gives the user the ability to producea tool that can predict unknown parameters based on a model conditioned on known values of otherparameters. empiriciSN is an example application of this functionality that can be used for fittingan XDGMM model to observed supernova/host datasets and predicting likely supernova parametersusing on a model conditioned on observed host properties. It is primarily intended for simulatingrealistic supernovae for LSST data simulations based on empirical galaxy properties.Subject headings: supernovae: general — density estimation — Bayesian inference

1. INTRODUCTION

The problem of inferring a distribution function givena set of samples from that distribution function andthe problem of finding overdensities in this distributionfunction are common issues in many areas of science,particularly astronomy (e.g., Skuljan et al. 1999; Hogget al. 2005; Bovy et al. 2012). Gaussian mixture models(GMMs), which model an underlying density probabilitydistribution function (pdf) using a sum of Gaussian com-ponents, are a commonly used tool for solving densityestimation problems such as these (Ivezic et al. 2014).However, traditional GMMs do not have the ability toincorporate measurement noise into the density calcu-lation, and often in astronomy we must deal with ob-servations that have multiple sources of noise with verydifferent properties. For problems such as this, the “ex-treme deconvolution” GMM (XDGMM) technique mustbe used.

XD was originally outlined by Bovy et al. (2011), andprovides a way to perform Bayesian estimation of mul-tivariate densities modeled as Gaussian mixtures (Ivezicet al. 2014). XDGMMs have already proven useful formodeling underlying distributions using noisy observa-tions for multiple areas of astronomy, from velocity dis-tributions of nearby stars (Bovy et al. 2009; Bovy & Hogg2010) to photometric redshifts and quasar probabilitiesof SDSS sources (Bovy et al. 2012) to 3-D kinematicsof stars in the Sagittarius stream (Koposov et al. 2013).However, the potential of XD models to be used as pre-

1 Department of Astronomy, The Ohio State University, 140West 18th Avenue, Columbus, OH 43210, USA

2 Center for Cosmology and AstroParticle Physics (CCAPP),The Ohio State University, 191 W. Woodruff Ave., Columbus,OH 43210, USA

3 Kavli Institute for Particle Astrophysics and Cosmology, De-partment of Physics, Stanford University, Stanford, CA, 94305

4 SLAC National Accelerator Laboratory, Menlo Park, CA,94025

dictive tools has yet to be explored. An XDGMM isable to model the complicated correlations between var-ious parameters in a many-dimensional dataset. If thismodel could be conditioned on the known values of someof these parameters, it could be used to predict likely val-ues for the remaining parameters, allowing the samplingof realistic properties without knowledge of how the var-ious parameters are correlated. This is an XD extensionof the predictive approach known as Gaussian MixtureRegression, with the added functionality of being able tohandle noisy or missing data. While there are multipleexisting implementations of the XDGMM algorithm, noexisting tool has this functionality.

One potential use of an XDGMM prediction tool is tosample likely parameters for a supernova (SN) given theparameters of a host galaxy. The problem of supernovasimulation is a common one for large-scale sky surveys,as it is useful both for planting fake supernovae (SNe) inexisting data to test detection efficiency for calculatingSN rate (Melinder et al. 2008; Graur et al. 2014) and forcreating realistic simulated data to test data processingpipelines of upcoming surveys, such as the Large Syn-optic Survey Telescope (LSST; Ivezic et al. 2008). Forvarious applications it can also be useful to place real-istic simulated SN within a realistic galaxy distributionin a cosmological context, for example to understand theconnection between observational biases in host detec-tion and cosmological observables. In each of these cases,having realistic SN properties is essential for avoidingthe introduction of further uncertainty or biasing detec-tion of new sources. Further, many known correlationsbetween host and SN properties are based on physicalquantities, such as host mass, metallicity, and star for-mation rate, that must be inferred from observations us-ing theoretical models, introducing further uncertainty(e.g., Sullivan et al. 2010; Childress et al. 2013; Grauret al. 2016a,b). An XDGMM model trained only on a

SLAC-PUB-16990

This material is based upon work supported by the U.S. Department of Energy, Office of Science, under Contract No. DE-AC02-76SF00515.

2

wide range of empirical, observed host properties couldbe used to sample realistic supernova properties withoutthe need for theoretical models, removing this as a sourceof uncertainty. However, in order to build such a tool,a new implementation of XDGMM that allows for theconditioning of the model is needed.

The rest of this paper is laid out as follows. In §2 wedescribe the XDGMM class5 (Holoien et al. 2016a) andthe new functionality that differentiates it from existingXDGMM fitting tools. In §3 we describe the empiri-ciSN supernova prediction tool6 (Holoien et al. 2016b)and demonstrate its functionality. Finally in §4 we sum-marize the capabilities of our software and describe someof the preliminary results obtained using empiriciSN.

2. XDGMM

As described in §1, XDGMM fitting methods are use-ful tools for performing density estimation of noisy data,a situation that occurs often in astronomy. When webegan our research into building a tool to predict theproperties of supernovae based on observed host galaxyproperties, XDGMM modeling seemed to be a naturalway to use machine learning to fit the underlying dis-tributions of the numerous host and supernova proper-ties in our dataset. Furthermore, by conditioning such amodel on known host properties, we can create a modelbased solely on the supernova properties of interest, andsample from this conditioned model to predict super-nova properties for a given host. However, existing tools,such as AstroML7 (Vanderplas et al. 2012; Ivezic et al.2015) and the Extreme-Deconvolution tool8 fromBovy et al. (2011), provided XD fitting methods but didnot have the ability to condition the model that we re-quired. In addition, though the AstroML implementa-tion of XDGMM utilizes some of the functionality of thescikit-learn GMM class (Pedregosa et al. 2011), nei-ther tool implements the scikit-learn algorithms thatcould be used to perform cross-validation (CV) tests tooptimize model parameters. Because the ability to con-dition and perform cross-validation on XDGMM modelscould be useful for other astronomical studies, we decidedto first build our own implementation of XDGMM thatprovides access to both the AstroML and Extreme-Deconvolution fitting methods and implements thefunctionality we needed to build a supernova fitting tooland make it available to the public.

2.1. Fitting Methods

Both the AstroML and Bovy et al. (2011) fitting al-gorithms are able to successfully fit a Gaussian MixtureModel using extreme deconvolution, and improving orediting their methods was not one of our goals with thisproject. However, as the two tools use slightly differentalgorithms to perform fits, we provided the ability forthe user to select between the two when using XDGMM.Brief descriptions of each method are provided here.

5 The version of XDGMM used in this paper is availableat https://github.com/tholoien/XDGMM/tree/v1.1 and has DOIhttps://doi.org/10.5281/zenodo.268532

6 The version of empiriciSN used in this paper is available athttps://github.com/tholoien/empiriciSN/tree/v1.0 and has DOIhttps://doi.org/10.5281/zenodo.163859

7 http://www.astroml.org/index.html8 https://github.com/jobovy/extreme-deconvolution

AstroML is an open-source Python module for ma-chine learning and data mining and provides a wide rangeof statistical and machine learning tools for analyzing as-tronomical datasets (Vanderplas et al. 2012; Ivezic et al.2015). One of the provided tools is an implementation ofXD Gaussian Mixture Modeling, and is based on the al-gorithms described in Bovy et al. (2011). Though slowerthan the Bovy et al. (2011) Extreme-deconvolutiontool, which makes use of OpenMP for parallelizing themodel fitting process, the AstroML implementation ofXDGMM provides a clean user interface similar to that ofthe GMM implementation of scikit-learn (Pedregosaet al. 2011), and we based our interface for XDGMM onthat of the AstroML tool. We also use the AstroMLimplementation of several of the methods used to scoredatasets under an existing model.

The utility of extreme deconvolution for density esti-mation of astronomical datasets was first described inBovy et al. (2011), and the Extreme-Deconvolutiontool provided by the authors of that manuscript was oneof the first tools to implement XDGMM fitting meth-ods. Though Python, R, and IDL wrappers are avail-able, Extreme-Deconvolution is built in C and usesOpenMP to parallelize the fitting method. As such,it provides a significantly faster fit than the AstroMLXDGMM tool.

Though the Extreme-Deconvolution providesfaster performance, we elected to make the AstroMLfitting method the default fitting method of XDGMMfor two reasons. First, the AstroML implementationprovides more stable fit results, and is less prone to is-sues resulting from outlying data than the Bovy et al.(2011) tool. Second, as a Python module, AstroMLis easily installable on most systems, while Extreme-Deconvolution requires a more detailed installation,as C compilers and the availability of OpenMP varyfrom system to system. Because of this, while As-troML is required for installing XDGMM, Extreme-Deconvolution is not, and is only imported if the userattempts to perform a fit using the Bovy et al. (2011)method.

Listing 1 shows an example of how to create a newXDGMM object, fit a model to a dataset, and sampledata from the model. The fitting and the sampling in-terface was purposefully built to mimic the AstroMLXDGMM interface so that our XDGMM class could besubstituted for theirs in existing code.

Listing 1—An example of the fitting interface for XDGMM.We purposefully built this to use the same interface as theAstroML XDGMM tool.

from xdgmm import XDGMMxd = XDGMM()X, Xerr = (data, errors)xd.fit(X, Xerr)xd.sample(2000)

2.2. Component Selection

When fitting a Gaussian Mixture Model to a dataset,it is necessary to choose the number of Gaussian compo-nents to use in the model. If the number of componentsin the model is too small, the model will be too simplis-tic, and will underfit the data, but if the number of com-

3

ponents is too large, the model will be too flexible andwill overfit the data. In either case, a subsequent sam-ple drawn from the model will not accurately representthe dataset used to train the model. In addition, withlarge datasets and large numbers of parameters being fit,the computation costs will rapidly become expensive, re-sulting in very long fit times. Thus, it is important tochoose a number of components that can fit the data wellwithout overfitting and which doesn’t place unnecessarystress on computational resources.

2.2.1. Bayesian Information Criterion

One method for choosing the correct number of com-ponents for the model is to use the Bayesian InformationCriterion (BIC; Schwarz 1978). The formula for the BICis given in Equation 1 below.

BIC = −2 log L+ k log n (1)

Here, L is equal to the maximized likelihood functionof the model being scored, k is the number of free param-eters being estimated (e.g., the number of components ina GMM), and n is the number of observations used tofit the model. If the BIC is calculated for a number ofdifferent models that each use a different number of freeparameters, the one with the lowest BIC is the preferredmodel. Since it incorporates both a likelihood score anda component that incorporates the number of free pa-rameters, it penalizes models with too many degrees offreedom, which can help avoid overfitting.

Our XDGMM class computes the BIC score for thecurrent model using a specific dataset in the same waythat the scikit-learn GMM class computes the BIC,except that our class can also account for uncertainty onthe input data when computing the BIC. (If the user in-puts a covariance matrix with a dataset, the XDGMMclass will incorporate these uncertainties into the modelcovariance matrix before calculating the BIC.) We havealso provided a function that can compute the BIC fora given dataset for a range of numbers of components,allowing the user to compare different models and se-lect the ideal one. This functionality is demonstrated inListing 2.

Listing 2—A demonstration of the BIC test function, whichallows the user to compare different XDGMM models withdifferent numbers of components.

param range = np.array([1,2,3,4,5,6,7,8,9,10])bic, optimal n comp , lowest bic =

xd.bic test(X, Xerr, param range)

In the example code of Listing 2, the XDGMM objectcomputes the BIC score for the data and uncertaintiescontained in the X and Xerr arrays for a number ofcomponents ranging from 1 to 10. It then returns thebic array, which contains the score for each model, theoptimal number of components (defined as the number ofcomponents in the model with the lowest BIC score), andthe lowest BIC score. These results can be used for directcomparison, or can be plotted to see the results visually.In Figure 1, we show the BIC results for the AstroMLXDGMM demo dataset (Vanderplas et al. 2012). Theminimum BIC value occurs with 5 Gaussian componentsin the model, indicating that models with higher numbersof components overfit the data.

1 2 3 4 5 6 7 8 9 10

Number of components

15800

16000

16200

16400

16600

16800

17000

17200

BIC

scor

e

*

Fig. 1.—BIC scores computed by XDGMM using the As-troML XDGMM demo dataset (Vanderplas et al. 2012) fordifferent models with the number of components ranging from1 to 10. The optimal number of model components based onthe BIC is 5.

2.2.2. Machine Learning

An alternative way to determine the number of com-ponents is to perform a cross-validation test with a rangeof numbers of components. In order to allow the user toperform such a test, we have made the XDGMM classa subclass of the scikit-learn BaseEstimator classand implemented all the scikit-learn functions nec-essary for the standard scikit-learn cross-validationtools. We use the mean log-likelihood of a dataset underthe given model as the score for cross-validation. BecauseXDGMM extends BaseEstimator, a cross-validationtest can be performed by simply passing a XDGMM ob-ject and a dataset into the scikit-learn cross-validationfunctions. A demonstration of computing a validationcurve using the same AstroML demo dataset for 1 to10 components is given in Listing 3.

Listing 3—A demonstration of a cross-validation test per-formed using the scikit-learn validation curve function.

param range = np.array([1,2,3,4,5,6,7,8,9,10])shuffle split = ShuffleSplit(3, test size=0.3)train scores ,test scores =

validation curve(xd, X=X, y=Xerr,param name=

"n components",param range=param range ,n jobs=3,cv=shuffle split)

It is important to note the trick used to pass errors tothe scikit-learn methods. Normally for unsupervisedlearning you would only pass an X “design matrix” array,and not a “target” y array, to the validation curvemethod. However, an error array must be passed to theXDGMM fit method, and validation curve simplyuses its y input as the second argument for the fit func-tion. Thus, by passing in the error array as the “target”array, we can pass it to our fit function so that it canbe used in fitting the data.

Figure 2 shows the results of the cross-validation testabove. The cross-validation test prefers the maximumnumber of components (10) that we allowed for the model

4

Fig. 2.—Results of the cross-validation test performed inListing 3 on the AstroML demo dataset (Vanderplas et al.2012). The red line shows the mean training scores for eachnumber of components in the test, and the green line showsthe mean scores for the test sample. The shaded regions indi-cate the standard deviation for each. The cross-validation testprefers a maximum number of components for this dataset.

(and in fact, the score continues to rise as more compo-nents are added beyond 10). This is a result of the par-ticular dataset being fit: the likelihood of the data beingfit increases with more components, and there is enoughstructure to the data that even with a large number ofGaussians, the trained model continues to be a good pre-dictor of new data. However, increasing the number ofcomponents in the model rapidly causes the fit algorithmto become computationally expensive, especially for theastroML algorithm. While a model with a large numberof components may be mathematically superior, in mostcases the BIC seems to provide a way to find a modelthat is “good enough” to fit the data well, while alsokeeping the number of components at a value that keepsthe computation of new fits reasonable. We recommendtrying both tests with a given dataset to see if the re-sults differ substantially before settling on a choice forthe number of components to use when fitting a model.

Once we know the optimal number of components touse, it is straightforward to fit a model to the data(see Listing 1). Figure 2 replicates the results of theAstroML Extreme Deconvolution example (Vanderplaset al. 2012) using our XDGMM code. We first create a“true” distribution and a “noisy” distribution using theVanderplas et al. (2012) demo code, then we fit a modelto the noisy distribution using 5 Gaussian componentsand sample 2000 data points from the model. We cansee that even with only 5 components, the distributionsampled from the XDGMM model is able to replicate thetrue data sample despite being fit using the “measured”noisy distribution. This demonstrates why extreme de-convolution is such a powerful tool for modeling datasetssuch as this.

2.3. Conditioning the Model

A primary motivation behind this implementation ofextreme deconvolution was to develop a tool that can beused to predict model parameters based on known valuesof other parameters. To do this, the model must be con-ditioned on the known parameter values, after which wecan then sample values of the non-conditioned parame-

Fig. 3.—Replication of the results of the AstroML ExtremeDeconvolution example (Vanderplas et al. 2012). Top Left:the “true” distribution of the demo dataset. Top right: the“noisy” distribution of the demo dataset, meant to simulateobserved data points. Bottom right: The 5 Gaussian com-ponents from the XDGMM model after fitting the model tothe data. Bottom left: 2000 data points sampled from theXDGMM model. The resampled dataset closely matches thetrue distribution, despite being fit using the noisy distribu-tion.

ters from the conditioned model. Neither the AstroMLnor the Bovy et al. (2011) implementations of XDGMMcontain this functionality, and we have implemented it inour software.

First, we briefly discuss the mathematics of a condi-tional Gaussian mixture model. The probability distri-bution for a Gaussian mixture with K components isgiven by (Bishop 2006; Rasmussen & Williams 2006):

p (x) =

K∑k=1

πkN (x | µk,Σk) (2)

Here, πk, µk, and Σk are the mixing coefficient(weight), means, and covariances of the k-th Gaussiancomponent. Given the jointly Gaussian vectors xA andxB and the above Gaussian mixture, we have:

x =

(xA

xB

), µk =

(µkA

µkB

),

Σk =

(ΣkAA ΣkAB

ΣkBA ΣkBB

), Λk = Σ−1k

The conditional distribution of xA given xB for thek-th Gaussian component is given by (Bishop 2006):

pk (xA | xB) =pk (xA,xB)

pk (xB)

= N(xA | µkA|B ,Λ

−1kAA

) (3)

The conditional mean vector of the k-th Gaussian com-ponent is given by:

µkA|B = µkA −Λ−1kAAΛkAB (xB − µkB) (4)

5

Finally, the k-th conditional mixing coefficient is givenby:

π′k =πkN (xB | µkB ,ΣkBB)∑

kN (xB | µkB ,ΣkBB)(5)

Thus, the conditional probability distribution for thewhole GMM is given by:

p (xA | xB) =

K∑k=1

π′kpk (xA | xB) (6)

The resulting conditioned GMM has the same numberof Gaussian components as the original GMM, but hasfewer dimensions, given by the number of dimensions inxA. We can then use this conditioned model to samplevalues for the parameters in xA given the known quanti-ties in xB .

When using XDGMM as a prediction tool for astro-nomical quantities, it may often be the case that theuser wants to condition the model on parameter measure-ments that have measurement uncertainties. Condition-ing a model on a particular value of xB=xB,0 is equiv-alent to marginalizing out xB assuming a delta functionPDF for it. If we include uncertainties on the measure-ment of xB in the form of a covariance matrix CB , we canincorporate these uncertainties into the conditioning byadding CB to the covariance array of the unconditionedGMM prior to conditioning the model. The result willstill be a GMM, but its components will be i) broader,since the extra covariance CB will end up being added tothe component covariance matrix Λ−1kAA, and ii) weighteddifferently, since the weights in Equation 5 are themselvesfunctions of xB .

We have built two different but equally straightforwardinterfaces for conditioning the model. In order to con-dition the model, the XDGMM object needs to be in-formed which of the parameters of the model (e.g., xand y in the sample dataset) have values on which tocondition the model. The XDGMM object stores theparameters in a specific order based on their order in thedataset that was used to fit the model—for example, x isstored first and y second for the demo dataset used here,since the data was passed to the model as (x, y) pairs.In some cases, such as this simple demo, it may be easyfor the user to remember the order of the parameters,and we have built one conditioning interface to take ad-vantage of such cases. Listing 4 demonstrates this firstinterface. In this conditioning method, the user passesone or two arrays to the condition function: one arraycontaining values for each parameter (either a value forconditioning or NaN if the parameter is not being usedfor conditioning), and an optional second array contain-ing uncertainties on the parameter values.

However, we recognize that in many cases, the usermay be fitting large datasets with many parameters, andmaintaining the proper order for conditioning may bedifficult. For this reason, the XDGMM object also al-lows the user to label the parameters in the model. Thiscan be done manually, by setting the XDGMM object’slabels array, or by fitting data stored in a PandasDataFrame object. If the data being fit are stored in aPandas DataFrame and the columns are labeled, the

Fig. 4.—Probability distribution of x from the demo modelconditioned on y = 1.5 ± 0.05. The gray ellipses show the5 components of the original XDGMM model (the bottom-right panel of Figure 3), the blue line shows the value of y usedto condition the model, and the red line shows the resultingdistribution of x (right scale). Note how conditioning themodel changes the weights and means of the components ofthe model, and how the measured value of y essentially rulesout several model components.

labels will be automatically stored in the XDGMM ob-ject when the data are fit.

Listing 4—A demonstration of the first interface for modelconditioning the model using the demo dataset and the knownvalue y = 1.5 ± 0.05. In this method, the user knows the in-dices of the parameters to use for conditioning and passesarrays for the parameter values and uncertainties to the con-dition function.

fixed X = np.array([np.nan, 1.5])unc = np.array([0.0,0.05])new xd = xd.condition(X input=fixed X ,

Xerr input=unc)

If the labels have been set, the user can then use adictionary object which links the labels for parametersto condition the model on with (value, uncertainty) pairsto condition the model. In Listing 5 we demonstrate thisfunctionality. Here we label the parameters ‘x’ and ‘y’and then pass a dictionary containing only a value fory to the condition function. The conditioned modelthat results will be the same regardless of the methodused for conditioning; the different interfaces are simplysupplied so that the user can choose whichever methodthey prefer.

Listing 5—A demonstration of the second interface formodel conditioning. Labels for the different parameters inthe model are first set by the user, and then a dictionaryobject is used for conditioning.

xd.labels = np.array([’x’,’y’])fixed = {’y’:(1.5,0.05)}new xd2 = xd.condition(X dict=fixed)

Once the model has been conditioned, the resultingmodel will have the same number of components as theoriginal model but will have fewer dimensions, as it isnow a model only for the parameters that were not con-ditioned out. In the code above, we have conditioned the

6

Fig. 5.—Top: Distribution of “observed” (x, y) pairs sam-pled from the demo XDGMM model (red) compared with(x, y) pairs that predict an x value for each observed y value(blue). Though a predicted x value for a given y value maynot exactly match the true x value, the overall distribution isthe same, which indicates that the XDGMM model functionsproperly as a prediction tool. Bottom: The same plot withthe x values predicted by a random forest method. Since therandom forest model was trained on the noisy demo data anddoes not incorporate data uncertainty, the x values it predictshave significantly more scatter than the x values predicted byXDGMM.

demo model based using y = 1.5 ± 0.05, and the result-ing model is a 5 component GMM for the x parameter.Figure 4 shows the resulting probability distribution ofx. Conditioning the model changes the weights, means,and covariances of the components of the model. Theconstraint on y essentially rules out several componentsof the original model, significantly reducing their weightin the conditioned model.

As stated before, one potential use of a conditionedmodel is to create a “prediction engine” that can predictsome parameters using an XDGMM model conditionedon known values of other parameters. To demonstratethis, we sampled 1000 data points from our original, un-conditioned model to create a dataset to be comparedwith our predictions. This represents a new “observed”dataset for the x and y parameters. Now if we had onlyobserved the y values from this dataset and wanted topredict a likely x value for each y value, we can con-dition the model on each of these y values in turn anddraw a predicted x value from the conditioned model.In reality, XDGMM would likely be used to predict val-ues for parameters that have not been measured, so thisprovides a good way to test whether the tool is function-ing properly—these predicted x values should follow thesame distribution of the observed x values—and Figure 5shows that this is the case. Though the predicted x for asingle given y value may not match the observed x value,

the fact that the overall distributions match indicatesthat XDGMM provides an accurate prediction tool.

Figure 5 also compares the performance of ourXDGMM model with a standard random forest pre-dictive method. We fit a random forest model to thesame noisy dataset used for the demo, and then used thismodel to predict x values for the same y values used forthe XDGMM test. Since the random forest model wasfit on the noisy data and does not handle data uncertain-ties, it is unable to replicate the tight “true” distributionof our test dataset. While this is a simple example andthere are other predictive machine learning methods thatcould potentially model the data, this demonstrates thatXDGMM has capabilities, such as accounting for corre-lations in predicted values and handling noisy or missingdata, that other methods do not.

Throughout this Section we have used the AstroMLExtreme Deconvolution example dataset (Vanderplaset al. 2012) because it is a simple two-dimensional datasetthat makes the capabilities of XDGMM (e.g., fitting amodel to a dataset, sampling from a model, and condi-tioning a model) easy to visualize. Using this dataset alsoallows us to compare our XDGMM class directly withthe AstroML implementation. However, this dataset isvery simplistic, and could likely be modeled equally wellwith a number of different modeling techniques. In or-der to provide an example of a more realistic use case foran XDGMM model, Figure 6 shows the results of fittinga 12-component XDGMM model to stellar data fromSDSS Stripe 82 (Ivezic et al. 2007).

This dataset, which is also used in the AstroMLExtreme Deconvolution examples, is a five-dimensionaldataset consisting of the g-band magnitude and u − g,g − r, r − i, and i − z colors of roughly 13,000 starsfrom the SDSS Stripe 82 Standard Star Catalog (Ivezicet al. 2007). Magnitudes derived from single epoch ob-servations are used as a low signal-to-noise input samplefor our XDGMM model, and magnitudes derived frommultiple observations (and thus with smaller scatter) areused as a comparison sample. Figure 6 shows two dimen-sions, the g − r and r − i colors, of the five dimensionsthat were fit. The high signal-to-noise data is shown inthe top-left panel and the low signal-to-noise input datais shown in the top-right panel. The XDGMM modelwas fit using a 12 Gaussian components and the Bovy etal. fitting method, with the resulting Gaussian compo-nents shown in the bottom-right panel. The bottom-leftpanel shows the distribution of an equal number of pointssampled from the fit model, and as the figure shows, thepoints sampled from the resulting distribution have scat-ter comparable to the Standard Star Catalog data despitebeing fit to more noisy input data. This example showsthat XDGMM can be a powerful tool for modeling theunderlying distributions of noisy, observed astronomicaldatasets, and our XDGMM model could then be con-ditioned to, for example, sample likely star colors givenonly a g-band magnitude.

3. EMPIRICISN

It is well established that supernova properties, suchas light curve color and shape, have a dependence ontheir host environments (e.g., Modjaz et al. 2008; Sul-livan et al. 2010; Childress et al. 2013; Galbany et al.2014; Graur et al. 2016a,b). Planting simulated super-

7

Fig. 6.—Replication of the results of the AstroML Ex-treme Deconvolution of Stellar Data example (Vanderplaset al. 2012), using an XDGMM object to model stellar mag-nitudes and colors using data from the SDSS Stripe 82 Stan-dard Star Catalog (Ivezic et al. 2007). The figure shows twodimensions, the g− r and r− i colors, of the five-dimensionaldataset. Top Left: high signal-to-noise magnitudes calcu-lated from multiple epochs of observation. Top right: lowsignal-to-noise magnitudes taken from single epoch observa-tions. Bottom right: The 12 Gaussian components from theXDGMM model after fitting the model to the data. Bot-tom left: an equal number of data points sampled from theXDGMM model. The resampled dataset has a tight scattersimilar to that of the multi epoch data, despite being fit usingthe single epoch observations.

novae in real or simulated imaging data has a variety ofuses—for instance, fake supernovae can be used to testthe detection efficiency of supernova searches, which isa necessary quantity to know for calculating supernovarates, and simulated data including supernovae can beused to train data processing and automated source de-tection pipelines for future surveys like LSST. Modelingthe distribution of supernovae within a cosmologicallymotivated galaxy distribution can also be used to testhow the connection between their properties and the un-derlying structure can impact various observables.

It is important to ensure that supernovae simulatedfor these purposes have properties that accurately matchtheir environments and are consistent with each other,otherwise the results of these studies wouldn’t be appli-cable to real-world conditions. However, many of theknown supernova-host correlations are based on phys-ical parameters of the host—e.g., star formation rate,mass, metallicity—which must be inferred using theoret-ical models from observations (e.g., Sullivan et al. 2010;Childress et al. 2013; Graur et al. 2016a,b). Thoughmany of these theories are fairly well-established, thisintroduces additional uncertainty into the selection of su-pernova properties.

In this section we outline empiriciSN, a tool for pre-dicting realistic Type Ia supernova (SN Ia) propertiesbased only on observed host galaxy properties. Our goalin creating empiriciSN was to provide a model trainedon observed empirical host and supernova properties,thus eliminating the need for using theoretical modelsto infer the host galaxy’s physical properties. As this re-

quires calculating correlations between many supernovaand host properties and the subsequent conditioning ofthe model, it provides a real-world use for our XDGMMclass. Our default model is trained using supernova andgalaxy properties that can be generated by SNCosmo(Barbary 2014) and CatSim (Connolly et al. 2014) sothat it can be used for generating realistic supernovaefor LSST Twinkles9 simulations (LSST DESC, in prep.).These include the SALT2 Type Ia light curve parame-ters (x0, x1, and c; Guy et al. 2007), the host redshift,the 10 rest-frame host colors obtainable with ugriz mag-nitudes, the separation of the supernova from the hostnucleus in units of the host effective radius, and the lo-cal surface brightness at the location of the supernovain all 5 ugriz filters. These host properties were chosenbecause they are all observable properties that do notrequire theoretical modeling, and are known to correlatewith physical properties of the host environment that canaffect supernova parameters.

3.1. Input Catalogs

In order to model the 20 host and supernova propertieslisted above, we require a large dataset with consistentmeasurements of the SALT2 parameters and consistenthost photometry. We decided to use a sample of super-novae taken from the Supernova Legacy Survey (SNLS;Astier et al. 2006; Sullivan et al. 2011) and the SloanDigital Sky Survey (SDSS; York et al. 2000) SupernovaSurvey to build a model for our data.

All SALT2 light curve parameters for the SNLS su-pernovae and a portion of the parameters for our SDSSsupernovae are taken from the Joint Light-curve Analy-sis (JLA; Betoule et al. 2014), a project to analyze lightcurves of supernovae discovered by SNLS, SDSS, andother sources. This includes 242 spectroscopically con-firmed Type Ia supernovae from SNLS and 374 spectro-scopically confirmed Type Ia supernovae from the SDSSSN survey. Because the JLA catalog provides a peakmagnitude rather than the x0 SALT2 parameter, we usedSNCosmo to fit the JLA light curves ourselves assumingthe redshifts, x1, and c parameters provided, and calcu-lated x0 in this way. In order to increase the size of oursample to be large enough to model, we also include theremaining spectroscopically confirmed SNe Ia from theSDSS SN search as well as the photometric SNe Ia witha spectroscopic host redshift from (Sako et al. 2014). Weinclude the photometric SNe Ia because doing so providesus with an additional 906 SNe, though we acknowledgethat some of these may not actually be Type Ia. Sakoet al. (2014) provide the x0 SALT2 parameter, but sincethey use a slightly different model than the JLA model,we correct the Sako et al. (2014) X0 values by a fac-tor of 10(0.108) to make them consistent with the valuesmeasured from the JLA light curves.

We then searched the coordinates of all host galax-ies from our SN samples in the SDSS Data Release 12(DR12; Alam et al. 2015) and obtained model magni-tudes, model fluxes, effective radii, and morphology forall galaxies that were detected in DR12 data. This re-duced our sample to 159 supernovae from SNLS and 1273supernovae from SDSS. For the purposes of calculating

9 https://github.com/LSSTDESC/Twinkles

8

local surface brightness, all galaxies in the sample areconsidered to have either an exponential or a de Vau-couleurs surface brightness profile, and we use whichevermodel is considered more likely by the SDSS pipeline inthe r-band as the model for each galaxy. The r-bandeffective radius of the best-fit surface brightness profilewas used to convert the separation from the host nucleusmeasured in Betoule et al. (2014) and Sako et al. (2014)from arcseconds to units of R/Re.

The host galaxy model magnitudes are magnitudesgenerated for each filter assuming the same best-fit sur-face brightness profile and incorporate a convolution withthe image PSF to account for PSF effects. The magni-tudes have been corrected for Galactic extinction andcorrected to rest-frame using kcorrect (Blanton &Roweis 2007) before being used to calculate host col-ors. The model magnitudes are ideal for unbiased galaxycolor measurements, and while other datasets may notmeasure galaxy magnitudes and colors in the same way,we believe they should still be able to obtain reasonableresults from our default model.

Though we have taken steps to make our SN and hostgalaxy sample as consistent as possible, we acknowledgethat both SN datasets were obtained after applying selec-tion criteria, particularly the JLA sample, and we havenot incorporated any corrections into our model to cor-rect for these selection effects. Thus the distributionprobability of SN parameters obtained by empiriciSNcombines both the true underlying distribution in na-ture and the detection efficiencies of each survey, and itmay be necessary for the user to correct for the detec-tion efficiency when using our default model to simulateSNe. We also caution that, though the dataset spans awide range of SN and host galaxy properties, it is pos-sible that certain galaxy types (e.g., low-mass galaxies)are underrepresented and therefore not well-modeled bythe default model. We will be taking steps to quantifypotential shortcomings of the default catalog in a futurerelease of the software.

However, despite the survey effects present in our de-fault datasets, when combined they still provide us witha fairly large dataset with a wide range of SN and hostgalaxy properties. Furthermore, we have built empiri-ciSN to be easily updated with additional or differentcatalogs by the user; as long as the data files are format-ted in a manner similar to our default dataset, an Em-piricist object can fit a model to any number of super-nova and host properties. This allows the user to makeadjustments to the provided SDSS/SNLS dataset (suchas using fluxes instead of magnitudes, for their moreGaussian uncertainties), extend the model to include ad-ditional catalogs, or even to model different types of su-pernovae, in the future.

Testing using the BIC test described in §2.2.1 indicatedthat the preferred number of Gaussian components forour dataset was 6, and we have provided a default 6-component model that is available with the empiriciSNsoftware. The default model also has built-in labels foreach of the SN and host parameters so that these can beused for conditioning, as described in §2.3.

3.2. Demo/Results

The empiriciSN class object is called Empiricist,and here we demonstrate some of its basic functional-

ity. If using the default model fit to our SDSS and SNLSdata sample, or another model that has already been fitto a dataset, it is straightforward to declare a new Em-piricist object and read in the existing model, as shownin Listing 6. A model can be loaded upon creation ofan Empiricist object by passing the model file name tothe model file argument of the constructor. Alterna-tively, Listing 7 demonstrates how to run a test for theoptimal number of components and fit a new model to adataset. The fit model function always saves the newlyfit model to a file, either with a the default name ‘em-piriciSN model.fit’ or with a file name passed into thefunction’s filename argument. After fitting a model,that model is stored in the Empiricist object and canbe used for SN prediction without the need to load themodel again.

Listing 6—An example of creating a new Empiricist objectand reading in our pre-computed default model. The Em-piricist object can also be created with the model alreadyloaded by passing the file name to the model file argumentof the constructor.

from empiriciSN import Empiricistemp = Empiricist()emp.read model(’default model.fit’)

Listing 7—A demonstration of the interface for testing forthe optimal number of components to use for a dataset andfitting a model to that dataset. The component test func-tion’s third argument is the range of values for the numberof Gaussian components to test using the BIC test built intothe XDGMM model; in this case we use the values 1 − 8.The newly fit model is automatically saved to a file with thedefault name ‘empiriciSN model.fit’, or with a name passedinto the fit model function’s filename argument.

X, Xerr = (data, errors)comp range = np.array([1,2,3,4,5,6,7,8])bics, optimal n comp , lowest bic =

emp.component test(X=X, Xerr=Xerr,component range=

comp range)emp.fit model(X=X, Xerr=Xerr,

n components=optimal n comp)

If using the default model, the local surface brightnessat the location of the supernova in each filter are 5 of thehost properties necessary for sampling a realistic SN fora host. However, the separation of the SN from the hostnucleus is one of the properties being fit, and the localsurface brightness cannot be calculated until a locationhas been chosen. Because of this, the prediction of a real-istic SN proceeds in two steps: first, a position is selectedbased on a subset of host parameters, and then the localsurface brightness is calculated and the SALT2 parame-ters of the SN are sampled from a model conditioned onthe full range of host parameters.

In order to select a location for a SN, the user cancondition on any subset of the parameters used to fitthe model. The indices of the parameters to conditionon must be passed as an argument to the get logRfunction, as must the index of the logR/Re parameter.Any indices may be used except the first three, whichare assumed to be the three SALT2 parameters for theSN. The Empiricist object will condition the XDGMM

9

model using the data passed into the function and thenreturn a value of logR/Re sampled from the conditionedmodel. Uncertainties on the quantities being used forconditioning the model may be used, but are not re-quired. Listing 8 demonstrates this functionality, usingthe host galaxy redshift and 10 host colors to conditionthe model and select a location for the SN.

When using our default model, the get local SBfunction can be used to select a local surface brightnessat the location of the SN once a location has been sam-pled for a given host. The host data passed into thisfunction must be an array of 21 surface brightness pa-rameters. The first index should be the host Sersic in-dex (1 for an exponential profile, 4 for a de Vaucouleursprofile), and this should be followed by sets of magni-tude, magnitude uncertainty, effective (half light) radiusin arcseconds, and radius uncertainty for each of the 5ugriz filters. The function returns two arrays, one withthe local surface brightness in units of magnitudes persquare arcsecond for each filter and the other containingthe uncertainties on the local surface brightnesses. Themagnitudes are assumed to be K-corrected and correctedfor Galactic extinction, as this is what the default modelwas trained on. Listing 9 demonstrates this.

Listing 8—A demonstration of selecting a location for a SNgiven a subset of host parameters using our default model.In this case, the indices used for conditioning represent theredshift and the 10 ugriz colors of the host. The X and Xerrarrays represent arrays of the host redshift and colors anduncertainties on these quantities, respectively.

X, Xerr = (data, errors)cond ind =

np.array([3,5,6,7,8,9,10,11,12,13,14])logR = emp.get logR(cond indices=cond ind ,

R index=4, X=X, Xerr=Xerr)

Listing 9—A demonstration of calculating the local sur-face brightness of the host, if using our default model. TheSB params array is assumed to be of the form described inthe text. The logR value is assumed to have been fit usingget logR as demonstrated in Listing 8.

SB params = [params for host]SB, SB err =

emp.get local SB(SB params=SB params ,R=logR)

Finally, once we have a location and local surfacebrightnesses, it is straightforward to sample a SN for thehost galaxy using the get SN function. In Listing 10 wedemonstrate how to select a single SN for a given host.The resulting array contains the SALT2 x0, x1, and cparameters for the sampled SN.

Figure 7 shows a plot of the measured SALT2 param-eter distributions from our test SN sample in black, theSALT2 parameters for 482 SNe sampled from our un-conditioned fitted model in red, and the distribution ofparameters for 1000 SNe that were sampled for a singlehost galaxy in our sample in blue, with location and localsurface brightness calculated as described above. As canbe seen in the Figure, the distribution of supernova pa-rameters sampled from the unconditioned model matchesthat of the actual distribution quite well, given the smallnumbers involved. Conversely, the distributions for the

Fig. 7.—Distributions of the three SALT2 SN parametersmeasured in our full 482-object test dataset (black) comparedto the parameters for 482 SNe sampled from our uncondi-tioned, fitted model (red) and 1000 SNe drawn using empiri-ciSN for a single set of host galaxy parameters (blue). TheSN location and local surface brightness were also sampledusing empiriciSN, as described in Listings 8 and 9. Thedistributions of the various properties taken from the uncon-ditioned model match the true distributions well, while theycan be very different for a single position in a single host thanwhat they are for the full sample.

various properties can be quite different for a single po-sition in a single host than what they are for the fullsample, which is the behavior we expect.

Listing 10—The supernova selection interface for the Em-piricist object. Here we combine the radius and the hostproperties fit in the previous two Listings with our initialmagnitude and redshift arrays to create an array with all thehost properties needed to condition the model and samplesupernova properties. Here we are using the array index ver-sion of XDGMM conditioning as opposed to the dictionaryversion.

host params =np.array([np.nan,np.nan,np.nan])

host params = np.append(X[0],logR)host params = np.append(host params ,X[1:])host params = np.append(host params ,SB)host err =

np.append(np.array([0.0,0.0,0.0]),Xerr[0])

host err = np.append(host err , 0.0)host err = np.append(host err , Xerr[1:])host err = np.append(host err , SB err)

predicted SN = emp.get SN(X=host params ,Xerr=host err ,n SN=1)

For a more detailed walkthrough of the empiriciSNsoftware, please see the demo notebook on the empiri-ciSN github page.

10

4. DISCUSSION

In this paper we have summarized the capabilitiesof two new pieces of Python software that implementExtreme Deconvolution Gaussian Mixture Modeling fordensity estimation in astrophysical contexts.XDGMM is a new implementation of XDGMM that

extends existing XD algorithms and has several new ca-pabilities that are not present in any previously existingXDGMM implementation. It allows the user to choosebetween either the AstroML (Vanderplas et al. 2012;Ivezic et al. 2015) or the Extreme-Deconvolutioncode of Bovy et al. (2011) for performing XDGMM fitsto data, and uses the AstroML interface for fitting andsampling so that existing code that uses AstroML doesnot need to be modified. It extends the scikit-learnBaseEstimator class so that cross-validation methodswill work, and also has a function for computing theBayesian Information Criterion of a model given a certaindataset, in order to allow the user to test different modelparameters. Finally, and most crucially, XDGMM mod-els can be conditioned on a given subset of data, and theconditioned model can then be used to sample the re-maining parameters. This allows our XDGMM classto function as a prediction tool, which will have a widevariety of astronomical applications. XDGMM is eas-ily extendible to include additional implementations ofXDGMM methods or even different types of fitting so-lutions altogether, such as a Dirichlet process GMM.As long as the basic distribution remains a multivariateGaussian, our machine learning and conditioning algo-rithms should still function as intended.empiriciSN is an example use of XDGMM as a pre-

diction tool and is designed to predict realistic supernovaparameters for a given set of host galaxy parameters. Wehave built an XDGMM model based on 4 Type Ia super-nova parameters (The SALT2 x0, x1, and color parame-ters and the location of the supernova in the host galaxy)and 16 host galaxy parameters (redshift, ugriz colors,sersic index, and ugriz local surface brightness at thelocation of the SN) that is trained on a dataset compris-

ing 159 supernovae from SNLS and 1273 supernovae fromSDSS. Given the redshift, ugriz magnitudes, and surfacebrightness profiles for a galaxy, empiriciSN can select alocation of a supernova relative to the effective radius ofthe galaxy, compute the local surface brightness in all 5ugriz filters, and sample realistic SALT2 parameters forthe supernova given the host properties using this defaultmodel. The user can also train a new model based on anew dataset, if the default dataset is not desired, or tochange the parameters used in the model. This makes itcapable of performing similar predictions for other typesof supernovae, or performing simpler, catalog level sim-ulations, leaving out the SN position and local surfacebrightness information. empiriciSN was primarily builtto be used for planting realistic supernovae in simulatedsurvey data, and is already being implemented for thispurpose to model LSST supernovae. In the near futurewe also intend to combine this tool with realistic largearea galaxy mock catalogs, with potential applicationsfor various current and future surveys including DES,DESI, and LSST.

Both XDGMM and empiriciSN are open sourceprojects. We welcome further contributions and collab-oration from the community.

ACKNOWLEDGMENTS

We thank Rahul Biswas and Bob Nichol for useful dis-cussion and feedback, and the three referees (domain re-viewer, statistics editor and data editor) for their positiveand constructive feedback, which led to improvements toboth the paper and the code. TW-SH was supported bythe DOE Computational Science Graduate Fellowship,grant number DE-FG02-97ER25308. PJM and RHW ac-knowledge support from the U.S. Department of Energyunder contract number DE-AC02-76SF00515.

Funding for SDSS-III has been provided by the AlfredP. Sloan Foundation, the Participating Institutions, theNational Science Foundation, and the U.S. Departmentof Energy Office of Science. The SDSS-III web site ishttp://www.sdss3.org/.

REFERENCES

Alam, S., Albareti, F. D., Allende Prieto, C., et al. 2015, TheAstrophysical Journal Supplement Series, 219, 12

Astier, P., Guy, J., Regnault, N., et al. 2006, Astronomy &Astrophysics, 447, 31

Barbary, K. 2014, sncosmo, v0.4.2, , , doi:10.5281/zenodo.11938.https://doi.org/10.5281/zenodo.11938

Betoule, M., Kessler, R., Guy, J., et al. 2014, Astronomy &Astrophysics, 568, A22

Bishop, C. M. 2006, Pattern Recognition and Machine LearningBlanton, M. R., & Roweis, S. 2007, AJ, 133, 734Bovy, J., & Hogg, D. W. 2010, The Astrophysical Journal, 717,

617Bovy, J., Hogg, D. W., & Roweis, S. T. 2009, The Astrophysical

Journal, 700, 1794—. 2011, Annals of Applied Statistics, 5, 1657Bovy, J., Myers, A. D., Hennawi, J. F., et al. 2012, The

Astrophysical Journal, 749, 41Childress, M., Aldering, G., Antilogus, P., et al. 2013, The

Astrophysical Journal, 770, 108Connolly, A. J., Angeli, G. Z., Chandrasekharan, S., et al. 2014,

in Proc. SPIE, Vol. 9150, Modeling, Systems Engineering, andProject Management for Astronomy VI, 915014

Galbany, L., Stanishev, V., Mourao, A. M., et al. 2014,Astronomy & Astrophysics, 572, A38

Graur, O., Bianco, F. B., Huang, S., et al. 2016a, ArXiv e-prints,arXiv:1609.02921

Graur, O., Bianco, F. B., Modjaz, M., et al. 2016b, ArXive-prints, arXiv:1609.02923

Graur, O., Rodney, S. A., Maoz, D., et al. 2014, TheAstrophysical Journal, 783, 28

Guy, J., Astier, P., Baumont, S., et al. 2007, Astronomy &Astrophysics, 466, 11

Hogg, D. W., Blanton, M. R., Roweis, S. T., & Johnston, K. V.2005, The Astrophysical Journal, 629, 268

Holoien, T. W.-S., Marhsall, P. J., & Wechsler, R. H. 2016a,XDGMM, v1.0, , , doi:10.5281/zenodo.163858.https://doi.org/10.5281/zenodo.163858

—. 2016b, empiriciSN, v1.0, , , doi:10.5281/zenodo.163859.https://doi.org/10.5281/zenodo.163859

Ivezic, Z., Connelly, A. J., VanderPlas, J. T., & Gray, A. 2014,Statistics, Data Mining, and Machine Learning in Astronomy

Ivezic, Z., Connolly, A. J., & Vanderplas, J. 2015, in AmericanAstronomical Society Meeting Abstracts, Vol. 225, AmericanAstronomical Society Meeting Abstracts, 336.48

Ivezic, Z., Smith, J. A., Miknaitis, G., et al. 2007, AJ, 134, 973Ivezic, Z., Tyson, J. A., Abel, B., et al. 2008, ArXiv e-prints,

arXiv:0805.2366Koposov, S. E., Belokurov, V., & Wyn Evans, N. 2013, The

Astrophysical Journal, 766, 79Melinder, J., Mattila, S., Ostlin, G., Mencıa Trinchant, L., &

Fransson, C. 2008, Astronomy & Astrophysics, 490, 419Modjaz, M., Kewley, L., Kirshner, R. P., et al. 2008, The

Astronomical Journal, 135, 1136Pedregosa, F., Varoquaux, G., Gramfort, A., et al. 2011, Journal

of Machine Learning Research, 12, 2825

11

Rasmussen, C. E., & Williams, C. K. I. 2006, Gaussian Processesfor Machine Learning

Sako, M., Bassett, B., Becker, A. C., et al. 2014, ArXiv e-prints,arXiv:1401.3317

Schwarz, G. 1978, The Annals of Statistics, 6, 461Skuljan, J., Hearnshaw, J. B., & Cottrell, P. L. 1999, Monthly

Notices of the Royal Astronomical Society, 308, 731Sullivan, M., Conley, A., Howell, D. A., et al. 2010, Monthly

Notices of the Royal Astronomical Society, 406, 782

Sullivan, M., Guy, J., Conley, A., et al. 2011, The AstrophysicalJournal, 737, 102

Vanderplas, J., Connolly, A., Ivezic, Z., & Gray, A. 2012, inConference on Intelligent Data Understanding (CIDU), 47–54

York, D. G., Adelman, J., Anderson, Jr., J. E., et al. 2000, TheAstronomical Journal, 120, 1579