Item-to-Item Recommendation

Overview

Item-to-item recommendations help users discover products similar to what they are currently viewing or have purchased. This technique powers features like “You might also like” and “Frequently bought together” on e-commerce platforms. These recommendations:

• Increase customer engagement by surfacing relevant products.

• Boost conversion rates by promoting co-purchased or similar items.

• Enhance personalization by learning from user behavior patterns.

Kumo AI can generate rich item embeddings optimized for co-purchases, not just semantic similarity (for example, recommending cereal when someone buys milk instead of just different types of milk). It balances purchase, view, and interaction signals to go beyond simple text matching.

Data Requirements and Schema

To train an item-to-item recommendation model, you need structured data that captures relationships between items based on user behavior.

Core Tables

1. Purchase Item Pairs Table

   • Captures item co-occurrence based on user behavior (for example, items bought in the same order or session).

   • Key attributes:

     • item_id_lhs: The primary item (left-hand side).

     • item_id_rhs: The similar/co-purchased item (right-hand side).

     • Optional: Purchase session, timestamps, user interactions.

2. Items Table (LHS & RHS)

   • Represents unique items in the dataset (even if LHS and RHS contain the same data, Kumo requires them as separate tables).

   • Key attributes:

     • item_id: Unique product identifier.

     • Optional: Category, price, brand, description, image embeddings.

3. Users Table (Optional)

   • Stores customer details that can improve recommendations.

   • Key attributes:

     • user_id: Unique identifier.

     • Optional: Location, demographics, past purchase patterns.

Entity Relationship Diagram (ERD)

Predictive Queries

The following predictive query ranks the top 20 most relevant items for each product:

PREDICT LIST_DISTINCT(purchase_item_pairs.item_id_rhs)
RANK TOP 20
FOR EACH items_lhs.item_id_lhs

Time-Based Ranking

If you want to factor in temporal dynamics (for example, trends over the last N days):

PREDICT LIST_DISTINCT(purchase_item_pairs.item_id_rhs, 0, N, days)
RANK TOP 20
FOR EACH items_lhs.item_id_lhs

Handling Cold-Start Items

For businesses where new items frequently appear, consider enabling Kumo’s cold-start handling in the model plan:

handle_new_target_entities: true

This ensures the model learns from item attributes when no purchase history exists.

Deployment Strategy

Batch Recommendations in a Key-Value Store

A common way to serve item recommendations is to precompute them and store them in a key-value store for low-latency retrieval:

1
ITEM_ID_1 : {ITEM_ID_A, ITEM_ID_B, ..., ITEM_ID_N} 
2
# LHS_ITEM : {Recommended items for LHS_ITEM}

Using Embeddings for Similarity Scores

Instead of retrieving static predictions, you can use dot product similarity between embeddings to dynamically compute item similarity scores. This enables:

• Personalized recommendations based on the user’s session.

• Real-time filtering to exclude items already viewed by the user.

Example workflow:

1. Cache top-10 recommendations for each item in a key-value store.

2. Store LHS and RHS embeddings in a vector database.

3. During a session:

   • Show cached recommendations first.

   • If the user exhausts cached items, backfill recommendations dynamically using dot product similarity.

This hybrid approach trades off latency against freshness.

Building Models with the Kumo Fine-Tune SDK

1. Initialize the Kumo Fine-Tune SDK

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

2. Create a Connector for Data Storage

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

3. Select Tables

1
items_lhs = kumo.Table.from_source_table(
2
    source_table=connector.table('items_lhs'),
3
    primary_key='item_id_lhs',
4
).infer_metadata()
5
6
items_rhs = kumo.Table.from_source_table(
7
    source_table=connector.table('items_rhs'),
8
    primary_key='item_id_rhs',
9
).infer_metadata()
10
11
purchase_item_pairs = kumo.Table.from_source_table(
12
    source_table=connector.table('purchase_item_pairs'),
13
    time_column=None,
14
).infer_metadata()

4. Create Graph Schema

1
graph = kumo.Graph(
2
    tables={
3
        'items_lhs': items_lhs,
4
        'items_rhs': items_rhs,
5
        'purchase_item_pairs': purchase_item_pairs,
6
    },
7
    edges=[
8
        dict(src_table='purchase_item_pairs', fkey='item_id_lhs', dst_table='items_lhs'),
9
        dict(src_table='purchase_item_pairs', fkey='item_id_rhs', dst_table='items_rhs'),
10
    ],
11
)
12
13
graph.validate(verbose=True)

5. Train the Model

1
pquery = kumo.PredictiveQuery(
2
    graph=graph,
3
    query="PREDICT LIST_DISTINCT(purchase_item_pairs.item_id_rhs) RANK TOP 20 FOR EACH items_lhs.item_id_lhs"
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(
10
    graph=graph,
11
    train_table=pquery.generate_training_table(non_blocking=True),
12
    non_blocking=False,
13
)
14
print(f"Training metrics: {training_job.metrics()}")