Index Optimization Techniques

Index Optimization Techniques in AI Discoverability Architecture represent a critical set of methodologies designed to enhance the efficiency, accuracy, and scalability of information retrieval systems that enable AI models and applications to be discovered, accessed, and utilized effectively ¹². These techniques focus on structuring, organizing, and maintaining indices that facilitate rapid search and retrieval of AI-relevant content, including model metadata, training datasets, embeddings, and semantic representations. The primary purpose is to reduce latency, improve relevance ranking, and enable efficient similarity search across high-dimensional vector spaces that characterize modern AI systems ³. In an era where organizations deploy thousands of AI models and process petabytes of data, optimized indexing becomes essential for operational efficiency, cost management, and delivering responsive user experiences in AI-powered applications.

Overview

The emergence of Index Optimization Techniques in AI Discoverability Architecture stems from the exponential growth in AI model deployment and the increasing dimensionality of embedding representations used in modern machine learning systems ¹². As transformer-based models became ubiquitous, generating embeddings with 768, 1024, or even higher dimensions, traditional database indexing approaches proved computationally prohibitive for similarity search operations ³. This created an urgent need for specialized indexing strategies that could handle the unique characteristics of high-dimensional vector spaces while maintaining acceptable query performance.

The fundamental challenge these techniques address is the "curse of dimensionality"—as embedding dimensions increase, the computational cost of exact nearest neighbor search grows exponentially, making brute-force approaches impractical for real-time applications ²⁷. Traditional indexing methods designed for low-dimensional structured data fail to provide meaningful performance improvements in high-dimensional spaces where distances between points become increasingly uniform. This necessitated the development of approximate algorithms that trade perfect accuracy for orders-of-magnitude speed improvements while providing bounded error guarantees ³⁵.

The practice has evolved significantly from early locality-sensitive hashing (LSH) approaches to sophisticated graph-based indices and learned quantization methods ⁴⁶. Modern implementations leverage GPU acceleration, distributed computing frameworks, and machine learning techniques to optimize index structures themselves, creating adaptive systems that learn from query patterns and data distributions ¹³. This evolution reflects the maturation of AI infrastructure from experimental systems to production-grade platforms serving billions of queries daily.

Key Concepts

Hierarchical Navigable Small World (HNSW) Graphs

HNSW is a graph-based index structure that organizes vectors into multi-layer proximity graphs, enabling logarithmic search complexity through hierarchical navigation ². The algorithm constructs layers of increasingly sparse graphs, where upper layers provide long-range connections for rapid traversal and lower layers contain dense local neighborhoods for precise retrieval. Each node maintains a limited number of bidirectional edges to nearby neighbors, creating a navigable structure that balances connectivity and memory efficiency.

Example: A scientific literature search platform indexing 50 million research papers uses HNSW to organize 768-dimensional embeddings generated from paper abstracts. When a researcher queries "quantum error correction in topological qubits," the system enters the HNSW graph at the top layer, making large jumps across the vector space to reach the relevant region, then descends through progressively denser layers to identify the 100 most semantically similar papers in under 20 milliseconds, despite the massive corpus size.

Product Quantization (PQ)

Product quantization is a compression technique that decomposes high-dimensional vectors into subvectors and quantizes each independently using learned codebooks, achieving significant memory reduction while preserving approximate distances ¹⁵. The method partitions a d-dimensional vector into m subvectors of dimension d/m, then represents each subvector by its nearest centroid from a codebook of k entries, reducing storage from d floating-point numbers to m codebook indices.

Example: An e-commerce platform with 100 million product images generates 2048-dimensional CNN embeddings for visual search. Applying 8-way product quantization with 256-entry codebooks reduces each embedding from 8KB (2048 × 4 bytes) to just 8 bytes (8 indices × 1 byte), achieving a 1000x compression ratio. This enables the entire index to fit in 800MB of RAM instead of 800GB, while maintaining 95% recall@10 for visual similarity queries, making real-time visual search economically viable.

