[Scipysvn] r6889  trunk/scipy/odr
scipysvn@scip...
scipysvn@scip...
Sun Nov 14 04:00:34 CST 2010
Author: rgommers
Date: 20101114 04:00:33 0600 (Sun, 14 Nov 2010)
New Revision: 6889
Modified:
trunk/scipy/odr/__init__.py
trunk/scipy/odr/odrpack.py
Log:
DOC: merge wiki edits for odr module.
Modified: trunk/scipy/odr/__init__.py
===================================================================
 trunk/scipy/odr/__init__.py 20101114 10:00:16 UTC (rev 6888)
+++ trunk/scipy/odr/__init__.py 20101114 10:00:33 UTC (rev 6889)
@@ 1,3 +1,90 @@
+"""
+Orthogonal Distance Regression (:mod:`scipy.odr`)
+=================================================
+
+Introduction
+
+
+Why Orthogonal Distance Regression (ODR)? Sometimes one has
+measurement errors in the explanatory (a.k.a., "independent")
+variable(s), not just the response (a.k.a., "dependent") variable(s).
+Ordinary Least Squares (OLS) fitting procedures treat the data for
+explanatory variables as fixed, i.e., not subject to error of any kind.
+Furthermore, OLS procedures require that the response variables be an
+explicit function of the explanatory variables; sometimes making the
+equation explicit is impractical and/or introduces errors. ODR can
+handle both of these cases with ease, and can even reduce to the OLS
+case if that is sufficient for the problem.
+
+ODRPACK is a FORTRAN77 library for performing ODR with possibly
+nonlinear fitting functions. It uses a modified trustregion
+LevenbergMarquardttype algorithm [1]_ to estimate the function
+parameters. The fitting functions are provided by Python functions
+operating on NumPy arrays. The required derivatives may be provided
+by Python functions as well, or may be estimated numerically. ODRPACK
+can do explicit or implicit ODR fits, or it can do OLS. Input and
+output variables may be multidimensional. Weights can be provided to
+account for different variances of the observations, and even
+covariances between dimensions of the variables.
+
+odr provides two interfaces: a single function, and a set of
+highlevel classes that wrap that function; please refer to their
+docstrings for more information. While the docstring of the function
+odr does not have a full explanation of its arguments, the classes do,
+and arguments of the same name usually have the same requirements.
+Furthermore, the user is urged to at least skim the `ODRPACK User's
+Guide <http://docs.scipy.org/doc/external/odrpack_guide.pdf>`_ 
+"Know Thy Algorithm."
+
+Use
+
+
+See the docstrings of `odr.odrpack` and the functions and classes for
+usage instructions. The ODRPACK User's Guide (linked above) is also
+quite helpful.
+
+References
+
+.. [1] P. T. Boggs and J. E. Rogers, "Orthogonal Distance Regression,"
+ in "Statistical analysis of measurement error models and
+ applications: proceedings of the AMSIMSSIAM joint summer research
+ conference held June 1016, 1989," Contemporary Mathematics,
+ vol. 112, pg. 186, 1990.
+
+.. currentmodule:: scipy.odr
+
+Modules
+
+
+.. autosummary::
+ :toctree: generated/
+
+ odrpack Python wrappers for FORTRAN77 ODRPACK.
+ models Model instances for use with odrpack.
+
+Classes
+
+
+.. autosummary::
+ :toctree: generated/
+
+ ODR Gathers all info & manages the main fitting routine.
+ Data Stores the data to fit.
+ Model Stores information about the function to be fit.
+ Output
+ RealData Weights as actual std. dev.s and/or covariances.
+ odr_error
+ odr_stop
+
+Functions
+
+
+.. autosummary::
+ :toctree: generated/
+
+ odr
+
+"""
#
# odr  Orthogonal Distance Regression
#
Modified: trunk/scipy/odr/odrpack.py
===================================================================
 trunk/scipy/odr/odrpack.py 20101114 10:00:16 UTC (rev 6888)
+++ trunk/scipy/odr/odrpack.py 20101114 10:00:33 UTC (rev 6889)
@@ 1,4 +1,5 @@
""" Python wrappers for Orthogonal Distance Regression (ODRPACK).
+"""
+Python wrappers for Orthogonal Distance Regression (ODRPACK).
Classes
=======
@@ 28,43 +29,52 @@
Basic use:
1) Define the function you want to fit against:
+1) Define the function you want to fit against.
+::
def f(B, x):
+ ''' Linear function y = m*x + b '''
return B[0]*x + B[1]
 B is a vector of the parameters.
 x is an array of the current x values. (Same format as the x passed to Data or
 RealData. Return an array in the same format as y passed to Data or
 RealData.)
