VictorMylle/Thesis
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Using val set for diffusion trainer

Browse Source
This commit is contained in:
Victor Mylle
2024-05-17 13:24:02 +02:00
parent 615f9486bc
commit 11ae0e1949
13 changed files with 287 additions and 175 deletions
Download Patch File Download Diff File Expand all files Collapse all files

104
src/data/preprocessing.py
View File

@@ -49,6 +49,10 @@ class DataProcessor:
-np.inf,
datetime(year=2022, month=11, day=30, tzinfo=pytz.UTC),
)
self.val_range = (
datetime(year=2022, month=10, day=1, tzinfo=pytz.UTC),
datetime(year=2022, month=11, day=30, tzinfo=pytz.UTC),
)
self.test_range = (datetime(year=2023, month=1, day=1, tzinfo=pytz.UTC), np.inf)
self.update_range_str()
@@ -227,14 +231,23 @@ class DataProcessor:
transform: bool = True,
predict_sequence_length: int = 96,
shuffle: bool = True,
with_validation: bool = False,
):
train_df = self.all_features.copy()
train_range = self.train_range
if with_validation:
train_range = (
self.train_range[0],
self.val_range[0] - pd.Timedelta(days=1),
)
if self.train_range[0] != -np.inf:
train_df = train_df[(train_df["datetime"] >= self.train_range[0])]
train_df = train_df[(train_df["datetime"] >= train_range[0])]
if self.train_range[1] != np.inf:
train_df = train_df[(train_df["datetime"] <= self.train_range[1])]
train_df = train_df[(train_df["datetime"] <= train_range[1])]
if transform:
train_df["nrv"] = self.nrv_scaler.fit_transform(
@@ -276,6 +289,58 @@ class DataProcessor:
)
return self.get_dataloader(train_dataset, shuffle=shuffle)
def get_val_dataloader(
self,
transform: bool = True,
predict_sequence_length: int = 96,
full_day_skip: bool = False,
):
val_df = self.all_features.copy()
if self.test_range[0] != -np.inf:
val_df = val_df[(val_df["datetime"] >= self.val_range[0])]
if self.test_range[1] != np.inf:
val_df = val_df[(val_df["datetime"] <= self.val_range[1])]
if transform:
val_df["nrv"] = self.nrv_scaler.transform(
val_df["nrv"].values.reshape(-1, 1)
).reshape(-1)
val_df["load_forecast"] = self.load_forecast_scaler.transform(
val_df["load_forecast"].values.reshape(-1, 1)
).reshape(-1)
val_df["total_load"] = self.load_forecast_scaler.transform(
val_df["total_load"].values.reshape(-1, 1)
).reshape(-1)
val_df["pv_forecast"] = self.pv_forecast_scaler.transform(
val_df["pv_forecast"].values.reshape(-1, 1)
).reshape(-1)
val_df["pv_history"] = self.pv_forecast_scaler.transform(
val_df["pv_history"].values.reshape(-1, 1)
).reshape(-1)
val_df["wind_forecast"] = self.wind_forecast_scaler.transform(
val_df["wind_forecast"].values.reshape(-1, 1)
).reshape(-1)
val_df["wind_history"] = self.wind_forecast_scaler.transform(
val_df["wind_history"].values.reshape(-1, 1)
).reshape(-1)
val_df["nominal_net_position"] = self.nominal_net_position_scaler.transform(
val_df["nominal_net_position"].values.reshape(-1, 1)
).reshape(-1)
val_dataset = NrvDataset(
val_df,
data_config=self.data_config,
full_day_skip=self.full_day_skip or full_day_skip,
predict_sequence_length=predict_sequence_length,
lstm=self.lstm,
)
return self.get_dataloader(val_dataset, shuffle=False)
def get_test_dataloader(
self,
transform: bool = True,
@@ -335,14 +400,35 @@ class DataProcessor:
transform: bool = True,
predict_sequence_length: int = 96,
full_day_skip: bool = False,
validation: bool = False,
):
return self.get_train_dataloader(
transform=transform, predict_sequence_length=predict_sequence_length
), self.get_test_dataloader(
transform=transform,
predict_sequence_length=predict_sequence_length,
full_day_skip=full_day_skip,
)
if not validation:
return self.get_train_dataloader(
transform=transform, predict_sequence_length=predict_sequence_length
), self.get_test_dataloader(
transform=transform,
predict_sequence_length=predict_sequence_length,
full_day_skip=full_day_skip,
)
else:
return (
self.get_train_dataloader(
transform=transform,
predict_sequence_length=predict_sequence_length,
with_validation=True,
),
self.get_val_dataloader(
transform=transform,
predict_sequence_length=predict_sequence_length,
full_day_skip=full_day_skip,
),
self.get_test_dataloader(
transform=transform,
predict_sequence_length=predict_sequence_length,
full_day_skip=full_day_skip,
),
)
def inverse_transform(self, input_data):
try:

