lsst.meas.modelfit  15.0-3-g150fc43+8
modelFitAdapters.py
Go to the documentation of this file.
1 from builtins import zip
2 from builtins import object
3 #
4 # LSST Data Management System
5 # Copyright 2008-2013 LSST Corporation.
6 #
7 # This product includes software developed by the
8 # LSST Project (http://www.lsst.org/).
9 #
10 # This program is free software: you can redistribute it and/or modify
11 # it under the terms of the GNU General Public License as published by
12 # the Free Software Foundation, either version 3 of the License, or
13 # (at your option) any later version.
14 #
15 # This program is distributed in the hope that it will be useful,
16 # but WITHOUT ANY WARRANTY; without even the implied warranty of
17 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 # GNU General Public License for more details.
19 #
20 # You should have received a copy of the LSST License Statement and
21 # the GNU General Public License along with this program. If not,
22 # see <http://www.lsstcorp.org/LegalNotices/>.
23 #
24 
25 import numpy
26 from .densityPlot import mergeDefaults
27 from .. import modelfitLib
28 
29 __all__ = ("SamplingDataAdapter", "OptimizerTrackLayer", "OptimizerDataAdapter",)
30 
31 
32 class ModelFitDataAdapter(object):
33 
34  def __init__(self, record):
35  self.record = record
36  self.pdf = record.getPdf()
37  self.dimensions = list(record.getInterpreter().getParameterNames())
38 
39  def eval1d(self, dim, x):
40  i = self.dimensions.index(dim)
41  z = numpy.zeros(x.shape, dtype=float)
42  if i >= self.pdf.getDimension():
43  return None
44  projection = self.pdf.project(i)
45  projection.evaluate(x.reshape(x.shape + (1,)), z)
46  return z
47 
48  def eval2d(self, xDim, yDim, x, y):
49  i = self.dimensions.index(yDim)
50  j = self.dimensions.index(xDim)
51  z = numpy.zeros(x.size, dtype=float)
52  if i >= self.pdf.getDimension() or j >= self.pdf.getDimension():
53  return None
54  projection = self.pdf.project(j, i)
55  xy = numpy.zeros((x.size, 2), dtype=float)
56  xy[:, 0] = x.flatten()
57  xy[:, 1] = y.flatten()
58  projection.evaluate(xy, z)
59  return z.reshape(x.shape)
60 
61 
63 
64  def __init__(self, record):
65  ModelFitDataAdapter.__init__(self, record)
66  self.samples = record.getSamples().copy(deep=True)
67  self.values = self.samples["parameters"]
68  self.weights = self.samples["weight"]
69  self.setRangesFromQuantiles(0.001, 0.999)
70  assert self.values.shape[1] == len(self.dimensions)
71 
72  def setRangesFromQuantiles(self, lower, upper):
73  fractions = numpy.array([lower, upper], dtype=float)
74  ranges = self.record.getInterpreter().computeParameterQuantiles(self.record, fractions)
75  self.lower = {dim: ranges[i, 0] for i, dim in enumerate(self.dimensions)}
76  self.upper = {dim: ranges[i, 1] for i, dim in enumerate(self.dimensions)}
77 
78 
79 class OptimizerTrackLayer(object):
80 
81  defaults = dict(
82  accepted=dict(
83  marker='.', linestyle='-', color='c',
84  markevery=(1, 1), # (start, stride): don't put a marker on the first point
85  ),
86  rejected=dict(
87  marker='.', linestyle='-', color='k', alpha=0.5,
88  markevery=3, # marker at every third point, so we only mark the rejected points
89  ),
90  )
91 
92  def __init__(self, tag, accepted=None, rejected=None):
93  self.tag = tag
94  self.accepted = mergeDefaults(accepted, self.defaults['accepted'])
95  self.rejected = mergeDefaults(rejected, self.defaults['rejected'])
96 
97  def plotX(self, axes, data, dim):
98  pass
99 
100  def plotY(self, axes, data, dim):
101  pass
102 
103  def plotXY(self, axes, data, xDim, yDim):
104  i = data.dimensions.index(yDim)
105  j = data.dimensions.index(xDim)
106  artists = []
107  artists.extend(axes.plot(data.rejected[:, j], data.rejected[:, i], **self.rejected))
108  artists.extend(axes.plot(data.accepted[:, j], data.accepted[:, i], **self.accepted))
109  return artists
110 
111 
113 
114  def __init__(self, record):
115  ModelFitDataAdapter.__init__(self, record)
116  self.samples = record.getSamples().copy(deep=True)
117  self.parameters = self.samples["parameters"]
118  self.state = self.samples["state"]
119  # The first point is neither accepted nor rejected, so we test on rejected and !rejected so
120  # as to include the first point with the accepted points
121  mask = (self.state & modelfitLib.Optimizer.STATUS_STEP_REJECTED).astype(bool)
122  self.accepted = self.parameters[numpy.logical_not(mask)]
123  # For each rejected point, we have three path points: the rejected point, the last accepted point,
124  # and a NaN to tell matplotlib not to connect to the next one.
125  # Note that the defaults for OptimizerTrackLayer use markevery=3 to only put markers on
126  # the rejected points
127  rejected = []
128  current = self.parameters[0]
129  nans = numpy.array([numpy.nan] * self.parameters.shape[1], dtype=float)
130  for parameters, isRejected in zip(self.parameters, mask):
131  if isRejected:
132  rejected.extend([parameters, current, nans])
133  else:
134  current = parameters
135  self.rejected = numpy.array(rejected)
136  self.lower = {}
137  self.upper = {}
138  for i, dim in enumerate(self.dimensions):
139  projected = self.pdf[0].project(i)
140  mu = projected.getMu()
141  sigma = projected.getSigma()**0.5
142  self.lower[dim] = min(self.accepted[:, i].min(), mu - 3*sigma)
143  self.upper[dim] = max(self.accepted[:, i].max(), mu + 3*sigma)
144  # Now we setup some special points for a CrossPointsLayer
145  self.points = numpy.zeros((2, self.parameters.shape[1]), dtype=float)
146  record.getInterpreter().packParameters(
147  self.record['initial.nonlinear'], self.record['initial.amplitudes'],
148  self.points[0, :]
149  )
150  record.getInterpreter().packParameters(
151  self.record['fit.nonlinear'], self.record['fit.amplitudes'],
152  self.points[1, :]
153  )