1.5. The Prelude and Imports

1.5.1. 3 ways to bring names into scope

Glob the whole prelude

use rustyml::prelude::*;

This pulls everything into the current scope. It suits getting code written quickly, without having to look up where each item lives.

Glob a single prelude category

The prelude is split into 4 submodules, so you can import just what you need:

use rustyml::prelude::machine_learning::*; // classical estimators, traits, and shared enums
use rustyml::prelude::neural_network::*;   // SequentialBuilder, Sequential, History, Tensor, Shape, layers, losses, optimizers
use rustyml::prelude::metrics::*;          // the evaluation-metric functions and types
use rustyml::prelude::utils::*;            // standardize, normalize, scalers, encoders, split

Use this when the file you are writing clearly belongs to a single domain.

Import by exact path

use rustyml::machine_learning::LinearRegression;
use rustyml::traits::{Fit, Predict};
use rustyml::metrics::r2_score;

Library code that has to be maintained long-term should prefer this style.

1.5.2. What the prelude re-exports

The prelude is a hand-picked list: it re-exports only the items you reach for often. The tables below show exactly what each prelude submodule re-exports.

Machine learning

Neural network

Average names 2 different items in this crate. This table lists it as a merge layer that averages its inputs. The metrics table below lists it as an averaging mode for a classification score. use rustyml::prelude::* globs both categories, so an explicit re-export at the prelude root breaks the tie: plain Average is always the averaging mode. Reach the merge layer by its full path, rustyml::neural_network::layers::Average.

Note the exact casing on RMSprop (lowercase p). Activations come in 2 forms. One is the standalone layers in the table above. The other is a variant of the Activation enum, such as Activation::ReLU or Activation::LeakyReLU { negative_slope }. Any layer that accepts an Activation also accepts a standalone activation layer, because each one implements Layer and Into<Activation>.

The table has no gap. A whole model, from the first add to predict, needs the 1 glob and nothing else.

PReLU is the exception: it holds trainable slopes, so it is a layer and nothing else. 3.2. Dense Layers and Activations lists the full set with the formula for each one.

For example, 1 of Dense::new’s parameters is activation: impl Into<Activation>, so you can pass either an Activation enum variant or a standalone activation layer. Dense::new(8, Activation::ReLU) and Dense::new(8, ReLU::new()) are equivalent.

Metrics

Unlike the error-propagation design in the rest of the crate, the metric functions panic outright on an error, which keeps the module lightweight. See 5. Model Evaluation for the metrics module in depth. Their argument order is (y_true, y_pred), matching scikit-learn.

Utilities

1.5.3. Feature gates decide what the prelude contains

The rustyml::prelude module is always compiled, but each submodule only appears once the matching module feature is enabled. So use rustyml::prelude::* does not mean everything RustyML can do. It means everything the features you enabled can do. For what each feature contains, see 1.2 Installation and Feature Flags.

1.5.4. Using fully-qualified paths

To find where an item lives, docs.rs/rustyml is the place to look. Here is a lookup table for the main types: