qlora-rs 1.0.5

4-bit quantized LoRA (QLoRA) implementation with dual GGUF and Candle native export for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

//! # qlora-rs
//!
//! 4-bit quantized `LoRA` (`QLoRA`) implementation for Rust.
//!
//! This crate provides:
//! - NF4 (4-bit `NormalFloat`) quantization
//! - Double quantization for memory efficiency
//! - `QLoRA` training with frozen quantized base weights
//! - GGUF model export for inference deployment
//!
//! ## Quick Start
//!
//! ```rust,ignore
//! use qlora_rs::{QLoraConfig, QuantizedLinear, quantize_nf4};
//! use candle_core::Device;
//!
//! // Quantize a weight tensor to 4-bit
//! let quantized = quantize_nf4(&weights, 64)?;
//!
//! // Create QLoRA layer
//! let config = QLoraConfig::default();
//! let layer = QuantizedLinear::new(768, 768, config, &Device::Cpu)?;
//! ```
//!
//! ## Architecture
//!
//! `QLoRA` keeps base model weights frozen in 4-bit precision while training
//! `LoRA` adapters in full precision. This enables fine-tuning large models
//! on consumer hardware.

#![warn(missing_docs)]
#![warn(clippy::pedantic)]

pub mod error;
pub mod export;
pub mod formats;
#[cfg(feature = "cuda")]
pub mod kernels;
pub mod native;
pub mod qlora;
pub mod quantization;
pub mod training;

pub use error::{QLoraError, Result};
pub use formats::{export_model, export_native_format, ExportConfig, ExportFormat};
pub use qlora::{QLoraConfig, QLoraLayer, QuantizedLinear};
pub use quantization::{
    dequantize_nf4, dequantize_nf4_with_dtype, pad_for_quantization,
    pad_for_quantization_with_info, quantize_nf4, unpad_tensor, ComputeDType, PaddingInfo,
    QuantizationConfig, QuantizationStrategy, QuantizedTensor,
};
pub use training::{
    cross_entropy_loss, PagedAdamW, PagedAdamWState, QLoraTrainer, QLoraTrainingConfig,
    TrainingMetrics,
};