def solver(sim):
# State variables: rho, rho*u, e
# Primitive variables: rho, u, p
# Auxiliary variables: c, mach
# Create a mesh based on given geometry
x, dx, xh, area, volume = mesh.initialize_mesh(sim.geom, sim.n_elem)
# Used initial temperature to initialize primitive variables
T = isentropic_T(sim.inlet_total_T, sim.inlet_mach, sim.gamma)
# Initialize primitive variables
p = np.linspace(sim.inlet_p, sim.outlet_p, sim.n_elem, endpoint=True)
rho = evaluate_rho(p, T, sim.R)
c = evaluate_c(p, rho, sim.gamma)
u = evaluate_u(c, sim.inlet_mach)
e = evaluate_e(rho, T, u, sim.Cv)
W = np.empty([3, sim.n_elem])
W = np.array([rho, rho * u, evaluate_e(rho, T, u, sim.Cv)])
F = np.empty_like(W)
Q = np.empty_like(W)
fluxes = np.empty([3, sim.n_elem + 1])
dt = np.empty_like(volume)
residual = np.empty_like(W)
dW = np.empty_like(W)
W = solve_steady(sim, W, dx, area)
return W
def get_potentials_labels(self, mode):
if mode == 'train':
return self.potentials_train, np.empty_like(self.potentials_train)
elif mode == 'test':
return self.potentials_test, np.empty_like(self.potentials_test)
else:
return self.potentials_valid, np.empty_like(self.potentials_valid)
def visualise_functions():
nx, ny = (100, 100)
x = np.linspace(-5, 5, nx)
y = np.linspace(-5, 5, ny)
xv, yv = np.meshgrid(x, y)
eval_convex = np.empty_like(xv)
eval_rosenbrock = np.empty_like(xv)
eval_rastrigin = np.empty_like(xv)
for i in range(nx):
for j in range(ny):
eval_convex[i, j] = convex_function([xv[i, j], yv[i, j]])
eval_rosenbrock[i, j] = rosenbrock([xv[i, j], yv[i, j]])
eval_rastrigin[i, j] = rastrigin([xv[i, j], yv[i, j]])
plt.contourf(x, y, eval_convex)
plt.colorbar()
plt.show()
plt.clf()
plt.contourf(x, y, eval_rosenbrock)
plt.colorbar()
plt.show()
plt.clf()
plt.contourf(x, y, eval_rastrigin)
plt.colorbar()
plt.show()
def repeat_to_match_shape(g, A, axis=None):
gout = np.empty_like(A)
if np.ndim(gout) == 0:
gout = g
else:
gout = np.ones_like(A) * g
return gout
def __init__(self, env, x_init, u_init):
''' Initialize the DDP solver.
'''
self.env = env
# Get number of states, controls and timesteps.
self.n_steps, self.n_u = u_init.shape
n_steps_x, self.n_x = x_init.shape
assert self.n_steps + 1 == n_steps_x, \
"Number of control steps must be one less than the number of states"
# Allocate memory for relevant variables.
self.x = x_init
self.u = u_init
self.du = np.empty_like(u_init)
self.feedback = np.empty((self.n_steps, self.n_u, self.n_x))
# Generate one-step cost derivative functions.
self.l_x = autograd.grad(env.transition_cost, 0)
self.l_u = autograd.grad(env.transition_cost, 1)
self.l_xx = autograd.jacobian(self.l_x, 0)
self.l_xu = autograd.jacobian(self.l_x, 1)
self.l_uu = autograd.jacobian(self.l_u, 1)
# Generate the final cost derivative functions.
self.l_final_x = autograd.grad(env.final_cost, 0)
self.l_final_xx = autograd.jacobian(self.l_final_x, 0)
# Generate dynamics derivative functions.
self.f_x = autograd.jacobian(env.step, 0)
self.f_u = autograd.jacobian(env.step, 1)
self.f_xx = autograd.jacobian(self.f_x, 0)
self.f_xu = autograd.jacobian(self.f_x, 1)
self.f_uu = autograd.jacobian(self.f_u, 1)
def optimize(function, method, autodiff):
eval_points_x = []
eval_points_y = []
def fill_eval_points(xk):
eval_points_x.append(xk[0])
eval_points_y.append(xk[1])
x0 = np.array([2.5, 2.5])
if autodiff:
jac = grad(function)
else:
jac = None
if method == 'shgo':
bounds = [(-10, 10), (-10.0, 10.0)]
res = shgo(function,
bounds,
callback=fill_eval_points,
options={'disp': True})
else:
res = minimize(function,
x0,
method=method,
callback=fill_eval_points,
jac=jac,
options={'disp': True})
nx, ny = (100, 100)
x = np.linspace(-5, 5, nx)
y = np.linspace(-5, 5, ny)
xv, yv = np.meshgrid(x, y)
eval_function = np.empty_like(xv)
for i in range(nx):
for j in range(ny):
eval_function[i, j] = function([xv[i, j], yv[i, j]])
print(function.__name__)
plt.clf()
plt.contourf(x, y, eval_function)
plt.plot(eval_points_x, eval_points_y, 'x-k')
plt.colorbar()
neval = res.nfev
try:
neval += res.njev
except:
print('no njev')
try:
neval += res.nhev
except:
print('no nhev')
plt.title('iterations: {} evaluations: {}'.format(res.nit, neval))
if autodiff:
ext = '-auto.pdf'
else:
ext = '.pdf'
plt.savefig(function.__name__ + '-' + method + ext)
def standardToNat( cls, pi ):
if( np.any( np.isclose( pi, 0.0 ) ) ):
n = np.empty_like( pi )
n[ ~np.isclose( pi, 0.0 ) ] = np.log( pi[ ~np.isclose( pi, 0.0 ) ] )
n[ np.isclose( pi, 0.0 ) ] = np.NINF
else:
n = np.log( pi )
return ( n, )
def placement(val):
total = totalD
ans = np.empty_like(Ds)
for i, d in enumerate(Ds):
total /= d
ans[i] = val // total
val -= (val // total) * total
return ans
def _backwardPass(self, F_x, F_u, L_x, L_u, L_xx, L_ux, L_uu):
V_x = L_x[-1]
V_xx = L_xx[-1]
k = np.empty_like(self.k)
K = np.empty_like(self.K)
for i in range(self.horizon-1,-1,-1):
Q_x, Q_u, Q_xx, Q_ux, Q_uu = self._Q(F_x[i], F_u[i], L_x[i], L_u[i], L_xx[i], L_ux[i], L_uu[i], V_x, V_xx)
k[i] = -np.linalg.solve(Q_uu, Q_u)
K[i] = -np.linalg.solve(Q_uu, Q_ux)
V_x = Q_x + K[i].T.dot(Q_uu).dot(k[i])
V_x += K[i].T.dot(Q_u) + Q_ux.T.dot(k[i])
V_xx = Q_xx + K[i].T.dot(Q_uu).dot(K[i])
V_xx += K[i].T.dot(Q_ux) + Q_ux.T.dot(K[i])
V_xx = 0.5 * (V_xx + V_xx.T)
return np.array(k), np.array(K)
def forward(self, last_cost=None, dv1=None, dv2=None, stepsize=1.):
''' The forward pass of the DDP algorithm.
'''
u_proposed = np.empty_like(self.u)
x_proposed = np.empty_like(self.x)
x_proposed[0, :] = self.x[0, :]
for i in range(self.n_steps):
# Compute the action via the control law.
x_err = x_proposed[i, :] - self.x[i, :]
u_proposed[i, :] = self.u[i, :] + \
stepsize * self.du[i, :] + \
self.feedback[i, :, :].dot(x_err)
# Evaluate the dynamics.
x_proposed[i + 1, :] = self.env.step(x_proposed[i, :],
u_proposed[i, :])
# Compute the transition cost.
cost = np.sum(self.env.transition_cost(x_proposed[:-1, :], u_proposed))
# Add the final cost and return.
cost += self.env.final_cost(x_proposed[-1, :])
# Accept if there is no prior cost.
if last_cost is None:
self.u = u_proposed
self.x = x_proposed
return cost, stepsize
# Check the linesearch termination condition.
relative_improvement = (cost - last_cost) / (stepsize * dv1 +
stepsize**2 * dv2)
if relative_improvement > .1:
# Accept the proposal.
self.u = u_proposed
self.x = x_proposed
return cost, stepsize
# Reduce the stepsize and recurse.
return self.forward(last_cost=last_cost,
dv1=dv1,
dv2=dv2,
stepsize=.5 * stepsize)
def sparsepowersum(arr, b, fact=None):
tmp = np.empty_like(arr.data)
np.exp(np.multiply(np.log(arr.data, tmp), b, tmp), tmp)
if not type(arr.indptr) == np.int64:
indptr = arr.indptr.astype(np.int64)
else:
indptr = arr.indptr
if fact is not None:
tmp *= fact
result = pointer_sum(tmp, indptr)
return result
def forwardBaseCase( self ):
ans = self.pi0
if( self.chainCuts is not None ):
if( self.chainCuts[ 0, 0 ] == 0 ):
ans = np.empty_like( self.pi0 )
ans[ : ] = np.NINF
x = self.chainCuts[ 0, 1 ]
ans[ x ] = 0.0
return ans + self.emissionProb( 0, forward=True )
def DP_inv(vec,nx):
Y = np.reshape(vec,(nx,nx))
# Y = (Y+Y.T)/2
s,U = np.linalg.eigh(Y)
s_x = np.empty_like(s)
for i in range(len(s)):
s_x[i] = np.roots([1,-s[i],-1])[np.roots([1,-s[i],-1])>0]
# print(s_x)
TT = (U @ np.diag(s_x) @ np.linalg.inv(U))
b, _ = np.linalg.eig(TT.reshape((nx, nx)))
# print(b)
return TT.reshape((nx**2,1))
def BC_outlet_residual(sim, W_g, W_d, dt, dx):
# Returns the update of the ghost vector
# W_g = Ghost state vector
# W_d = Domain state vector
#r_g = np.copy(W_g[0]) # Very important else dW_g = 0
r_g = W_g[0] # Very important else dW_g = 0
u_g = W_g[1] / r_g
p_g = evaluate_p1(W_g, sim.gamma)
c_g = evaluate_c(p_g, r_g, sim.gamma)
r_d = W_d[0]
u_d = W_d[1] / W_d[0]
p_d = evaluate_p1(W_d, sim.gamma)
c_d = evaluate_c(p_d, r_d, sim.gamma)
dtdx = dt / dx
avgu = 0.5 * (u_d + u_g)
avgc = 0.5 * (c_d + c_g)
eigenvalues0 = avgu * dtdx
eigenvalues1 = (avgu + avgc) * dtdx
eigenvalues2 = (avgu - avgc) * dtdx
dpdx = p_g - p_d
dudx = u_g - u_d
Ri0 = -eigenvalues0 * ((r_g - r_d) - dpdx / c_g**2)
Ri1 = -eigenvalues1 * (dpdx + r_g * c_g * dudx)
Ri2 = -eigenvalues2 * (dpdx - r_g * c_g * dudx)
mach_outlet = avgu / avgc
dp = 0
if mach_outlet > 1.0:
dp = 0.5 * (Ri1 + Ri2)
drho = Ri0 + dp / c_g**2
du = (Ri1 - dp) / (r_g * c_g)
u_g_new = u_g + du
r_g_new = r_g + drho
p_g_new = p_g + dp
T_g_new = p_g_new / (r_g_new * sim.R)
e_g_new = evaluate_e(r_g_new, T_g_new, u_g_new, sim.Cv)
dW_g = np.empty_like(W_g)
dW_g[0] = r_g_new - W_g[0]
dW_g[1] = r_g_new * u_g_new - W_g[1]
dW_g[2] = e_g_new - W_g[2]
return dW_g
def transitionProb( self, t, t1, forward=False ):
ans = self.pi
if( self.chainCuts is not None ):
t1Index = self.chainCuts[ :, 0 ] == t1
if( np.any( t1Index ) ):
# Here, only 1 col of transitions is possible
assert self.chainCuts[ t1Index ].size == 2
ans = np.empty_like( self.pi )
ans[ : ] = np.NINF
x1 = self.chainCuts[ t1Index, 1 ]
ans[ :, x1 ] = 0.0
return ans if forward == True else ans.T
def noise_inputs(inputs, TEMP, noise_type):
count = 0
perturbed = np.empty_like(inputs)
perturbed[:] = inputs
perturbed[perturbed == 1] = 5
perturbed[perturbed == 0] = 1
if noise_type == 2:
TEMP = 1
# [5,1,...] - softmax = [ 0.91610478, 0.01677904, ...] for 6 dim
# for each sequence time step, add gumbel noise
# as per this blog post: http://www.inference.vc/instance-noise-a-trick-for-stabilising-gan-training/
for pert in perturbed: # Iterate over time steps.
noise = npr.gumbel(loc=0.0, scale=1, size=pert.shape)
output = TEMP * (pert + noise)
perturbed[count] = output - logsumexp(output, axis=1, keepdims=True)
count = count + 1
return perturbed
def shift(x, offsets):
"""Similar to np.roll, but fills with nan instead of rolling values over.
Also shifts along multiple axes at the same time.
Args:
x: The input array to shift.
offsets: How much to shift each axis, offsets[i] is the offset for the i-th
axis.
Returns:
An array with same shape as the input, with specified shifts applied.
"""
def to_slice(offset):
return slice(offset, None) if offset >= 0 else slice(None, offset)
out = np.empty_like(x)
out.fill(np.nan)
ind_src = tuple(to_slice(-o) for o in offsets)
ind_dst = tuple(to_slice(o) for o in offsets)
out[ind_dst] = x[ind_src]
return out
