Rustlearn

https://docs.rs/rustlearn
Admin
Rustlearn is a machine learning crate for Rust providing implementations of common algorithms...
Tokens:426,651
Snippets:2,192
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Example Usage of Hyperparameters

Source: https://docs.rs/rustlearn/0.5.0/src/rustlearn/trees/decision_tree.rs.html

Demonstrates how to create and configure Hyperparameters for a DecisionTree. This example shows setting the dimension, minimum samples for splitting, and maximum depth before building the model.

```rust
let model = Hyperparameters::new(4)
                             .min_samples_split(5)
                             .max_depth(40)
                             .build();
```

--------------------------------

### SGDClassifier Usage

Source: https://docs.rs/rustlearn/latest/src/rustlearn/linear_models/sgdclassifier.rs.html

Examples demonstrating how to initialize, fit, and predict using the SGDClassifier.

```APIDOC
## SGDClassifier

### Description
A two-class logistic regression classifier implemented using stochastic gradient descent.

### Examples

Fitting the model on the iris dataset is straightforward:

```rust
use rustlearn::prelude::*; 
use rustlearn::linear_models::sgdclassifier::Hyperparameters;
use rustlearn::datasets::iris;

let (X, y) = iris::load_data();

let mut model = Hyperparameters::new(4)
                                .learning_rate(1.0)
                                .l2_penalty(0.5)
                                .l1_penalty(0.0)
                                .one_vs_rest();

model.fit(&X, &y).unwrap();

let prediction = model.predict(&X).unwrap();
```

To run multiple epochs of training, use repeated calls to `fit`:

```rust
use rustlearn::prelude::*; 
use rustlearn::linear_models::sgdclassifier::Hyperparameters;
use rustlearn::datasets::iris;

let (X, y) = iris::load_data();

let mut model = Hyperparameters::new(4)
                                .learning_rate(1.0)
                                .l2_penalty(0.5)
                                .l1_penalty(0.0)
                                .one_vs_rest();

let num_epochs = 20;

for _ in 0..num_epochs {
    model.fit(&X, &y).unwrap();
}

let prediction = model.predict(&X).unwrap();
```
```

--------------------------------

### Random Forest Example

Source: https://docs.rs/rustlearn/0.5.0/index.html

Illustrates the creation and usage of a random forest model with the iris dataset. This example includes setting hyperparameters for decision trees and the random forest itself. Serialization and deserialization are commented out but show potential usage.

```rust
use rustlearn::prelude::*;

use rustlearn::ensemble::random_forest::Hyperparameters;
use rustlearn::datasets::iris;
use rustlearn::trees::decision_tree;

let (data, target) = iris::load_data();

let mut tree_params = decision_tree::Hyperparameters::new(data.cols());
tree_params.min_samples_split(10)
    .max_features(4);

let mut model = Hyperparameters::new(tree_params, 10)
    .one_vs_rest();

model.fit(&data, &target).unwrap();

// Optionally serialize and deserialize the model

// let encoded = bincode::serialize(&model).unwrap();
// let decoded: OneVsRestWrapper<RandomForest> = bincode::deserialize(&encoded).unwrap();

let prediction = model.predict(&data).unwrap();

```

--------------------------------

### Accessing Rows of a Transposed Array (Large Example)

Source: https://docs.rs/rustlearn/latest/src/rustlearn/array/test.rs.html

This example demonstrates accessing rows from a larger transposed array. It's important to verify dimensions and content for correctness.

```rust
let mut arr = Array::from(vec![0.2718385852867393,
                                       0.013460642713719828,
                                       0.12798750635805256,
                                       0.7919986749289545,
                                       0.9391186519981108,
                                       0.9806978175296652,
                                       0.48024033473364547,
                                       0.1669245810689408,
                                       0.6801699678508741,
                                       0.9490436766686265,
                                       0.44904300995572166,
                                       0.23258694099688615,
                                       0.7220265418019424,
                                       0.14200835687922775,
                                       0.10019118536548222,
                                       0.6312223198556238,
                                       0.09417371194068569,
                                       0.13715955368621513,
                                       0.9505754201392806,
                                       0.6387252873419664,
                                       0.9996498787040119,
                                       0.7780565108493451,
                                       0.016974953804198112,
                                       0.2079781316192134]);
```

--------------------------------

### Create a new DictVectorizer

Source: https://docs.rs/rustlearn/0.5.0/rustlearn/feature_extraction/dict_vectorizer/struct.DictVectorizer.html

Instantiates a new DictVectorizer. This is the starting point for accumulating feature data.

```rust
pub fn new() -> DictVectorizer
```

