candle

vela

Candle es un marco de aprendizaje automático minimalista para Rust centrado en el rendimiento (incluida la compatibilidad con GPU) y la facilidad de uso. Pruebe nuestras demostraciones en línea: susurro, LLaMA2, T5, yolo, Segment Anything.

empezar

Asegúrese de tener candle-core instalado correctamente como se describe en Instalación .

Veamos cómo ejecutar una multiplicación de matrices simple. Escriba lo siguiente en su archivo 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 debe mostrar un tensor de forma Tensor[[2, 4], f32] .

Una vez instalada candle con soporte Cuda, simplemente defina que el device esté en GPU:

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

Para ver ejemplos más avanzados, consulte la siguiente sección.

Mira nuestros ejemplos

Estas demostraciones en línea se ejecutan completamente en su navegador:

• yolo: estimación de pose y reconocimiento de objetos.
• susurro: reconocimiento de voz.
• LLaMA2: generación de texto.
• T5: generación de texto.
• Phi-1.5 y Phi-2: generación de texto.
• Modelo Segment Anything: segmentación de imágenes.
• BLIP: subtítulos de imágenes.

También proporcionamos algunos ejemplos basados ​​en la línea de comandos utilizando modelos de última generación:

• LLaMA v1, v2 y v3: LLM general, incluye la variante SOLAR-10.7B.
• Falcón: LLM general.
• Codegeex4: finalización de código, intérprete de código, búsqueda web, llamada a funciones, nivel de repositorio
• GLM4: LM de chat multimodal multilingüe abierto de THUDM
• Gemma v1 y v2: LLM generales 2b y 7b+/9b de Google Deepmind.
• RecurrentGemma: modelos 2b y 7b basados ​​en Griffin de Google que combinan atención con un estado similar a RNN.
• Phi-1, Phi-1.5, Phi-2 y Phi-3: LLM generales 1.3b, 2.7b y 3.8b con rendimiento a la par de los modelos 7b.
• StableLM-3B-4E1T: un LLM general 3b previamente capacitado en tokens 1T de inglés y conjuntos de datos de códigos. También es compatible con StableLM-2, un LLM de 1.6b entrenado en tokens 2T, así como las variantes de código.
• Mamba: una implementación de sólo inferencia del modelo de espacio de estados de Mamba.
• Mistral7b-v0.1: un LLM general 7b con mejor rendimiento que todos los modelos 13b disponibles públicamente a partir del 28 de septiembre de 2023.
• Mixtral8x7b-v0.1: una mezcla escasa de expertos 8x7b LLM general con mejor rendimiento que un modelo Llama 2 70B con una inferencia mucho más rápida.
• StarCoder y StarCoder2: LLM especializado en generación de código.
• Qwen1.5: LLM bilingües (inglés/chino).
• RWKV v5 y v6: un RNN con rendimiento LLM a nivel de transformador.
• Replit-code-v1.5: un LLM 3.3b especializado en completar código.
• Yi-6B / Yi-34B: dos LLM generales bilingües (inglés/chino) con parámetros 6b y 34b.
• LLaMA cuantificado: versión cuantificada del modelo LLaMA que utiliza las mismas técnicas de cuantificación que llama.cpp.

• Difusión estable: modelo generativo de texto a imagen, soporte para las versiones 1.5, 2.1, SDXL 1.0 y Turbo.

• Wuerstchen: otro modelo generativo de texto a imagen.

• yolo-v3 y yolo-v8: modelos de detección de objetos y estimación de pose.

• segment-anything: modelo de segmentación de imágenes con aviso.

• SegFormer: modelo de segmentación semántica basado en transformadores.
• Whisper: modelo de reconocimiento de voz.
• EnCodec: modelo de compresión de audio de alta calidad mediante cuantificación vectorial residual.
• MetaVoice: modelo fundamental para la conversión de texto a voz.
• Parler-TTS: modelo grande de conversión de texto a voz.
• T5, Bert, JinaBert: útil para incrustaciones de oraciones.
• DINOv2: modelo de visión por computadora entrenado mediante autosupervisión (se puede utilizar para clasificación de imágenes, evaluación de profundidad y segmentación).
• VGG, RepVGG: modelos de visión por computadora.
• BLIP: modelo de imagen a texto, se puede utilizar para generar títulos para una imagen.
• CLIP: modelo multimodelo de visión y lenguaje.
• TrOCR: un modelo de OCR transformador, con submodelos dedicados para escritura a mano y reconocimiento impreso.
• Marian-MT: modelo de traducción automática neuronal, genera el texto traducido a partir del texto de entrada.
• Moondream: pequeño modelo de visión por computadora que puede responder preguntas del mundo real sobre imágenes.

Ejecútelos usando comandos como:

 cargo run --example quantized --release

Para utilizar CUDA, agregue --features cuda a la línea de comando de ejemplo. Si tiene cuDNN instalado, use --features cudnn para acelerar aún más.

También hay algunos ejemplos de wasm para susurro y llama2.c. Puedes construirlos con trunk o probarlos en línea: Whisper, Llama2, T5, Phi-1.5 y Phi-2, Segment Anything Model.