74
src/trainers/diffusion_trainer.py
View File

@@ -202,8 +202,8 @@ class DiffusionTrainer:
if task:
self.init_clearml_task(task)
train_loader, test_loader = self.data_processor.get_dataloaders(
predict_sequence_length=self.ts_length
train_loader, val_loader, test_loader = self.data_processor.get_dataloaders(
predict_sequence_length=self.ts_length, validation=True
)
train_sample_indices = self.random_samples(train=True, num_samples=5)
@@ -230,7 +230,7 @@ class DiffusionTrainer:
running_loss /= len(train_loader.dataset)
if epoch % 75 == 0 and epoch != 0:
crps, _ = self.test(test_loader, epoch, task)
crps, _ = self.test(val_loader, epoch, task)
if best_crps is None or crps < best_crps:
best_crps = crps
@@ -585,46 +585,48 @@ class DiffusionTrainer:
if task:
task.get_logger().report_scalar(
title="CRPS", series="test", value=mean_crps, iteration=epoch
title="CRPS", series="val", value=mean_crps, iteration=epoch
)
# if self.policy_evaluator:
# _, test_loader = self.data_processor.get_dataloaders(
# predict_sequence_length=self.ts_length, full_day_skip=True
# )
if self.policy_evaluator:
_, val_loader, _ = self.data_processor.get_dataloaders(
predict_sequence_length=self.ts_length,
full_day_skip=True,
validation=True,
)
# optimal_penalty, profit, charge_cycles = (
# self.policy_evaluator.optimize_penalty_for_target_charge_cycles(
# idx_samples=generated_samples,
# test_loader=test_loader,
# initial_penalty=self.prev_optimal_penalty,
# target_charge_cycles=283,
# initial_learning_rate=1,
# max_iterations=50,
# tolerance=1,
# iteration=epoch,
# )
# )
optimal_penalty, profit, charge_cycles = (
self.policy_evaluator.optimize_penalty_for_target_charge_cycles(
idx_samples=generated_samples,
test_loader=val_loader,
initial_penalty=self.prev_optimal_penalty,
target_charge_cycles=283,
initial_learning_rate=1,
max_iterations=50,
tolerance=1,
iteration=epoch,
)
)
# self.prev_optimal_penalty = optimal_penalty
self.prev_optimal_penalty = optimal_penalty
# task.get_logger().report_scalar(
# title="Optimal Penalty",
# series="test",
# value=optimal_penalty,
# iteration=epoch,
# )
task.get_logger().report_scalar(
title="Optimal Penalty",
series="test",
value=optimal_penalty,
iteration=epoch,
)
# task.get_logger().report_scalar(
# title="Optimal Profit", series="test", value=profit, iteration=epoch
# )
task.get_logger().report_scalar(
title="Optimal Profit", series="test", value=profit, iteration=epoch
)
# task.get_logger().report_scalar(
# title="Optimal Charge Cycles",
# series="test",
# value=charge_cycles,
# iteration=epoch,
# )
task.get_logger().report_scalar(
title="Optimal Charge Cycles",
series="test",
value=charge_cycles,
iteration=epoch,
)
return mean_crps, generated_samples

2
src/training_scripts/diffusion_training.py
View File

@@ -71,6 +71,6 @@ policy_evaluator = PolicyEvaluator(baseline_policy, task)
#### Trainer ####
trainer = DiffusionTrainer(
model, data_processor, "cuda", policy_evaluator=policy_evaluator, noise_steps=100
model, data_processor, "cuda", policy_evaluator=policy_evaluator, noise_steps=20
)
trainer.train(model_parameters["epochs"], model_parameters["learning_rate"], task)

56
src/training_scripts/non_autoregressive_quantiles.py
View File

@@ -1,8 +1,12 @@
from src.utils.clearml import ClearMLHelper
#### ClearML ####
clearml_helper = ClearMLHelper(project_name="Thesis/NAQR: GRU")
task = clearml_helper.get_task(task_name="NAQR: GRU (8 - 512) + Load + PV + Wind + NP")
clearml_helper = ClearMLHelper(
project_name="Thesis/NAQR: Non Linear (4 - 256) + Load + PV + Wind + NP"
)
task = clearml_helper.get_task(
task_name="NAQR: Non Linear (4 - 256) + Load + PV + Wind + NP"
)
task.execute_remotely(queue_name="default", exit_process=True)
from src.policies.PolicyEvaluator import PolicyEvaluator
@@ -119,32 +123,32 @@ trainer.plot_every(20)
trainer.train(task=task, epochs=epochs, remotely=True)
### Policy Evaluation ###
# idx_samples = trainer.test_set_samples
# _, test_loader = trainer.data_processor.get_dataloaders(
# predict_sequence_length=trainer.model.output_size, full_day_skip=False
# )
idx_samples = trainer.test_set_samples
_, test_loader = trainer.data_processor.get_dataloaders(
predict_sequence_length=trainer.model.output_size, full_day_skip=False
)
# policy_evaluator.evaluate_test_set(idx_samples, test_loader)
# policy_evaluator.plot_profits_table()
# policy_evaluator.plot_thresholds_per_day()
policy_evaluator.evaluate_test_set(idx_samples, test_loader)
policy_evaluator.plot_profits_table()
policy_evaluator.plot_thresholds_per_day()
# optimal_penalty, profit, charge_cycles = (
# policy_evaluator.optimize_penalty_for_target_charge_cycles(
# idx_samples=idx_samples,
# test_loader=test_loader,
# initial_penalty=1000,
# target_charge_cycles=283,
# learning_rate=15,
# max_iterations=150,
# tolerance=1,
# )
# )
optimal_penalty, profit, charge_cycles = (
policy_evaluator.optimize_penalty_for_target_charge_cycles(
idx_samples=idx_samples,
test_loader=test_loader,
initial_penalty=1000,
target_charge_cycles=283,
learning_rate=15,
max_iterations=150,
tolerance=1,
)
)
# print(
# f"Optimal Penalty: {optimal_penalty}, Profit: {profit}, Charge Cycles: {charge_cycles}"
# )
# task.get_logger().report_single_value(name="Optimal Penalty", value=optimal_penalty)
# task.get_logger().report_single_value(name="Optimal Profit", value=profit)
# task.get_logger().report_single_value(name="Optimal Charge Cycles", value=charge_cycles)
print(
f"Optimal Penalty: {optimal_penalty}, Profit: {profit}, Charge Cycles: {charge_cycles}"
)
task.get_logger().report_single_value(name="Optimal Penalty", value=optimal_penalty)
task.get_logger().report_single_value(name="Optimal Profit", value=profit)
task.get_logger().report_single_value(name="Optimal Charge Cycles", value=charge_cycles)
task.close()