Struct Variable 

pub struct Variable { /* private fields */ }

A tensor with automatic differentiation support.

Variable wraps a Tensor and tracks operations performed on it to enable automatic gradient computation. When requires_grad is true, all operations are recorded in a computational graph.

Implementations

impl Variable

pub fn new(data: Tensor<f32>, requires_grad: bool) -> Variable

Creates a new variable from a tensor.

Arguments

• data - The tensor data
• requires_grad - Whether to track gradients for this variable

Examples found in repository

examples/hvac_model.rs (line 190)

    fn mean_pool(&self, x: &Variable) -> Variable {
        let data = x.data();
        let shape = data.shape();
        let batch_size = shape[0];
        let seq_len = shape[1];
        let hidden = shape[2];

        // Reshape to [batch * seq, hidden] then back
        let values = data.to_vec();

        // Calculate mean over sequence dimension
        let mut pooled = vec![0.0f32; batch_size * hidden];
        for b in 0..batch_size {
            for h in 0..hidden {
                let mut sum = 0.0;
                for s in 0..seq_len {
                    let idx = b * seq_len * hidden + s * hidden + h;
                    sum += values[idx];
                }
                pooled[b * hidden + h] = sum / seq_len as f32;
            }
        }

        let pooled_tensor = Tensor::from_vec(pooled, &[batch_size, hidden])
            .expect("Failed to create pooled tensor");
        Variable::new(pooled_tensor, x.requires_grad())
    }

    /// Forward pass returning logits for all 3 horizons
    pub fn forward_multi(&self, x: &Variable) -> HvacOutput {
        let x_data = x.data();
        let shape = x_data.shape();
        let batch_size = shape[0];
        let seq_len = shape[1];
        drop(x_data); // Release borrow

        // Input projection: [batch, seq, features] -> [batch, seq, hidden]
        // Reshape for linear: [batch * seq, features]
        let x_flat = x.reshape(&[batch_size * seq_len, self.config.num_features]);
        let proj = self.input_proj.forward(&x_flat);
        let proj = self.input_norm.forward(&proj);
        let proj = self.input_relu.forward(&proj);
        let proj = proj.reshape(&[batch_size, seq_len, self.config.hidden_size]);

        // GRU encoding: [batch, seq, hidden] -> [batch, seq, hidden]
        let encoded = self.gru.forward(&proj);

        // Mean pooling: [batch, seq, hidden] -> [batch, hidden]
        let pooled = self.mean_pool(&encoded);

        // Prediction heads
        let imminent_logits = self.head_imminent.forward(&pooled);
        let warning_logits = self.head_warning.forward(&pooled);
        let early_logits = self.head_early.forward(&pooled);

        HvacOutput {
            imminent_logits,
            warning_logits,
            early_logits,
        }
    }

    /// Get predicted classes (argmax of logits)
    pub fn predict(&self, x: &Variable) -> (Vec<usize>, Vec<usize>, Vec<usize>) {
        let output = self.forward_multi(x);

        let imminent_probs = self.softmax.forward(&output.imminent_logits);
        let warning_probs = self.softmax.forward(&output.warning_logits);
        let early_probs = self.softmax.forward(&output.early_logits);

        (
            argmax_batch(&imminent_probs),
            argmax_batch(&warning_probs),
            argmax_batch(&early_probs),
        )
    }

    /// Returns the model configuration
    pub fn config(&self) -> &HvacConfig {
        &self.config
    }

    /// Returns the number of trainable parameters
    pub fn num_parameters(&self) -> usize {
        self.parameters()
            .iter()
            .map(|p| p.variable().data().numel())
            .sum()
    }
}

impl Module for HvacPredictor {
    fn forward(&self, x: &Variable) -> Variable {
        // Return concatenated logits for all horizons
        let output = self.forward_multi(x);
        // For single output, return imminent predictions
        output.imminent_logits
    }

    fn parameters(&self) -> Vec<Parameter> {
        let mut params = self.input_proj.parameters();
        params.extend(self.input_norm.parameters());
        params.extend(self.gru.parameters());
        params.extend(self.head_imminent.parameters());
        params.extend(self.head_warning.parameters());
        params.extend(self.head_early.parameters());
        params
    }
}

// =============================================================================
// Helper Functions
// =============================================================================

/// Get argmax for each sample in batch
fn argmax_batch(x: &Variable) -> Vec<usize> {
    let data = x.data();
    let shape = data.shape();
    let batch_size = shape[0];
    let num_classes = shape[1];
    let values = data.to_vec();

    let mut results = Vec::with_capacity(batch_size);
    for b in 0..batch_size {
        let start = b * num_classes;
        let end = start + num_classes;
        let slice = &values[start..end];

        let mut max_idx = 0;
        let mut max_val = slice[0];
        for (i, &v) in slice.iter().enumerate() {
            if v > max_val {
                max_val = v;
                max_idx = i;
            }
        }
        results.push(max_idx);
    }
    results
}

/// Failure type names
pub const FAILURE_TYPES: [&str; 20] = [
    "normal",
    "pump_failure_hw_5",
    "pump_failure_hw_6",
    "pump_failure_cw_3",
    "pump_failure_cw_4",
    "pump_failure_2pipe_a",
    "pump_failure_2pipe_b",
    "pressure_low_hw",
    "pressure_high_hw",
    "pressure_low_cw",
    "pressure_high_cw",
    "temp_anomaly_hw_supply",
    "temp_anomaly_cw_supply",
    "temp_anomaly_space",
    "valve_stuck_1_3",
    "valve_stuck_2_3",
    "vfd_fault",
    "sensor_drift",
    "chiller_fault",
    "interlock_violation",
];

/// Feature names for the 28 sensor inputs
pub const FEATURE_NAMES: [&str; 28] = [
    "hw_pump_5_current",
    "hw_pump_6_current",
    "cw_pump_3_current",
    "cw_pump_4_current",
    "2pipe_pump_a_current",
    "2pipe_pump_b_current",
    "hw_supply_4pipe_temp",
    "cw_supply_4pipe_temp",
    "hw_supply_2pipe_temp",
    "cw_return_2pipe_temp",
    "outdoor_air_temp",
    "mech_room_temp",
    "space_sensor_1_temp",
    "space_sensor_2_temp",
    "hw_pressure_4pipe",
    "cw_pressure_4pipe",
    "hw_pump_5_vfd_speed",
    "hw_pump_6_vfd_speed",
    "cw_pump_3_vfd_speed",
    "cw_pump_4_vfd_speed",
    "2pipe_pump_a_vfd_speed",
    "2pipe_pump_b_vfd_speed",
    "steam_valve_1_3_pos",
    "steam_valve_2_3_pos",
    "summer_winter_mode",
    "hw_lead_pump_id",
    "cw_lead_pump_id",
    "2pipe_lead_pump_id",
];

// =============================================================================
// Main
// =============================================================================

fn main() {
    println!("╔════════════════════════════════════════════════════════════╗");
    println!("║     HVAC Multi-Horizon Predictor - AxonML Native           ║");
    println!("╚════════════════════════════════════════════════════════════╝");
    println!();

    // Create model with default config
    let config = HvacConfig::default();
    println!("Model Configuration:");
    println!("  Input features: {}", config.num_features);
    println!("  Sequence length: {}", config.seq_len);
    println!("  Hidden size: {}", config.hidden_size);
    println!("  GRU layers: {}", config.num_layers);
    println!("  Output classes: {}", config.num_classes);
    println!("  Dropout: {}", config.dropout);
    println!();

    let model = HvacPredictor::new(config.clone());
    println!("Model created!");
    println!("  Total parameters: {}", model.num_parameters());
    println!();

    // Create sample input
    let batch_size = 2;
    let mut input_data = vec![0.5f32; batch_size * config.seq_len * config.num_features];

    // Simulate normal HVAC readings
    for b in 0..batch_size {
        for t in 0..config.seq_len {
            let base = (b * config.seq_len + t) * config.num_features;
            // Pump currents ~25A (normalized)
            for i in 0..6 {
                input_data[base + i] = 0.5;
            }
            // Temperatures (normalized)
            input_data[base + 6] = 0.83; // HW supply ~180F
            input_data[base + 7] = 0.375; // CW supply ~55F
            // VFD speeds ~60%
            for i in 16..22 {
                input_data[base + i] = 0.6;
            }
        }
    }

    let input = Tensor::from_vec(
        input_data,
        &[batch_size, config.seq_len, config.num_features],
    )
    .expect("Failed to create input tensor");

    let input_var = Variable::new(input, false);
    println!("Input shape: {:?}", input_var.data().shape());

    // Run inference
    println!();
    println!("Running inference...");
    let (imminent, warning, early) = model.predict(&input_var);

    println!();
    println!("Predictions:");
    println!("────────────────────────────────────────────────────────────");
    for b in 0..batch_size {
        println!("Sample {}:", b);
        println!(
            "  5 min (Imminent): {} - {}",
            imminent[b], FAILURE_TYPES[imminent[b]]
        );
        println!(
            "  15 min (Warning): {} - {}",
            warning[b], FAILURE_TYPES[warning[b]]
        );
        println!(
            "  30 min (Early):   {} - {}",
            early[b], FAILURE_TYPES[early[b]]
        );
    }
    println!("────────────────────────────────────────────────────────────");
    println!();
    println!("Model ready for training with your HVAC sensor data!");
}

examples/hvac_training.rs (line 779)

fn train_epoch(
    model: &HvacPredictor,
    optimizer: &mut Adam,
    loss_fn: &CrossEntropyLoss,
    x_data: &[f32],
    y_imminent: &[i64],
    y_warning: &[i64],
    y_early: &[i64],
    batch_size: usize,
    seq_len: usize,
    num_features: usize,
) -> (f32, f32, f32, f32) {
    let n_sequences = y_imminent.len();
    let n_batches = n_sequences / batch_size;

    let mut total_loss = 0.0f32;
    let mut total_acc_imm = 0.0f32;
    let mut total_acc_warn = 0.0f32;
    let mut total_acc_early = 0.0f32;

    for batch_idx in 0..n_batches {
        let start = batch_idx * batch_size;

        // Prepare batch data
        let mut batch_x = vec![0.0f32; batch_size * seq_len * num_features];
        let mut batch_y_imm = vec![0i64; batch_size];
        let mut batch_y_warn = vec![0i64; batch_size];
        let mut batch_y_early = vec![0i64; batch_size];

        for b in 0..batch_size {
            let seq_start = (start + b) * seq_len * num_features;
            for i in 0..(seq_len * num_features) {
                batch_x[b * seq_len * num_features + i] = x_data[seq_start + i];
            }
            batch_y_imm[b] = y_imminent[start + b];
            batch_y_warn[b] = y_warning[start + b];
            batch_y_early[b] = y_early[start + b];
        }

        // Create tensors
        let x_tensor = Tensor::from_vec(batch_x, &[batch_size, seq_len, num_features])
            .expect("Failed to create input tensor");
        let x_var = Variable::new(x_tensor, true);

        // Forward pass
        let (logits_imm, logits_warn, logits_early) = model.forward_multi(&x_var);

        // Calculate losses (simplified - just use imminent for now)
        let y_imm_tensor = Tensor::from_vec(
            batch_y_imm.iter().map(|&y| y as f32).collect(),
            &[batch_size],
        )
        .expect("Failed to create label tensor");
        let y_imm_var = Variable::new(y_imm_tensor, false);

        let loss = loss_fn.compute(&logits_imm, &y_imm_var);

        // Backward pass
        optimizer.zero_grad();
        loss.backward();
        optimizer.step();

        // Metrics
        total_loss += loss.data().to_vec()[0];
        total_acc_imm += calculate_accuracy(&logits_imm, &batch_y_imm);
        total_acc_warn += calculate_accuracy(&logits_warn, &batch_y_warn);
        total_acc_early += calculate_accuracy(&logits_early, &batch_y_early);
    }

    let n = n_batches as f32;
    (
        total_loss / n,
        total_acc_imm / n,
        total_acc_warn / n,
        total_acc_early / n,
    )
}

examples/simple_training.rs (line 62)

fn main() {
    println!("=== Axonml ML Framework - Simple Training Example ===\n");

    // Print version and features
    println!("Version: {}", axonml::version());
    println!("Features: {}\n", axonml::features());

    // 1. Create a simple dataset (XOR problem)
    println!("1. Creating XOR dataset...");
    let inputs = vec![
        vec![0.0, 0.0],
        vec![0.0, 1.0],
        vec![1.0, 0.0],
        vec![1.0, 1.0],
    ];
    let targets = vec![0.0, 1.0, 1.0, 0.0]; // XOR outputs

    println!("   Inputs: {inputs:?}");
    println!("   Targets: {targets:?}\n");

    // 2. Create a simple MLP model
    println!("2. Creating MLP model (2 -> 4 -> 1)...");
    let linear1 = Linear::new(2, 4);
    let linear2 = Linear::new(4, 1);

    println!("   Layer 1: Linear(2, 4)");
    println!("   Layer 2: Linear(4, 1)\n");

    // 3. Create optimizer
    println!("3. Creating Adam optimizer (lr=0.1)...");
    let params = [linear1.parameters(), linear2.parameters()].concat();
    let mut optimizer = Adam::new(params, 0.1);
    println!("   Optimizer created!\n");

    // 4. Training loop
    println!("4. Training for 1000 epochs...");
    let epochs = 1000;

    for epoch in 0..epochs {
        let mut total_loss = 0.0;

        for (input, &target) in inputs.iter().zip(targets.iter()) {
            // Create input tensor
            let x = Variable::new(Tensor::from_vec(input.clone(), &[1, 2]).unwrap(), true);

            // Forward pass
            let h = linear1.forward(&x);
            let h = h.sigmoid();
            let output = linear2.forward(&h);
            let output = output.sigmoid();

            // Create target tensor
            let y = Variable::new(Tensor::from_vec(vec![target], &[1, 1]).unwrap(), false);

            // Compute MSE loss manually: (output - target)^2
            let diff = output.sub_var(&y);
            let loss = diff.mul_var(&diff);

            total_loss += loss.data().to_vec()[0];

            // Backward pass
            loss.backward();

            // Update weights
            optimizer.step();
            optimizer.zero_grad();
        }

        if epoch % 200 == 0 || epoch == epochs - 1 {
            println!("   Epoch {}: Loss = {:.6}", epoch, total_loss / 4.0);
        }
    }

    // 5. Test the trained model
    println!("\n5. Testing trained model...");
    for (input, &expected) in inputs.iter().zip(targets.iter()) {
        let x = Variable::new(Tensor::from_vec(input.clone(), &[1, 2]).unwrap(), false);

        let h = linear1.forward(&x);
        let h = h.sigmoid();
        let output = linear2.forward(&h);
        let output = output.sigmoid();

        let pred = output.data().to_vec()[0];
        let rounded = if pred > 0.5 { 1.0 } else { 0.0 };

        println!(
            "   Input: {input:?} -> Predicted: {pred:.4} (rounded: {rounded}) | Expected: {expected}"
        );
    }

    println!("\n=== Training Complete! ===");
}

examples/mnist_training.rs (lines 95-102)

fn main() {
    println!("=== AxonML - MNIST Training (LeNet) ===\n");

    // Detect device
    #[cfg(feature = "cuda")]
    let device = {
        let cuda = Device::Cuda(0);
        if cuda.is_available() {
            println!("GPU detected: using CUDA device 0");
            cuda
        } else {
            println!("CUDA feature enabled but no GPU available, using CPU");
            Device::Cpu
        }
    };
    #[cfg(not(feature = "cuda"))]
    let device = {
        println!("Using CPU (compile with --features cuda for GPU)");
        Device::Cpu
    };

    // 1. Create dataset
    let num_train = 2000;
    let num_test = 400;
    println!("\n1. Creating SyntheticMNIST dataset ({num_train} train, {num_test} test)...");
    let train_dataset = SyntheticMNIST::new(num_train);
    let test_dataset = SyntheticMNIST::new(num_test);

    // 2. Create DataLoader
    let batch_size = 64;
    println!("2. Creating DataLoader (batch_size={batch_size})...");
    let train_loader = DataLoader::new(train_dataset, batch_size);
    let test_loader = DataLoader::new(test_dataset, batch_size);
    println!("   Training batches: {}", train_loader.len());

    // 3. Create LeNet model and move to device
    println!("3. Creating LeNet model...");
    let model = LeNet::new();
    model.to_device(device);
    let params = model.parameters();
    let total_params: usize = params
        .iter()
        .map(|p| p.variable().data().to_vec().len())
        .sum();
    println!(
        "   Parameters: {} ({} total weights)",
        params.len(),
        total_params
    );
    println!("   Device: {:?}", device);

    // 4. Create optimizer and loss
    println!("4. Creating Adam optimizer (lr=0.001) + CrossEntropyLoss...");
    let mut optimizer = Adam::new(params, 0.001);
    let criterion = CrossEntropyLoss::new();

    // 5. Training loop
    let epochs = 10;
    println!("5. Training for {epochs} epochs...\n");

    let train_start = Instant::now();

    for epoch in 0..epochs {
        let epoch_start = Instant::now();
        let mut total_loss = 0.0;
        let mut correct = 0usize;
        let mut total = 0usize;
        let mut batch_count = 0;

        for batch in train_loader.iter() {
            let bs = batch.data.shape()[0];

            // Reshape to [N, 1, 28, 28] and create Variable
            let input_data = batch.data.to_vec();
            let input_tensor = Tensor::from_vec(input_data, &[bs, 1, 28, 28]).unwrap();
            let input = Variable::new(
                if device.is_gpu() {
                    input_tensor.to_device(device).unwrap()
                } else {
                    input_tensor
                },
                true,
            );

            // Target: convert one-hot [N, 10] to class indices [N]
            let target_onehot = batch.targets.to_vec();
            let mut target_indices = vec![0.0f32; bs];
            for i in 0..bs {
                let offset = i * 10;
                let mut max_idx = 0;
                let mut max_val = f32::NEG_INFINITY;
                for c in 0..10 {
                    if target_onehot[offset + c] > max_val {
                        max_val = target_onehot[offset + c];
                        max_idx = c;
                    }
                }
                target_indices[i] = max_idx as f32;
            }
            let target_tensor = Tensor::from_vec(target_indices.clone(), &[bs]).unwrap();
            let target = Variable::new(
                if device.is_gpu() {
                    target_tensor.to_device(device).unwrap()
                } else {
                    target_tensor
                },
                false,
            );

            // Forward pass
            let output = model.forward(&input);

            // Cross-entropy loss
            let loss = criterion.compute(&output, &target);

            let loss_val = loss.data().to_vec()[0];
            total_loss += loss_val;
            batch_count += 1;

            // Compute training accuracy
            let out_data = output.data().to_vec();
            for i in 0..bs {
                let offset = i * 10;
                let mut pred = 0;
                let mut pred_val = f32::NEG_INFINITY;
                for c in 0..10 {
                    if out_data[offset + c] > pred_val {
                        pred_val = out_data[offset + c];
                        pred = c;
                    }
                }
                if pred == target_indices[i] as usize {
                    correct += 1;
                }
                total += 1;
            }

            // Backward pass
            loss.backward();

            // Update weights
            optimizer.step();
            optimizer.zero_grad();
        }

        let epoch_time = epoch_start.elapsed();
        let avg_loss = total_loss / batch_count as f32;
        let accuracy = 100.0 * correct as f32 / total as f32;
        let samples_per_sec = total as f64 / epoch_time.as_secs_f64();

        println!(
            "   Epoch {:2}/{}: Loss={:.4}  Acc={:.1}%  ({:.0} samples/s, {:.2}s)",
            epoch + 1,
            epochs,
            avg_loss,
            accuracy,
            samples_per_sec,
            epoch_time.as_secs_f64(),
        );
    }

    let train_time = train_start.elapsed();
    println!("\n   Total training time: {:.2}s", train_time.as_secs_f64());

    // 6. Test evaluation
    println!("\n6. Evaluating on test set...");

    // Disable gradient computation for evaluation
    let (correct, total) = no_grad(|| {
        let mut correct = 0usize;
        let mut total = 0usize;

        for batch in test_loader.iter() {
            let bs = batch.data.shape()[0];

            let input_data = batch.data.to_vec();
            let input_tensor = Tensor::from_vec(input_data, &[bs, 1, 28, 28]).unwrap();
            let input = Variable::new(
                if device.is_gpu() {
                    input_tensor.to_device(device).unwrap()
                } else {
                    input_tensor
                },
                false,
            );

            let target_onehot = batch.targets.to_vec();
            let output = model.forward(&input);
            let out_data = output.data().to_vec();

            for i in 0..bs {
                // Prediction: argmax of output
                let offset = i * 10;
                let mut pred = 0;
                let mut pred_val = f32::NEG_INFINITY;
                for c in 0..10 {
                    if out_data[offset + c] > pred_val {
                        pred_val = out_data[offset + c];
                        pred = c;
                    }
                }

                // True label: argmax of one-hot target
                let mut true_label = 0;
                let mut true_val = f32::NEG_INFINITY;
                for c in 0..10 {
                    if target_onehot[i * 10 + c] > true_val {
                        true_val = target_onehot[i * 10 + c];
                        true_label = c;
                    }
                }

                if pred == true_label {
                    correct += 1;
                }
                total += 1;
            }
        }

        (correct, total)
    });

    let test_accuracy = 100.0 * correct as f32 / total as f32;
    println!(
        "   Test Accuracy: {}/{} ({:.2}%)",
        correct, total, test_accuracy
    );

    println!("\n=== Training Complete! ===");
    println!("   Device: {:?}", device);
    println!("   Final test accuracy: {:.2}%", test_accuracy);
}