+ # B is a vector of the parameters.
+ # x is an array of the current x values.
+ # x is same format as the x passed to Data or RealData.
+ # Return an array in the same format as y passed to Data or RealData.
+
2) Create a Model.
+::
linear = Model(f)
3) Create a Data or RealData instance.
+::
mydata = Data(x, y, wd=1./power(sx,2), we=1./power(sy,2))
 or
+or
+::
+
mydata = RealData(x, y, sx=sx, sy=sy)
4) Instantiate ODR with your data, model and initial parameter estimate.
+::
myodr = ODR(mydata, linear, beta0=[1., 2.])
5) Run the fit.
+::
myoutput = myodr.run()
6) Examine output.
+::
myoutput.pprint()
Read the docstrings and the accompanying tests for more advanced usage.

Notes
=====
@@ 97,6 +107,7 @@
Robert Kern
robert.kern@gmail.com
+
"""
import numpy
@@ 414,67 +425,72 @@
class Model(object):
 """ The Model class stores information about the function you wish to fit.
+ """
+ The Model class stores information about the function you wish to fit.
 It stores the function itself, at the least, and optionally stores functions
 which compute the Jacobians used during fitting. Also, one can provide
 a function that will provide reasonable starting values for the fit
 parameters possibly given the set of data.
+ It stores the function itself, at the least, and optionally stores
+ functions which compute the Jacobians used during fitting. Also, one
+ can provide a function that will provide reasonable starting values
+ for the fit parameters possibly given the set of data.
 The initialization method stores these into members of the
 same name.
+ The initialization method stores these into members of the same name.
 fcn  fit function: fcn(beta, x) > y
+ fcn  fit function
+ fcn(beta, x) > y
 fjacb  Jacobian of fcn wrt the fit parameters beta:
+ fjacb  Jacobian of fcn wrt the fit parameters beta
fjacb(beta, x) > @f_i(x,B)/@B_j
 fjacd  Jacobian of fcn wrt the (possibly multidimensional) input variable:
+ fjacd  Jacobian of fcn wrt the (possibly multidimensional) input
+ variable
fjacd(beta, x) > @f_i(x,B)/@x_j
extra_args  if specified, extra_args should be a tuple of extra
 arguments to pass to fcn, fjacb, and fjacd. Each will be called like
 the following: apply(fcn, (beta, x) + extra_args)
+ arguments to pass to fcn, fjacb, and fjacd. Each will be called
+ like the following: apply(fcn, (beta, x) + extra_args)
estimate  provide estimates of the fit parameters from the data:
estimate(data) > estbeta
implicit  boolean variable which, if TRUE, specifies that the model
is implicit; i.e fcn(beta, x) ~= 0 and there is no y data to fit
 against.
+ against
 meta  an optional, freeform dictionary of metadata for the model
+ meta  optional
+ freeform dictionary of metadata for the model
Note that the fcn, fjacb, and fjacd operate on NumPy arrays and return
 a NumPy array. estimate takes an instance of the Data class.
+ a NumPy array. The `estimate` object takes an instance of the Data class.
Here are the rules for the shapes of the argument and return arrays:
x  if the input data is singledimensional, then x is rank1
array; i.e. x = array([1, 2, 3, ...]); x.shape = (n,)
 If the input data is multidimensional, then x is a rank2 array; i.e.
 x = array([[1, 2, ...], [2, 4, ...]]); x.shape = (m, n) In all cases, it
 has the same shape as the input data array passed to odr(). m is the
 dimensionality of the input data, n is the number of observations.
+ If the input data is multidimensional, then x is a rank2 array;
+ i.e., x = array([[1, 2, ...], [2, 4, ...]]); x.shape = (m, n) In
+ all cases, it has the same shape as the input data array passed to
+ odr(). m is the dimensionality of the input data, n is the number
+ of observations.
 y  if the response variable is singledimensional, then y is a rank1
 array; i.e. y = array([2, 4, ...]); y.shape = (n,)
 If the response variable is multidimensional, then y is a rank2 array;
 i.e. y = array([[2, 4, ...], [3, 6, ...]]); y.shape = (q, n) where q is
 the dimensionality of the response variable.
+ y  if the response variable is singledimensional, then y is a
+ rank1 array, i.e., y = array([2, 4, ...]); y.shape = (n,)
+ If the response variable is multidimensional, then y is a rank2
+ array, i.e., y = array([[2, 4, ...], [3, 6, ...]]); y.shape =
+ (q, n) where q is the dimensionality of the response variable.
beta  rank1 array of length p where p is the number of parameters;
i.e. beta = array([B_1, B_2, ..., B_p])
 fjacb  if the response variable is multidimensional, then the return
 array's shape is (q, p, n) such that
 fjacb(x,beta)[l,k,i] = @f_l(X,B)/@B_k evaluated at the i'th data point.
 If q == 1, then the return array is only rank2 and with shape (p, n).
+ fjacb  if the response variable is multidimensional, then the
+ return array's shape is (q, p, n) such that fjacb(x,beta)[l,k,i] =
+ @f_l(X,B)/@B_k evaluated at the i'th data point. If q == 1, then
+ the return array is only rank2 and with shape (p, n).
 fjacd  as with fjacb, only the return array's shape is (q, m, n) such that
 fjacd(x,beta)[l,j,i] = @f_l(X,B)/@X_j at the i'th data point.
 If q == 1, then the return array's shape is (m, n). If m == 1, the shape
 is (q, n). If m == q == 1, the shape is (n,).
+ fjacd  as with fjacb, only the return array's shape is (q, m, n)
+ such that fjacd(x,beta)[l,j,i] = @f_l(X,B)/@X_j at the i'th data
+ point. If q == 1, then the return array's shape is (m, n). If
+ m == 1, the shape is (q, n). If m == q == 1, the shape is (n,).
+
"""
def __init__(self, fcn, fjacb=None, fjacd=None,
@@ 516,56 +532,58 @@
class Output(object):
 """ The Output class stores the output of an ODR run.
+ """
+ The Output class stores the output of an ODR run.
 Takes one argument for initialization: the return value from the
 function odr().
+ Takes one argument for initialization, the return value from the
+ function odr.
Attributes

 beta  estimated parameter values [beta.shape == (q,)]

 sd_beta  standard errors of the estimated parameters
+ beta :
+ estimated parameter values [beta.shape == (q,)]
+ sd_beta :
+ standard errors of the estimated parameters
[sd_beta.shape == (p,)]

 cov_beta  covariance matrix of the estimated parameters
+ cov_beta :
+ covariance matrix of the estimated parameters
[cov_beta.shape == (p, p)]
 Optional Attributes
 
 Present if odr() was run with "full_output=1".
+ Following are present if odr() was run with "full_output=1".
 delta  array of estimated errors in input variables
+ delta :
+ array of estimated errors in input variables
[delta.shape == data.x.shape]

 eps  array of estimated errors in response variables
+ eps :
+ array of estimated errors in response variables
[eps.shape == data.y.shape]

 xplus  array of x + delta [xplus.shape == data.x.shape]

 y  array of y = fcn(x + delta) [y.shape == data.y.shape]

 res_var  residual variance [scalar]

 sum_sqare  sum of squares error [scalar]

 sum_square_delta  sum of squares of delta error [scalar]

 sum_square_eps  sum of squares of eps error [scalar]

 inv_condnum  inverse condition number [scalar] (cf. ODRPACK UG p. 77)

 rel_error  relative error in function values computed within fcn [scalar]

 work  final work array [array]

 work_ind  indices into work for drawing out values [dictionary]
+ xplus :
+ array of x + delta [xplus.shape == data.x.shape]
+ y :
+ array of y = fcn(x + delta) [y.shape == data.y.shape]
+ res_var : float
+ residual variance
+ sum_sqare : float
+ sum of squares error
+ sum_square_delta : float
+ sum of squares of delta error
+ sum_square_eps : float
+ sum of squares of eps error
+ inv_condnum : float
+ inverse condition number (cf. ODRPACK UG p. 77)
+ rel_error : float
+ relative error in function values computed within fcn
+ work : ndarray
+ final work array
+ work_ind : dictionary
+ indices into work for drawing out values
(cf. ODRPACK UG p. 83)

 info  reason for returning (as output by ODRPACK) [integer]
+ info : int
+ reason for returning (as output by ODRPACK)
(cf. ODRPACK UG p. 38)
+ stopreason : list of strings
+ "info" interpreted into English
 stopreason  "info" interpreted into English [list of strings]
"""
def __init__(self, output):
@@ 595,7 +613,8 @@
class ODR(object):
 """ The ODR class gathers all information and coordinates the running of the
+ """
+ The ODR class gathers all information and coordinates the running of the
main fitting routine.
Members of instances of the ODR class have the same names as the arguments
@@ 603,93 +622,92 @@
Parameters

 Required:
 data  instance of the Data class

 model  instance of the Model class

 beta0  a rank1 sequence of initial parameter values. Optional if
+ data:
+ instance of the Data class
+ model:
+ instance of the Model class
+ beta0:
+ a rank1 sequence of initial parameter values. Optional if
model provides an "estimate" function to estimate these values.

 Optional:
 delta0  a (doubleprecision) float array to hold the initial values of
 the errors in the input variables. Must be same shape as data.x .

 ifixb  sequence of integers with the same length as beta0 that determines
+ delta0: optional
+ a (doubleprecision) float array to hold the initial values of
+ the errors in the input variables. Must be same shape as data.x
+ ifixb: optional
+ sequence of integers with the same length as beta0 that determines
which parameters are held fixed. A value of 0 fixes the parameter,
a value > 0 makes the parameter free.

 ifixx  an array of integers with the same shape as data.x that determines
 which input observations are treated as fixed. One can use a sequence of
 length m (the dimensionality of the input observations) to fix some
+ ifixx: optional
+ an array of integers with the same shape as data.x that determines
+ which input observations are treated as fixed. One can use a sequence
+ of length m (the dimensionality of the input observations) to fix some
dimensions for all observations. A value of 0 fixes the observation,
a value > 0 makes it free.

 job  an integer telling ODRPACK what tasks to perform. See p. 31 of the
+ job: optional
+ an integer telling ODRPACK what tasks to perform. See p. 31 of the
ODRPACK User's Guide if you absolutely must set the value here. Use the
method set_job postinitialization for a more readable interface.

 iprint  an integer telling ODRPACK what to print. See pp. 3334 of the
+ iprint: optional
+ an integer telling ODRPACK what to print. See pp. 3334 of the
ODRPACK User's Guide if you absolutely must set the value here. Use the
method set_iprint postinitialization for a more readable interface.

 errfile  string with the filename to print ODRPACK errors to. *Do Not Open
+ errfile: optional
+ string with the filename to print ODRPACK errors to. *Do Not Open
This File Yourself!*

 rptfile  string with the filename to print ODRPACK summaries to. *Do Not
+ rptfile: optional
+ string with the filename to print ODRPACK summaries to. *Do Not
Open This File Yourself!*

 ndigit  integer specifying the number of reliable digits in the computation
+ ndigit: optional
+ integer specifying the number of reliable digits in the computation
of the function.

 taufac  float specifying the initial trust region. The default value is 1.
+ taufac: optional
+ float specifying the initial trust region. The default value is 1.
The initial trust region is equal to taufac times the length of the
first computed GaussNewton step. taufac must be less than 1.

 sstol  float specifying the tolerance for convergence based on the relative
+ sstol: optional
+ float specifying the tolerance for convergence based on the relative
change in the sumofsquares. The default value is eps**(1/2) where eps
is the smallest value such that 1 + eps > 1 for double precision
computation on the machine. sstol must be less than 1.

 partol  float specifying the tolerance for convergence based on the relative
+ partol: optional
+ float specifying the tolerance for convergence based on the relative
change in the estimated parameters. The default value is eps**(2/3) for
explicit models and eps**(1/3) for implicit models. partol must be less
than 1.

 maxit  integer specifying the maximum number of iterations to perform. For
+ maxit: optional
+ integer specifying the maximum number of iterations to perform. For
first runs, maxit is the total number of iterations performed and
defaults to 50. For restarts, maxit is the number of additional
iterations to perform and defaults to 10.

 stpb  sequence (len(stpb) == len(beta0)) of relative step sizes to compute
+ stpb: optional
+ sequence (len(stpb) == len(beta0)) of relative step sizes to compute
finite difference derivatives wrt the parameters.

 stpd  array (stpd.shape == data.x.shape or stpd.shape == (m,)) of relative
+ stpd: optional
+ array (stpd.shape == data.x.shape or stpd.shape == (m,)) of relative
step sizes to compute finite difference derivatives wrt the input
variable errors. If stpd is a rank1 array with length m (the
dimensionality of the input variable), then the values are broadcast to
all observations.

 sclb  sequence (len(stpb) == len(beta0)) of scaling factors for the
+ sclb: optional
+ sequence (len(stpb) == len(beta0)) of scaling factors for the
parameters. The purpose of these scaling factors are to scale all of
 the parameters to around unity. Normally appropriate scaling factors are
 computed if this argument is not specified. Specify them yourself if the
 automatic procedure goes awry.

 scld  array (scld.shape == data.x.shape or scld.shape == (m,)) of scaling
+ the parameters to around unity. Normally appropriate scaling factors
+ are computed if this argument is not specified. Specify them yourself
+ if the automatic procedure goes awry.
+ scld: optional
+ array (scld.shape == data.x.shape or scld.shape == (m,)) of scaling
factors for the *errors* in the input variables. Again, these factors
are automatically computed if you do not provide them. If scld.shape ==
(m,), then the scaling factors are broadcast to all observations.
+ work: optional
+ array to hold the doublevalued working data for ODRPACK. When
+ restarting, takes the value of self.output.work.
+ iwork: optional
+ array to hold the integervalued working data for ODRPACK. When
+ restarting, takes the value of self.output.iwork.
+ output:
+ an instance if the Output class containing all of the returned
+ data from an invocation of ODR.run() or ODR.restart()
 work  array to hold the doublevalued working data for ODRPACK. When
 restarting, takes the value of self.output.work .

 iwork  array to hold the integervalued working data for ODRPACK. When
 restarting, takes the value of self.output.iwork .

 Other Members (not supplied as initialization arguments):
 output  an instance if the Output class containing all of the returned
 data from an invocation of ODR.run() or ODR.restart()
"""
def __init__(self, data, model, beta0=None, delta0=None, ifixb=None,
@@ 867,47 +885,58 @@
def set_job(self, fit_type=None, deriv=None, var_calc=None,
del_init=None, restart=None):
 """ Sets the "job" parameter is a hopefully comprehensible way.
+ """
+ Sets the "job" parameter is a hopefully comprehensible way.
If an argument is not specified, then the value is left as is. The
default value from class initialization is for all of these options set
to 0.
 ========= ===== =====================================================
 Parameter Value Meaning
 ========= ===== =====================================================
 fit_type 0 explicit ODR
 1 implicit ODR
 2 ordinary leastsquares
+ Parameters
+ 
+ fit_type : {0, 1, 2} int
+ 0 > explicit ODR
 deriv 0 forward finite differences
 1 central finite differences
 2 usersupplied derivatives (Jacobians) with results
 checked by ODRPACK
 3 usersupplied derivatives, no checking
+ 1 > implicit ODR
 var_calc 0 calculate asymptotic covariance matrix and fit
 parameter uncertainties (V_B, s_B) using derivatives
 recomputed at the final solution
 1 calculate V_B and s_B using derivatives from last
 iteration
 2 do not calculate V_B and s_B
+ 2 > ordinary leastsquares
+ deriv : {0, 1, 2, 3} int
+ 0 > forward finite differences
 del_init 0 initial input variable offsets set to 0
 1 initial offsets provided by user in variable "work"
+ 1 > central finite differences
 restart 0 fit is not a restart
 1 fit is a restart
 ========= ===== =====================================================
+ 2 > usersupplied derivatives (Jacobians) with results
+ checked by ODRPACK
+ 3 > usersupplied derivatives, no checking
+ var_calc : {0, 1, 2} int
+ 0 > calculate asymptotic covariance matrix and fit
+ parameter uncertainties (V_B, s_B) using derivatives
+ recomputed at the final solution
+
+ 1 > calculate V_B and s_B using derivatives from last iteration
+
+ 2 > do not calculate V_B and s_B
+ del_init : {0, 1} int
+ 0 > initial input variable offsets set to 0
+
+ 1 > initial offsets provided by user in variable "work"
+ restart : {0, 1} int
+ 0 > fit is not a restart
+
+ 1 > fit is a restart
+
+ Notes
+ 
The permissible values are different from those given on pg. 31 of the
 ODRPACK User's Guide only in that one cannot specify numbers greater than the
 last value for each variable.
+ ODRPACK User's Guide only in that one cannot specify numbers greater than
+ the last value for each variable.
If one does not supply functions to compute the Jacobians, the fitting
procedure will change deriv to 0, finite differences, as a default. To
initialize the input variable offsets by yourself, set del_init to 1 and
put the offsets into the "work" variable correctly.
+
"""
if self.job is None:
More information about the Scipysvn
mailing list