uform
v3 for 3 platforms ?️??
Incorporation multimodale de 64 à 768 dimensions • Chat de paramètre 1B
Textes courts • Images • Clips vidéo • Documents longs
Onnx • coreml • pytorch
Python • JavaScript • Swift
Bienvenue à UForm, une bibliothèque d'IA multimodale aussi polyvalente que efficace. Les modèles d'intégration minuscules UForm vous aideront à comprendre et à rechercher le contenu visuel et textuel dans diverses langues. Les petits modèles génératifs UForm, en revanche, ne prennent pas seulement en charge les cas de conversation et d'utilisation du chat, mais sont idéaux pour le sous-titrage d'image rapide et la réponse aux questions visuelles (VQA). Avec des modèles de transformateurs pré-formés personnalisés compacts, cela peut fonctionner de votre ferme de serveur jusqu'à votre smartphone.
f32 à i8 sans perdre beaucoup de rappel.Pour la précision et les références de vitesse, référez-vous à la page d'évaluation.
| Modèle | Paramètres | Langues | Architecture |
|---|---|---|---|
uform3-image-text-english-large ? | 365 m | 1 | 12 couche Bert, Vit-L / 14 |
uform3-image-text-english-base | 143 m | 1 | 4 couche Bert, Vit-B / 16 |
uform3-image-text-english-small ? | 79 m | 1 | 4 couches Bert, Vit-S / 16 |
uform3-image-text-multilingual-base | 206m | 21 | 12 couches Bert, Vit-B / 16 |
| Modèle | Paramètres | But | Architecture |
|---|---|---|---|
uform-gen2-dpo ? | 1,2 b | Chat, légende d'image, VQA | Qwen1.5-0.5b, vit-h / 14 |
uform-gen2-qwen-500m | 1,2 b | Chat, légende d'image, VQA | Qwen1.5-0.5b, vit-h / 14 |
uform-gen | 1,5 b | Le sous-titrage de l'image, VQA | lama-1.3b, vit-b / 16 |
Tout d'abord, pip install uform . Ensuite, chargez le modèle:
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 ]INCHED IMAGES:
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 )Incorporer les requêtes:
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 )Pour plus de détails, consultez:
Les modèles génératifs sont nativement compatibles avec
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 ]Pour plus de détails, consultez:
Selon l'application, les intérêts peuvent être basés sur des représentations numériques plus petites sans perdre beaucoup de rappel. Le passage de f32 à f16 est recommandé dans presque tous les cas, sauf si vous exécutez un très vieux matériel sans support de demi-précision. Le passage à i8 avec une mise à l'échelle linéaire est également possible, mais sera perceptible dans le rappel sur des collections plus grandes avec des millions d'entrées consultables. De même, pour les intérêts de plus grande dimension (512 ou 768), une stratégie commune consiste à les quantifier en représentations mono-bit pour une recherche plus rapide.
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 ))Une approche alternative à la quantification consiste à utiliser les intégres de matryoshka, où les intérêts sont tranchés en parties plus petites, et la recherche est effectuée de manière hiérarchique.
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 ]Les deux approches sont soutenues nativement par le moteur de recherche Vector-Search Usearch et les bibliothèques de numéros SIMSIMD. Lorsque vous traitez avec de petites collections (jusqu'à des millions d'entrées) et à la recherche de calculs de distance en cosinus à faible latence, vous pouvez obtenir une amélioration des performances 5x-2500X par rapport à la torche, Numpy, Scipy et Vanilla Python en utilisant SIMSIMD.
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 CPUDe même, lorsqu'il s'agit de grandes collections (jusqu'à des milliards d'entrées par serveur) et de la recherche d'une recherche à haut débit, vous pouvez obtenir une amélioration des performances 100X par rapport à FAISS et à d'autres solutions de recherche vectorielle à l'aide de Usersearch. Voici quelques exemples:
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 est une forte dépendance à transporter, surtout si vous courez sur les appareils Edge ou IoT. En utilisant l'exécution de la vanille ONNX, on peut réduire considérablement la consommation de mémoire et la latence de déploiement.
$ 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_onnxLa plupart de ce poids peut être encore réduit à 100 Mo pour le modèle et l'exécution. Vous pouvez choisir l'un des nombreux fournisseurs d'exécution ONNX pris en charge, qui comprend XNNPACK, CUDA et Tensorrt pour les GPU NVIDIA, OpenVino sur Intel, DirectML sur Windows, ROCM sur AMD, COREML sur les appareils Apple, et plus à venir.
Les modèles génératifs peuvent être utilisés pour des expériences de type Chat dans la ligne de commande. Pour cela, vous pouvez utiliser l'outil CLI uform-chat , qui est disponible dans le package UForm.
$ 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