Inverted File (IVF) Indices

IVF indices partition the vector space into clusters using k-means or similar algorithms, creating an inverted structure that maps cluster centroids to the vectors they contain ¹³. During search, the system identifies the most relevant clusters by comparing the query vector to centroids, then performs exhaustive search only within those selected partitions, dramatically reducing the search space.

Example: A code search engine indexing 500 million code snippets across GitHub repositories uses IVF with 65,536 clusters. When a developer searches for "implement binary search tree traversal," the query embedding is compared against cluster centroids, identifying the 50 most relevant clusters containing approximately 400,000 code snippets. The system then performs detailed similarity comparison only within this reduced set, achieving 50x speedup compared to exhaustive search while maintaining 98% recall for relevant code examples.

Approximate Nearest Neighbor (ANN) Search

ANN search algorithms trade perfect accuracy for significant performance improvements by finding neighbors that are approximately closest rather than guaranteed closest ²⁷. These methods provide probabilistic guarantees on result quality, typically measured as recall@k (the fraction of true k-nearest neighbors found), while achieving orders-of-magnitude faster query times than exact search.

Example: A music streaming service uses ANN search to power its "discover similar artists" feature across 10 million artist embeddings. The system employs HNSW with parameters tuned to achieve 90% recall@20 with average query latency of 5ms, compared to 500ms for exact search. This enables real-time recommendations during user browsing sessions, where the slight accuracy trade-off is imperceptible to users but the latency improvement is critical for engagement.

Locality-Sensitive Hashing (LSH)

LSH is a probabilistic technique that hashes similar vectors to the same buckets with high probability, enabling sublinear search by examining only vectors in matching buckets ⁷. The method uses specially designed hash functions that preserve similarity relationships, such that vectors close in the original space collide in hash space more frequently than distant vectors.

Example: A content moderation system processing 1 billion user-uploaded images daily uses LSH to detect near-duplicate content. Images are converted to 512-dimensional perceptual hash embeddings, then indexed using 128 LSH hash tables with 16-bit hash codes. When a new image is uploaded, the system queries all hash tables and examines only the ~1000 images in matching buckets, identifying duplicates or near-duplicates in under 2ms, enabling real-time content filtering at massive scale.

Scalar Quantization

Scalar quantization reduces the precision of vector components from 32-bit floating-point to lower-bit representations (8-bit, 4-bit, or even binary), dramatically reducing memory footprint and enabling faster distance computations ¹⁵. The technique maps the continuous range of component values to a discrete set of quantization levels, with careful calibration to minimize information loss.

Example: A recommendation system serving personalized content to 500 million users stores user and item embeddings in 8-bit scalar quantized format. Each 256-dimensional embedding requires only 256 bytes instead of 1KB, reducing total memory from 500GB to 125GB for user embeddings alone. The system uses SIMD instructions to compute distances between quantized vectors 4x faster than full-precision arithmetic, enabling real-time personalization with sub-10ms latency while reducing infrastructure costs by 60%.

Hybrid Search Architecture

Hybrid search combines dense vector similarity with sparse keyword matching and structured metadata filtering to leverage complementary retrieval signals ⁸. This approach typically uses techniques like reciprocal rank fusion or learned ensemble methods to merge results from multiple retrieval stages, balancing semantic understanding with exact keyword matching.

Example: A legal document search platform indexes 10 million case documents using both dense BERT embeddings and traditional BM25 inverted indices. When an attorney searches for "precedents regarding data privacy violations in healthcare," the system executes parallel searches: vector search identifies semantically similar cases, BM25 finds documents with exact keyword matches, and metadata filters restrict results to healthcare jurisdiction. The three result sets are merged using learned weights optimized on historical click data, producing more relevant results than any single method alone.

Applications in AI Discoverability Systems

Model Repository Search and Discovery

Organizations with extensive model repositories use optimized indices to enable data scientists to discover relevant pre-trained models based on semantic queries, task descriptions, or example inputs ⁶⁸. Vector indices organize model embeddings derived from training data characteristics, architecture descriptions, and performance metrics, enabling similarity-based model recommendation.

A financial services company maintains a repository of 5,000 machine learning models for various prediction tasks. Each model is represented by a composite embedding combining its architecture fingerprint, training data distribution statistics, and performance characteristics across benchmark tasks. When a data scientist begins a new fraud detection project, they query the repository with a description of their use case and sample data. The HNSW-indexed system returns the 20 most similar existing models in milliseconds, along with their transfer learning potential scores, reducing model development time from weeks to days by leveraging relevant prior work.

Dataset Discovery and Lineage Tracking

Index optimization enables efficient discovery of training datasets, feature stores, and data lineage information across petabyte-scale data lakes ¹⁸. Organizations index dataset metadata, schema information, statistical profiles, and sample embeddings to support semantic search over available data assets.

A healthcare AI research consortium indexes 50,000 medical imaging datasets across multiple institutions. Each dataset is represented by embeddings capturing imaging modality, anatomical focus, demographic distributions, and annotation characteristics. Researchers searching for "pediatric chest X-ray datasets with pneumonia annotations" receive ranked results based on semantic similarity, with the index supporting real-time filtering by patient count, annotation quality scores, and data sharing permissions. The IVF-indexed system handles complex queries across the distributed catalog in under 100ms, facilitating collaborative research while maintaining governance controls.

Embedding-Based Content Recommendation

Large-scale content platforms use optimized vector indices to power personalized recommendations by finding items similar to user preferences or contextually relevant to current activity ⁸. These systems must handle billions of item embeddings and millions of concurrent queries with strict latency requirements.

A video streaming platform with 100 million videos uses a multi-stage retrieval architecture. The first stage employs IVF indices with product quantization to retrieve 1,000 candidate videos from the full catalog in 10ms based on user embedding similarity. The second stage uses HNSW indices over higher-quality embeddings to rerank candidates to 100 videos in 5ms. The final stage applies learned ranking models with full-precision features. This cascade architecture balances recall, precision, and latency, enabling personalized recommendations that drive 35% of platform engagement while maintaining sub-50ms end-to-end latency.

Semantic Code Search and Developer Tools

Development platforms index millions of code repositories using embeddings that capture semantic meaning, enabling natural language search over codebases ⁹. Optimized indices make it practical to search across entire organizations' code assets in real-time.

A technology company with 10,000 microservices and 500 million lines of code uses code embeddings generated by CodeBERT to enable semantic search. Developers can query "implement rate limiting with exponential backoff" and receive relevant code snippets ranked by semantic similarity, even when exact keywords don't match. The system uses HNSW indices sharded across 20 nodes, with each shard handling a subset of repositories. Query routing based on repository metadata ensures relevant shards are searched, achieving 95% recall with average latency of 150ms across the distributed index.

Best Practices

Implement Multi-Stage Retrieval Pipelines

Rather than relying on a single index structure, implement cascading retrieval stages that progressively refine results using increasingly expensive but accurate methods ³⁸. This approach balances the trade-off between recall, precision, and computational cost by using fast approximate methods for initial candidate generation and precise methods for final ranking.

Rationale: Single-stage retrieval systems must choose between high recall (expensive, slow) or low latency (potentially missing relevant results). Multi-stage pipelines achieve both by casting a wide net quickly, then focusing computational resources on the most promising candidates.

Implementation Example: A job matching platform implements a three-stage pipeline: Stage 1 uses IVF with 10,000 clusters and product quantization to retrieve 5,000 candidate jobs from 50 million listings in 8ms based on resume embedding similarity. Stage 2 applies HNSW search over uncompressed embeddings to rerank to 500 candidates in 12ms. Stage 3 uses a transformer-based cross-encoder to compute precise matching scores for the final 50 results in 30ms. This architecture achieves 98% recall@50 with 50ms total latency, compared to 2 seconds for exhaustive search or 70% recall for single-stage approximate search.

