Shipment Delay Prediction

Solution Background and Business Value

Shipment delays disrupt supply chains, increasing costs, creating inventory shortages, and reducing customer satisfaction. They affect production schedules, logistics efficiency, and overall competitiveness.

Kumo’s AI-driven predictive models analyze historical shipment data to forecast potential delivery delays. The models draw on past shipment records, carrier performance, and external factors such as weather and traffic to generate accurate predictions without extensive manual feature engineering.

Predicting shipment delays enables better planning and resource allocation, reduces costs from last-minute adjustments, and improves supply chain efficiency. Reliable delivery performance builds customer trust and competitive advantage.

Data Requirements and Schema

The following tables form the core data model for shipment delay prediction. Additional tables can improve prediction accuracy.

Core Tables

1. Shipments: Contains core shipment details.

   • shipment_id (Primary Key)

   • order_id (Foreign Key referencing Orders)

   • origin (Origin location)

   • destination (Destination location)

   • ship_date (Date of shipment)

   • actual_delivery_date (Date shipment was delivered)

2. Orders: Contains order information linked to shipments.

   • order_id (Primary Key)

   • customer_id (Foreign Key referencing Customers)

   • order_date (Order placement date)

   • total_amount (Total order value)

   • priority (High, Medium, Low)

3. Customers: Stores details about customers placing orders.

   • customer_id (Primary Key)

   • Additional customer attributes

4. Locations: Stores warehouse and delivery location information.

   • location_id (Primary Key)

   • location_name

   • address

   • city, state, zip_code

5. Shipment_Events: Logs shipment progress and delays.

   • event_id (Primary Key)

   • shipment_id (Foreign Key referencing Shipments)

   • event_date (Event timestamp)

   • event_type (Event status: Picked up, In transit, Delayed, and so on)

   • event_value (Details, including delay duration)

   • location_id (Foreign Key referencing Locations)

Entity Relationship Diagram (ERD)

Predictive Queries

The following predictive queries cover common shipment delay forecasting scenarios:

1. Predict if a shipment will be delayed:

   1
   PREDICT Shipments.delay_duration > 0
   2
   FOR EACH Shipments.shipment_id

2. Predict delay for shipments sent in the last 7 days:

   1
   PREDICT Shipments.delay_duration > 0
   2
   FOR EACH Shipments.shipment_id
   3
   WHERE COUNT(Shipment_events.event_type,-7,0,days) > 0

3. Predict delay after reaching the first location:

   1
   PREDICT COUNT(Shipments.event_type == "Delayed", 0, X) > 0
   2
   FOR EACH Shipments.shipment_id
   3
   WHERE COUNT(Shipment_events.event_type == "Shipped" ,-7,0,days) > 0
   4
   AND COUNT(Location.location_id, -7,0, days) == 2

4. Predict delay duration for shipments:

   1
   PREDICT Shipments.delay_duration
   2
   FOR EACH Shipments.shipment_id

Building Models with the Kumo Fine-Tune SDK

1. Select tables

1
import kumoai as kumo
2
3
kumo.init(url="<your_kumo_url>", api_key="<your_api_key>")
4
connector = kumo.S3Connector("s3://your-dataset-bucket/")
5
6
shipments = kumo.Table.from_source_table(source_table=connector.table('shipments'), primary_key='shipment_id').infer_metadata()
7
orders = kumo.Table.from_source_table(source_table=connector.table('orders'), primary_key='order_id').infer_metadata()
8
customers = kumo.Table.from_source_table(source_table=connector.table('customers'), primary_key='customer_id').infer_metadata()
9
locations = kumo.Table.from_source_table(source_table=connector.table('locations'), primary_key='location_id').infer_metadata()
10
shipment_events = kumo.Table.from_source_table(source_table=connector.table('shipment_events'), primary_key='event_id').infer_metadata()

2. Create graph schema

1
graph = kumo.Graph(
2
    tables={
3
        'shipments': shipments,
4
        'orders': orders,
5
        'customers': customers,
6
        'locations': locations,
7
        'shipment_events': shipment_events,
8
    },
9
    edges=[
10
        dict(src_table='shipments', fkey='order_id', dst_table='orders'),
11
        dict(src_table='orders', fkey='customer_id', dst_table='customers'),
12
        dict(src_table='shipment_events', fkey='shipment_id', dst_table='shipments'),
13
        dict(src_table='shipment_events', fkey='location_id', dst_table='locations'),
14
    ],
15
)
16
graph.validate(verbose=True)

3. Train the model

1
pquery = kumo.PredictiveQuery(
2
    graph=graph,
3
    query="PREDICT Shipments.delay_duration FOR EACH Shipments.shipment_id"
4
)
5
pquery.validate(verbose=True)
6
7
model_plan = pquery.suggest_model_plan()
8
trainer = kumo.Trainer(model_plan)
9
training_job = trainer.fit(graph=graph, train_table=pquery.generate_training_table(non_blocking=True), non_blocking=False)
10
print(f"Training metrics: {training_job.metrics()}")

4. Run model

1
prediction_job = trainer.predict(
2
    graph=graph,
3
    prediction_table=pquery.generate_prediction_table(non_blocking=True),
4
    output_connector=connector,
5
    output_table_name='shipment_delay_predictions',
6
    non_blocking=False,
7
)
8
print(f'Prediction summary: {prediction_job.summary()}')