uform
v3 for 3 platforms ?️??
Multimodale Einbettungen von 64 bis 768 Abmessungen • 1B Parameter Chat
Kurze Texte • Bilder • Videoclips • Lange Dokumente
Onnx • coreml • pytorch
Python • JavaScript • Swift
Willkommen bei Uform, einer multimodalen KI -Bibliothek, die so vielseitig wie effizient ist. UFFORME TINY -Einbettungsmodelle helfen Ihnen dabei, visuelle und textuelle Inhalte in verschiedenen Sprachen zu verstehen und zu suchen. UFFORMENDE Small generative Modelle unterstützen hingegen nicht nur Konversations- und Chat-Anwendungsfälle, sondern eignen sich hervorragend für schnelle Bildunterschriften und visuelle Beantwortung (VQA). Mit kompakten maßgeschneiderten Modellen für vorgeschriebene Transformator kann dies von Ihrer Serverfarm bis hin zu Ihrem Smartphone ausgeführt werden.
f32 bis i8 , ohne viel Rückruf zu verlieren.Für Genauigkeit und Geschwindigkeitsbenchmarks finden Sie auf die Bewertungsseite.
| Modell | Parameter | Sprachen | Architektur |
|---|---|---|---|
uform3-image-text-english-large ? | 365 m | 1 | 12 Schicht Bert, Vit-L/14 |
uform3-image-text-english-base | 143 m | 1 | 4 Schicht Bert, Vit-B/16 |
uform3-image-text-english-small ? | 79 m | 1 | 4 Schicht Bert, Vit-S/16 |
uform3-image-text-multilingual-base | 206 m | 21 | 12 Schicht Bert, Vit-B/16 |
| Modell | Parameter | Zweck | Architektur |
|---|---|---|---|
uform-gen2-dpo ? | 1.2 b | Chat, Bildunterschrift, VQA | Qwen1.5-0.5b, Vit-H/14 |
uform-gen2-qwen-500m | 1.2 b | Chat, Bildunterschrift, VQA | Qwen1.5-0.5b, Vit-H/14 |
uform-gen | 1,5 b | Bildunterschrift, VQA | LAMA-1.3B, Vit-B/16 |
Erstens pip install uform . Laden Sie dann das Modell: laden Sie:
from uform import get_model , Modality
processors , models = get_model ( 'unum-cloud/uform3-image-text-english-small' )
model_text = models [ Modality . TEXT_ENCODER ]
model_image = models [ Modality . IMAGE_ENCODER ]
processor_text = processors [ Modality . TEXT_ENCODER ]
processor_image = processors [ Modality . IMAGE_ENCODER ]Bilder einbetten:
import requests
from io import BytesIO
from PIL import Image
image_url = 'https://media-cdn.tripadvisor.com/media/photo-s/1b/28/6b/53/lovely-armenia.jpg'
image = Image . open ( BytesIO ( requests . get ( image_url ). content ))
image_data = processor_image ( image )
image_features , image_embedding = model_image . encode ( image_data , return_features = True )Anfragen einbetten:
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 )Weitere Informationen finden Sie unter:
Die generativen Modelle sind nativ kompatibel mit
from transformers import AutoModel , AutoProcessor
model = AutoModel . from_pretrained ( 'unum-cloud/uform-gen2-dpo' , trust_remote_code = True )
processor = AutoProcessor . from_pretrained ( 'unum-cloud/uform-gen2-dpo' , trust_remote_code = True )
prompt = 'Question or Instruction'
image = Image . open ( 'image.jpg' )
inputs = processor ( text = [ prompt ], images = [ image ], return_tensors = 'pt' )
with torch . inference_mode ():
output = model . generate (
** inputs ,
do_sample = False ,
use_cache = True ,
max_new_tokens = 256 ,
eos_token_id = 151645 ,
pad_token_id = processor . tokenizer . pad_token_id
)
prompt_len = inputs [ 'input_ids' ]. shape [ 1 ]
decoded_text = processor . batch_decode ( output [:, prompt_len :])[ 0 ]Weitere Informationen finden Sie unter:
Abhängig von der Anwendung können die Einbettungen auf kleinere numerische Darstellungen heruntergefahren werden, ohne viel Rückruf zu verlieren. Der Umschalten von f32 auf f16 wird in fast allen Fällen empfohlen, es sei denn, Sie laufen mit sehr alter Hardware ohne Unterstützung mit halbem Präzision. Das Umschalten auf i8 mit linearer Skalierung ist ebenfalls möglich, wird jedoch im Rückruf bei größeren Sammlungen mit Millionen von durchsuchbaren Einträgen spürbar sein. In ähnlicher Weise besteht eine gemeinsame Strategie bei höherdimensionalen Einbettungen (512 oder 768) darin, sie in Einzelbit-Darstellungen für eine schnellere Suche zu quantisieren.
import numpy as np
f32_embedding : np . ndarray = model . encode_text ( text_data , return_features = False )
f16_embedding : np . ndarray = f32_embedding . astype ( np . float16 )
i8_embedding : np . ndarray = ( f32_embedding * 127 ). astype ( np . int8 )
b1_embedding : np . ndarray = np . packbits (( f32_embedding > 0 ). astype ( np . uint8 ))Der alternative Ansatz zur Quantisierung besteht darin, die Matryoshka -Einbettungen zu verwenden, bei denen die Einbettungen in kleinere Teile geschnitten werden und die Suche auf hierarchische Weise durchgeführt wird.
import numpy as np
large_embedding : np . ndarray = model . encode_text ( text_data , return_features = False )
small_embedding : np . ndarray = large_embedding [:, : 256 ]
tiny_embedding : np . ndarray = large_embedding [:, : 64 ]Beide Ansätze werden von der Usearch Vector-Such-Engine und den Simsimd Numerics-Bibliotheken nativ unterstützt. Beim Umgang mit kleinen Sammlungen (bis zu Millionen von Einträgen) und der Suche nach Cosinus-Entfernungsberechnungen mit geringer Latenz können Sie mit Simsimd mit Simsimd eine Leistungsverbesserung von 5x-2500x gegenüber Torch, Numpy, Scipy und Vanilla Python erzielen.
from simsimd import cosine , hamming
distance : float = cosine ( f32_embedding , f32_embedding ) # 32x SciPy performance on Apple M2 CPU
distance : float = cosine ( f16_embedding , f16_embedding ) # 79x SciPy performance on Apple M2 CPU
distance : float = cosine ( i8_embedding , i8_embedding ) # 133x SciPy performance on Apple M2 CPU
distance : float = hamming ( b1_embedding , b1_embedding ) # 17x SciPy performance on Apple M2 CPUIn ähnlicher Weise können Sie im Umgang mit großen Sammlungen (bis zu Milliarden von Einträgen pro Server) und der Suche nach einer Hochdurchsatz-Suche mithilfe von Usearch eine 100-fache Leistungsverbesserung gegenüber FAISS und anderen Vektor-Such-Lösungen erzielen. Hier sind einige Beispiele:
from usearch . index import Index
f32_index = Index ( ndim = 64 , metric = 'cos' , dtype = 'f32' ) # for Matryoshka embeddings
f16_index = Index ( ndim = 64 , metric = 'cos' , dtype = 'f16' ) # for Matryoshka embeddings
i8_index = Index ( ndim = 256 , metric = 'cos' , dtype = 'i8' ) # for quantized embeddings
b1_index = Index ( ndim = 768 , metric = 'hamming' , dtype = 'b1' ) # for binary embeddingsPytorch ist eine schwere Abhängigkeit, insbesondere wenn Sie an Kanten- oder IoT -Geräten laufen. Mit der Laufzeit von Vanille -ONNX kann man den Speicherverbrauch und die Latenz für die Bereitstellung erheblich reduzieren.
$ conda create -n uform_torch python=3.10 -y
$ conda create -n uform_onnx python=3.10 -y
$ conda activate uform_torch && pip install -e " .[torch] " && conda deactivate
$ conda activate uform_onnx && pip install -e " .[onnx] " && conda deactivate
$ du -sh $( conda info --envs | grep ' uform_torch ' | awk ' {print $2} ' )
> 5.2G ~ /conda/envs/uform_torch
$ du -sh $( conda info --envs | grep ' uform_onnx ' | awk ' {print $2} ' )
> 461M ~ /conda/envs/uform_onnxDas meiste Gewicht kann sowohl für das Modell als auch für die Laufzeit auf 100 MB verringert werden. Sie können einen von vielen unterstützten ONNX -Ausführungsanbietern auswählen, zu denen Xnnpack, Cuda und Tensorrt für NVIDIA GPUS, OpenVino auf Intel, DirectML unter Windows, ROCM auf AMD, Coreml auf Apple -Geräten und mehr kommen.
Die generativen Modelle können für chat-ähnliche Erlebnisse in der Befehlszeile verwendet werden. Dafür können Sie das uform-chat -CLI-Tool verwenden, das im Uform-Paket verfügbar ist.
$ 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
