Create vrp_core.py

vrp_core.py

@@ -0,0 +1,287 @@
+from __future__ import annotations
+import os, io, json, zipfile, math, time, logging, pathlib, shutil, re, random, hashlib
+from dataclasses import dataclass
+from typing import Dict, List, Tuple, Optional
+import numpy as np
+import pandas as pd
+from scipy.spatial.distance import cdist
+import subprocess
+import tempfile
+import requests
+
+LOGGER = logging.getLogger("cuopt_cvrptw.core")
+
+DATA_CACHE_DIR = os.environ.get("CUOPT_DATA_DIR", "/tmp/data/cuopt_cvrptw")
+os.makedirs(DATA_CACHE_DIR, exist_ok=True)
+
+HOMBERGER_URLS = [
+    # Multiple mirrors to improve resilience; the app tries each in order.
+    # If all fail, the user can upload a local .TXT instance.
+    "https://www.sintef.no/projectweb/top/vrptw/homberger-benchmark/",
+    "https://lopez-ibanez.eu/benchmarking/vrptw-homberger",
+]
+
+DEFAULT_INSTANCE = "C1_10_1.TXT"  # 1000 customers
+
+@dataclass
+class GPUInfo:
+    available: bool
+    name: Optional[str] = None
+    driver: Optional[str] = None
+    cuda_version: Optional[str] = None
+    memory_total_mb: Optional[int] = None
+    cudf_version: Optional[str] = None
+    cuopt_version: Optional[str] = None
+    details_raw: Optional[str] = None
+    error: Optional[str] = None
+
+def _try_imports():
+    mods = {}
+    try:
+        import cudf  # type: ignore
+        mods["cudf"] = cudf
+    except Exception as e:
+        mods["cudf_error"] = str(e)
+    try:
+        # cuOpt package name may vary by CUDA; use the generic import path.
+        import cuopt  # type: ignore
+        mods["cuopt"] = cuopt
+    except Exception as e:
+        mods["cuopt_error"] = str(e)
+    return mods
+
+def check_gpu() -> GPUInfo:
+    """Collects environment and GPU details using nvidia-smi and optional cudf/cuopt versions."""
+    available = False
+    name = driver = cuda = None
+    mem_total = None
+    raw = ""
+    try:
+        out = subprocess.check_output(["nvidia-smi"], stderr=subprocess.STDOUT, text=True, timeout=5)
+        raw = out
+        available = True
+        # Parse simple fields
+        m_name = re.search(r"GPU 0:\s*([^,|]+)", out)
+        if m_name: name = m_name.group(1).strip()
+        m_driver = re.search(r"Driver Version:\s*([0-9.]+)", out)
+        if m_driver: driver = m_driver.group(1)
+        m_cuda = re.search(r"CUDA Version:\s*([0-9.]+)", out)
+        if m_cuda: cuda = m_cuda.group(1)
+        # Memory total (MiB)
+        m_mem = re.findall(r"\|\s+(\d+)\s*MiB /\s*(\d+)\s*MiB\s*\|", out)
+        if m_mem and m_mem[0]:
+            mem_total = int(m_mem[0][1])
+    except Exception as e:
+        return GPUInfo(False, error=f"nvidia-smi not available or failed: {e}")
+
+    mods = _try_imports()
+    cudf_v = getattr(mods.get("cudf"), "__version__", None) if "cudf" in mods else None
+    cuopt_v = getattr(mods.get("cuopt"), "__version__", None) if "cuopt" in mods else None
+
+    return GPUInfo(True, name, driver, cuda, mem_total, cudf_v, cuopt_v, details_raw=raw)
+
+def download_dataset(dest_dir: str = DATA_CACHE_DIR) -> Tuple[bool, str]:
+    """Attempt to download and cache the Homberger dataset. Returns (ok, message)."""
+    try:
+        os.makedirs(dest_dir, exist_ok=True)
+        # If already present (some .TXT files), skip
+        if list_instances(dest_dir):
+            return True, f"Dataset already present at {dest_dir}."
+        # Attempt crude scrape of links and download .zip/.7z if available
+        session = requests.Session()
+        for base in HOMBERGER_URLS:
+            try:
+                r = session.get(base, timeout=15)
+                r.raise_for_status()
+                # look for zip link names
+                zip_links = re.findall(r'href="([^"]+homberger[^"]+\.(zip|7z))"', r.text, re.IGNORECASE)
+                if not zip_links:
+                    continue
+                # take first link
+                rel, _ = zip_links[0]
+                url = rel if rel.startswith("http") else requests.compat.urljoin(base, rel)
+                z = session.get(url, timeout=60)
+                z.raise_for_status()
+                archive_path = os.path.join(dest_dir, os.path.basename(url))
+                with open(archive_path, "wb") as f:
+                    f.write(z.content)
+                # Try unzip if zip
+                if archive_path.lower().endswith(".zip"):
+                    with zipfile.ZipFile(archive_path, 'r') as zf:
+                        zf.extractall(dest_dir)
+                else:
+                    # 7z not handled; ask user to upload or manually extract
+                    return False, f"Downloaded {archive_path} but cannot extract .7z automatically. Upload a .TXT or extract manually."
+                if list_instances(dest_dir):
+                    return True, f"Downloaded and extracted dataset to {dest_dir}."
+            except Exception as e:
+                LOGGER.warning("Dataset fetch attempt failed from %s: %s", base, e)
+        return False, "Failed to auto-download dataset from known mirrors. Please upload a .TXT file or place files under /tmp/data/cuopt_cvrptw."
+    except Exception as e:
+        return False, f"Download error: {e}"
+
+def list_instances(dest_dir: str = DATA_CACHE_DIR) -> List[str]:
+    out = []
+    for root, _, files in os.walk(dest_dir):
+        for fn in files:
+            if fn.upper().endswith(".TXT"):
+                out.append(os.path.join(root, fn))
+    return sorted(out)
+
+def _read_txt(path: str) -> pd.DataFrame:
+    """
+    Parses Homberger/Gehring CVRPTW .TXT format.
+    Columns (typical): cust_no, x, y, demand, ready_time, due_date, service_time
+    Depot is usually row with cust_no == 0 or first line.
+    """
+    with open(path, "r", encoding="latin-1") as f:
+        lines = [ln.strip() for ln in f if ln.strip()]
+    # heuristic: skip header lines until we find a line that begins with an integer id
+    data_lines = []
+    for ln in lines:
+        if re.match(r"^\d+(\s+[-+]?\d+(\.\d+)*)+", ln):
+            data_lines.append(ln)
+    if not data_lines:
+        raise ValueError("Could not find data rows with numeric columns.")
+    rows = []
+    for ln in data_lines:
+        parts = re.split(r"\s+", ln)
+        if len(parts) < 7:
+            # try to pad or skip
+            continue
+        cust_no = int(parts[0])
+        x = float(parts[1]); y = float(parts[2])
+        demand = float(parts[3])
+        ready = float(parts[4]); due = float(parts[5]); service = float(parts[6])
+        rows.append((cust_no, x, y, demand, ready, due, service))
+    if not rows:
+        raise ValueError("No valid rows parsed. Confirm file format.")
+    df = pd.DataFrame(rows, columns=["cust_no","x","y","demand","ready_time","due_time","service_time"])
+    return df
+
+def create_from_file(file_path: str) -> Dict:
+    """
+    Read .TXT and return a structured dict with nodes, depot, capacity guess, etc.
+    """
+    df = _read_txt(file_path)
+    # Ensure depot exists
+    if 0 not in set(df["cust_no"].values):
+        # Assume first row depot
+        df.loc[df.index[0], "cust_no"] = 0
+    df = df.sort_values("cust_no").reset_index(drop=True)
+    # Estimate default capacity: use 10x 95th percentile demand as a heuristic
+    cap = max(1, int(10 * np.percentile(df["demand"].values[1:], 95)))
+    out = {
+        "meta": {
+            "instance_id": pathlib.Path(file_path).name,
+            "n_nodes": int(df.shape[0]),
+            "n_customers": int(df.shape[0]-1),
+            "estimated_capacity": int(cap),
+        },
+        "data": df
+    }
+    return out
+
+def build_data_model(df: pd.DataFrame, capacity: int, n_vehicles: Optional[int] = None) -> Dict:
+    """
+    Build a generic data structure expected by cuOpt. We avoid a hard dependency here;
+    the solver will convert this dictionary to actual cuOpt DataModel if available.
+    """
+    coords = df[["x","y"]].to_numpy(dtype=np.float32)
+    dist = cdist(coords, coords, metric="euclidean").astype(np.float32)
+
+    # time windows
+    tw = df[["ready_time","due_time"]].to_numpy(dtype=np.float32)
+    service = df["service_time"].to_numpy(dtype=np.float32)
+    demand = df["demand"].to_numpy(dtype=np.float32)
+
+    model = {
+        "distance_matrix": dist,
+        "time_windows": tw,
+        "service_times": service,
+        "demand": demand,
+        "depot": 0,
+        "vehicle_capacity": float(capacity),
+        "n_vehicles": int(n_vehicles) if n_vehicles else None,
+    }
+    return model
+
+def _to_cuopt_model(model: Dict):
+    mods = _try_imports()
+    if "cuopt" not in mods:
+        raise RuntimeError(f"cuOpt not installed: {mods.get('cuopt_error','unknown')}")
+    cuopt = mods["cuopt"]
+    # The actual cuOpt API may differ; below is a representative outline.
+    dm = cuopt.DataModel()
+    dm.add_cost_matrix(model["distance_matrix"])
+    dm.add_time_windows(model["time_windows"])
+    dm.add_service_times(model["service_times"])
+    dm.add_demands(model["demand"], model["vehicle_capacity"])
+    dm.set_depot(model["depot"])
+    if model.get("n_vehicles"):
+        dm.set_number_of_vehicles(model["n_vehicles"])
+    return dm
+
+def run_solver(model: Dict, time_limit_s: int, seed: Optional[int] = None) -> Dict:
+    """Run cuOpt solver with a wall-clock limit. Returns metrics dict for UI."""
+    start = time.time()
+    mods = _try_imports()
+    if "cuopt" not in mods:
+        raise RuntimeError(f"cuOpt not installed: {mods.get('cuopt_error','unknown')}")
+    cuopt = mods["cuopt"]
+    dm = _to_cuopt_model(model)
+    cfg = cuopt.SolverConfig()
+    cfg.time_limit = int(time_limit_s)
+    if seed is not None:
+        try:
+            cfg.random_seed = int(seed)
+        except Exception:
+            pass
+
+    solver = cuopt.Solver(dm, cfg)
+    status = solver.solve()
+    runtime = time.time() - start
+
+    # Extract fields safely
+    try:
+        total_cost = float(solver.get_objective())
+    except Exception:
+        total_cost = float("nan")
+    try:
+        vehicles_used = int(solver.get_vehicles_used())
+    except Exception:
+        vehicles_used = None
+
+    return {
+        "status": int(status) if isinstance(status, (int, np.integer)) else 0,
+        "objective": total_cost,
+        "vehicles_used": vehicles_used,
+        "runtime_s": runtime,
+        "time_limit_s": int(time_limit_s),
+        "seed": seed,
+    }
+
+def evaluate_against_bks(metrics: Dict, bks: Dict) -> Dict:
+    out = {}
+    if bks.get("vehicles"):
+        if metrics.get("vehicles_used") is not None:
+            out["delta_vehicles"] = metrics["vehicles_used"] - float(bks["vehicles"])
+        else:
+            out["delta_vehicles"] = None
+    if bks.get("cost"):
+        if not math.isnan(metrics.get("objective", float("nan"))):
+            out["delta_cost"] = metrics["objective"] - float(bks["cost"])
+            if bks["cost"] > 0:
+                out["pct_over_bks"] = 100.0 * out["delta_cost"] / float(bks["cost"])
+    return out
+
+def safe_hash(s: str) -> str:
+    return hashlib.sha1(s.encode("utf-8")).hexdigest()[:10]
+
+def write_csv(path: str, rows: List[Dict]):
+    df = pd.DataFrame(rows)
+    df.to_csv(path, index=False)
+
+def write_json(path: str, obj: Dict):
+    with open(path, "w") as f:
+        json.dump(obj, f, indent=2)