examples/train_panoptes.rs (lines 98-101)

fn main() {
    println!("╔══════════════════════════════════════════════════════════════╗");
    println!("║     PANOPTES — Facility-Wide Anomaly Detection Training     ║");
    println!("║     Heritage Pointe of Warren (59 equipment)                ║");
    println!("╚══════════════════════════════════════════════════════════════╝");
    println!();

    // =========================================================================
    // Generate training data
    // =========================================================================
    println!("[data] Generating physics-informed training data...");
    let t0 = Instant::now();

    let sim = WarrenSimulator::new(SEED);
    let normal_train = sim.generate_normal(NORMAL_SAMPLES);
    let fault_data = sim.generate_with_faults(FAULT_SAMPLES, 1.0);

    // Validation set (different seed)
    let val_sim = WarrenSimulator::new(SEED + 999);
    let normal_val = val_sim.generate_normal(200);
    let fault_val = val_sim.generate_with_faults(100, 1.0);

    println!("  Normal train: {} samples", normal_train.len());
    println!("  Fault train:  {} samples", fault_data.len());
    println!("  Normal val:   {} samples", normal_val.len());
    println!("  Fault val:    {} samples", fault_val.len());
    println!("  Generated in {:.1}s", t0.elapsed().as_secs_f32());
    println!();

    // =========================================================================
    // Create model
    // =========================================================================
    let model = Panoptes::new(NUM_EQUIPMENT);
    println!("[model] Panoptes created");
    println!("  Equipment slots: {NUM_EQUIPMENT}");
    println!("  Parameters: {}", model.num_parameters());
    println!("  Embed dim: {EMBED_DIM}");
    println!();

    let mse = MSELoss::new();

    // Zero target for normal operation
    let zero_target = Variable::new(
        Tensor::from_vec(vec![0.0; NUM_EQUIPMENT], &[1, NUM_EQUIPMENT]).unwrap(),
        false,
    );

    // =========================================================================
    // Phase 1: Learn normal operation
    // =========================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!(" PHASE 1: Learning Normal Operation ({PHASE1_EPOCHS} epochs)");
    println!("═══════════════════════════════════════════════════════════════");
    println!(
        "  {:>5}  {:>12}  {:>12}  {:>8}",
        "Epoch", "Train Loss", "Val Loss", "Time"
    );
    println!("  {:-<5}  {:-<12}  {:-<12}  {:-<8}", "", "", "", "");

    let params = model.parameters();
    let mut optimizer = Adam::new(params, LR);

    for epoch in 1..=PHASE1_EPOCHS {
        let epoch_start = Instant::now();
        let mut epoch_loss = 0.0f32;
        let mut batch_count = 0;

        // Train on normal data: target = all zeros
        for batch_start in (0..normal_train.len()).step_by(BATCH_SIZE) {
            let batch_end = (batch_start + BATCH_SIZE).min(normal_train.len());

            for i in batch_start..batch_end {
                optimizer.zero_grad();

                let (equip_scores, _) = model.forward_snapshot(&normal_train[i]);
                let loss = mse.compute(&equip_scores, &zero_target);
                let loss_val = loss.data().to_vec()[0];
                epoch_loss += loss_val;
                batch_count += 1;

                if loss.requires_grad() {
                    loss.backward();
                    optimizer.step();
                }
            }
        }

        // Validation
        let val_loss = evaluate_normal(&model, &normal_val, &mse, &zero_target);

        let avg_loss = epoch_loss / batch_count as f32;
        let elapsed = epoch_start.elapsed().as_secs_f32();

        println!(
            "  {:>5}  {:>12.6}  {:>12.6}  {:>6.1}s",
            epoch, avg_loss, val_loss, elapsed
        );
    }

    println!();

    // =========================================================================
    // Phase 2: Learn fault signatures
    // =========================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!(" PHASE 2: Learning Fault Signatures ({PHASE2_EPOCHS} epochs)");
    println!("═══════════════════════════════════════════════════════════════");
    println!(
        "  {:>5}  {:>12}  {:>12}  {:>12}  {:>8}",
        "Epoch", "Normal Loss", "Fault Loss", "Val Loss", "Time"
    );
    println!(
        "  {:-<5}  {:-<12}  {:-<12}  {:-<12}  {:-<8}",
        "", "", "", "", ""
    );

    // Reset optimizer with lower LR for phase 2
    let params = model.parameters();
    let mut optimizer = Adam::new(params, LR * 0.5);

    for epoch in 1..=PHASE2_EPOCHS {
        let epoch_start = Instant::now();
        let mut normal_loss_sum = 0.0f32;
        let mut fault_loss_sum = 0.0f32;
        let mut normal_count = 0;
        let mut fault_count = 0;

        // Interleave normal + fault samples
        let normal_per_epoch = NORMAL_SAMPLES / 2; // Use half of normal data
        let fault_per_epoch = fault_data.len();

        // Normal samples: target = zeros
        for i in 0..normal_per_epoch.min(normal_train.len()) {
            optimizer.zero_grad();
            let (equip_scores, _) = model.forward_snapshot(&normal_train[i]);
            let loss = mse.compute(&equip_scores, &zero_target);
            normal_loss_sum += loss.data().to_vec()[0];
            normal_count += 1;

            if loss.requires_grad() {
                loss.backward();
                optimizer.step();
            }
        }

        // Fault samples: target = 1.0 for affected equipment
        for i in 0..fault_per_epoch {
            let (ref snap, ref _fault, ref affected) = fault_data[i];

            let target_vec = PanoptesTrainingData::fault_target(NUM_EQUIPMENT, affected);
            let fault_target = Variable::new(
                Tensor::from_vec(target_vec, &[1, NUM_EQUIPMENT]).unwrap(),
                false,
            );

            optimizer.zero_grad();
            let (equip_scores, _) = model.forward_snapshot(snap);
            let loss = mse.compute(&equip_scores, &fault_target);
            fault_loss_sum += loss.data().to_vec()[0];
            fault_count += 1;

            if loss.requires_grad() {
                loss.backward();
                optimizer.step();
            }
        }

        // Validation
        let val_loss = evaluate_mixed(&model, &normal_val, &fault_val, &mse, &zero_target);

        let avg_normal = normal_loss_sum / normal_count.max(1) as f32;
        let avg_fault = fault_loss_sum / fault_count.max(1) as f32;
        let elapsed = epoch_start.elapsed().as_secs_f32();

        println!(
            "  {:>5}  {:>12.6}  {:>12.6}  {:>12.6}  {:>6.1}s",
            epoch, avg_normal, avg_fault, val_loss, elapsed
        );
    }

    println!();

    // =========================================================================
    // Phase 3: Temporal training
    // =========================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!(" PHASE 3: Temporal Training ({PHASE3_EPOCHS} epochs, window={TEMPORAL_WINDOW})");
    println!("═══════════════════════════════════════════════════════════════");

    // Generate temporal sequences
    println!("[data] Generating temporal sequences...");
    let t0 = Instant::now();

    // Normal temporal sequences: varied starting OAT, slow drift
    let mut normal_seqs: Vec<Vec<FacilitySnapshot>> = Vec::new();
    for i in 0..TEMPORAL_NORMAL_SEQS {
        let start_oat = -5.0 + (i as f32 / TEMPORAL_NORMAL_SEQS as f32) * 100.0;
        let drift = if start_oat < 50.0 { 0.2 } else { -0.1 }; // warming up or cooling down
        let seq_sim = WarrenSimulator::new(SEED + 5000 + i as u64);
        let seq = seq_sim.generate_temporal_sequence(TEMPORAL_WINDOW, start_oat, drift);
        normal_seqs.push(seq);
    }

    // Fault temporal sequences: fault injected mid-sequence
    let mut fault_seqs: Vec<(Vec<FacilitySnapshot>, usize, FaultType, Vec<usize>)> = Vec::new();
    for i in 0..TEMPORAL_FAULT_SEQS {
        let start_oat = -5.0 + (i as f32 / TEMPORAL_FAULT_SEQS as f32) * 100.0;
        let drift = 0.1;
        let seq_sim = WarrenSimulator::new(SEED + 8000 + i as u64);
        let seq_data =
            seq_sim.generate_temporal_with_fault(TEMPORAL_WINDOW, start_oat, drift, i as u64);
        fault_seqs.push(seq_data);
    }

    // Validation temporal sequences
    let mut val_normal_seqs: Vec<Vec<FacilitySnapshot>> = Vec::new();
    for i in 0..20 {
        let start_oat = 10.0 + (i as f32 / 20.0) * 80.0;
        let seq_sim = WarrenSimulator::new(SEED + 9000 + i as u64);
        let seq = seq_sim.generate_temporal_sequence(TEMPORAL_WINDOW, start_oat, 0.15);
        val_normal_seqs.push(seq);
    }

    let mut val_fault_seqs: Vec<(Vec<FacilitySnapshot>, usize, FaultType, Vec<usize>)> = Vec::new();
    for i in 0..20 {
        let start_oat = 10.0 + (i as f32 / 20.0) * 80.0;
        let seq_sim = WarrenSimulator::new(SEED + 9500 + i as u64);
        let seq_data =
            seq_sim.generate_temporal_with_fault(TEMPORAL_WINDOW, start_oat, 0.1, i as u64);
        val_fault_seqs.push(seq_data);
    }

    println!("  Normal temporal seqs: {}", normal_seqs.len());
    println!("  Fault temporal seqs:  {}", fault_seqs.len());
    println!("  Val normal seqs:      {}", val_normal_seqs.len());
    println!("  Val fault seqs:       {}", val_fault_seqs.len());
    println!("  Window size: {TEMPORAL_WINDOW} snapshots (1 hour)");
    println!("  Generated in {:.1}s", t0.elapsed().as_secs_f32());
    println!();

    println!(
        "  {:>5}  {:>12}  {:>12}  {:>12}  {:>8}",
        "Epoch", "Normal Loss", "Fault Loss", "Val Loss", "Time"
    );
    println!(
        "  {:-<5}  {:-<12}  {:-<12}  {:-<12}  {:-<8}",
        "", "", "", "", ""
    );

    // Lower LR for temporal fine-tuning
    let params = model.parameters();
    let mut optimizer = Adam::new(params, LR * 0.3);

    for epoch in 1..=PHASE3_EPOCHS {
        let epoch_start = Instant::now();
        let mut normal_loss_sum = 0.0f32;
        let mut fault_loss_sum = 0.0f32;
        let mut normal_count = 0;
        let mut fault_count = 0;

        // Normal temporal sequences: target = all zeros
        for seq in &normal_seqs {
            optimizer.zero_grad();
            let (equip_scores, _) = model.forward_temporal(seq);
            let loss = mse.compute(&equip_scores, &zero_target);
            normal_loss_sum += loss.data().to_vec()[0];
            normal_count += 1;

            if loss.requires_grad() {
                loss.backward();
                optimizer.step();
            }
        }

        // Fault temporal sequences: target = 1.0 for affected equipment
        for (seq, _onset, _fault, affected) in &fault_seqs {
            let target_vec = PanoptesTrainingData::fault_target(NUM_EQUIPMENT, affected);
            let fault_target = Variable::new(
                Tensor::from_vec(target_vec, &[1, NUM_EQUIPMENT]).unwrap(),
                false,
            );

            optimizer.zero_grad();
            let (equip_scores, _) = model.forward_temporal(seq);
            let loss = mse.compute(&equip_scores, &fault_target);
            fault_loss_sum += loss.data().to_vec()[0];
            fault_count += 1;

            if loss.requires_grad() {
                loss.backward();
                optimizer.step();
            }
        }

        // Validation
        let val_loss = evaluate_temporal_mixed(
            &model,
            &val_normal_seqs,
            &val_fault_seqs,
            &mse,
            &zero_target,
        );

        let avg_normal = normal_loss_sum / normal_count.max(1) as f32;
        let avg_fault = fault_loss_sum / fault_count.max(1) as f32;
        let elapsed = epoch_start.elapsed().as_secs_f32();

        println!(
            "  {:>5}  {:>12.6}  {:>12.6}  {:>12.6}  {:>6.1}s",
            epoch, avg_normal, avg_fault, val_loss, elapsed
        );
    }

    println!();

    // =========================================================================
    // Final evaluation
    // =========================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!(" FINAL EVALUATION");
    println!("═══════════════════════════════════════════════════════════════");

    // Test on normal data — scores should be near zero
    let config = FacilityConfig::warren();
    println!("\n  Normal operation (should be low scores):");
    for i in [0, 50, 100, 150] {
        if i >= normal_val.len() {
            break;
        }
        let (equip_scores, fac_score) = model.forward_snapshot(&normal_val[i]);
        let scores = equip_scores.data().to_vec();
        let fac = fac_score.data().to_vec()[0];
        let max_score = scores.iter().cloned().fold(0.0f32, f32::max);
        let avg_score: f32 = scores.iter().sum::<f32>() / scores.len() as f32;
        println!(
            "    Sample {i:>3}: facility={fac:.4}, avg_equip={avg_score:.4}, max_equip={max_score:.4}"
        );
    }

    // Test on fault data — affected equipment should have higher scores
    println!("\n  Fault samples (affected equipment should score higher):");
    for i in 0..5.min(fault_val.len()) {
        let (ref snap, ref fault, ref affected) = fault_val[i];
        let (equip_scores, fac_score) = model.forward_snapshot(snap);
        let scores = equip_scores.data().to_vec();
        let fac = fac_score.data().to_vec()[0];

        let output = PanoptesOutput::from_scores(&scores, fac, &config, 0.3);

        // Get scores for affected vs unaffected
        let affected_avg: f32 = if !affected.is_empty() {
            affected
                .iter()
                .filter(|&&s| s < scores.len())
                .map(|&s| scores[s])
                .sum::<f32>()
                / affected.len() as f32
        } else {
            0.0
        };

        println!("    Fault {:?}:", fault);
        println!(
            "      facility={fac:.4}, affected_avg={affected_avg:.4}, alerts={}",
            output.alerts.len()
        );
    }

    // Temporal evaluation
    println!("\n  Temporal normal (should be low scores):");
    for i in 0..3.min(val_normal_seqs.len()) {
        let (equip_scores, fac_score) = model.forward_temporal(&val_normal_seqs[i]);
        let scores = equip_scores.data().to_vec();
        let fac = fac_score.data().to_vec()[0];
        let max_score = scores.iter().cloned().fold(0.0f32, f32::max);
        let avg_score: f32 = scores.iter().sum::<f32>() / scores.len() as f32;
        println!(
            "    Seq {i:>3}: facility={fac:.4}, avg_equip={avg_score:.4}, max_equip={max_score:.4}"
        );
    }

    println!("\n  Temporal fault (fault injected mid-sequence):");
    for i in 0..5.min(val_fault_seqs.len()) {
        let (ref seq, onset, ref fault, ref affected) = val_fault_seqs[i];
        let (equip_scores, fac_score) = model.forward_temporal(seq);
        let scores = equip_scores.data().to_vec();
        let fac = fac_score.data().to_vec()[0];

        let affected_avg: f32 = if !affected.is_empty() {
            affected
                .iter()
                .filter(|&&s| s < scores.len())
                .map(|&s| scores[s])
                .sum::<f32>()
                / affected.len() as f32
        } else {
            0.0
        };
        let unaffected_avg: f32 = {
            let unaffected: Vec<f32> = scores
                .iter()
                .enumerate()
                .filter(|(idx, _)| !affected.contains(idx))
                .map(|(_, &s)| s)
                .collect();
            if unaffected.is_empty() {
                0.0
            } else {
                unaffected.iter().sum::<f32>() / unaffected.len() as f32
            }
        };

        let output = PanoptesOutput::from_scores(&scores, fac, &config, 0.3);
        println!(
            "    Fault {:?} (onset step {onset}/{TEMPORAL_WINDOW}):",
            fault
        );
        println!(
            "      facility={fac:.4}, affected={affected_avg:.4}, unaffected={unaffected_avg:.4}, alerts={}",
            output.alerts.len()
        );
    }

    println!();
    println!("Training complete.");
}