Maintain Shadow Indices for Zero-Downtime Updates

When reindexing or updating index structures, maintain parallel shadow indices that can be built and validated before switching traffic, ensuring continuous availability ¹². This practice prevents service disruptions during index maintenance operations that may take hours or days for large-scale systems.

Rationale: Index rebuilding for large datasets is computationally intensive and time-consuming. Direct updates to production indices risk degraded performance or failures during construction, while taking indices offline creates unacceptable service interruptions.

Implementation Example: An e-commerce search system rebuilds its 200 million product vector index nightly to incorporate new listings and updated embeddings. The system maintains two complete index copies (blue/green deployment). At 2 AM, construction begins on the inactive index using the latest embeddings, taking 3 hours to complete. Automated validation compares query results between old and new indices on a sample of 10,000 test queries, checking for recall degradation. Once validation passes, traffic is gradually shifted to the new index over 30 minutes using weighted load balancing, with automatic rollback if error rates increase. The old index remains available for 24 hours as a fallback, ensuring zero user-facing downtime despite major index updates.

Use Stratified Sampling for Evaluation

When evaluating index performance, ensure test queries represent the true production distribution across different query types, popularity levels, and edge cases ⁷⁹. Avoid over-optimizing for benchmark datasets that don't reflect real-world usage patterns.

Rationale: Index configurations optimized for uniform random queries may perform poorly on production workloads with skewed distributions, temporal patterns, and diverse query characteristics. Representative evaluation prevents deployment of configurations that excel in benchmarks but fail in practice.

Implementation Example: A document search system creates a stratified evaluation set by sampling 5,000 queries from production logs across five dimensions: query frequency (head/torso/tail), query length (short/medium/long), result set size (sparse/dense), temporal pattern (trending/stable), and user segment (power users/casual users). Each configuration is evaluated on all strata, with performance metrics weighted by production query distribution. This reveals that the HNSW configuration optimized for benchmark datasets achieves 95% recall on head queries but only 75% on tail queries, leading to adoption of a hybrid configuration that maintains 90%+ recall across all strata.

Implement Comprehensive Monitoring and Alerting

Deploy monitoring systems that track index health metrics including query latency percentiles (p50/p95/p99), recall rates, memory consumption, update throughput, and error rates ¹³. Establish automated alerts for degradation and implement circuit breakers for graceful failure handling.

Rationale: Index performance can degrade gradually due to data distribution shifts, memory pressure, or configuration drift. Without continuous monitoring, these issues may go undetected until they cause user-facing failures.

Implementation Example: A recommendation system monitors 15 key metrics for its vector indices: p50/p95/p99 query latency, queries per second, recall@10/50/100 measured against ground truth samples, index memory usage, cache hit rates, update latency, failed query rate, and index fragmentation. Dashboards display trends over 24-hour and 7-day windows. Automated alerts trigger when p95 latency exceeds 50ms for 5 consecutive minutes, recall@10 drops below 85%, or memory usage exceeds 90% of allocated capacity. Circuit breakers automatically fall back to a simpler but more reliable index structure if error rates exceed 1%, preventing cascading failures while engineering teams investigate root causes.

Implementation Considerations

Tool and Framework Selection

Choosing appropriate indexing frameworks depends on specific requirements including scale, latency constraints, update frequency, and integration ecosystem ¹²³. Organizations must evaluate trade-offs between specialized libraries, vector databases, and custom implementations.

FAISS (Facebook AI Similarity Search) provides highly optimized implementations of various index types with GPU acceleration support, making it suitable for organizations with large-scale batch processing requirements and in-house ML infrastructure ¹. A research institution processing genomic data uses FAISS GPU indices to search across 10 billion protein sequence embeddings, leveraging NVIDIA A100 GPUs to achieve 100x speedup over CPU-based search for computational biology applications.

