def PyAdolc_dvLJ(x):
adolc.trace_on(0)
ad_x = adolc.adouble(np.zeros(np.shape(np.ravel(x)),dtype=float))
adolc.independent(ad_x)
ad_y = Adolc_vLJ(ad_x)
adolc.dependent(ad_y)
adolc.trace_off()
return adolc.gradient(0, np.ravel(x))
def pCostpW_adolc(self, W, p_target):
tag = self.pCostpW_tag
if not self.pCostpW_traced:
aW = adouble(W.flatten(order='F'))
ap = adouble(p_target)
adolc.trace_on(tag)
adolc.independent(aW)
aW3 = np.reshape(aW, W.shape, order='F')
acost = cost.inverse_pressure_design(aW3, ap)
adolc.dependent(acost)
adolc.trace_off()
return adolc.gradient(self.pCostpW_tag, W.flatten(order='F'))
def PyAdolc_dvLJ_for_Optimize(x):
return adolc.gradient(0, x)
t0 = 0.0
tf = 1.0
conp = [ 1.0, 1.0 ]
adolc.trace_on(tag_full)
con = adolc.as_adouble(conp)
for c in con:
c.declareIndependent()
y = con
ynew = adolc.as_adouble([ 0.0, 0.0 ])
for i in range(steps):
euler_step_act(n,y,m,ynew)
y = ynew
f = y[0] + y[1]
f.declareDependent()
adolc.trace_off()
grad = adolc.gradient(tag_full,conp)
print(" full taping:\n gradient=(",grad[0],", ",grad[1],")\n\n")
# now taping external function
adolc.trace_on(tag_ext_fct)
con = adolc.as_adouble(conp)
for c in con:
c.declareIndependent()
y = con
ynew = adolc.as_adouble([ 0.0, 0.0 ])
euler_step_act(2,y,2,ynew)
for c in ynew:
c.declareDependent()
adolc.trace_off()
edf = euler_step_edf(tag_ext_fct)
def gradient(self,x):
return adolc.gradient(self.tape_number,
np.ravel(x)).reshape(x.shape)
def A_gradA_taped(self, XP):
return adolc.function(self.adolcID,
XP), adolc.gradient(self.adolcID, XP)
def __call__(self, x):
return adolc.gradient(self.id, x)
adolc.independent(x)
y = f(x)
adolc.dependent(y)
adolc.trace_off()
# point at which the derivatives should be evaluated
x = random((N,D))
print('\n\n')
print('Sympy function = function check (should be almost zero)')
print(f(x) - sym_f(x))
print('\n\n')
print('Sympy vs Hand Derived Gradient check (should be almost zero)')
print(df(x) - sym_df(x))
print('Sympy vs Ad Derived Gradient check (should be almost zero)')
print(adolc.gradient(0, numpy.ravel(x)).reshape(x.shape) - sym_df(x))
print('\n\n')
print('Sympy vs Hand Derived Hessian check (should be almost zero)')
print(ddf(x) - sym_ddf(x))
print('Sympy vs Ad Derive Hessian check (should be almost zero)')
print(adolc.hessian(0, numpy.ravel(x)).reshape(x.shape + x.shape) - sym_ddf(x))
def eval_grad_f(x, user_data=None):
return adolc.gradient(fID,x)
def grLLadolc(x):
return adolc.gradient(1, x)
## PyADOLC taping
start_time = time()
ax = numpy.array([adolc.adouble(0.0) for i in range(N)])
adolc.trace_on(0)
for n in range(N):
ax[n].is_independent(x[n])
ay = f(ax)
adolc.depends_on(ay)
adolc.trace_off()
end_time = time()
adolc_tape_times.append(end_time - start_time)
## PyADOLC gradient
start_time = time()
adolc_g = adolc.gradient(0, x)
end_time = time()
adolc_gradient_times.append(end_time - start_time)
### check that both derivatives give the same result
# print 'difference between forward and reverse gradient computation', numpy.linalg.norm(g_forward - g_reverse)
# print 'difference between forward and reverse gradient2 computation', numpy.linalg.norm(g_forward - g_reverse2)
# print 'difference between Algopy and PyAdolc', numpy.linalg.norm(adolc_g - g_reverse2)
import pylab
function_plot = pylab.loglog(Ns, function_eval_times, "r.")
forward_plot = pylab.loglog(Ns, forward_eval_times, "b.")
taperev_plot = pylab.loglog(Ns, tape_rev_eval_times, "r^")
tape_plot = pylab.loglog(Ns, tape_eval_times, "b^")
def alglib_func(x,grad,p):
grad[:] = adolc.gradient(adolcID,x)
return adolc.function(adolcID,x)
def _adolc_grad(self, x, **kwargs):
"Evaluate the objective gradient from the ADOL-C tape."
return adolc.gradient(self._obj_trace_id, x)
def gradA_taped(self, XP):
return adolc.gradient(self.adolcID, XP)
def eval_grad_f_adolc(x, user_data=None):
return adolc.gradient(1, x)
def evaluateCostGradient(self, grad_f, x):
agrad_f = adolc.gradient(1, x)
np.copyto(grad_f, agrad_f)
def _adolc_grad(self, x, **kwargs):
"""Evaluate the objective gradient."""
return adolc.gradient(self._obj_trace_id, x)
def gradA_taped(self, XP, user_data=None):
return adolc.gradient(self.adolcID, XP)
def gradient(self, x):
return adolc.gradient(0,x)
## PyADOLC taping
start_time = time()
ax = numpy.array([adolc.adouble(0.) for i in range(N)])
adolc.trace_on(0)
for n in range(N):
ax[n].is_independent(x[n])
ay = f(ax)
adolc.depends_on(ay)
adolc.trace_off()
end_time = time()
adolc_tape_times.append(end_time - start_time)
## PyADOLC gradient
start_time = time()
adolc_g = adolc.gradient(0, x)
end_time = time()
adolc_gradient_times.append(end_time - start_time)
### check that both derivatives give the same result
#print 'difference between forward and reverse gradient computation', numpy.linalg.norm(g_forward - g_reverse)
#print 'difference between forward and reverse gradient2 computation', numpy.linalg.norm(g_forward - g_reverse2)
#print 'difference between Algopy and PyAdolc', numpy.linalg.norm(adolc_g - g_reverse2)
import pylab
function_plot = pylab.loglog(Ns, function_eval_times, 'r.')
forward_plot = pylab.loglog(Ns, forward_eval_times, 'b.')
taperev_plot = pylab.loglog(Ns, tape_rev_eval_times, 'r^')
tape_plot = pylab.loglog(Ns, tape_eval_times, 'b^')
rev_plot = pylab.loglog(Ns, rev_eval_times, 'cs')
import numpy
import math
import adolc
# tape a function evaluation
ax = numpy.array([adolc.adouble(0.) for n in range(2)])
# ay = adolc.adouble(0)
adolc.trace_on(13)
adolc.independent(ax)
ay = numpy.sin(ax[0] + ax[1]*ax[0])
adolc.dependent(ay)
adolc.trace_off()
x = numpy.array([3., 7.])
y = numpy.zeros(1)
adolc.tape_to_latex(13, x, y)
y = adolc.function(13, x)
g = adolc.gradient(13, x)
J = adolc.jacobian(13, x)
print('function y=', y)
print('gradient g=', g)
print('Jacobian J=', J)
adolc.independent(x) y = f(x) adolc.dependent(y) adolc.trace_off() # point at which the derivatives should be evaluated x = random((N,D)) print '\n\n' print 'Sympy function = function check (should be almost zero)' print f(x) - sym_f(x) print '\n\n' print 'Sympy vs Hand Derived Gradient check (should be almost zero)' print df(x) - sym_df(x) print 'Sympy vs Ad Derived Gradient check (should be almost zero)' print adolc.gradient(0, numpy.ravel(x)).reshape(x.shape) - sym_df(x) print '\n\n' print 'Sympy vs Hand Derived Hessian check (should be almost zero)' print ddf(x) - sym_ddf(x) print 'Sympy vs Ad Derive Hessian check (should be almost zero)' print adolc.hessian(0, numpy.ravel(x)).reshape(x.shape + x.shape) - sym_ddf(x)
def eval_grad_f_adolc(x, user_data=None):
return adolc.gradient(1, x)
def grFun(x):
return adolc.gradient(1, x)
def gradient(self, x):
return adolc.gradient(0, x)
