lsst.meas.algorithms.objectSizeStarSelector Namespace Reference

Classes
class	EventHandler
class	ObjectSizeStarSelectorConfig
class	ObjectSizeStarSelectorTask

Functions
	_assignClusters (yvec, centers)
	_kcenters (yvec, nCluster, useMedian=False, widthStdAllowed=0.15)
	_improveCluster (yvec, centers, clusterId, nsigma=2.0, nIteration=10, clusterNum=0, widthStdAllowed=0.15)
	plot (mag, width, centers, clusterId, marker="o", markersize=2, markeredgewidth=0, ltype='-', magType="model", clear=True)

Variables
	_LOG = getLogger(__name__)

Function Documentation

_assignClusters()

lsst.meas.algorithms.objectSizeStarSelector._assignClusters ( yvec, centers )

protected

Return a vector of centerIds based on their distance to the centers.

Definition at line 167 of file objectSizeStarSelector.py.

def _assignClusters(yvec, centers):
    """Return a vector of centerIds based on their distance to the centers.
    """
    assert len(centers) > 0
 
    minDist = numpy.nan*numpy.ones_like(yvec)
    clusterId = numpy.empty_like(yvec)
    clusterId.dtype = int               # zeros_like(..., dtype=int) isn't in numpy 1.5
    dbl = _LOG.getChild("_assignClusters")
    dbl.setLevel(dbl.INFO)
 
    # Make sure we are logging aall numpy warnings...
    oldSettings = numpy.seterr(all="warn")
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        for i, mean in enumerate(centers):
            dist = abs(yvec - mean)
            if i == 0:
                update = dist == dist       # True for all points
            else:
                update = dist < minDist
                if w:  # Only do if w is not empty i.e. contains a warning message
                    dbl.trace(str(w[-1]))
 
            minDist[update] = dist[update]
            clusterId[update] = i
    numpy.seterr(**oldSettings)
 
    return clusterId
 
 

_improveCluster()

lsst.meas.algorithms.objectSizeStarSelector._improveCluster ( yvec, centers, clusterId, nsigma = 2.0, nIteration = 10, clusterNum = 0, widthStdAllowed = 0.15 )

protected

Improve our estimate of one of the clusters (clusterNum) by sigma-clipping around its median.

Definition at line 240 of file objectSizeStarSelector.py.

def _improveCluster(yvec, centers, clusterId, nsigma=2.0, nIteration=10, clusterNum=0, widthStdAllowed=0.15):
    """Improve our estimate of one of the clusters (clusterNum) by sigma-clipping around its median.
    """
 
    nMember = sum(clusterId == clusterNum)
    if nMember < 5:  # can't compute meaningful interquartile range, so no chance of improvement
        return clusterId
    for iter in range(nIteration):
        old_nMember = nMember
 
        inCluster0 = clusterId == clusterNum
        yv = yvec[inCluster0]
 
        centers[clusterNum] = numpy.median(yv)
        stdev = numpy.std(yv)
 
        syv = sorted(yv)
        stdev_iqr = 0.741*(syv[int(0.75*nMember)] - syv[int(0.25*nMember)])
        median = syv[int(0.5*nMember)]
 
        sd = stdev if stdev < stdev_iqr else stdev_iqr
 
        if False:
            print("sigma(iqr) = %.3f, sigma = %.3f" % (stdev_iqr, numpy.std(yv)))
        newCluster0 = abs(yvec - centers[clusterNum]) < nsigma*sd
        clusterId[numpy.logical_and(inCluster0, newCluster0)] = clusterNum
        clusterId[numpy.logical_and(inCluster0, numpy.logical_not(newCluster0))] = -1
 
        nMember = sum(clusterId == clusterNum)
        # 'sd < widthStdAllowed * median' prevents too much rejections
        if nMember == old_nMember or sd < widthStdAllowed * median:
            break
 
    return clusterId
 
 

_kcenters()

lsst.meas.algorithms.objectSizeStarSelector._kcenters ( yvec, nCluster, useMedian = False, widthStdAllowed = 0.15 )

protected

A classic k-means algorithm, clustering yvec into nCluster clusters

