Embedding Models

Pixeltable ships embedding functions for OpenAI, Hugging Face, Jina, Voyage, and more. When your model is not one of them, wrap it in a UDF and declare it in __indexes__. The index then loads with the existing rows and updates as new rows arrive.

Quick start

A UDF that returns a fixed-width array is usable as an embedding. Declare it on the model:

import pixeltable as pxt
import pixeltable.functions as pxtf

TableModel = pxt.model_base()

embed = pxtf.huggingface.sentence_transformer.using(model_id='intfloat/e5-large-v2')

class Docs(TableModel, name='docs'):
    text: pxt.String

    __indexes__ = [pxt.EmbeddingIndex(text, string_embed=embed, name='docs_embed')]

pxt schema update app.py my_app creates the table and the index. Query it with similarity():

t = pxt.get_table('my_app.docs')
sim = t.text.similarity(string='how do computed columns work')
t.order_by(sim, asc=False).limit(10).select(t.text, sim).collect()

Application code declares indexes in __indexes__. In a notebook or a test, call t.add_embedding_index('text', string_embed=embed) instead.

Your own model

.using() covers a built-in function with a fixed parameter. For a model Pixeltable does not ship, write the UDF yourself. The return type fixes the dimension, and the index requires it:

@pxt.udf
def my_embed(text: str) -> pxt.Array[(768,), pxt.Float]:
    return _model().encode(text)

Declaring it is the same:

class Docs(TableModel, name='docs'):
    text: pxt.String

    __indexes__ = [pxt.EmbeddingIndex(text, string_embed=my_embed)]

Load the model once

A UDF body runs per row. Loading weights inside it reloads them on every row. Cache the model at module scope so the cost is paid once per process:

import functools


@functools.cache
def _model():
    from sentence_transformers import SentenceTransformer

    return SentenceTransformer('intfloat/e5-large-v2')


@pxt.udf
def my_embed(text: str) -> pxt.Array[(768,), pxt.Float]:
    return _model().encode(text)

Batch the calls

Embedding models are much faster on a batch than on single rows. A batched UDF takes and returns Batch, and Pixeltable groups rows for you up to batch_size:

from pixeltable.func import Batch


@pxt.udf(batch_size=32)
def my_embed(texts: Batch[str]) -> Batch[pxt.Array[(768,), pxt.Float]]:
    return list(_model().encode(list(texts)))

The signature is the only change. The __indexes__ declaration stays the same.

This is how the built-in functions are written: pxtf.huggingface.sentence_transformer is a @pxt.udf(batch_size=32) over Batch[str].

Metric and precision

EmbeddingIndex takes metric (cosine, ip, or l2; default cosine) and precision (fp16 or fp32; default fp16). Match the metric to how your model was trained:

__indexes__ = [
    pxt.EmbeddingIndex(text, string_embed=my_embed, metric='ip', precision='fp32')
]

Additional resources

UDFs

Writing and batching UDFs

Embedding indexes

Built-in embeddings and search

Model hub

Find embedding models

Built-in Integrations

Infrastructure

Bring Your Own

Providers

Quick start

Your own model

Load the model once

Batch the calls

Metric and precision

Additional resources

UDFs

Embedding indexes

Model hub

​Quick start

​Your own model

​Load the model once

​Batch the calls

​Metric and precision

​Additional resources

UDFs

Embedding indexes

Model hub

Quick start

Your own model

Load the model once

Batch the calls

Metric and precision

Additional resources