candle

vela

Candle é uma estrutura de ML minimalista para Rust com foco no desempenho (incluindo suporte a GPU) e facilidade de uso. Experimente nossas demonstrações online: sussurro, LLaMA2, T5, yolo, Segment Anything.

Comece

Certifique-se de ter candle-core instalado corretamente conforme descrito em Instalação .

Vamos ver como executar uma multiplicação de matrizes simples. Escreva o seguinte em seu arquivo myapp/src/main.rs :

 use candle_core :: { Device , Tensor } ;

fn main ( ) -> Result < ( ) , Box < dyn std :: error :: Error > > {
    let device = Device :: Cpu ;

    let a = Tensor :: randn ( 0f32 , 1. , ( 2 , 3 ) , & device ) ? ;
    let b = Tensor :: randn ( 0f32 , 1. , ( 3 , 4 ) , & device ) ? ;

    let c = a . matmul ( & b ) ? ;
    println ! ( "{c}" ) ;
    Ok ( ( ) )
}

cargo run deve exibir um tensor de forma Tensor[[2, 4], f32] .

Tendo instalado candle com suporte Cuda, basta definir o device para estar na GPU:

 - let device = Device::Cpu;
+ let device = Device::new_cuda(0)?;

Para exemplos mais avançados, dê uma olhada na seção a seguir.

Confira nossos exemplos

Estas demonstrações online são executadas inteiramente no seu navegador:

• yolo: estimativa de pose e reconhecimento de objetos.
• sussurro: reconhecimento de fala.
• LLaMA2: geração de texto.
• T5: geração de texto.
• Phi-1.5 e Phi-2: geração de texto.
• Modelo Segmentar Qualquer Coisa: Segmentação de imagem.
• BLIP: legendagem de imagens.

Também fornecemos alguns exemplos baseados em linha de comando usando modelos de última geração:

• LLaMA v1, v2 e v3: LLM geral, inclui a variante SOLAR-10.7B.
• Falcão: LLM geral.
• Codegeex4: conclusão de código, intérprete de código, pesquisa na web, chamada de função, nível de repositório
• GLM4: Abra LMs de bate-papo multimodal multilíngue por THUDM
• Gemma v1 e v2: LLMs gerais 2b e 7b+/9b do Google Deepmind.
• RecurrentGemma: modelos 2b e 7b baseados em Griffin do Google que misturam atenção com um estado semelhante ao RNN.
• Phi-1, Phi-1.5, Phi-2 e Phi-3: LLMs gerais 1.3b, 2.7b e 3.8b com desempenho equivalente aos modelos 7b.
• StableLM-3B-4E1T: um LLM geral 3b pré-treinado em tokens 1T de inglês e conjuntos de dados de código. Também suporta StableLM-2, um LLM 1.6b treinado em tokens 2T, bem como variantes de código.
• Mamba: uma implementação apenas de inferência do modelo de espaço de estados Mamba.
• Mistral7b-v0.1: um LLM geral 7b com melhor desempenho do que todos os modelos 13b disponíveis publicamente em 28/09/2023.
• Mixtral8x7b-v0.1: uma mistura esparsa de LLM geral 8x7b de especialistas com melhor desempenho do que um modelo Llama 2 70B com inferência muito mais rápida.
• StarCoder e StarCoder2: LLM especializado em geração de código.
• Qwen1.5: LLMs bilíngues (inglês/chinês).
• RWKV v5 e v6: Um RNN com desempenho LLM em nível de transformador.
• Replit-code-v1.5: um LLM 3.3b especializado para conclusão de código.
• Yi-6B / Yi-34B: dois LLMs gerais bilíngues (inglês/chinês) com parâmetros 6b e 34b.
• LLaMA quantizado: versão quantizada do modelo LLaMA usando as mesmas técnicas de quantização do llama.cpp.

• Difusão Estável: modelo generativo de texto para imagem, suporte para as versões 1.5, 2.1, SDXL 1.0 e Turbo.

• Wuerstchen: outro modelo gerador de texto para imagem.

• yolo-v3 e yolo-v8: modelos de detecção de objetos e estimativa de pose.

• segment-anything: modelo de segmentação de imagens com prompt.

