def run(dataset, sensor_class, which_i, coeff_type, k_nn, epochs, folder,
T_train, freq):
# Create the folder in which the experiment results will be stored.
exp_logger = ExperimentLogger(folder, locals())
# Load true load flow.
V_org, I_org, P_org, Q_org, current_idx = load_true_data(dataset)
T = V_org.shape[1]
# Extract the list of which coefficients to estimate.
which_i = utils.unpack_which_i(which_i, V_org.shape[0])
# Select the noise std that corresponds to the type of coefficient(s).
std_abs = constants.SENSOR_STD_ABS[sensor_class]
std_arg = constants.SENSOR_STD_ANG[sensor_class]
# Transform voltage phasor measurements into either
# (|x|, Re{x}, or Im{x}) based on `coeff_type`.
X_org_a, X_org_b = utils.dependent_vars_setup(V_org, coeff_type)
# Remove slack bus measurements and create delta matrices.
dPQ_org = np.vstack((np.diff(P_org[1:], axis=1),
np.diff(Q_org[1:], axis=1)))
dX_org_a = np.diff(X_org_a[1:], axis=1)
# Add noise to load flow data.
V_meas, _, P_meas, Q_meas, _, _, _, _, _, _ = \
simulate_noisy_meas(sensor_class, V_org, I_org, current_idx)
# Transform voltage phasor measurements into either
# (|x|, Re{x}, or Im{x}) based on `coeff_type`.
X_meas_a, X_meas_b = utils.dependent_vars_setup(V_meas, coeff_type)
# Remove slack bus measurements and create delta matrices.
dPQ_meas = np.vstack((np.diff(P_meas[1:], axis=1),
np.diff(Q_meas[1:], axis=1)))
dX_meas_a = np.diff(X_meas_a[1:], axis=1)
# Load the true sensitivity coefficients of interest.
coefficients = load_coefficients(dataset)
S_a_true, S_b_true = utils.coefficients_setup(coefficients, coeff_type, which_i)
del coefficients
# Compute the true voltage magnitude deviations (from the load flow).
dV_load_flow = np.diff(np.abs(V_org[1:]), axis=1)
# T_plot = 200
t_nn = np.arange(T_train + k_nn, T) # which timesteps the NN estimates.
t_plot = np.arange(T_train + k_nn, T, freq) # which timesteps should be plotted.
t_nn_plot = np.arange(0, T - T_train - k_nn, freq) # the idx of the nn estimations that should be plotted
X_train, X_test = dX_meas_a[:, :T_train], dX_meas_a[:, T_train:]
PQ_train, PQ_test = dPQ_meas[:, :T_train], dPQ_meas[:, T_train:]
fig_1, axs_1 = plt.subplots(len(which_i), 1, sharex=True, figsize=(10, 2.5*len(which_i)))
fig_2, axs_2 = plt.subplots(len(which_i), 1, sharex=True, figsize=(10, 2.5*len(which_i)))
for idx, x_i in enumerate(which_i):
training_dataset = build_training_dataloader(X_train, PQ_train, x_i, k_nn)
in_shape = (dX_meas_a.shape[0] + dPQ_meas.shape[0]) * k_nn
hidden_shapes = [128, 128]
sc_matrix_shape = (dPQ_meas.shape[0])
model = FeedForward(in_shape, hidden_shapes, sc_matrix_shape, k_nn)
train_loss = nn.train(model, training_dataset, lr=1e-3, epochs=epochs, l2=0.)
# Use the neural net to estimate the coefficients for the last 12 hours.
testing_dataset = build_testing_dataloader(X_test, PQ_test, x_i, k_nn)
S_a_nn, dV_nn, dV_nn_true = model.predict(testing_dataset)
# Plot estimated coefficient.
ax = axs_1[idx]
ax.plot(t_plot, S_a_true[x_i][x_i - 1][t_plot], label='True')
ax.plot(t_plot, S_a_nn[x_i - 1][t_nn_plot], label='Neural net')
ax.legend(loc='upper right')
# Plot predicted d|X|.
ax = axs_2[idx]
ax.plot(t_plot, dV_load_flow[x_i-1][t_plot], label='True')
ax.plot(t_plot, dV_nn[t_nn_plot], label='Neural net')
ax.legend(loc='upper right')
exp_logger.save_figure(fig_1, 'coefficients')
exp_logger.save_figure(fig_2, 'dV')
plt.show()
print('Done!')
Kp_all[x_idx][n_exp, offset + i, ts] = S[x_i][x_i - 1]
Kq_all[x_idx][n_exp, offset + i, ts] = S[x_i][x_i - 1 + N]
X_all[x_idx][n_exp, offset + i, ts] = dV[x_i]
ts_linear = ts
################### USED THE TRAINED NN FOR INFERENCE ###################
print('Neural nets...')
offset = 6
for x_idx, x_i in enumerate(x_is):
for i in range(6):
# Create test dataset.
data = build_testing_dataloader(X_matrices[i], PQ_matrices[i],
x_i, k_nn)
# Load trained model.
filename = nn_utils.checkpoint_filename(
dataset, sensor_class, 'NN', model_types[i], x_i,
train_seed)
model = nn_logger.load_model(filename)
# Predict coefficients on the test set.
S, y_pred, _ = model.predict(data)
# Save predicted data.
ts = np.arange(k_nn, T_test - 1)
Kp_all[x_idx][n_exp, offset + i, ts] = S[x_i - 1, :len(ts)]
Kq_all[x_idx][n_exp, offset + i, ts] = S[x_i - 1 + N, :len(ts)]
X_all[x_idx][n_exp, offset + i, ts] = y_pred[:len(ts)]
# Train LSTMs.
for idx, (m, data) in enumerate(zip(lstms, train_datasets)):
if idx in methods['LSTM']:
lstm.train(m,
data,
epochs_lstm,
lr=1e-3,
batch_size=batch_size)
################### TEST THE FEEDFORWARD NEURAL NETS ###################
# Timesteps corresponding to the estimations.
ts = np.arange(T_train + k_nn, T_train + T_test - 1)
# Define testing data sets.
test_dv_magn = build_testing_dataloader(dV_meas_magn_test, dPQ_meas_test,
x_i, k_nn)
test_dv_re = build_testing_dataloader(dV_meas_re_test, dPQ_meas_test, x_i,
k_nn)
test_dv_im = build_testing_dataloader(dV_meas_im_test, dPQ_meas_test, x_i,
k_nn)
test_v_magn = build_testing_dataloader(V_meas_magn_test, PQ_meas_bias_test,
x_i, k_nn)
test_v_re = build_testing_dataloader(V_meas_re_test, PQ_meas_bias_test,
x_i, k_nn)
test_v_im = build_testing_dataloader(V_meas_im_test, PQ_meas_bias_test,
x_i, k_nn)
test_datasets = [
test_dv_magn, test_dv_re, test_dv_im, test_v_magn, test_v_re, test_v_im
]
model_v_magn, model_v_re, model_v_im]
# Define training data sets.
train_dv_magn = build_training_dataloader(dV_meas_magn_tr, dPQ_meas_tr, x_i, k_nn)
train_dv_re = build_training_dataloader(dV_meas_re_tr, dPQ_meas_tr, x_i, k_nn)
train_dv_im = build_training_dataloader(dV_meas_im_tr, dPQ_meas_tr, x_i, k_nn)
train_v_magn = build_training_dataloader(V_meas_magn_tr, PQ_meas_bias_tr, x_i, k_nn)
train_v_re = build_training_dataloader(V_meas_re_tr, PQ_meas_bias_tr, x_i, k_nn)
train_v_im = build_training_dataloader(V_meas_im_tr, PQ_meas_bias_tr, x_i, k_nn)
train_datasets = [train_dv_magn, train_dv_re, train_dv_im,
train_v_magn, train_v_re, train_v_im]
# Define validation data sets.
val_dv_magn = build_testing_dataloader(dV_meas_magn_val, dPQ_meas_val, x_i, k_nn)
val_dv_re = build_testing_dataloader(dV_meas_re_val, dPQ_meas_val, x_i, k_nn)
val_dv_im = build_testing_dataloader(dV_meas_im_val, dPQ_meas_val, x_i, k_nn)
val_v_magn = build_testing_dataloader(V_meas_magn_val, PQ_meas_bias_val, x_i, k_nn)
val_v_re = build_testing_dataloader(V_meas_re_val, PQ_meas_bias_val, x_i, k_nn)
val_v_im = build_testing_dataloader(V_meas_im_val, PQ_meas_bias_val, x_i, k_nn)
val_datasets = [val_dv_magn, val_dv_re, val_dv_im,
val_v_magn, val_v_re, val_v_im]
for idx, (model, train_data, val_data) in enumerate(zip(models, train_datasets, val_datasets)):
# Train neural network.
best_loss, best_model, best_epoch = \
train(model, train_data, val_data, lr=1e-3, epoch_max=epochs, l2=0.)
dV_meas_magn = np.diff(V_meas_magn, axis=1)
dPQ_meas = np.diff(PQ_meas, axis=1)
# Split training and testing data.
dV_train, dPQ_train = dV_meas_magn[:, :T_train], dPQ_meas[:, :T_train]
dV_test, dPQ_test = dV_meas_magn[:, T_train:], dPQ_meas[:, T_train:]
T_test = T - T_train
V_train, PQ_train = V_meas_magn[:, :T_train], PQ_meas_bias[:, :T_train]
V_test, PQ_test = V_meas_magn[:, T_train:], PQ_meas_bias[:, T_train:]
####################### TRAIN NEURAL NETWORKS #######################
# Define training and testing data sets.
train_dv = build_training_dataloader(dV_train, dPQ_train, x_i, k_nn)
test_dv = build_testing_dataloader(dV_test, dPQ_test, x_i, k_nn)
train_v = build_training_dataloader(V_train, PQ_train, x_i, k_nn)
test_v = build_testing_dataloader(V_test, PQ_test, x_i, k_nn)
# models_dv = []
models_v = []
for iter in range(N_nets):
print(f'\nTraining model {iter}...')
# # Initialize neural nets.
# in_shape = 3 * N * k_nn
# sc_matrix_shape = 2 * N
# model_dv = FeedForward(in_shape, hidden_shapes, sc_matrix_shape, k_nn)
#