Real-Time Feature Vector Construction from Search Query Semantics and Geolocation for LinUCB Offer Matching

High-Dimensional Contextual Modeling for Edge Decision Engines

Deploying contextual multi-armed bandits on high-traffic landing pages shifts the optimization paradigm from static, global split-testing to dynamic, per-request personalization. In a Linear Upper Confidence Bound (LinUCB) framework, the core determinant of convergence velocity and personalization accuracy is the design of the feature vector $x_{t,a} in mathbb{R}^d$. The edge runtime must ingest fragmented, noisy signals—specifically incoming search semantics and geospatial network metadata—and project them into a bounded, low-latency, dense vector representation before the page renders.

When engineering these features on high-volume organic landing pages, the primary business objective is to systematically match high-intent visitors with optimal contextual calls-to-action (CTAs) and personalized promotions to sustainably increase organic revenue. This vectorization process operates under strict execution budgets: the total latency of parameter extraction, semantic tokenization, continuous scaling, and vector concatenation must execute within sub-15-millisecond windows. This architectural deep dive details the mathematical formulations, extraction patterns, and dimensionality reduction pipelines necessary to construct real-time feature vectors that maximize reward discovery in LinUCB engines.

For a complete architectural overview of bandit infrastructure across organic search funnels, consult our foundational guide on Multi-Armed Bandit Implementation for Contextual Offer and CTA Matching on High-Volume Organic Pages.

—

LinUCB Context Space: Formulation and Dimensionality Constraints

The standard disjoint LinUCB algorithm assumes the expected reward $mathbb{E}[r_{t,a} mid x_{t,a}]$ of an arm (offer) $a in mathcal{A}$ is linear in its context $x_{t,a}$ with an unknown coefficient vector $theta_a^*$. That is:

$$mathbb{E}[r_{t,a} mid x_{t,a}] = x_{t,a}^T theta_a^*$$

At each round $t$, the decision rule selects the arm maximizing:

$$a_t = argmax_{a in mathcal{A}} left( x_{t,a}^T hat{theta}_a + alpha sqrt{x_{t,a}^T A_a^{-1} x_{t,a}} right)$$

Where:

  • $A_a = D_a^T D_a + I_d$ is the $d times d$ covariance matrix of historical contexts for arm $a$.
  • $b_a = D_a^T c_a$ is the $d$-dimensional vector tracking the historical payoff-weighted context sum.
  • $hat{theta}_a = A_a^{-1} b_a$ is the ridge regression ridge estimate of arm parameters.
  • $alpha = 1 + sqrt{ln(2/delta)/2}$ controls the radius of the exploration confidence ellipsoid.

The time complexity of the matrix-vector multiplication $x_{t,a}^T A_a^{-1} x_{t,a}$ is $mathcal{O}(d^2)$ when maintaining the inverse matrix $A_a^{-1}$ incrementally via the Sherman-Morrison update formula:

$$A_a^{-1} leftarrow A_a^{-1} – frac{A_a^{-1} x_t x_t^T A_a^{-1}}{1 + x_t^T A_a^{-1} x_t}$$

If $d$ escalates past 100 dimensions, matrix operations consume excessive CPU cycles in edge runtimes (e.g., Cloudflare Workers, Fastly Compute@Edge, AWS Lambda@Edge), rendering edge evaluation infeasible within standard Time to First Byte (TTFB) budgets. Furthermore, sample complexity scales with the context dimension: the regret bounds of LinUCB scale as $tilde{mathcal{O}}(d sqrt{T})$. Unbounded or sparse one-hot encoded vector spaces cause the model to over-explore, depressing conversions. Consequently, real-time vector engineering must compress raw search semantics and geolocation into a compact, highly dense vector where $d in [24, 48]$.

—

Search Query Semantics: Real-Time Edge Extraction and Dimensionality Reduction

1. Resolving Context Under Google’s Encrypted Search (Referrer Nullification)

