Struct CpuBackend 

pub struct CpuBackend<'a> { /* private fields */ }

The reference backend. CpuBackend::borrowing reads the datasets in place; CpuBackend::new copies them on load.

Implementations

impl<'a> CpuBackend<'a>

pub fn new() -> CpuBackend<'a>

A backend that copies the datasets it is loaded with.

pub fn borrowing( train: &'a BinnedDataset, valid: &[&'a BinnedDataset], ) -> CpuBackend<'a>

A backend that reads train and valid in place when load gets these same datasets (by address), so the bins are not copied; other datasets are copied.

Trait Implementations

impl Backend for CpuBackend<'_>

fn name(&self) -> String

Human-readable device name for logs (cpu (14 threads), Apple M4 Pro (metal)).

fn set_thread_pool(&mut self, pool: Arc<ThreadPool>)

The pool host-side parallel work runs on when num_threads is set; backends without host-side parallelism ignore it. Called before load.

fn load( &mut self, train: &BinnedDataset, valid: &[&BinnedDataset], objective: &ObjectiveSetup, ) -> Result<()>

Takes the training set and validation sets; called once, before anything else.

fn init_scores(&mut self, dataset: usize, value: f64) -> Result<()>

Sets every score of dataset to value.

fn compute_gradients(&mut self) -> Result<GradientStats>

Computes f32 gradients and hessians of the training scores; returns their local maxima.

fn quantize(&mut self, spec: &QuantSpec) -> Result<()>

Quantizes the gradients and hessians with spec (quantize::quantize_row, keyed by global row id).

fn reset_partition(&mut self, bag: &BagSpec) -> Result<u32>

Refills the partition with the bagged training rows in ascending order; returns their count.

fn set_histogram_features(&mut self, used: &[bool])

Histograms from now on only need the bins of the features with used[feature] (LightGBM is_feature_used: the tree’s feature mask and the parent’s splittable features); the other bins may hold anything. Every rank passes the same mask. Backends may ignore it.

fn histogram( &mut self, leaf: LeafRange, quantized: bool, out: &mut [f64], ) -> Result<()>

Histogram of the rows of leaf into out (2 * total_bins, overwritten): quantized units when quantized, else float sums of gradients and hessians.

fn partition(&mut self, leaf: LeafRange, split: &BinSplit) -> Result<u32>

Stable in-place partition of leaf’s rows by split; returns the number of rows going left.

fn leaf_sums( &mut self, leaves: &[LeafRange], grad_scale: f32, hess_scale: f32, ) -> Result<Vec<[i64; 2]>>

Exact fixed-point sums [sum rint(g * scale), sum rint(h * scale)] of each leaf’s float gradients (quantize::to_fixed), for leaf renewal.

fn add_tree(&mut self, tree: &DeviceTree) -> Result<()>

Adds tree to the scores of every dataset, traversing binned rows.

fn scores(&mut self, dataset: usize) -> Result<Vec<f32>>

The current scores of dataset.

fn partition_and_histogram( &mut self, leaf: LeafRange, split: &BinSplit, side: Side, quantized: bool, out: &mut [f64], ) -> Result<u32>

partition, then the histogram of the side child into out; returns the left count. A device overrides it to run both without waiting for the count in between: the side is chosen before partitioning (from the split’s estimated counts, the same on every rank), so the histogram’s row range can stay on the device.

impl<'a> Debug for CpuBackend<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Default for CpuBackend<'a>

fn default() -> Self

Returns the “default value” for a type.