// =============================================================================
// Evaluation helpers
// =============================================================================

fn evaluate_normal(
    model: &Panoptes,
    val_data: &[FacilitySnapshot],
    mse: &MSELoss,
    zero_target: &Variable,
) -> f32 {
    let mut total_loss = 0.0f32;
    for snap in val_data {
        let (equip_scores, _) = model.forward_snapshot(snap);
        let loss = mse.compute(&equip_scores, zero_target);
        total_loss += loss.data().to_vec()[0];
    }
    total_loss / val_data.len() as f32
}

fn evaluate_mixed(
    model: &Panoptes,
    normal_val: &[FacilitySnapshot],
    fault_val: &[(FacilitySnapshot, FaultType, Vec<usize>)],
    mse: &MSELoss,
    zero_target: &Variable,
) -> f32 {
    let mut total_loss = 0.0f32;
    let mut count = 0;

    for snap in normal_val {
        let (equip_scores, _) = model.forward_snapshot(snap);
        let loss = mse.compute(&equip_scores, zero_target);
        total_loss += loss.data().to_vec()[0];
        count += 1;
    }

    for (snap, _, affected) in fault_val {
        let target_vec = PanoptesTrainingData::fault_target(NUM_EQUIPMENT, affected);
        let fault_target = Variable::new(
            Tensor::from_vec(target_vec, &[1, NUM_EQUIPMENT]).unwrap(),
            false,
        );
        let (equip_scores, _) = model.forward_snapshot(snap);
        let loss = mse.compute(&equip_scores, &fault_target);
        total_loss += loss.data().to_vec()[0];
        count += 1;
    }

    total_loss / count as f32
}

fn evaluate_temporal_mixed(
    model: &Panoptes,
    normal_seqs: &[Vec<FacilitySnapshot>],
    fault_seqs: &[(Vec<FacilitySnapshot>, usize, FaultType, Vec<usize>)],
    mse: &MSELoss,
    zero_target: &Variable,
) -> f32 {
    let mut total_loss = 0.0f32;
    let mut count = 0;

    for seq in normal_seqs {
        let (equip_scores, _) = model.forward_temporal(seq);
        let loss = mse.compute(&equip_scores, zero_target);
        total_loss += loss.data().to_vec()[0];
        count += 1;
    }

    for (seq, _, _, affected) in fault_seqs {
        let target_vec = PanoptesTrainingData::fault_target(NUM_EQUIPMENT, affected);
        let fault_target = Variable::new(
            Tensor::from_vec(target_vec, &[1, NUM_EQUIPMENT]).unwrap(),
            false,
        );
        let (equip_scores, _) = model.forward_temporal(seq);
        let loss = mse.compute(&equip_scores, &fault_target);
        total_loss += loss.data().to_vec()[0];
        count += 1;
    }

    total_loss / count as f32
}

pub fn from_tensor(data: Tensor<f32>) -> Variable

Creates a variable that doesn’t require gradients.

pub fn from_operation( data: Tensor<f32>, grad_fn: GradFn, requires_grad: bool, ) -> Variable

Creates a new variable from an operation result with an attached gradient function.

This connects the variable to the computational graph, allowing gradients to flow backward through the operation that produced this variable.

pub fn data(&self) -> Tensor<f32>

Returns a reference to the underlying tensor data.

Examples found in repository

examples/hvac_training.rs (line 617)

    pub fn forward_multi(&self, x: &Variable) -> (Variable, Variable, Variable) {
        let x_data = x.data();
        let shape = x_data.shape();
        let batch_size = shape[0];
        let seq_len = shape[1];
        drop(x_data);

        let x_flat = x.reshape(&[batch_size * seq_len, self.config.num_features]);
        let proj = self.input_proj.forward(&x_flat);
        let proj = self.input_norm.forward(&proj);
        let proj = self.input_relu.forward(&proj);
        let proj = proj.reshape(&[batch_size, seq_len, self.config.hidden_size]);

        // Use forward_mean for proper gradient flow (equivalent to forward + mean_pool)
        let pooled = self.gru.forward_mean(&proj);

        let imminent = self.head_imminent.forward(&pooled);
        let warning = self.head_warning.forward(&pooled);
        let early = self.head_early.forward(&pooled);

        (imminent, warning, early)
    }

    pub fn num_parameters(&self) -> usize {
        self.parameters()
            .iter()
            .map(|p| p.variable().data().numel())
            .sum()
    }
}

impl Module for HvacPredictor {
    fn forward(&self, x: &Variable) -> Variable {
        let (imminent, _, _) = self.forward_multi(x);
        imminent
    }

    fn parameters(&self) -> Vec<Parameter> {
        let mut params = self.input_proj.parameters();
        params.extend(self.input_norm.parameters());
        params.extend(self.gru.parameters());
        params.extend(self.head_imminent.parameters());
        params.extend(self.head_warning.parameters());
        params.extend(self.head_early.parameters());
        params
    }
}

// =============================================================================
// Training Loop
// =============================================================================

/// Normalize data to [0, 1] range based on sensor ranges
fn normalize_data(data: &mut [f32], n_samples: usize) {
    let sensor_ranges: [(f32, f32); 28] = [
        (0.0, 50.0),    // 0: hw_pump_5_current
        (0.0, 50.0),    // 1: hw_pump_6_current
        (0.0, 50.0),    // 2: cw_pump_3_current
        (0.0, 50.0),    // 3: cw_pump_4_current
        (0.0, 50.0),    // 4: 2pipe_pump_a_current
        (0.0, 50.0),    // 5: 2pipe_pump_b_current
        (80.0, 200.0),  // 6: hw_supply_4pipe_temp
        (40.0, 80.0),   // 7: cw_supply_4pipe_temp
        (115.0, 155.0), // 8: hw_supply_2pipe_temp
        (70.0, 120.0),  // 9: cw_return_2pipe_temp
        (-20.0, 120.0), // 10: outdoor_air_temp
        (50.0, 90.0),   // 11: mech_room_temp
        (65.0, 85.0),   // 12: space_sensor_1_temp
        (65.0, 85.0),   // 13: space_sensor_2_temp
        (0.0, 200.0),   // 14: hw_pressure_4pipe
        (0.0, 200.0),   // 15: cw_pressure_4pipe
        (0.0, 100.0),   // 16-21: VFD speeds
        (0.0, 100.0),
        (0.0, 100.0),
        (0.0, 100.0),
        (0.0, 100.0),
        (0.0, 100.0),
        (0.0, 100.0), // 22: steam_valve_1_3_pos
        (0.0, 100.0), // 23: steam_valve_2_3_pos
        (0.0, 1.0),   // 24: summer_winter_mode
        (0.0, 1.0),   // 25: hw_lead_pump_id
        (0.0, 1.0),   // 26: cw_lead_pump_id
        (0.0, 1.0),   // 27: 2pipe_lead_pump_id
    ];

    for i in 0..n_samples {
        for f in 0..28 {
            let (min_val, max_val) = sensor_ranges[f];
            let idx = i * 28 + f;
            data[idx] = ((data[idx] - min_val) / (max_val - min_val)).clamp(0.0, 1.0);
        }
    }
}

/// Calculate accuracy
fn calculate_accuracy(logits: &Variable, labels: &[i64]) -> f32 {
    let data = logits.data();
    let shape = data.shape();
    let batch_size = shape[0];
    let num_classes = shape[1];
    let values = data.to_vec();

    let mut correct = 0;
    for b in 0..batch_size {
        let start = b * num_classes;
        let mut max_idx = 0;
        let mut max_val = values[start];
        for c in 1..num_classes {
            if values[start + c] > max_val {
                max_val = values[start + c];
                max_idx = c;
            }
        }
        if max_idx == labels[b] as usize {
            correct += 1;
        }
    }
    correct as f32 / batch_size as f32
}

/// Training function
fn train_epoch(
    model: &HvacPredictor,
    optimizer: &mut Adam,
    loss_fn: &CrossEntropyLoss,
    x_data: &[f32],
    y_imminent: &[i64],
    y_warning: &[i64],
    y_early: &[i64],
    batch_size: usize,
    seq_len: usize,
    num_features: usize,
) -> (f32, f32, f32, f32) {
    let n_sequences = y_imminent.len();
    let n_batches = n_sequences / batch_size;

    let mut total_loss = 0.0f32;
    let mut total_acc_imm = 0.0f32;
    let mut total_acc_warn = 0.0f32;
    let mut total_acc_early = 0.0f32;

    for batch_idx in 0..n_batches {
        let start = batch_idx * batch_size;

        // Prepare batch data
        let mut batch_x = vec![0.0f32; batch_size * seq_len * num_features];
        let mut batch_y_imm = vec![0i64; batch_size];
        let mut batch_y_warn = vec![0i64; batch_size];
        let mut batch_y_early = vec![0i64; batch_size];

        for b in 0..batch_size {
            let seq_start = (start + b) * seq_len * num_features;
            for i in 0..(seq_len * num_features) {
                batch_x[b * seq_len * num_features + i] = x_data[seq_start + i];
            }
            batch_y_imm[b] = y_imminent[start + b];
            batch_y_warn[b] = y_warning[start + b];
            batch_y_early[b] = y_early[start + b];
        }

        // Create tensors
        let x_tensor = Tensor::from_vec(batch_x, &[batch_size, seq_len, num_features])
            .expect("Failed to create input tensor");
        let x_var = Variable::new(x_tensor, true);

        // Forward pass
        let (logits_imm, logits_warn, logits_early) = model.forward_multi(&x_var);

        // Calculate losses (simplified - just use imminent for now)
        let y_imm_tensor = Tensor::from_vec(
            batch_y_imm.iter().map(|&y| y as f32).collect(),
            &[batch_size],
        )
        .expect("Failed to create label tensor");
        let y_imm_var = Variable::new(y_imm_tensor, false);

        let loss = loss_fn.compute(&logits_imm, &y_imm_var);

        // Backward pass
        optimizer.zero_grad();
        loss.backward();
        optimizer.step();

        // Metrics
        total_loss += loss.data().to_vec()[0];
        total_acc_imm += calculate_accuracy(&logits_imm, &batch_y_imm);
        total_acc_warn += calculate_accuracy(&logits_warn, &batch_y_warn);
        total_acc_early += calculate_accuracy(&logits_early, &batch_y_early);
    }

    let n = n_batches as f32;
    (
        total_loss / n,
        total_acc_imm / n,
        total_acc_warn / n,
        total_acc_early / n,
    )
}

examples/hvac_model.rs (line 166)

    fn mean_pool(&self, x: &Variable) -> Variable {
        let data = x.data();
        let shape = data.shape();
        let batch_size = shape[0];
        let seq_len = shape[1];
        let hidden = shape[2];

        // Reshape to [batch * seq, hidden] then back
        let values = data.to_vec();

        // Calculate mean over sequence dimension
        let mut pooled = vec![0.0f32; batch_size * hidden];
        for b in 0..batch_size {
            for h in 0..hidden {
                let mut sum = 0.0;
                for s in 0..seq_len {
                    let idx = b * seq_len * hidden + s * hidden + h;
                    sum += values[idx];
                }
                pooled[b * hidden + h] = sum / seq_len as f32;
            }
        }

        let pooled_tensor = Tensor::from_vec(pooled, &[batch_size, hidden])
            .expect("Failed to create pooled tensor");
        Variable::new(pooled_tensor, x.requires_grad())
    }

    /// Forward pass returning logits for all 3 horizons
    pub fn forward_multi(&self, x: &Variable) -> HvacOutput {
        let x_data = x.data();
        let shape = x_data.shape();
        let batch_size = shape[0];
        let seq_len = shape[1];
        drop(x_data); // Release borrow

        // Input projection: [batch, seq, features] -> [batch, seq, hidden]
        // Reshape for linear: [batch * seq, features]
        let x_flat = x.reshape(&[batch_size * seq_len, self.config.num_features]);
        let proj = self.input_proj.forward(&x_flat);
        let proj = self.input_norm.forward(&proj);
        let proj = self.input_relu.forward(&proj);
        let proj = proj.reshape(&[batch_size, seq_len, self.config.hidden_size]);

        // GRU encoding: [batch, seq, hidden] -> [batch, seq, hidden]
        let encoded = self.gru.forward(&proj);

        // Mean pooling: [batch, seq, hidden] -> [batch, hidden]
        let pooled = self.mean_pool(&encoded);

        // Prediction heads
        let imminent_logits = self.head_imminent.forward(&pooled);
        let warning_logits = self.head_warning.forward(&pooled);
        let early_logits = self.head_early.forward(&pooled);

        HvacOutput {
            imminent_logits,
            warning_logits,
            early_logits,
        }
    }

    /// Get predicted classes (argmax of logits)
    pub fn predict(&self, x: &Variable) -> (Vec<usize>, Vec<usize>, Vec<usize>) {
        let output = self.forward_multi(x);

        let imminent_probs = self.softmax.forward(&output.imminent_logits);
        let warning_probs = self.softmax.forward(&output.warning_logits);
        let early_probs = self.softmax.forward(&output.early_logits);

        (
            argmax_batch(&imminent_probs),
            argmax_batch(&warning_probs),
            argmax_batch(&early_probs),
        )
    }

    /// Returns the model configuration
    pub fn config(&self) -> &HvacConfig {
        &self.config
    }

    /// Returns the number of trainable parameters
    pub fn num_parameters(&self) -> usize {
        self.parameters()
            .iter()
            .map(|p| p.variable().data().numel())
            .sum()
    }
}

impl Module for HvacPredictor {
    fn forward(&self, x: &Variable) -> Variable {
        // Return concatenated logits for all horizons
        let output = self.forward_multi(x);
        // For single output, return imminent predictions
        output.imminent_logits
    }

    fn parameters(&self) -> Vec<Parameter> {
        let mut params = self.input_proj.parameters();
        params.extend(self.input_norm.parameters());
        params.extend(self.gru.parameters());
        params.extend(self.head_imminent.parameters());
        params.extend(self.head_warning.parameters());
        params.extend(self.head_early.parameters());
        params
    }
}

// =============================================================================
// Helper Functions
// =============================================================================

/// Get argmax for each sample in batch
fn argmax_batch(x: &Variable) -> Vec<usize> {
    let data = x.data();
    let shape = data.shape();
    let batch_size = shape[0];
    let num_classes = shape[1];
    let values = data.to_vec();

    let mut results = Vec::with_capacity(batch_size);
    for b in 0..batch_size {
        let start = b * num_classes;
        let end = start + num_classes;
        let slice = &values[start..end];

        let mut max_idx = 0;
        let mut max_val = slice[0];
        for (i, &v) in slice.iter().enumerate() {
            if v > max_val {
                max_val = v;
                max_idx = i;
            }
        }
        results.push(max_idx);
    }
    results
}

/// Failure type names
pub const FAILURE_TYPES: [&str; 20] = [
    "normal",
    "pump_failure_hw_5",
    "pump_failure_hw_6",
    "pump_failure_cw_3",
    "pump_failure_cw_4",
    "pump_failure_2pipe_a",
    "pump_failure_2pipe_b",
    "pressure_low_hw",
    "pressure_high_hw",
    "pressure_low_cw",
    "pressure_high_cw",
    "temp_anomaly_hw_supply",
    "temp_anomaly_cw_supply",
    "temp_anomaly_space",
    "valve_stuck_1_3",
    "valve_stuck_2_3",
    "vfd_fault",
    "sensor_drift",
    "chiller_fault",
    "interlock_violation",
];

/// Feature names for the 28 sensor inputs
pub const FEATURE_NAMES: [&str; 28] = [
    "hw_pump_5_current",
    "hw_pump_6_current",
    "cw_pump_3_current",
    "cw_pump_4_current",
    "2pipe_pump_a_current",
    "2pipe_pump_b_current",
    "hw_supply_4pipe_temp",
    "cw_supply_4pipe_temp",
    "hw_supply_2pipe_temp",
    "cw_return_2pipe_temp",
    "outdoor_air_temp",
    "mech_room_temp",
    "space_sensor_1_temp",
    "space_sensor_2_temp",
    "hw_pressure_4pipe",
    "cw_pressure_4pipe",
    "hw_pump_5_vfd_speed",
    "hw_pump_6_vfd_speed",
    "cw_pump_3_vfd_speed",
    "cw_pump_4_vfd_speed",
    "2pipe_pump_a_vfd_speed",
    "2pipe_pump_b_vfd_speed",
    "steam_valve_1_3_pos",
    "steam_valve_2_3_pos",
    "summer_winter_mode",
    "hw_lead_pump_id",
    "cw_lead_pump_id",
    "2pipe_lead_pump_id",
];

// =============================================================================
// Main
// =============================================================================

fn main() {
    println!("╔════════════════════════════════════════════════════════════╗");
    println!("║     HVAC Multi-Horizon Predictor - AxonML Native           ║");
    println!("╚════════════════════════════════════════════════════════════╝");
    println!();

    // Create model with default config
    let config = HvacConfig::default();
    println!("Model Configuration:");
    println!("  Input features: {}", config.num_features);
    println!("  Sequence length: {}", config.seq_len);
    println!("  Hidden size: {}", config.hidden_size);
    println!("  GRU layers: {}", config.num_layers);
    println!("  Output classes: {}", config.num_classes);
    println!("  Dropout: {}", config.dropout);
    println!();

    let model = HvacPredictor::new(config.clone());
    println!("Model created!");
    println!("  Total parameters: {}", model.num_parameters());
    println!();

    // Create sample input
    let batch_size = 2;
    let mut input_data = vec![0.5f32; batch_size * config.seq_len * config.num_features];

    // Simulate normal HVAC readings
    for b in 0..batch_size {
        for t in 0..config.seq_len {
            let base = (b * config.seq_len + t) * config.num_features;
            // Pump currents ~25A (normalized)
            for i in 0..6 {
                input_data[base + i] = 0.5;
            }
            // Temperatures (normalized)
            input_data[base + 6] = 0.83; // HW supply ~180F
            input_data[base + 7] = 0.375; // CW supply ~55F
            // VFD speeds ~60%
            for i in 16..22 {
                input_data[base + i] = 0.6;
            }
        }
    }

    let input = Tensor::from_vec(
        input_data,
        &[batch_size, config.seq_len, config.num_features],
    )
    .expect("Failed to create input tensor");

    let input_var = Variable::new(input, false);
    println!("Input shape: {:?}", input_var.data().shape());

    // Run inference
    println!();
    println!("Running inference...");
    let (imminent, warning, early) = model.predict(&input_var);

    println!();
    println!("Predictions:");
    println!("────────────────────────────────────────────────────────────");
    for b in 0..batch_size {
        println!("Sample {}:", b);
        println!(
            "  5 min (Imminent): {} - {}",
            imminent[b], FAILURE_TYPES[imminent[b]]
        );
        println!(
            "  15 min (Warning): {} - {}",
            warning[b], FAILURE_TYPES[warning[b]]
        );
        println!(
            "  30 min (Early):   {} - {}",
            early[b], FAILURE_TYPES[early[b]]
        );
    }
    println!("────────────────────────────────────────────────────────────");
    println!();
    println!("Model ready for training with your HVAC sensor data!");
}