--------------------------------

### Reshape and Transpose Array (2x7)

Source: https://docs.rs/rustlearn/latest/src/rustlearn/array/test.rs.html

This example illustrates reshaping a 2x7 array and then transposing it. It's a common pattern for data manipulation.

```rust
let mut arr = Array::from(vec![0.1676678409149912,
                                       0.861383405027676,
                                       0.9216207547768913,
                                       0.6191954561476947,
                                       0.12362933806379073,
                                       0.44381481157270497,
                                       0.19877703470687746,
                                       0.14107562648466954,
                                       0.6710861414183165,
                                       0.24887924418424412,
                                       0.36999837265698077,
                                       0.34671285416782716,
                                       0.8249131922342992,
                                       0.841648699352834]);
        arr.reshape(2, 7);
        arr = arr.T();
```

--------------------------------

### Get Specific Row from Transposed Array

Source: https://docs.rs/rustlearn/latest/src/rustlearn/array/test.rs.html

Shows how to extract a row from an array after it has been transposed using the `.T()` method. This example verifies dimensions before comparing the row content.

```rust
let mut arr = Array::from(vec![0.7707843100914994,
                                       0.25091438495265406,
                                       0.8799693575880421,
                                       0.28563785932012686,
                                       0.697387193772135,
                                       0.5745064605630149,
                                       0.3904684326376954,
                                       0.28571568506794665,
                                       0.19545894929132046,
                                       0.6664775490939762,
                                       0.8209682309863416,
                                       0.3129695667863188,
                                       0.28191295400607375,
                                       0.18339346264137957,
                                       0.8465732304205962,
                                       0.9730523995670246,
                                       0.2109218243532145,
                                       0.49922436813494864]);
arr.reshape(3, 6);
arr = arr.T();

        let mut result =
            Array::from(vec![0.5745064605630149, 0.3129695667863188, 0.49922436813494864]);
        result.reshape(1, 3);

        let idx: usize = 5;

        assert!(result.rows() == arr.get_rows(&idx).rows());
        assert!(result.cols() == arr.get_rows(&idx).cols());

        assert!(allclose(&arr.get_rows(&idx), &result));
```

--------------------------------

### Import Rustlearn Prelude

Source: https://docs.rs/rustlearn/0.5.0/index.html

Import the prelude for all linear algebra primitives and common traits in rustlearn.

```rust
use rustlearn::prelude::*;

```

--------------------------------

### Create and Populate SparseRowArray

Source: https://docs.rs/rustlearn/0.5.0/rustlearn/array/sparse/index.html

Demonstrates how to initialize a `SparseRowArray` with zeros and set specific entries. Ensure `rustlearn::prelude::*` is imported.

```rust
use rustlearn::prelude::*;

let mut array = SparseRowArray::zeros(20, 5);

array.set(0, 2, 5.0);

println!("Entry at ({}, {}) is {}", 0, 2, array.get(0, 2));

```

--------------------------------

### Get Specific Row from Array (Different Dimensions)

Source: https://docs.rs/rustlearn/latest/src/rustlearn/array/test.rs.html

Illustrates retrieving a specific row from an array with different dimensions using `get_rows`. This example uses a 6x4 array and extracts a row.

```rust
let mut arr = Array::from(vec![0.20868550871724179,
                                       0.5605127695203469,
                                       0.339804058118506,
                                       0.7256905381163948,
                                       0.6611417510563221,
                                       0.969019548886142,
                                       0.8471190899730158,
                                       0.4380513125992891,
                                       0.8646212553805457,
                                       0.6487929773201981,
                                       0.6937440457173739,
                                       0.9679474559715064,
                                       0.24340259978189238,
                                       0.7870005431727255,
                                       0.6427913578996599,
                                       0.6660887992362555,
                                       0.40442105665544525,
                                       0.12523251977686645,
                                       0.837216006531832,
                                       0.16563066983169672,
                                       0.6202657886890243,
                                       0.5242136939252772,
                                       0.35801788839394355,
                                       0.11278053040947844]);
arr.reshape(6, 4);

        let mut result = Array::from(vec![0.40442105665544525,
                                          0.12523251977686645,
                                          0.837216006531832,
                                          0.16563066983169672]);
        result.reshape(1, 4);

        let idx: usize = 4;

        assert!(allclose(&arr.get_rows(&idx), &result));
```

--------------------------------

### Import rustlearn Models and Utilities

Source: https://docs.rs/rustlearn/0.5.0/rustlearn

Import individual models and utilities from submodules, along with the prelude.