Vector database platforms like Pinecone, Weaviate, and Milvus offer managed services with built-in scalability, metadata filtering, and ACID guarantees, appropriate for organizations prioritizing operational simplicity over fine-grained control ³. A startup building a semantic search application chooses Weaviate for its GraphQL API, automatic sharding, and hybrid search capabilities, enabling rapid development without dedicated infrastructure engineering.

Specialized libraries like Annoy (Spotify) and ScaNN (Google) optimize for specific use cases—Annoy excels at read-heavy workloads with infrequent updates, while ScaNN achieves state-of-the-art accuracy-speed trade-offs through learned quantization ³. A music streaming service uses Annoy for playlist recommendation, rebuilding indices nightly during low-traffic periods and serving billions of read queries daily with consistent sub-10ms latency.

Audience-Specific Customization

Index configurations should be tailored to user segments with different latency tolerance, accuracy requirements, and query patterns ⁸⁹. Differentiated service tiers enable optimization for diverse use cases within a single system.

A B2B SaaS platform serving both free and enterprise customers implements tiered index strategies. Free tier users query a heavily compressed IVF index with aggressive quantization, accepting 80% recall and 100ms latency. Enterprise customers access HNSW indices with minimal compression, achieving 95% recall and 20ms latency. Power users with API access can specify custom accuracy-latency trade-offs through query parameters. This approach optimizes infrastructure costs while meeting diverse customer expectations, with enterprise tier revenue justifying the 5x higher computational cost per query.

Organizational Maturity and Context

Implementation strategies should align with organizational ML maturity, available expertise, and existing infrastructure ⁶. Early-stage organizations benefit from managed solutions, while mature ML organizations may justify custom implementations for specific optimizations.

A financial services company with a mature ML platform and dedicated infrastructure team builds custom index implementations using C++ and CUDA, optimizing for their specific embedding characteristics and regulatory requirements around data locality. The investment in custom development yields 40% better performance than off-the-shelf solutions and ensures compliance with data residency requirements. Conversely, a healthcare startup with limited ML infrastructure expertise adopts a managed vector database, trading some performance optimization for reduced operational complexity and faster time-to-market, allowing their small team to focus on domain-specific model development rather than infrastructure.

Incremental Adoption and Migration Strategies

Organizations with existing search infrastructure should plan phased migrations that minimize risk and enable validation at each stage ¹⁷. Parallel running of old and new systems allows comparison and gradual traffic shifting.

An e-commerce platform migrates from keyword-based search to hybrid semantic search over 6 months. Phase 1 deploys vector indices alongside existing Elasticsearch infrastructure, serving 5% of traffic to collect performance data. Phase 2 implements A/B testing comparing search quality metrics (click-through rate, conversion rate, zero-result queries) between systems. Phase 3 gradually increases vector search traffic to 50% while monitoring business metrics. Phase 4 completes migration after confirming 15% improvement in conversion rates and 30% reduction in zero-result queries. The staged approach identifies and resolves three critical issues (query parsing edge cases, category filter integration, mobile performance) before full deployment, avoiding potential revenue impact from a big-bang migration.

Common Challenges and Solutions

Challenge: Accuracy-Latency Trade-off Management

The fundamental tension between search accuracy and query latency creates difficult optimization decisions, as aggressive performance optimizations often degrade recall below acceptable thresholds ²³. Organizations must balance user experience requirements with infrastructure costs while maintaining service level agreements. Data scientists may demand 99% recall for model evaluation workflows, while consumer-facing applications tolerate 85% recall if latency stays under 50ms. This creates conflicting requirements within a single system.

Solution:

Implement query-time accuracy controls that allow different applications to specify their accuracy-latency preferences through configuration parameters ²⁷. HNSW indices support an ef_search parameter that controls search thoroughness—higher values improve recall but increase latency. Expose this as an application-level configuration, with sensible defaults for different use cases.

