From e677b5cd6963ceed96040fe4c2e3b4057a1e0187 Mon Sep 17 00:00:00 2001
From: vaaaaanquish <6syun9@gmail.com>
Date: Sat, 16 Jan 2021 02:26:39 +0900
Subject: [PATCH 1/6] add comment

---
 Cargo.toml                                    |   1 +
 .../{ => binary_classification}/Cargo.toml    |   4 +-
 .../{ => binary_classification}/src/main.rs   |  16 +--
 src/booster.rs                                |  68 +++++++---
 src/dataset.rs                                | 118 ++++++++++++++++--
 src/error.rs                                  |  58 +++++++++
 src/lib.rs                                    |   8 ++
 7 files changed, 232 insertions(+), 41 deletions(-)
 rename examples/{ => binary_classification}/Cargo.toml (63%)
 rename examples/{ => binary_classification}/src/main.rs (67%)

diff --git a/Cargo.toml b/Cargo.toml
index 39223c0..7256741 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -11,3 +11,4 @@ exclude = [".gitignore", ".gitmodules", "examples", "lightgbm-sys"]
 [dependencies]
 lightgbm-sys = "0.1.0"
 libc = "0.2.81"
+derive_builder = "0.5.1"
diff --git a/examples/Cargo.toml b/examples/binary_classification/Cargo.toml
similarity index 63%
rename from examples/Cargo.toml
rename to examples/binary_classification/Cargo.toml
index b303bc3..8b9b8e2 100644
--- a/examples/Cargo.toml
+++ b/examples/binary_classification/Cargo.toml
@@ -1,10 +1,10 @@
 [package]
-name = "lightgbm-example"
+name = "lightgbm-example-binary-classification"
 version = "0.1.0"
 authors = ["vaaaaanquish <6syun9@gmail.com>"]
 publish = false
 
 [dependencies]
-lightgbm = "0.1.1"
+lightgbm = { path = "../../" }
 csv = "1.1.5"
 itertools = "0.9.0"
diff --git a/examples/src/main.rs b/examples/binary_classification/src/main.rs
similarity index 67%
rename from examples/src/main.rs
rename to examples/binary_classification/src/main.rs
index fed42c3..9463749 100644
--- a/examples/src/main.rs
+++ b/examples/binary_classification/src/main.rs
@@ -6,17 +6,7 @@ use itertools::zip;
 use lightgbm::{Dataset, Booster};
 
 fn main() -> std::io::Result<()> {
-    // let feature = vec![vec![1.0, 0.1, 0.2, 0.1],
-    //                vec![0.7, 0.4, 0.5, 0.1],
-    //                vec![0.9, 0.8, 0.5, 0.1],
-    //                vec![0.2, 0.2, 0.8, 0.7],
-    //                vec![0.1, 0.7, 1.0, 0.9]];
-    // let label = vec![0.0, 0.0, 0.0, 1.0, 1.0];
-    // let train_dataset = Dataset::from_mat(feature, label).unwrap();
-
-    // let train_dataset = Dataset::from_file("../lightgbm-sys/lightgbm/examples/binary_classification/binary.train".to_string()).unwrap();
-
-    let mut train_rdr = csv::ReaderBuilder::new().has_headers(false).delimiter(b'\t').from_path("../lightgbm-sys/lightgbm/examples/binary_classification/binary.train")?;
+    let mut train_rdr = csv::ReaderBuilder::new().has_headers(false).delimiter(b'\t').from_path("../../lightgbm-sys/lightgbm/examples/binary_classification/binary.train")?;
     let mut train_labels: Vec<f32> = Vec::new();
     let mut train_feature: Vec<Vec<f64>> = Vec::new();
     for result in train_rdr.records() {
@@ -28,7 +18,7 @@ fn main() -> std::io::Result<()> {
     }
     let train_dataset = Dataset::from_mat(train_feature, train_labels).unwrap();
 
-    let mut rdr = csv::ReaderBuilder::new().has_headers(false).delimiter(b'\t').from_path("../lightgbm-sys/lightgbm/examples/binary_classification/binary.test")?;
+    let mut rdr = csv::ReaderBuilder::new().has_headers(false).delimiter(b'\t').from_path("../../lightgbm-sys/lightgbm/examples/binary_classification/binary.test")?;
     let mut test_labels: Vec<f32> = Vec::new();
     let mut test_feature: Vec<Vec<f64>> = Vec::new();
     for result in rdr.records() {
@@ -39,7 +29,7 @@ fn main() -> std::io::Result<()> {
         test_feature.push(feature);
     }
 
-    let booster = Booster::train(train_dataset).unwrap();
+    let booster = Booster::train(train_dataset, "objective=binary metric=auc".to_string()).unwrap();
     let result = booster.predict(test_feature).unwrap();
 
     let mut tp = 0;
diff --git a/src/booster.rs b/src/booster.rs
index b8994c7..1dbc4c1 100644
--- a/src/booster.rs
+++ b/src/booster.rs
@@ -1,42 +1,45 @@
-use lightgbm_sys;
-
 use libc::{c_char, c_double, c_void, c_long};
 use std::ffi::CString;
 use std;
 
-use super::{LGBMResult, Dataset};
+
+use lightgbm_sys;
+
+
+use super::{LGBMResult, Dataset, LGBMError};
 
 
+/// Core model in LightGBM, containing functions for training, evaluating and predicting.
 pub struct Booster {
     pub(super) handle: lightgbm_sys::BoosterHandle
 }
 
+
 impl Booster {
     fn new(handle: lightgbm_sys::BoosterHandle) -> LGBMResult<Self> {
         Ok(Booster{handle})
     }
 
-    pub fn train(dataset: Dataset) -> LGBMResult<Self> {
-        let params = CString::new("objective=binary metric=auc").unwrap();
+    /// Create a new Booster model with given Dataset and parameters.
+    pub fn train(dataset: Dataset, params: String) -> LGBMResult<Self> {
+        let params = CString::new(params).unwrap();
         let mut handle = std::ptr::null_mut();
-        unsafe {
+        lgbm_call!(
             lightgbm_sys::LGBM_BoosterCreate(
                 dataset.handle,
                 params.as_ptr() as *const c_char,
                 &mut handle
-            );
-        }
+            )
+        )?;
 
-        // train
         let mut is_finished: i32 = 0;
-        unsafe{
-            for _ in 1..100 {
-                lightgbm_sys::LGBM_BoosterUpdateOneIter(handle, &mut is_finished);
-            }
+        for _ in 1..100 {
+            lgbm_call!(lightgbm_sys::LGBM_BoosterUpdateOneIter(handle, &mut is_finished))?;
         }
         Ok(Booster::new(handle)?)
     }
 
+    /// Predict results for given data.
     pub fn predict(&self, data: Vec<Vec<f64>>) -> LGBMResult<Vec<f64>> {
         let data_length = data.len();
         let feature_length = data[0].len();
@@ -45,7 +48,7 @@ impl Booster {
         let out_result: Vec<f64> = vec![Default::default(); data.len()];
         let flat_data = data.into_iter().flatten().collect::<Vec<_>>();
 
-        unsafe {
+        lgbm_call!(
             lightgbm_sys::LGBM_BoosterPredictForMat(
                 self.handle,
                 flat_data.as_ptr() as *const c_void,
@@ -59,8 +62,41 @@ impl Booster {
                 params.as_ptr() as *const c_char,
                 &mut out_length,
                 out_result.as_ptr() as *mut c_double
-            );
-        }
+            )
+        )?;
         Ok(out_result)
     }
 }
+
+
+impl Drop for Booster {
+    fn drop(&mut self) {
+        lgbm_call!(lightgbm_sys::LGBM_BoosterFree(self.handle)).unwrap();
+    }
+}
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn read_train_file() -> LGBMResult<Dataset> {
+        Dataset::from_file("lightgbm-sys/lightgbm/examples/binary_classification/binary.train".to_string())
+    }
+
+    #[test]
+    fn predict() {
+        let dataset = read_train_file().unwrap();
+        let bst = Booster::train(dataset, "objective=binary metric=auc".to_string()).unwrap();
+        let feature = vec![vec![0.5; 28], vec![0.0; 28], vec![0.9; 28]];
+        let result = bst.predict(feature).unwrap();
+        let mut normalized_result = Vec::new();
+        for r in result{
+            if r > 0.5{
+                normalized_result.push(1);
+            } else {
+                normalized_result.push(0);
+            }
+        }
+        assert_eq!(normalized_result, vec![0, 0, 1]);
+    }
+}
diff --git a/src/dataset.rs b/src/dataset.rs
index 59449a5..63a4ddc 100644
--- a/src/dataset.rs
+++ b/src/dataset.rs
@@ -1,21 +1,64 @@
-use libc::{c_void,c_char};
-
 use std;
 use std::ffi::CString;
+use libc::{c_void,c_char};
 use lightgbm_sys;
 
-use super::LGBMResult;
 
+use super::{LGBMResult, LGBMError};
+
+
+/// Dataset used throughout LightGBM for training.
+///
+/// # Examples
+///
+/// ## from mat
+///
+/// ```
+/// use lightgbm::Dataset;
+///
+/// let data = vec![vec![1.0, 0.1, 0.2, 0.1],
+///                vec![0.7, 0.4, 0.5, 0.1],
+///                vec![0.9, 0.8, 0.5, 0.1],
+///                vec![0.2, 0.2, 0.8, 0.7],
+///                vec![0.1, 0.7, 1.0, 0.9]];
+/// let label = vec![0.0, 0.0, 0.0, 1.0, 1.0];
+/// let dataset = Dataset::from_mat(data, label).unwrap();
+/// ```
+///
+/// ## from file
+///
+/// ```
+/// use lightgbm::Dataset;
+///
+/// let dataset = Dataset::from_file(
+///     "lightgbm-sys/lightgbm/examples/binary_classification/binary.train"
+///     .to_string()).unwrap();
+/// ```
 pub struct Dataset {
     pub(super) handle: lightgbm_sys::DatasetHandle
 }
 
+
 #[link(name = "c")]
 impl Dataset {
     fn new(handle: lightgbm_sys::DatasetHandle) -> LGBMResult<Self> {
         Ok(Dataset{handle})
     }
 
+    /// Create a new `Dataset` from dense array in row-major order.
+    ///
+    /// Example
+    /// ```
+    /// use lightgbm::Dataset;
+    ///
+    /// let data = vec![vec![1.0, 0.1, 0.2, 0.1],
+    ///                vec![0.7, 0.4, 0.5, 0.1],
+    ///                vec![0.9, 0.8, 0.5, 0.1],
+    ///                vec![0.2, 0.2, 0.8, 0.7],
+    ///                vec![0.1, 0.7, 1.0, 0.9]];
+    /// let label = vec![0.0, 0.0, 0.0, 1.0, 1.0];
+    /// let dataset = Dataset::from_mat(data, label).unwrap();
+    /// ```
     pub fn from_mat(data: Vec<Vec<f64>>, label: Vec<f32>) -> LGBMResult<Self> {
         let data_length = data.len();
         let feature_length = data[0].len();
@@ -25,7 +68,7 @@ impl Dataset {
         let mut handle = std::ptr::null_mut();
         let flat_data = data.into_iter().flatten().collect::<Vec<_>>();
 
-        unsafe{
+        lgbm_call!(
             lightgbm_sys::LGBM_DatasetCreateFromMat(
                 flat_data.as_ptr() as *const c_void,
                 lightgbm_sys::C_API_DTYPE_FLOAT64 as i32,
@@ -35,33 +78,88 @@ impl Dataset {
                 params.as_ptr() as *const c_char,
                 reference,
                 &mut handle
-            );
+            )
+        )?;
 
+        lgbm_call!(
             lightgbm_sys::LGBM_DatasetSetField(
                 handle,
                 label_str.as_ptr() as *const c_char,
                 label.as_ptr() as *const c_void,
                 data_length as i32,
                 lightgbm_sys::C_API_DTYPE_FLOAT32 as i32
-            );
-        }
+            )
+        )?;
+
         Ok(Dataset::new(handle)?)
     }
 
+    /// Create a new `Dataset` from file.
+    ///
+    /// file is `tsv`.
+    /// ```text
+    /// <label>\t<value>\t<value>\t...
+    /// ```
+    ///
+    /// ```text
+    /// 2 0.11 0.89 0.2
+    /// 3 0.39 0.1 0.4
+    /// 0 0.1 0.9 1.0
+    /// ```
+    ///
+    /// Example
+    /// ```
+    /// use lightgbm::Dataset;
+    ///
+    /// let dataset = Dataset::from_file("lightgbm-sys/lightgbm/examples/binary_classification/binary.train".to_string());
+    /// ```
     pub fn from_file(file_path: String) -> LGBMResult<Self> {
         let file_path_str = CString::new(file_path).unwrap();
         let params = CString::new("").unwrap();
         let mut handle = std::ptr::null_mut();
 
-        unsafe {
+        lgbm_call!(
             lightgbm_sys::LGBM_DatasetCreateFromFile(
                 file_path_str.as_ptr() as *const c_char,
                 params.as_ptr() as *const c_char,
                 std::ptr::null_mut(),
                 &mut handle
-            );
-        }
+            )
+        )?;
+
         Ok(Dataset::new(handle)?)
     }
 }
 
+
+impl Drop for Dataset {
+    fn drop(&mut self) {
+        lgbm_call!(lightgbm_sys::LGBM_DatasetFree(self.handle)).unwrap();
+    }
+}
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn read_train_file() -> LGBMResult<Dataset> {
+        Dataset::from_file("lightgbm-sys/lightgbm/examples/binary_classification/binary.train".to_string())
+    }
+
+    #[test]
+    fn read_file() {
+        assert!(read_train_file().is_ok());
+    }
+
+    #[test]
+    fn from_mat(){
+        let data = vec![vec![1.0, 0.1, 0.2, 0.1],
+                        vec![0.7, 0.4, 0.5, 0.1],
+                        vec![0.9, 0.8, 0.5, 0.1],
+                        vec![0.2, 0.2, 0.8, 0.7],
+                        vec![0.1, 0.7, 1.0, 0.9]];
+        let label = vec![0.0, 0.0, 0.0, 1.0, 1.0];
+        let dataset = Dataset::from_mat(data, label);
+        assert!(dataset.is_ok());
+    }
+}
diff --git a/src/error.rs b/src/error.rs
index df93901..f596040 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,15 +1,73 @@
+//! Functionality related to errors and error handling.
+
+
 use std;
+use std::ffi::CStr;
+use std::fmt::{self, Display};
+use std::error::Error;
+
+use lightgbm_sys;
 
+
+/// Convenience return type for most operations which can return an `LightGBM`.
 pub type LGBMResult<T> = std::result::Result<T, LGBMError>;
 
 
+/// Wrap errors returned by the LightGBM library.
 #[derive(Debug, Eq, PartialEq)]
 pub struct LGBMError {
     desc: String,
 }
 
+
 impl LGBMError {
     pub(crate) fn new<S: Into<String>>(desc: S) -> Self {
         LGBMError { desc: desc.into() }
     }
+
+
+    /// Check the return value from an LightGBM FFI call, and return the last error message on error.
+    ///
+    /// Return values of 0 are treated as success, returns values of -1 are treated as errors.
+    ///
+    /// Meaning of any other return values are undefined, and will cause a panic.
+    pub(crate) fn check_return_value(ret_val: i32) -> LGBMResult<()> {
+        match ret_val {
+            0  => Ok(()),
+            -1 => Err(LGBMError::from_lightgbm()),
+            _  => panic!(format!("unexpected return value '{}', expected 0 or -1", ret_val)),
+        }
+    }
+
+    /// Get the last error message from LightGBM.
+    fn from_lightgbm() -> Self {
+        let c_str = unsafe { CStr::from_ptr(lightgbm_sys::LGBM_GetLastError()) };
+        let str_slice = c_str.to_str().unwrap();
+        LGBMError { desc: str_slice.to_owned() }
+    }
+}
+
+
+impl Error for LGBMError {}
+
+
+impl Display for LGBMError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "LightGBM error: {}", &self.desc)
+    }
+}
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn return_value_handling() {
+        let result = LGBMError::check_return_value(0);
+        assert_eq!(result, Ok(()));
+
+        let result = LGBMError::check_return_value(-1);
+        assert_eq!(result, Err(LGBMError { desc: "Everything is fine".to_owned() }));
+    }
 }
