Indeksowanie IVFFlat na potrzeby szybkości

Welcome to optimizing pgvector performance! For small datasets, a simple vector similarity query might be fast enough. But as your data grows, brute-force search becomes too slow.

This lesson introduces IVFFlat indexing, a powerful technique to accelerate Approximate Nearest Neighbor (ANN) searches in pgvector.

Imagine searching for the closest person to you in a massive crowd. Without any organization, you'd have to check every single person.

Similarly, without an index, pgvector has to compare your query vector to every single vector in your table. This is called a brute-force search, and it's inefficient for large datasets.

• Indexes organize data.
• They make lookups much faster.
• Crucial for scalable vector search.

IVFFlat (Inverted File Index with Flat quantizer) is an ANN indexing algorithm. Its core idea is to group similar vectors into 'lists' or 'clusters'.

Think of it like sorting books by genre before looking for a specific title. You first pick the right genre, then search within that smaller section.

When you query an IVFFlat index, it performs a two-step process:

1. Find nearest lists: It quickly identifies a few (or more) clusters that are closest to your query vector.
2. Search within lists: It then only searches for nearest neighbors within those selected clusters, ignoring the rest of the dataset.

This significantly reduces the number of comparisons needed, speeding up your queries.

When creating an IVFFlat index, the most important parameter is lists. This defines how many clusters (or partitions) your data will be divided into.

• More lists: Each cluster has fewer vectors. This can lead to faster searches (less data to scan per cluster).
• Fewer lists: Each cluster has more vectors. Searches might be slower, but you're less likely to miss true nearest neighbors.

It's a trade-off between search speed and recall (how many of the true nearest neighbors you actually find).

Before creating an index, you need a table with a vector column. If you haven't already, ensure the vector extension is enabled.

Here's a quick setup for a table with 3-dimensional vectors:

Now, let's create an IVFFlat index on our embedding column. We'll specify the vector_l2_ops operator class for L2 distance (Euclidean distance), and set the lists parameter.

A good starting point for lists is rows / 1000 for up to 1M rows, or sqrt(rows) for larger datasets.

Once the IVFFlat index is created, your standard similarity queries will automatically benefit from it! pgvector will use the index to find approximate nearest neighbors much faster.

Let's find the 3 closest items to [1,2,3]:

At query time, you can further tune the search with the ivfflat.probes parameter. This setting controls how many of the nearest 'lists' (clusters) are actually searched.

• More probes: Better recall, but slower search.
• Fewer probes: Faster search, but potentially lower recall.

The default probes value is 1. You can set it for your session:

Let's test your understanding of IVFFlat indexing.

Great job! You've learned the fundamentals of IVFFlat indexing in pgvector.

• IVFFlat speeds up ANN searches by partitioning data.
• The lists parameter (index creation) controls the number of clusters.
• The ivfflat.probes parameter (query time) controls how many clusters are searched.
• Both involve a trade-off between search speed and recall.

Next, we'll explore HNSW indexing, another powerful option for even higher recall.