```rust
use rustlearn::prelude::*;

use rustlearn::linear_models::sgdclassifier::Hyperparameters;
// more imports
```

--------------------------------

### Test Scalar Get Rows Transpose

Source: https://docs.rs/rustlearn/latest/src/rustlearn/array/test.rs.html

Tests the functionality of getting rows from a transposed array with scalar indexing.

```rust
    #[test]
    fn test_scalar_get_rows_transpose_9() {

        let mut arr = Array::from(vec![0.9058704104647929,
                                       0.9174485614828881,
                                       0.2406691976095029,
                                       0.220714202251722,
                                       0.042199568357976114,
                                       0.48665612442387685,
                                       0.7575461347311593,
                                       0.22419192871566973,
                                       0.7097752684375215,
                                       0.1925008894000757,
                                       0.47933693147499434,
                                       0.12753850011229628,
                                       0.2843434588211813,
                                       0.10319057485057492,
                                       0.32444345473467084,
                                       0.6295224472317583,
                                       0.6165680202130384,
                                       0.2385542680818219,
                                       0.129278413055962,
                                       0.9159942040797456,
                                       0.49442243513535344,
                                       0.5507984587600816,
                                       0.6474250958230049,
                                       0.8448279100953802,
                                       0.9713486908733158,
                                       0.1182634921189929,
                                       0.0448569910081652,
                                       0.15855114104871249,
                                       0.9514234005377552,
                                       0.42671958367097107,
                                       0.5068355074640134,
                                       0.025359934640823978,
                                       0.015614477870282917,
                                       0.5521159014023806,
                                       0.8069985935631249]);
        arr.reshape(5, 7);
        arr = arr.T();

        let mut result = Array::from(vec![0.9058704104647929,
                                          0.22419192871566973,
                                          0.32444345473467084,
                                          0.5507984587600816,
                                          0.9514234005377552]);
        result.reshape(1, 5);

        let idx: usize = 0;

        assert!(result.rows() == arr.get_rows(&idx).rows());
        assert!(result.cols() == arr.get_rows(&idx).cols());

        assert!(allclose(&arr.get_rows(&idx), &result));
    }

```

--------------------------------

### Matrix Multiplication with Transpose (Second Example) in Rustlearn

Source: https://docs.rs/rustlearn/latest/src/rustlearn/array/test.rs.html

Demonstrates another matrix multiplication with transpose operation. This example uses different array dimensions and values.

```rust
    #[test]
    fn test_matmul_transpose_6() {

        let mut arr1 = Array::from(vec![0.9276189989088249,
                                        0.8821012380772483,
                                        0.9576279927537044,
                                        0.22119528649355513,
                                        0.15085713741486573,
                                        0.12322318180711189,
                                        0.4779679546181437,
                                        0.25742220251992387,
                                        0.9464418322439493,
                                        0.4909424621118489,
                                        0.7208912195238542,
                                        0.9962322660739507,
                                        0.43533776323883855,
                                        0.021464328280912603,
                                        0.015101580588801289,
                                        0.4716963821413963]);
        arr1.reshape(2, 8);

        let mut arr2 = Array::from(vec![0.6380396395660042,
                                        0.10554754374241415,
                                        0.21965756983369356,
                                        0.7349374715928855,
                                        0.7131278653062647,
                                        0.9603874411608422,
                                        0.7313319921709864,
                                        0.8400464200610347,
                                        0.5942567718918943,
                                        0.6819923645474909,
                                        0.7108151819484294,
                                        0.1756086825292481,
                                        0.3818892264503654,
                                        0.39877587789472135,
                                        0.3871422778639042,
                                        0.18732006765193376,
                                        0.42338466389086193,
                                        0.7379784022664586,
                                        0.9901201285264503,
                                        0.06883631042351934,
                                        0.8524458513130413,
                                        0.7847495669454642,
                                        0.4793364790425151,
                                        0.2975398248045932,
                                        0.4832935210264835,
                                        0.3928910553212097,
                                        0.8996944797582809,
                                        0.2800125195754294,
                                        0.09461643872180725,
                                        0.5045095661759922,
                                        0.1777668022757236,
                                        0.23142416909963948]);
        arr2.reshape(4, 8);

        let mut result = Array::from(vec![1.849598533760568,
                                          2.2123816048166196,
                                          2.5381020520478583]);
    }

```

--------------------------------

### Test Scalar Get Rows Transpose

Source: https://docs.rs/rustlearn/latest/src/rustlearn/array/test.rs.html

Tests the functionality of getting rows from a transposed array using a scalar index. Ensures dimensions match and content is equivalent.

