Function train_test_split_seeded 

pub fn train_test_split_seeded(
    x: &Tensor,
    train_ratio: f64,
    seed: u64,
) -> Result<(Tensor, Tensor), MattenMlprepError>

Splits the rows of a 2D tensor into (train, test) by a seeded, shuffled partition.

n_train = floor(n_rows * train_ratio)   // identical to train_test_split

Row order is determined by a Fisher-Yates shuffle of the row indices (never the data itself), driven by a [SplitMix64] stream seeded from seed. The first n_train shuffled indices become train; the rest become test. Only row selection and order differ from train_test_split; the output sizes match exactly for the same (x, train_ratio).

Reproducibility

The same (x, train_ratio, seed) always produces byte-identical output, on every platform and every future release of this crate. The PRNG constants, the shuffle direction, and the seed-to-state mapping are part of this function’s observable, contract-bearing behavior (RFC-077 §6) and will not change without a documented breaking change.

Errors

• MattenMlprepError::ExpectedMatrix if x is not rank-2.
• MattenMlprepError::InvalidRatio if train_ratio is not finite or not in (0.0, 1.0).
• MattenMlprepError::EmptySplit if floor(rows * train_ratio) == 0.
• MattenMlprepError::DynamicTensor (with the dynamic feature) if x is dynamic.

use matten::Tensor;
use matten_mlprep::train_test_split_seeded;

let x = Tensor::new(vec![10.0, 20.0, 30.0, 40.0, 50.0], &[5, 1]);
let (train, test) = train_test_split_seeded(&x, 0.6, 42).unwrap();
assert_eq!(train.shape(), &[3, 1]);
assert_eq!(test.shape(), &[2, 1]);

// Same seed -> byte-identical output.
let (train2, test2) = train_test_split_seeded(&x, 0.6, 42).unwrap();
assert_eq!(train.as_slice(), train2.as_slice());
assert_eq!(test.as_slice(), test2.as_slice());

Examples found in repository

examples/train_test_split_seeded.rs (line 19)

fn main() {
    let x = Tensor::new(vec![10.0, 20.0, 30.0, 40.0, 50.0], &[5, 1]);
    let (train, test) = train_test_split_seeded(&x, 0.6, 7).expect("valid split"); // 3 / 2
    println!("train {:?}: {:?}", train.shape(), train.as_slice());
    println!("test  {:?}: {:?}", test.shape(), test.as_slice());

    assert_eq!(train.shape(), &[3, 1]);
    assert_eq!(test.shape(), &[2, 1]);

    // Re-running with the same seed reproduces the exact same split.
    let (train2, test2) = train_test_split_seeded(&x, 0.6, 7).expect("valid split");
    assert_eq!(train.as_slice(), train2.as_slice());
    assert_eq!(test.as_slice(), test2.as_slice());
    println!("same seed -> reproduced split: OK");

    // A different seed shuffles differently.
    let (train3, _) = train_test_split_seeded(&x, 0.6, 8).expect("valid split");
    println!(
        "different seed -> train {:?}: {:?}",
        train3.shape(),
        train3.as_slice()
    );

    println!("train_test_split_seeded: OK");
}