hessboost 0.2.2

Fast, deterministic gradient boosting (GBDT) in Rust: conformal intervals, explainable boosting machines, distributional boosting, tree-based diffusion, and XGBoost model interchange
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

use serde::de::DeserializeOwned;
use serde::{Deserialize, Deserializer};
use std::path::{Path, PathBuf};

/// JSON `null` is the fixture encoding for a missing `f32` value.
pub fn nan_for_null<'de, D>(deserializer: D) -> Result<Vec<f32>, D::Error>
where
    D: Deserializer<'de>,
{
    let values: Vec<Option<f32>> = Vec::deserialize(deserializer)?;
    Ok(values
        .into_iter()
        .map(|value| value.unwrap_or(f32::NAN))
        .collect())
}

/// The fixtures directory under the crate manifest directory.
pub fn fixtures_dir() -> PathBuf {
    PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("fixtures")
}

/// Every `*.json` fixture in `dir`, in path order.
pub fn json_paths(dir: &Path, what: &str, script: &str) -> Vec<PathBuf> {
    let entries = std::fs::read_dir(dir).unwrap_or_else(|error| {
        panic!(
            "{what} fixtures missing at {}: {error}; run {script}",
            dir.display()
        )
    });
    let mut paths: Vec<PathBuf> = entries
        .flatten()
        .map(|entry| entry.path())
        .filter(|path| path.extension().and_then(|extension| extension.to_str()) == Some("json"))
        .collect();
    assert!(!paths.is_empty(), "no {what} fixtures in {}", dir.display());
    paths.sort();
    paths
}

/// Deserialize one JSON fixture at `path` with a path-aware parse error.
pub fn load_json<T: DeserializeOwned>(path: &Path) -> T {
    let text = std::fs::read_to_string(path)
        .unwrap_or_else(|error| panic!("reading {}: {error}", path.display()));
    serde_json::from_str(&text)
        .unwrap_or_else(|error| panic!("parsing {}: {error}", path.display()))
}

/// Every `*.json` fixture in `dir`, deserialized in path order.
pub fn load_all<T: DeserializeOwned>(dir: &Path, what: &str, script: &str) -> Vec<T> {
    json_paths(dir, what, script)
        .iter()
        .map(|path| load_json(path))
        .collect()
}