uform
v3 for 3 platforms ?️??
Incorporações multimodais de 64 a 768 Dimensões • 1B Parâmetro Chat
Textos curtos • Imagens • videoclipes • Documentos longos
Onnx • Coreml • Pytorch
Python • JavaScript • Swift
Bem -vindo ao Uform, uma biblioteca de AI multimodal que é tão versátil quanto eficiente. Os minúsculos modelos de incorporação do Uform ajudarão você a entender e pesquisar conteúdo visual e textual em vários idiomas. Os pequenos modelos generativos, por outro lado, não suportam apenas as casos de uso de conversação e bate-papo, mas são ótimos para legendas de imagem rápida e resposta visual de perguntas (VQA). Com os modelos de transformadores pré-treinados personalizados compactos, isso pode ser executado em qualquer lugar, desde o seu farm de servidores até o seu smartphone.
f32 a i8 sem perder muito lembrança.Para uma precisão e referência de velocidade, consulte a página de avaliação.
| Modelo | Parâmetros | Idiomas | Arquitetura |
|---|---|---|---|
uform3-image-text-english-large ? | 365 m | 1 | 12 camadas Bert, Vit-L/14 |
uform3-image-text-english-base | 143 m | 1 | 4 camadas Bert, Vit-B/16 |
uform3-image-text-english-small ? | 79 m | 1 | 4 camadas Bert, Vit-S/16 |
uform3-image-text-multilingual-base | 206m | 21 | 12 camadas Bert, Vit-B/16 |
| Modelo | Parâmetros | Propósito | Arquitetura |
|---|---|---|---|
uform-gen2-dpo ? | 1.2 b | Bate -papo, legenda de imagem, VQA | QWEN1.5-0.5B, VIT-H/14 |
uform-gen2-qwen-500m | 1.2 b | Bate -papo, legenda de imagem, VQA | QWEN1.5-0.5B, VIT-H/14 |
uform-gen | 1.5 b | Legenda de imagem, VQA | lhama-1.3b, vit-b/16 |
Primeiro, pip install uform . Em seguida, carregue o modelo:
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 ]Imagens de incorporação:
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 )Consultas de incorporação:
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 )Para mais detalhes, confira:
Os modelos generativos são nativamente compatíveis com
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 ]Para mais detalhes, confira:
Dependendo da aplicação, as incorporações podem ser revestidas para representações numéricas menores sem perder muito recall. A mudança de f32 para f16 é recomendada em quase todos os casos, a menos que você esteja executando em hardware muito antigo sem suporte a meia precisão. Também é possível mudar para i8 com escala linear, mas será perceptível no recall de coleções maiores com milhões de entradas pesquisáveis. Da mesma forma, para incorporações de alta dimensão (512 ou 768), uma estratégia comum é quantizá-las em representações de bits únicos para pesquisa mais rápida.
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 ))A abordagem alternativa da quantização é usar as incorporações de Matryoshka, onde as incorporações são cortadas em partes menores, e a pesquisa é realizada de maneira hierárquica.
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 ]Ambas as abordagens são suportadas nativamente pelo mecanismo de pesquisa vetorial de pesquisa e pelas bibliotecas numéricas simsimd. Ao lidar com pequenas coleções (até milhões de entradas) e procurar cálculos de distância cosseno de baixa latência, você pode obter uma melhoria de desempenho 5x-2500X sobre a tocha, Numpy, Scipy e Vanilla Python usando o 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 CPUDa mesma forma, ao lidar com grandes coleções (até bilhões de entradas por servidor) e à procura de pesquisa de alto rendimento, você pode obter uma melhoria de desempenho de 100x em relação ao FAISS e outras soluções de pesquisa vetorial usando o Usearch. Aqui estão alguns exemplos:
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 embeddingsO Pytorch é uma dependência pesada de transportar, especialmente se você correr na borda ou em dispositivos IoT. Usando tempo de execução de baunilha ONNX, pode -se reduzir significativamente o consumo de memória e a latência de implantação.
$ 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_onnxA maior parte desse peso pode ser reduzida ainda mais para 100 MB para o modelo e o tempo de execução. Você pode escolher um dos muitos provedores de execução ONNX suportados, que inclui Xnnpack, Cuda e Tensorrt para Nvidia GPUs, Openvino no Intel, DirectML no Windows, ROCM na AMD, COREML em dispositivos Apple e mais por vir.
Os modelos generativos podem ser usados para experiências semelhantes a bate-papo na linha de comando. Para isso, você pode usar a ferramenta CLI uform-chat , disponível no pacote 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
