How Logistics Companies Use Machine Learning for Growth

# ETA prediction — the most impactful ML problem in logistics
# (predicting delivery time for a given shipment)

import pandas as pd
import numpy as np
import xgboost as xgb
from sklearn.metrics import mean_absolute_error
from sklearn.model_selection import train_test_split

# Historical shipment data
df = pd.read_parquet("s3://logistics-lake/shipments/")

# Feature engineering — most of the work
df["pickup_hour"] = pd.to_datetime(df["pickup_time"]).dt.hour
df["pickup_day_of_week"] = pd.to_datetime(df["pickup_time"]).dt.dayofweek
df["is_weekend"] = df["pickup_day_of_week"].isin([5, 6]).astype(int)
df["is_festival_day"] = df["pickup_date"].isin(festival_dates).astype(int)

# Distance + route features
df["route_distance_km"] = df["distance_km"]  # precomputed
df["traffic_factor"] = df["historical_traffic_for_hour"]

# Weather at origin + destination
df = df.merge(weather_df, on=["origin_city", "pickup_date"], how="left")
df["weather_severity"] = df["rain_mm"] * 0.3 + df["wind_speed_kph"] * 0.1

# Driver + vehicle features
df["driver_experience_years"] = df["driver_years"]
df["vehicle_age_months"] = df["vehicle_age"]
df["is_owned_vehicle"] = (df["vehicle_type"] == "owned").astype(int)

# Target: actual ETA (delivery - pickup, in minutes)
df["actual_eta_minutes"] = (
    pd.to_datetime(df["delivery_time"]) - pd.to_datetime(df["pickup_time"])
).dt.total_seconds() / 60

# Train/test split by time
cutoff = df["pickup_date"].max() - pd.Timedelta(days=30)
train = df[df["pickup_date"] < cutoff]
test = df[df["pickup_date"] >= cutoff]

features = [
    "pickup_hour", "pickup_day_of_week", "is_weekend", "is_festival_day",
    "route_distance_km", "traffic_factor",
    "rain_mm", "wind_speed_kph", "weather_severity",
    "driver_experience_years", "vehicle_age_months", "is_owned_vehicle",
]

model = xgb.XGBRegressor(
    n_estimators=800, max_depth=7,
    learning_rate=0.05, subsample=0.8,
    colsample_bytree=0.8, early_stopping_rounds=30,
)
model.fit(
    train[features], train["actual_eta_minutes"],
    eval_set=[(test[features], test["actual_eta_minutes"])],
    verbose=False,
)

# Evaluate — MAE in minutes
preds = model.predict(test[features])
mae_minutes = mean_absolute_error(test["actual_eta_minutes"], preds)
print(f"MAE: {mae_minutes:.1f} minutes")  # Industry benchmark: 15–30 min

# Real skills: feature engineering, time-series-aware splits,
# external features (weather, traffic), XGBoost, MAE evaluation.
# This is exactly what logistics ML interviews test.

# Route optimisation — a classic logistics ML + OR problem
# (minimising total distance while respecting constraints)

from ortools.constraint_solver import routing_enums_pb2, pywrapcp

def solve_route(distance_matrix, num_vehicles=1, depot=0):
    """
    Given a distance matrix, find the shortest route that
    visits every location once and returns to depot.
    This is the Traveling Salesman Problem (TSP) — real logistics
    adds time windows, capacity, and multi-vehicle constraints.
    """
    manager = pywrapcp.RoutingIndexManager(
        len(distance_matrix), num_vehicles, depot
    )
    routing = pywrapcp.RoutingModel(manager)

    # Distance callback
    def distance_callback(from_index, to_index):
        return distance_matrix[manager.IndexToNode(from_index)][
            manager.IndexToNode(to_index)
        ]

    transit_callback_index = routing.RegisterTransitCallback(distance_callback)
    routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)

    # Solve — use path cheapest arc + guided local search
    search_params = pywrapcp.DefaultRoutingSearchParameters()
    search_params.first_solution_strategy = (
        routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC
    )
    search_params.local_search_metaheuristic = (
        routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH
    )
    search_params.time_limit.seconds = 30

    solution = routing.SolveWithParameters(search_params)

    if solution:
        route = []
        index = routing.Start(0)
        while not routing.IsEnd(index):
            route.append(manager.IndexToNode(index))
            index = solution.Value(routing.NextVar(index))
        route.append(manager.IndexToNode(index))
        return route, solution.ObjectiveValue()
    return None, None

# Real logistics extends this with:
# - Time windows (VRPTW)
# - Vehicle capacities (CVRP)
# - Multi-depot, multi-vehicle
# - Real-time traffic + dynamic re-routing
# - ML to predict travel times between stops

# Skills: OR-Tools, constraint programming, TSP/VRP algorithms,
# ML integration for edge weights.