VDB Design Problem - Balanced Tier =================================== Problem Setting --------------- Design a Vector Database index optimized for **recall** subject to a **latency constraint**. This tier uses latency-gated scoring: solutions exceeding the latency threshold receive zero points, while solutions meeting the constraint are scored purely by recall@1. **Optimization Goal**: Maximize recall@1 within latency constraint $$ \text{score} = \begin{cases} 0 & \text{if } t_{\text{query}} > t_{\text{max}} \\ 100 & \text{if } t_{\text{query}} \leq t_{\text{max}} \text{ and } r \geq r_{\text{baseline}} \\ 100 \cdot \frac{r - r_{\text{min}}}{r_{\text{baseline}} - r_{\text{min}}} & \text{if } t_{\text{query}} \leq t_{\text{max}} \text{ and } r < r_{\text{baseline}} \end{cases} $$ Where: - $r$: Your recall@1 - $t_{\text{query}}$: Your average query latency (ms) - $r_{\text{baseline}} = 0.9914$ (baseline recall) - $r_{\text{min}} = 0.6939$ (minimum acceptable recall, 70% of baseline) - $t_{\text{max}} = 5.775\text{ms}$ (maximum allowed latency, 150% of baseline 3.85ms) **Key Insight**: Latency is a hard constraint. Only recall determines your score within the constraint. Baseline Performance -------------------- - Recall@1: **0.9914** (99.14%) - Avg query time: **3.85ms** - Baseline score: **100** (recall equals baseline within latency constraint) Scoring Examples ---------------- Assuming all solutions meet latency constraint ($t \leq 5.775\text{ms}$): | Recall@1 | Latency | Score Calculation | Score | |----------|---------|-------------------|-------| | 0.9914 | 3.85ms | $r = r_{\text{baseline}}$ → max score | **100** | | 0.9950 | 3.00ms | $r > r_{\text{baseline}}$ → max score | **100** | | 0.9500 | 2.50ms | $\frac{0.95 - 0.6939}{0.9914 - 0.6939} = 0.860$ | **86.0** | | 0.8500 | 4.00ms | $\frac{0.85 - 0.6939}{0.9914 - 0.6939} = 0.524$ | **52.4** | | 0.6939 | 5.00ms | $r = r_{\text{min}}$ → minimum score | **0** | | 0.9900 | **6.00ms** | $t > t_{\text{max}}$ → latency gate fails | **0** | **Note**: Faster latency does NOT increase score - only recall matters if constraint is met. API Specification ----------------- Implement a class with the following interface: ```python import numpy as np from typing import Tuple class YourIndexClass: def __init__(self, dim: int, **kwargs): """ Initialize the index for vectors of dimension `dim`. Args: dim: Vector dimensionality (e.g., 128 for SIFT1M) **kwargs: Optional parameters (e.g., M, ef_construction for HNSW) Example: index = YourIndexClass(dim=128, M=16, ef_search=64) """ pass def add(self, xb: np.ndarray) -> None: """ Add vectors to the index. Args: xb: Base vectors, shape (N, dim), dtype float32 Notes: - Can be called multiple times (cumulative) - Must handle large N (e.g., 1,000,000 vectors) Example: index.add(xb) # xb.shape = (1000000, 128) """ pass def search(self, xq: np.ndarray, k: int) -> Tuple[np.ndarray, np.ndarray]: """ Search for k nearest neighbors of query vectors. Args: xq: Query vectors, shape (nq, dim), dtype float32 k: Number of nearest neighbors to return Returns: (distances, indices): - distances: shape (nq, k), dtype float32, L2 distances - indices: shape (nq, k), dtype int64, indices into base vectors Notes: - Must return exactly k neighbors per query - Indices should refer to positions in the vectors passed to add() - Lower distance = more similar Example: D, I = index.search(xq, k=1) # xq.shape = (10000, 128) # D.shape = (10000, 1), I.shape = (10000, 1) """ pass ``` **Implementation Requirements**: - Class can have any name (evaluator auto-discovers classes with `add` and `search` methods) - Must handle SIFT1M dataset: 1M base vectors, 10K queries, 128 dimensions - Your `search` must return tuple `(distances, indices)` with shapes `(nq, k)` - Distances should be L2 (Euclidean) or L2-squared - No need to handle dataset loading - evaluator provides numpy arrays Evaluation Process ------------------ The evaluator follows these steps: ### 1. Load Dataset ```python from faiss.contrib.datasets import DatasetSIFT1M ds = DatasetSIFT1M() xb = ds.get_database() # (1000000, 128) float32 xq = ds.get_queries() # (10000, 128) float32 gt = ds.get_groundtruth() # (10000, 100) int64 - ground truth indices ``` ### 2. Build Index ```python from solution import YourIndexClass # Auto-discovered d = xb.shape[1] # 128 for SIFT1M index = YourIndexClass(d) # Pass dimension as first argument index.add(xb) # Add all 1M base vectors ``` ### 3. Measure Performance (Batch Queries) ```python import time t0 = time.time() D, I = index.search(xq, k=1) # Search all 10K queries at once t1 = time.time() # Calculate metrics recall_at_1 = (I[:, :1] == gt[:, :1]).sum() / len(xq) avg_query_time_ms = (t1 - t0) * 1000.0 / len(xq) ``` **Important**: `avg_query_time_ms` from **batch queries** is used for scoring. Batch queries benefit from CPU cache and vectorization, typically faster than single queries. ### 4. Calculate Score ```python if avg_query_time_ms > 5.775: score = 0.0 elif recall_at_1 >= 0.9914: score = 100.0 else: recall_range = 0.9914 - 0.6939 recall_proportion = (recall_at_1 - 0.6939) / recall_range score = max(0.0, min(100.0, 100.0 * recall_proportion)) ``` Dataset Details --------------- - **Name**: SIFT1M - **Base vectors**: 1,000,000 vectors of dimension 128 - **Query vectors**: 10,000 vectors - **Ground truth**: Precomputed nearest neighbors (k=1) - **Metric**: L2 (Euclidean distance) - **Vector type**: float32 Runtime Platform ---------------- - **Infrastructure**: Evaluations run on SkyPilot-managed cloud instances (AWS, GCP, or Azure) - **Compute**: CPU-only instances (no GPU required) - **Environment**: Docker containerized execution with Python 3, NumPy ≥1.24, FAISS-CPU ≥1.7.4 Constraints ----------- - **Timeout**: 1 hour for entire evaluation (index construction + queries) - **Memory**: Use reasonable memory (index should fit in RAM) - **Latency constraint**: avg_query_time_ms ≤ 5.775ms - **Recall range**: 0.6939 ≤ recall@1 ≤ 1.0 Strategy Tips ------------- 1. **Focus on recall**: Latency only needs to meet threshold, doesn't improve score beyond that 2. **Batch optimization is key**: Your `search` should handle batch queries efficiently 3. **Parameter tuning**: Small changes (e.g., HNSW's M, ef_search) significantly affect recall 4. **Don't over-optimize latency**: Meeting 5.775ms is enough; focus energy on recall Example: Simple Baseline ------------------------- ```python import numpy as np class SimpleIndex: def __init__(self, dim: int, **kwargs): self.dim = dim self.xb = None def add(self, xb: np.ndarray) -> None: if self.xb is None: self.xb = xb.copy() else: self.xb = np.vstack([self.xb, xb]) def search(self, xq: np.ndarray, k: int) -> tuple: # Compute all pairwise L2 distances # xq: (nq, dim), xb: (N, dim) # distances: (nq, N) distances = np.sqrt(((xq[:, np.newaxis, :] - self.xb[np.newaxis, :, :]) ** 2).sum(axis=2)) # Get k nearest neighbors indices = np.argpartition(distances, k-1, axis=1)[:, :k] sorted_indices = np.argsort(distances[np.arange(len(xq))[:, None], indices], axis=1) final_indices = indices[np.arange(len(xq))[:, None], sorted_indices] final_distances = distances[np.arange(len(xq))[:, None], final_indices] return final_distances, final_indices ``` **Note**: This baseline achieves perfect recall (100%) but is too slow for large datasets. Use approximate methods like HNSW, IVF, or LSH for better speed-recall tradeoffs. Debugging Tips -------------- - **Test locally**: Use a subset of data (e.g., 10K vectors) for faster iteration - **Verify shapes**: Ensure `search` returns `(nq, k)` shaped arrays - **Check recall calculation**: `(I[:, :1] == gt[:, :1]).sum() / len(xq)` - **Profile latency**: Measure batch vs single query performance separately - **Validate before submit**: Run full 1M dataset locally if possible