Para LLaMA2, ejecute el siguiente comando para recuperar los archivos de peso e iniciar un servidor de prueba:

 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

Y luego dirígete a http://localhost:8081/.

Recursos externos útiles

• candle-tutorial : un tutorial muy detallado que muestra cómo convertir un modelo de PyTorch a Candle.
• candle-lora : Implementación LoRA eficiente y ergonómica para Candle. candle-lora tiene
  Soporte LoRA listo para usar para muchos modelos de Candle, que se puede encontrar aquí.
• optimisers : una colección de optimizadores que incluye SGD con impulso, AdaGrad, AdaDelta, AdaMax, NAdam, RAdam y RMSprop.
• candle-vllm : plataforma eficiente para inferencia y servicio de LLM locales, incluido un servidor API compatible con OpenAI.
• candle-ext : una biblioteca de extensión para Candle que proporciona funciones de PyTorch que no están disponibles actualmente en Candle.
• candle-coursera-ml : Implementación de algoritmos de ML del curso de especialización en aprendizaje automático de Coursera.
• kalosm : un metamarco multimodal en Rust para interactuar con modelos locales previamente entrenados con soporte para generación controlada, samplers personalizados, bases de datos vectoriales en memoria, transcripción de audio y más.
• candle-sampling : Técnicas de muestreo para velas.
• gpt-from-scratch-rs : una adaptación del tutorial Construyamos GPT de Andrej Karpathy en YouTube que muestra la API Candle en un problema de juguete.
• candle-einops : Una implementación puramente oxidada de la biblioteca einops de Python.
• atoma-infer : una biblioteca de Rust para una inferencia rápida a escala, que aprovecha FlashAttention2 para un cálculo de atención eficiente, PagedAttention para una gestión eficiente de la memoria caché KV y compatibilidad con múltiples GPU. Es compatible con la API de OpenAI.

Si tiene una adición a esta lista, envíe una solicitud de extracción.

Características

• Sintaxis simple, se ve y se siente como PyTorch.
  • Entrenamiento modelo.
  • Incorpore operaciones/kernels definidos por el usuario, como flash-attention v2.
• Backends.
  • Backend de CPU optimizado con soporte MKL opcional para x86 y Accelerate para Mac.
  • Backend CUDA para ejecutar eficientemente en GPU, distribución de múltiples GPU a través de NCCL.
  • Soporte WASM, ejecute sus modelos en un navegador.
• Modelos incluidos.
  • Modelos de lenguaje.
    • LLaMA v1, v2 y v3 con variantes como SOLAR-10.7B.
    • Halcón.
    • StarCoder, StarCoder2.
    • Fi 1, 1,5, 2 y 3.
    • Mamba, Mamba mínima
    • Gemma v1 2b y 7b+, v2 2b y 9b.
    • Mistral 7b v0.1.
    • Mixtral 8x7b v0.1.
    • StableLM-3B-4E1T, StableLM-2-1.6B, Stable-Code-3B.
    • Código de repetición v1.5-3B.
    • Berto.
    • Yi-6B y Yi-34B.
    • Qwen1.5, Qwen1.5 MoE.
    • RWKV v5 y v6.
  • LLM cuantificados.
    • Llama 7b, 13b, 70b, así como las variantes de chat y código.
    • Mistral 7b y 7b instruyen.
    • Mixtral 8x7b.
    • Zephyr 7b a y b (basado en Mistral-7b).
    • OpenChat 3.5 (basado en Mistral-7b).
  • Texto a texto.
    • T5 y sus variantes: FlanT5, UL2, MADLAD400 (traducción), CoEdit (Corrección gramatical).
    • Marian MT (Traducción automática).
  • Texto a imagen.
    • Difusión estable v1.5, v2.1, XL v1.0.
    • Wurstchen v2.
  • Imagen a texto.
    • PUNTO LUMINOSO EN UN RADAR.
    • TROCR.
  • Audio.
    • Susurro, voz a texto multilingüe.
    • EnCodec, modelo de compresión de audio.
    • MetaVoice-1B, modelo de conversión de texto a voz.
    • Parler-TTS, modelo de conversión de texto a voz.
  • Modelos de visión por computadora.
    • DINOv2, ConvMixer, EfficientNet, ResNet, ViT, VGG, RepVGG, ConvNeXT, ConvNeXTv2, MobileOne, EfficientVit (MSRA), MobileNetv4, Hiera, FastViT.
    • yolo-v3, yolo-v8.
    • Modelo de segmento cualquier cosa (SAM).
    • SegFormer.
• Formatos de archivo: cargue modelos desde archivos safetensors, npz, ggml o PyTorch.
• Implementaciones pequeñas y rápidas sin servidor (en CPU).
• Soporte de cuantificación utilizando los tipos cuantificados llama.cpp.

como usar

Hoja de referencia:

	Usando PyTorch	Usando vela
