def solver(self,
opt,
ic,
start,
end,
Tn,
algorithm='scipy_lbfgs',
options=None):
h = self.mesh.hmax()
def J(x):
loc_opt, loc_ic = self.get_opt(x, opt, ic, 1)
U = self.PDE_solver(loc_ic, loc_opt, start, end, Tn)
return self.J(loc_opt, loc_ic, U, start, end)
def grad_J(x):
loc_opt, loc_ic = self.get_opt(x, opt, ic, 1)
P = self.adjoint_solver(loc_ic, loc_opt, start, end, Tn)
return self.grad_J(P, loc_opt, loc_ic, h)
control0 = self.get_control(opt, ic, 1)
if algorithm == 'my_lbfgs':
control0 = SimpleVector(control0)
self.update_lbfgs_options(options)
solver = Lbfgs(J, grad_J, control0, options=self.Lbfgs_options)
res = solver.solve()
elif algorithm == 'scipy_lbfgs':
res = Mini(J,
control0.copy(),
method='L-BFGS-B',
jac=grad_J,
options={
'gtol': 1e-5,
'disp': True
})
elif algorithm == 'my_steepest_decent':
self.update_SD_options(options)
SDopt = self.SD_options
Solver = SteepestDecent(J, grad_J, control0.copy(), options=SDopt)
res = Solver.solve()
return res
def solve(self,N,x0=None,Lbfgs_options=None,algorithm='my_lbfgs'):
"""
Solve the optimazation problem without penalty
Arguments:
* N: number of discritization points
* x0: initial guess for control
* Lbfgs_options: same as for class initialisation
"""
self.t = np.linspace(0,self.T,N+1)
dt=float(self.T)/N
if x0==None:
x0 = self.initial_control(N)# np.zeros(N+1)
if algorithm=='my_lbfgs':
x0 = self.Vec(x0)
initial_counter = self.counter.copy()
def J(u):
self.counter[0]+=1
return self.Functional(u,N)
def grad_J(u):
self.counter[1]+=1
#l = self.adjoint_solver(u,N)
return self.Gradient(u,N)#grad_J(u,l,dt)
if algorithm=='my_lbfgs':
self.update_Lbfgs_options(Lbfgs_options)
#solver = Lbfgs(J,grad_J,x0,options=self.Lbfgs_options)
solver=SplitLbfgs(J,grad_J,x0.array(),
options=self.Lbfgs_options)
#res = solver.solve()
res = solver.normal_solve()
elif algorithm=='my_steepest_decent':
self.update_SD_options(Lbfgs_options)
SDopt = self.SD_options
Solver = SteepestDecent(J,grad_J,x0.copy(),
options=SDopt)
res = Solver.solve()
import matplotlib.pyplot as plt
#Y = self.ODE_solver(res.x,N)
#plt.plot(Y)
#plt.show()
res.add_FuncGradCounter(self.counter-initial_counter)
return res
def penalty_solver(self,opt,ic,start,end,Tn,m,mu_list,
algorithm='scipy_lbfgs',options=None):
h = self.h
X = Function(self.V)
xN = self.xN
control0 = self.get_control(opt,ic,m)
if algorithm=='my_lbfgs':
control0 = SimpleVector(control0)
res =[]
for k in range(len(mu_list)):
J,grad_J = self.create_reduced_penalty_j(opt,ic,start,end,Tn,m,mu_list[k])
if algorithm == 'my_steepest_decent':
self.update_SD_options(options)
SDopt = self.SD_options
Solver = SteepestDecent(J,grad_J,control0.copy(),
options=SDopt)
res1 = Solver.solve()
control0 = res1.x.copy()
else:
self.update_lbfgs_options(options)
if algorithm=='my_lbfgs':
solver = Lbfgs(J,grad_J,control0,options=self.Lbfgs_options)
res1 = solver.solve()
control0 = res1['control'].copy()
elif algorithm=='scipy_lbfgs':
res1 = Mini(J,control0.copy(),method='L-BFGS-B',jac=grad_J,
options={'gtol':1e-6, 'disp':True,'maxcor':10})
control0 = res1.x.copy()
res.append(res1)
if len(res)==1:
return res[0]
return res
def scaled_PPCSDsolve(self,
N,
m,
my_list,
tol_list=None,
x0=None,
options=None):
dt = float(self.T) / N
if x0 == None:
x0 = np.zeros(N + m)
result = []
PPC = self.PC_maker2(N, m, step=1)
initial_counter = self.counter.copy()
for i in range(len(my_list)):
J, grad_J = self.generate_reduced_penalty(dt, N, m, my_list[i])
self.update_SD_options(options)
SDopt = self.SD_options
Solver = SteepestDecent(J,
grad_J,
x0,
scale={'m': m},
options=SDopt)
res = Solver.PPC_solve(PPC)
print res.x[N + 1:]
res.rescale()
print res.x[N + 1:]
x0 = res.x
result.append(res)
res.add_FuncGradCounter(self.counter - initial_counter)
if len(result) == 1:
#y,Y = self.ODE_penalty_solver(x0,N,m)
#import matplotlib.pyplot as plt
#plt.plot(Y)
#plt.show()
return res
else:
return result
def solve(self,N,x0=None,Lbfgs_options=None,algorithm='my_lbfgs'):
"""
Solve the optimazation problem without penalty
Arguments:
* N: number of discritization points
* x0: initial guess for control
* Lbfgs_options: same as for class initialisation
"""
dt=float(self.T)/N
if x0==None:
x0 = np.zeros(N+1)
if algorithm=='my_lbfgs':
x0 = self.Vec(x0)
def J(u):
return self.Functional(u,N)
def grad_J(u):
l = self.adjoint_solver(u,N)
return self.grad_J(u,l,dt)
if algorithm=='my_lbfgs':
self.update_Lbfgs_options(Lbfgs_options)
solver = Lbfgs(J,grad_J,x0,options=self.Lbfgs_options)
res = solver.solve()
elif algorithm=='my_steepest_decent':
self.update_SD_options(Lbfgs_options)
SDopt = self.SD_options
Solver = SteepestDecent(J,grad_J,x0.copy(),
options=SDopt)
res = Solver.solve()
import matplotlib.pyplot as plt
#Y = self.ODE_solver(res.x,N)
#plt.plot(Y)
#plt.show()
return res
def solver(self,opt,ic,start,end,Tn,algorithm='scipy_lbfgs',
options=None):
h = self.mesh.hmax()
def J(x):
loc_opt,loc_ic = self.get_opt(x,opt,ic,1)
U = self.PDE_solver(loc_ic,loc_opt,start,end,Tn)
return self.J(loc_opt,loc_ic,U,start,end)
def grad_J(x):
loc_opt,loc_ic = self.get_opt(x,opt,ic,1)
P = self.adjoint_solver(loc_ic,loc_opt,start,end,Tn)
return self.grad_J(P,loc_opt,loc_ic,h)
control0 = self.get_control(opt,ic,1)
if algorithm=='my_lbfgs':
control0 = SimpleVector(control0)
self.update_lbfgs_options(options)
solver = Lbfgs(J,grad_J,control0,options=self.Lbfgs_options)
res = solver.solve()
elif algorithm=='scipy_lbfgs':
res = Mini(J,control0.copy(),method='L-BFGS-B',
jac=grad_J,options={'gtol': 1e-5, 'disp': True})
elif algorithm=='my_steepest_decent':
self.update_SD_options(options)
SDopt = self.SD_options
Solver = SteepestDecent(J,grad_J,control0.copy(),options=SDopt)
res = Solver.solve()
return res
def alternate_direction_penalty_solve(self,N,m,my_list,tol_list=None,x0=None,Lbfgs_options=None,algorithm='my_lbfgs',ppc=None):
self.t,self.T_z = self.decompose_time(N,m)
dt=float(self.T)/N
if x0==None:
x0 = self.initial_control(N,m=m)#np.zeros(N+m)
x = None
#if algorithm=='my_lbfgs':
#x0 = self.Vec(x0)
Result = []
initial_counter = self.counter.copy()
import matplotlib.pyplot as plt
for i in range(len(my_list)):
def J(u):
self.counter[0]+=1
return self.Penalty_Functional(u,N,m,my_list[i])
def grad_J(u):
self.counter[1]+=1
return self.Penalty_Gradient(u,N,m,my_list[i])
J_lam = lambda u2: J(np.hstack((x0[:N+1],u2)))
if ppc==None:
grad_lam = lambda u2: grad_J(np.hstack((x0[:N+1],u2)))[N+1:]
else:
grad_lam = lambda u2: ppc(grad_J(np.hstack((x0[:N+1],u2)))[N+1:])
self.update_SD_options(Lbfgs_options)
SDopt = self.SD_options
Solver =SteepestDecent(J_lam,grad_lam,x0.copy()[N+1:],options=SDopt)
lam_res = Solver.solve()
#x0[N+1:]=lam_res.x[:]
J_v = lambda u3 : J(np.hstack((u3,x0[N+1:])))
grad_v= lambda u3 : grad_J(np.hstack((u3,x0[N+1:])))[:N+1]
Solver = SteepestDecent(J_v,grad_v,x0.copy()[:N+1],options=SDopt)
v_res = Solver.solve()
x0[N+1:]=lam_res.x[:]
x0[:N+1]= v_res.x[:]
plt.plot(x0[N+1:])
plt.show()
v_res.add_FuncGradCounter(self.counter-initial_counter)
lam_res.add_FuncGradCounter(self.counter-initial_counter)
res = [lam_res,v_res,x0]
return res
def alternate_direction_penalty_solve(self,
N,
m,
my_list,
tol_list=None,
x0=None,
Lbfgs_options=None,
algorithm='my_lbfgs',
ppc=None):
self.t, self.T_z = self.decompose_time(N, m)
dt = float(self.T) / N
if x0 == None:
x0 = self.initial_control(N, m=m) #np.zeros(N+m)
x = None
#if algorithm=='my_lbfgs':
#x0 = self.Vec(x0)
Result = []
initial_counter = self.counter.copy()
for i in range(len(my_list)):
def J(u):
self.counter[0] += 1
return self.Penalty_Functional(u, N, m, my_list[i])
def grad_J(u):
self.counter[1] += 1
return self.Penalty_Gradient(u, N, m, my_list[i])
J_lam = lambda u2: J(np.hstack((x0[:N + 1], u2)))
if ppc == None:
grad_lam = lambda u2: grad_J(np.hstack(
(x0[:N + 1], u2)))[N + 1:]
else:
grad_lam = lambda u2: ppc(
grad_J(np.hstack((x0[:N + 1], u2)))[N + 1:])
self.update_SD_options(Lbfgs_options)
SDopt = self.SD_options
Solver = SteepestDecent(J_lam,
grad_lam,
x0.copy()[N + 1:],
options=SDopt)
lam_res = Solver.solve()
x0[N + 1:] = lam_res.x[:]
x2 = self.partition_control(x0[:N + 1], N, m)
v_res = []
v_x = []
##########i=0################
Ji = lambda v: self.alternate_Penalty_Functional(
v, self.y0, x0[N + 1], N, m, my_list[i], 0)
grad_Ji = lambda v: self.alternate_Penalty_Gradient(
v, self.y0, x0[N + 1], N, m, my_list[i], 0)
Solver = SteepestDecent(Ji, grad_Ji, x2[0].copy(), options=SDopt)
#print Ji(x2[0])
print 0
v_res.append(Solver.solve())
v_x.append(Solver.solve().x)
############i=2,..,m-1######################
for j in range(1, m - 1):
Ji = lambda v: self.alternate_Penalty_Functional(
v, x0[N + 1], x0[N + 1 + j], N, m, my_list[i], j)
grad_Ji = lambda v: self.alternate_Penalty_Gradient(
v, x0[N + 1], x0[N + 1 + j], N, m, my_list[i], j)
print j
Solver = SteepestDecent(Ji,
grad_Ji,
x2[j].copy(),
options=SDopt)
v_res.append(Solver.solve())
v_x.append(Solver.solve().x)
################i=m################
Ji = lambda v: self.alternate_Penalty_Functional(
v, x0[-1], self.yT, N, m, 1, m - 1)
grad_Ji = lambda v: self.alternate_Penalty_Gradient(
v, x0[-1], self.yT, N, m, 1, m - 1)
print m - 1
Solver = SteepestDecent(Ji, grad_Ji, x2[-1].copy(), options=SDopt)
v_res.append(Solver.solve())
v_x.append(Solver.solve().x)
#################end################
v_gather = self.explicit_gather(v_x, N, m)
x0[:N + 1] = v_gather[:]
#x0[N+1:]=lam_res.x[:]
plt.plot(x0[N + 1:])
plt.show()
#v_res.add_FuncGradCounter(self.counter-initial_counter)
lam_res.add_FuncGradCounter(self.counter - initial_counter)
res = [lam_res, v_res, x0]
return res
a = 0.9
yT = 5
alpha = 0.5
N = 500
m = 10
mu = 1
mu_list = [1, 10]
opt = {'maxiter': 500}
problem = Problem3(y0, yT, T, a, alpha, J, grad_J)
res1 = problem.penalty_solve(N, m, mu_list, algorithm='my_steepest_decent')
JJ, grad_JJ = problem.generate_reduced_penalty(1. / 500, N, m, mu)
x0 = np.zeros(N + m)
x0[N + 1:] = 0
solver2 = SteepestDecent(JJ, grad_JJ, x0, options=opt, scale={'m': m})
res2 = solver2.solve()
solver3 = SteepestDecent(JJ, grad_JJ, x0, options=opt)
#res3 = solver3.solve()
res3 = problem.penalty_solve(N,
m,
mu_list,
algorithm='my_steepest_decent',
scale=True)
#print res1.niter,res2.niter,res3.niter
for i in range(len(mu_list)):
print res1[i].niter, res3[i].niter
plt.figure()
plt.plot(res1[-1].x[N + 1:], '>r')
#plt.plot(res2.x[N+1:],'b--')
T = 1
y0 = 1
a = 1
yT = 3
alpha = 0.5
N = 500
m = 10
mu = 1
opt = {'maxiter':100}
problem = Problem3(y0,yT,T,a,alpha,J,grad_J)
res1=problem.penalty_solve(N,m,[mu],algorithm='my_steepest_decent')
JJ,grad_JJ = problem.generate_reduced_penalty(1./500,N,m,mu)
solver2 = SteepestDecent(JJ,grad_JJ,np.zeros(N+m)+1,
options=opt,scale={'m':m})
res2 = solver2.solve()
solver3 = SteepestDecent(JJ,grad_JJ,np.zeros(N+m)+1,options=opt)
res3 = solver3.solve()
print res1.niter,res2.niter,res3.niter
plt.plot(res1.x[N+1:],'>r')
plt.plot(res2.x[N+1:],'b--')
plt.plot(res3.x[N+1:])
plt.plot(res2.x[N+1:]*res2.scaler.gamma)
plt.show()
def penalty_solver(self,
opt,
ic,
start,
end,
Tn,
m,
mu_list,
algorithm='scipy_lbfgs',
options=None):
h = self.h
X = Function(self.V)
xN = self.xN
control0 = self.get_control(opt, ic, m)
if algorithm == 'my_lbfgs':
control0 = SimpleVector(control0)
res = []
for k in range(len(mu_list)):
J, grad_J = self.create_reduced_penalty_j(opt, ic, start, end, Tn,
m, mu_list[k])
if algorithm == 'my_steepest_decent':
self.update_SD_options(options)
SDopt = self.SD_options
Solver = SteepestDecent(J,
grad_J,
control0.copy(),
options=SDopt)
res1 = Solver.solve()
control0 = res1.x.copy()
else:
self.update_lbfgs_options(options)
if algorithm == 'my_lbfgs':
solver = Lbfgs(J,
grad_J,
control0,
options=self.Lbfgs_options)
res1 = solver.solve()
control0 = res1['control'].copy()
elif algorithm == 'scipy_lbfgs':
res1 = Mini(J,
control0.copy(),
method='L-BFGS-B',
jac=grad_J,
options={
'gtol': 1e-6,
'disp': True,
'maxcor': 10
})
control0 = res1.x.copy()
res.append(res1)
if len(res) == 1:
return res[0]
return res
def penalty_solve(self,N,m,my_list,tol_list=None,x0=None,Lbfgs_options=None,algorithm='my_lbfgs',scale=False):
"""
Solve the optimazation problem with penalty
Arguments:
* N: number of discritization points
* m: number ot processes
* my_list: list of penalty variables, that we want to solve the problem
for.
* x0: initial guess for control
* options: same as for class initialisation
"""
self.t,self.T_z = self.decompose_time(N,m)
dt=float(self.T)/N
if x0==None:
x0 = self.initial_control(N,m=m)#np.zeros(N+m)
x = None
if algorithm=='my_lbfgs':
x0 = self.Vec(x0)
Result = []
initial_counter = self.counter.copy()
for i in range(len(my_list)):
#"""
def J(u):
self.counter[0]+=1
return self.Penalty_Functional(u,N,m,my_list[i])
def grad_J(u):
self.counter[1]+=1
return self.Penalty_Gradient(u,N,m,my_list[i])
#"""
#J,grad_J = self.generate_reduced_penalty(dt,N,m,my_list[i])
if algorithm=='my_lbfgs':
self.update_Lbfgs_options(Lbfgs_options)
if tol_list!=None:
try:
opt = {'jtol':tol_list[i]}
self.update_Lbfgs_options(opt)
except:
print 'no good tol_list'
if scale:
scaler={'m':m,'factor':self.Lbfgs_options['scale_factor']}
#solver = Lbfgs(J,grad_J,x0,options=self.Lbfgs_options,scale=scaler)
solver = SplitLbfgs(J,grad_J,x0.array(),options=self.Lbfgs_options,scale=scaler)
else:
#solver = Lbfgs(J,grad_J,x0,options=self.Lbfgs_options)
solver = SplitLbfgs(J,grad_J,x0.array(),m=m,options=self.Lbfgs_options)
#res = solver.solve()
res = solver.normal_solve()
x0 = res['control']
#print J(x0.array())
elif algorithm=='my_steepest_decent':
self.update_SD_options(Lbfgs_options)
SDopt = self.SD_options
if scale:
scale = {'m':m,'factor':SDopt['scale_factor']}
Solver = SteepestDecent(J,grad_J,x0.copy(),
options=SDopt,scale=scale)
res = Solver.solve()
res.rescale()
else:
Solver = PPCSteepestDecent(J,grad_J,x0.copy(),
lambda x: x,options=SDopt)
res = Solver.split_solve(m)
x0 = res.x.copy()
elif algorithm=='slow_steepest_decent':
self.update_SD_options(Lbfgs_options)
SDopt = self.SD_options
Solver = SteepestDecent(J,grad_J,x0.copy(),
options=SDopt)
res = Solver.solve()
x0 = res.x.copy()
elif algorithm == 'split_lbfgs':
self.update_Lbfgs_options(Lbfgs_options)
Solver = SplitLbfgs(J,grad_J,x0,m,options=self.Lbfgs_options)
res = Solver.solve()
x0 = res.x.copy()
res.jump_diff=self.jump_diff
Result.append(res)
print 'jump diff:',self.jump_diff
res.add_FuncGradCounter(self.counter-initial_counter)
if len(Result)==1:
return res
else:
return Result