examples/simple_training.rs (line 77)

fn main() {
    println!("=== Axonml ML Framework - Simple Training Example ===\n");

    // Print version and features
    println!("Version: {}", axonml::version());
    println!("Features: {}\n", axonml::features());

    // 1. Create a simple dataset (XOR problem)
    println!("1. Creating XOR dataset...");
    let inputs = vec![
        vec![0.0, 0.0],
        vec![0.0, 1.0],
        vec![1.0, 0.0],
        vec![1.0, 1.0],
    ];
    let targets = vec![0.0, 1.0, 1.0, 0.0]; // XOR outputs

    println!("   Inputs: {inputs:?}");
    println!("   Targets: {targets:?}\n");

    // 2. Create a simple MLP model
    println!("2. Creating MLP model (2 -> 4 -> 1)...");
    let linear1 = Linear::new(2, 4);
    let linear2 = Linear::new(4, 1);

    println!("   Layer 1: Linear(2, 4)");
    println!("   Layer 2: Linear(4, 1)\n");

    // 3. Create optimizer
    println!("3. Creating Adam optimizer (lr=0.1)...");
    let params = [linear1.parameters(), linear2.parameters()].concat();
    let mut optimizer = Adam::new(params, 0.1);
    println!("   Optimizer created!\n");

    // 4. Training loop
    println!("4. Training for 1000 epochs...");
    let epochs = 1000;

    for epoch in 0..epochs {
        let mut total_loss = 0.0;

        for (input, &target) in inputs.iter().zip(targets.iter()) {
            // Create input tensor
            let x = Variable::new(Tensor::from_vec(input.clone(), &[1, 2]).unwrap(), true);

            // Forward pass
            let h = linear1.forward(&x);
            let h = h.sigmoid();
            let output = linear2.forward(&h);
            let output = output.sigmoid();

            // Create target tensor
            let y = Variable::new(Tensor::from_vec(vec![target], &[1, 1]).unwrap(), false);

            // Compute MSE loss manually: (output - target)^2
            let diff = output.sub_var(&y);
            let loss = diff.mul_var(&diff);

            total_loss += loss.data().to_vec()[0];

            // Backward pass
            loss.backward();

            // Update weights
            optimizer.step();
            optimizer.zero_grad();
        }

        if epoch % 200 == 0 || epoch == epochs - 1 {
            println!("   Epoch {}: Loss = {:.6}", epoch, total_loss / 4.0);
        }
    }

    // 5. Test the trained model
    println!("\n5. Testing trained model...");
    for (input, &expected) in inputs.iter().zip(targets.iter()) {
        let x = Variable::new(Tensor::from_vec(input.clone(), &[1, 2]).unwrap(), false);

        let h = linear1.forward(&x);
        let h = h.sigmoid();
        let output = linear2.forward(&h);
        let output = output.sigmoid();

        let pred = output.data().to_vec()[0];
        let rounded = if pred > 0.5 { 1.0 } else { 0.0 };

        println!(
            "   Input: {input:?} -> Predicted: {pred:.4} (rounded: {rounded}) | Expected: {expected}"
        );
    }

    println!("\n=== Training Complete! ===");
}

examples/mnist_training.rs (line 62)

fn main() {
    println!("=== AxonML - MNIST Training (LeNet) ===\n");

    // Detect device
    #[cfg(feature = "cuda")]
    let device = {
        let cuda = Device::Cuda(0);
        if cuda.is_available() {
            println!("GPU detected: using CUDA device 0");
            cuda
        } else {
            println!("CUDA feature enabled but no GPU available, using CPU");
            Device::Cpu
        }
    };
    #[cfg(not(feature = "cuda"))]
    let device = {
        println!("Using CPU (compile with --features cuda for GPU)");
        Device::Cpu
    };

    // 1. Create dataset
    let num_train = 2000;
    let num_test = 400;
    println!("\n1. Creating SyntheticMNIST dataset ({num_train} train, {num_test} test)...");
    let train_dataset = SyntheticMNIST::new(num_train);
    let test_dataset = SyntheticMNIST::new(num_test);

    // 2. Create DataLoader
    let batch_size = 64;
    println!("2. Creating DataLoader (batch_size={batch_size})...");
    let train_loader = DataLoader::new(train_dataset, batch_size);
    let test_loader = DataLoader::new(test_dataset, batch_size);
    println!("   Training batches: {}", train_loader.len());

    // 3. Create LeNet model and move to device
    println!("3. Creating LeNet model...");
    let model = LeNet::new();
    model.to_device(device);
    let params = model.parameters();
    let total_params: usize = params
        .iter()
        .map(|p| p.variable().data().to_vec().len())
        .sum();
    println!(
        "   Parameters: {} ({} total weights)",
        params.len(),
        total_params
    );
    println!("   Device: {:?}", device);

    // 4. Create optimizer and loss
    println!("4. Creating Adam optimizer (lr=0.001) + CrossEntropyLoss...");
    let mut optimizer = Adam::new(params, 0.001);
    let criterion = CrossEntropyLoss::new();

    // 5. Training loop
    let epochs = 10;
    println!("5. Training for {epochs} epochs...\n");

    let train_start = Instant::now();

    for epoch in 0..epochs {
        let epoch_start = Instant::now();
        let mut total_loss = 0.0;
        let mut correct = 0usize;
        let mut total = 0usize;
        let mut batch_count = 0;

        for batch in train_loader.iter() {
            let bs = batch.data.shape()[0];

            // Reshape to [N, 1, 28, 28] and create Variable
            let input_data = batch.data.to_vec();
            let input_tensor = Tensor::from_vec(input_data, &[bs, 1, 28, 28]).unwrap();
            let input = Variable::new(
                if device.is_gpu() {
                    input_tensor.to_device(device).unwrap()
                } else {
                    input_tensor
                },
                true,
            );

            // Target: convert one-hot [N, 10] to class indices [N]
            let target_onehot = batch.targets.to_vec();
            let mut target_indices = vec![0.0f32; bs];
            for i in 0..bs {
                let offset = i * 10;
                let mut max_idx = 0;
                let mut max_val = f32::NEG_INFINITY;
                for c in 0..10 {
                    if target_onehot[offset + c] > max_val {
                        max_val = target_onehot[offset + c];
                        max_idx = c;
                    }
                }
                target_indices[i] = max_idx as f32;
            }
            let target_tensor = Tensor::from_vec(target_indices.clone(), &[bs]).unwrap();
            let target = Variable::new(
                if device.is_gpu() {
                    target_tensor.to_device(device).unwrap()
                } else {
                    target_tensor
                },
                false,
            );

            // Forward pass
            let output = model.forward(&input);

            // Cross-entropy loss
            let loss = criterion.compute(&output, &target);

            let loss_val = loss.data().to_vec()[0];
            total_loss += loss_val;
            batch_count += 1;

            // Compute training accuracy
            let out_data = output.data().to_vec();
            for i in 0..bs {
                let offset = i * 10;
                let mut pred = 0;
                let mut pred_val = f32::NEG_INFINITY;
                for c in 0..10 {
                    if out_data[offset + c] > pred_val {
                        pred_val = out_data[offset + c];
                        pred = c;
                    }
                }
                if pred == target_indices[i] as usize {
                    correct += 1;
                }
                total += 1;
            }

            // Backward pass
            loss.backward();

            // Update weights
            optimizer.step();
            optimizer.zero_grad();
        }

        let epoch_time = epoch_start.elapsed();
        let avg_loss = total_loss / batch_count as f32;
        let accuracy = 100.0 * correct as f32 / total as f32;
        let samples_per_sec = total as f64 / epoch_time.as_secs_f64();

        println!(
            "   Epoch {:2}/{}: Loss={:.4}  Acc={:.1}%  ({:.0} samples/s, {:.2}s)",
            epoch + 1,
            epochs,
            avg_loss,
            accuracy,
            samples_per_sec,
            epoch_time.as_secs_f64(),
        );
    }

    let train_time = train_start.elapsed();
    println!("\n   Total training time: {:.2}s", train_time.as_secs_f64());

    // 6. Test evaluation
    println!("\n6. Evaluating on test set...");

    // Disable gradient computation for evaluation
    let (correct, total) = no_grad(|| {
        let mut correct = 0usize;
        let mut total = 0usize;

        for batch in test_loader.iter() {
            let bs = batch.data.shape()[0];

            let input_data = batch.data.to_vec();
            let input_tensor = Tensor::from_vec(input_data, &[bs, 1, 28, 28]).unwrap();
            let input = Variable::new(
                if device.is_gpu() {
                    input_tensor.to_device(device).unwrap()
                } else {
                    input_tensor
                },
                false,
            );

            let target_onehot = batch.targets.to_vec();
            let output = model.forward(&input);
            let out_data = output.data().to_vec();

            for i in 0..bs {
                // Prediction: argmax of output
                let offset = i * 10;
                let mut pred = 0;
                let mut pred_val = f32::NEG_INFINITY;
                for c in 0..10 {
                    if out_data[offset + c] > pred_val {
                        pred_val = out_data[offset + c];
                        pred = c;
                    }
                }

                // True label: argmax of one-hot target
                let mut true_label = 0;
                let mut true_val = f32::NEG_INFINITY;
                for c in 0..10 {
                    if target_onehot[i * 10 + c] > true_val {
                        true_val = target_onehot[i * 10 + c];
                        true_label = c;
                    }
                }

                if pred == true_label {
                    correct += 1;
                }
                total += 1;
            }
        }

        (correct, total)
    });

    let test_accuracy = 100.0 * correct as f32 / total as f32;
    println!(
        "   Test Accuracy: {}/{} ({:.2}%)",
        correct, total, test_accuracy
    );

    println!("\n=== Training Complete! ===");
    println!("   Device: {:?}", device);
    println!("   Final test accuracy: {:.2}%", test_accuracy);
}

examples/train_panoptes.rs (line 132)

fn main() {
    println!("╔══════════════════════════════════════════════════════════════╗");
    println!("║     PANOPTES — Facility-Wide Anomaly Detection Training     ║");
    println!("║     Heritage Pointe of Warren (59 equipment)                ║");
    println!("╚══════════════════════════════════════════════════════════════╝");
    println!();

    // =========================================================================
    // Generate training data
    // =========================================================================
    println!("[data] Generating physics-informed training data...");
    let t0 = Instant::now();

    let sim = WarrenSimulator::new(SEED);
    let normal_train = sim.generate_normal(NORMAL_SAMPLES);
    let fault_data = sim.generate_with_faults(FAULT_SAMPLES, 1.0);

    // Validation set (different seed)
    let val_sim = WarrenSimulator::new(SEED + 999);
    let normal_val = val_sim.generate_normal(200);
    let fault_val = val_sim.generate_with_faults(100, 1.0);

    println!("  Normal train: {} samples", normal_train.len());
    println!("  Fault train:  {} samples", fault_data.len());
    println!("  Normal val:   {} samples", normal_val.len());
    println!("  Fault val:    {} samples", fault_val.len());
    println!("  Generated in {:.1}s", t0.elapsed().as_secs_f32());
    println!();

    // =========================================================================
    // Create model
    // =========================================================================
    let model = Panoptes::new(NUM_EQUIPMENT);
    println!("[model] Panoptes created");
    println!("  Equipment slots: {NUM_EQUIPMENT}");
    println!("  Parameters: {}", model.num_parameters());
    println!("  Embed dim: {EMBED_DIM}");
    println!();

    let mse = MSELoss::new();

    // Zero target for normal operation
    let zero_target = Variable::new(
        Tensor::from_vec(vec![0.0; NUM_EQUIPMENT], &[1, NUM_EQUIPMENT]).unwrap(),
        false,
    );

    // =========================================================================
    // Phase 1: Learn normal operation
    // =========================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!(" PHASE 1: Learning Normal Operation ({PHASE1_EPOCHS} epochs)");
    println!("═══════════════════════════════════════════════════════════════");
    println!(
        "  {:>5}  {:>12}  {:>12}  {:>8}",
        "Epoch", "Train Loss", "Val Loss", "Time"
    );
    println!("  {:-<5}  {:-<12}  {:-<12}  {:-<8}", "", "", "", "");

    let params = model.parameters();
    let mut optimizer = Adam::new(params, LR);

    for epoch in 1..=PHASE1_EPOCHS {
        let epoch_start = Instant::now();
        let mut epoch_loss = 0.0f32;
        let mut batch_count = 0;

        // Train on normal data: target = all zeros
        for batch_start in (0..normal_train.len()).step_by(BATCH_SIZE) {
            let batch_end = (batch_start + BATCH_SIZE).min(normal_train.len());

            for i in batch_start..batch_end {
                optimizer.zero_grad();

                let (equip_scores, _) = model.forward_snapshot(&normal_train[i]);
                let loss = mse.compute(&equip_scores, &zero_target);
                let loss_val = loss.data().to_vec()[0];
                epoch_loss += loss_val;
                batch_count += 1;

                if loss.requires_grad() {
                    loss.backward();
                    optimizer.step();
                }
            }
        }

        // Validation
        let val_loss = evaluate_normal(&model, &normal_val, &mse, &zero_target);

        let avg_loss = epoch_loss / batch_count as f32;
        let elapsed = epoch_start.elapsed().as_secs_f32();

        println!(
            "  {:>5}  {:>12.6}  {:>12.6}  {:>6.1}s",
            epoch, avg_loss, val_loss, elapsed
        );
    }

    println!();

    // =========================================================================
    // Phase 2: Learn fault signatures
    // =========================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!(" PHASE 2: Learning Fault Signatures ({PHASE2_EPOCHS} epochs)");
    println!("═══════════════════════════════════════════════════════════════");
    println!(
        "  {:>5}  {:>12}  {:>12}  {:>12}  {:>8}",
        "Epoch", "Normal Loss", "Fault Loss", "Val Loss", "Time"
    );
    println!(
        "  {:-<5}  {:-<12}  {:-<12}  {:-<12}  {:-<8}",
        "", "", "", "", ""
    );

    // Reset optimizer with lower LR for phase 2
    let params = model.parameters();
    let mut optimizer = Adam::new(params, LR * 0.5);

    for epoch in 1..=PHASE2_EPOCHS {
        let epoch_start = Instant::now();
        let mut normal_loss_sum = 0.0f32;
        let mut fault_loss_sum = 0.0f32;
        let mut normal_count = 0;
        let mut fault_count = 0;

        // Interleave normal + fault samples
        let normal_per_epoch = NORMAL_SAMPLES / 2; // Use half of normal data
        let fault_per_epoch = fault_data.len();

        // Normal samples: target = zeros
        for i in 0..normal_per_epoch.min(normal_train.len()) {
            optimizer.zero_grad();
            let (equip_scores, _) = model.forward_snapshot(&normal_train[i]);
            let loss = mse.compute(&equip_scores, &zero_target);
            normal_loss_sum += loss.data().to_vec()[0];
            normal_count += 1;

            if loss.requires_grad() {
                loss.backward();
                optimizer.step();
            }
        }

        // Fault samples: target = 1.0 for affected equipment
        for i in 0..fault_per_epoch {
            let (ref snap, ref _fault, ref affected) = fault_data[i];

            let target_vec = PanoptesTrainingData::fault_target(NUM_EQUIPMENT, affected);
            let fault_target = Variable::new(
                Tensor::from_vec(target_vec, &[1, NUM_EQUIPMENT]).unwrap(),
                false,
            );

            optimizer.zero_grad();
            let (equip_scores, _) = model.forward_snapshot(snap);
            let loss = mse.compute(&equip_scores, &fault_target);
            fault_loss_sum += loss.data().to_vec()[0];
            fault_count += 1;

            if loss.requires_grad() {
                loss.backward();
                optimizer.step();
            }
        }

        // Validation
        let val_loss = evaluate_mixed(&model, &normal_val, &fault_val, &mse, &zero_target);

        let avg_normal = normal_loss_sum / normal_count.max(1) as f32;
        let avg_fault = fault_loss_sum / fault_count.max(1) as f32;
        let elapsed = epoch_start.elapsed().as_secs_f32();

        println!(
            "  {:>5}  {:>12.6}  {:>12.6}  {:>12.6}  {:>6.1}s",
            epoch, avg_normal, avg_fault, val_loss, elapsed
        );
    }

    println!();

    // =========================================================================
    // Phase 3: Temporal training
    // =========================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!(" PHASE 3: Temporal Training ({PHASE3_EPOCHS} epochs, window={TEMPORAL_WINDOW})");
    println!("═══════════════════════════════════════════════════════════════");

    // Generate temporal sequences
    println!("[data] Generating temporal sequences...");
    let t0 = Instant::now();

    // Normal temporal sequences: varied starting OAT, slow drift
    let mut normal_seqs: Vec<Vec<FacilitySnapshot>> = Vec::new();
    for i in 0..TEMPORAL_NORMAL_SEQS {
        let start_oat = -5.0 + (i as f32 / TEMPORAL_NORMAL_SEQS as f32) * 100.0;
        let drift = if start_oat < 50.0 { 0.2 } else { -0.1 }; // warming up or cooling down
        let seq_sim = WarrenSimulator::new(SEED + 5000 + i as u64);
        let seq = seq_sim.generate_temporal_sequence(TEMPORAL_WINDOW, start_oat, drift);
        normal_seqs.push(seq);
    }

    // Fault temporal sequences: fault injected mid-sequence
    let mut fault_seqs: Vec<(Vec<FacilitySnapshot>, usize, FaultType, Vec<usize>)> = Vec::new();
    for i in 0..TEMPORAL_FAULT_SEQS {
        let start_oat = -5.0 + (i as f32 / TEMPORAL_FAULT_SEQS as f32) * 100.0;
        let drift = 0.1;
        let seq_sim = WarrenSimulator::new(SEED + 8000 + i as u64);
        let seq_data =
            seq_sim.generate_temporal_with_fault(TEMPORAL_WINDOW, start_oat, drift, i as u64);
        fault_seqs.push(seq_data);
    }

    // Validation temporal sequences
    let mut val_normal_seqs: Vec<Vec<FacilitySnapshot>> = Vec::new();
    for i in 0..20 {
        let start_oat = 10.0 + (i as f32 / 20.0) * 80.0;
        let seq_sim = WarrenSimulator::new(SEED + 9000 + i as u64);
        let seq = seq_sim.generate_temporal_sequence(TEMPORAL_WINDOW, start_oat, 0.15);
        val_normal_seqs.push(seq);
    }

    let mut val_fault_seqs: Vec<(Vec<FacilitySnapshot>, usize, FaultType, Vec<usize>)> = Vec::new();
    for i in 0..20 {
        let start_oat = 10.0 + (i as f32 / 20.0) * 80.0;
        let seq_sim = WarrenSimulator::new(SEED + 9500 + i as u64);
        let seq_data =
            seq_sim.generate_temporal_with_fault(TEMPORAL_WINDOW, start_oat, 0.1, i as u64);
        val_fault_seqs.push(seq_data);
    }

    println!("  Normal temporal seqs: {}", normal_seqs.len());
    println!("  Fault temporal seqs:  {}", fault_seqs.len());
    println!("  Val normal seqs:      {}", val_normal_seqs.len());
    println!("  Val fault seqs:       {}", val_fault_seqs.len());
    println!("  Window size: {TEMPORAL_WINDOW} snapshots (1 hour)");
    println!("  Generated in {:.1}s", t0.elapsed().as_secs_f32());
    println!();

    println!(
        "  {:>5}  {:>12}  {:>12}  {:>12}  {:>8}",
        "Epoch", "Normal Loss", "Fault Loss", "Val Loss", "Time"
    );
    println!(
        "  {:-<5}  {:-<12}  {:-<12}  {:-<12}  {:-<8}",
        "", "", "", "", ""
    );

    // Lower LR for temporal fine-tuning
    let params = model.parameters();
    let mut optimizer = Adam::new(params, LR * 0.3);

    for epoch in 1..=PHASE3_EPOCHS {
        let epoch_start = Instant::now();
        let mut normal_loss_sum = 0.0f32;
        let mut fault_loss_sum = 0.0f32;
        let mut normal_count = 0;
        let mut fault_count = 0;

        // Normal temporal sequences: target = all zeros
        for seq in &normal_seqs {
            optimizer.zero_grad();
            let (equip_scores, _) = model.forward_temporal(seq);
            let loss = mse.compute(&equip_scores, &zero_target);
            normal_loss_sum += loss.data().to_vec()[0];
            normal_count += 1;

            if loss.requires_grad() {
                loss.backward();
                optimizer.step();
            }
        }

        // Fault temporal sequences: target = 1.0 for affected equipment
        for (seq, _onset, _fault, affected) in &fault_seqs {
            let target_vec = PanoptesTrainingData::fault_target(NUM_EQUIPMENT, affected);
            let fault_target = Variable::new(
                Tensor::from_vec(target_vec, &[1, NUM_EQUIPMENT]).unwrap(),
                false,
            );

            optimizer.zero_grad();
            let (equip_scores, _) = model.forward_temporal(seq);
            let loss = mse.compute(&equip_scores, &fault_target);
            fault_loss_sum += loss.data().to_vec()[0];
            fault_count += 1;

            if loss.requires_grad() {
                loss.backward();
                optimizer.step();
            }
        }

        // Validation
        let val_loss = evaluate_temporal_mixed(
            &model,
            &val_normal_seqs,
            &val_fault_seqs,
            &mse,
            &zero_target,
        );

        let avg_normal = normal_loss_sum / normal_count.max(1) as f32;
        let avg_fault = fault_loss_sum / fault_count.max(1) as f32;
        let elapsed = epoch_start.elapsed().as_secs_f32();

        println!(
            "  {:>5}  {:>12.6}  {:>12.6}  {:>12.6}  {:>6.1}s",
            epoch, avg_normal, avg_fault, val_loss, elapsed
        );
    }

    println!();

    // =========================================================================
    // Final evaluation
    // =========================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!(" FINAL EVALUATION");
    println!("═══════════════════════════════════════════════════════════════");

    // Test on normal data — scores should be near zero
    let config = FacilityConfig::warren();
    println!("\n  Normal operation (should be low scores):");
    for i in [0, 50, 100, 150] {
        if i >= normal_val.len() {
            break;
        }
        let (equip_scores, fac_score) = model.forward_snapshot(&normal_val[i]);
        let scores = equip_scores.data().to_vec();
        let fac = fac_score.data().to_vec()[0];
        let max_score = scores.iter().cloned().fold(0.0f32, f32::max);
        let avg_score: f32 = scores.iter().sum::<f32>() / scores.len() as f32;
        println!(
            "    Sample {i:>3}: facility={fac:.4}, avg_equip={avg_score:.4}, max_equip={max_score:.4}"
        );
    }

    // Test on fault data — affected equipment should have higher scores
    println!("\n  Fault samples (affected equipment should score higher):");
    for i in 0..5.min(fault_val.len()) {
        let (ref snap, ref fault, ref affected) = fault_val[i];
        let (equip_scores, fac_score) = model.forward_snapshot(snap);
        let scores = equip_scores.data().to_vec();
        let fac = fac_score.data().to_vec()[0];

        let output = PanoptesOutput::from_scores(&scores, fac, &config, 0.3);

        // Get scores for affected vs unaffected
        let affected_avg: f32 = if !affected.is_empty() {
            affected
                .iter()
                .filter(|&&s| s < scores.len())
                .map(|&s| scores[s])
                .sum::<f32>()
                / affected.len() as f32
        } else {
            0.0
        };

        println!("    Fault {:?}:", fault);
        println!(
            "      facility={fac:.4}, affected_avg={affected_avg:.4}, alerts={}",
            output.alerts.len()
        );
    }

    // Temporal evaluation
    println!("\n  Temporal normal (should be low scores):");
    for i in 0..3.min(val_normal_seqs.len()) {
        let (equip_scores, fac_score) = model.forward_temporal(&val_normal_seqs[i]);
        let scores = equip_scores.data().to_vec();
        let fac = fac_score.data().to_vec()[0];
        let max_score = scores.iter().cloned().fold(0.0f32, f32::max);
        let avg_score: f32 = scores.iter().sum::<f32>() / scores.len() as f32;
        println!(
            "    Seq {i:>3}: facility={fac:.4}, avg_equip={avg_score:.4}, max_equip={max_score:.4}"
        );
    }

    println!("\n  Temporal fault (fault injected mid-sequence):");
    for i in 0..5.min(val_fault_seqs.len()) {
        let (ref seq, onset, ref fault, ref affected) = val_fault_seqs[i];
        let (equip_scores, fac_score) = model.forward_temporal(seq);
        let scores = equip_scores.data().to_vec();
        let fac = fac_score.data().to_vec()[0];

        let affected_avg: f32 = if !affected.is_empty() {
            affected
                .iter()
                .filter(|&&s| s < scores.len())
                .map(|&s| scores[s])
                .sum::<f32>()
                / affected.len() as f32
        } else {
            0.0
        };
        let unaffected_avg: f32 = {
            let unaffected: Vec<f32> = scores
                .iter()
                .enumerate()
                .filter(|(idx, _)| !affected.contains(idx))
                .map(|(_, &s)| s)
                .collect();
            if unaffected.is_empty() {
                0.0
            } else {
                unaffected.iter().sum::<f32>() / unaffected.len() as f32
            }
        };

        let output = PanoptesOutput::from_scores(&scores, fac, &config, 0.3);
        println!(
            "    Fault {:?} (onset step {onset}/{TEMPORAL_WINDOW}):",
            fault
        );
        println!(
            "      facility={fac:.4}, affected={affected_avg:.4}, unaffected={unaffected_avg:.4}, alerts={}",
            output.alerts.len()
        );
    }

    println!();
    println!("Training complete.");
}

