Skip to content
GitLab
Projects
Groups
Snippets
Help
Loading...
Help
What's new
10
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Sign in
Toggle navigation
Open sidebar
pyMOR
pymor
Commits
54aa00ab
Commit
54aa00ab
authored
Dec 03, 2020
by
Tim Keil
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
[docs/tutorials] fix some docs issues and include Hendriks review
parent
794dafe1
Changes
1
Hide whitespace changes
Inline
Sidebyside
Showing
1 changed file
with
33 additions
and
33 deletions
+33
33
docs/source/tutorial_optimization.rst
docs/source/tutorial_optimization.rst
+33
33
No files found.
docs/source/tutorial_optimization.rst
View file @
54aa00ab
...
...
@@ 23,10 +23,10 @@ where :math:`u_{\mu} \in V := H^1_0(\Omega)` is the solution of
a_
{\
mu
}(
u_
{\
mu
},
v
)
=
f_
{\
mu
}(
v
)
\
qquad
\
forall
\,
v
\
in
V
\
tag
{
P
.
b
}.
\
end
{
equation
}
The
equation
:
raw

latex
:`\
eqref
{
eq
:
primal
}`
is
called
the
primal
The
equation
:
math
:`\
eqref
{
eq
:
primal
}`
is
called
the
primal
equation
and
can
be
arbitrarily
complex
.
MOR
methods
in
the
context
of
PDE

constrained
optimization
problems
thus
aim
to
find
a
surrogate
model
of
:
raw

latex
:`\
eqref
{
eq
:
primal
}`
to
reduce
the
computational
costs
of
of
:
math
:`\
eqref
{
eq
:
primal
}`
to
reduce
the
computational
costs
of
an
evaluation
of
:
math
:`
J
(
u_
{\
mu
},
\
mu
)`.
Since
:
math
:`
u_
{\
mu
}`
is
always
related
to
:
math
:`\
mu
`,
we
can
also
...
...
@@ 38,13 +38,13 @@ problem: Find a local minimizer of
..
math
::
\
min_
{\
mu
\
in
\
mathcal
{
P
}}
\
mathcal
{
J
}(\
mu
)
,
\
tag
{$\
hat
{
P
}$}
\
min_
{\
mu
\
in
\
mathcal
{
P
}}
\
mathcal
{
J
}(\
mu
)
.
\
tag
{$\
hat
{
P
}$}
There
exist
plenty
of
different
methods
to
solve
(:
math
:`\
hat
{
P
}`)
by
using
MOR
methods
.
Some
of
them
rely
on
an
RB
method
with
traditional
offline
/
online
splitting
,
which
typically
result
in
a
very
online
efficient
approach
.
Recent
research
also
tackles
overall
efficiency
by
overcoming
the
expensive
offline
approach
which
we
will
discuss
further
overcoming
the
expensive
offline
phase
,
which
we
will
discuss
further
below
.
In
this
tutorial
,
we
use
a
simple
linear
scalar
valued
objective
functional
...
...
@@ 68,10 +68,10 @@ with data functions
..
math
::
\
begin
{
align
}
l
(
x
,
y
)
&=
\
tfrac
{
1
}{
2
}
\
pi
^
2
cos
(\
tfrac
{
1
}{
2
}
\
pi
x
)
cos
(\
tfrac
{
1
}{
2
}
\
pi
y
),\\
l
(
x
,
y
)
&=
\
tfrac
{
1
}{
2
}
\
pi
^
2
\
cos
(\
tfrac
{
1
}{
2
}
\
pi
x
)
\
cos
(\
tfrac
{
1
}{
2
}
\
pi
y
),\\
\
lambda
(\
mu
)
&=
\
theta_0
(\
mu
)
\
lambda_0
+
\
theta_1
(\
mu
)
\
lambda_1
,\\
\
theta_0
(\
mu
)
&=
1.1
+
sin
(\
mu_0
)\
mu_1
,\\
\
theta_1
(\
mu
)
&=
1.1
+
sin
(\
mu_1
),\\
\
theta_0
(\
mu
)
&=
1.1
+
\
sin
(\
mu_0
)\
mu_1
,\\
\
theta_1
(\
mu
)
&=
1.1
+
\
sin
(\
mu_1
),\\
\
lambda_0
&=
\
chi_
{\
Omega
\
backslash
\
omega
},\\
\
lambda_1
&=
\
chi_
\
omega
,\\
\
omega
&:=
[\
tfrac
{
2
}{
3
},
\
tfrac
{
1
}{
3
}]^
2
\
cup
([\
tfrac
{
2
}{
3
},
\
tfrac
{
1
}{
3
}]
\
times
[\
tfrac
{
1
}{
3
},
\
tfrac
{
2
}{
3
}]).
...
...
@@ 102,7 +102,7 @@ equation. Moreover, we consider the linear objective functional
where
:
math
:`\
theta_
{\
mathcal
{
J
}}(\
mu
)
:=
1
+
\
frac
{
1
}{
5
}(\
mu_0
+
\
mu_1
)`.
With
this
data
,
we
can
construct
a
\

