/[MITgcm]/manual/s_autodiff/text/doc_ad_2.tex

Diff of /manual/s_autodiff/text/doc_ad_2.tex

Parent Directory | Revision Log | View Revision Graph Revision Graph | View Patch Patch

-revision 1.19 by heimbach,
Tue Aug  2 22:26:58 2005 UTC
+revision 1.21 by heimbach,
Thu Jan 17 22:32:06 2008 UTC
 Line 4
  Author: Patrick Heimbach
  {\sf Automatic differentiation} (AD), also referred to as algorithmic
  (or, more loosely, computational) differentiation, involves
- automatically deriving code to calculate
+ automatically deriving code to calculate partial derivatives from an
- partial derivatives from an existing fully non-linear prognostic code.
+ existing fully non-linear prognostic code.  (see \cite{gri:00}).  A
- (see \cite{gri:00}).
+ software tool is used that parses and transforms source files
- A software tool is used that parses and transforms source files
+ according to a set of linguistic and mathematical rules.  AD tools are
- according to a set of linguistic and mathematical rules.
+ like source-to-source translators in that they parse a program code as
- AD tools are like source-to-source translators in that
+ input and produce a new program code as output
- they parse a program code as input and produce a new program code
+ (we restrict our discussion to source-to-source tools, ignoring
- as output.
+ operator-overloading tools).  However, unlike a
- However, unlike a pure source-to-source translation, the output program
+ pure source-to-source translation, the output program represents a new
- represents a new algorithm, such as the evaluation of the
+ algorithm, such as the evaluation of the Jacobian, the Hessian, or
- Jacobian, the Hessian, or higher derivative operators.
+ higher derivative operators.  In principle, a variety of derived
- In principle, a variety of derived algorithms
+ algorithms can be generated automatically in this way.
- can be generated automatically in this way.
+ MITgcm has been adapted for use with the Tangent linear and Adjoint
- The MITGCM has been adapted for use with the
+ Model Compiler (TAMC) and its successor TAF (Transformation of
- Tangent linear and Adjoint Model Compiler (TAMC) and its successor TAF
+ Algorithms in Fortran), developed by Ralf Giering (\cite{gie-kam:98},
- (Transformation of Algorithms in Fortran), developed
+ \cite{gie:99,gie:00}).  The first application of the adjoint of MITgcm
- by Ralf Giering (\cite{gie-kam:98}, \cite{gie:99,gie:00}).
+ for sensitivity studies has been published by \cite{maro-eta:99}.
- The first application of the adjoint of the MITGCM for sensitivity
+ \cite{stam-etal:97,stam-etal:02} use MITgcm and its adjoint for ocean
- studies has been published by \cite{maro-eta:99}.
+ state estimation studies.  In the following we shall refer to TAMC and
- \cite{sta-eta:97,sta-eta:01} use the MITGCM and its adjoint
+ TAF synonymously, except were explicitly stated otherwise.
- for ocean state estimation studies.
- In the following we shall refer to TAMC and TAF synonymously,
+ As of mid-2007 we are also able to generate fairly efficient
- except were explicitly stated otherwise.
+ adjoint code of the MITgcm using a new, open-source AD tool,
+ called OpenAD (see \cite{naum-etal:06,utke-etal:08}.
- TAMC exploits the chain rule for computing the first
+ This enables us for the first time to compare adjoint models
- derivative of a function with
+ generated from different AD tools, providing an additional
- respect to a set of input variables.
+ accuracy check, complementary to finite-difference gradient checks.
- Treating a given forward code as a composition of operations --
+ OpenAD and its application to  MITgcm is described in detail
- each line representing a compositional element, the chain rule is
+ in section \ref{sec_ad_openad}.
- rigorously applied to the code, line by line. The resulting
- tangent linear or adjoint code,
+ The AD tool exploits the chain rule for computing the first derivative of a
- then, may be thought of as the composition in
+ function with respect to a set of input variables.  Treating a given
- forward or reverse order, respectively, of the
+ forward code as a composition of operations -- each line representing
- Jacobian matrices of the forward code's compositional elements.
+ a compositional element, the chain rule is rigorously applied to the
+ code, line by line. The resulting tangent linear or adjoint code,
+ then, may be thought of as the composition in forward or reverse
+ order, respectively, of the Jacobian matrices of the forward code's
+ compositional elements.
  %**********************************************************************
  \section{Some basic algebra}
-Line 688 
 Schematic view of intermediate dump and
+Line 692 
 Schematic view of intermediate dump and
  In this section we describe in a general fashion
  the parts of the code that are relevant for automatic
  differentiation using the software tool TAF.
+ Modifications to use OpenAD are described in \ref{sec_ad_openad}.
  \input{part5/doc_ad_the_model}
-Line 771 
 w.r.t. the 3-level checkpointing (see se
+Line 776 
 w.r.t. the 3-level checkpointing (see se
  %------------------------------------------------------------------
- \subsection{Building the AD code
+ \subsection{Building the AD code using TAF
  \label{section_ad_build}}
  The build process of an AD code is very similar to building
-Line 781 
 the following {\tt make} targets are ava
+Line 786 
 the following {\tt make} targets are ava
  \begin{table}[h!]
  {\footnotesize
- \begin{tabular}{ccll}
+ \begin{tabular}{|ccll|}
+ \hline
  ~ & {\it AD-target} & {\it output} & {\it description} \\
  \hline
  \hline
-Line 800 
 generates code for $<$MODE$>$ using $<$T
+Line 806 
 generates code for $<$MODE$>$ using $<$T
  ~ & ~ & ~ & and compiles all code \\
  ~ & ~ & ~ & (use of TAF is set as default) \\
  \hline
- \hline
  \end{tabular}
  }
  \end{table}
-Line 809 
 Here, the following placeholders are use
+Line 814 
 Here, the following placeholders are use
  %
  \begin{itemize}
  %
- \item [$<$TOOL$>$]
+ \item $<$TOOL$>$
  %
  \begin{itemize}
  %
-Line 818 
 Here, the following placeholders are use
+Line 823 
 Here, the following placeholders are use
  %
  \end{itemize}
  %
- \item [$<$MODE$>$]
+ \item $<$MODE$>$
  %
  \begin{itemize}
  %
-Line 860 
 The {\tt make <MODE>all} target consists
+Line 865 
 The {\tt make <MODE>all} target consists
  \item
  A header file {\tt AD\_CONFIG.h} is generated which contains a CPP option
  on which code ought to be generated. Depending on the {\tt make} target,
- the contents is
+ the contents is one of the following:
  \begin{itemize}
  \item
  {\tt \#define ALLOW\_ADJOINT\_RUN}
-Line 876 
 consisting of all {\tt .f} files that ar
+Line 881 
 consisting of all {\tt .f} files that ar
  and all {\tt .flow} files that are part of the list {\bf AD\_FLOW\_FILES}.
  %
  \item
- The AD tool is invoked with the {\bf <MODE>\_<TOOL>\_FLAGS}.
+ The AD tool is invoked with the {\tt <MODE>\_<TOOL>\_FLAGS}.
  The default AD tool flags in {\tt genmake2} can be overrwritten by
  an {\tt adjoint\_options} file (similar to the platform-specific
  {\tt build\_options}, see Section ???.
-Line 955 
 The flow directives for the core MITgcm
+Line 960 
 The flow directives for the core MITgcm
  {\tt eesupp/src/} and {\tt model/src/}
  reside in {\tt pkg/autodiff/}.
  This directory also contains hand-written adjoint code
- for the MITgcm WRAPPER (see Section ???).
+ for the MITgcm WRAPPER (section \ref{chap:sarch}).
  Flow directives for package-specific routines are contained in
  the corresponding package directories in the file
-Line 1124 
 from each contribution and sums over all
+Line 1129 
 from each contribution and sums over all
  \end{equation}
  %
  The total cost function {\bf fc} will be the
- 'dependent' variable in the argument list for TAMC, i.e.
+ 'dependent' variable in the argument list for TAF, i.e.
  \begin{verbatim}
- tamc -output 'fc' ...
+ taf -output 'fc' ...
  \end{verbatim}
  %%%% \end{document}
-Line 1209 
 and their gradients: {\it ctrl\_unpack}
+Line 1214 
 and their gradients: {\it ctrl\_unpack}
  \\
  %
  Two important issues related to the handling of the control
- variables in the MITGCM need to be addressed.
+ variables in MITgcm need to be addressed.
  First, in order to save memory, the control variable arrays
  are not kept in memory, but rather read from file and added
  to the initial fields during the model initialization phase.
-Line 1241 
 and gradient are generated and initialis
+Line 1246 
 and gradient are generated and initialis
  %
  The dependency flow for differentiation w.r.t. the controls
  starts with adding a perturbation onto the input variable,
- thus defining the independent or control variables for TAMC.
+ thus defining the independent or control variables for TAF.
  Three types of controls may be considered:
  %
  \begin{itemize}
-Line 1274 
 u         & = \, u_{[0]} \, + \, \Delta
+Line 1279 
 u         & = \, u_{[0]} \, + \, \Delta
  holding the perturbation. In the case of a simple
  sensitivity study this array is identical to zero.
  However, it's specification is essential in the context
- of automatic differentiation since TAMC
+ of automatic differentiation since TAF
  treats the corresponding line in the code symbolically
  when determining the differentiation chain and its origin.
  Thus, the variable names are part of the argument list
- when calling TAMC:
+ when calling TAF:
  %
  \begin{verbatim}
- tamc -input 'xx_tr1 ...' ...
+ taf -input 'xx_tr1 ...' ...
  \end{verbatim}
  %
- Now, as mentioned above, the MITGCM avoids maintaining
+ Now, as mentioned above, MITgcm avoids maintaining
  an array for each control variable by reading the
  perturbation to a temporary array from file.
- To ensure the symbolic link to be recognized by TAMC, a scalar
+ To ensure the symbolic link to be recognized by TAF, a scalar
  dummy variable {\bf xx\_tr1\_dummy} is introduced
  and an 'active read' routine of the adjoint support
  package {\it pkg/autodiff} is invoked.
  The read-procedure is tagged with the variable
- {\bf xx\_tr1\_dummy} enabling TAMC to recognize the
+ {\bf xx\_tr1\_dummy} enabling TAF to recognize the
  initialization of the perturbation.
- The modified call of TAMC thus reads
+ The modified call of TAF thus reads
  %
  \begin{verbatim}
- tamc -input 'xx_tr1_dummy ...' ...
+ taf -input 'xx_tr1_dummy ...' ...
  \end{verbatim}
  %
  and the modified operation to (\ref{perturb})

 Legend:



Removed from v.1.19
 


changed lines


 
Added in v.1.21
 Legend:



Removed from v.1.19
 


changed lines


 
Added in v.1.21
-Removed from v.1.19
+Added in v.1.21

	ViewVC Help
Powered by ViewVC 1.1.22