// =============================================================================
// Evaluation helpers
// =============================================================================

fn evaluate_normal(
    model: &Panoptes,
    val_data: &[FacilitySnapshot],
    mse: &MSELoss,
    zero_target: &Variable,
) -> f32 {
    let mut total_loss = 0.0f32;
    for snap in val_data {
        let (equip_scores, _) = model.forward_snapshot(snap);
        let loss = mse.compute(&equip_scores, zero_target);
        total_loss += loss.data().to_vec()[0];
    }
    total_loss / val_data.len() as f32
}

fn evaluate_mixed(
    model: &Panoptes,
    normal_val: &[FacilitySnapshot],
    fault_val: &[(FacilitySnapshot, FaultType, Vec<usize>)],
    mse: &MSELoss,
    zero_target: &Variable,
) -> f32 {
    let mut total_loss = 0.0f32;
    let mut count = 0;

    for snap in normal_val {
        let (equip_scores, _) = model.forward_snapshot(snap);
        let loss = mse.compute(&equip_scores, zero_target);
        total_loss += loss.data().to_vec()[0];
        count += 1;
    }

    for (snap, _, affected) in fault_val {
        let target_vec = PanoptesTrainingData::fault_target(NUM_EQUIPMENT, affected);
        let fault_target = Variable::new(
            Tensor::from_vec(target_vec, &[1, NUM_EQUIPMENT]).unwrap(),
            false,
        );
        let (equip_scores, _) = model.forward_snapshot(snap);
        let loss = mse.compute(&equip_scores, &fault_target);
        total_loss += loss.data().to_vec()[0];
        count += 1;
    }

    total_loss / count as f32
}

fn evaluate_temporal_mixed(
    model: &Panoptes,
    normal_seqs: &[Vec<FacilitySnapshot>],
    fault_seqs: &[(Vec<FacilitySnapshot>, usize, FaultType, Vec<usize>)],
    mse: &MSELoss,
    zero_target: &Variable,
) -> f32 {
    let mut total_loss = 0.0f32;
    let mut count = 0;

    for seq in normal_seqs {
        let (equip_scores, _) = model.forward_temporal(seq);
        let loss = mse.compute(&equip_scores, zero_target);
        total_loss += loss.data().to_vec()[0];
        count += 1;
    }

    for (seq, _, _, affected) in fault_seqs {
        let target_vec = PanoptesTrainingData::fault_target(NUM_EQUIPMENT, affected);
        let fault_target = Variable::new(
            Tensor::from_vec(target_vec, &[1, NUM_EQUIPMENT]).unwrap(),
            false,
        );
        let (equip_scores, _) = model.forward_temporal(seq);
        let loss = mse.compute(&equip_scores, &fault_target);
        total_loss += loss.data().to_vec()[0];
        count += 1;
    }

    total_loss / count as f32
}

pub fn shape(&self) -> Vec<usize>

Returns the shape of the tensor.

pub fn ndim(&self) -> usize

Returns the number of dimensions.

pub fn numel(&self) -> usize

Returns the total number of elements.

pub fn device(&self) -> Device

Returns the device this variable’s data is on.

pub fn to_device(&self, device: Device) -> Variable

Moves this variable’s data to the specified device.

Creates a new leaf Variable on the target device. Used for moving inputs to GPU before forward pass.

pub fn requires_grad(&self) -> bool

Returns whether this variable requires gradients.

Examples found in repository

examples/hvac_model.rs (line 190)

    fn mean_pool(&self, x: &Variable) -> Variable {
        let data = x.data();
        let shape = data.shape();
        let batch_size = shape[0];
        let seq_len = shape[1];
        let hidden = shape[2];

        // Reshape to [batch * seq, hidden] then back
        let values = data.to_vec();

        // Calculate mean over sequence dimension
        let mut pooled = vec![0.0f32; batch_size * hidden];
        for b in 0..batch_size {
            for h in 0..hidden {
                let mut sum = 0.0;
                for s in 0..seq_len {
                    let idx = b * seq_len * hidden + s * hidden + h;
                    sum += values[idx];
                }
                pooled[b * hidden + h] = sum / seq_len as f32;
            }
        }

        let pooled_tensor = Tensor::from_vec(pooled, &[batch_size, hidden])
            .expect("Failed to create pooled tensor");
        Variable::new(pooled_tensor, x.requires_grad())
    }

examples/train_panoptes.rs (line 136)