A multi-tenant AI platform implements three service tiers: "fast" (ef_search=50, ~85% recall, <10ms), "balanced" (ef_search=200, ~92% recall, <30ms), and "accurate" (ef_search=500, ~97% recall, <100ms). Applications specify their tier through API parameters. The recommendation engine uses "fast" for real-time suggestions, the content moderation system uses "balanced" for automated filtering with human review, and the model evaluation pipeline uses "accurate" for offline analysis. This approach satisfies diverse requirements without maintaining separate indices, while monitoring systems track actual recall and latency by tier to ensure SLA compliance.

Challenge: Index Update Latency and Freshness

Maintaining index freshness while serving high query loads creates operational challenges, as index updates can be computationally expensive and may degrade query performance ¹². Graph-based indices like HNSW require careful edge management during insertions, while quantization-based methods may need periodic retraining of codebooks. Systems requiring real-time updates (new product listings, breaking news, user-generated content) cannot tolerate batch rebuild delays.

Solution:

Implement hybrid update strategies combining incremental updates for recent data with periodic full rebuilds for optimization ¹². Maintain a small "hot" index for recent additions using simpler structures that support fast insertion, and a large "cold" index for historical data using highly optimized structures. Merge results at query time, and periodically migrate data from hot to cold indices during low-traffic periods.

A news aggregation platform indexes articles from 10,000 sources with 50,000 new articles daily. The system maintains a hot HNSW index for articles from the last 7 days (~350,000 articles) with relaxed optimization parameters enabling 5-second insertion latency. A cold IVF index with aggressive product quantization contains 50 million historical articles, rebuilt weekly during Sunday night maintenance windows. Queries search both indices in parallel, merging results with recency boosting. Articles migrate from hot to cold during nightly batch processes. This architecture achieves <10 second freshness for breaking news while maintaining optimized search performance across the full archive, with total query latency under 40ms.

Challenge: Memory Consumption at Scale

High-dimensional embeddings for large datasets create substantial memory requirements that can exceed available RAM, forcing expensive disk I/O or distributed architectures ¹⁵. A system with 1 billion 768-dimensional float32 embeddings requires 2.9TB of memory for raw vectors alone, before index overhead. Cloud infrastructure costs scale linearly with memory, making naive approaches economically prohibitive.

Solution:

Apply aggressive compression through product quantization and scalar quantization, combined with tiered storage strategies that keep hot data in memory and cold data on SSD ¹⁵. Modern NVMe SSDs provide sufficient throughput for less-frequently accessed vectors, while in-memory caching handles popular queries.

An image search platform with 5 billion images (2048-dimensional embeddings, 38TB uncompressed) implements a three-tier storage strategy. Tier 1 keeps 100 million most-queried images in RAM using 8-bit scalar quantization (195GB). Tier 2 stores 1 billion moderately popular images on NVMe SSD using 8-way product quantization with 256-entry codebooks (7.5GB index, 1TB compressed vectors). Tier 3 archives 3.9 billion rarely-accessed images on network-attached storage with aggressive 16-way product quantization. An adaptive caching policy promotes images between tiers based on query frequency. This architecture reduces memory requirements from 38TB to 200GB while maintaining sub-100ms latency for 95% of queries, cutting infrastructure costs by 85%.

Challenge: Data Distribution Skew and Hotspots

Real-world data distributions are rarely uniform, creating performance hotspots where certain regions of the vector space are densely populated while others are sparse ⁷⁹. Partition-based indices like IVF suffer when queries concentrate on a few popular clusters, overwhelming those partitions while leaving others idle. This creates load imbalance in distributed systems and unpredictable latency.

Solution:

Implement adaptive partitioning strategies that subdivide dense regions and merge sparse regions, combined with dynamic load balancing across distributed nodes ¹⁷. Monitor query patterns and cluster sizes, triggering repartitioning when imbalance exceeds thresholds.