```rust
    #[test]
    fn test_scalar_get_rows_transpose_7() {

        let mut arr = Array::from(vec![0.1272207720538362,
                                       0.5722512148113048,
                                       0.9093077469603993,
                                       0.8031151814245743,
                                       0.7878095174291018,
                                       0.68571961443512,
                                       0.2304103778988914,
                                       0.9477147799579432,
                                       0.04830228168121298,
                                       0.23860575739602574,
                                       0.4924570255163495,
                                       0.8433460131727744]);
        arr.reshape(6, 6);
        arr = arr.T();

        let mut result = Array::from(vec![0.2718385852867393,
                                          0.48024033473364547,
                                          0.7220265418019424,
                                          0.9505754201392806,
                                          0.1272207720538362,
                                          0.2304103778988914]);
        result.reshape(1, 6);

        let idx: usize = 0;

        assert!(result.rows() == arr.get_rows(&idx).rows());
        assert!(result.cols() == arr.get_rows(&idx).cols());

        assert!(allclose(&arr.get_rows(&idx), &result));
    }

```

--------------------------------

### Train and Predict with Random Forest

Source: https://docs.rs/rustlearn/0.5.0/rustlearn/ensemble/random_forest

Demonstrates how to load data, configure decision tree hyperparameters, initialize a random forest model with a specified number of trees, train the model, and make predictions. Ensure the necessary prelude and dataset are imported.

```rust
use rustlearn::prelude::*;

use rustlearn::ensemble::random_forest::Hyperparameters;
use rustlearn::datasets::iris;
use rustlearn::trees::decision_tree;

let (data, target) = iris::load_data();

let mut tree_params = decision_tree::Hyperparameters::new(data.cols());
tree_params.min_samples_split(10)
    .max_features(4);

let mut model = Hyperparameters::new(tree_params, 10)
    .one_vs_rest();

model.fit(&data, &target).unwrap();

let prediction = model.predict(&data).unwrap();

```

--------------------------------

### Import Specific Models and Utilities

Source: https://docs.rs/rustlearn/0.5.0/index.html

Import individual models and utilities from submodules alongside the prelude.

```rust
use rustlearn::prelude::*;

use rustlearn::linear_models::sgdclassifier::Hyperparameters;
// more imports

```

--------------------------------

### Test Array Get Functionality

Source: https://docs.rs/rustlearn/latest/src/rustlearn/array/test.rs.html

Verifies the `get` method for accessing elements at specific indices within an Array. Asserts that retrieved values match expected floating-point numbers.

```rust
assert!(close(arr.get(0, 4), 0.752985306516));
        assert!(close(arr.get(1, 4), 0.972936747196));
        assert!(close(arr.get(2, 4), 0.0483774375986));
        assert!(close(arr.get(3, 4), 0.096648276834));
        assert!(close(arr.get(4, 4), 0.756069929567));
        assert!(close(arr.get(5, 4), 0.44789761169));
        assert!(close(arr.get(6, 4), 0.558090641318));
        assert!(close(arr.get(7, 4), 0.365642301604));
        assert!(close(arr.get(0, 5), 0.338632939335));
        assert!(close(arr.get(1, 5), 0.235820373685));
        assert!(close(arr.get(2, 5), 0.227415183528));
        assert!(close(arr.get(3, 5), 0.090845844464));
        assert!(close(arr.get(4, 5), 0.801360488075));
        assert!(close(arr.get(5, 5), 0.184335262651));
        assert!(close(arr.get(6, 5), 0.166577483436));
        assert!(close(arr.get(7, 5), 0.876580360468));
        assert!(close(arr.get(0, 6), 0.300903889795));
        assert!(close(arr.get(1, 6), 0.0824622426054));
        assert!(close(arr.get(2, 6), 0.57048477017));
        assert!(close(arr.get(3, 6), 0.581971805173));
        assert!(close(arr.get(4, 6), 0.43949517411));
        assert!(close(arr.get(5, 6), 0.21381802195));
        assert!(close(arr.get(6, 6), 0.846786664965));
        assert!(close(arr.get(7, 6), 0.286597816032));
        assert!(close(arr.get(0, 7), 0.987434811394));
        assert!(close(arr.get(1, 7), 0.351616737105));
        assert!(close(arr.get(2, 7), 0.922635050449));
        assert!(close(arr.get(3, 7), 0.967930776509));
        assert!(close(arr.get(4, 7), 0.177817746359));
        assert!(close(arr.get(5, 7), 0.189873869008));
        assert!(close(arr.get(6, 7), 0.464062150385));
        assert!(close(arr.get(7, 7), 0.333041773282));
        assert!(close(arr.get(0, 8), 0.81780830653));
        assert!(close(arr.get(1, 8), 0.492501643062));
        assert!(close(arr.get(2, 8), 0.84632733488));
        assert!(close(arr.get(3, 8), 0.800257416013));
        assert!(close(arr.get(4, 8), 0.178537092654));
        assert!(close(arr.get(5, 8), 0.380089876429));
        assert!(close(arr.get(6, 8), 0.591937855112));
        assert!(close(arr.get(7, 8), 0.630833632448));
```