fn main() {
    println!("╔══════════════════════════════════════════════════════════════╗");
    println!("║     PANOPTES — Facility-Wide Anomaly Detection Training     ║");
    println!("║     Heritage Pointe of Warren (59 equipment)                ║");
    println!("╚══════════════════════════════════════════════════════════════╝");
    println!();

    // =========================================================================
    // Generate training data
    // =========================================================================
    println!("[data] Generating physics-informed training data...");
    let t0 = Instant::now();

    let sim = WarrenSimulator::new(SEED);
    let normal_train = sim.generate_normal(NORMAL_SAMPLES);
    let fault_data = sim.generate_with_faults(FAULT_SAMPLES, 1.0);

    // Validation set (different seed)
    let val_sim = WarrenSimulator::new(SEED + 999);
    let normal_val = val_sim.generate_normal(200);
    let fault_val = val_sim.generate_with_faults(100, 1.0);

    println!("  Normal train: {} samples", normal_train.len());
    println!("  Fault train:  {} samples", fault_data.len());
    println!("  Normal val:   {} samples", normal_val.len());
    println!("  Fault val:    {} samples", fault_val.len());
    println!("  Generated in {:.1}s", t0.elapsed().as_secs_f32());
    println!();

    // =========================================================================
    // Create model
    // =========================================================================
    let model = Panoptes::new(NUM_EQUIPMENT);
    println!("[model] Panoptes created");
    println!("  Equipment slots: {NUM_EQUIPMENT}");
    println!("  Parameters: {}", model.num_parameters());
    println!("  Embed dim: {EMBED_DIM}");
    println!();

    let mse = MSELoss::new();

    // Zero target for normal operation
    let zero_target = Variable::new(
        Tensor::from_vec(vec![0.0; NUM_EQUIPMENT], &[1, NUM_EQUIPMENT]).unwrap(),
        false,
    );

    // =========================================================================
    // Phase 1: Learn normal operation
    // =========================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!(" PHASE 1: Learning Normal Operation ({PHASE1_EPOCHS} epochs)");
    println!("═══════════════════════════════════════════════════════════════");
    println!(
        "  {:>5}  {:>12}  {:>12}  {:>8}",
        "Epoch", "Train Loss", "Val Loss", "Time"
    );
    println!("  {:-<5}  {:-<12}  {:-<12}  {:-<8}", "", "", "", "");

    let params = model.parameters();
    let mut optimizer = Adam::new(params, LR);

    for epoch in 1..=PHASE1_EPOCHS {
        let epoch_start = Instant::now();
        let mut epoch_loss = 0.0f32;
        let mut batch_count = 0;

        // Train on normal data: target = all zeros
        for batch_start in (0..normal_train.len()).step_by(BATCH_SIZE) {
            let batch_end = (batch_start + BATCH_SIZE).min(normal_train.len());

            for i in batch_start..batch_end {
                optimizer.zero_grad();

                let (equip_scores, _) = model.forward_snapshot(&normal_train[i]);
                let loss = mse.compute(&equip_scores, &zero_target);
                let loss_val = loss.data().to_vec()[0];
                epoch_loss += loss_val;
                batch_count += 1;

                if loss.requires_grad() {
                    loss.backward();
                    optimizer.step();
                }
            }
        }

        // Validation
        let val_loss = evaluate_normal(&model, &normal_val, &mse, &zero_target);

        let avg_loss = epoch_loss / batch_count as f32;
        let elapsed = epoch_start.elapsed().as_secs_f32();

        println!(
            "  {:>5}  {:>12.6}  {:>12.6}  {:>6.1}s",
            epoch, avg_loss, val_loss, elapsed
        );
    }

    println!();

    // =========================================================================
    // Phase 2: Learn fault signatures
    // =========================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!(" PHASE 2: Learning Fault Signatures ({PHASE2_EPOCHS} epochs)");
    println!("═══════════════════════════════════════════════════════════════");
    println!(
        "  {:>5}  {:>12}  {:>12}  {:>12}  {:>8}",
        "Epoch", "Normal Loss", "Fault Loss", "Val Loss", "Time"
    );
    println!(
        "  {:-<5}  {:-<12}  {:-<12}  {:-<12}  {:-<8}",
        "", "", "", "", ""
    );

    // Reset optimizer with lower LR for phase 2
    let params = model.parameters();
    let mut optimizer = Adam::new(params, LR * 0.5);

    for epoch in 1..=PHASE2_EPOCHS {
        let epoch_start = Instant::now();
        let mut normal_loss_sum = 0.0f32;
        let mut fault_loss_sum = 0.0f32;
        let mut normal_count = 0;
        let mut fault_count = 0;

        // Interleave normal + fault samples
        let normal_per_epoch = NORMAL_SAMPLES / 2; // Use half of normal data
        let fault_per_epoch = fault_data.len();

        // Normal samples: target = zeros
        for i in 0..normal_per_epoch.min(normal_train.len()) {
            optimizer.zero_grad();
            let (equip_scores, _) = model.forward_snapshot(&normal_train[i]);
            let loss = mse.compute(&equip_scores, &zero_target);
            normal_loss_sum += loss.data().to_vec()[0];
            normal_count += 1;

            if loss.requires_grad() {
                loss.backward();
                optimizer.step();
            }
        }

        // Fault samples: target = 1.0 for affected equipment
        for i in 0..fault_per_epoch {
            let (ref snap, ref _fault, ref affected) = fault_data[i];

            let target_vec = PanoptesTrainingData::fault_target(NUM_EQUIPMENT, affected);
            let fault_target = Variable::new(
                Tensor::from_vec(target_vec, &[1, NUM_EQUIPMENT]).unwrap(),
                false,
            );

            optimizer.zero_grad();
            let (equip_scores, _) = model.forward_snapshot(snap);
            let loss = mse.compute(&equip_scores, &fault_target);
            fault_loss_sum += loss.data().to_vec()[0];
            fault_count += 1;

            if loss.requires_grad() {
                loss.backward();
                optimizer.step();
            }
        }

        // Validation
        let val_loss = evaluate_mixed(&model, &normal_val, &fault_val, &mse, &zero_target);

        let avg_normal = normal_loss_sum / normal_count.max(1) as f32;
        let avg_fault = fault_loss_sum / fault_count.max(1) as f32;
        let elapsed = epoch_start.elapsed().as_secs_f32();

        println!(
            "  {:>5}  {:>12.6}  {:>12.6}  {:>12.6}  {:>6.1}s",
            epoch, avg_normal, avg_fault, val_loss, elapsed
        );
    }

    println!();

    // =========================================================================
    // Phase 3: Temporal training
    // =========================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!(" PHASE 3: Temporal Training ({PHASE3_EPOCHS} epochs, window={TEMPORAL_WINDOW})");
    println!("═══════════════════════════════════════════════════════════════");

    // Generate temporal sequences
    println!("[data] Generating temporal sequences...");
    let t0 = Instant::now();

    // Normal temporal sequences: varied starting OAT, slow drift
    let mut normal_seqs: Vec<Vec<FacilitySnapshot>> = Vec::new();
    for i in 0..TEMPORAL_NORMAL_SEQS {
        let start_oat = -5.0 + (i as f32 / TEMPORAL_NORMAL_SEQS as f32) * 100.0;
        let drift = if start_oat < 50.0 { 0.2 } else { -0.1 }; // warming up or cooling down
        let seq_sim = WarrenSimulator::new(SEED + 5000 + i as u64);
        let seq = seq_sim.generate_temporal_sequence(TEMPORAL_WINDOW, start_oat, drift);
        normal_seqs.push(seq);
    }

    // Fault temporal sequences: fault injected mid-sequence
    let mut fault_seqs: Vec<(Vec<FacilitySnapshot>, usize, FaultType, Vec<usize>)> = Vec::new();
    for i in 0..TEMPORAL_FAULT_SEQS {
        let start_oat = -5.0 + (i as f32 / TEMPORAL_FAULT_SEQS as f32) * 100.0;
        let drift = 0.1;
        let seq_sim = WarrenSimulator::new(SEED + 8000 + i as u64);
        let seq_data =
            seq_sim.generate_temporal_with_fault(TEMPORAL_WINDOW, start_oat, drift, i as u64);
        fault_seqs.push(seq_data);
    }

    // Validation temporal sequences
    let mut val_normal_seqs: Vec<Vec<FacilitySnapshot>> = Vec::new();
    for i in 0..20 {
        let start_oat = 10.0 + (i as f32 / 20.0) * 80.0;
        let seq_sim = WarrenSimulator::new(SEED + 9000 + i as u64);
        let seq = seq_sim.generate_temporal_sequence(TEMPORAL_WINDOW, start_oat, 0.15);
        val_normal_seqs.push(seq);
    }

    let mut val_fault_seqs: Vec<(Vec<FacilitySnapshot>, usize, FaultType, Vec<usize>)> = Vec::new();
    for i in 0..20 {
        let start_oat = 10.0 + (i as f32 / 20.0) * 80.0;
        let seq_sim = WarrenSimulator::new(SEED + 9500 + i as u64);
        let seq_data =
            seq_sim.generate_temporal_with_fault(TEMPORAL_WINDOW, start_oat, 0.1, i as u64);
        val_fault_seqs.push(seq_data);
    }

    println!("  Normal temporal seqs: {}", normal_seqs.len());
    println!("  Fault temporal seqs:  {}", fault_seqs.len());
    println!("  Val normal seqs:      {}", val_normal_seqs.len());
    println!("  Val fault seqs:       {}", val_fault_seqs.len());
    println!("  Window size: {TEMPORAL_WINDOW} snapshots (1 hour)");
    println!("  Generated in {:.1}s", t0.elapsed().as_secs_f32());
    println!();

    println!(
        "  {:>5}  {:>12}  {:>12}  {:>12}  {:>8}",
        "Epoch", "Normal Loss", "Fault Loss", "Val Loss", "Time"
    );
    println!(
        "  {:-<5}  {:-<12}  {:-<12}  {:-<12}  {:-<8}",
        "", "", "", "", ""
    );

    // Lower LR for temporal fine-tuning
    let params = model.parameters();
    let mut optimizer = Adam::new(params, LR * 0.3);

    for epoch in 1..=PHASE3_EPOCHS {
        let epoch_start = Instant::now();
        let mut normal_loss_sum = 0.0f32;
        let mut fault_loss_sum = 0.0f32;
        let mut normal_count = 0;
        let mut fault_count = 0;

        // Normal temporal sequences: target = all zeros
        for seq in &normal_seqs {
            optimizer.zero_grad();
            let (equip_scores, _) = model.forward_temporal(seq);
            let loss = mse.compute(&equip_scores, &zero_target);
            normal_loss_sum += loss.data().to_vec()[0];
            normal_count += 1;

            if loss.requires_grad() {
                loss.backward();
                optimizer.step();
            }
        }

        // Fault temporal sequences: target = 1.0 for affected equipment
        for (seq, _onset, _fault, affected) in &fault_seqs {
            let target_vec = PanoptesTrainingData::fault_target(NUM_EQUIPMENT, affected);
            let fault_target = Variable::new(
                Tensor::from_vec(target_vec, &[1, NUM_EQUIPMENT]).unwrap(),
                false,
            );

            optimizer.zero_grad();
            let (equip_scores, _) = model.forward_temporal(seq);
            let loss = mse.compute(&equip_scores, &fault_target);
            fault_loss_sum += loss.data().to_vec()[0];
            fault_count += 1;

            if loss.requires_grad() {
                loss.backward();
                optimizer.step();
            }
        }

        // Validation
        let val_loss = evaluate_temporal_mixed(
            &model,
            &val_normal_seqs,
            &val_fault_seqs,
            &mse,
            &zero_target,
        );

        let avg_normal = normal_loss_sum / normal_count.max(1) as f32;
        let avg_fault = fault_loss_sum / fault_count.max(1) as f32;
        let elapsed = epoch_start.elapsed().as_secs_f32();

        println!(
            "  {:>5}  {:>12.6}  {:>12.6}  {:>12.6}  {:>6.1}s",
            epoch, avg_normal, avg_fault, val_loss, elapsed
        );
    }

    println!();

    // =========================================================================
    // Final evaluation
    // =========================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!(" FINAL EVALUATION");
    println!("═══════════════════════════════════════════════════════════════");

    // Test on normal data — scores should be near zero
    let config = FacilityConfig::warren();
    println!("\n  Normal operation (should be low scores):");
    for i in [0, 50, 100, 150] {
        if i >= normal_val.len() {
            break;
        }
        let (equip_scores, fac_score) = model.forward_snapshot(&normal_val[i]);
        let scores = equip_scores.data().to_vec();
        let fac = fac_score.data().to_vec()[0];
        let max_score = scores.iter().cloned().fold(0.0f32, f32::max);
        let avg_score: f32 = scores.iter().sum::<f32>() / scores.len() as f32;
        println!(
            "    Sample {i:>3}: facility={fac:.4}, avg_equip={avg_score:.4}, max_equip={max_score:.4}"
        );
    }

    // Test on fault data — affected equipment should have higher scores
    println!("\n  Fault samples (affected equipment should score higher):");
    for i in 0..5.min(fault_val.len()) {
        let (ref snap, ref fault, ref affected) = fault_val[i];
        let (equip_scores, fac_score) = model.forward_snapshot(snap);
        let scores = equip_scores.data().to_vec();
        let fac = fac_score.data().to_vec()[0];

        let output = PanoptesOutput::from_scores(&scores, fac, &config, 0.3);

        // Get scores for affected vs unaffected
        let affected_avg: f32 = if !affected.is_empty() {
            affected
                .iter()
                .filter(|&&s| s < scores.len())
                .map(|&s| scores[s])
                .sum::<f32>()
                / affected.len() as f32
        } else {
            0.0
        };

        println!("    Fault {:?}:", fault);
        println!(
            "      facility={fac:.4}, affected_avg={affected_avg:.4}, alerts={}",
            output.alerts.len()
        );
    }

    // Temporal evaluation
    println!("\n  Temporal normal (should be low scores):");
    for i in 0..3.min(val_normal_seqs.len()) {
        let (equip_scores, fac_score) = model.forward_temporal(&val_normal_seqs[i]);
        let scores = equip_scores.data().to_vec();
        let fac = fac_score.data().to_vec()[0];
        let max_score = scores.iter().cloned().fold(0.0f32, f32::max);
        let avg_score: f32 = scores.iter().sum::<f32>() / scores.len() as f32;
        println!(
            "    Seq {i:>3}: facility={fac:.4}, avg_equip={avg_score:.4}, max_equip={max_score:.4}"
        );
    }

    println!("\n  Temporal fault (fault injected mid-sequence):");
    for i in 0..5.min(val_fault_seqs.len()) {
        let (ref seq, onset, ref fault, ref affected) = val_fault_seqs[i];
        let (equip_scores, fac_score) = model.forward_temporal(seq);
        let scores = equip_scores.data().to_vec();
        let fac = fac_score.data().to_vec()[0];

        let affected_avg: f32 = if !affected.is_empty() {
            affected
                .iter()
                .filter(|&&s| s < scores.len())
                .map(|&s| scores[s])
                .sum::<f32>()
                / affected.len() as f32
        } else {
            0.0
        };
        let unaffected_avg: f32 = {
            let unaffected: Vec<f32> = scores
                .iter()
                .enumerate()
                .filter(|(idx, _)| !affected.contains(idx))
                .map(|(_, &s)| s)
                .collect();
            if unaffected.is_empty() {
                0.0
            } else {
                unaffected.iter().sum::<f32>() / unaffected.len() as f32
            }
        };

        let output = PanoptesOutput::from_scores(&scores, fac, &config, 0.3);
        println!(
            "    Fault {:?} (onset step {onset}/{TEMPORAL_WINDOW}):",
            fault
        );
        println!(
            "      facility={fac:.4}, affected={affected_avg:.4}, unaffected={unaffected_avg:.4}, alerts={}",
            output.alerts.len()
        );
    }

    println!();
    println!("Training complete.");
}

pub fn is_leaf(&self) -> bool

Returns whether this is a leaf variable.

pub fn grad(&self) -> Option<Tensor<f32>>

Returns the gradient of this variable.

Only available for leaf variables after backward() has been called.

pub fn grad_fn(&self) -> Option<&GradFn>

Returns the gradient function.

pub fn set_grad(&self, grad: Tensor<f32>)

Sets the gradient (used during backward pass).

pub fn accumulate_grad(&self, grad: &Tensor<f32>)

Accumulates gradient (adds to existing gradient).

pub fn zero_grad(&self)

Clears the gradient.

pub fn detach(&self) -> Variable

Detaches this variable from the computation graph.

Returns a new variable with the same data but no gradient history.

pub fn requires_grad_(self, requires_grad: bool) -> Variable

Returns a new variable with requires_grad set.

pub fn backward(&self)

Computes gradients via backpropagation.

This should only be called on scalar (single-element) tensors, typically the loss value.

Examples found in repository

examples/hvac_training.rs (line 796)

fn train_epoch(
    model: &HvacPredictor,
    optimizer: &mut Adam,
    loss_fn: &CrossEntropyLoss,
    x_data: &[f32],
    y_imminent: &[i64],
    y_warning: &[i64],
    y_early: &[i64],
    batch_size: usize,
    seq_len: usize,
    num_features: usize,
) -> (f32, f32, f32, f32) {
    let n_sequences = y_imminent.len();
    let n_batches = n_sequences / batch_size;

    let mut total_loss = 0.0f32;
    let mut total_acc_imm = 0.0f32;
    let mut total_acc_warn = 0.0f32;
    let mut total_acc_early = 0.0f32;

    for batch_idx in 0..n_batches {
        let start = batch_idx * batch_size;

        // Prepare batch data
        let mut batch_x = vec![0.0f32; batch_size * seq_len * num_features];
        let mut batch_y_imm = vec![0i64; batch_size];
        let mut batch_y_warn = vec![0i64; batch_size];
        let mut batch_y_early = vec![0i64; batch_size];

        for b in 0..batch_size {
            let seq_start = (start + b) * seq_len * num_features;
            for i in 0..(seq_len * num_features) {
                batch_x[b * seq_len * num_features + i] = x_data[seq_start + i];
            }
            batch_y_imm[b] = y_imminent[start + b];
            batch_y_warn[b] = y_warning[start + b];
            batch_y_early[b] = y_early[start + b];
        }

        // Create tensors
        let x_tensor = Tensor::from_vec(batch_x, &[batch_size, seq_len, num_features])
            .expect("Failed to create input tensor");
        let x_var = Variable::new(x_tensor, true);

        // Forward pass
        let (logits_imm, logits_warn, logits_early) = model.forward_multi(&x_var);

        // Calculate losses (simplified - just use imminent for now)
        let y_imm_tensor = Tensor::from_vec(
            batch_y_imm.iter().map(|&y| y as f32).collect(),
            &[batch_size],
        )
        .expect("Failed to create label tensor");
        let y_imm_var = Variable::new(y_imm_tensor, false);

        let loss = loss_fn.compute(&logits_imm, &y_imm_var);

        // Backward pass
        optimizer.zero_grad();
        loss.backward();
        optimizer.step();

        // Metrics
        total_loss += loss.data().to_vec()[0];
        total_acc_imm += calculate_accuracy(&logits_imm, &batch_y_imm);
        total_acc_warn += calculate_accuracy(&logits_warn, &batch_y_warn);
        total_acc_early += calculate_accuracy(&logits_early, &batch_y_early);
    }

    let n = n_batches as f32;
    (
        total_loss / n,
        total_acc_imm / n,
        total_acc_warn / n,
        total_acc_early / n,
    )
}

examples/simple_training.rs (line 80)

fn main() {
    println!("=== Axonml ML Framework - Simple Training Example ===\n");

    // Print version and features
    println!("Version: {}", axonml::version());
    println!("Features: {}\n", axonml::features());

    // 1. Create a simple dataset (XOR problem)
    println!("1. Creating XOR dataset...");
    let inputs = vec![
        vec![0.0, 0.0],
        vec![0.0, 1.0],
        vec![1.0, 0.0],
        vec![1.0, 1.0],
    ];
    let targets = vec![0.0, 1.0, 1.0, 0.0]; // XOR outputs

    println!("   Inputs: {inputs:?}");
    println!("   Targets: {targets:?}\n");

    // 2. Create a simple MLP model
    println!("2. Creating MLP model (2 -> 4 -> 1)...");
    let linear1 = Linear::new(2, 4);
    let linear2 = Linear::new(4, 1);

    println!("   Layer 1: Linear(2, 4)");
    println!("   Layer 2: Linear(4, 1)\n");

    // 3. Create optimizer
    println!("3. Creating Adam optimizer (lr=0.1)...");
    let params = [linear1.parameters(), linear2.parameters()].concat();
    let mut optimizer = Adam::new(params, 0.1);
    println!("   Optimizer created!\n");

    // 4. Training loop
    println!("4. Training for 1000 epochs...");
    let epochs = 1000;

    for epoch in 0..epochs {
        let mut total_loss = 0.0;

        for (input, &target) in inputs.iter().zip(targets.iter()) {
            // Create input tensor
            let x = Variable::new(Tensor::from_vec(input.clone(), &[1, 2]).unwrap(), true);

            // Forward pass
            let h = linear1.forward(&x);
            let h = h.sigmoid();
            let output = linear2.forward(&h);
            let output = output.sigmoid();

            // Create target tensor
            let y = Variable::new(Tensor::from_vec(vec![target], &[1, 1]).unwrap(), false);

            // Compute MSE loss manually: (output - target)^2
            let diff = output.sub_var(&y);
            let loss = diff.mul_var(&diff);

            total_loss += loss.data().to_vec()[0];

            // Backward pass
            loss.backward();

            // Update weights
            optimizer.step();
            optimizer.zero_grad();
        }

        if epoch % 200 == 0 || epoch == epochs - 1 {
            println!("   Epoch {}: Loss = {:.6}", epoch, total_loss / 4.0);
        }
    }

    // 5. Test the trained model
    println!("\n5. Testing trained model...");
    for (input, &expected) in inputs.iter().zip(targets.iter()) {
        let x = Variable::new(Tensor::from_vec(input.clone(), &[1, 2]).unwrap(), false);

        let h = linear1.forward(&x);
        let h = h.sigmoid();
        let output = linear2.forward(&h);
        let output = output.sigmoid();

        let pred = output.data().to_vec()[0];
        let rounded = if pred > 0.5 { 1.0 } else { 0.0 };

        println!(
            "   Input: {input:?} -> Predicted: {pred:.4} (rounded: {rounded}) | Expected: {expected}"
        );
    }

    println!("\n=== Training Complete! ===");
}

examples/mnist_training.rs (line 158)

