Demand Forecasting Solution

Solution Background and Business Value

Demand forecasting predicts future item demand so businesses can optimize inventory, reduce waste, and improve operational efficiency across sales, retail, manufacturing, and supply chain.

For example, a meal kit delivery service uses demand forecasting to order the correct amount of raw ingredients per recipe, preventing shortages and minimizing waste.

Forecasting accuracy is typically measured using MAE (Mean Absolute Error) or SMAPE (Symmetric Mean Absolute Percentage Error). Depending on business needs, forecasts can target different time frames and aggregation levels:

• Forecasting the number of orders per recipe group six weeks ahead.

• Predicting the total demand for specific ingredients over the next 28 days.

Data Requirements and Schema

Core Tables

1. Sales/Orders Table: Captures historical sales transactions.

   • order_id (Primary Key)

   • item_id (Foreign Key referencing Items)

   • buyer_id (Foreign Key referencing Buyers)

   • group_id (Foreign Key referencing Groups)

   • event_id (Foreign Key referencing Events)

   • timestamp (Date and time of the sale)

   • quantity (Number of items sold)

2. Items Table: Stores static information about each item.

   • item_id (Primary Key)

3. Groups Table: Categorizes items for aggregated forecasting.

   • group_id (Primary Key)

4. Buyers Table: Contains buyer information to enhance predictive accuracy.

   • buyer_id (Primary Key)

5. Events Table: Records external factors that may affect demand, such as holidays or promotions.

   • event_id (Primary Key)

   • timestamp (Date and time of the event)

Entity Relationship Diagram (ERD)

Predictive Queries

Kumo expresses demand forecasting logic as Predictive Queries: SQL-like statements that define what to predict and over what time window. The syntax PREDICT <aggregation>(table.column, start_offset, end_offset, time_unit) FOR EACH table.id_column specifies the aggregation function, the prediction window as offsets from the anchor time, and the entity to predict for.

1. Forecasting demand using order count:

   1
   PREDICT COUNT(sales.*, 0, 30, days)
   2
   FOR EACH items.item_id

2. Forecasting demand using sum of item quantities:

   1
   PREDICT SUM(sales.quantity, 0, 30, days)
   2
   FOR EACH items.item_id

3. Forecasting at an aggregated category level:

   1
   PREDICT SUM(sales.quantity, 0, 30, days)
   2
   FOR EACH groups.group_id

4. Predicting demand six weeks into the future:

   1
   PREDICT SUM(sales.quantity, 35, 42, days)
   2
   FOR EACH groups.group_id

5. Filtering out instances where demand is zero:

   1
   PREDICT SUM(sales.quantity, 0, 30, days)
   2
   FOR EACH groups.group_id
   3
   ASSUMING SUM(sales.quantity, 0, 30, days) > 0

Deployment Strategy

Demand forecasting models are typically deployed in automated pipelines that refresh predictions on a set cadence (daily, weekly, or monthly).

1. Data Preparation: Refresh the latest sales and entity data snapshots in the data warehouse.

2. Model Inference: Kumo ingests the data and generates future demand predictions, storing results in the configured output location.

3. Data Transformation: Apply post-processing as needed. For example, clamp negative predictions to zero:

   1
   SELECT item_id,
   2
          CASE
   3
              WHEN TARGET_PRED < 0 THEN 0
   4
              ELSE TARGET_PRED
   5
          END AS TARGET_PRED
   6
   FROM PREDICTIONS

4. Consumption: Analysts review predictions for strategic decision-making or feed them directly into downstream applications for inventory planning, marketing, and logistics.

Building models in Kumo Fine-Tune SDK

1. Initialize the Kumo Fine-Tune SDK

1
import kumoai as kumo
2
3
# Initialize Kumo client
4
kumo.init(url="https://<customer_id>.kumoai.cloud/api", api_key=API_KEY)

2. Connect Data

1
connector = kumo.S3Connector("s3://your-dataset-location/")

3. Select tables

1
sales = kumo.Table.from_source_table(source_table=connector.table("sales"), primary_key="order_id", time_column="timestamp").infer_metadata()
2
3
items = kumo.Table.from_source_table(source_table=connector.table("items"), primary_key="item_id").infer_metadata()
4
5
groups = kumo.Table.from_source_table(source_table=connector.table("groups"), primary_key="group_id").infer_metadata()
6
7
buyers = kumo.Table.from_source_table(source_table=connector.table("buyers"), primary_key="buyer_id").infer_metadata()
8
9
events = kumo.Table.from_source_table(source_table=connector.table("events"), primary_key="event_id", time_column="timestamp").infer_metadata()

4. Create graph schema

1
graph = kumo.Graph(tables={"sales": sales, "items": items, "groups": groups, "buyers": buyers, "events": events}, edges=[
2
    {"src_table": "sales", "fkey": "item_id", "dst_table": "items"},
3
    {"src_table": "sales", "fkey": "buyer_id", "dst_table": "buyers"},
4
    {"src_table": "sales", "fkey": "group_id", "dst_table": "groups"},
5
    {"src_table": "sales", "fkey": "event_id", "dst_table": "events"}
6
])
7
graph.validate(verbose=True)

5. Train the model

1
pquery = kumo.PredictiveQuery(graph=graph, query="""PREDICT SUM(sales.quantity, 0, 30, days) FOR EACH items.item_id""")
2
pquery.validate(verbose=True)
3
model_plan = pquery.suggest_model_plan()
4
trainer = kumo.Trainer(model_plan)
5
training_job = trainer.fit(graph=graph, train_table=pquery.generate_training_table(non_blocking=True), non_blocking=False)
6
print(f"Training metrics: {training_job.metrics()}")