UForm

Pocket-Sized Multimodal AI
For Content Understanding and Generation

Multimodal Embeddings from 64 to 768 Dimensions • 1B Parameter Chat
Short Texts • Images • 🔜 Video Clips • 🔜 Long Documents
ONNX • CoreML • PyTorch
Python • JavaScript • Swift

Welcome to UForm, a multimodal AI library that's as versatile as it is efficient. UForm tiny embedding models will help you understand and search visual and textual content across various languages. UForm small generative models, on the other hand, don't only support conversational and chat use-cases, but are great for fast image captioning and Visual Question Answering (VQA). With compact custom pre-trained transformer models, this can run anywhere from your server farm down to your smartphone.

Features

• Tiny Embeddings: 64-dimensional Matryoshka-style embeddings for extremely fast search.
• Throughput: Thanks to the small size, the inference speed is 2-4x faster than competitors.
• Portable: Models come with native ONNX support, making them easy to deploy on any platform.
• Quantization Aware: Down-cast embeddings from f32 to i8 without losing much recall.
• Multilingual: Trained on a balanced dataset, the recall is great across over 20 languages.

Models

For accuracy and speed benchmarks refer to the evaluation page.

Embedding Models

Generative Models

Quick Start Examples

Embedding Models

First, pip install uform. Then, load the model:

```py from uform import get_model, Modality

processors, models = get_model('unum-cloud/uform3-image-text-english-small')

modeltext = models[Modality.TEXTENCODER] modelimage = models[Modality.IMAGEENCODER] processortext = processors[Modality.TEXTENCODER] processorimage = processors[Modality.IMAGEENCODER] ```

Embed images:

```py import requests from io import BytesIO from PIL import Image

imageurl = 'https://media-cdn.tripadvisor.com/media/photo-s/1b/28/6b/53/lovely-armenia.jpg' image = Image.open(BytesIO(requests.get(imageurl).content)) imagedata = processorimage(image) imagefeatures, imageembedding = modelimage.encode(imagedata, return_features=True) ```

Embed queries:

py text = 'a cityscape bathed in the warm glow of the sun, with varied architecture and a towering, snow-capped mountain rising majestically in the background' text_data = processor_text(text) text_features, text_embedding = model_text.encode(text_data, return_features=True)

For more details check out:

• Python docs on embedding models in python/README.md
• JavaScript docs on embedding models in javascript/README.md
• Swift docs on embedding models in swift/README.md

Generative Models

The generative models are natively compatible with

```python from transformers import AutoModel, AutoProcessor

model = AutoModel.frompretrained('unum-cloud/uform-gen2-dpo', trustremotecode=True) processor = AutoProcessor.frompretrained('unum-cloud/uform-gen2-dpo', trustremotecode=True)

prompt = 'Question or Instruction' image = Image.open('image.jpg')

inputs = processor(text=[prompt], images=[image], return_tensors='pt')

with torch.inferencemode(): output = model.generate( **inputs, dosample=False, usecache=True, maxnewtokens=256, eostokenid=151645, padtokenid=processor.tokenizer.padtokenid ) promptlen = inputs['inputids'].shape[1] decodedtext = processor.batchdecode(output[:, promptlen:])[0] ```

For more details check out:

• Python docs on generative models in python/README.md
• JavaScript docs on generative models 🔜
• Swift docs on generative models 🔜

Technical Details

Down-casting, Quantization, Matryoshka, and Slicing

Depending on the application, the embeddings can be down-casted to smaller numeric representations without losing much recall. Switching from f32 to f16 is recommended in almost all cases, unless you are running on very old hardware without half-precision support. Switching to i8 with linear scaling is also possible, but will be noticeable in the recall on larger collections with millions of searchable entries. Similarly, for higher-dimensional embeddings (512 or 768), a common strategy is to quantize them into single-bit representations for faster search.

```python import numpy as np

f32embedding: np.ndarray = model.encodetext(textdata, returnfeatures=False) f16embedding: np.ndarray = f32embedding.astype(np.float16) i8embedding: np.ndarray = (f32embedding * 127).astype(np.int8) b1embedding: np.ndarray = np.packbits((f32embedding > 0).astype(np.uint8)) ```

Alternative approach to quantization is to use the Matryoshka embeddings, where the embeddings are sliced into smaller parts, and the search is performed in a hierarchical manner.

```python import numpy as np

largeembedding: np.ndarray = model.encodetext(textdata, returnfeatures=False) smallembedding: np.ndarray = largeembedding[:, :256] tinyembedding: np.ndarray = largeembedding[:, :64] ```

Both approaches are natively supported by the USearch vector-search engine and the SimSIMD numerics libraries. When dealing with small collections (up to millions of entries) and looking for low-latency cosine distance calculations, you can achieve 5x-2500x performance improvement over Torch, NumPy, SciPy, and vanilla Python using SimSIMD.

```python from simsimd import cosine, hamming

distance: float = cosine(f32embedding, f32embedding) # 32x SciPy performance on Apple M2 CPU distance: float = cosine(f16embedding, f16embedding) # 79x SciPy performance on Apple M2 CPU distance: float = cosine(i8embedding, i8embedding) # 133x SciPy performance on Apple M2 CPU distance: float = hamming(b1embedding, b1embedding) # 17x SciPy performance on Apple M2 CPU ```

Similarly, when dealing with large collections (up to billions of entries per server) and looking for high-throughput search, you can achieve 100x performance improvement over FAISS and other vector-search solutions using USearch. Here are a couple of examples:

```python from usearch.index import Index

f32index = Index(ndim=64, metric='cos', dtype='f32') # for Matryoshka embeddings f16index = Index(ndim=64, metric='cos', dtype='f16') # for Matryoshka embeddings i8index = Index(ndim=256, metric='cos', dtype='i8') # for quantized embeddings b1index = Index(ndim=768, metric='hamming', dtype='b1') # for binary embeddings ```

Compact Packaging

PyTorch is a heavy dependency to carry, especially if you run on Edge or IoT devices. Using vanilla ONNX runtime, one can significantly reduce memory consumption and deployment latency.

```sh $ conda create -n uformtorch python=3.10 -y $ conda create -n uformonnx python=3.10 -y $ conda activate uformtorch && pip install -e ".[torch]" && conda deactivate $ conda activate uformonnx && pip install -e ".[onnx]" && conda deactivate $ du -sh $(conda info --envs | grep 'uform_torch' | awk '{print $2}')

5.2G ~/conda/envs/uformtorch $ du -sh $(conda info --envs | grep 'uformonnx' | awk '{print $2}') 461M ~/conda/envs/uform_onnx ```

Most of that weight can be further reduced down to 100 MB for both the model and the runtime. You can pick one of many supported ONNX execution providers, which includes XNNPACK, CUDA and TensorRT for Nvidia GPUs, OpenVINO on Intel, DirectML on Windows, ROCm on AMD, CoreML on Apple devices, and more to come.

Multimodal Chat in CLI

The generative models can be used for chat-like experiences in the command line. For that, you can use the uform-chat CLI tool, which is available in the UForm package.

```bash $ pip install uform $ uform-chat --model unum-cloud/uform-gen2-dpo --image=zebra.jpg $ uform-chat --model unum-cloud/uform-gen2-dpo \

--image="https://bit.ly/3tIVg9M" \
--device="cuda:0" \
--fp16

```