StationaryProblem
\

in
pyMOR
.
With
this
data
,
we
can
construct
a

StationaryProblem

in
pyMOR
.
..
jupyter

execute
::
...
...
@@ 134,15 +134,15 @@ With this data, we can construct a \StationaryProblem\ in pyMOR.
problem
=
StationaryProblem
(
domain
,
f
,
diffusion
,
outputs
=[(
'l2'
,
f
*
theta_J
)])
pyMOR
supports
to
choose
an
output
in
\

StationaryProblem
\
.
pyMOR
supports
to
choose
an
output
in

StationaryProblem
.
So
far
:
math
:`
L
^
2
`
and
:
math
:`
L
^
2
`
boundary
integrals
over
:
math
:`
u_
\
mu
`,
multiplied
by
an
arbitrary
\

Function
\
,
integrals
over
:
math
:`
u_
\
mu
`,
multiplied
by
an
arbitrary

Function
,
are
supported
.
These
outputs
can
also
be
handled
by
the
discretizer
.
In
our
case
,
we
make
use
of
the
:
math
:`
L
^
2
`
output
and
multiply
it
by
the
term
:
math
:`\
theta_
\
mu
l_
\
mu
`.
We
now
use
the
standard
builtin
discretization
tool
(
see
:
doc
:`
tutorial_builtin_discretizer
`)
to
construct
a
full
order
\

StationaryModel
\
.
Since
we
intend
to
use
a
fixed
to
construct
a
full
order

StationaryModel
.
Since
we
intend
to
use
a
fixed
energy
norm
..
math
::
\\,.\
_
{\
bar
{\
mu
}}
:
=
a_
{\,\
bar
{\
mu
}}(.,.),
...
...
@@ 160,16 +160,15 @@ we also define :math:`\bar{\mu}`, which we parse via the argument
In
case
,
you
need
an
output
functional
that
can
not
be
defined
in
the
\

StationaryProblem
\
,
you
can
also
directly
define
the
``
output_functional
``
in
the
\

StationaryModel
\
.

StationaryProblem
,
we
can
also
directly
define
the
``
output_functional
``
in
the

StationaryModel
.
..
jupyter

execute
::
output_functional
=
fom
.
rhs
.
H
*
theta_J
fom
=
fom
.
with_
(
output_functional
=
output_functional
)
To
overcome
that
pyMORs
outputs
return
a
\
NumpyVectorArray
\,
we
have
to
define
a
function
that
returns
NumPy
arrays
instead
.
We
now
define
a
function
that
can
be
used
by
the
minimizer
below
.
..
jupyter

execute
::
...
...
@@ 184,7 +183,7 @@ which in our case is :math:`\mu_0 = (0.25,0.5)`.
initial_guess
=
fom
.
parameters
.
parse
([
0.25
,
0.5
])
Next
,
we
visualize
the
diffusion
function
:
math
:`\
lambda_
\
mu
`
by
using
\

InterpolationOperator
\

for
interpolating
it
on
the
grid
.

InterpolationOperator

for
interpolating
it
on
the
grid
.
..
jupyter

execute
::
...
...
@@ 315,7 +314,7 @@ It is optional to give an expression for the gradient of the objective
functional
to
the
``
minimize
``
function
.
In
case
no
gradient
is
given
,
``
minimize
``
just
approximates
the
gradient
with
finite
differences
.
This
is
not
recommended
because
the
gradient
is
inexact
and
the
computation
of
finite
difference
requires
even
more
evalu
t
ations
of
the
computation
of
finite
difference
s
requires
even
more
evaluations
of
the
primal
equation
.
We
anyway
start
with
this
approach
.
..
jupyter

execute
::
...
...
@@ 360,9 +359,9 @@ Optimizing with the ROM using finite differences
We
can
use
a
standard
RB
method
to
build
a
surrogate
model
for
the
FOM
.
As
a
result
,
the
solution
of
the
primal
equation
is
no
longer
expensive
and
the
optimization
method
has
the
chance
to
converge
faster
.
For
this
,
we
define
a
standard
``
r
eductor
``
and
use
the
``
MinThetaParameterFunctional
``
for
an
estimation
of
the
coerciviy
and
the
optimization
method
can
evaluate
the
objective
functional
quickly
.
For
this
,
we
define
a
standard

CoerciveRBR
eductor

and
use
the

MinThetaParameterFunctional

for
an
estimation
of
the
coerciviy
constant
.
..
jupyter

