test: bound example training runs

Author: kholdrex

examples/stock_prediction.rs

@@ -7,10 +7,31 @@
 #![allow(unused_comparisons)]
 
 use ndarray::{arr2, Array2};
+use rand::{rngs::StdRng, Rng, SeedableRng};
 use rust_lstm::loss::MSELoss;
 use rust_lstm::models::lstm_network::LSTMNetwork;
 use rust_lstm::optimizers::Adam;
-use rust_lstm::training::LSTMTrainer;
+use rust_lstm::training::{LSTMTrainer, TrainingConfig};
+
+pub(crate) const DEMO_EPOCHS: usize = 2;
+pub(crate) const DEMO_PRINT_EVERY: usize = 1;
+pub(crate) const DEMO_STOCK_DAYS: usize = 80;
+pub(crate) const DEMO_SEQUENCE_LENGTH: usize = 5;
+pub(crate) const DEMO_HIDDEN_SIZE: usize = 8;
+pub(crate) const DEMO_RNG_SEED: u64 = 42;
+
+pub(crate) fn demo_training_config() -> TrainingConfig {
+    TrainingConfig {
+        epochs: DEMO_EPOCHS,
+        print_every: DEMO_PRINT_EVERY,
+        log_lr_changes: false,
+        ..TrainingConfig::default()
+    }
+}
+
+pub(crate) fn demo_stock_trainer(network: LSTMNetwork) -> LSTMTrainer<MSELoss, Adam> {
+    LSTMTrainer::new(network, MSELoss, Adam::new(0.001)).with_config(demo_training_config())
+}
 
 /// Stock data point with OHLCV (Open, High, Low, Close, Volume)
 #[derive(Debug, Clone)]
@@ -137,10 +158,7 @@ impl StockPredictor {
             val_data.len()
         );
 
-        // Create trainer with Adam optimizer
-        let loss_function = MSELoss;
-        let optimizer = Adam::new(0.001);
-        let mut trainer = LSTMTrainer::new(self.network.clone(), loss_function, optimizer);
+        let mut trainer = demo_stock_trainer(self.network.clone());
 
         // Train the model
         trainer.train(train_data, Some(val_data));