diff --git a/src/lib.rs b/src/lib.rs
index adfe90d..3fcc966 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,6 +1,14 @@
 extern crate lightgbm_sys;
 extern crate libc;
 
+#[macro_use]
+macro_rules! lgbm_call {
+    ($x:expr) => {
+        LGBMError::check_return_value(unsafe { $x })
+    };
+}
+
+
 mod error;
 pub use error::{LGBMError,LGBMResult};
 

From e86ef7233b8c76e0074adac31549c35508480516 Mon Sep 17 00:00:00 2001
From: vaaaaanquish <6syun9@gmail.com>
Date: Sat, 16 Jan 2021 02:27:31 +0900
Subject: [PATCH 2/6] update gitignore

---
 .gitignore | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index f0404a7..fecf55b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,4 +13,5 @@ Cargo.lock
 lightgbm-sys/target
 
 # example
-examples/target
+examples/binary_classification/target/
+examples/multiclass_classification/target/

From 874c9b0420ecd9681ea9fbb5e54e91c538fd8806 Mon Sep 17 00:00:00 2001
From: vaaaaanquish <6syun9@gmail.com>
Date: Sat, 16 Jan 2021 23:54:43 +0900
Subject: [PATCH 3/6] add parameter by serde_json

---
 Cargo.toml                                 |  1 +
 examples/binary_classification/Cargo.toml  |  1 +
 examples/binary_classification/src/main.rs | 50 +++++++------
 src/booster.rs                             | 81 +++++++++++++++++++---
 src/lib.rs                                 |  1 +
 5 files changed, 103 insertions(+), 31 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 7256741..ae1ce79 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,3 +12,4 @@ exclude = [".gitignore", ".gitmodules", "examples", "lightgbm-sys"]
 lightgbm-sys = "0.1.0"
 libc = "0.2.81"
 derive_builder = "0.5.1"