Modern organic referrers from search engines strip query parameters (q=) via TLS and Referrer-Policy configurations. To derive semantic search signals when direct search strings are nullified, edge nodes parse the landing URL’s canonical path and matching taxonomy, along with historical query tokens mapped via Google Search Console (GSC) pre-aggregated landing-page dictionaries.

When an internal search or explicit campaign parameter (e.g., utm_term, search_term) is present, raw text is tokenized directly. Otherwise, the edge engine reads an embedded route signature token vector pre-indexed in edge KV storage. This dual-pipeline structure guarantees that every organic arrival carries a non-zero semantic initialization.

2. Feature Hashing and Subword Tokenization

To avoid massive multi-megabyte out-of-vocabulary (OOV) dictionaries at the edge, raw query strings or path slugs undergo character n-gram hashing via the MurmurHash3 algorithm. Tokens are projected into a fixed-width bucket space $mathbb{R}^k$ (where $k=16$):

$$h(w_i) pmod k implies text{Index } j$$

Using a signed hash function $xi(w_i) in {-1, +1}$, the feature hashing representation yields an unbiased linear embedding:

$$phi_j(s) = sum_{w_i in s : h(w_i) equiv j} xi(w_i)$$

3. Offline Pre-computed Semantic Latent Projections

For high-traffic organic templates (e.g., product listing pages, collection hubs, technical documentation hubs), offline pipelines compute 384-dimensional dense embeddings of the target document using quantized Sentence-BERT models (e.g., all-MiniLM-L6-v2). These 384-dimensional vectors are reduced using Principal Component Analysis (PCA) or Truncated Singular Value Decomposition (SVD) down to 12 dimensions.

The transformation matrix $W_{text{SVD}} in mathbb{R}^{384 times 12}$ projects the normalized document vector $v_{text{doc}}$:

$$z_{text{sem}} = v_{text{doc}} W_{text{SVD}}$$

At inference time, the edge worker retrieves $z_{text{sem}}$ from edge memory via a deterministic lookup of the page path hash, eliminating local neural inference while preserving deep semantic taxonomy.

—

Spatial Feature Engineering from IP and Client Network Signatures

Geolocation context provides valuable priors regarding spending power, regional intent, and localized product affinity. Edge runtimes provide network-level metadata including client IP addresses, which are mapped at wire-speed to geolocation records via MaxMind GeoIP2 or native edge headers (e.g., Cloudflare request.cf).

1. Geohash Trigonometric Decompositions

Raw latitude ($phi$) and longitude ($lambda$) present a boundary discontinuity problem when left as raw floats. Furthermore, Euclidean distance calculations in Cartesian space break down near the antimeridian and poles. To feed geographic coordinates into a linear model, the engine computes circular/spherical continuous encodings:

$$x_{text{lat}} = sinleft(frac{pi phi}{90}right), quad y_{text{lat}} = cosleft(frac{pi phi}{90}right)$$

$$x_{text{lon}} = sinleft(frac{pi lambda}{180}right), quad y_{text{lon}} = cosleft(frac{pi lambda}{180}right)$$

This 4-dimensional unit vector ensures that geographical proximity remains smooth and continuous across all coordinate transformations within the linear reward function.

2. Purchasing Power Parity (PPP) and Macro-Economic Normalization

Raw ISO country codes or Designated Market Area (DMA) IDs must not be one-hot encoded due to dimensionality explosion. Instead, the edge runtime uses a pre-compiled, static lookup array mapping ISO 3166-1 alpha-2 codes and US metro codes to a continuous wealth/purchasing index normalized to $[0, 1]$:

$$I_{text{PPP}} = frac{text{GDP}_{text{local}} – text{GDP}_{min}}{text{GDP}_{max} – text{GDP}_{min}}$$

3. Network Performance and Edge Proximity Proxies

User connection type strongly correlates with browsing urgency and conversion behavior. The engine extracts the Round-Trip Time (RTT) metric and connection density, normalized via a log-sigmoid transformation:

$$f(text{RTT}) = frac{1}{1 + expleft(-frac{text{RTT} – mu_{text{RTT}}}{sigma_{text{RTT}}}right)}$$

