Delete actor_modified.py

actor_modified.py

@@ -1,155 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from Actor.graph import Graph
-from Actor.fleet import Fleet
-from utils.actor_utils import widen_data, select_data
-from Actor.normalization import Normalization
-
-
-class Actor(nn.Module):
-    def __init__(self, model=None, num_movers=5, num_neighbors_encoder=5,
-                 num_neighbors_action=5, normalize=False, use_fleet_attention=True,
-                 device='cpu'):
-        super().__init__()
-
-        self.device = device
-        self.num_movers = num_movers
-        self.num_neighbors_encoder = num_neighbors_encoder
-        self.num_neighbors_action = num_neighbors_action
-
-        self.apply_normalization = normalize
-        self.normalization = None
-        self.use_fleet_attention = use_fleet_attention
-
-        if model is None:
-            self.mode = 'nearest_neighbors'
-        else:
-            self.encoder = model.encoder.to(self.device)
-            self.decoder = model.decoder.to(self.device)
-            self.projections = model.projections.to(self.device)
-            self.fleet_attention = model.fleet_attention.to(self.device)
-            self.mode = 'train'
-
-        self.sample_size = 1
-
-    def train_mode(self, sample_size=1):
-        self.train()
-        self.sample_size = sample_size
-        self.mode = 'train'
-
-    def greedy_search(self):
-        self.eval()
-        self.mode = 'greedy'
-
-    def nearest_neighbors(self):
-        self.eval()
-        self.mode = 'nearest_neighbors'
-
-    def sample_mode(self, sample_size=10):
-        self.sample_size = sample_size
-        self.eval()
-        self.mode = 'sample'
-
-    def beam_search(self, sample_size=10):
-        self.sample_size = sample_size
-        self.eval()
-        self.mode = 'beam_search'
-
-    def update_batch_size(self):
-        self.batch_size = self.fleet.time.shape[0]
-        self.fleet.batch_size = self.batch_size
-        self.graph.batch_size = self.batch_size
-
-    def forward(self, batch, *args, **kwargs):
-        graph_data, fleet_data = batch
-        self.original_batch_size = graph_data['distance_matrix'].shape[0]
-        self.batch_size = self.original_batch_size
-
-        self.num_nodes = graph_data['distance_matrix'].shape[1]
-        self.num_cars = fleet_data['start_time'].shape[1]
-
-        self.graph = Graph(graph_data, device=self.device)
-        self.fleet = Fleet(fleet_data, num_nodes=self.num_nodes, device=self.device)
-        self.update_batch_size()
-
-        self.normalization = Normalization(self, normalize_position=True)
-        if self.apply_normalization:
-            self.normalization.normalize(self)
-
-        self.num_depots = self.fleet.num_depots.max().item()
-        self.num_movers_corrected = int(min(max(self.num_movers, self.num_depots), self.num_cars))
-
-        if self.mode != 'nearest_neighbors':
-            encoder_input = self.graph.construct_vector()
-            encoder_mask = self.compute_encoder_mask()
-            self.node_embeddings = self.encoder(encoder_input, encoder_mask)
-            self.node_projections = self.projections(self.node_embeddings)
-
-        if self.mode == 'sample':
-            widen_data(self, include_embeddings=True, include_projections=True)
-            self.update_batch_size()
-
-        self.log_probs = torch.zeros(self.batch_size).to(self.device)
-        self.counter = 0
-        while self.loop_condition() and (self.counter < self.num_nodes * 4):
-            unavailable_moves = self.check_non_depot_options(use_time=True)
-            mover_indices = self.get_mover_indices(unavailable_moves=unavailable_moves)
-            action_mask = self.compute_action_mask(mover_indices=mover_indices, unavailable_moves=unavailable_moves)
-
-            decoder_output = None
-            if self.mode != 'nearest_neighbors':
-                decoder_input = self.construct_decoder_input(mover_indices=mover_indices)
-                decoder_mask = self.compute_decoder_mask(mover_indices=mover_indices, unavailable_moves=unavailable_moves)
-                decoder_output = self.decoder(decoder_input=decoder_input,
-                                              projections=self.node_projections,
-                                              mask=decoder_mask)
-
-            next_node, car_to_move, log_prob = self.compute_action(decoder_output, action_mask, mover_indices)
-
-            if self.mode == 'beam_search':
-                widen_data(self, include_embeddings=True, include_projections=True)
-                self.update_batch_size()
-
-            self.log_probs += log_prob
-            self.update_time(next_node, car_to_move)
-            self.update_distance(next_node, car_to_move)
-            self.update_node_path(next_node, car_to_move)
-            self.update_traversed_nodes()
-
-            if (self.mode == 'beam_search') and (self.counter > 0):
-                self.consolidate_beams()
-
-            self.update_batch_size()
-            self.counter += 1
-
-        self.return_to_depot_1()
-
-        if self.mode in {'beam_search', 'sample'}:
-            incomplete = self.check_complete().float()
-            cost = self.compute_cost()
-            max_cost = cost.max()
-            masked_cost = (1 - incomplete) * cost + incomplete * max_cost * 10
-
-            p = masked_cost.reshape(self.original_batch_size, self.sample_size)
-            a = torch.argmin(p, dim=1)
-            b = torch.arange(self.original_batch_size).to(self.device)
-            b = b * self.sample_size
-            index = a + b
-            select_data(self, index=index, include_projections=True, include_embeddings=True)
-
-        self.update_batch_size()
-        if self.apply_normalization:
-            self.normalization.inverse_normalize(self)
-
-        output = {
-            'distance': self.fleet.distance.sum(dim=1).squeeze(1).detach(),
-            'total_time': self.fleet.time.sum(dim=1).squeeze(1).detach(),
-            'log_probs': self.log_probs,
-            'late_time': self.fleet.late_time.sum(dim=1).squeeze(1).detach(),
-            'incomplete': self.check_complete(),
-            'path': self.fleet.path,
-            'arrival_times': self.fleet.arrival_times
-        }
-
-        return output