+serde_json = "1.0.59"
diff --git a/examples/binary_classification/Cargo.toml b/examples/binary_classification/Cargo.toml
index 8b9b8e2..72ee4fc 100644
--- a/examples/binary_classification/Cargo.toml
+++ b/examples/binary_classification/Cargo.toml
@@ -8,3 +8,4 @@ publish = false
 lightgbm = { path = "../../" }
 csv = "1.1.5"
 itertools = "0.9.0"
+serde_json = "1.0.59"
diff --git a/examples/binary_classification/src/main.rs b/examples/binary_classification/src/main.rs
index 9463749..b52c996 100644
--- a/examples/binary_classification/src/main.rs
+++ b/examples/binary_classification/src/main.rs
@@ -1,36 +1,44 @@
 extern crate lightgbm;
 extern crate csv;
+extern crate serde_json;
 extern crate itertools;
 
 use itertools::zip;
 use lightgbm::{Dataset, Booster};
+use serde_json::json;
 
-fn main() -> std::io::Result<()> {
-    let mut train_rdr = csv::ReaderBuilder::new().has_headers(false).delimiter(b'\t').from_path("../../lightgbm-sys/lightgbm/examples/binary_classification/binary.train")?;
-    let mut train_labels: Vec<f32> = Vec::new();
-    let mut train_feature: Vec<Vec<f64>> = Vec::new();
-    for result in train_rdr.records() {
-        let record = result?;
-        let label = record[0].parse::<f32>().unwrap();
-        let feature: Vec<f64> = record.iter().map(|x| x.parse::<f64>().unwrap()).collect::<Vec<f64>>()[1..].to_vec();
-        train_labels.push(label);
-        train_feature.push(feature);
-    }
-    let train_dataset = Dataset::from_mat(train_feature, train_labels).unwrap();
 
-    let mut rdr = csv::ReaderBuilder::new().has_headers(false).delimiter(b'\t').from_path("../../lightgbm-sys/lightgbm/examples/binary_classification/binary.test")?;
-    let mut test_labels: Vec<f32> = Vec::new();
-    let mut test_feature: Vec<Vec<f64>> = Vec::new();
-    for result in rdr.records() {
-        let record = result?;
+fn load_file(file_path: &str) -> (Vec<Vec<f64>>, Vec<f32>) {
+    let rdr = csv::ReaderBuilder::new().has_headers(false).delimiter(b'\t').from_path(file_path);
+    let mut labels: Vec<f32> = Vec::new();
+    let mut features: Vec<Vec<f64>> = Vec::new();
+    for result in rdr.unwrap().records() {
+        let record = result.unwrap();
         let label = record[0].parse::<f32>().unwrap();
         let feature: Vec<f64> = record.iter().map(|x| x.parse::<f64>().unwrap()).collect::<Vec<f64>>()[1..].to_vec();
-        test_labels.push(label);
-        test_feature.push(feature);
+        labels.push(label);
+        features.push(feature);
     }
+    (features, labels)
+}
+
+
+fn main() -> std::io::Result<()> {
+    let (train_features, train_labels) = load_file("../../lightgbm-sys/lightgbm/examples/binary_classification/binary.train");
+    let (test_features, test_labels) = load_file("../../lightgbm-sys/lightgbm/examples/binary_classification/binary.test");
+    let train_dataset = Dataset::from_mat(train_features, train_labels).unwrap();
+
+    let params = json!{
+        {
+            "num_iterations": 100,
+            "objective": "binary",
+            "metric": "auc"
+        }
+    };
+
+    let booster = Booster::train(train_dataset, &params).unwrap();
+    let result = booster.predict(test_features).unwrap();
 
-    let booster = Booster::train(train_dataset, "objective=binary metric=auc".to_string()).unwrap();
-    let result = booster.predict(test_feature).unwrap();
 
     let mut tp = 0;
     for (label, pred) in zip(&test_labels, &result){
diff --git a/src/booster.rs b/src/booster.rs
index 1dbc4c1..3c39909 100644
--- a/src/booster.rs
+++ b/src/booster.rs
@@ -2,6 +2,7 @@ use libc::{c_char, c_double, c_void, c_long};
 use std::ffi::CString;
 use std;
 
+use serde_json::Value;
 
 use lightgbm_sys;
 
@@ -11,41 +12,92 @@ use super::{LGBMResult, Dataset, LGBMError};
 
 /// Core model in LightGBM, containing functions for training, evaluating and predicting.
 pub struct Booster {
-    pub(super) handle: lightgbm_sys::BoosterHandle
+    pub(super) handle: lightgbm_sys::BoosterHandle,
+    num_classes: i64
 }
 
 
 impl Booster {
-    fn new(handle: lightgbm_sys::BoosterHandle) -> LGBMResult<Self> {
-        Ok(Booster{handle})
+    fn new(handle: lightgbm_sys::BoosterHandle, num_classes: i64) -> LGBMResult<Self> {
+        Ok(Booster{handle, num_classes})
     }
 
     /// Create a new Booster model with given Dataset and parameters.
-    pub fn train(dataset: Dataset, params: String) -> LGBMResult<Self> {
-        let params = CString::new(params).unwrap();
+    ///
+    /// Example
+    /// ```
+    /// extern crate serde_json;
+    /// use lightgbm::{Dataset, Booster};
+    /// use serde_json::json;
+    ///
+    /// let data = vec![vec![1.0, 0.1, 0.2, 0.1],
+    ///                vec![0.7, 0.4, 0.5, 0.1],
+    ///                vec![0.9, 0.8, 0.5, 0.1],
+    ///                vec![0.2, 0.2, 0.8, 0.7],
+    ///                vec![0.1, 0.7, 1.0, 0.9]];
+    /// let label = vec![0.0, 0.0, 0.0, 1.0, 1.0];
+    /// let dataset = Dataset::from_mat(data, label).unwrap();
+    /// let params = json!{
+    ///    {
+    ///         "num_iterations": 3,
+    ///         "objective": "binary",
+    ///         "metric": "auc"
+    ///     }
+    /// };
+    /// let bst = Booster::train(dataset, &params).unwrap();
+    /// ```
+    pub fn train(dataset: Dataset, parameter: &Value) -> LGBMResult<Self> {
+
+        // get num_iterations
+        let num_iterations: i64;
+        if parameter["num_iterations"].is_null(){
+            num_iterations = 100;
+        } else {
+            num_iterations = parameter["num_iterations"].as_i64().unwrap();
+        }
+
+        // get num_classes
+        let num_classes: i64;
+        if parameter["num_classes"].is_null(){
+            num_classes = 1;
+        } else {
+            num_classes = parameter["num_classes"].as_i64().unwrap();
+        }
+
+        // exchange params {"x": "y", "z": 1} => "x=y z=1"
+        let params_string = parameter.as_object().unwrap().iter().map(|(k, v)| format!("{}={}", k, v)).collect::<Vec<_>>().join(" ");
+        let params_cstring = CString::new(params_string).unwrap();
+
         let mut handle = std::ptr::null_mut();
         lgbm_call!(
             lightgbm_sys::LGBM_BoosterCreate(
                 dataset.handle,
-                params.as_ptr() as *const c_char,
+                params_cstring.as_ptr() as *const c_char,
                 &mut handle
             )
         )?;
 
         let mut is_finished: i32 = 0;
-        for _ in 1..100 {
+        for _ in 1..num_iterations {
             lgbm_call!(lightgbm_sys::LGBM_BoosterUpdateOneIter(handle, &mut is_finished))?;
         }
-        Ok(Booster::new(handle)?)
+        Ok(Booster::new(handle, num_classes)?)
     }
 
     /// Predict results for given data.
+    ///
+    /// Input data example
+    /// ```
+    /// let data = vec![vec![1.0, 0.1, 0.2],
+    ///                vec![0.7, 0.4, 0.5],
+    ///                vec![0.1, 0.7, 1.0]];
+    /// ```
     pub fn predict(&self, data: Vec<Vec<f64>>) -> LGBMResult<Vec<f64>> {
         let data_length = data.len();
         let feature_length = data[0].len();
         let params = CString::new("").unwrap();
         let mut out_length: c_long = 0;
-        let out_result: Vec<f64> = vec![Default::default(); data.len()];
+        let out_result: Vec<f64> = vec![Default::default(); data.len() * self.num_classes as usize];
         let flat_data = data.into_iter().flatten().collect::<Vec<_>>();
 
         lgbm_call!(
@@ -79,6 +131,7 @@ impl Drop for Booster {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use serde_json::json;
     fn read_train_file() -> LGBMResult<Dataset> {
         Dataset::from_file("lightgbm-sys/lightgbm/examples/binary_classification/binary.train".to_string())
     }
@@ -86,7 +139,15 @@ mod tests {
     #[test]
     fn predict() {
         let dataset = read_train_file().unwrap();
-        let bst = Booster::train(dataset, "objective=binary metric=auc".to_string()).unwrap();
+        let params = json!{
+            {
+                "num_iterations": 10,
+                "objective": "binary",
+                "metric": "auc",
+                "data_random_seed": 0
+            }
+        };
+        let bst = Booster::train(dataset, &params).unwrap();
         let feature = vec![vec![0.5; 28], vec![0.0; 28], vec![0.9; 28]];
         let result = bst.predict(feature).unwrap();
         let mut normalized_result = Vec::new();
diff --git a/src/lib.rs b/src/lib.rs
index 3fcc966..4fc6c8f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,5 +1,6 @@
 extern crate lightgbm_sys;
 extern crate libc;
+extern crate serde_json;
 
 #[macro_use]
 macro_rules! lgbm_call {

From cdf333195097277830cc2b752e102be52687472a Mon Sep 17 00:00:00 2001
From: vaaaaanquish <6syun9@gmail.com>
Date: Sat, 16 Jan 2021 23:56:49 +0900
Subject: [PATCH 4/6] num_classes -> num_class

---
 src/booster.rs | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/booster.rs b/src/booster.rs
index 3c39909..3497b45 100644
--- a/src/booster.rs
+++ b/src/booster.rs
@@ -13,13 +13,13 @@ use super::{LGBMResult, Dataset, LGBMError};
 /// Core model in LightGBM, containing functions for training, evaluating and predicting.
 pub struct Booster {
     pub(super) handle: lightgbm_sys::BoosterHandle,
-    num_classes: i64
+    num_class: i64
 }
 
 
 impl Booster {
-    fn new(handle: lightgbm_sys::BoosterHandle, num_classes: i64) -> LGBMResult<Self> {
-        Ok(Booster{handle, num_classes})
+    fn new(handle: lightgbm_sys::BoosterHandle, num_class: i64) -> LGBMResult<Self> {
+        Ok(Booster{handle, num_class})
     }
 
     /// Create a new Booster model with given Dataset and parameters.
@@ -56,12 +56,12 @@ impl Booster {
             num_iterations = parameter["num_iterations"].as_i64().unwrap();
         }
 
-        // get num_classes
-        let num_classes: i64;
-        if parameter["num_classes"].is_null(){
-            num_classes = 1;
+        // get num_class
+        let num_class: i64;
+        if parameter["num_class"].is_null(){
+            num_class = 1;
         } else {
-            num_classes = parameter["num_classes"].as_i64().unwrap();
+            num_class = parameter["num_class"].as_i64().unwrap();
         }
 
         // exchange params {"x": "y", "z": 1} => "x=y z=1"
@@ -81,7 +81,7 @@ impl Booster {
         for _ in 1..num_iterations {
             lgbm_call!(lightgbm_sys::LGBM_BoosterUpdateOneIter(handle, &mut is_finished))?;
         }
-        Ok(Booster::new(handle, num_classes)?)
+        Ok(Booster::new(handle, num_class)?)
     }
 
     /// Predict results for given data.
@@ -97,7 +97,7 @@ impl Booster {
         let feature_length = data[0].len();
         let params = CString::new("").unwrap();
         let mut out_length: c_long = 0;
-        let out_result: Vec<f64> = vec![Default::default(); data.len() * self.num_classes as usize];
+        let out_result: Vec<f64> = vec![Default::default(); data.len() * self.num_class as usize];
         let flat_data = data.into_iter().flatten().collect::<Vec<_>>();
 
         lgbm_call!(

From 5cfaa715c8136491c0bc442c238a523e00242b99 Mon Sep 17 00:00:00 2001
From: vaaaaanquish <6syun9@gmail.com>
Date: Sun, 17 Jan 2021 01:32:35 +0900
Subject: [PATCH 5/6] add multiclass example

---
 Cargo.toml                                    |  2 +-
 examples/binary_classification/src/main.rs    |  5 +-
 examples/multiclass_classification/Cargo.toml | 11 +++
 .../multiclass_classification/src/main.rs     | 72 +++++++++++++++++++
 src/booster.rs                                | 19 ++++-
 5 files changed, 103 insertions(+), 6 deletions(-)
 create mode 100644 examples/multiclass_classification/Cargo.toml
 create mode 100644 examples/multiclass_classification/src/main.rs

diff --git a/Cargo.toml b/Cargo.toml
index ae1ce79..dde4452 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "lightgbm"
-version = "0.1.1"
+version = "0.1.2"
 authors = ["vaaaaanquish <6syun9@gmail.com>"]
 license = "MIT"
 repository = "https://github.com/vaaaaanquish/LightGBM"
diff --git a/examples/binary_classification/src/main.rs b/examples/binary_classification/src/main.rs
index b52c996..8d2bf35 100644
--- a/examples/binary_classification/src/main.rs
+++ b/examples/binary_classification/src/main.rs
@@ -3,6 +3,7 @@ extern crate csv;
 extern crate serde_json;
 extern crate itertools;
 
+
 use itertools::zip;
 use lightgbm::{Dataset, Booster};
 use serde_json::json;
@@ -41,7 +42,7 @@ fn main() -> std::io::Result<()> {
 
 
     let mut tp = 0;
-    for (label, pred) in zip(&test_labels, &result){
+    for (label, pred) in zip(&test_labels, &result[0]){
         if label == &(1 as f32) && pred > &(0.5 as f64) {
             tp = tp + 1;
         } else if label == &(0 as f32) && pred <= &(0.5 as f64) {
@@ -49,6 +50,6 @@ fn main() -> std::io::Result<()> {
         }
         println!("{}, {}", label, pred)
     }
-    println!("{} / {}", &tp, result.len());
+    println!("{} / {}", &tp, result[0].len());
     Ok(())
 }
diff --git a/examples/multiclass_classification/Cargo.toml b/examples/multiclass_classification/Cargo.toml
new file mode 100644
index 0000000..e1bca0c
--- /dev/null
+++ b/examples/multiclass_classification/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "lightgbm-example-multiclass-classification"
+version = "0.1.0"
+authors = ["vaaaaanquish <6syun9@gmail.com>"]
+publish = false
+
+[dependencies]
+lightgbm = { path = "../../" }
+csv = "1.1.5"
+itertools = "0.9.0"
+serde_json = "1.0.59"
diff --git a/examples/multiclass_classification/src/main.rs b/examples/multiclass_classification/src/main.rs
new file mode 100644
index 0000000..efbbd92
--- /dev/null
+++ b/examples/multiclass_classification/src/main.rs
@@ -0,0 +1,72 @@
+extern crate lightgbm;
+extern crate csv;
+extern crate serde_json;
+extern crate itertools;
+
+
+use itertools::zip;
+use lightgbm::{Dataset, Booster};
+use serde_json::json;
+
+
+fn load_file(file_path: &str) -> (Vec<Vec<f64>>, Vec<f32>) {
+    let rdr = csv::ReaderBuilder::new().has_headers(false).delimiter(b'\t').from_path(file_path);
+    let mut labels: Vec<f32> = Vec::new();
+    let mut features: Vec<Vec<f64>> = Vec::new();
+    for result in rdr.unwrap().records() {
+        let record = result.unwrap();
+        let label = record[0].parse::<f32>().unwrap();
+        let feature: Vec<f64> = record.iter().map(|x| x.parse::<f64>().unwrap()).collect::<Vec<f64>>()[1..].to_vec();
+        labels.push(label);
+        features.push(feature);
+    }
+    (features, labels)
+}
+
+fn argmax<T: PartialOrd>(xs: &[T]) -> usize {
+    if xs.len() == 1 {
+        0
+    } else {
+        let mut maxval = &xs[0];
+        let mut max_ixs: Vec<usize> = vec![0];
+        for (i, x) in xs.iter().enumerate().skip(1) {
+            if x > maxval {
+                maxval = x;
+                max_ixs = vec![i];
+            } else if x == maxval {
+                max_ixs.push(i);
+            }
+        }
+        max_ixs[0]
+    }
+}
+
+fn main() -> std::io::Result<()> {
+    let (train_features, train_labels) = load_file("../../lightgbm-sys/lightgbm/examples/multiclass_classification/multiclass.train");
+    let (test_features, test_labels) = load_file("../../lightgbm-sys/lightgbm/examples/multiclass_classification/multiclass.test");
+    let train_dataset = Dataset::from_mat(train_features, train_labels).unwrap();
+
+    let params = json!{
+        {
+            "num_iterations": 100,
+            "objective": "multiclass",
+            "metric": "multi_logloss",
+            "num_class": 5,
+        }
+    };
+
+    let booster = Booster::train(train_dataset, &params).unwrap();
+    let result = booster.predict(test_features).unwrap();
+
+
+    let mut tp = 0;
+    for (label, pred) in zip(&test_labels, &result){
+        let argmax_pred = argmax(&pred);
+        if *label == argmax_pred as f32 {
+            tp = tp + 1;
+        }
+        println!("{}, {}, {:?}", label, argmax_pred, &pred);
+    }
+    println!("{} / {}", &tp, result.len());
+    Ok(())
+}
diff --git a/src/booster.rs b/src/booster.rs
index 3497b45..4d464c9 100644
--- a/src/booster.rs
+++ b/src/booster.rs
@@ -92,7 +92,12 @@ impl Booster {
     ///                vec![0.7, 0.4, 0.5],
     ///                vec![0.1, 0.7, 1.0]];
     /// ```
-    pub fn predict(&self, data: Vec<Vec<f64>>) -> LGBMResult<Vec<f64>> {
+    ///
+    /// Output data example
+    /// ```
+    /// let output = vec![vec![1.0, 0.109, 0.433]];
+    /// ```
+    pub fn predict(&self, data: Vec<Vec<f64>>) -> LGBMResult<Vec<Vec<f64>>> {
         let data_length = data.len();
         let feature_length = data[0].len();
         let params = CString::new("").unwrap();
@@ -116,7 +121,15 @@ impl Booster {
                 out_result.as_ptr() as *mut c_double
             )
         )?;
-        Ok(out_result)
+
+        // reshape for multiclass [1,2,3,4,5,6] -> [[1,2,3], [4,5,6]]  # 3 class
+        let reshaped_output;
+        if self.num_class > 1{
+            reshaped_output = out_result.chunks(self.num_class as usize).map(|x| x.to_vec()).collect();
+        } else {
+            reshaped_output = vec![out_result];
+        }
+        Ok(reshaped_output)
     }
 }
 
@@ -151,7 +164,7 @@ mod tests {
         let feature = vec![vec![0.5; 28], vec![0.0; 28], vec![0.9; 28]];
         let result = bst.predict(feature).unwrap();
         let mut normalized_result = Vec::new();
-        for r in result{
+        for r in result[0]{
             if r > 0.5{
                 normalized_result.push(1);
             } else {

From 6e6be3b56a9eb70c339ba12c0b62dde502af4499 Mon Sep 17 00:00:00 2001
From: vaaaaanquish <6syun9@gmail.com>
Date: Sun, 17 Jan 2021 02:58:07 +0900
Subject: [PATCH 6/6] add regression exj

---
 .gitignore                      |  1 +
 examples/regression/Cargo.toml  | 11 +++++++
 examples/regression/src/main.rs | 55 +++++++++++++++++++++++++++++++++
 3 files changed, 67 insertions(+)
 create mode 100644 examples/regression/Cargo.toml
 create mode 100644 examples/regression/src/main.rs

diff --git a/.gitignore b/.gitignore
index fecf55b..61d7627 100644
--- a/.gitignore
+++ b/.gitignore
@@ -15,3 +15,4 @@ lightgbm-sys/target
 # example
 examples/binary_classification/target/
 examples/multiclass_classification/target/
+examples/regression/target/
diff --git a/examples/regression/Cargo.toml b/examples/regression/Cargo.toml
new file mode 100644
index 0000000..0289846
--- /dev/null
+++ b/examples/regression/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "lightgbm-example-regression"
+version = "0.1.0"
+authors = ["vaaaaanquish <6syun9@gmail.com>"]
+publish = false
+
+[dependencies]
+lightgbm = { path = "../../" }
+csv = "1.1.5"
+itertools = "0.9.0"
+serde_json = "1.0.59"
diff --git a/examples/regression/src/main.rs b/examples/regression/src/main.rs
new file mode 100644
index 0000000..ddf5f41
--- /dev/null
+++ b/examples/regression/src/main.rs
@@ -0,0 +1,55 @@
+extern crate lightgbm;
+extern crate csv;
+extern crate serde_json;
+extern crate itertools;
+
+
+use itertools::zip;
+use lightgbm::{Dataset, Booster};
+use serde_json::json;
+
+
+fn load_file(file_path: &str) -> (Vec<Vec<f64>>, Vec<f32>) {
+    let rdr = csv::ReaderBuilder::new().has_headers(false).delimiter(b'\t').from_path(file_path);
+    let mut labels: Vec<f32> = Vec::new();
+    let mut features: Vec<Vec<f64>> = Vec::new();
+    for result in rdr.unwrap().records() {
+        let record = result.unwrap();
+        let label = record[0].parse::<f32>().unwrap();
+        let feature: Vec<f64> = record.iter().map(|x| x.parse::<f64>().unwrap()).collect::<Vec<f64>>()[1..].to_vec();
+        labels.push(label);
+        features.push(feature);
+    }
+    (features, labels)
+}
+
+
+fn main() -> std::io::Result<()> {
+    let (train_features, train_labels) = load_file("../../lightgbm-sys/lightgbm/examples/regression/regression.train");
+    let (test_features, test_labels) = load_file("../../lightgbm-sys/lightgbm/examples/regression/regression.test");
+    let train_dataset = Dataset::from_mat(train_features, train_labels).unwrap();
+
+    let params = json!{
+        {
+            "num_iterations": 100,
+            "objective": "regression",
+            "metric": "l2"
+        }
+    };
+
+    let booster = Booster::train(train_dataset, &params).unwrap();
+    let result = booster.predict(test_features).unwrap();
+
+
+    let mut tp = 0;
+    for (label, pred) in zip(&test_labels, &result[0]){
+        if label == &(1 as f32) && pred > &(0.5 as f64) {
+            tp = tp + 1;
+        } else if label == &(0 as f32) && pred <= &(0.5 as f64) {
+            tp = tp + 1;
+        }
+        println!("{}, {}", label, pred)
+    }
+    println!("{} / {}", &tp, result[0].len());
+    Ok(())
+}