--------------------------------

### Initialize and Use Array in Rust

Source: https://docs.rs/rustlearn/latest/src/rustlearn/array/test.rs.html

Shows how to initialize a 1D array from a vector and then create a second array for subsequent operations. This is a common pattern for setting up data for computations.

```rust
let mut arr2 = Array::from(vec![1.1055915355682373,
                                          1.0103296041488647,
                                          2.0580873489379883,
                                          2.01757550239563,
                                          2.1222567558288574,
                                          0.19761289656162262,
                                          0.7987737655639648,
                                          0.4312933087348938,
                                          1.0986870527267456,
                                          1.50045907497406,
                                          2.949162721633911,
                                          0.9209742546081543,
                                          15.564422607421875,
                                          12.631396293640137,
                                          1.6796804666519165,
                                          9.856907844543457,
                                          2.0870282649993896,
                                          0.6912974119186401,
                                          2.3309082984924316,
                                          2.399832248687744,
                                          0.728661298751831,
                                          0.012240624986588955,
                                          2.4571237564086914,
                                          0.1399819254875183,
                                          1.0175671577453613,
                                          0.7334205508232117,
                                          0.2805781960487366,
                                          0.5128139853477478,
                                          18.380783081054688,
                                          0.431574285030365,
                                          2.071538209915161,
                                          0.6715353727340698,
                                          0.9522784948348999,
                                          0.5846233367919922,
                                          3.193681240081787,
                                          0.9475670456886292]);
```

--------------------------------

### Test Scalar Get Rows Transpose with Different Data

Source: https://docs.rs/rustlearn/latest/src/rustlearn/array/test.rs.html

Tests the functionality of getting rows from a transposed array using a scalar index with a different dataset. Verifies dimension and content equality.

```rust
    #[test]
    fn test_scalar_get_rows_transpose_8() {

        let mut arr = Array::from(vec![0.7585933989589557,
                                       0.29088432020241584,
                                       0.7643341872939214,
                                       0.836775218001464,
                                       0.3769148476585228,
                                       0.6977319782273234,
                                       0.9199661944212296,
                                       0.4686776725666314,
                                       0.7316101282371349,
                                       0.010247040539513863,
                                       0.04393813135038249,
                                       0.5246689967353431,
                                       0.2908815249594344,
                                       0.1962702360964671,
                                       0.14616285960637965,
                                       0.26404283873074286,
                                       0.29377021478284215,
                                       0.728609074576266,
                                       0.12980871138479078,
                                       0.6287927742441822,
                                       0.1928991963488823,
                                       0.6248893174890445,
                                       0.055569813316688976,
                                       0.4193956556537305,
                                       0.755910885757368,
                                       0.23272758704023733,
                                       0.9134030871532263,
                                       0.2278706667044479,
                                       0.9689881107806262,
                                       0.3147237564886278,
                                       0.62197218783676,
                                       0.14674543088775016,
                                       0.7825943647079507,
                                       0.17626465303951122,
                                       0.031700206452515256,
                                       0.35552418832283306,
                                       0.28987457696053687,
                                       0.9213173807005415,
                                       0.22233723243411985,
                                       0.6330528087199453,
                                       0.05729903201260578,
                                       0.8950982415656692,
                                       0.6337288687754038,
                                       0.46276848503218115,
                                       0.09078810453420316,
                                       0.9821533348159726,
                                       0.7516318919626817,
                                       0.9263977611806433,
                                       0.5772193772944185,
                                       0.44456220698867976,
                                       0.11843053646665092,
                                       0.0033921197532106317,
                                       0.42989727068529604]);
        arr.reshape(6, 6);
        arr = arr.T();

        let mut result = Array::from(vec![0.7585933989589557,
                                          0.29088432020241584,
                                          0.7643341872939214,
                                          0.836775218001464,
                                          0.3769148476585228,
                                          0.6977319782273234]);
        result.reshape(1, 6);

        let idx: usize = 0;

        assert!(result.rows() == arr.get_rows(&idx).rows());
        assert!(result.cols() == arr.get_rows(&idx).cols());

        assert!(allclose(&arr.get_rows(&idx), &result));
    }

```