• SegFormer: modelo de segmentação semântica baseado em transformador.
• Sussurro: modelo de reconhecimento de fala.
• EnCodec: modelo de compressão de áudio de alta qualidade usando quantização vetorial residual.
• MetaVoice: modelo fundamental para conversão de texto em fala.
• Parler-TTS: modelo grande de conversão de texto em fala.
• T5, Bert, JinaBert: útil para incorporação de frases.
• DINOv2: modelo de visão computacional treinado com autosupervisão (pode ser usado para classificação de imagenet, avaliação de profundidade, segmentação).
• VGG, RepVGG: modelos de visão computacional.
• BLIP: modelo de imagem para texto, pode ser usado para gerar legendas para uma imagem.
• CLIP: visão multimodelo e modelo de linguagem.
• TrOCR: um modelo de OCR transformador, com submodelos dedicados para escrita manual e reconhecimento impresso.
• Marian-MT: modelo de tradução automática neural, gera o texto traduzido a partir do texto de entrada.
• Moondream: pequeno modelo de visão computacional que pode responder a perguntas do mundo real sobre imagens.

Execute-os usando comandos como:

 cargo run --example quantized --release

Para usar CUDA, adicione --features cuda à linha de comando de exemplo. Se você tiver o cuDNN instalado, use --features cudnn para acelerar ainda mais.

Existem também alguns exemplos de wasm para sussurro e llama2.c. Você pode construí-los com trunk ou experimentá-los online: sussurro, llama2, T5, Phi-1.5 e Phi-2, Segment Anything Model.

Para LLaMA2, execute o seguinte comando para recuperar os arquivos de peso e iniciar um servidor de teste:

 cd candle-wasm-examples/llama2-c
wget https://huggingface.co/spaces/lmz/candle-llama2/resolve/main/model.bin
wget https://huggingface.co/spaces/lmz/candle-llama2/resolve/main/tokenizer.json
trunk serve --release --port 8081

E então vá para http://localhost:8081/.

Recursos externos úteis

• candle-tutorial : Um tutorial muito detalhado mostrando como converter um modelo PyTorch em Candle.
• candle-lora : Implementação LoRA eficiente e ergonômica para Candle. candle-lora tem
  suporte LoRA pronto para uso para muitos modelos da Candle, que pode ser encontrado aqui.
• optimisers : uma coleção de otimizadores, incluindo SGD com momentum, AdaGrad, AdaDelta, AdaMax, NAdam, RAdam e RMSprop.
• candle-vllm : Plataforma eficiente para inferência e atendimento de LLMs locais, incluindo um servidor API compatível com OpenAI.
• candle-ext : Uma biblioteca de extensão para Candle que fornece funções PyTorch não disponíveis atualmente no Candle.
• candle-coursera-ml : Implementação de algoritmos de ML do curso de especialização em aprendizado de máquina do Coursera.
• kalosm : Uma metaestrutura multimodal em Rust para interface com modelos locais pré-treinados com suporte para geração controlada, samplers personalizados, bancos de dados de vetores na memória, transcrição de áudio e muito mais.
• candle-sampling : Técnicas de amostragem para velas.
• gpt-from-scratch-rs : Uma versão do tutorial Vamos construir GPT de Andrej Karpathy no YouTube apresentando a API Candle em um problema de brinquedo.
• candle-einops : Uma implementação de ferrugem pura da biblioteca python einops.
• atoma-infer : uma biblioteca Rust para inferência rápida em escala, aproveitando FlashAttention2 para computação de atenção eficiente, PagedAttention para gerenciamento eficiente de memória de cache KV e suporte multi-GPU. É compatível com a API OpenAI.

Se você tiver uma adição a esta lista, envie uma solicitação pull.

Características

• Sintaxe simples, parece PyTorch.
  • Treinamento de modelo.
  • Incorpore operações/kernels definidos pelo usuário, como flash-attention v2.
• Back-ends.
  • Back-end de CPU otimizado com suporte MKL opcional para x86 e Accelerate para Macs.
  • Backend CUDA para execução eficiente em GPUs, distribuição de múltiplas GPUs via NCCL.
  • Suporte WASM, execute seus modelos em um navegador.
