Try Something New

Solution Background and Business Value

Personalized try-something-new recommendations introduce customers to products they have not purchased before but are likely to enjoy based on their buying habits and preferences. This strategy enhances customer experience by encouraging product discovery while expanding sales into new product categories.

By integrating these recommendations into push notifications, in-product placements, and email campaigns, businesses can:

• Drive cross-selling opportunities by exposing customers to new product lines.

• Enhance customer satisfaction by keeping the shopping experience fresh.

• Increase engagement and retention by offering relevant and timely suggestions.

Data Requirements and Graph Schema

Building an effective Try-Something-New recommendation model requires a structured dataset. A small set of core tables is sufficient to start; adding more data sources can improve model quality.

Core Tables

Three core tables are required:

1. Users Table

   • Stores details about users for whom the model generates recommendations.

   • Key attributes:

     • user_id: Unique identifier (Primary Key).

     • join_timestamp: When the user joined.

     • Other optional features: age, location, and shopping behavior.

2. Items Table

   • Stores information about the items available for recommendation.

   • Key attributes:

     • item_id: Unique identifier (Primary Key).

     • start_timestamp / end_timestamp: Availability period of the item.

     • Other optional features: price, category, color, and brand.

3. Transactions Table

   • Stores user purchase history, which the model learns from.

   • Key attributes:

     • transaction_id: Unique identifier (Primary Key).

     • user_id: Foreign Key linking to Users.

     • item_id: Foreign Key linking to Items.

     • timestamp: When the purchase was made.

     • Other optional features: total amount, payment method, and discount applied.

Entity Relationship Diagram (ERD)

Predictive Query

The challenge in try-something-new recommendations is keeping recommendations novel to the user without discarding valuable purchase history. Training a model solely on first-time purchases would lose the broader patterns that drive good recommendations.

Instead, train a general item-to-user recommendation model and apply filters at prediction time to remove items the user has already purchased. This ensures:

• The model learns broad user-item affinity.

• Users receive only new product recommendations.

PREDICT LIST_DISTINCT(transactions.item_id, 0, X, days) RANK TOP 50
FOR EACH users.user_id

This query:

• Predicts the top 50 distinct items a user is likely to buy.

• Uses a future X-day window to determine potential purchases.

Filtering for New Recommendations

Try-something-new recommendations work best for less-active users. Target those with fewer than N purchases in the last D days by adding the following filter:

WHERE COUNT(transactions.*, -D, 0, days) < N

Building models in Kumo Predict SDK

The Kumo Predict SDK simplifies ML modeling on relational data and implements this solution in a few steps.

1. Initialize the Kumo Predict SDK

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

2. Connect data

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

3. Select tables

users = kumo.Table.from_source_table(
    source_table=connector.table('users'),
    primary_key='user_id',
).infer_metadata()
items = kumo.Table.from_source_table(
    source_table=connector.table('items'),
    primary_key='item_id',
).infer_metadata()
transactions = kumo.Table.from_source_table(
    source_table=connector.table('transactions'),
    time_column='timestamp',
).infer_metadata()

4. Create graph schema

graph = kumo.Graph(
    tables={
        'users': users,
        'items': items,
        'transactions': transactions,
    },
    edges=[
        dict(src_table='transactions', fkey='user_id', dst_table='users'),
        dict(src_table='transactions', fkey='item_id', dst_table='items'),
    ],
)
graph.validate(verbose=True)

5. Train the model

pquery = kumo.PredictiveQuery(
    graph=graph,
    query=(
        "PREDICT LIST_DISTINCT(transactions.item_id, 0, X, days) RANK TOP 50\n"
        "FOR EACH users.user_id"
    ),
)
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()}")

6. Run the model

prediction_job = trainer.predict(
    graph=graph,
    prediction_table=pquery.generate_prediction_table(non_blocking=True),
    output_types={'predictions', 'embeddings'},
    output_connector=connector,
    output_table_name='try_something_new_predictions',
    training_job_id=training_job.job_id,
    non_blocking=False,
)
print(f'Batch prediction job summary: {prediction_job.summary()}')