--------------------------------

### Train Factorization Machine Model

Source: https://docs.rs/rustlearn/0.5.0/rustlearn/factorization/factorization_machines/index.html

This example demonstrates how to initialize and train a Factorization Machine model using the rustlearn library. It loads the iris dataset, configures hyperparameters for the model (dimensionality and number of iterations), and fits the model to the data. The `one_vs_rest` method is used for multi-class classification.

```rust
use rustlearn::prelude::*;
use rustlearn::factorization::factorization_machines::Hyperparameters;
use rustlearn::datasets::iris;

let (X, y) = iris::load_data();

let mut model = Hyperparameters::new(4, 10)
                                .one_vs_rest();

model.fit(&X, &y).unwrap();

let prediction = model.predict(&X).unwrap();
```

--------------------------------

### Initialize and Reshape Array

Source: https://docs.rs/rustlearn/latest/src/rustlearn/array/test.rs.html

Demonstrates initializing a new array with a vector of f64 values and then reshaping it into an 8x5 matrix. This is useful for preparing data for matrix operations.

```rust
let mut arr2 = Array::from(vec![0.2409084439277649,
                                         0.4596225917339325,
                                         0.4888952672481537,
                                         0.6638343334197998,
                                         0.388359934091568,
                                         0.46549633145332336,
                                         0.5773903727531433,
                                         0.03631483390927315,
                                         0.9943253993988037,
                                         0.0273441094905138,
                                         0.020947275683283806,
                                         0.31343042850494385,
                                         0.07427830994129181,
                                         0.19509199261665344,
                                         0.1998319774866104,
                                         0.20672959089279175,
                                         0.3237887918949127,
                                         0.28872179985046387,
                                         0.36704495549201965,
                                         0.3148595988750458,
                                         0.8327291011810303,
                                         0.9654577374458313,
                                         0.9463678002357483,
                                         0.48835742473602295,
                                         0.9109439253807068,
                                         0.030691994354128838,
                                         0.9641919732093811,
                                         0.43064993619918823,
                                         0.446991503238678,
                                         0.2768392860889435,
                                         0.8910713791847229,
                                         0.23636873066425323,
                                         0.8908159136772156,
                                         0.7293870449066162,
                                         0.2140239179134369,
                                         0.7874829173088074,
                                         0.8699233531951904]);
arr2.reshape(8, 5);
```

--------------------------------

### SVC Hyperparameter Configuration

Source: https://docs.rs/rustlearn/latest/src/rustlearn/svm/libsvm/svc.rs.html

Illustrates setting various hyperparameters for the SVC model, including regularization parameter C, kernel type, degree, gamma, coef0, and cache size. The `build` method finalizes the configuration.

```rust
pub fn new(dim: usize, kernel: KernelType, num_classes: usize) -> Hyperparameters {
    Hyperparameters {
        dim: dim,
        num_classes: num_classes,
        svm_parameter: ffi::SvmParameter::new(ffi::SvmType::C_SVC, kernel, num_classes, dim),
    }
}

/// Set the regularization parameter `C`; smaller values
/// mean more regularization.
/// Default is `1.0`.
pub fn C(&mut self, C: f64) -> &mut Hyperparameters {
    self.svm_parameter.C = C;
    self
}

/// Set the degree of the polynomial kernel. No effect on other
/// kernels. Default: 3.
pub fn degree(&mut self, degree: i32) -> &mut Hyperparameters {
    self.svm_parameter.degree = degree;
    self
}

/// Set the gamma parameter of the RBF kernel.
/// Default is `1 / self.dim`.
pub fn gamma(&mut self, gamma: f64) -> &mut Hyperparameters {
    self.svm_parameter.gamma = gamma;
    self
}

/// Set the coef0 parameter for the sigmoid kernel.
/// Default is `0.0`.
pub fn coef0(&mut self, coef0: f64) -> &mut Hyperparameters {
    self.svm_parameter.coef0 = coef0;
    self
}

/// Set the `libsvm` cache size, in megabytes.
/// Default is `100.0`.
pub fn cache_size(&mut self, cache_size: f64) -> &mut Hyperparameters {
    self.svm_parameter.cache_size = cache_size;
    self
}

/// Build the SVC model. `libsvm` natively supports multiclass
/// problems via one-vs-one (OvO) estimation, so no one-vs-rest
/// wrapper is provided.
pub fn build(&self) -> SVC {
    SVC {
        dim: self.dim,
        hyperparams: self.to_owned(),
        model: None,
    }
}

```

--------------------------------

### RandomForest::type_id

