Upload 3 files

baseline.py

@@ -0,0 +1,41 @@
+import torch
+import torch.nn as nn
+from torch.nn.utils import clip_grad_norm_
+from torch.utils.data import DataLoader
+
+
+def update_baseline(actor, baseline, validation_set, record_scores, batch_size=100, threshold=0.95):
+
+    val_dataloader = DataLoader(dataset=validation_set,
+                                batch_size=batch_size,
+                                collate_fn=validation_set.collate)
+
+    actor.greedy_search()
+    actor.eval()
+
+    actor_scores = []
+    for batch in val_dataloader:
+        with torch.no_grad():
+            actor_output = actor(batch)
+            actor_cost = actor_output['total_time']
+            actor_cost.reshape(-1)
+        actor_scores.append(actor_cost)
+    actor_scores = torch.cat(actor_scores, dim=0)
+
+
+    if record_scores is None:
+        baseline.load_state_dict(actor.state_dict())
+        record_scores = actor_scores
+        return record_scores
+    else:
+
+        if actor_scores.mean().item() < record_scores.mean().item():
+            print('\n', flush=True)
+            print('baseline updated', flush=True)
+            print('\n', flush=True)
+
+            baseline.load_state_dict(actor.state_dict())
+            record_scores = actor_scores
+            return record_scores
+        else:
+            return record_scores

train.py

@@ -0,0 +1,54 @@
+import torch
+import torch.nn as nn
+from torch.nn.utils import clip_grad_norm_
+from torch.utils.data import DataLoader
+from just_time_windows.Actor.actor import Actor
+
+
+
+
+def train_batch(actor, baseline, batch, optimizer, gradient_clipping=True, comparison_model=None, compute_cost_ratio=True):
+
+    device = actor.device
+
+    actor.train_mode()
+    actor.train()
+    actor_output = actor(batch)
+    actor_cost, log_probs = actor_output['total_time'], actor_output['log_probs']
+
+
+    with torch.no_grad():
+        baseline.greedy_search()
+        baseline_output = baseline(batch)
+        baseline_cost = baseline_output['total_time']
+
+    loss = ((actor_cost - baseline_cost).detach() * log_probs).mean()
+
+    optimizer.zero_grad()
+    loss.backward()
+
+    if gradient_clipping:
+        for group in optimizer.param_groups:
+            clip_grad_norm_(
+                group['params'],
+                1,
+                norm_type=2
+            )
+
+    optimizer.step()
+
+    if compute_cost_ratio and (comparison_model is None):
+        normalize = actor.apply_normalization
+        comparison_model = Actor(model=None, num_neighbors_action=1, normalize=normalize, device=device)
+
+    if compute_cost_ratio:
+        with torch.no_grad():
+            comp_output = comparison_model(batch)
+            comp_cost = comp_output['total_time']
+
+        a = comp_cost.sum().item()
+        b = actor_cost.sum().item()
+        return b / a
+    else:
+        return None
+

validation.py

@@ -0,0 +1,24 @@
+
+import torch
+import torch.nn as nn
+from torch.nn.utils import clip_grad_norm_
+from torch.utils.data import DataLoader
+
+
+def validation(actor, validation_dataset, batch_size):
+
+    val_dataloader = DataLoader(dataset=validation_dataset,
+                                batch_size=batch_size,
+                                collate_fn=validation_dataset.collate)
+
+    scores = []
+    for batch in val_dataloader:
+        with torch.no_grad():
+            actor_output = actor(batch)
+            cost = actor_output['total_time']
+
+            scores.append(cost.reshape(-1))
+
+    scores = torch.cat(scores, dim=0)
+
+    return scores