1 unstable release

0.0.1 Jun 16, 2023

#7 in #light-gbm

Download history 19/week @ 2024-02-26 2/week @ 2024-03-04 7/week @ 2024-03-11 1/week @ 2024-03-25 24/week @ 2024-04-01 22/week @ 2024-04-29 21/week @ 2024-05-13 63/week @ 2024-05-20 75/week @ 2024-05-27 150/week @ 2024-06-03 116/week @ 2024-06-10

414 downloads per month
Used in 5 crates (via lgbm)

MIT license

80KB
955 lines

LGBM-rs

Crates.io Docs.rs Actions Status

Unofficial Rust bindings for LightGBM

Requirement

Windows or Linux

  1. Install LightGBM and build according to LightGBM Documentation.
  2. Set the environment variable LIGHTGBM_LIB_PATH to the directory containing the build output (.dll and .lib on Windows, .so on Linux).

MacOS

Run the following command to install LightGBM on your system.

brew install lightgbm

Example

Cargo.toml

[dependencies]
lgbm = "0.0.1"

main.rs

use lgbm::{
    parameters::{Objective, Verbosity},
    Booster, Dataset, Field, Mat, Parameters, PredictType,
};
use std::sync::Arc;

fn main() -> anyhow::Result<()> {
    let mut p = Parameters::new();
    p.push("num_class", 3);
    p.push("objective", Objective::Multiclass);
    p.push("verbosity", Verbosity::Fatal);

    let mut train = Dataset::from_mat(&Mat::from_rows(train_features()), None, &p)?;
    train.set_field(Field::LABEL, &train_labels())?;

    let mut valid = Dataset::from_mat(&Mat::from_rows(valid_features()), Some(&train), &p)?;
    valid.set_field(Field::LABEL, &valid_labels())?;

    let mut b = Booster::new(Arc::new(train), &p)?;
    b.add_valid_data(Arc::new(valid))?;
    for _ in 0..100 {
        if b.update_one_iter()? {
            break;
        }
    }
    let p = Parameters::new();
    let rs = b.predict_for_mat(
        &Mat::from_rows(test_features()),
        PredictType::Normal,
        0,
        None,
        &p,
    )?;
    println!("\n{rs:.5}");
    Ok(())
}
fn train_features() -> Vec<[f64; 1]> {
    (0..128).map(|x| [(x % 3) as f64]).collect()
}
fn train_labels() -> Vec<f32> {
    (0..128).map(|x| (x % 3) as f32).collect()
}
fn valid_features() -> Vec<[f64; 1]> {
    (0..64).map(|x| [(x % 3) as f64]).collect()
}
fn valid_labels() -> Vec<f32> {
    (0..64).map(|x| (x % 3) as f32).collect()
}
fn test_features() -> Vec<[f64; 1]> {
    (0..4).map(|x| [(x % 3) as f64]).collect()
}

output

num_data  : 4
num_class : 3
num_2     : 1

   |    0    |    1    |    2    |
---|---------|---------|---------|
 0 | 0.99998 | 0.00001 | 0.00001 |
 1 | 0.00001 | 0.99998 | 0.00001 |
 2 | 0.00001 | 0.00001 | 0.99998 |
 3 | 0.99998 | 0.00001 | 0.00001 |

Static linking or dynamic linking

The following types of linking are supported.

os static dynamic
Windows
Linux
MacOS

On Windows, if lib_lightgbm.dll exists in the directory specified by LIGHTGBM_LIB_PATH, it will be dynamically linked. Otherwise, it will be statically linked.

On Linux, if lib_lightgbm.a exists in the directory specified by LIGHTGBM_LIB_PATH, it is statically linked. Otherwise, it is dynamically linked.

License

This project is licensed under MIT. See the LICENSE files for details.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you will be under the MIT license, without any additional terms or conditions.

No runtime deps