Source: https://docs.rs/rustlearn/latest/rustlearn/ensemble/random_forest/struct.RandomForest.html

Gets the TypeId of the RandomForest instance.

```APIDOC
## RandomForest::type_id

### Description
Gets the `TypeId` of `self`.

### Method
```rust
fn type_id(&self) -> TypeId
```
```

--------------------------------

### Train and Predict with SVC

Source: https://docs.rs/rustlearn/0.5.0/rustlearn/svm/libsvm/svc/index.html

Demonstrates how to initialize, train, and make predictions using the SVC model with the iris dataset. Ensure necessary imports are included.

```rust
use rustlearn::prelude::*; use rustlearn::datasets::iris;
use rustlearn::svm::libsvm::svc::{Hyperparameters, KernelType};

let (X, y) = iris::load_data();

let mut model = Hyperparameters::new(4, KernelType::Linear, 4)
    .C(0.3)
    .build();

model.fit(&X, &y).unwrap();

let prediction = model.predict(&X).unwrap();

```

--------------------------------

### Test Vector Get Rows

Source: https://docs.rs/rustlearn/latest/src/rustlearn/array/test.rs.html

Tests the functionality of accessing rows from a vector-like array.

```rust
    #[test]
    fn test_vector_get_rows_0() {

        let mut arr = Array::from(vec![0.3026844973337608,
                                       0.8583123142333691,
                                       0.16731151966900837,
                                       0.33635588451063736,
                                       0.25153161820736425,
                                       0.8198965297579482,
                                       0.19126813305801438,
                                       0.13342028215153323,
                                       0.3797980276515116,
                                       0.4900123765802087,
                                       0.616117445213224,
                                       0.1828317097820401,
                                       0.5898986540355099,
                                       0.3692672059112524,

```

--------------------------------

### Construct and Index SparseColumnArray

Source: https://docs.rs/rustlearn/0.5.0/src/rustlearn/array/sparse.rs.html

Demonstrates the construction of a SparseColumnArray from a dense array and verifies its non-zero count and element access.

```rust
    #[test]
    fn column_construction_and_indexing() {
        let dense_arr = Array::from(&vec![vec![0.0, 1.0], vec![2.0, 0.0]]);
        let arr = SparseColumnArray::from(&dense_arr);

        assert!(arr.nnz() == 2);
        assert!(allclose(&arr.todense(), &dense_arr));

        assert!(arr.get(0, 0) == 0.0);
        assert!(arr.get(0, 1) == 1.0);
        assert!(arr.get(1, 0) == 2.0);
        assert!(arr.get(1, 1) == 0.0);
    }

```

--------------------------------

### Initialize and Reshape Array in Rust

Source: https://docs.rs/rustlearn/latest/src/rustlearn/array/test.rs.html

Demonstrates initializing a new Array from a vector of f64 values and then reshaping it into a 9x7 matrix. Ensure the total number of elements in the vector matches the product of the new dimensions.

```rust
let mut arr = Array::from(vec![0.5720898040673107,
                                       0.04459127396247098,
                                       0.5895633328775719,
                                       0.9658090410489292,
                                       0.3534478214947444,
                                       0.5285776368934987,
                                       0.13445147873841157,
                                       0.36101860852519785,
                                       0.3343563716507818,
                                       0.363015951384304,
                                       0.584979662494934,
                                       0.9548274787099071,
                                       0.1075713091854591,
                                       0.2038098798210375,
                                       0.01140797599229293,
                                       0.08184250431205853,
                                       0.9042079612866117,
                                       0.8979491942667515,
                                       0.869373724494945,
                                       0.3538388463563201,
                                       0.4754988589174608,
                                       0.4694231674732119,
                                       0.1887409583134234,
                                       0.9148221048400892,
                                       0.6559195021254881,
                                       0.1897196903434769,
                                       0.7602151618545422,
                                       0.44835948468885367,
                                       0.7131453192939813,
                                       0.879632358051081,
                                       0.3493184807385423,
                                       0.7590567490943513,
                                       0.41898863180099055,
                                       0.548792375495095,
                                       0.704546184617159,
                                       0.7541363839955707,
                                       0.5848805009620869,
                                       0.5822557475310346,
                                       0.7146597150121486,
                                       0.2796232248768632,
                                       0.27467637251457966,
                                       0.06960804611156912,
                                       0.3593073709314968,
                                       0.8817491601357033,
                                       0.13658583253315493,
                                       0.2291696765983675]);
        arr.reshape(9, 7);

```

--------------------------------

### Test Array Indexing

Source: https://docs.rs/rustlearn/latest/src/rustlearn/array/test.rs.html