Return the set of centres, and the cluster ID for each of the points

If useMedian is true, use the median of the cluster as its centre, rather than
the traditional mean

Serge Monkewitz points out that there other (maybe smarter) ways of seeding the means:
   "e.g. why not use the Forgy or random partition initialization methods"
however, the approach adopted here seems to work well for the particular sorts of things
we're clustering in this application

Definition at line 198 of file objectSizeStarSelector.py.

def _kcenters(yvec, nCluster, useMedian=False, widthStdAllowed=0.15):
    """A classic k-means algorithm, clustering yvec into nCluster clusters
 
    Return the set of centres, and the cluster ID for each of the points
 
    If useMedian is true, use the median of the cluster as its centre, rather than
    the traditional mean
 
    Serge Monkewitz points out that there other (maybe smarter) ways of seeding the means:
       "e.g. why not use the Forgy or random partition initialization methods"
    however, the approach adopted here seems to work well for the particular sorts of things
    we're clustering in this application
    """
 
    assert nCluster > 0
 
    mean0 = sorted(yvec)[len(yvec)//10]  # guess
    delta = mean0 * widthStdAllowed * 2.0
    centers = mean0 + delta * numpy.arange(nCluster)
 
    func = numpy.median if useMedian else numpy.mean
 
    clusterId = numpy.zeros_like(yvec) - 1            # which cluster the points are assigned to
    clusterId.dtype = int                             # zeros_like(..., dtype=int) isn't in numpy 1.5
    while True:
        oclusterId = clusterId
        clusterId = _assignClusters(yvec, centers)
 
        if numpy.all(clusterId == oclusterId):
            break
 
        for i in range(nCluster):
            # Only compute func if some points are available; otherwise, default to NaN.
            pointsInCluster = (clusterId == i)
            if numpy.any(pointsInCluster):
                centers[i] = func(yvec[pointsInCluster])
            else:
                centers[i] = numpy.nan
 
    return centers, clusterId
 
 

plot()

lsst.meas.algorithms.objectSizeStarSelector.plot	(		mag,
			width,
			centers,
			clusterId,
			marker = "o",
			markersize = 2,
			markeredgewidth = 0,
			ltype = '-',
			magType = "model",
			clear = True )

Definition at line 276 of file objectSizeStarSelector.py.

         magType="model", clear=True):
 
    log = _LOG.getChild("plot")
    try:
        import matplotlib.pyplot as plt
    except ImportError as e:
        log.warning("Unable to import matplotlib: %s", e)
        return
 
    try:
        fig
    except NameError:
        fig = plt.figure()
    else:
        if clear:
            fig.clf()
 
    axes = fig.add_axes((0.1, 0.1, 0.85, 0.80))
 
    xmin = sorted(mag)[int(0.05*len(mag))]
    xmax = sorted(mag)[int(0.95*len(mag))]
 
    axes.set_xlim(-17.5, -13)
    axes.set_xlim(xmin - 0.1*(xmax - xmin), xmax + 0.1*(xmax - xmin))
    axes.set_ylim(0, 10)
 
    colors = ["r", "g", "b", "c", "m", "k", ]
    for k, mean in enumerate(centers):
        if k == 0:
            axes.plot(axes.get_xlim(), (mean, mean,), "k%s" % ltype)
 
        li = (clusterId == k)
        axes.plot(mag[li], width[li], marker, markersize=markersize, markeredgewidth=markeredgewidth,
                  color=colors[k % len(colors)])
 
    li = (clusterId == -1)
    axes.plot(mag[li], width[li], marker, markersize=markersize, markeredgewidth=markeredgewidth,
              color='k')
 
    if clear:
        axes.set_xlabel("Instrumental %s mag" % magType)
        axes.set_ylabel(r"$\sqrt{(I_{xx} + I_{yy})/2}$")
 
    return fig
 
 
@pexConfig.registerConfigurable("objectSize", sourceSelectorRegistry)

Variable Documentation

_LOG

lsst.meas.algorithms.objectSizeStarSelector._LOG = getLogger(__name__)

protected

Definition at line 41 of file objectSizeStarSelector.py.