Struct WeightsContext 

pub struct WeightsContext { /* private fields */ }

Memory-mapped safetensors files and an index from tensor name to file.

Implementations

impl WeightsContext

pub fn new() -> Self

Creates an empty context with no files loaded.

Examples found in repository

examples/read_tensor.rs (line 4)

fn main() {
    let _ctx = WeightsContext::new();
    // Assuming a file exists or just demonstrating the API
    println!("WeightsContext created.");

    // Note: In a real scenario, we'd call ctx.load_file("path/to/model.safetensors")
    println!("API Usage: ctx.load_file(path), then ctx.read_bytes(name, callback)");
}

examples/load_and_run.rs (line 13)

fn main() {
    env_logger::init();
    pollster::block_on(async {
        // 1. Setup Backend
        let ctx = Arc::new(WgpuContext::new().await);
        let engine = ComputeEngine::new(&ctx);

        // 2. Setup Context (Mocking usage since we don't have a real file in this test)
        let _weights_ctx = WeightsContext::new();

        println!("Demonstrating full pipeline (conceptual)...");

        // 3. Create GPU Tensors
        let shape = vec![4];
        let gpu_int8 = UnifiedTensor::new(&ctx, &[1.0, 2.0, 3.0, 4.0], &shape);
        let gpu_fp32 = UnifiedTensor::empty(&ctx, &shape);

        // 4. Dequantize
        engine.dequantize(&ctx, &gpu_int8, &gpu_fp32);

        // 5. Sequential Ops instead of Fused
        let gpu_c = UnifiedTensor::new(&ctx, &[2.0, 2.0, 2.0, 2.0], &shape);
        let gpu_out = UnifiedTensor::empty(&ctx, &shape);
        let temp = UnifiedTensor::empty(&ctx, &shape);

        engine.add(&ctx, &gpu_fp32, &gpu_c, &temp);
        engine.mul(&ctx, &temp, &gpu_c, &gpu_out);

        let result = gpu_out.to_vec(&ctx).await;
        println!("Result: {:?}", result);
        println!("SUCCESS: Pipeline logic verified!");
    });
}

pub fn load_file<P: AsRef<Path>>(&mut self, path: P) -> Result<(), LoaderError>

Maps one safetensors file and indexes its tensor names.

pub fn load_model_dir<P: AsRef<Path>>( &mut self, model_dir: P, ) -> Result<(), LoaderError>

Loads a model directory: sharded files via the index, else model.safetensors, else consolidated.safetensors.

pub fn get_tensor_info(&self, name: &str) -> Option<(Vec<usize>, String)>

Returns the shape and dtype name of a tensor, or None if it is missing.

pub fn get_tensor_metadata( &self, name: &str, ) -> Result<TensorMetadata, LoaderError>

Returns the shape and dtype of a tensor, or an error if it is missing.

pub fn read_bytes<F>(&self, name: &str, callback: F) -> Result<(), LoaderError>

where F: FnOnce(&[u8], &[usize]),

Calls callback with the raw bytes and shape of a tensor.

pub fn read_f32_tensor( &self, name: &str, ) -> Result<(Vec<f32>, Vec<usize>), LoaderError>

Reads an F32, F16 or BF16 tensor as f32 values plus its shape.

pub fn upload_quantized( &self, name: &str, ctx: &Arc<WgpuContext>, engine: &ComputeEngine, ) -> Result<UnifiedTensor, LoaderError>

Reads <name>.weight, .scales and .biases and uploads them as one quantized GPU tensor.

Trait Implementations

impl Default for WeightsContext

fn default() -> Self

Returns the “default value” for a type.