Tests accessing elements of a reshaped array using `get`.

```rust
    #[test]
    fn test_index_9() {

        let mut arr = Array::from(vec![0.8838213961957216,
                                       0.7310938683329141,
                                       0.591505339227943,
                                       0.3930296867058841,
                                       0.27046020836139695,
                                       0.9695271560912553]);
        arr.reshape(1, 6);

        assert!(close(arr.get(0, 0), 0.883821396196));
        assert!(close(arr.get(0, 1), 0.731093868333));
        assert!(close(arr.get(0, 2), 0.591505339228));
        assert!(close(arr.get(0, 3), 0.393029686706));
        assert!(close(arr.get(0, 4), 0.270460208361));
        assert!(close(arr.get(0, 5), 0.969527156091));
    }
```

--------------------------------

### Get Coefficients Method

Source: https://docs.rs/rustlearn/0.5.0/src/rustlearn/linear_models/sgdclassifier.rs.html

Returns a reference to the current estimated coefficients vector of the SGDClassifier.

```rust
pub fn get_coefficients(&self) -> &Array {
    &self.coefficients
}
```

--------------------------------

### Train and Predict with SVC

Source: https://docs.rs/rustlearn/0.5.0/rustlearn/svm/libsvm/svc

Demonstrates how to load the iris dataset, configure SVC hyperparameters, train a model, and make predictions. Ensure the necessary imports are included.

```rust
use rustlearn::prelude::*; use rustlearn::datasets::iris;
use rustlearn::svm::libsvm::svc::{Hyperparameters, KernelType};

let (X, y) = iris::load_data();

let mut model = Hyperparameters::new(4, KernelType::Linear, 4)
    .C(0.3)
    .build();

model.fit(&X, &y).unwrap();

let prediction = model.predict(&X).unwrap();
```

--------------------------------

### Get Coefficients of Factorization Machine

Source: https://docs.rs/rustlearn/0.5.0/src/rustlearn/factorization/factorization_machines.rs.html

Returns a reference to the coefficients of the Factorization Machine model.

```rust
pub fn get_coefficients(&self) -> &Array {
        &self.coefficients
    }
```

--------------------------------

### SGDClassifier Training and Prediction Example

Source: https://docs.rs/rustlearn/0.5.0/src/rustlearn/linear_models/sgdclassifier.rs.html

Demonstrates fitting an SGDClassifier model to training data and then using it to predict on test data. Assumes data and target variables are already prepared.

```rust
model.fit(&x_train, &y_train).unwrap();

            let y_hat = model.predict(&x_test).unwrap();

            test_accuracy += accuracy_score(&target.get_rows(&test_idx), &y_hat);
        }

        test_accuracy /= no_splits as f32;
        println!("{}", test_accuracy);

        assert!(test_accuracy > 0.88);
    }
}
```

--------------------------------

### View a specific column

Source: https://docs.rs/rustlearn/0.5.0/rustlearn/array/dense/struct.Array.html

Get an immutable view of a single column at the specified index.

```rust
fn view_column(self, idx: usize) -> ArrayView<'a>
```

--------------------------------

### Get Array order

Source: https://docs.rs/rustlearn/0.5.0/rustlearn/array/dense/struct.Array.html

Retrieve the memory layout order (row-major or column-major) of the Array.

```rust
pub fn order(&self) -> &MatrixOrder
```

--------------------------------

### Create LibsvmNode

Source: https://docs.rs/rustlearn/0.5.0/src/rustlearn/svm/libsvm/ffi.rs.html

A constructor for creating a new `LibsvmNode`.

```rust
fn new(index: i32, value: f64) -> LibsvmNode {
        LibsvmNode {
            index: index,
            value: value,
        }
    }
```

--------------------------------

### Initialize Factorization Machine Hyperparameters

Source: https://docs.rs/rustlearn/0.5.0/rustlearn/factorization/factorization_machines/struct.Hyperparameters.html

Creates new Hyperparameters for a Factorization Machine. The `num_components` parameter controls model expressiveness and complexity.

```rust
pub fn new(dim: usize, num_components: usize) -> Hyperparameters
```

--------------------------------

### SparseRowArray::get

Source: https://docs.rs/rustlearn/0.5.0/rustlearn/array/sparse/struct.SparseRowArray.html

Gets the value of an entry at the specified row and column with bounds checking.

```APIDOC
## SparseRowArray::get

### Description
Get the value of the entry at (`row`, `column`).

### Signature
```rust
fn get(&self, row: usize, column: usize) -> f32
```
```
Tokens:
Raw