Creación	torch.Tensor([[1, 2], [3, 4]])	Tensor::new(&[[1f32, 2.], [3., 4.]], &Device::Cpu)?
Creación	torch.zeros((2, 2))	Tensor::zeros((2, 2), DType::F32, &Device::Cpu)?
Indexación	tensor[:, :4]	tensor.i((.., ..4))?
Operaciones	tensor.view((2, 2))	tensor.reshape((2, 2))?
Operaciones	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)?
Ahorro	torch.save({"A": A}, "model.bin")	candle::safetensors::save(&HashMap::from([("A", A)]), "model.safetensors")?
Cargando	weights = torch.load("model.bin")	candle::safetensors::load("model.safetensors", &device)

Estructura

• Candle-core: operaciones centrales, dispositivos y definición de estructura Tensor
• vela-nn: Herramientas para construir modelos reales
• ejemplos de velas: ejemplos de uso de la biblioteca en entornos realistas
• kernels de velas: kernels personalizados CUDA
• Candle-datasets: conjuntos de datos y cargadores de datos.
• transformadores de velas: servicios públicos relacionados con transformadores.
• vela-flash-attn: Capa de atención flash v2.
• vela-onnx: evaluación del modelo ONNX.

Preguntas frecuentes

¿Por qué debería utilizar Vela?

El objetivo principal de Candle es hacer posible la inferencia sin servidor . Los marcos completos de aprendizaje automático como PyTorch son muy grandes, lo que hace que la creación de instancias en un clúster sea lenta. Candle permite el despliegue de binarios ligeros.

En segundo lugar, Candle te permite eliminar Python de las cargas de trabajo de producción. La sobrecarga de Python puede perjudicar gravemente el rendimiento y GIL es una fuente notoria de dolores de cabeza.

¡Finalmente, Rust es genial! Gran parte del ecosistema HF ya tiene cajas Rust, como tensores de seguridad y tokenizadores.

Otros marcos de aprendizaje automático

• dfdx es una caja formidable, con formas incluidas en tipos. Esto evita muchos dolores de cabeza al hacer que el compilador se queje de las discrepancias de forma desde el principio. Sin embargo, descubrimos que algunas funciones aún requieren trabajo nocturno y escribir código puede resultar un poco desalentador para los expertos en no oxidación.

  Estamos aprovechando y contribuyendo con otras cajas principales durante el tiempo de ejecución, por lo que esperamos que ambas cajas puedan beneficiarse entre sí.

• burn es una caja general que puede aprovechar múltiples backends para que puedas elegir el mejor motor para tu carga de trabajo.

• tch-rs Enlaces a la biblioteca torch en Rust. Extremadamente versátiles, pero incorporan toda la biblioteca de antorchas al tiempo de ejecución. El principal contribuyente de tch-rs también participa en el desarrollo de candle .

Errores comunes

Faltan símbolos al compilar con la función mkl.

Si le faltan algunos símbolos al compilar binarios/pruebas usando mkl o funciones de aceleración, por ejemplo, para mkl obtendrá:

  = 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

o 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

Es probable que esto se deba a que falta un indicador del vinculador que era necesario para habilitar la biblioteca mkl. Puedes intentar agregar lo siguiente para mkl en la parte superior de tu binario:

 extern crate intel_mkl_src ;

o para acelerar:

 extern crate accelerate_src ; 

No se pueden ejecutar los ejemplos de LLaMA: el acceso a la fuente requiere credenciales de inicio de sesión

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

Es probable que esto se deba a que no tienes permiso para el modelo LLaMA-v2. Para solucionar este problema, debe registrarse en huggingface-hub, aceptar las condiciones del modelo LLaMA-v2 y configurar su token de autenticación. Consulte el número 350 para obtener más detalles.

Faltan encabezados lindos/cutlass al compilar 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 se proporciona como un submódulo de git, por lo que es posible que desees ejecutar el siguiente comando para registrarlo correctamente.

git submodule update --init

La compilación con atención flash falla

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

Este es un error en gcc-11 provocado por el compilador Cuda. Para solucionar este problema, instale una versión diferente de gcc compatible, por ejemplo gcc-10, y especifique la ruta al compilador en la variable de entorno NVCC_CCBIN.

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

Error de vinculación en Windows al ejecutar pruebas de Rustdoc o 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'

Asegúrese de vincular todas las bibliotecas nativas que puedan estar ubicadas fuera del objetivo del proyecto; por ejemplo, para ejecutar pruebas de mdbook, debe ejecutar:

 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

Tiempo de carga de modelo extremadamente lento con WSL

Esto puede deberse a que los modelos se cargan desde /mnt/c , más detalles en stackoverflow.

Seguimiento de errores

Puede configurar RUST_BACKTRACE=1 para que se le proporcionen rastreos cuando se genere un error de vela.

Error de Cuda RC

Si encuentra un error como este called Result::unwrap() on an value: LoadLibraryExW { source: Os { code: 126, kind: Uncategorized, message: "The specified module could not be found." } } en ventanas. Para arreglarlo, copie y cambie el nombre de estos 3 archivos (asegúrese de que estén en la ruta). Las rutas dependen de su versión de 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