concision 0.3.1

Concision is a toolkit for designing machine-learning models in Rust.
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
55

/*
    Appellation: simple <example>
    Created At: 2025.11.26:14:10:58
    Contrib: @FL03
*/
extern crate concision as cnc;

use cnc::ex::sample::TestModel;
use cnc::{ModelFeatures, Predict, StandardModelConfig, Train};
use ndarray::prelude::*;

fn main() -> anyhow::Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(tracing_subscriber::filter::EnvFilter::from_default_env())
        .with_max_level(tracing::Level::TRACE)
        .with_target(false)
        .with_timer(tracing_subscriber::fmt::time::uptime())
        .init();
    tracing::info!("Setting up the model...");
    // define the models features
    let features = ModelFeatures::deep(3, 9, 2, 6);
    tracing::debug!("Model Features: {features:?}");
    // initialize the models configuration
    let mut config = StandardModelConfig::new()
        .with_epochs(1000)
        .with_batch_size(32);
    config.set_learning_rate(0.01);
    config.set_momentum(0.9);
    config.set_decay(0.0001);
    tracing::debug!("Model Config: {config:?}");
    // initialize the model
    let mut model = TestModel::<f64>::new(config, features).init();
    // initialize some input data
    let input = Array1::linspace(1.0, 9.0, model.features().input());
    // propagate the input through the model
    let output = model.predict(&input);
    tracing::info!("output: {:?}", output);
    // verify the output shape
    assert_eq!(output.dim(), (model.features().output()));
    let training_input =
        Array2::from_shape_vec((1, model.features().input()), input.to_vec()).unwrap();
    let expected_output = Array2::from_elem((1, model.features().output()), 0.235);
    let training_span = tracing::info_span!("Starting training...").entered();
    // train the model
    for e in 0..model.config().epochs() {
        training_span.in_scope(|| tracing::trace!("Training epoch {}...", e));
        model.train(&training_input, &expected_output)?;
    }
    drop(training_span);
    // forward the input through the model
    let output = model.predict(&input);
    tracing::info!("output: {:?}", output);

    Ok(())
}