Item-to-Item Recommendation

​

Solution Background and Business Value

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 (e.g., recommending cereal when someone buys milk instead of just different types of milk). It balances signals from purchases, views, and interactions to improve recommendations beyond simple text matching.

​

Data Requirements and Schema

To train an item-to-item recommendation model, we 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 (e.g., 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 (e.g., 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:

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

At runtime, the application retrieves recommendations instantly for a given product.

Using Embeddings for Similarity Scores

Instead of retrieving static predictions, we 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 balances speed and flexibility.

​

Building models in Kumo SDK

1. Initialize the Kumo SDK

import kumoai as kumo

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

2. Create a Connector for Data Storage

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

3. Select tables

items_lhs = kumo.Table.from_source_table(
    source_table=connector.table('items_lhs'),
    primary_key='item_id_lhs',
).infer_metadata()

items_rhs = kumo.Table.from_source_table(
    source_table=connector.table('items_rhs'),
    primary_key='item_id_rhs',
).infer_metadata()

purchase_item_pairs = kumo.Table.from_source_table(
    source_table=connector.table('purchase_item_pairs'),
    time_column=None,
).infer_metadata()

4. Create graph schema

graph = kumo.Graph(
    tables={
        'items_lhs': items_lhs,
        'items_rhs': items_rhs,
        'purchase_item_pairs': purchase_item_pairs,
    },
    edges=[
        dict(src_table='purchase_item_pairs', fkey='item_id_lhs', dst_table='items_lhs'),
        dict(src_table='purchase_item_pairs', fkey='item_id_rhs', dst_table='items_rhs'),
    ],
)

graph.validate(verbose=True)

5. Train the Model

pquery = kumo.PredictiveQuery(
    graph=graph,
    query="PREDICT LIST_DISTINCT(purchase_item_pairs.item_id_rhs) RANK TOP 20 FOR EACH items_lhs.item_id_lhs"
)
pquery.validate(verbose=True)

model_plan = pquery.suggest_model_plan()
trainer = kumo.Trainer(model_plan)
training_job = trainer.fit(
    graph=graph,
    train_table=pquery.generate_training_table(non_blocking=True),
    non_blocking=False,
)
print(f"Training metrics: {training_job.metrics()}")