h5_data = h5py.File(filename, 'r')
u = np.array(h5_data[dataset_name]['u'])
y = np.array(h5_data[dataset_name]['y'])
# y = (y - np.mean(y[[0], :, :], axis=-2))/(np.std(y[[0], :, :], axis=-2))
batch_size = u.shape[0]
seq_len = u.shape[1]
n_u = u.shape[2]
n_y = y.shape[2]
# In[To tensors]
u_torch = torch.tensor(u, dtype=torch.float32)
y_torch = torch.tensor(y, dtype=torch.float32)
# In[Deterministic model]
G = SisoLinearDynamicalOperator(n_b, n_a, n_k=n_k)
F = SisoStaticNonLinearity(n_hidden=10)
# In[Log-likelihood]
optimizer = torch.optim.Adam([
{
'params': G.parameters(),
'lr': lr
},
{
'params': F.parameters(),
'lr': lr
},
],
lr=lr)
v_fit = v[0:n_fit:decimate]
y_fit = y[0:n_fit:decimate]
u_fit = u[0:n_fit:decimate]
t_fit = t[0:n_fit:decimate]
# In[Prepare training tensors]
u_fit_torch = torch.tensor(u_fit[None, :, :],
dtype=torch.float,
requires_grad=False)
bins_fit_torch = torch.tensor(bins_fit[None, :, :],
dtype=torch.float,
requires_grad=False)
v_fit_torch = torch.tensor(v_fit[None, :, :], dtype=torch.float)
# In[Prepare model]
G1 = SisoLinearDynamicalOperator(n_b, n_a, n_k=1)
F_nl = SisoStaticNonLinearity(n_hidden=10, activation='tanh')
G2 = SisoLinearDynamicalOperator(n_b, n_a)
log_sigma_hat = torch.tensor(
np.log(1.0),
requires_grad=True) # torch.randn(1, requires_grad = True)
def model(u_in):
y1_lin = G1(u_fit_torch)
y1_nl = F_nl(y1_lin)
y_hat = G2(y1_nl)
return y_hat, y1_nl, y1_lin
# In[Setup optimizer]
optimizer = torch.optim.Adam([
N = y.size
ts = 1/fs
t = np.arange(N)*ts
# In[Get fit data]
y_fit = y[:n_fit:decimate]
u_fit = u[:n_fit:decimate]
t_fit = t[0:n_fit:decimate]
# In[Prepare data]
u_fit_torch = torch.tensor(u_fit[None, ...], dtype=torch.float, requires_grad=False)
y_fit_torch = torch.tensor(y_fit[None, ...], dtype=torch.float, requires_grad=False)
y_hidden_torch = torch.tensor(y_fit[None, ...], dtype=torch.float, requires_grad=True)
# optimize on the output to manage the feedback connection
# In[First dynamical system custom defined]
G1 = SisoLinearDynamicalOperator(n_b, n_a, n_k)
# Static non-linearity
F_nl = SisoStaticNonLinearity()
# Setup optimizer
optimizer = torch.optim.Adam([
{'params': G1.parameters(), 'lr': lr},
{'params': F_nl.parameters(), 'lr': lr},
{'params': [y_hidden_torch], 'lr': 1e-3},
], lr=lr)
# In[Structure]
# u ---> ----> G ------> y_lin
# |
# |
e = np.random.randn(N_sim_d)
te = np.arange(N_sim_d) * ts
d, u = control.forced_response(Hud, te, e)
d_fast = d[n_skip_d:]
d_fast = d_fast.reshape(-1, 1)
y_fit_clean = np.copy(y_fit)
y_fit = y_fit + d_fast
# In[Prepare training tensors]
u_fit_torch = torch.tensor(u_fit[None, :, :],
dtype=torch.float,
requires_grad=False)
y_fit_torch = torch.tensor(y_fit[None, :, :], dtype=torch.float)
# In[Prepare model]
G1 = SisoLinearDynamicalOperator(n_b, n_a, n_k=1)
F_nl = SisoStaticNonLinearity(n_hidden=10, activation='tanh')
G2 = SisoLinearDynamicalOperator(n_b, n_a)
def model(u_in):
y1_lin = G1(u_fit_torch)
y1_nl = F_nl(y1_lin)
y_hat = G2(y1_nl)
return y_hat, y1_nl, y1_lin
# In[Setup optimizer]
optimizer_ADAM = torch.optim.Adam([
{
'params': G1.parameters(),
'lr': lr_ADAM
},
N = y.size
fs = 50 # Sampling frequency (Hz)
ts = 1 / fs
t = np.arange(N) * ts
# Fit data
y_fit = y[:n_fit:decimate] - 1.5
u_fit = u[:n_fit:decimate]
t_fit = t[0:n_fit:decimate]
# In[Prepare data]
u_fit_torch = torch.tensor(u_fit[None, :, :], dtype=torch.float)
y_fit_torch = torch.tensor(y_fit[None, :, :], dtype=torch.float)
# In[Setup model]
G1 = SisoLinearDynamicalOperator(n_b=4, n_a=4, n_k=1)
F = SisoStaticNonLinearity(n_hidden=16, activation='tanh')
G2 = SisoLinearDynamicalOperator(n_b=4, n_a=4, n_k=1)
# Setup optimizer
optimizer = torch.optim.Adam([
{
'params': G1.parameters(),
'lr': lr
},
{
'params': F.parameters(),
'lr': lr
},
],
lr=lr)
ts = 1 / fs
t = np.arange(N) * ts
# Fit data
y_fit = y[:n_fit:decimate]
u_fit = u[:n_fit:decimate]
t_fit = t[0:n_fit:decimate]
# Prepare data
u_fit_torch = torch.tensor(u_fit[None, :, :],
dtype=torch.float,
requires_grad=False)
y_fit_torch = torch.tensor(y_fit[None, :, :], dtype=torch.float)
# Second-order dynamical system custom defined
G1 = SisoLinearDynamicalOperator(n_b=n_b, n_a=n_a)
y_init_1 = torch.zeros((n_batch, n_a), dtype=torch.float)
u_init_1 = torch.zeros((n_batch, n_b), dtype=torch.float)
# Static non-linearity
F_nl = StaticNonLin()
# Setup optimizer
optimizer = torch.optim.Adam([
{
'params': G1.parameters(),
'lr': 1e-4
},
{
'params': F_nl.parameters(),
'lr': 1e-4
x_noise = np.copy(x) + np.random.randn(*x.shape) * std_noise
x_noise = x_noise.astype(np.float32)
# In[Output]
y_noise = np.copy(x_noise[:, [0]])
y_nonoise = np.copy(x[:, [0]])
# Prepare data
u_torch = torch.tensor(u[None, ...],
dtype=torch.float,
requires_grad=False)
y_meas_torch = torch.tensor(y_noise[None, ...], dtype=torch.float)
y_true_torch = torch.tensor(y_nonoise[None, ...], dtype=torch.float)
# In[Second-order dynamical system custom defined]
G = SisoLinearDynamicalOperator(n_b, n_a)
with torch.no_grad():
G.b_coeff[0, 0, 0] = 0.01
G.b_coeff[0, 0, 1] = 0.0
G.a_coeff[0, 0, 0] = -0.9
G.b_coeff[0, 0, 1] = 0.01
# In[Setup optimizer]
optimizer = torch.optim.Adam([
{
'params': G.parameters(),
'lr': lr
},
],
# Train on a single example
u = u[[0], ...]
y = y[[0], ...]
batch_size = u.shape[0]
seq_len = u.shape[1]
n_u = u.shape[2]
n_y = y.shape[2]
# In[To tensors]
u_torch = torch.tensor(u, dtype=torch.float32)
y_torch = torch.tensor(y, dtype=torch.float32)
# In[Deterministic model]
G = SisoLinearDynamicalOperator(n_b, n_a, n_k=n_k)
F = SisoStaticNonLinearity(n_hidden=10)
model_folder = os.path.join("models", model_name)
G.load_state_dict(torch.load(os.path.join(model_folder, "G.pkl")))
F.load_state_dict(torch.load(os.path.join(model_folder, "F.pkl")))
# In[Simulate]
y_lin = G(u_torch)
y_nl = F(y_lin)
y_hat = y_nl
# In[Detach]
y_hat = y_hat.detach().numpy()
# In[Predict]
plt.plot(y0[0, :, 0], 'k', label='y0')
u = np.array(df_X[COL_U], dtype=np.float32)
fs = np.array(df_X[COL_F].iloc[0], dtype=np.float32).item()
N = y_meas.size
ts = 1 / fs
t = np.arange(N) * ts
t_fit_start = 0
t_fit_end = 100000
t_test_start = 100000
t_test_end = 188000
t_skip = 1000 # skip for statistics
# In[Instantiate models]
# Create models
G1 = SisoLinearDynamicalOperator(n_b=n_b, n_a=n_a, n_k=1)
G2 = SisoLinearDynamicalOperator(n_b=n_b, n_a=n_a, n_k=0)
F_nl = SisoStaticNonLinearity(n_hidden=10, activation='tanh')
model_folder = os.path.join("models", model_name)
# Create model parameters
G1.load_state_dict(torch.load(os.path.join(model_folder, "G1.pkl")))
F_nl.load_state_dict(torch.load(os.path.join(model_folder, "F_nl.pkl")))
G2.load_state_dict(torch.load(os.path.join(model_folder, "G2.pkl")))
# In[Predict]
u_torch = torch.tensor(u[None, :, :])
y1_lin = G1(u_torch)
y1_nl = F_nl(y1_lin)
y_hat = G2(y1_nl)
# scale state
x = x / np.array([100.0, 10.0])
# Add measurement noise
std_noise_V = add_noise * 0.1
#y_nonoise = np.copy(1 + x[:, [0]] + x[:, [0]]**2)
y_nonoise = np.copy(x[:, [0, 1]]) #np.copy(1 + x[:, [0]] ** 3)
y_noise = y_nonoise + np.random.randn(*y_nonoise.shape) * std_noise_V
# Prepare data
u_torch = torch.tensor(u[None, :, :],
dtype=torch.float,
requires_grad=False)
y_meas_torch = torch.tensor(y_noise[None, :, :], dtype=torch.float)
y_true_torch = torch.tensor(y_nonoise[None, :, :], dtype=torch.float)
G = SisoLinearDynamicalOperator(n_b, n_a, n_k=1)
nn_static = SisoStaticNonLinearity()
# Setup optimizer
params_lin = G.parameters()
optimizer = torch.optim.Adam([{
'params': params_lin,
'lr': lr
}, {
'params': nn_static.parameters(),
'lr': lr
}],
lr=lr)
# In[Train]
LOSS = []
e = np.random.randn(N_sim_d)
te = np.arange(N_sim_d) * ts
d, u = control.forced_response(Hud, te, e)
d_fast = d[n_skip_d:]
d_fast = d_fast.reshape(-1, 1)
y_fit_clean = np.copy(y_fit)
y_fit = y_fit + d_fast
# In[Prepare training tensors]
u_fit_torch = torch.tensor(u_fit[None, :, :],
dtype=torch.float,
requires_grad=False)
y_fit_torch = torch.tensor(y_fit[None, :, :], dtype=torch.float)
# In[Prepare model]
G1 = SisoLinearDynamicalOperator(n_b, n_a, n_k=1)
F_nl = SisoStaticNonLinearity(n_hidden=10, activation='tanh')
G2 = SisoLinearDynamicalOperator(n_b, n_a)
H_inv = SisoLinearDynamicalOperator(2, 2, n_k=1)
def model(u_in):
y1_lin = G1(u_fit_torch)
y1_nl = F_nl(y1_lin)
y_hat = G2(y1_nl)
return y_hat, y1_nl, y1_lin
# In[Setup optimizer]
optimizer_ADAM = torch.optim.Adam([
{
'params': G1.parameters(),