pysersic 0.1.1__tar.gz

pysersic-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 pysersic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pysersic-0.1.1/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.1
+Name: pysersic
+Version: 0.1.1
+Summary: A Tool for fitting sersic profiles in python
+Download-URL: https://github.com/pysersic/pysersic/archive/refs/tags/v0.1.1.tar.gz
+Author: Imad Pasha & Tim Miller
+Author-email: imad.pasha@yale.edu
+License-File: LICENSE

pysersic-0.1.1/README.md

@@ -0,0 +1,68 @@
+![pysersic logo featuring a spiral s-galaxy as the S](misc/pysersic.png)
+ 
+![License](https://img.shields.io/badge/license-MIT-blue)
+[![Documentation Status](https://readthedocs.org/projects/pysersic/badge/?version=latest)](https://pysersic.readthedocs.io/en/latest/?badge=latest)
+![tests](https://github.com/pysersic/pysersic/actions/workflows/pytest.yml/badge.svg)
+
+pysersic is a code for fitting sersic profiles to galaxy images using Bayesian Inference. It is written in python using [jax](https://github.com/google/jax) with inference performed using [numpyro](https://github.com/pyro-ppl/numpyro)
+
+## Installation
+
+First you should install jax. The easiest way to do this is to use ``` pip install 'jax[cpu]' ```, however if you are on windows or planning on running it on a GPU, the installation can be a little more complicated, please see the guide [here](https://github.com/google/jax#installation). The other package dependencies for ```pysersic``` are:
+- arviz
+- asdf
+- astropy
+- corner
+- jax
+- matplotlib
+- numpy
+- numpyro
+- pandas
+- photutils
+- scipy
+- tqdm
+
+Next you can install pysersic! We will be uploading it to pypi very soon, but for now you should install it locally by cloning the github repo.
+
+```
+git clone https://github.com/pysersic/pysersic.git
+cd pysersic
+pip install -e .
+```
+
+## Basic usage
+
+All you need to run pysersic is a cutout of you galaxy of interest, and cutout of the error map, pixelized version of the PSF, and optionally a mask specifying bad pixels or nearby sources. The most basic setup is shown below for many many more details and in depth examples please see the [documentation](https://pysersic.readthedocs.io/en/latest/). First we set up a prior.
+
+```
+from pysersic.priors import SourceProperties
+
+props = SourceProperties(img_cutout,mask=mask) # Optional mask
+prior = props.generate_prior('sersic', # Other profiles inclues 'exp', 'dev' and 'pointsource'
+                          sky_type='none') # Can also use 'flat' or 'tilted-plane' to simultaneously fit a background
+```
+Then we initialize the fitting object:
+
+```
+from pysersic import FitSingle
+from pysersic.loss import gaussian_loss
+
+fitter = FitSingle(data=img_cutout, # Cutout of galaxy 
+                  rms=sig_cutout, # Cutout of pixel errors
+                  psf=psf, #Point spread function
+                  prior=prior, # Prior that we initialized above
+                  mask=mask, #Optional mask
+                  loss_func=gaussian_loss) # Can specify loss function! See loss.py for many options or write your own!
+```
+
+Now we can fit!
+
+```
+map_dict = fitter.find_MAP() # Find the 'best-fit' parameters as the maximum-a-posteriori. Returns a dictionary containing the MAP parameters and model image
+
+svi_res = fitter.estimate_posterior('svi-flow') #Train a normalizing flow to estimate the posterior, retruns a PysersicResults object containing the posterior and other helper methods
+nuts_res = fitter.sample() #Sample the posterior using the No U-turn sampler (NUTS), retruns a PysersicResults object
+```
+
+## Citation
+We will be submitting a paper soon describing pysersic for now please reference this webpage and cite 'Pasha & Miller in prep.' 

pysersic-0.1.1/pysersic/__init__.py

@@ -0,0 +1,4 @@
+from .priors import (PySersicMultiPrior, PySersicSourcePrior, SourceProperties,autoprior)
+from .pysersic import FitMulti, FitSingle
+from .rendering import FourierRenderer, HybridRenderer, PixelRenderer
+from .results import PySersicResults, parse_multi_results

pysersic-0.1.1/pysersic/galfit.py

@@ -0,0 +1,190 @@
+from typing import Iterable, Union
+
+import jax.numpy as jnp
+from astropy.io import fits
+
+from pysersic import FitMulti, FitSingle, priors
+
+from .loss import gaussian_loss
+
+
+def search_start(list_of_strings: Iterable, to_match: str)-> list:
+    """Search a list of strings and match those which start with to_match
+
+    Parameters
+    ----------
+    list_of_strings : Iterable
+    to_match : str
+        pattern to match
+
+    Returns
+    -------
+    list
+        List of results contianing the index and full string
+    """
+    result = []
+    for j,string in enumerate(list_of_strings):
+        if string.split()[0] == to_match:
+            result.append([j,string])
+    return result
+
+def load_fits_from_galfit_line(line:str) -> jnp.array:
+    """Load fits file from galfit config line
+
+    Parameters
+    ----------
+    line : str
+
+    Returns
+    -------
+    jnp.array
+        Image in first HDU
+    """
+    fname = line.split()[1]
+    return jnp.array( fits.getdata(fname) )
+
+def match_line_and_load_galfit(list_of_strings: Iterable, to_match: str, assert_message: str = "")-> jnp.array:
+    """Combine the above two functions to search and load fits files from a galfit config
+
+    Parameters
+    ----------
+    list_of_strings : Iterable
+    to_match : str
+    assert_message : str, optional
+        Message to raise if line file is not present
+
+    Returns
+    -------
+    jnp.array
+        _description_
+
+    Raises
+    ------
+    UserWarning
+        _description_
+    """
+    matches = search_start(list_of_strings, to_match)
+    line = matches[0][1]
+    if line.split()[1] == 'none':
+        raise UserWarning(assert_message)
+    return load_fits_from_galfit_line(line)
+
+def generate_fitter_from_galfit_config(config_loc: str, loss: callable = gaussian_loss ) -> Union[FitSingle,FitMulti]:
+    """Function to generate a Fitter instance from a galfit config file. This function is only meant to be a starting place to easily try PySersic on the many galfit config files we know you all have lying around. As such this does not follow all of the rules and constraints the galfit takes into account. For more fine grained control we recommend initializing a pysersic Fitter instance yourself, please see the `examples/` folder or the documentation for some help with this. 
+
+    Parameters
+    ----------
+    config_loc : str
+        Config file locations
+    loss : callable, optional
+        Loss function to use, see loss.py for more details, by default gaussian_loss
+
+    Returns
+    -------
+    Union[FitSingle,FitMulti]
+        Fitter based on config file. If there is only one source then returns a FitSingle object, otherwise returns a fit_multi
+    """
+    
+    with open(config_loc,'r') as f:
+        lines = []
+        for line in f.readlines():
+            if line[0] == '#' or line[:1] == '\n' or line[0] == '=':
+                continue
+            else:
+                lines.append(line)
+    
+    im = match_line_and_load_galfit(lines, 'A)', assert_message='Missing science image, labelled D) in config file')
+    rms = match_line_and_load_galfit(lines, 'C)', assert_message='Missing rms image, labelled C) in config file')
+    psf = match_line_and_load_galfit(lines,'D)', assert_message='Missing psf image, labelled D) in config file')
+
+    try:
+        mask = match_line_and_load_galfit(lines,'F)')
+    except:
+        mask = jnp.zeros_like(im)
+    zpt = float ( search_start(lines, 'J)')[0][1].split()[1] )
+    source_list = search_start(lines, '0)')
+    
+    sky_type = 'none'
+    source_dict = {}
+    source_dict['type'] = []
+    source_dict['flux'] = []
+    source_dict['r'] = []
+    source_dict['x'] = []
+    source_dict['y'] = []
+
+    for i,source in enumerate(source_list):
+        ind = source[0]
+        
+        if i == len(source_list) -1:
+            next_ind = None
+        else:
+            next_ind = source_list[i+1][0]
+        source_string_list = lines[ind:next_ind]
+
+        source_type = source[1].split()[1]
+        if source_type == 'sersic' or 'dev' in source_type or 'exp' in source_type or source_type == 'psf':
+            if 'dev' in source_type:
+                source_type = 'dev'
+            elif 'exp' in source_type:
+                source_type = 'exp'
+            elif source_type == 'psf':
+                source_type = 'pointsource'
+
+            mag = float( search_start(source_string_list, '3)')[0][1].split()[1] )
+            flux = 10.**( (mag - zpt)/-2.5)
+            
+            x,y = search_start(source_string_list, '1)')[0][1].split()[1:3]
+            x = float(x)
+            y = float(y)
+    
+            source_dict['type'].append(source_type)
+            source_dict['x'].append(x)
+            source_dict['y'].append(y)
+            source_dict['flux'].append(flux)
+
+            if source_type != 'pointsource':
+                r = float( search_start(source_string_list, '4)')[0][1].split()[1] )
+            else:
+                r = -99
+            source_dict['r'].append(r)
+
+        elif source_type == 'sky':
+            print('sky')
+            fit_back = search_start(source_string_list, '1)')[0][1].split()[2]
+            back_init = float(search_start(source_string_list, '1)')[0][1].split()[1])
+            fit_x_sl = search_start(source_string_list,'2)')[0][1].split()[2]
+            fit_y_sl = search_start(source_string_list,'2)')[0][1].split()[2]
+            if fit_y_sl == '1' or fit_x_sl == '1':
+                sky_type = 'tilted-plane'
+            elif fit_back == '1':
+                sky_type = 'flat'
+            else:
+                sky_type = 'none'
+        else:
+            print (f"Skipping source {i}, profile type of {source_type} currently not supported")
+
+    N_sources = len(source_dict['type'])
+    types = source_dict['type']
+    print(f"Found {N_sources} source(s) to fit of type(s) {types}")
+
+    if len(source_dict['type']) == 1:
+        prof_type = source_dict['type'][0]
+        sp = priors.SourceProperties(im, mask = mask)
+        sp.set_sky_guess(sky_guess = 0, sky_guess_err = 1)
+        sp.set_flux_guess(flux_guess= source_dict['flux'][0])
+        sp.set_position_guess( [source_dict['x'][0],source_dict['y'][0] ])
+
+        if prof_type != 'psf':
+            sp.set_r_eff_guess(r_eff_guess=source_dict['r'][0])
+        prior = sp.generate_prior(prof_type, sky_type = sky_type)
+        ps_fitter = FitSingle(data = im, rms = rms, psf = psf, prior = prior, loss_func = loss )
+
+    elif len(source_dict['type']) > 1:
+        multi_prior = priors.PySersicMultiPrior(catalog=source_dict, sky_type = sky_type,sky_guess=back_init, sky_guess_err = back_init + 1e-5)
+        ps_fitter = FitMulti(data = im, rms = rms, psf = psf, prior = multi_prior, loss_func = loss)
+
+    else:
+        print ('Did not find any viable sources in galfit config')
+        ps_fitter = 0
+    
+    return ps_fitter

pysersic-0.1.1/pysersic/loss.py

@@ -0,0 +1,328 @@
+import jax.numpy as jnp
+from numpyro import distributions as dist, sample, handlers, factor,deterministic
+from typing import Optional
+
+def gaussian_loss(mod: jnp.array,
+                data: jnp.array,
+                rms: jnp.array,
+                mask: jnp.array)-> float:
+    """Basic Gaussian loss function using given uncertainties
+
+    Parameters
+    ----------
+    mod : jnp.array
+        Model image
+    data : jnp.array
+        data to be fit
+    rms : jnp.array
+        per pixel 1-sigma uncertainties
+
+    Returns
+    -------
+    float
+        Sampled loss function
+    """
+
+    with handlers.mask(mask = mask):
+        loss = sample("Loss", dist.Normal(mod, rms), obs=data)
+    return loss
+
+def cash_loss(mod: jnp.array,
+                data: jnp.array,
+                rms: jnp.array,
+                mask: jnp.array)-> float:
+    """
+    Cash statistic based on Poisson statistics derived in Cash (1979) (DOI 10.1086/156922) and advocated for in Erwin (2015) (https://arxiv.org/abs/1408.1097) for use in Sersic fitting. Since the is based on Poisson statistics, scaling of the image will produce different confidence intervals. Additionally, since a logarithm is taken of the model image, negative values associated with different sky models will cause issues.
+
+    Parameters
+    ----------
+    mod : jnp.array
+        Model image
+    data : jnp.array
+        data to be fit
+    rms : jnp.array
+        per pixel 1-sigma uncertainties
+
+    Returns
+    -------
+    float
+        Sampled loss function
+    """
+    
+    with handlers.mask(mask = mask):
+        loss = factor('cash_loss', -1*(mod - data*jnp.log(mod)))
+    return loss
+
+def gaussian_loss_w_frac(mod: jnp.array,
+                data: jnp.array,
+                rms: jnp.array,
+                mask: jnp.array)-> float:
+    """Gaussian loss with and additional fractional increase to all uncertainties such that,
+
+    $$ \sigma_{new,i} = (1 + f) * \sigma_{old,i} $$
+
+    f is a free parameter varied between -0.5 and 2
+
+    Parameters
+    ----------
+    mod : jnp.array
+        Model image
+    data : jnp.array
+        data to be fit
+    rms : jnp.array
+        per pixel 1-sigma uncertainties
+
+    Returns
+    -------
+    float
+        Sampled loss function
+    """
+    
+    scatter_frac = sample('frac_scatter_increase', dist.TruncatedNormal(low = -0.5, high = 2) )
+    with handlers.mask(mask = mask):
+        loss =  sample("Loss", dist.Normal(mod, (1+ scatter_frac)*rms), obs=data)    
+    return loss
+
+def gaussian_loss_w_sys(mod: jnp.array,
+                data: jnp.array,
+                rms: jnp.array,
+                mask: jnp.array)-> float:
+    """Gaussian loss with and additional systematic increase such_that
+
+    $$ \sigma_{new,i}^2 = \sigma_{old,i}^2 + \sigma_{sys}^2 $$
+
+    \sigma_{sys} is a free parameter with a Normal prior, with loc = 0 and scale = mean(rms) truncated to ensure > 0
+
+    Parameters
+    ----------
+    mod : jnp.array
+        Model image
+    data : jnp.array
+        data to be fit
+    rms : jnp.array
+        per pixel 1-sigma uncertainties
+
+    Returns
+    -------
+    float
+        Sampled loss function
+    """
+    
+    sys_scatter_base = sample('sys_scatter_base', dist.TruncatedNormal(low = 0, scale = 1 ) )
+    sys_scatter = deterministic('sys_scatter', sys_scatter_base*jnp.mean(rms))
+    with handlers.mask(mask = mask):
+        loss =  sample("Loss", dist.Normal(mod, jnp.sqrt(rms**2 + sys_scatter**2)), obs=data)    
+    return loss
+
+def student_t_loss(mod: jnp.array,
+                data: jnp.array,
+                rms: jnp.array,
+                mask: jnp.array,
+                nu: Optional[int] = 5)-> float:
+    """
+    Student T loss, with a df = 5 by default. This has fatter tails than Gaussian loss (or chi squared) so is more resilient to outliers
+
+    Parameters
+    ----------
+    mod : jnp.array
+        Model image
+    data : jnp.array
+        data to be fit
+    rms : jnp.array
+        per pixel 1-sigma uncertainties
+
+    Returns
+    -------
+    float
+        Sampled loss function
+    """
+    nu = 5.
+    with handlers.mask(mask = mask):
+        loss =  sample("Loss", dist.StudentT(nu,mod,jnp.sqrt((nu-2.)/2.)*rms), obs=data)    
+    return loss
+
+def student_t_loss_free_sys(mod: jnp.array,
+                data: jnp.array,
+                rms: jnp.array,
+                mask: jnp.array,
+                nu: Optional[int] = 5)-> float:
+    """
+    Student T loss, which has fatter tails than Gaussian loss (or chi squared) so is so is more resilient to outliers. In addition, add additional systematic increase such that
+
+    $$ \sigma_{new,i}^2 = \sigma_{old,i}^2 + \sigma_{sys}^2 $$
+
+    \sigma_{sys} is a free parameter with a Normal prior, with loc = 0 and scale = mean(rms) truncated to ensure > 0
+
+
+    Parameters
+    ----------
+    mod : jnp.array
+        Model image
+    data : jnp.array
+        data to be fit
+    rms : jnp.array
+        per pixel 1-sigma uncertainties
+
+    Returns
+    -------
+    float
+        Sampled loss function
+    """
+    sys_scatter_base = sample('sys_scatter_base', dist.TruncatedNormal(low = 0, scale = 1 ) )
+    sys_scatter = deterministic('sys_scatter', sys_scatter_base*jnp.mean(rms))
+    rms_new = jnp.sqrt((nu-2.)/2.)*jnp.sqrt(rms**2 + sys_scatter**2)
+
+    with handlers.mask(mask = mask):
+        loss =  sample("Loss", dist.StudentT(nu, mod, rms_new), obs=data)    
+    return loss
+
+def pseudo_huber_loss(mod: jnp.array,
+                data: jnp.array,
+                rms: jnp.array,
+                mask: jnp.array,
+                delta: Optional[int] = 3
+                )-> float:
+    """
+    Pseudo huber loss function of the form:
+
+    $$ L = \delta^2 * ( \sqrt{1 + (a/\delta)^2} - 1) $$
+
+    where a is the residuals scaled by the rms and delta can be chosen. This loss function is more robust to outliers than the Gaussian loss function as it is meant to transition for L2 to L1 loss at residuals greater than delta. The delta parameter is 3 by default but can be varied.
+
+    Parameters
+    ----------
+    mod : jnp.array
+        Model image
+    data : jnp.array
+        data to be fit
+    rms : jnp.array
+        per pixel 1-sigma uncertainties
+
+    Returns
+    -------
+    float
+        Sampled loss function
+    """
+    
+    with handlers.mask(mask = mask):
+        res = (data-mod)/rms
+        loss = factor('pseudo_huber_loss', -1.*(jnp.sqrt(1 + ( res/delta )**2) - 1) )
+    return loss
+
+def gaussian_mixture(mod: jnp.array,
+                data: jnp.array,
+                rms: jnp.array,
+                mask: jnp.array,
+                c: Optional[float] = 5.
+                )-> float:
+    """
+    Gaussian mixture loss function, with one representing a "contaminating" outlier distribution with standard deviation equal to c*rms where c is 5 by default. The "contaminating fraction" or fraction of outliers is a free parameter with a Uniform prior between 0 and 0.25.
+
+    Parameters
+    ----------
+    Parameters
+    ----------
+    mod : jnp.array
+        Model image
+    data : jnp.array
+        data to be fit
+    rms : jnp.array
+        per pixel 1-sigma uncertainties
+    c : float, optional
+        factor to increase rms for outlier distribution, by default 5
+
+    Returns
+    -------
+    float
+        _description_
+    """
+    contam_frac_base = sample('outlier_frac_base', dist.TruncatedNormal(low = 0, scale = 1., high = 5.) )
+    contam_frac = deterministic('outlier_frac', contam_frac_base*0.05 )
+
+    mixture_dists = dist.Categorical(probs = jnp.array([1-contam_frac, contam_frac]))
+    component_dists = dist.Normal(jnp.stack([mod,mod],axis = -1), jnp.stack([rms,c*rms],axis = -1) )
+
+    with handlers.mask(mask = mask):
+        loss = sample("Loss", dist.MixtureSameFamily(mixture_dists, component_dists), obs=data)
+    return loss
+
+def gaussian_mixture_w_sys(mod: jnp.array,
+                data: jnp.array,
+                rms: jnp.array,
+                mask: jnp.array,
+                c: Optional[float] = 5.
+                )-> float:
+    """
+    Gaussian mixture loss function, with one representing a "contaminating" outlier distribution with standard deviation equal to c*rms where c is 5 by default. The "outlier fraction" or fraction of outliers is a free parameter with a Uniform prior between 0 and 0.25.
+
+    Parameters
+    ----------
+    Parameters
+    ----------
+    mod : jnp.array
+        Model image
+    data : jnp.array
+        data to be fit
+    rms : jnp.array
+        per pixel 1-sigma uncertainties
+    c : float, optional
+        factor to increase rms for outlier distribution, by default 5
+
+    Returns
+    -------
+    float
+        _description_
+    """
+    contam_frac_base = sample('outlier_frac_base', dist.TruncatedNormal(low = 0, scale = 1., high = 5.) )
+    contam_frac = deterministic('outlier_frac', contam_frac_base*0.05 )
+
+    sys_scatter_base = sample('sys_scatter_base', dist.TruncatedNormal(low = 0, scale = 1 ) )
+    sys_scatter = deterministic('sys_scatter', sys_scatter_base*jnp.mean(rms))
+
+    rms_new = jnp.sqrt(rms**2 + sys_scatter**2)
+    mixture_dists = dist.Categorical(probs = jnp.array([1-contam_frac, contam_frac]))
+    component_dists = dist.Normal(jnp.stack([mod,mod],axis = -1), jnp.stack([rms_new,c*rms_new],axis = -1) )
+
+    with handlers.mask(mask = mask):
+        loss = sample("Loss", dist.MixtureSameFamily(mixture_dists, component_dists), obs=data)
+    return loss
+
+def gaussian_mixture_w_frac(mod: jnp.array,
+                data: jnp.array,
+                rms: jnp.array,
+                mask: jnp.array,
+                c: Optional[float] = 5.
+                )-> float:
+    """
+    Gaussian mixture loss function, with one representing a "contaminating" outlier distribution with standard deviation equal to c*rms where c is 5 by default. The "outlier fraction" or fraction of outliers is a free parameter with a Uniform prior between 0 and 0.25.
+
+    Parameters
+    ----------
+    Parameters
+    ----------
+    mod : jnp.array
+        Model image
+    data : jnp.array
+        data to be fit
+    rms : jnp.array
+        per pixel 1-sigma uncertainties
+    c : float, optional
+        factor to increase rms for outlier distribution, by default 5
+
+    Returns
+    -------
+    float
+        _description_
+    """
+    contam_frac_base = sample('outlier_frac_base', dist.TruncatedNormal(low = 0, scale = 1., high = 5.) )
+    contam_frac = deterministic('outlier_frac', contam_frac_base*0.05 )
+
+    sig_frac = sample('sig_frac', dist.TruncatedNormal(low = -2./3., high = 2., loc = 0, scale = 0.5 ) )
+
+    rms_new = (1+sig_frac)*rms
+    mixture_dists = dist.Categorical(probs = jnp.array([1-contam_frac, contam_frac]))
+    component_dists = dist.Normal(jnp.stack([mod,mod],axis = -1), jnp.stack([rms_new,c*rms],axis = -1) )
+
+    with handlers.mask(mask = mask):
+        loss = sample("Loss", dist.MixtureSameFamily(mixture_dists, component_dists), obs=data)
+    return loss