Overview

Netcore Unbxd provides 14 core recommendation algorithms, each powered by a specific signal type and optimised for different page types and user intents.

Let's understand how each algorithm works, their underlying logic, and the minimum data required for reliable performance.

📘

Before You Start

• Signal Type refers to the primary source of data an algorithm uses to generate recommendations.
• Cold Start refers to scenarios where there is insufficient data to generate reliable recommendations.

Available Recommendation Algorithms

Refer to the table below to understand what each recommendation algorithm does.

To access Algorithms, log in to the Netcore Unbxd Recommendation console and navigate to Algorithms > Core Algorithms.

Below is explained how each of the recommendation algorithms works:

Top Sellers

Top Sellers ranks products based on purchase volume within a rolling time window (default: 7 days). A time decay function ensures that recent purchases are weighted more heavily than older ones.

Formula: TopSeller Score(item) = Σ Orders(item, t) * TimeDecay(t) and TimeDecay(t) = e^(-λ * (T - t)) where:

T = current timestamp t = timestamp of each order event λ = decay constant (default ≈ 0.1 per day)

Refer to the table below for Top Sellers details

Category Top Sellers

It extends the Top Sellers logic to a specific category, surfacing the best-selling products within that category rather than sitewide.

Formula: CategoryTopSeller Score(item, category) = Σ Orders(item, t | category(item) = category) * TimeDecay(t)

Algorithm Details:

Recently Viewed

It displays products a shopper has viewed, ordered by recency and weighted by frequency. This is a fully personalised, session-aware algorithm.

Formula: RecentlyViewed Score(item, user) = ViewCount(item, user) * TimeDecay(last_view_time)

Algorithm Details:

Recommended For You

Builds a user-specific interest profile using past interactions (clicks, cart, purchase) and recommends products with similar attributes.

Formula: User Interest Profile(user) = Σ [EventWeight(event) * AttributeVector(item)] RecommendedForYou Score(item, user) = cosine_similarity(AttributeVector(item), User Interest Profile(user)) where

AttributeVector(item) = product attributes (category, brand, price tier, tags, keywords) EventWeight = Order > Cart > Click cosine_similarity = similarity score between vectors

Algorithm Details:

Boutique

A scoped version of Recommended For You, restricted to a specific boutique or brand catalog. It provides personalization within a curated variety. It uses the same user interest profiling logic.

Algorithm Details

Cross Sell

It identifies categories that are frequently used together and recommends products from complementary categories.

Formula: CategoryAffinity(Cat_A, Cat_B) = |Users who interacted with both Cat_A and Cat_B| / sqrt(|Users Cat_A| * |Users Cat_B|)

Algorithm Details:

Bought Also Bought

It identifies products frequently purchased by the same users over time, building item-to-item relationships.

Formula: BoughtAlsoBought Score(A, B) = |Users who purchased both A and B| / sqrt(|Users A| * |Users B|)

Algorithm Details:

More Like These

It uses semantic similarity across product attributes (title, description, category, brand, tags) to find similar items.

Algorithm Details

AI-Based Complete The Look

This Algorithm generates product combinations based on visual and stylistic compatibility.

Formula: CTL Score(A, B) = α * VisualCompatibility(img_A, img_B) + β * StyleAttributeMatch(attr_A, attr_B) + γ * CategoryComplementarity(cat_A, cat_B) where,

α + β + γ = 1 (weights calibrated per client)

Algorithm Details

Complete The Look (Editorial)

It works on manual product associations defined by merchandisers.

Algorithm Details:

Recommendations Based on Recently Viewed

This algorithm uses recently viewed products as seeds to recommend new, similar products that the shopper hasn't seen yet.

Formula: RecsFromRecentlyViewed Score(candidate, user) = Σ [TimeDecay(view_t) * cosine_similarity(AttributeVector(candidate), AttributeVector(seed_item))]

Algorithm Details:

Recommendations Based on Last Viewed

This uses the most recently viewed product as the primary intent signal to generate focused recommendations.

Formula: RecsFromLastViewed Score(candidate, user) = α * cosine_similarity(AttributeVector(candidate), AttributeVector(LastViewedItem(user))) + β * BoughtAlsoBought Score(candidate, LastViewedItem(user)) where:
α + β = 1 (default: α = 0.6, β = 0.4)

Algorithm Details