Struct VarBuilder 

pub struct VarBuilder<'a, R: Runtime> { /* private fields */ }

Scoped access to weights in a VarMap.

VarBuilder holds a reference to a VarMap and a prefix string for navigating hierarchical weight names (e.g., “model.layers.0.self_attn”).

Implementations

impl<'a, R: Runtime> VarBuilder<'a, R>

pub fn new(varmap: &'a mut VarMap<R>, device: &'a R::Device) -> Self

Create a root VarBuilder.

pub fn push_prefix(&mut self, segment: &str) -> VarBuilder<'_, R>

Create a sub-builder with an additional prefix component.

pub fn pp(&mut self, segment: &str) -> VarBuilder<'_, R>

Alias for push_prefix.

pub fn get(&self, name: &str) -> Result<&Weight<R>>

Get a weight by name (relative to prefix).

pub fn get_tensor(&self, name: &str) -> Result<&Tensor<R>>

Get a standard tensor by name (relative to prefix).

pub fn get_quant_tensor(&self, name: &str) -> Result<&QuantTensor<R>>

Get a quantized tensor by name.

pub fn take_tensor(&mut self, name: &str) -> Result<Tensor<R>>

Take a standard tensor by name, removing it from the map (zero-copy).

pub fn take_tensor_optional(&mut self, name: &str) -> Result<Option<Tensor<R>>>

Take a standard tensor by name if it exists, returning None if absent.

Useful for tensors that only exist in some architectures (e.g., attention biases, Q/K layer norms for Command-R).

pub fn take_weight_optional(&mut self, name: &str) -> Result<Option<Weight<R>>>

Take a weight by name if it exists, returning None if absent.

pub fn take_maybe_quant_linear_optional( &mut self, name: &str, bias_name: Option<&str>, ) -> Result<Option<MaybeQuantLinear<R>>>

Take a MaybeQuantLinear if the weight exists, returning None if absent.

pub fn take_quant_tensor(&mut self, name: &str) -> Result<QuantTensor<R>>

Take a quantized tensor by name, removing it from the map (zero-copy).

pub fn take_weight(&mut self, name: &str) -> Result<Weight<R>>

Take a weight (standard or quantized) by name, removing it from the map.

pub fn take_maybe_quant_linear( &mut self, name: &str, bias_name: Option<&str>, ) -> Result<MaybeQuantLinear<R>>

Take a weight and construct a MaybeQuantLinear from it.

If bias_name is provided, attempts to take a standard tensor for bias.

pub fn get_with_shape( &self, name: &str, expected_shape: &[usize], ) -> Result<&Tensor<R>>

Get a standard tensor and validate its shape.

pub fn device(&self) -> &R::Device

Device for this builder.

pub fn contains(&self, name: &str) -> bool

Check if a name exists (relative to prefix).

pub fn prefix(&self) -> &str

Current prefix.

pub fn take_tensor_dequant( &mut self, name: &str, target_dtype: DType, ) -> Result<Tensor<R>>

where R: Runtime<DType = DType>, R::Client: DequantOps<R>,

Take a tensor by name, dequantizing if it’s quantized.

Useful for weights like embeddings that must be standard tensors but may be stored quantized in GGUF files.

pub fn take_tensor_shard( &mut self, name: &str, dim: usize, rank: usize, world_size: usize, ) -> Result<Tensor<R>>

Take a tensor and narrow it along dim for the given TP rank.

Takes the full tensor from the VarMap, narrows to the rank’s shard along dim, returns contiguous shard. The full tensor is removed from the VarMap (zero-copy take, then narrow).

Column-parallel uses dim=0, row-parallel uses dim=1.

impl<R: Runtime> VarBuilder<'static, R>

pub fn from_var_map(varmap: Box<VarMap<R>>, device: &'static R::Device) -> Self

Create a VarBuilder from a boxed VarMap.

Takes ownership of the VarMap by boxing and leaking it to obtain a 'static reference, which is required for VarBuilder<'static, R>. This is appropriate when the VarMap must outlive any particular scope.