fn main() {
    println!("=== AxonML - MNIST Training (LeNet) ===\n");

    // Detect device
    #[cfg(feature = "cuda")]
    let device = {
        let cuda = Device::Cuda(0);
        if cuda.is_available() {
            println!("GPU detected: using CUDA device 0");
            cuda
        } else {
            println!("CUDA feature enabled but no GPU available, using CPU");
            Device::Cpu
        }
    };
    #[cfg(not(feature = "cuda"))]
    let device = {
        println!("Using CPU (compile with --features cuda for GPU)");
        Device::Cpu
    };

    // 1. Create dataset
    let num_train = 2000;
    let num_test = 400;
    println!("\n1. Creating SyntheticMNIST dataset ({num_train} train, {num_test} test)...");
    let train_dataset = SyntheticMNIST::new(num_train);
    let test_dataset = SyntheticMNIST::new(num_test);

    // 2. Create DataLoader
    let batch_size = 64;
    println!("2. Creating DataLoader (batch_size={batch_size})...");
    let train_loader = DataLoader::new(train_dataset, batch_size);
    let test_loader = DataLoader::new(test_dataset, batch_size);
    println!("   Training batches: {}", train_loader.len());

    // 3. Create LeNet model and move to device
    println!("3. Creating LeNet model...");
    let model = LeNet::new();
    model.to_device(device);
    let params = model.parameters();
    let total_params: usize = params
        .iter()
        .map(|p| p.variable().data().to_vec().len())
        .sum();
    println!(
        "   Parameters: {} ({} total weights)",
        params.len(),
        total_params
    );
    println!("   Device: {:?}", device);

    // 4. Create optimizer and loss
    println!("4. Creating Adam optimizer (lr=0.001) + CrossEntropyLoss...");
    let mut optimizer = Adam::new(params, 0.001);
    let criterion = CrossEntropyLoss::new();

    // 5. Training loop
    let epochs = 10;
    println!("5. Training for {epochs} epochs...\n");

    let train_start = Instant::now();

    for epoch in 0..epochs {
        let epoch_start = Instant::now();
        let mut total_loss = 0.0;
        let mut correct = 0usize;
        let mut total = 0usize;
        let mut batch_count = 0;

        for batch in train_loader.iter() {
            let bs = batch.data.shape()[0];

            // Reshape to [N, 1, 28, 28] and create Variable
            let input_data = batch.data.to_vec();
            let input_tensor = Tensor::from_vec(input_data, &[bs, 1, 28, 28]).unwrap();
            let input = Variable::new(
                if device.is_gpu() {
                    input_tensor.to_device(device).unwrap()
                } else {
                    input_tensor
                },
                true,
            );

            // Target: convert one-hot [N, 10] to class indices [N]
            let target_onehot = batch.targets.to_vec();
            let mut target_indices = vec![0.0f32; bs];
            for i in 0..bs {
                let offset = i * 10;
                let mut max_idx = 0;
                let mut max_val = f32::NEG_INFINITY;
                for c in 0..10 {
                    if target_onehot[offset + c] > max_val {
                        max_val = target_onehot[offset + c];
                        max_idx = c;
                    }
                }
                target_indices[i] = max_idx as f32;
            }
            let target_tensor = Tensor::from_vec(target_indices.clone(), &[bs]).unwrap();
            let target = Variable::new(
                if device.is_gpu() {
                    target_tensor.to_device(device).unwrap()
                } else {
                    target_tensor
                },
                false,
            );

            // Forward pass
            let output = model.forward(&input);

            // Cross-entropy loss
            let loss = criterion.compute(&output, &target);

            let loss_val = loss.data().to_vec()[0];
            total_loss += loss_val;
            batch_count += 1;

            // Compute training accuracy
            let out_data = output.data().to_vec();
            for i in 0..bs {
                let offset = i * 10;
                let mut pred = 0;
                let mut pred_val = f32::NEG_INFINITY;
                for c in 0..10 {
                    if out_data[offset + c] > pred_val {
                        pred_val = out_data[offset + c];
                        pred = c;
                    }
                }
                if pred == target_indices[i] as usize {
                    correct += 1;
                }
                total += 1;
            }

            // Backward pass
            loss.backward();

            // Update weights
            optimizer.step();
            optimizer.zero_grad();
        }

        let epoch_time = epoch_start.elapsed();
        let avg_loss = total_loss / batch_count as f32;
        let accuracy = 100.0 * correct as f32 / total as f32;
        let samples_per_sec = total as f64 / epoch_time.as_secs_f64();

        println!(
            "   Epoch {:2}/{}: Loss={:.4}  Acc={:.1}%  ({:.0} samples/s, {:.2}s)",
            epoch + 1,
            epochs,
            avg_loss,
            accuracy,
            samples_per_sec,
            epoch_time.as_secs_f64(),
        );
    }

    let train_time = train_start.elapsed();
    println!("\n   Total training time: {:.2}s", train_time.as_secs_f64());

    // 6. Test evaluation
    println!("\n6. Evaluating on test set...");

    // Disable gradient computation for evaluation
    let (correct, total) = no_grad(|| {
        let mut correct = 0usize;
        let mut total = 0usize;

        for batch in test_loader.iter() {
            let bs = batch.data.shape()[0];

            let input_data = batch.data.to_vec();
            let input_tensor = Tensor::from_vec(input_data, &[bs, 1, 28, 28]).unwrap();
            let input = Variable::new(
                if device.is_gpu() {
                    input_tensor.to_device(device).unwrap()
                } else {
                    input_tensor
                },
                false,
            );

            let target_onehot = batch.targets.to_vec();
            let output = model.forward(&input);
            let out_data = output.data().to_vec();

            for i in 0..bs {
                // Prediction: argmax of output
                let offset = i * 10;
                let mut pred = 0;
                let mut pred_val = f32::NEG_INFINITY;
                for c in 0..10 {
                    if out_data[offset + c] > pred_val {
                        pred_val = out_data[offset + c];
                        pred = c;
                    }
                }

                // True label: argmax of one-hot target
                let mut true_label = 0;
                let mut true_val = f32::NEG_INFINITY;
                for c in 0..10 {
                    if target_onehot[i * 10 + c] > true_val {
                        true_val = target_onehot[i * 10 + c];
                        true_label = c;
                    }
                }

                if pred == true_label {
                    correct += 1;
                }
                total += 1;
            }
        }

        (correct, total)
    });

    let test_accuracy = 100.0 * correct as f32 / total as f32;
    println!(
        "   Test Accuracy: {}/{} ({:.2}%)",
        correct, total, test_accuracy
    );

    println!("\n=== Training Complete! ===");
    println!("   Device: {:?}", device);
    println!("   Final test accuracy: {:.2}%", test_accuracy);
}

examples/train_panoptes.rs (line 137)

fn main() {
    println!("╔══════════════════════════════════════════════════════════════╗");
    println!("║     PANOPTES — Facility-Wide Anomaly Detection Training     ║");
    println!("║     Heritage Pointe of Warren (59 equipment)                ║");
    println!("╚══════════════════════════════════════════════════════════════╝");
    println!();

    // =========================================================================
    // Generate training data
    // =========================================================================
    println!("[data] Generating physics-informed training data...");
    let t0 = Instant::now();

    let sim = WarrenSimulator::new(SEED);
    let normal_train = sim.generate_normal(NORMAL_SAMPLES);
    let fault_data = sim.generate_with_faults(FAULT_SAMPLES, 1.0);

    // Validation set (different seed)
    let val_sim = WarrenSimulator::new(SEED + 999);
    let normal_val = val_sim.generate_normal(200);
    let fault_val = val_sim.generate_with_faults(100, 1.0);

    println!("  Normal train: {} samples", normal_train.len());
    println!("  Fault train:  {} samples", fault_data.len());
    println!("  Normal val:   {} samples", normal_val.len());
    println!("  Fault val:    {} samples", fault_val.len());
    println!("  Generated in {:.1}s", t0.elapsed().as_secs_f32());
    println!();

    // =========================================================================
    // Create model
    // =========================================================================
    let model = Panoptes::new(NUM_EQUIPMENT);
    println!("[model] Panoptes created");
    println!("  Equipment slots: {NUM_EQUIPMENT}");
    println!("  Parameters: {}", model.num_parameters());
    println!("  Embed dim: {EMBED_DIM}");
    println!();

    let mse = MSELoss::new();

    // Zero target for normal operation
    let zero_target = Variable::new(
        Tensor::from_vec(vec![0.0; NUM_EQUIPMENT], &[1, NUM_EQUIPMENT]).unwrap(),
        false,
    );

    // =========================================================================
    // Phase 1: Learn normal operation
    // =========================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!(" PHASE 1: Learning Normal Operation ({PHASE1_EPOCHS} epochs)");
    println!("═══════════════════════════════════════════════════════════════");
    println!(
        "  {:>5}  {:>12}  {:>12}  {:>8}",
        "Epoch", "Train Loss", "Val Loss", "Time"
    );
    println!("  {:-<5}  {:-<12}  {:-<12}  {:-<8}", "", "", "", "");

    let params = model.parameters();
    let mut optimizer = Adam::new(params, LR);

    for epoch in 1..=PHASE1_EPOCHS {
        let epoch_start = Instant::now();
        let mut epoch_loss = 0.0f32;
        let mut batch_count = 0;

        // Train on normal data: target = all zeros
        for batch_start in (0..normal_train.len()).step_by(BATCH_SIZE) {
            let batch_end = (batch_start + BATCH_SIZE).min(normal_train.len());

            for i in batch_start..batch_end {
                optimizer.zero_grad();

                let (equip_scores, _) = model.forward_snapshot(&normal_train[i]);
                let loss = mse.compute(&equip_scores, &zero_target);
                let loss_val = loss.data().to_vec()[0];
                epoch_loss += loss_val;
                batch_count += 1;

                if loss.requires_grad() {
                    loss.backward();
                    optimizer.step();
                }
            }
        }

        // Validation
        let val_loss = evaluate_normal(&model, &normal_val, &mse, &zero_target);

        let avg_loss = epoch_loss / batch_count as f32;
        let elapsed = epoch_start.elapsed().as_secs_f32();

        println!(
            "  {:>5}  {:>12.6}  {:>12.6}  {:>6.1}s",
            epoch, avg_loss, val_loss, elapsed
        );
    }

    println!();

    // =========================================================================
    // Phase 2: Learn fault signatures
    // =========================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!(" PHASE 2: Learning Fault Signatures ({PHASE2_EPOCHS} epochs)");
    println!("═══════════════════════════════════════════════════════════════");
    println!(
        "  {:>5}  {:>12}  {:>12}  {:>12}  {:>8}",
        "Epoch", "Normal Loss", "Fault Loss", "Val Loss", "Time"
    );
    println!(
        "  {:-<5}  {:-<12}  {:-<12}  {:-<12}  {:-<8}",
        "", "", "", "", ""
    );

    // Reset optimizer with lower LR for phase 2
    let params = model.parameters();
    let mut optimizer = Adam::new(params, LR * 0.5);

    for epoch in 1..=PHASE2_EPOCHS {
        let epoch_start = Instant::now();
        let mut normal_loss_sum = 0.0f32;
        let mut fault_loss_sum = 0.0f32;
        let mut normal_count = 0;
        let mut fault_count = 0;

        // Interleave normal + fault samples
        let normal_per_epoch = NORMAL_SAMPLES / 2; // Use half of normal data
        let fault_per_epoch = fault_data.len();

        // Normal samples: target = zeros
        for i in 0..normal_per_epoch.min(normal_train.len()) {
            optimizer.zero_grad();
            let (equip_scores, _) = model.forward_snapshot(&normal_train[i]);
            let loss = mse.compute(&equip_scores, &zero_target);
            normal_loss_sum += loss.data().to_vec()[0];
            normal_count += 1;

            if loss.requires_grad() {
                loss.backward();
                optimizer.step();
            }
        }

        // Fault samples: target = 1.0 for affected equipment
        for i in 0..fault_per_epoch {
            let (ref snap, ref _fault, ref affected) = fault_data[i];

            let target_vec = PanoptesTrainingData::fault_target(NUM_EQUIPMENT, affected);
            let fault_target = Variable::new(
                Tensor::from_vec(target_vec, &[1, NUM_EQUIPMENT]).unwrap(),
                false,
            );

            optimizer.zero_grad();
            let (equip_scores, _) = model.forward_snapshot(snap);
            let loss = mse.compute(&equip_scores, &fault_target);
            fault_loss_sum += loss.data().to_vec()[0];
            fault_count += 1;

            if loss.requires_grad() {
                loss.backward();
                optimizer.step();
            }
        }

        // Validation
        let val_loss = evaluate_mixed(&model, &normal_val, &fault_val, &mse, &zero_target);

        let avg_normal = normal_loss_sum / normal_count.max(1) as f32;
        let avg_fault = fault_loss_sum / fault_count.max(1) as f32;
        let elapsed = epoch_start.elapsed().as_secs_f32();

        println!(
            "  {:>5}  {:>12.6}  {:>12.6}  {:>12.6}  {:>6.1}s",
            epoch, avg_normal, avg_fault, val_loss, elapsed
        );
    }

    println!();

    // =========================================================================
    // Phase 3: Temporal training
    // =========================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!(" PHASE 3: Temporal Training ({PHASE3_EPOCHS} epochs, window={TEMPORAL_WINDOW})");
    println!("═══════════════════════════════════════════════════════════════");

    // Generate temporal sequences
    println!("[data] Generating temporal sequences...");
    let t0 = Instant::now();

    // Normal temporal sequences: varied starting OAT, slow drift
    let mut normal_seqs: Vec<Vec<FacilitySnapshot>> = Vec::new();
    for i in 0..TEMPORAL_NORMAL_SEQS {
        let start_oat = -5.0 + (i as f32 / TEMPORAL_NORMAL_SEQS as f32) * 100.0;
        let drift = if start_oat < 50.0 { 0.2 } else { -0.1 }; // warming up or cooling down
        let seq_sim = WarrenSimulator::new(SEED + 5000 + i as u64);
        let seq = seq_sim.generate_temporal_sequence(TEMPORAL_WINDOW, start_oat, drift);
        normal_seqs.push(seq);
    }

    // Fault temporal sequences: fault injected mid-sequence
    let mut fault_seqs: Vec<(Vec<FacilitySnapshot>, usize, FaultType, Vec<usize>)> = Vec::new();
    for i in 0..TEMPORAL_FAULT_SEQS {
        let start_oat = -5.0 + (i as f32 / TEMPORAL_FAULT_SEQS as f32) * 100.0;
        let drift = 0.1;
        let seq_sim = WarrenSimulator::new(SEED + 8000 + i as u64);
        let seq_data =
            seq_sim.generate_temporal_with_fault(TEMPORAL_WINDOW, start_oat, drift, i as u64);
        fault_seqs.push(seq_data);
    }

    // Validation temporal sequences
    let mut val_normal_seqs: Vec<Vec<FacilitySnapshot>> = Vec::new();
    for i in 0..20 {
        let start_oat = 10.0 + (i as f32 / 20.0) * 80.0;
        let seq_sim = WarrenSimulator::new(SEED + 9000 + i as u64);
        let seq = seq_sim.generate_temporal_sequence(TEMPORAL_WINDOW, start_oat, 0.15);
        val_normal_seqs.push(seq);
    }

    let mut val_fault_seqs: Vec<(Vec<FacilitySnapshot>, usize, FaultType, Vec<usize>)> = Vec::new();
    for i in 0..20 {
        let start_oat = 10.0 + (i as f32 / 20.0) * 80.0;
        let seq_sim = WarrenSimulator::new(SEED + 9500 + i as u64);
        let seq_data =
            seq_sim.generate_temporal_with_fault(TEMPORAL_WINDOW, start_oat, 0.1, i as u64);
        val_fault_seqs.push(seq_data);
    }

    println!("  Normal temporal seqs: {}", normal_seqs.len());
    println!("  Fault temporal seqs:  {}", fault_seqs.len());
    println!("  Val normal seqs:      {}", val_normal_seqs.len());
    println!("  Val fault seqs:       {}", val_fault_seqs.len());
    println!("  Window size: {TEMPORAL_WINDOW} snapshots (1 hour)");
    println!("  Generated in {:.1}s", t0.elapsed().as_secs_f32());
    println!();

    println!(
        "  {:>5}  {:>12}  {:>12}  {:>12}  {:>8}",
        "Epoch", "Normal Loss", "Fault Loss", "Val Loss", "Time"
    );
    println!(
        "  {:-<5}  {:-<12}  {:-<12}  {:-<12}  {:-<8}",
        "", "", "", "", ""
    );

    // Lower LR for temporal fine-tuning
    let params = model.parameters();
    let mut optimizer = Adam::new(params, LR * 0.3);

    for epoch in 1..=PHASE3_EPOCHS {
        let epoch_start = Instant::now();
        let mut normal_loss_sum = 0.0f32;
        let mut fault_loss_sum = 0.0f32;
        let mut normal_count = 0;
        let mut fault_count = 0;

        // Normal temporal sequences: target = all zeros
        for seq in &normal_seqs {
            optimizer.zero_grad();
            let (equip_scores, _) = model.forward_temporal(seq);
            let loss = mse.compute(&equip_scores, &zero_target);
            normal_loss_sum += loss.data().to_vec()[0];
            normal_count += 1;

            if loss.requires_grad() {
                loss.backward();
                optimizer.step();
            }
        }

        // Fault temporal sequences: target = 1.0 for affected equipment
        for (seq, _onset, _fault, affected) in &fault_seqs {
            let target_vec = PanoptesTrainingData::fault_target(NUM_EQUIPMENT, affected);
            let fault_target = Variable::new(
                Tensor::from_vec(target_vec, &[1, NUM_EQUIPMENT]).unwrap(),
                false,
            );

            optimizer.zero_grad();
            let (equip_scores, _) = model.forward_temporal(seq);
            let loss = mse.compute(&equip_scores, &fault_target);
            fault_loss_sum += loss.data().to_vec()[0];
            fault_count += 1;

            if loss.requires_grad() {
                loss.backward();
                optimizer.step();
            }
        }

        // Validation
        let val_loss = evaluate_temporal_mixed(
            &model,
            &val_normal_seqs,
            &val_fault_seqs,
            &mse,
            &zero_target,
        );

        let avg_normal = normal_loss_sum / normal_count.max(1) as f32;
        let avg_fault = fault_loss_sum / fault_count.max(1) as f32;
        let elapsed = epoch_start.elapsed().as_secs_f32();

        println!(
            "  {:>5}  {:>12.6}  {:>12.6}  {:>12.6}  {:>6.1}s",
            epoch, avg_normal, avg_fault, val_loss, elapsed
        );
    }

    println!();

    // =========================================================================
    // Final evaluation
    // =========================================================================
    println!("═══════════════════════════════════════════════════════════════");
    println!(" FINAL EVALUATION");
    println!("═══════════════════════════════════════════════════════════════");

    // Test on normal data — scores should be near zero
    let config = FacilityConfig::warren();
    println!("\n  Normal operation (should be low scores):");
    for i in [0, 50, 100, 150] {
        if i >= normal_val.len() {
            break;
        }
        let (equip_scores, fac_score) = model.forward_snapshot(&normal_val[i]);
        let scores = equip_scores.data().to_vec();
        let fac = fac_score.data().to_vec()[0];
        let max_score = scores.iter().cloned().fold(0.0f32, f32::max);
        let avg_score: f32 = scores.iter().sum::<f32>() / scores.len() as f32;
        println!(
            "    Sample {i:>3}: facility={fac:.4}, avg_equip={avg_score:.4}, max_equip={max_score:.4}"
        );
    }

    // Test on fault data — affected equipment should have higher scores
    println!("\n  Fault samples (affected equipment should score higher):");
    for i in 0..5.min(fault_val.len()) {
        let (ref snap, ref fault, ref affected) = fault_val[i];
        let (equip_scores, fac_score) = model.forward_snapshot(snap);
        let scores = equip_scores.data().to_vec();
        let fac = fac_score.data().to_vec()[0];

        let output = PanoptesOutput::from_scores(&scores, fac, &config, 0.3);

        // Get scores for affected vs unaffected
        let affected_avg: f32 = if !affected.is_empty() {
            affected
                .iter()
                .filter(|&&s| s < scores.len())
                .map(|&s| scores[s])
                .sum::<f32>()
                / affected.len() as f32
        } else {
            0.0
        };

        println!("    Fault {:?}:", fault);
        println!(
            "      facility={fac:.4}, affected_avg={affected_avg:.4}, alerts={}",
            output.alerts.len()
        );
    }

    // Temporal evaluation
    println!("\n  Temporal normal (should be low scores):");
    for i in 0..3.min(val_normal_seqs.len()) {
        let (equip_scores, fac_score) = model.forward_temporal(&val_normal_seqs[i]);
        let scores = equip_scores.data().to_vec();
        let fac = fac_score.data().to_vec()[0];
        let max_score = scores.iter().cloned().fold(0.0f32, f32::max);
        let avg_score: f32 = scores.iter().sum::<f32>() / scores.len() as f32;
        println!(
            "    Seq {i:>3}: facility={fac:.4}, avg_equip={avg_score:.4}, max_equip={max_score:.4}"
        );
    }

    println!("\n  Temporal fault (fault injected mid-sequence):");
    for i in 0..5.min(val_fault_seqs.len()) {
        let (ref seq, onset, ref fault, ref affected) = val_fault_seqs[i];
        let (equip_scores, fac_score) = model.forward_temporal(seq);
        let scores = equip_scores.data().to_vec();
        let fac = fac_score.data().to_vec()[0];

        let affected_avg: f32 = if !affected.is_empty() {
            affected
                .iter()
                .filter(|&&s| s < scores.len())
                .map(|&s| scores[s])
                .sum::<f32>()
                / affected.len() as f32
        } else {
            0.0
        };
        let unaffected_avg: f32 = {
            let unaffected: Vec<f32> = scores
                .iter()
                .enumerate()
                .filter(|(idx, _)| !affected.contains(idx))
                .map(|(_, &s)| s)
                .collect();
            if unaffected.is_empty() {
                0.0
            } else {
                unaffected.iter().sum::<f32>() / unaffected.len() as f32
            }
        };

        let output = PanoptesOutput::from_scores(&scores, fac, &config, 0.3);
        println!(
            "    Fault {:?} (onset step {onset}/{TEMPORAL_WINDOW}):",
            fault
        );
        println!(
            "      facility={fac:.4}, affected={affected_avg:.4}, unaffected={unaffected_avg:.4}, alerts={}",
            output.alerts.len()
        );
    }

    println!();
    println!("Training complete.");
}