• Modelos incluídos.
  • Modelos de linguagem.
    • LLaMA v1, v2 e v3 com variantes como SOLAR-10.7B.
    • Falcão.
    • StarCoder, StarCoder2.
    • Phi 1, 1,5, 2 e 3.
    • Mamba, Mamba Mínima
    • Gemma v1 2b e 7b+, v2 2b e 9b.
    • Mistral 7b v0.1.
    • Mixtral 8x7b v0.1.
    • StableLM-3B-4E1T, StableLM-2-1.6B, Stable-Code-3B.
    • Código de repetição-v1.5-3B.
    • Bert.
    • Yi-6B e Yi-34B.
    • Qwen1.5, Qwen1.5 MoE.
    • RWKV v5 e v6.
  • LLMs quantizados.
    • Llama 7b, 13b, 70b, bem como as variantes de chat e código.
    • Mistral 7b e 7b instruem.
    • Mixtral 8x7b.
    • Zephyr 7b aeb (baseado em Mistral-7b).
    • OpenChat 3.5 (baseado em Mistral-7b).
  • Texto para texto.
    • T5 e suas variantes: FlanT5, UL2, MADLAD400 (tradução), CoEdit (correção gramatical).
    • Marian MT (Tradução Automática).
  • Texto para imagem.
    • Difusão Estável v1.5, v2.1, XL v1.0.
    • Würstchen v2.
  • Imagem para texto.
    • BLIPE.
    • TrOCR.
  • Áudio.
    • Sussurro, fala para texto multilíngue.
    • EnCodec, modelo de compressão de áudio.
    • MetaVoice-1B, modelo de conversão de texto em fala.
    • Parler-TTS, modelo de conversão de texto em fala.
  • Modelos de visão computacional.
    • DINOv2, ConvMixer, EfficientNet, ResNet, ViT, VGG, RepVGG, ConvNeXT, ConvNeXTv2, MobileOne, EfficientVit (MSRA), MobileNetv4, Hiera, FastViT.
    • yolo-v3, yolo-v8.
    • Modelo Segment-Qualquer coisa (SAM).
    • SegFormer.
• Formatos de arquivo: carrega modelos de arquivos safetensors, npz, ggml ou PyTorch.
• Sem servidor (na CPU), implantações pequenas e rápidas.
• Suporte à quantização usando os tipos quantizados llama.cpp.

Como usar

Folha de dicas:

	Usando PyTorch	Usando Vela
Criação	torch.Tensor([[1, 2], [3, 4]])	Tensor::new(&[[1f32, 2.], [3., 4.]], &Device::Cpu)?
Criação	torch.zeros((2, 2))	Tensor::zeros((2, 2), DType::F32, &Device::Cpu)?
Indexação	tensor[:, :4]	tensor.i((.., ..4))?
Operações	tensor.view((2, 2))	tensor.reshape((2, 2))?
Operações	a.matmul(b)	a.matmul(&b)?
Aritmética	a + b	&a + &b
Dispositivo	tensor.to(device="cuda")	tensor.to_device(&Device::new_cuda(0)?)?
Tipo D	tensor.to(dtype=torch.float16)	tensor.to_dtype(&DType::F16)?
Salvando	torch.save({"A": A}, "model.bin")	candle::safetensors::save(&HashMap::from([("A", A)]), "model.safetensors")?
Carregando	weights = torch.load("model.bin")	candle::safetensors::load("model.safetensors", &device)

Estrutura

• candle-core: operações principais, dispositivos e definição de estrutura Tensor
• candle-nn: Ferramentas para construir modelos reais
• exemplos de velas: exemplos de uso da biblioteca em ambientes realistas
• candle-kernels: kernels personalizados CUDA
• conjuntos de dados de velas: conjuntos de dados e carregadores de dados.
• transformadores vela: utilidades relacionadas a transformadores.
• vela-flash-attn: camada de atenção v2 do Flash.
• candle-onnx: avaliação do modelo ONNX.

Perguntas frequentes

Por que devo usar Vela?

O principal objetivo do Candle é tornar possível a inferência sem servidor . Estruturas completas de aprendizado de máquina como PyTorch são muito grandes, o que torna lenta a criação de instâncias em um cluster. Candle permite a implantação de binários leves.

Em segundo lugar, o Candle permite remover o Python das cargas de trabalho de produção. A sobrecarga do Python pode prejudicar seriamente o desempenho, e o GIL é uma fonte notória de dores de cabeça.

Finalmente, Rust é legal! Grande parte do ecossistema HF já possui caixas de ferrugem, como safetensors e tokenizers.

Outras estruturas de ML

• dfdx é uma caixa formidável, com formas incluídas em tipos. Isso evita muitas dores de cabeça, fazendo com que o compilador reclame imediatamente sobre incompatibilidades de forma. No entanto, descobrimos que alguns recursos ainda exigem o uso noturno, e escrever código pode ser um pouco assustador para quem não é especialista em ferrugem.

  Estamos aproveitando e contribuindo com outras caixas principais para o tempo de execução, então esperamos que ambas as caixas possam se beneficiar uma da outra.

• burn é uma caixa geral que pode aproveitar vários back-ends para que você possa escolher o melhor mecanismo para sua carga de trabalho.

• tch-rs Vinculações à biblioteca de tochas no Rust. Extremamente versáteis, mas trazem toda a biblioteca de tochas para o tempo de execução. O principal contribuidor do tch-rs também está envolvido no desenvolvimento do candle .

Erros Comuns

Símbolos ausentes ao compilar com o recurso mkl.