@@ -178,6 +196,7 @@ impl StockPredictor {
 
 /// Generate synthetic stock data for demonstration
 fn generate_stock_data(days: usize) -> Vec<StockData> {
+    let mut rng = StdRng::seed_from_u64(DEMO_RNG_SEED);
     let mut data = Vec::new();
     let mut price = 100.0;
     let volume_base = 1_000_000.0;
@@ -186,19 +205,19 @@ fn generate_stock_data(days: usize) -> Vec<StockData> {
         // Random walk with trend and volatility
         let trend = 0.001; // Slight upward trend
         let volatility = 0.02;
-        let random_change = (rand::random::<f64>() - 0.5) * volatility;
+        let random_change = (rng.gen::<f64>() - 0.5) * volatility;
 
         price *= 1.0 + trend + random_change;
         price = price.max(1.0); // Prevent negative prices
 
         // Generate OHLC based on closing price
         let daily_volatility = 0.005;
-        let high = price * (1.0 + rand::random::<f64>() * daily_volatility);
-        let low = price * (1.0 - rand::random::<f64>() * daily_volatility);
-        let open = low + (high - low) * rand::random::<f64>();
+        let high = price * (1.0 + rng.gen::<f64>() * daily_volatility);
+        let low = price * (1.0 - rng.gen::<f64>() * daily_volatility);
+        let open = low + (high - low) * rng.gen::<f64>();
 
         // Volume with some correlation to price movement
-        let volume_factor = 0.8 + 0.4 * rand::random::<f64>();
+        let volume_factor = 0.8 + 0.4 * rng.gen::<f64>();
         let volume = volume_base * volume_factor;
 
         data.push(StockData {
@@ -214,12 +233,21 @@ fn generate_stock_data(days: usize) -> Vec<StockData> {
     data
 }
 
+#[allow(dead_code)]
+pub(crate) fn demo_stock_closes(days: usize) -> Vec<f64> {
+    generate_stock_data(days)
+        .into_iter()
+        .map(|stock| stock.close)
+        .collect()
+}
+
 fn main() {
     println!("🏦 Stock Price Prediction with LSTM");
     println!("=====================================\n");
+    println!("This bounded demo favors quick execution over prediction quality.\n");
 
     // Generate synthetic stock data (in practice, you'd load real data)
-    let stock_data = generate_stock_data(500); // 500 days of data
+    let stock_data = generate_stock_data(DEMO_STOCK_DAYS); // Bounded synthetic dataset for a quick demo
     println!(
         "📈 Generated {} days of synthetic stock data",
         stock_data.len()
@@ -237,16 +265,16 @@ fn main() {
     }
 
     // Create and train predictor
-    let mut predictor = StockPredictor::new(20, 50); // 20-day sequences, 50 hidden units
+    let mut predictor = StockPredictor::new(DEMO_SEQUENCE_LENGTH, DEMO_HIDDEN_SIZE);
     predictor.train(&stock_data, 0.2); // 80% train, 20% validation
 
     // Make predictions on recent data
     println!("\n🔮 Making predictions...");
-    let recent_data = &stock_data[stock_data.len() - 30..]; // Last 30 days
+    let recent_window = DEMO_SEQUENCE_LENGTH * 2;
+    let recent_data = &stock_data[stock_data.len() - recent_window..];
 
-    for i in 20..25 {
-        // Predict for days 21-25 of recent data
-        let input_data = &recent_data[i - 20..i];
+    for i in DEMO_SEQUENCE_LENGTH..recent_window {
+        let input_data = &recent_data[i - DEMO_SEQUENCE_LENGTH..i];
         if let Some(predicted_price) = predictor.predict_next_price(input_data) {
             let actual_price = recent_data[i].close;
             let error = (predicted_price - actual_price).abs();

examples/training_example.rs

@@ -10,7 +10,45 @@ use ndarray::{arr2, Array2};
 use rust_lstm::loss::MSELoss;
 use rust_lstm::models::lstm_network::LSTMNetwork;
 use rust_lstm::optimizers::{Adam, SGD};
-use rust_lstm::training::LSTMTrainer;
+use rust_lstm::training::{LSTMTrainer, TrainingConfig};
+
+pub(crate) const DEMO_EPOCHS: usize = 5;
+pub(crate) const DEMO_PRINT_EVERY: usize = 1;
+
+pub(crate) fn demo_training_config() -> TrainingConfig {
+    TrainingConfig {
+        epochs: DEMO_EPOCHS,
+        print_every: DEMO_PRINT_EVERY,
+        log_lr_changes: false,
+        ..TrainingConfig::default()
+    }
+}
+
+pub(crate) fn demo_sgd_trainer(
+    input_size: usize,
+    hidden_size: usize,
+    num_layers: usize,
+) -> LSTMTrainer<MSELoss, SGD> {
+    LSTMTrainer::new(
+        LSTMNetwork::new(input_size, hidden_size, num_layers),
+        MSELoss,
+        SGD::new(0.01),
+    )
+    .with_config(demo_training_config())
+}
+
+pub(crate) fn demo_adam_trainer(
+    input_size: usize,
+    hidden_size: usize,
+    num_layers: usize,
+) -> LSTMTrainer<MSELoss, Adam> {
+    LSTMTrainer::new(
+        LSTMNetwork::new(input_size, hidden_size, num_layers),
+        MSELoss,
+        Adam::new(0.001),
+    )
+    .with_config(demo_training_config())
+}
 
 /// Generate sine wave training data for sequence prediction
 fn generate_sine_data(
@@ -86,8 +124,7 @@ fn main() {
 
     // Training with SGD
     println!("Training with SGD optimizer:");
-    let network = LSTMNetwork::new(input_size, hidden_size, num_layers);
-    let mut trainer_sgd = LSTMTrainer::new(network, MSELoss, SGD::new(0.01));
+    let mut trainer_sgd = demo_sgd_trainer(input_size, hidden_size, num_layers);
 
     trainer_sgd.train(&train_data, Some(&val_data));
 
@@ -108,8 +145,7 @@ fn main() {
 
     // Training with Adam
     println!("Training with Adam optimizer:");
-    let network = LSTMNetwork::new(input_size, hidden_size, num_layers);
-    let mut trainer_adam = LSTMTrainer::new(network, MSELoss, Adam::new(0.001));
+    let mut trainer_adam = demo_adam_trainer(input_size, hidden_size, num_layers);
 
     trainer_adam.train(&train_data, Some(&val_data));
 

tests/example_training_bounds_test.rs

@@ -0,0 +1,68 @@
+#[allow(dead_code)]
+#[path = "../examples/training_example.rs"]
+mod training_example;
+
+#[allow(dead_code)]
+#[path = "../examples/stock_prediction.rs"]
+mod stock_prediction;
+
+use std::hint::black_box;
+
+#[test]
+fn training_example_applies_bounded_config_to_both_demo_trainers() {
+    let sgd_trainer = training_example::demo_sgd_trainer(1, 10, 1);
+    let adam_trainer = training_example::demo_adam_trainer(1, 10, 1);
+
+    for epochs in [sgd_trainer.config.epochs, adam_trainer.config.epochs] {
+        assert!(
+            black_box(epochs) <= 5,
+            "training_example should keep both optimizer demos bounded"
+        );
+    }
+
+    for print_every in [
+        sgd_trainer.config.print_every,
+        adam_trainer.config.print_every,
+    ] {
+        assert!(
+            black_box(print_every) <= black_box(training_example::DEMO_EPOCHS),
+            "training_example should report progress without exceeding the epoch budget"
+        );
+    }
+}
+
+#[test]
+fn stock_prediction_applies_bounded_config_to_demo_trainer() {
+    let network =
+        rust_lstm::models::lstm_network::LSTMNetwork::new(5, stock_prediction::DEMO_HIDDEN_SIZE, 2);
+    let trainer = stock_prediction::demo_stock_trainer(network);
+
+    assert!(
+        black_box(trainer.config.epochs) <= 2,
+        "stock_prediction should avoid the default 100-epoch training config"
+    );
+    assert!(
+        black_box(stock_prediction::DEMO_STOCK_DAYS) <= 80,
+        "stock_prediction should keep its synthetic dataset bounded for interactive runs"
+    );
+    assert!(
+        black_box(stock_prediction::DEMO_SEQUENCE_LENGTH) <= 5,
+        "stock_prediction should keep sequence length bounded for interactive runs"
+    );
+    assert!(
+        black_box(stock_prediction::DEMO_HIDDEN_SIZE) <= 8,
+        "stock_prediction should keep hidden size bounded for interactive runs"
+    );
+}
+
+#[test]
+fn stock_prediction_demo_data_is_reproducible() {
+    let first = stock_prediction::demo_stock_closes(black_box(8));
+    let second = stock_prediction::demo_stock_closes(black_box(8));
+
+    assert_eq!(first, second, "seeded demo data should be reproducible");
+    assert!(
+        first.windows(2).any(|window| window[0] != window[1]),
+        "demo data should still vary across generated days"
+    );
+}