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