Se você receber alguns símbolos ausentes ao compilar binários/testes usando os recursos mkl ou acelerar, por exemplo, para mkl você obterá:

  = note: /usr/bin/ld: (....o): in function `blas::sgemm':
          .../blas-0.22.0/src/lib.rs:1944: undefined reference to `sgemm_' collect2: error: ld returned 1 exit status

  = note: some `extern` functions couldn't be found; some native libraries may need to be installed or have their path specified
  = note: use the `-l` flag to specify native libraries to link
  = note: use the `cargo:rustc-link-lib` directive to specify the native libraries to link with Cargo

ou para acelerar:

 Undefined symbols for architecture arm64:
            "_dgemm_", referenced from:
                candle_core::accelerate::dgemm::h1b71a038552bcabe in libcandle_core...
            "_sgemm_", referenced from:
                candle_core::accelerate::sgemm::h2cf21c592cba3c47 in libcandle_core...
          ld: symbol(s) not found for architecture arm64

Provavelmente, isso se deve à falta de um sinalizador de vinculador necessário para ativar a biblioteca mkl. Você pode tentar adicionar o seguinte para mkl no topo do seu binário:

 extern crate intel_mkl_src ;

ou para acelerar:

 extern crate accelerate_src ; 

Não é possível executar os exemplos do LLaMA: o acesso à fonte requer credenciais de login

 Error: request error: https://huggingface.co/meta-llama/Llama-2-7b-hf/resolve/main/tokenizer.json: status code 401

Provavelmente, isso ocorre porque você não tem permissão para o modelo LLaMA-v2. Para corrigir isso, você deve se registrar no huggingface-hub, aceitar as condições do modelo LLaMA-v2 e configurar seu token de autenticação. Consulte a edição nº 350 para obter mais detalhes.

Faltando cabeçalhos bonitos/cutlass ao compilar o flash-attn

  In file included from kernels/flash_fwd_launch_template.h:11:0,
                   from kernels/flash_fwd_hdim224_fp16_sm80.cu:5:
  kernels/flash_fwd_kernel.h:8:10: fatal error: cute/algorithm/copy.hpp: No such file or directory
   #include 
            ^~~~~~~~~~~~~~~~~~~~~~~~~
  compilation terminated.
  Error: nvcc error while compiling:

cutlass é fornecido como um submódulo git, então você pode querer executar o seguinte comando para fazer o check-in corretamente.

git submodule update --init

A compilação com atenção flash falha

 /usr/include/c++/11/bits/std_function.h:530:146: error: parameter packs not expanded with ‘...’:

Este é um bug no gcc-11 acionado pelo compilador Cuda. Para corrigir isso, instale uma versão diferente e compatível do gcc - por exemplo, gcc-10, e especifique o caminho para o compilador na variável de ambiente NVCC_CCBIN.

 env NVCC_CCBIN=/usr/lib/gcc/x86_64-linux-gnu/10 cargo ...

Erro de vinculação no Windows ao executar testes de ferrugem ou mdbook

 Couldn't compile the test.
---- .candle-booksrcinferencehub.md - Using_the_hub::Using_in_a_real_model_ (line 50) stdout ----
error: linking with `link.exe` failed: exit code: 1181
//very long chain of linking
 = note: LINK : fatal error LNK1181: cannot open input file 'windows.0.48.5.lib'

Certifique-se de vincular todas as bibliotecas nativas que possam estar localizadas fora do destino do projeto, por exemplo, para executar testes de mdbook, você deve executar:

 mdbook test candle-book -L .targetdebugdeps `
-L native=$env:USERPROFILE.cargoregistrysrcindex.crates.io-6f17d22bba15001fwindows_x86_64_msvc-0.42.2lib `
-L native=$env:USERPROFILE.cargoregistrysrcindex.crates.io-6f17d22bba15001fwindows_x86_64_msvc-0.48.5lib

Tempo de carregamento do modelo extremamente lento com WSL

Isso pode ser causado pelo carregamento dos modelos de /mnt/c , mais detalhes no stackoverflow.

Rastreando erros

Você pode definir RUST_BACKTRACE=1 para receber backtraces quando um erro de vela for gerado.

Erro CudaRC

Se você encontrar um erro como este called Result::unwrap() on an value: LoadLibraryExW { source: Os { code: 126, kind: Uncategorized, message: "The specified module could not be found." } } no Windows. Para corrigir, copie e renomeie esses 3 arquivos (certifique-se de que estejam no caminho). Os caminhos dependem da sua versão cuda. c:WindowsSystem32nvcuda.dll -> cuda.dll c:Program FilesNVIDIA GPU Computing ToolkitCUDAv12.4bincublas64_12.dll -> cublas.dll c:Program FilesNVIDIA GPU Computing ToolkitCUDAv12.4bincurand64_10.dll -> curand.dll