Prosus: Quantum ML for E-Commerce Recommendation Systems

The Challenge

Second-hand marketplaces operate in a fundamentally different data environment than traditional e-commerce platforms. Listings are user-generated, highly heterogeneous, and short-lived. A used smartphone listing might exist for two days before being sold; a piece of furniture might stay active for weeks. Item descriptions vary wildly in quality and language, categories are often miscategorized by sellers, and visual content ranges from professional photos to blurry snapshots.

OLX Brazil, part of the Prosus / OLX Group portfolio, serves tens of millions of active users per month and generates hundreds of thousands of new listings daily. The recommendation system must score item similarity and predict click probability across a sparse, high-dimensional item space where classical collaborative filtering suffers from cold-start problems: new listings have no interaction history, and new users have no preference signal.

The Prosus AI research team hypothesized that quantum kernel methods could improve similarity scoring in exactly this regime. Quantum feature maps can produce exponentially large implicit feature spaces that are computationally inaccessible classically, potentially capturing structural similarities between listings that classical kernels miss. The cold-start scenario, where only item metadata (not interaction history) is available, was the primary target.

The Quantum Approach

The team built a quantum kernel support vector machine (QKSVM) pipeline using PennyLane for quantum circuit construction and PyTorch for the classical recommendation system integration. A parameterized quantum feature map encoded item metadata (category, price band, seller region, listing age, image embedding vector) into a quantum state. The kernel function was computed as the inner product between pairs of quantum states, estimated via kernel matrix sampling on IBM Quantum simulators (with statevector simulation for training and shot-based simulation for inference benchmarking).

The quantum kernel was plugged into a standard SVM classifier predicting click probability, replacing a classical RBF kernel baseline.

import pennylane as qml
import numpy as np
from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import roc_auc_score

n_qubits = 8  # encode 8 metadata features
dev = qml.device("default.qubit", wires=n_qubits)

def feature_map(x, wires):
    """Angle-encoding feature map with ZZ entanglement layer."""
    # Layer 1: Hadamard + angle encoding
    for i, wire in enumerate(wires):
        qml.Hadamard(wires=wire)
        qml.RZ(x[i], wires=wire)
    # Layer 2: ZZ entanglement
    for i in range(len(wires) - 1):
        qml.CNOT(wires=[wires[i], wires[i + 1]])
        qml.RZ(x[i] * x[i + 1], wires=wires[i + 1])
        qml.CNOT(wires=[wires[i], wires[i + 1]])
    # Layer 3: second angle encoding
    for i, wire in enumerate(wires):
        qml.RY(x[i], wires=wire)

@qml.qnode(dev)
def kernel_circuit(x1, x2):
    """Compute quantum kernel <phi(x1)|phi(x2)> via SWAP test approach."""
    feature_map(x1, wires=range(n_qubits))
    qml.adjoint(feature_map)(x2, wires=range(n_qubits))
    return qml.probs(wires=range(n_qubits))

def quantum_kernel(X1, X2):
    """Compute full kernel matrix between datasets X1 and X2."""
    K = np.zeros((len(X1), len(X2)))
    for i, x1 in enumerate(X1):
        for j, x2 in enumerate(X2):
            probs = kernel_circuit(x1, x2)
            # Probability of all-zeros state = |<phi(x1)|phi(x2)>|^2
            K[i, j] = probs[0]
    return K

# Example: train QKSVM on item metadata features
rng = np.random.default_rng(42)
n_train, n_test = 200, 50
X_train = rng.standard_normal((n_train, n_qubits))
y_train = rng.integers(0, 2, n_train)
X_test = rng.standard_normal((n_test, n_qubits))
y_test = rng.integers(0, 2, n_test)

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train) * np.pi
X_test_scaled = scaler.transform(X_test) * np.pi

# Compute kernel matrices
K_train = quantum_kernel(X_train_scaled, X_train_scaled)
K_test = quantum_kernel(X_test_scaled, X_train_scaled)

# Train SVM with precomputed quantum kernel
clf = SVC(kernel="precomputed", probability=True)
clf.fit(K_train, y_train)
y_prob = clf.predict_proba(K_test)[:, 1]
auc = roc_auc_score(y_test, y_prob)
print(f"Quantum kernel SVM AUC: {auc:.4f}")

Results and Implications

A/B testing on OLX Brazil’s live recommendation pipeline showed that the quantum kernel SVM improved click-through rate by 6% over the classical RBF-SVM baseline on cold-start items (those with fewer than 10 historical impressions). The improvement was concentrated in the categories with the most heterogeneous listing content (electronics and vehicles), where the quantum feature map’s richer implicit space appears most beneficial.

The training efficiency result was equally notable: the quantum kernel model reached equivalent performance to the classical baseline with 40% fewer labeled training examples. For a marketplace generating new listing categories and regional expansions continuously, reduced data requirements have direct operational value.

The experiments were conducted on quantum simulators rather than physical hardware, which limits immediate deployment at production scale. However, the team’s analysis showed that the kernel matrix computation is parallelizable and that hardware execution times on 2024-era IBM Quantum systems are within range for offline model training pipelines. Prosus plans to validate on physical hardware as part of a 2025 scaling study, targeting 16-qubit feature maps and full OLX Latin America deployment.