| 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 |
|
|
