Upload 4 files

google_solver/Untitled.ipynb

@@ -0,0 +1,99 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import torch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[array([0.01560026, 0.14899027, 0.8198149 ], dtype=float32),\n",
+       " array([0.9768128 , 0.06915247, 0.42297667], dtype=float32),\n",
+       " array([0.9447805 , 0.9968865 , 0.85253155], dtype=float32),\n",
+       " array([0.4674251, 0.9449542, 0.6850118], dtype=float32),\n",
+       " array([0.8488321 , 0.9191937 , 0.33687925], dtype=float32)]"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "torch.rand(5, 3).numpy()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x = torch.rand(5, 3).numpy()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[[0.6611388, 0.24161768, 0.35973948],\n",
+       " [0.28449154, 0.81414443, 0.17932409],\n",
+       " [0.65817285, 0.1036877, 0.8726997],\n",
+       " [0.05815494, 0.3649323, 0.6273505],\n",
+       " [0.57139295, 0.16107935, 0.08857018]]"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "[list(x[i]) for i in range(x.shape[0])]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

google_solver/convert_data.py

@@ -0,0 +1,57 @@
+
+import torch
+import numpy as np
+
+
+def convert_tensor(x):
+    x = x.long().numpy().astype('int')
+
+    if len(x.shape) == 1:
+        return list(x)
+    else:
+        return [list(x[i]) for i in range(x.shape[0])]
+
+
+
+def make_time_windows(start_time, end_time):
+    return torch.cat([start_time, end_time], dim=2)
+
+
+
+def convert_data(input, scale_factor):
+
+    graph_data, fleet_data = input
+
+    start_times = graph_data['start_times']
+    end_times = graph_data['end_times']
+
+    distance_matrix = graph_data['distance_matrix']
+    time_matrix = graph_data['time_matrix']
+
+    time_windows = make_time_windows(start_times, end_times)
+
+
+    batch_size = distance_matrix.shape[0]
+    data = []
+    for i in range(batch_size):
+
+        num_vehicles = distance_matrix[i].shape[1]
+
+        space_mat = distance_matrix[i] * scale_factor
+        time_mat = time_matrix[i] * scale_factor
+        windows = time_windows[i] * scale_factor
+
+        space_mat = convert_tensor(space_mat)
+        time_mat = convert_tensor(time_mat)
+        windows = convert_tensor(windows)
+
+
+        D = {'distance_matrix': space_mat,
+             'time_matrix': time_mat,
+             'time_windows': windows,
+             'depot': 0,
+             'num_vehicles': num_vehicles
+             }
+
+        data.append(D)
+    return data

google_solver/google_model.py

@@ -0,0 +1,128 @@
+from __future__ import print_function
+from ortools.constraint_solver import routing_enums_pb2
+from ortools.constraint_solver import pywrapcp
+import torch
+from google_solver.convert_data import convert_data
+
+
+class GoogleActor(object):
+
+    def __init__(self, scale_factor=100):
+
+        if scale_factor is None:
+            self.scale_factor = 1
+        else:
+            self.scale_factor = scale_factor
+
+
+    def __call__(self, input):
+
+        drive_times = []
+        data = convert_data(input, self.scale_factor)
+        batch_size = len(data)
+        for datum in data:
+            routing, assignment = self.compute_route(datum)
+            total_time = self.compute_total_time(datum, routing, assignment)
+            drive_times.append(total_time)
+
+        drive_times = torch.tensor(drive_times).float()
+        return drive_times
+
+
+    def compute_distance(self, routing, assignment, num_nodes):
+        """Prints solution on console."""
+        cumulative_route_distance = 0
+        for vehicle_id in range(num_nodes):
+            index = routing.Start(vehicle_id)
+            route_distance = 0
+            while not routing.IsEnd(index):
+                previous_index = index
+                index = assignment.Value(routing.NextVar(index))
+                route_distance += routing.GetArcCostForVehicle(
+                    previous_index, index, vehicle_id)
+            cumulative_route_distance += route_distance
+
+        cumulative_route_distance = cumulative_route_distance / self.scale_factor
+        return cumulative_route_distance
+
+
+    def compute_total_time(self, data, routing, assignment):
+        time_dimension = routing.GetDimensionOrDie('Time')
+        total_time = 0
+        for vehicle_id in range(data['num_vehicles']):
+            index = routing.Start(vehicle_id)
+            while not routing.IsEnd(index):
+                index = assignment.Value(routing.NextVar(index))
+            time_var = time_dimension.CumulVar(index)
+            total_time += assignment.Min(time_var)
+        total_time = total_time/self.scale_factor
+        return total_time
+
+
+
+    def compute_route(self, input):
+
+        distance_matrix = input['distance_matrix']
+        time_matrix = input['time_matrix']
+        time_windows = input['time_windows']
+        num_vehicles = input['num_vehicles']
+        depot = input['depot']
+
+
+        manager = pywrapcp.RoutingIndexManager(len(time_matrix), num_vehicles, depot)
+        routing = pywrapcp.RoutingModel(manager)
+
+        def time_callback(from_index, to_index):
+            """Returns the travel time between the two nodes."""
+            # Convert from routing variable Index to time matrix NodeIndex.
+            from_node = manager.IndexToNode(from_index)
+            to_node = manager.IndexToNode(to_index)
+            return time_matrix[from_node][to_node]
+
+        transit_callback_index = routing.RegisterTransitCallback(time_callback)
+        routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)
+        time = 'Time'
+        routing.AddDimension(
+            transit_callback_index,
+            10000,  # allow waiting time
+            10000,  # maximum time per vehicle
+            False,  # Don't force start cumul to zero.
+            time)
+
+        time_dimension = routing.GetDimensionOrDie(time)
+        # Add time window constraints for each location except depot.
+        for location_idx, time_window in enumerate(time_windows):
+            if location_idx == 0:
+                continue
+            index = manager.NodeToIndex(location_idx)
+            a, b = int(time_window[0]), int(time_window[1])
+            time_dimension.CumulVar(index).SetRange(a, b)
+
+        # Add time window constraints for each vehicle start node.
+        for vehicle_id in range(num_vehicles):
+            index = routing.Start(vehicle_id)
+            a, b = int(time_windows[0][0]), int(time_windows[0][1])
+            time_dimension.CumulVar(index).SetRange(a, b)
+
+        for i in range(num_vehicles):
+            routing.AddVariableMinimizedByFinalizer(
+                time_dimension.CumulVar(routing.Start(i)))
+            routing.AddVariableMinimizedByFinalizer(
+                time_dimension.CumulVar(routing.End(i)))
+
+        search_parameters = pywrapcp.DefaultRoutingSearchParameters()
+        search_parameters.first_solution_strategy = (routing_enums_pb2.FirstSolutionStrategy.AUTOMATIC)
+        assignment = routing.SolveWithParameters(search_parameters)
+
+        return routing, assignment
+
+
+
+
+def evaluate_google_model(validation_dataset):
+    validation_dataset.device = 'cpu'
+    data = validation_dataset.get_data()
+    model = GoogleActor(scale_factor=100)
+    scores = model(data)
+    return scores
+

google_solver/scratch.py

@@ -0,0 +1,27 @@
+
+
+from just_time_windows.google_solver.google_model import evaluate_google_model
+from just_time_windows.Actor.actor import Actor as NN_Actor
+from just_time_windows.build_data import Raw_VRP_Data
+from just_time_windows.dataloader import VRP_Dataset
+
+
+dataset = VRP_Dataset(dataset_size=10, num_depots=1, num_nodes=12)
+
+batch = dataset.get_batch(0, 10)
+
+nn_actor = NN_Actor(model=None, num_movers=10, num_neighbors_action=1)
+
+
+nn_output = nn_actor(batch)
+time = nn_output['total_time']
+arrival_times = nn_output['arrival_times']
+
+
+output = evaluate_google_model(dataset)
+
+
+
+print(arrival_times)
+print(time.mean().item())
+print(output.mean().item())