Synthetic data for recommendation systems

Summary

• Synthetic data for recommendation systems is artificially generated interaction data (views, clicks, searches, cart adds, purchases, ratings) used to train, pre-train, or evaluate a recommender.
• It matters most for the cold-start problem: new stores, new catalogs, and new users have too few interactions for collaborative filtering or sequential models to learn from.
• There are five main sources: browser-agent simulation on your live site, tabular synthesizers, recommender simulators, LLM-agent research simulators, and public datasets. Only browser-agent simulation produces behavior on your catalog without needing data you don't have yet.
• Polanyi Labs is a browser-agent simulation tool. Give it a URL and AI shoppers, cast from NVIDIA Nemotron-Personas-USA, browse the site and return a recsys_events.jsonl event log.
• Use synthetic data to bootstrap and evaluate, then blend in real interactions and confirm with A/B tests.

What is synthetic data for recommendation systems?

A recommender learns preference from behavior: which items people saw, opened, compared, saved, added to cart, and bought. Synthetic recommendation data is that same behavior generated by a model or a simulation instead of being collected from real users. It is usually delivered as an interaction log: one row per event, with a user (or session), an item, an event type, a timestamp or sequence position, and context.

Good synthetic data looks like real data to the model that consumes it. It has realistic sparsity, popularity skew, sessions with intent, negative signals (items seen and skipped), and a mix of weak implicit feedback and strong explicit feedback.

Why recommenders need it: the cold-start problem

Collaborative filtering, matrix factorization, two-tower retrieval, and sequential models like SASRec or BERT4Rec all learn from interaction history. A store that launched last month, a brand with a few thousand monthly sessions, or a catalog full of new products doesn't have that history. The result is generic, popularity-ranked recommendations for exactly the visitors a growing brand most needs to convert.

The standard cold-start remedies each have limits:

• Popularity and rules: easy, but not personal.
• Content-based features: help with new items, but don't capture how people actually trade off products.
• Onboarding questionnaires: add friction, and many visitors skip them.
• Transfer from public datasets: real behavior, but from a different catalog and audience.
• Waiting: works eventually, at the cost of months or years of weak personalization.

Synthetic interaction data adds a sixth option: generate dense, catalog-specific behavior up front so the model has something to learn from on day one.

Tools and methods for generating recommendation data

1. Browser-agent simulation on your live site (Polanyi Labs)

AI agents with distinct personas and goals open your real website in a browser and shop: search, filter, open product pages, compare, add to cart, and choose. Every action is logged as a recommendation event. Because the agents use your actual catalog, navigation, and search, the resulting data reflects your products and your site. Because it needs only a URL, it works before you have users. See how Polanyi does it.

2. Tabular and relational synthesizers

Tools like the open-source SDV (Synthetic Data Vault), MOSTLY AI, and Gretel learn the statistical structure of an existing dataset and generate new rows that preserve it. They're excellent for privacy-safe sharing and augmentation, but they can only reproduce patterns that are already in your data. With no interaction history, there is nothing for them to learn from.

3. Recommender simulators

RecSim NG (Google Research), RecoGym (Criteo), KuaiSim, and Virtual Taobao provide environments where simulated users respond to recommendations, mainly for reinforcement-learning research. You get control and reproducibility, but you have to specify or fit the user model, and the environment is an abstraction of a platform, not your storefront.

4. LLM-agent simulators from research

Recent research systems such as RecAgent and Agent4Rec use LLM-powered agents as simulated users inside a sandboxed recommender. They show that language-model agents can mimic preference patterns. They're research code, typically built around existing datasets like MovieLens rather than a live product.

5. Public datasets

MovieLens, Amazon Reviews, RetailRocket, and YOOCHOOSE are real and well studied. Use them to benchmark architectures or pre-train, but their items, audience, and site design aren't yours.

How Polanyi Labs generates recommendation data

1. Cast a population. Shoppers are drawn from NVIDIA Nemotron-Personas-USA, with real demographic spread: age, location, occupation, interests, and personality.
2. Give each a goal. Every shopper gets a different objective and context, so journeys diverge the way real ones do.
3. Diagnose the site, then shop. Polanyi inspects your live site, then each shopper browses it in a real cloud browser, hard-pinned to your domain.
4. Record every interaction. Impressions, views, searches, filters, cart adds, and selections become structured events with a feedback class and signal strength.
5. Stop at the boundary. Shoppers never enter personal or payment details. Checkout hand-offs are logged as boundary events.

Each run returns personas.json, recsys_events.jsonl (also as Parquet), and summary.json. The docs list every field.

What one event looks like

{
  "event_type": "item_selected",
  "item_id": "B0C3HCD34R",
  "session_id": "ses_…",
  "actor_id": "syn_mary_alberti_…",
  "sequence_index": 15,
  "feedback_class": "implicit",
  "signal_strength": "very_strong",
  "observed": true,
  "is_synthetic": true,
  "training_use": "offline_sandbox_only"
}

Using synthetic events in your recommender

• Bootstrap a cold-start model. Train collaborative-filtering or two-tower models on synthetic sessions so first visitors get more than popularity.
• Pre-train, then fine-tune. Pre-train sequential models on synthetic journeys and fine-tune on real events as they arrive.
• Weight by signal strength. Map signal_strength to implicit-feedback confidence weights (for example, impression < view < cart add < selection).
• Evaluate offline. Compare ranking variants on held-out synthetic sessions before spending real traffic on an A/B test.
• Cover the long tail. Generate behavior around products with no history so they can be ranked at all.

Limits to keep in mind

Synthetic behavior is a model of people, not people. Treat it as a prior. Keep synthetic and real actor IDs separate (Polanyi marks every event is_synthetic: true), blend in real interactions as you collect them, and measure impact with live experiments. Polanyi defaults every event to training_use: offline_sandbox_only for this reason.

Frequently asked questions

What is the best tool to generate data for a recommendation system?

It depends on what you already have. With no or little user history, use a simulation that runs on your own catalog, such as Polanyi Labs. If you already have interaction data and need privacy-safe copies, use a tabular synthesizer like SDV, MOSTLY AI, or Gretel. For reinforcement-learning research, use RecSim NG or RecoGym.

Can I build a recommender with no user data?

Yes. Start with content-based and popularity signals, then add synthetic interaction data generated on your catalog so collaborative and sequential models have behavior to learn from. Replace and reweight it with real data over time.

Is synthetic recommendation data privacy-safe?

Data generated by simulated shoppers contains no real customer information. Polanyi's shoppers are synthetic personas and stop before entering any personal or payment details.

More answers in the FAQ.