execute
::
...
...
@@ 495,7 +494,7 @@ the objective functional is the number of evaluations of the objective
functional
.
In
the
FOM
example
from
above
we
saw
that
:
math
:`
48

9
=
39
`
evaluations
of
the
model
were
only
due
to
the
computation
of
the
finite
differences
.
If
the
problem
is
more
complex
and
the
mesh
is
finer
,
this
can
lead
us
in
to
a
serious
waste
of
and
the
mesh
is
finer
,
this
can
lead
to
a
serious
waste
of
computational
time
.
Also
from
an
optimizational
point
of
view
it
is
always
better
to
compute
the
true
gradient
of
the
objective
functional
.
...
...
@@ 523,7 +522,7 @@ solve another equation: Find :math:`d_{\mu_i} u_{\mu} \in V`, such that
where
:
math
:`
r_
\
mu
^{\
text
{
pr
}}`
denotes
the
residual
of
the
primal
equation
.
A
major
issue
of
this
approach
is
that
the
computation
of
the
full
gradient
requires
:
math
:`
P
`
solutions
of
:
raw

latex
:`\
eqref
{
sens
}`.
full
gradient
requires
:
math
:`
P
`
solutions
of
:
math
:`\
eqref
{
sens
}`.
Especially
for
high
dimensional
parameter
spaces
,
we
can
instead
use
the
adjoint
approach
to
reduce
the
computational
cost
to
only
one
solution
of
an
additional
problem
.
...
...
@@ 656,7 +655,7 @@ MOR methods in the context of optimization.
Breaking
the
traditional
offline
/
online
splitting
:
enrich
along
the
path
of
optimization

We
already
figured
that
the
main
drawback
for
using
RB
methods
in
the
We
already
figured
out
that
the
main
drawback
for
using
RB
methods
in
the
context
of
optimization
is
the
expensive
offline
time
to
build
the
surrogate
model
.
In
the
example
above
,
we
overcame
this
issue
by
choosing
a
very
high
tolerance
``
atol
``.
As
a
result
,
we
can
not
be
sure
...
...
@@ 666,9 +665,10 @@ face the danger of reducing with a bad surrogate for the whole parameter
space
.
Thinking
about
this
issue
again
,
it
is
important
to
notice
that
we
are
solving
an
optimization
problem
which
will
eventually
converge
to
a
certain
parameter
.
Thus
,
it
only
matters
that
the
surrogate
is
good
in
this
particular
reason
as
long
as
we
are
able
to
arrive
at
it
.
This
gives
hope
that
there
must
exists
a
more
efficient
way
of
using
RB
methods
without
trying
to
approximate
the
whole
parameter
space
.
this
particular
region
as
long
as
we
are
able
to
arrive
at
it
.
This
gives
hope
that
there
must
exist
a
more
efficient
way
of
using
RB
methods
without
trying
to
approximate
the
FOM
across
the
whole
parameter
space
.
One
possible
way
for
advanced
RB
methods
is
a
reduction
along
the
path
of
optimization
.
The
idea
is
,
that
we
start
with
an
empty
basis
and
only
...
...
@@ 738,17 +738,17 @@ the basis along the path of optimization.
The
computational
time
looks
at
least
better
than
the
FOM
optimization
and
we
are
very
close
to
the
reference
parameter
saved
some
computational
time
.
But
we
are
following
the
exact
same
path
than
the
FOM
and
thus
we
need
to
solve
the
FOM
model
as
often
as
before
.
The
only
time
that
we
safe
is
the
one
for
the
dual
solution
which
we
compute
with
the
ROM
instead
.
and
we
are
very
close
to
the
reference
parameter
.
But
we
are
following
the
exact
same
path
than
the
FOM
and
thus
we
need
to
solve
the
FOM
model
as
often
as
before
(
due
to
the
enrichments
).
The
only
time
that
we
safe
is
the
one
for
the
dual
solution
which
we
compute
with
the
ROM
instead
.
Adaptively
enriching
along
the
path

This
makes
us
think
about
another
idea
where
we
only
enrich
if
it
is
nec
c
essary
.
For
example
it
could
be
that
the
model
is
already
good
at
necessary
.
For
example
it
could
be
the
case
that
the
model
is
already
good
at
the
next
iteration
,
which
we
can
easily
check
by
evaluating
the
standard
error
estimator
which
is
also
used
in
the
greedy
algorithm
.
In
the
next
example
we
will
implement
this
adaptive
way
of
enriching
and
set
a
...
...
@@ 856,7 +856,7 @@ This notebook has shown several aspects on how to use RB methods for
reducing
a
FOM
for
an
optimization
problem
.
One
main
result
from
this
was
that
standard
RB
methods
can
help
to
reduce
the
computational
time
.
Thus
,
standard
RB
methods
are
especially
of
interest
if
an
optimization
problem
might
need
to
solved
multiple
times
.
problem
might
need
to
be
solved
multiple
times
.
However
,
for
only
a
single
optimization
routine
,
their
expensive
offline
time
might
make
them
unfavorable
because
they
lack
overall
efficiency
.
...
...
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
.
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment