BaseFitter

 
BaseFitter = class BaseFitter(builtins.object)
    BaseFitter(xdata, model, map=False, keep=None, fixedScale=None)
 
Base class for all Fitters.
 
The Fitter class is to be used in conjunction with *Model classes.
 
The Fitter class and its descendants fit data to a model. Fitter itself
is the variant for linear models, ie. models linear in its parameters.
 
For both linear and nonlinear models it holds that once the optimal
estimate of the parameters is found, a variety of calculations is exactly
the same: standard deviations, noise scale, evidence and model errors.
They all derive more or less from the inverse Hessian matrix ( aka the
covariance matrix ). All these calculations are in this Fitter class.
Other Fitter classes relegate their calculation in these issues to this one.
 
Examples
--------
# It is not possible to use this class. User Fitter, CurveFitter etc. in stead
 
Note Also
---------
1. The calculation of the evidence is an Gaussian approximation which is
   only exact for linear models with a fixed scale.
2. Attributes labelled as read only should not be set by a user.
 
Author: Do Kester
 
Attributes
----------
model : Model
    the model to be fitted
xdata : array_like
    independent variable(s)
nxdata : int (read only)
    length of the xdata vector(s)
ndim : int (read only)
    number of xdata vectors
weights : array_like
    the weights on the data from the last fit
imageAssistant : ImageAssistant
    to convert images to pixels indices, needed for a fit
keep : dict of {int : float}
    to keep the indexed (int) parameter at the provided value (float)
fitIndex : list of int (or None)
    list of parameter indices to fit (None is all)
npfit : int
    the number of parameters fitted in the last fit.
fixedScale : float
    the fixed noise scale.
    The presence of `fixedScale` has consequences for the definitions of `chisq`,
    `(co)variance`, `stdevs` and `evidence`
 
minimumScale : float
    introduce a minimum value for the noise scale
design : matrix (read only)
    the design matrix (partial of model to parameters)
    returns self.getDesign()
 
Attributes (available after a call to fit())
----------
yfit : array_like
    The model result at the optimal value for the parameters.
    If map is true, a map is returned.
chisq : float (read only)
    chisquared of the fit
parameters : ndarray
    parameters fitted to the model
    returns self.model.parameters
stdevs, standardDeviations : array_like (read only)
    the standard deviations on the parameters
    returns self.getStandardDeviations()
hessian : matrix (read only)
    the hessian matrix
covariance : matrix (read only)
    the covariance matrix
    returns self.getCovarianceMatrix()
scale : float
    the noise scale
    returns self.getScale()
sumwgt : float (read only)
    sum of the weights
logZ : float (read only)
    the e-log of the evidence
    returns self.getLogZ()
evidence : float (read only)
    the 10log of the evidence (logZ / log(10))
    returns self.getEvidence()
 
Attributes (available after a call to getLogZ() or getEvidence())
----------
logOccam : float (read only)
    Occam factor
logLikelihood : float (read only)
    log of the likelihood
 
  Constructor:
BaseFitter( xdata, model, map=False, keep=None, fixedScale=None )
Create a new Fitter, providing inputs and model.
 
A Fitter class is defined by its model and the input vectors ( the
independent variable ). When a fit to another model and/or another
input vector is needed a new object should be created.
 
Parameters
----------
xdata : array_like
    independent input variable(s)
model : Model
    the model function to be fitted
map : bool (False)
    When true, the xdata should be interpreted as a map.
    The fitting is done on the pixel indices of the map,
    using ImageAssistant
keep : dict of {int:float}
    dictionary of indices (int) to be kept at a fixed value (float)
    The values of keep will be used by the Fitter as long as the Fitter exists.
    See also fit( ..., keep=dict )
fixedScale : None or float
    None : the noise scale is not fixed
    float: value of the fixed noise scale
    The value of fixedScale only influences the evidence calculation
 
Raises
------
ValueError when one of the following is true
    1. Dimensionality of model and input does not match.
    2. Nans in input stream.
    3. Model is not the head of a compound model chain.
Methods defined here:
checkNan( ydata, weights=None )
Check there are no Nans or Infs in ydata or weights.
 
Parameters
----------
ydata : array_like
    data to be fitted.
weights : array_like
    weights pertaining to ydata
 
Raises
------
ValueError.
chiSquared( ydata, params=None, weights=None )
Calculates Chi-Squared for data and weights.
 
It is the (weighted) sum of the squared residuals.
 
Parameters
----------
ydata : array_like
    the data vector to be fitted.
params : array_like
    parameters for the model
weights : array_like
    weights to be used
 
Raises
------
ValueError when chisq <= 0.
fit( ydata, weights=None, keep=None )
Return model parameters fitted to the data.
 
Parameters
----------
ydata : array_like
    the data vector to be fitted.
weights : array_like
    weights to be used
keep : dict of {int:float}
    dictionary of indices (int) to be kept at a fixed value (float)
    The values will override those at initialization.
    They are only used in this call of fit.
 
Raises
------
NotImplementedError. BaseFitter cannot perform fits by itself.
fitpostscript( ydata, plot=False )
Produce a plot of the results.
fitprolog( ydata, weights=None, keep=None )
Prolog for all Fitters.
 
1. Checks data/weighs for Nans
2. Makes fitIndex.
 
Parameters
----------
ydata : array_like
    the data vector to be fitted
weights : array_like
    weights pertaining to the data
keep : dict of {int:float}
    dictionary of indices (int) to be kept at a fixed value (float)
 
Returns
-------
fitIndex : ndarray of int
    Indices of the parameters that need fitting
getCovarianceMatrix()
Returns the inverse hessian matrix over the fitted parameters,
        multiplied by the variance.
 
Stdevs are found from this as np.sqrt( np.diag( covarianceMatrix ) )
getDesign( params=None, xdata=None, index=None )
Return the design matrix, D.
The design matrix is also known as the Jacobian Matrix.
 
Parameters
----------
xdata : array_like
    the independent input data
params : array_like
    parameters of the model
index : list of int
    index of parameters to be fixed
getEvidence( limits=None, noiseLimits=None )
Calculation of the evidence, log10( Z ), for the model given the data.
 
    E = log10( P( Model | data ) )
 
The calculation of the evidence uses a Gaussion approximation of the Posterior
probability.
It needs to know the limits of the parameters (and the noise scale if applicable),
either from the priors in the model or from keywords "limits/noiseLimits".
 
 
Parameters
----------
limits : list of 2 floats/array_likes
    possible range of the parameters. ( [low,high] )
noiseLimits : list of 2 floats
    possible range on noise scale ( [low,high] )
 
Raises
------
ValueError when no Prior is available
getHessian( params=None, weights=None, index=None )
Calculates the hessian matrix for a given set of model parameters.
 
It includes "normalized" data if present. See normalize()
 
Parameters
----------
params : array_like
    the model parameters to be considered
weights : array_like
    weights to be used
index : list of int
    index of parameters to be fixed
getInverseHessian( params=None, weights=None, index=None )
Return the inverse of the Hessian Matrix, H.
 
Parameters
----------
ydata : array_like
    the data vector to be fitted.
weights : array_like
    weights to be used
index : list of int
    index of parameters to be fixed
getLogLikelihood( autoscale=False, var=1.0)
Return the log likelihood.
 
It is implementing eq 19/20 last parts (Kester 2002) term by term
 
Parameters
----------
autoscale : bool
    whether the noise scale is optimized too
var : float
    variance
getLogZ( limits=None, noiseLimits=None )
Calculation of the evidence, log( Z ), for the model given the data.
 
    logZ = log( P( Model | data ) )
 
The calculation of the evidence uses a Gaussion approximation of the Posterior
probability.
It needs to know the limits of the parameters (and the noise scale if applicable),
either from the priors in the model or from keywords "limits/noiseLimits".
 
 
Parameters
----------
limits : list of 2 floats/array_likes
    possible range of the parameters. ( [low,high] )
noiseLimits : list of 2 floats
    possible range on noise scale ( [low,high] )
 
Raises
------
ValueError when no Prior is available
 
RuntimeError when DoF <= 0. The number of (weighted) datapoints is too small.
getScale()
Return
------
float : the noise scale
    scale = sqrt( chisq / DOF )
 
Raise
-----
RuntimeError when DoF <= 0. The number of (weighted) datapoints is too small.
getStandardDeviations()
Calculates of standard deviations pertaining to the parameters.
 
    σ_i = s * sqrt( C[i,i] )
 
