# Error Checking Partial Derivatives¶

## Simple Example Using Problem.check_partial_derivatives¶

OpenMDAO provides a way for a Component developer to verify that their partial derivatives, for each individual component, are correct.

Problem has a method, check_partial_derivatives, that checks partial
derivatives comprehensively for all Components in your model (as long as
you didn’t set *deriv_options[‘type’] = ‘fd’ on that component*). To do this
check, the framework compares the analytic result against a finite
difference result. This means that the check_partial_derivatives function
can be quite computationally expensive. So use it to check your work, but
don’t leave the call in your production run scripts.

Note

check_partial_derivatives has three optional arguments,

**out_stream**, lets you define where the results of the check are written
to. The default is sys.stdout. This example explicitly sets the value of
out_stream to sys.stdout to make our automated doc tests work correctly.
You would only set this argument if you wanted to pipe it to a file or some
other stream.

**comps** is a list of component pathnames, which you can specify if you
want to only check the gradients on a subset of the components as a time
saver while debugging

**compact_print** can be set to True for more compact results (essentially
each input/output pair is summarized on one line.) You should be careful
with this, particuarly for arrays where an important difference in a single
array element might not be noticed when looking purely at the norm of the
difference between the arrays.

Here is example code for a model that consists of a single Component, SimpleArrayComp. After setting up the model, it runs `check_partial_derivatives on the Problem.

```
import numpy as np
import sys
from openmdao.api import IndepVarComp, Problem, Group
from openmdao.test.simple_comps import SimpleArrayComp
prob = Problem()
prob.root = Group()
prob.root.add('comp', SimpleArrayComp())
prob.root.add('p1', IndepVarComp('x', np.ones([2])))
prob.root.connect('p1.x', 'comp.x')
prob.setup(check=False)
prob.run()
data = prob.check_partial_derivatives(out_stream=sys.stdout)
```

This code generates output that looks like this:

```
Partial Derivatives Check
-------------------
Component: 'comp'
-------------------
comp: 'y' wrt 'x'
Forward Magnitude : 9.327379e+00
Reverse Magnitude : 9.327379e+00
Fd Magnitude : 9.327379e+00 (fd:forward)
Absolute Error (Jfor - Jfd) : 1.769949e-09
Absolute Error (Jrev - Jfd) : 1.769949e-09
Absolute Error (Jfor - Jrev): 0.000000e+00
Relative Error (Jfor - Jfd) : 1.897585e-10
Relative Error (Jrev - Jfd) : 1.897585e-10
Relative Error (Jfor - Jrev): 0.000000e+00
Raw Forward Derivative (Jfor)
[[ 2. 7.]
[ 5. -3.]]
Raw Reverse Derivative (Jrev)
[[ 2. 7.]
[ 5. -3.]]
Raw FD Derivative (Jfd)
[[ 2. 7.]
[ 5. -3.]]
...
```

You can control the finite difference used in the check by setting some additional options in the deriv_options dictionary.

```
# Set form to 'central', 'forward', or 'reverse'
prob.root.comp.deriv_options['check_form'] = 'central'
# Can check with 'fd' (finite difference) or 'cs' (complex step)
prob.root.comp.deriv_options['check_type'] = 'fd'
# Can be 'relative' or 'absolute'
prob.root.comp.deriv_options['check_step_calc'] = 'relative'
# Set a step size
prob.root.comp.deriv_options['check_step_size'] = 1.0e-5
```

You can also use the check_partial_derivatives method to compare two different kinds of finite difference executions (e.g., forward and central) with each other or to complex step. Do this by setting ‘type’ in your component to ‘fd’ or ‘cs’. The options for this second check are the regular ‘fd’ options ‘step_size’, ‘form’, ‘type’, and ‘step_calc’.

```
import numpy as np
import sys
from openmdao.api import IndepVarComp, Problem, Group
from openmdao.test.simple_comps import SimpleArrayComp
prob = Problem()
prob.root = Group()
prob.root.add('comp', SimpleArrayComp())
prob.root.add('p1', IndepVarComp('x', np.ones([2])))
prob.root.connect('p1.x', 'comp.x')
# Turn on fd in comp using forward difference
prob.root.comp.deriv_options['type'] = 'fd'
prob.root.comp.deriv_options['form'] = 'forward'
# Compare the fd with central difference
prob.root.comp.deriv_options['check_form'] = 'central'
prob.setup(check=False)
prob.run()
data = prob.check_partial_derivatives(out_stream=sys.stdout)
```

This code generates output that looks like this:

```
Partial Derivatives Check
-------------------
Component: 'comp'
-------------------
comp: 'y' wrt 'x'
Fwd/Rev Magnitude : Component supplies no analytic derivatives.
Fd Magnitude : 9.327379e+00 (fd:central)
Fd2 Magnitude : 9.327379e+00 (fd:forward)
Absolute Error (Jfd2 - Jfd): 2.551098e-09
Relative Error (Jfd2 - Jfd) : 2.735064e-10
Raw FD Derivative (Jfd)
[[ 2. 7.]
[ 5. -3.]]
Raw FD Check Derivative (Jfd2)
[[ 2. 7.]
[ 5. -3.]]
...
```

## Return Value of check_partial_derivatives¶

The method check_partial_derivatives returns a dict of dicts of dicts with comprehensive information about the check of the partial derivatives. You can use this data to write scripts to interact with the derivatives check information if you want.

The keys of the nested dicts are:

Dict Key | Example |
---|---|

Component name | ‘subcomp’ |

A tuple of strings indicating the (output, input) variables | (‘y1’, ‘x2’) |

One of [‘rel error’, ‘abs error’, ‘magnitude’, ‘fdstep’] | ‘rel error’ |

The type of the values depends on key of the innermost dict.

Key of Innermost Dict | Type of value |
---|---|

‘rel error’, ‘abs error’, ‘magnitude’ | A tuple containing norms for (forward - finite differences), ( adjoint - finite differences), (forward - adjoint) using the best case fdstep |

‘J_fd’, ‘J_fwd’, ‘J_rev’, ‘J_fd2’* | A numpy array representing the computed Jacobian for the three different methods of computation |