—

Vector Assembler, Continuous Imputation, and Normalization

The feature vector $x_{t}$ is synthesized by concatenating the semantic, geospatial, and hardware metadata sub-vectors. Below is the production layout for a 32-dimensional context space:

Feature Sub-vector Dimensions Extraction Method Transformation / Bounding
Semantic Intent Hash 12 MurmurHash3 on parsed query/slug tokens Zero-mean, unit variance scaled
Pre-computed Semantic SVD 8 Edge KV lookup of page intent representation $L_2$-normalized dense array
Geographic Polar Coords 4 Sin/Cos transform of Latitude/Longitude Bounded strictly in $[-1, 1]$
Economic Proxy (PPP) 2 Static mapping from Geo-IP ISO code MinMax scaled in $[0, 1]$
Device / Context Signals 4 User-Agent / Client-Hints (viewport, mobile) One-hot / Boolean flags ${0, 1}$
Temporal Diurnal Signals 2 Local solar time calculation from UTC + offset Sine/Cosine diurnal 24hr cycle

Vector Scaling and Strict $L_2$ Projection

LinUCB relies on context vectors having a strictly bounded norm to preserve theoretical regret guarantees. Specifically, we enforce $|x_{t}|_2 le 1$. If features are unnormalized, variables with larger numerical ranges dominate the computation of $A_a^{-1}$, distorting the confidence ellipsoid $alpha sqrt{x^T A_a^{-1} x}$.

Prior to passing $x_t$ into the upper confidence bound scoring function, the edge assembler applies a projection step:

$$x_{t, text{final}} = frac{x_t}{|x_t|_2} = frac{x_t}{sqrt{sum_{i=1}^{d} x_{t,i}^2}}$$

“`typescript
// Production Edge Vector Assembly (TypeScript / Cloudflare Workers runtime)
interface ContextRawSignals {
queryTokens: string[];
svdEmbeddings: number[]; // Length: 8
latitude: number;
longitude: number;
pppIndex: number;
isMobile: boolean;
epochMs: number;
timezoneOffset: number;
}

export function constructFeatureVector(signals: ContextRawSignals): Float64Array {
const d = 32;
const x = new Float64Array(d);

// 1. Semantic Hashing (Indices 0 – 11)
for (const token of signals.queryTokens) {
const hash = murmurhash3_32_gc(token, 0);
const bucket = Math.abs(hash) % 12;
const sign = (hash & 0x80000000) === 0 ? 1.0 : -1.0;
x[bucket] += sign;
}

// 2. Pre-computed Page Semantic SVD (Indices 12 – 19)
for (let i = 0; i 0 ? 1.0 : -1.0; // Northern vs Southern hemisphere seasonality

// 5. Hardware / Device Signatures (Indices 26 – 29)
x[26] = signals.isMobile ? 1.0 : 0.0;
x[27] = signals.isMobile ? 0.0 : 1.0;
x[28] = 0.0; // Reserved dynamic slot
x[29] = 1.0; // Intercept/bias term

// 6. Diurnal Local Time Signals (Indices 30 – 31)
const localHour = ((signals.epochMs + signals.timezoneOffset * 3600000) / 3600000) % 24;
const hourAngle = (localHour / 24.0) * 2 * Math.PI;
x[30] = Math.sin(hourAngle);
x[31] = Math.cos(hourAngle);

// 7. L2 Normalization
let normSquared = 0.0;
for (let i = 0; i 0) {
for (let i = 0; i < d; i++) {
x[i] /= norm;
}
}

return x;
}

function murmurhash3_32_gc(key: string, seed: number): number {
let remainder = key.length & 3;
let bytes = key.length – remainder;
let h1 = seed;
let c1 = 0xcc9e2d51;
let c2 = 0x1b873593;
let i = 0;

while (i < bytes) {
let k1 =
(key.charCodeAt(i) & 0xff) |
((key.charCodeAt(++i) & 0xff) << 8) |
((key.charCodeAt(++i) & 0xff) << 16) |
((key.charCodeAt(++i) & 0xff) << 24);
++i;

k1 = Math.imul(k1, c1);
k1 = (k1 <>> 17);
k1 = Math.imul(k1, c2);

h1 ^= k1;
h1 = (h1 <>> 19);
h1 = Math.imul(h1, 5) + 0xe6546b64;
}

let k1 = 0;
switch (remainder) {
case 3:
k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
case 2:
k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
case 1:
k1 ^= key.charCodeAt(i) & 0xff;
k1 = Math.imul(k1, c1);
k1 = (k1 <>> 17);
k1 = Math.imul(k1, c2);
h1 ^= k1;
}

h1 ^= key.length;
h1 ^= h1 >>> 16;
h1 = Math.imul(h1, 0x85ebca6b);
h1 ^= h1 >>> 13;
h1 = Math.imul(h1, 0xc2b2ae35);
h1 ^= h1 >>> 16;

return h1 >>> 0;
}
“`

