def scipy_simulate(ti_controls, sampling_times, model_parameters):
"""
The simulation function to be passed on to the pydex.designer. The function takes in
the nominal model parameter values, and experimental candidates. Returns the
predictions of the model at specified sampling times.
Parameters:
model : a Pyomo model instance
simulator : a Pyomo simulator instance
ti_controls : time-invariant controls of candidate (1D np.array)
sampling_times : sampling time choices of candidate (1D np.array)
model_parameters : nominal model parameter values (1D np.array)
Return
responses : a 2D np.array with shapes N_spt by n_r, corresponding to
the model's prediction on value of the n_r number of
responses at all N_spt number of sampling times.
"""
def scipy_model(t, ca, theta):
dca_dt = -theta[0] * ca
return dca_dt
sol = odeint(scipy_model,
args=tuple((model_parameters, )),
y0=ti_controls[0],
t=sampling_times,
tfirst=True)
return sol
def predict_time_series(param_vec, Ns, Cins, Cs, C_0s):
time_points = np.array([x * 1 for x in range(len(Ns))])
sol = odeint(sdot, N, time_points, tuple((param_vec, Cin, C, C_0)))[1:]
pred_Ns = sol[:, 0:2]
return pred_Ns
def predict(params, S, Cin):
time_diff = 2 # frame skipping
time_points = np.array([x * 1 for x in range(time_diff)])
sol = odeint(sdot, S, time_points, tuple((params, Cin)))[1:]
pred_N = sol[-1, 0:2]
return pred_N
def predict_time_series(self, params, S, Cins,
time_points): # verified working on timeseries
sol = odeint(self.sdot, S, time_points, tuple(
(params, Cins)))[:] #PUT THIS BACK FOR ONLINE
pred_N = sol[:, 0] #PUT THIS BACK FOR ONLINE
return pred_N
def C2(K):
gamma, N = K
def dC2dt(xs, t, gamma, N):
return paper2_dvdt(xs, gamma, N, default_params)
sol = odeint(dC2dt, x0, tspan2, tuple((gamma, N)))
return sol
def predict(self, initial_x, u, A, B, time):
# extract params from param_vec into form used by the rest of the code
time_points = np.array([x *1 for x in range(time)])
sol = odeint(self.linear_model, initial_x, time_points, tuple((u, A, B)))[1:]
pred_x = sol[-1, 0:2]
return pred_x
def run_model(params):
time_diff = 5 # frame skipping
time_points = np.array([x * 1 for x in range(time_diff)])
Cin = np.array([0.1, 0.1]) # initial value
S = np.array([10., 10., 0.1, 0.1, 1.])
sol = odeint(sdot, S, time_points, tuple((params, Cin)))[1:]
pred_N = sol[-1, 0:2]
return pred_N[0]
def predict(x, t, u, A, B):
# extract params from param_vec into form used by the rest of the code
time_diff = 2 # frame skipping
time_points = np.array([x *1 for x in range(time_diff)])
sol = odeint(linear_model, N, time_points, tuple((u, A, B)))[1:]
pred_x = sol[-1, 0:2]
return pred_x
def predict(self, params, S, Cin):
'''
predicts the populations at the next time point based on the current values for the params
'''
time_diff = 2 # frame skipping
time_points = np.array([x *1 for x in range(time_diff)])
sol = odeint(self.sdot, S, time_points, tuple((params, Cin)))[1:]
pred_N = sol[-1, 0:2]
return pred_N
def predict_series(param_vec, Ns, Cins, C, C_0):
# extract params from param_vec into form used by the rest of the code
time_diff = Ns.shape[0]
time_points = np.array([x * 1 for x in range(time_diff)])
sol = odeint(sdot, Ns, time_points, tuple((param_vec, Cins, C, C_0)))[1:]
pred_N = sol[-1, 0:2]
return pred_N
def ode_pred(params, y0, t):
return odeint(nn_predict, y0, t, tuple((params,)), rtol=0.01)
for insize, outsize in zip(layer_sizes[:-1], layer_sizes[1:])]
# Define neural ODE model.
def ode_pred(params, y0, t):
return odeint(nn_predict, y0, t, tuple((params,)), rtol=0.01)
def L1_loss(pred, targets):
return np.mean(np.abs(pred - targets))
if __name__ == '__main__':
# Generate data from true dynamics.
true_y0 = np.array([2., 0.]).T
t = np.linspace(0., max_T, N)
true_A = np.array([[-0.1, 2.0], [-2.0, -0.1]])
true_y = odeint(func, true_y0, t, args=(true_A,))
def train_loss(params, iter):
pred = ode_pred(params, true_y0, t)
return L1_loss(pred, true_y)
# Set up figure
fig = plt.figure(figsize=(12, 4), facecolor='white')
ax_traj = fig.add_subplot(131, frameon=False)
ax_phase = fig.add_subplot(132, frameon=False)
ax_vecfield = fig.add_subplot(133, frameon=False)
plt.show(block=False)
# Plots data and learned dynamics.
def callback(params, iter, g):
def ode_pred(params, y0, t):
return odeint(nn_predict, y0, t, tuple((params, )), rtol=0.01)
def ode_pred(params, y0, t):
return odeint(nn_predict, y0, t, tuple((params, )), rtol=0.01)
def L1_loss(pred, targets):
return np.mean(np.abs(pred - targets))
if __name__ == '__main__':
# Generate data from true dynamics.
true_y0 = np.array([2., 0.]).T
t = np.linspace(0., max_T, N)
true_A = np.array([[-0.1, 2.0], [-2.0, -0.1]])
true_y = odeint(func, true_y0, t, args=(true_A, ))
def train_loss(params, iter):
pred = ode_pred(params, true_y0, t)
return L1_loss(pred, true_y)
# Set up figure
fig = plt.figure(figsize=(12, 4), facecolor='white')
ax_traj = fig.add_subplot(131, frameon=False)
ax_phase = fig.add_subplot(132, frameon=False)
ax_vecfield = fig.add_subplot(133, frameon=False)
plt.show(block=False)
# Plots data and learned dynamics.
def callback(params, iter, g):
def predict(self, params, S, Cin, time_points):
sol = odeint(sdot, S, time_points, tuple(
(Cin, params, 2)))[1:] #PUT THIS BACK FOR ONLINE
return sol