pub fn backward_with_grad(&self, grad_output: &Tensor<f32>)

Runs the backward pass with a provided gradient tensor.

Unlike backward(), this does not require the variable to be scalar. The gradient tensor must match the shape of this variable.

pub fn add_var(&self, other: &Variable) -> Variable

Element-wise addition.

pub fn sub_var(&self, other: &Variable) -> Variable

Element-wise subtraction.

Examples found in repository

examples/simple_training.rs (line 74)

fn main() {
    println!("=== Axonml ML Framework - Simple Training Example ===\n");

    // Print version and features
    println!("Version: {}", axonml::version());
    println!("Features: {}\n", axonml::features());

    // 1. Create a simple dataset (XOR problem)
    println!("1. Creating XOR dataset...");
    let inputs = vec![
        vec![0.0, 0.0],
        vec![0.0, 1.0],
        vec![1.0, 0.0],
        vec![1.0, 1.0],
    ];
    let targets = vec![0.0, 1.0, 1.0, 0.0]; // XOR outputs

    println!("   Inputs: {inputs:?}");
    println!("   Targets: {targets:?}\n");

    // 2. Create a simple MLP model
    println!("2. Creating MLP model (2 -> 4 -> 1)...");
    let linear1 = Linear::new(2, 4);
    let linear2 = Linear::new(4, 1);

    println!("   Layer 1: Linear(2, 4)");
    println!("   Layer 2: Linear(4, 1)\n");

    // 3. Create optimizer
    println!("3. Creating Adam optimizer (lr=0.1)...");
    let params = [linear1.parameters(), linear2.parameters()].concat();
    let mut optimizer = Adam::new(params, 0.1);
    println!("   Optimizer created!\n");

    // 4. Training loop
    println!("4. Training for 1000 epochs...");
    let epochs = 1000;

    for epoch in 0..epochs {
        let mut total_loss = 0.0;

        for (input, &target) in inputs.iter().zip(targets.iter()) {
            // Create input tensor
            let x = Variable::new(Tensor::from_vec(input.clone(), &[1, 2]).unwrap(), true);

            // Forward pass
            let h = linear1.forward(&x);
            let h = h.sigmoid();
            let output = linear2.forward(&h);
            let output = output.sigmoid();

            // Create target tensor
            let y = Variable::new(Tensor::from_vec(vec![target], &[1, 1]).unwrap(), false);

            // Compute MSE loss manually: (output - target)^2
            let diff = output.sub_var(&y);
            let loss = diff.mul_var(&diff);

            total_loss += loss.data().to_vec()[0];

            // Backward pass
            loss.backward();

            // Update weights
            optimizer.step();
            optimizer.zero_grad();
        }

        if epoch % 200 == 0 || epoch == epochs - 1 {
            println!("   Epoch {}: Loss = {:.6}", epoch, total_loss / 4.0);
        }
    }

    // 5. Test the trained model
    println!("\n5. Testing trained model...");
    for (input, &expected) in inputs.iter().zip(targets.iter()) {
        let x = Variable::new(Tensor::from_vec(input.clone(), &[1, 2]).unwrap(), false);

        let h = linear1.forward(&x);
        let h = h.sigmoid();
        let output = linear2.forward(&h);
        let output = output.sigmoid();

        let pred = output.data().to_vec()[0];
        let rounded = if pred > 0.5 { 1.0 } else { 0.0 };

        println!(
            "   Input: {input:?} -> Predicted: {pred:.4} (rounded: {rounded}) | Expected: {expected}"
        );
    }

    println!("\n=== Training Complete! ===");
}

pub fn mul_var(&self, other: &Variable) -> Variable

Element-wise multiplication.

Examples found in repository

examples/simple_training.rs (line 75)

fn main() {
    println!("=== Axonml ML Framework - Simple Training Example ===\n");

    // Print version and features
    println!("Version: {}", axonml::version());
    println!("Features: {}\n", axonml::features());

    // 1. Create a simple dataset (XOR problem)
    println!("1. Creating XOR dataset...");
    let inputs = vec![
        vec![0.0, 0.0],
        vec![0.0, 1.0],
        vec![1.0, 0.0],
        vec![1.0, 1.0],
    ];
    let targets = vec![0.0, 1.0, 1.0, 0.0]; // XOR outputs

    println!("   Inputs: {inputs:?}");
    println!("   Targets: {targets:?}\n");

    // 2. Create a simple MLP model
    println!("2. Creating MLP model (2 -> 4 -> 1)...");
    let linear1 = Linear::new(2, 4);
    let linear2 = Linear::new(4, 1);

    println!("   Layer 1: Linear(2, 4)");
    println!("   Layer 2: Linear(4, 1)\n");

    // 3. Create optimizer
    println!("3. Creating Adam optimizer (lr=0.1)...");
    let params = [linear1.parameters(), linear2.parameters()].concat();
    let mut optimizer = Adam::new(params, 0.1);
    println!("   Optimizer created!\n");

    // 4. Training loop
    println!("4. Training for 1000 epochs...");
    let epochs = 1000;

    for epoch in 0..epochs {
        let mut total_loss = 0.0;

        for (input, &target) in inputs.iter().zip(targets.iter()) {
            // Create input tensor
            let x = Variable::new(Tensor::from_vec(input.clone(), &[1, 2]).unwrap(), true);

            // Forward pass
            let h = linear1.forward(&x);
            let h = h.sigmoid();
            let output = linear2.forward(&h);
            let output = output.sigmoid();

            // Create target tensor
            let y = Variable::new(Tensor::from_vec(vec![target], &[1, 1]).unwrap(), false);

            // Compute MSE loss manually: (output - target)^2
            let diff = output.sub_var(&y);
            let loss = diff.mul_var(&diff);

            total_loss += loss.data().to_vec()[0];

            // Backward pass
            loss.backward();

            // Update weights
            optimizer.step();
            optimizer.zero_grad();
        }

        if epoch % 200 == 0 || epoch == epochs - 1 {
            println!("   Epoch {}: Loss = {:.6}", epoch, total_loss / 4.0);
        }
    }

    // 5. Test the trained model
    println!("\n5. Testing trained model...");
    for (input, &expected) in inputs.iter().zip(targets.iter()) {
        let x = Variable::new(Tensor::from_vec(input.clone(), &[1, 2]).unwrap(), false);

        let h = linear1.forward(&x);
        let h = h.sigmoid();
        let output = linear2.forward(&h);
        let output = output.sigmoid();

        let pred = output.data().to_vec()[0];
        let rounded = if pred > 0.5 { 1.0 } else { 0.0 };

        println!(
            "   Input: {input:?} -> Predicted: {pred:.4} (rounded: {rounded}) | Expected: {expected}"
        );
    }

    println!("\n=== Training Complete! ===");
}

pub fn div_var(&self, other: &Variable) -> Variable

Element-wise division.

pub fn neg_var(&self) -> Variable

Negation.

pub fn matmul(&self, other: &Variable) -> Variable

Matrix multiplication.

pub fn pow(&self, exponent: f32) -> Variable

Power operation.

pub fn relu(&self) -> Variable

ReLU activation.

pub fn leaky_relu(&self, negative_slope: f32) -> Variable

Leaky ReLU activation.

pub fn elu(&self, alpha: f32) -> Variable

ELU activation.

pub fn sigmoid(&self) -> Variable

Sigmoid activation.

Examples found in repository

examples/simple_training.rs (line 66)

fn main() {
    println!("=== Axonml ML Framework - Simple Training Example ===\n");

    // Print version and features
    println!("Version: {}", axonml::version());
    println!("Features: {}\n", axonml::features());

    // 1. Create a simple dataset (XOR problem)
    println!("1. Creating XOR dataset...");
    let inputs = vec![
        vec![0.0, 0.0],
        vec![0.0, 1.0],
        vec![1.0, 0.0],
        vec![1.0, 1.0],
    ];
    let targets = vec![0.0, 1.0, 1.0, 0.0]; // XOR outputs

    println!("   Inputs: {inputs:?}");
    println!("   Targets: {targets:?}\n");

    // 2. Create a simple MLP model
    println!("2. Creating MLP model (2 -> 4 -> 1)...");
    let linear1 = Linear::new(2, 4);
    let linear2 = Linear::new(4, 1);

    println!("   Layer 1: Linear(2, 4)");
    println!("   Layer 2: Linear(4, 1)\n");

    // 3. Create optimizer
    println!("3. Creating Adam optimizer (lr=0.1)...");
    let params = [linear1.parameters(), linear2.parameters()].concat();
    let mut optimizer = Adam::new(params, 0.1);
    println!("   Optimizer created!\n");

    // 4. Training loop
    println!("4. Training for 1000 epochs...");
    let epochs = 1000;

    for epoch in 0..epochs {
        let mut total_loss = 0.0;

        for (input, &target) in inputs.iter().zip(targets.iter()) {
            // Create input tensor
            let x = Variable::new(Tensor::from_vec(input.clone(), &[1, 2]).unwrap(), true);

            // Forward pass
            let h = linear1.forward(&x);
            let h = h.sigmoid();
            let output = linear2.forward(&h);
            let output = output.sigmoid();

            // Create target tensor
            let y = Variable::new(Tensor::from_vec(vec![target], &[1, 1]).unwrap(), false);

            // Compute MSE loss manually: (output - target)^2
            let diff = output.sub_var(&y);
            let loss = diff.mul_var(&diff);

            total_loss += loss.data().to_vec()[0];

            // Backward pass
            loss.backward();

            // Update weights
            optimizer.step();
            optimizer.zero_grad();
        }

        if epoch % 200 == 0 || epoch == epochs - 1 {
            println!("   Epoch {}: Loss = {:.6}", epoch, total_loss / 4.0);
        }
    }

    // 5. Test the trained model
    println!("\n5. Testing trained model...");
    for (input, &expected) in inputs.iter().zip(targets.iter()) {
        let x = Variable::new(Tensor::from_vec(input.clone(), &[1, 2]).unwrap(), false);

        let h = linear1.forward(&x);
        let h = h.sigmoid();
        let output = linear2.forward(&h);
        let output = output.sigmoid();

        let pred = output.data().to_vec()[0];
        let rounded = if pred > 0.5 { 1.0 } else { 0.0 };

        println!(
            "   Input: {input:?} -> Predicted: {pred:.4} (rounded: {rounded}) | Expected: {expected}"
        );
    }

    println!("\n=== Training Complete! ===");
}

pub fn tanh(&self) -> Variable

Tanh activation.

pub fn exp(&self) -> Variable

Element-wise exponential.

pub fn log(&self) -> Variable

Element-wise natural logarithm.

pub fn clamp(&self, min_val: f32, max_val: f32) -> Variable

Element-wise clamp to [min_val, max_val].

pub fn sum(&self) -> Variable

Sum all elements.

pub fn sum_dim(&self, dim: usize) -> Variable

Sum along a dimension, removing that dimension.

pub fn mean(&self) -> Variable

Mean of all elements.

pub fn mse_loss(&self, target: &Variable) -> Variable

Mean Squared Error loss.

pub fn binary_cross_entropy(&self, target: &Variable) -> Variable

Binary Cross Entropy loss (expects sigmoid output).

pub fn reshape(&self, shape: &[usize]) -> Variable

Reshapes the variable to a new shape.

Examples found in repository

examples/hvac_training.rs (line 623)

    pub fn forward_multi(&self, x: &Variable) -> (Variable, Variable, Variable) {
        let x_data = x.data();
        let shape = x_data.shape();
        let batch_size = shape[0];
        let seq_len = shape[1];
        drop(x_data);

        let x_flat = x.reshape(&[batch_size * seq_len, self.config.num_features]);
        let proj = self.input_proj.forward(&x_flat);
        let proj = self.input_norm.forward(&proj);
        let proj = self.input_relu.forward(&proj);
        let proj = proj.reshape(&[batch_size, seq_len, self.config.hidden_size]);

        // Use forward_mean for proper gradient flow (equivalent to forward + mean_pool)
        let pooled = self.gru.forward_mean(&proj);

        let imminent = self.head_imminent.forward(&pooled);
        let warning = self.head_warning.forward(&pooled);
        let early = self.head_early.forward(&pooled);

        (imminent, warning, early)
    }

examples/hvac_model.rs (line 203)

    pub fn forward_multi(&self, x: &Variable) -> HvacOutput {
        let x_data = x.data();
        let shape = x_data.shape();
        let batch_size = shape[0];
        let seq_len = shape[1];
        drop(x_data); // Release borrow

        // Input projection: [batch, seq, features] -> [batch, seq, hidden]
        // Reshape for linear: [batch * seq, features]
        let x_flat = x.reshape(&[batch_size * seq_len, self.config.num_features]);
        let proj = self.input_proj.forward(&x_flat);
        let proj = self.input_norm.forward(&proj);
        let proj = self.input_relu.forward(&proj);
        let proj = proj.reshape(&[batch_size, seq_len, self.config.hidden_size]);

        // GRU encoding: [batch, seq, hidden] -> [batch, seq, hidden]
        let encoded = self.gru.forward(&proj);

        // Mean pooling: [batch, seq, hidden] -> [batch, hidden]
        let pooled = self.mean_pool(&encoded);

        // Prediction heads
        let imminent_logits = self.head_imminent.forward(&pooled);
        let warning_logits = self.head_warning.forward(&pooled);
        let early_logits = self.head_early.forward(&pooled);

        HvacOutput {
            imminent_logits,
            warning_logits,
            early_logits,
        }
    }

pub fn flatten(&self, start_dim: usize) -> Variable

Flattens all dimensions from start_dim to the end into a single dimension.

flatten(1) on a [batch, C, H, W] tensor produces [batch, C*H*W]. flatten(0) flattens everything into a 1D vector.

pub fn transpose(&self, dim0: usize, dim1: usize) -> Variable

Transposes two dimensions.

pub fn slice(&self, ranges: &[Range<usize>]) -> Variable

Slices the variable along specified ranges.

pub fn narrow(&self, dim: usize, start: usize, length: usize) -> Variable

Narrows the variable along a dimension.

Returns a view of the tensor containing elements from start to start + length along the specified dimension. This operation preserves gradients for backpropagation.

pub fn expand(&self, shape: &[usize]) -> Variable

Expands the variable to a new shape (broadcast).

Tracks the computational graph for backward pass.

pub fn select(&self, dim: usize, index: usize) -> Variable

Selects a single index along a dimension, reducing rank by 1.

For a tensor of shape (A, B, C), select(1, i) returns shape (A, C). Tracks the computational graph for backward pass.

pub fn unsqueeze(&self, dim: usize) -> Variable

Adds a dimension of size 1 at the given position.

Tracks the computational graph for backward pass.

pub fn cat(variables: &[&Variable], dim: usize) -> Variable

Concatenates variables along a dimension.

All variables must have the same shape except along the cat dimension. Tracks the computational graph for backpropagation.

pub fn mul_scalar(&self, scalar: f32) -> Variable

Multiplies by a scalar.

pub fn add_scalar(&self, scalar: f32) -> Variable

Adds a scalar.

pub fn sub_scalar(&self, scalar: f32) -> Variable

Subtracts a scalar.

pub fn div_scalar(&self, scalar: f32) -> Variable

Divides by a scalar.

pub fn gelu(&self) -> Variable

GELU activation function (Gaussian Error Linear Unit).

pub fn silu(&self) -> Variable

SiLU/Swish activation function (x * sigmoid(x)).

pub fn sqrt(&self) -> Variable

Square root.

pub fn softmax(&self, dim: i32) -> Variable

Softmax along specified dimension.

pub fn log_softmax(&self, dim: i32) -> Variable

Log softmax along specified dimension.

pub fn mean_dim(&self, dim: i32, keepdim: bool) -> Variable

Mean along a dimension, optionally keeping the dimension.

pub fn var_dim(&self, dim: i32, keepdim: bool) -> Variable

Variance along a dimension, optionally keeping the dimension.

pub fn from_tensor_with_grad(data: Tensor<f32>, requires_grad: bool) -> Variable

Creates a Variable from a tensor and requires_grad flag (for weight access). This is typically used internally by Parameter types.

pub fn clone_var(&self) -> Variable

Clones the variable (alias for Clone trait).

pub fn add(&self, other: &Variable) -> Variable

Adds another variable (alias for add_var for method chaining).

pub fn sub(&self, other: &Variable) -> Variable

Subtracts another variable (alias for sub_var for method chaining).

pub fn mul(&self, other: &Variable) -> Variable

Multiplies by another variable (alias for mul_var for method chaining).

pub fn div(&self, other: &Variable) -> Variable

Divides by another variable (alias for div_var for method chaining).

Trait Implementations

impl Add for &Variable

type Output = Variable

The resulting type after applying the + operator.

fn add(self, other: &Variable) -> Variable

Performs the + operation.

impl Clone for Variable

fn clone(&self) -> Variable

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Variable

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Div for &Variable

type Output = Variable

The resulting type after applying the / operator.

fn div(self, other: &Variable) -> Variable

Performs the / operation.

impl Mul for &Variable

type Output = Variable

The resulting type after applying the * operator.

fn mul(self, other: &Variable) -> Variable

Performs the * operation.

impl Neg for &Variable

type Output = Variable

The resulting type after applying the - operator.

fn neg(self) -> Variable

Performs the unary - operation.

impl Sub for &Variable

type Output = Variable

The resulting type after applying the - operator.

fn sub(self, other: &Variable) -> Variable

Performs the - operation.