A product search system initially partitions 100 million products into 10,000 IVF clusters using k-means. Monitoring reveals that 20% of queries target just 50 clusters containing popular product categories (electronics, fashion), while 3,000 clusters in niche categories receive minimal traffic. The system implements hierarchical clustering that subdivides the 50 hot clusters into 500 subclusters (10x fanout) while merging 3,000 cold clusters into 300 (10x consolidation), maintaining 10,000 total partitions but with balanced load. Distributed search nodes use consistent hashing with virtual nodes to ensure hot partitions are replicated across multiple servers. This reduces p99 latency from 250ms to 80ms by eliminating hotspot contention, while maintaining average latency and recall rates.

Challenge: Evaluation and Ground Truth Establishment

Measuring index quality requires ground truth nearest neighbors, but computing exact nearest neighbors for evaluation is often as expensive as the problem being solved ⁷⁹. Organizations struggle to validate that approximate methods maintain acceptable recall without prohibitively expensive exact search. This creates a validation gap where production indices may silently degrade without detection.

Solution:

Establish ground truth on representative samples using exact search, and implement continuous quality monitoring through query result comparison and user engagement metrics ⁷⁸. Combine offline evaluation on curated test sets with online A/B testing measuring business outcomes.

A recommendation system creates a ground truth evaluation set by computing exact nearest neighbors for 10,000 sampled user embeddings using brute-force search on a GPU cluster (one-time 48-hour computation). This establishes recall@k baselines for various index configurations. In production, the system continuously samples 0.1% of queries and computes exact results asynchronously for comparison, tracking recall drift over time. Additionally, A/B tests compare index configurations using business metrics (click-through rate, engagement time, conversion rate). When recall@10 drops from 92% to 87% over two weeks due to data distribution shift, automated alerts trigger index retraining. This multi-faceted evaluation approach catches both technical degradation (recall metrics) and business impact (engagement metrics), ensuring index quality aligns with user value.

References

1. Johnson, J., Douze, M., & Jégou, H. (2017). Billion-scale similarity search with GPUs. https://arxiv.org/abs/1603.09320
2. Malkov, Y. A., & Yashunin, D. A. (2018). Efficient and robust approximate nearest neighbor search using Hierarchical Navigable Small World graphs. https://arxiv.org/abs/1702.08734
3. Guo, R., Sun, P., Lindgren, E., Geng, Q., Simcha, D., Chern, F., & Kumar, S. (2020). Accelerating Large-Scale Inference with Anisotropic Vector Quantization. https://research.google/pubs/pub48292/
4. Baranchuk, D., Persiyanov, D., Sinitsin, A., & Babenko, A. (2020). Learning to Route in Similarity Graphs. https://arxiv.org/abs/2006.10639
5. Guo, R., Shen, X., Chern, F., & Kumar, S. (2020). Locally Adaptive Quantization for Similarity Search. https://proceedings.neurips.cc/paper/2020/hash/788d986905533aba051261497ecffcbb-Abstract.html
6. Kraska, T., Beutel, A., Chi, E. H., Dean, J., & Polyzotis, N. (2018). The Case for Learned Index Structures. https://arxiv.org/abs/1908.10396
7. Wang, M., Xu, X., Yue, Q., & Wang, Y. (2020). A Comprehensive Survey and Experimental Comparison of Graph-Based Approximate Nearest Neighbor Search. https://ieeexplore.ieee.org/document/9101432
8. Huang, J., Sharma, A., Sun, S., Xia, L., Zhang, D., Pronin, P., Padmanabhan, J., Ottaviano, G., & Yang, L. (2020). Embedding-based Retrieval in Facebook Search. https://research.google/pubs/pub48293/
9. Morozov, S., & Babenko, A. (2021). Approximate Nearest Neighbor Search under Neural Similarity Metric. https://arxiv.org/abs/2102.10882