where C is the Covariance matrix, the inverse of the Hessian Matrix and
s is the noiseScale.
 
Standard deviation are calculated for the fitted parameters only.
 
Note that the stdev will decrease with sqrt( N ) of the number of
datapoints while the noise scale, s, does not.
getVector( ydata, index=None )
Return the β-vector.
 
It includes "normalized" data if present. See normalize().
 
Parameters
----------
ydata : array_like
    the data vector to be fitted. When such is appliccable, it should be
    multiplied by weights and/or appended by normdata.
index : list of int
    index of parameters to be fixed
insertParameters( fitpar, index=None, into=None )
Insert fitparameters into the parameters when fitIndex is present.
 
Parameters
----------
fitpar : list of float
    (fitted) parameters
index : list of int
    list of parameter indices to be kept
into : list of float
    array into which the fitpar need to be inserted.
keepFixed( keep=None )
Keeps parameters fixed at the provided values.
 
1. The model will act exactly as if it were a model with less
   parameters, although slightly less efficient.
2. Repeated calls start from scratch.
3. Reset with keepFixed( None )
 
Parameters
----------
keep : dict of {int:float}
    dictionary of indices (int) to be kept at a fixed value (float)
 
Returns
-------
fitIndex : list of int (or None)
    list of parameter indices to be kept
limitsFit( fitmethod, ydata, weights=None, keep=None )
Fit the data to the model.
When a parameter(s) transgresses the limits, it set and fixed at that limit
and the fit is done again, excluding the parameter(s)
When the chisq landscape is largely monomodal (no local minima) this is OK.
 
Parameter
---------
fitmethod : callable fitmethod( ydata, weights=weights )
    A fit method from the BaseFitter family
ydata : array_like
    data that the model needs to be fit to
weights : array_like
    weights partaining to the data.
keep : dict of {int:float}
    dictionary of indices (int) to be kept at a fixed value (float)
    The values will override those at initialization.
    They are only used in this call of fit.
 
Returns
-------
pars : array_like
    the parameters of the fit
 
Raises
------
Warning when parameters have been reset at the limits.
makeVariance( scale=None )
Return the (calculated) variance of the remaining noise. I.e.
    var = chisq / dof
when automatic noise scaling is requested or
    var = scale^2
when we have a fixed scale.
 
Parameters
----------
scale : float
    noise scale to be used
modelFit( ydata, weights=None, keep=None )
Return model fitted to the data.
 
Parameters
----------
ydata : array_like
    the data vector to be fitted.
weights : None or array_like
    weights to be used
keep : dict of {int:float}
    dictionary of indices (int) to be kept at a fixed value (float)
    The values will override those at initialization.
    They are only used in this call of fit.
monteCarloError( xdata=None, monteCarlo=None )
Calculates σ-confidence regions on the model given some inputs.
 
From the full covariance matrix (inverse of the Hessian) random
samples are drawn, which are added to the parameters. With this new
set of parameters the model is calculated. This procedure is done
by default, 25 times.
The standard deviation of the models is returned as the error bar.
 
The calculation of the confidence region is delegated to the class
MonteCarlo. For tweaking of that class can be done outside BaseFitter.
 
Parameters
----------
xdata : array_like
    input data over which to calculate the error bars.
monteCarlo : MonteCarlo
    a ready-made MonteCarlo class.
normalize( normdfdp, normdata, weight=1.0)
If for some reason the model is degenerate, e.g when two parameters measure
essentially the same thing, This method can disambiguate these parameters.
 
It is like adding a dummy measurement of one (or more) parameter to the data.
 
Parameters
----------
normdfdp : array_like
    for each parameter to sum to value (same length as self.parameters)
normdata : float
    simulated data value
weight : float
    weight of this measurement
plotResult( xdata=None, ydata=None, model=None, residuals=True, confidence=False, show=True )
Plot the results of the fit.
 
Parameters
----------
xdata : array_like
    xdata of the problem
ydata : array_like
    ydata of the problem
model : Model
    the model the ydata are fitted to at xdata.
residuals : bool
    plot the residuals in a separate panel.
confidence : bool
    plot confidence region
show : bool
    display the plot.
setMinimumScale( scale=0)
Introduce a minimum in scale calculation and consequently in chisq.
    chi^2 >= sumwgt * scale^2
 
Parameters
----------
scale : float
    minimum scale