—

Latency Auditing and Edge Inference Constraints

Executing continuous LinUCB inferences requires verifying that memory footprint, matrix operations, and lookup chains do not breach edge worker runtime limitations.

1. Matrix-Vector Complexity Profile

With an arm set size $|mathcal{A}| = 8$ and context dimension $d = 32$:

  • Each arm maintains an inverse covariance matrix $A_a^{-1} in mathbb{R}^{32 times 32}$ ($1024$ double-precision floats $approx 8$ KB per arm). Total memory for 8 arms is $approx 64$ KB, fitting into L1/L2 processor caches at edge data centers.
  • Computing the point estimate $hat{y}_a = x_t^T hat{theta}_a$ requires $d = 32$ floating point multiply-accumulate (MAC) operations.
  • Computing the variance penalty $sigma_a = sqrt{x_t^T A_a^{-1} x_t}$ requires one matrix-vector multiplication ($d^2 = 1024$ MACs) and one inner product ($d = 32$ MACs).
  • Total computation for 8 arms requires approximately $8 times (1024 + 64) approx 8,704$ floating point operations. On modern 2.5 GHz+ cloud CPUs, this block executes in under 0.15 milliseconds.

2. The Asynchronous Read/Write Boundary

While action selection ($a_t = argmax text{UCB}_a$) occurs synchronously inline with the HTTP request, updating $A_a^{-1}$ via the Sherman-Morrison rank-1 update cannot stall user delivery. Once an impression or interaction occurs, the context vector $x_t$ and outcome reward $r_t in [0, 1]$ are flushed to a non-blocking stream (e.g., Cloudflare Queues, Kafka, AWS Kinesis). Updated matrices are calculated in an edge-adjacent aggregation pipeline and periodically pushed back into edge distributed key-value storage using read-replicas updated out of band every few seconds.

—

Diagnostic Verification and Production Pitfalls

When running this architecture at scale, feature vector anomalies can quickly degrade bandit performance:

  • Covariance Degeneracy (Collinear Features): If semantic features strongly duplicate geolocation signals (for example, localized landing page variants mapping identical coordinate proxies), $A_a$ can become ill-conditioned. Ensure that the initial regularizer matrix $I_d$ is initialized with $lambda ge 1.0$ across the diagonal to guarantee positive-definiteness.
  • Feature Starvation via Extreme Normalization: Normalizing without centering causes dense features (like polar coordinates) to visually drown out sparse signals (like hashed query tokens). Maintain dynamic moving-average trackers of vector sparsity offline, tuning per-block scales prior to global $L_2$ normalization.
  • Drift Between Training and Serving Embeddings: When offline NLP models regenerate semantic embeddings for the target URLs, older bandit instances may evaluate context using outdated coordinate vectors. Bind an integer embedding_version schema ID directly into the edge KV payload; if the model version shifts, reset or decay the respective arm matrices $A_a$ via an exponential forgetting factor $gamma in [0.95, 0.99]$.

Related Guides in This Series

Tagged