aprender 0.30.0

Next-generation ML framework in pure Rust — `cargo install aprender` for the `apr` CLI
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

<!-- PCU: examples-neural-network-training | contract: contracts/apr-page-examples-neural-network-training-v1.yaml -->
<!-- Example: cargo run -p aprender-core --example neural_network_training -->
<!-- Status: enforced -->

# Case Study: Neural Network Training Pipeline

Complete deep learning workflow with aprender's nn module.

## Features Demonstrated

- Multi-layer perceptron (MLP)
- Backpropagation training
- Optimizers (Adam, SGD)
- Learning rate schedulers
- Model serialization

## Problem: XOR Function

Learn the classic non-linearly separable XOR:

| X1 | X2 | Output |
|----|----|----|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |

## Architecture

```text
Input (2) → Linear(8) → ReLU → Linear(8) → ReLU → Linear(1) → Sigmoid
```

## Implementation

```rust,ignore
use aprender::autograd::Tensor;
use aprender::nn::{
    loss::MSELoss,
    optim::{Adam, Optimizer},
    scheduler::{LRScheduler, StepLR},
    serialize::{save_model, load_model},
    Linear, Module, ReLU, Sequential, Sigmoid,
};

fn main() {
    // Build network
    let mut model = Sequential::new()
        .add(Linear::new(2, 8))
        .add(ReLU::new())
        .add(Linear::new(8, 8))
        .add(ReLU::new())
        .add(Linear::new(8, 1))
        .add(Sigmoid::new());

    // XOR data
    let x_data = vec![
        vec![0.0, 0.0],
        vec![0.0, 1.0],
        vec![1.0, 0.0],
        vec![1.0, 1.0],
    ];
    let y_data = vec![0.0, 1.0, 1.0, 0.0];

    let mut optimizer = Adam::new(model.parameters(), 0.1);
    let mut scheduler = StepLR::new(&mut optimizer, 500, 0.5);
    let loss_fn = MSELoss::new();

    // Train
    for epoch in 0..2000 {
        let x = Tensor::from_vec(x_data.clone(), &[4, 2]);
        let y = Tensor::from_vec(y_data.clone(), &[4, 1]);

        let pred = model.forward(&x);
        let loss = loss_fn.forward(&pred, &y);

        optimizer.zero_grad();
        loss.backward();
        optimizer.step();
        scheduler.step();

        if epoch % 500 == 0 {
            println!("Epoch {}: loss = {:.6}", epoch, loss.data()[0]);
        }
    }

    // Save model
    save_model(&model, "xor_model.bin").unwrap();

    // Load and verify
    let loaded: Sequential = load_model("xor_model.bin").unwrap();
    println!("Model loaded, params: {}", count_parameters(&loaded));
}
```

## Key Concepts

1. **StepLR**: Decay learning rate every N epochs
2. **save_model/load_model**: Binary serialization
3. **ReLU activation**: Enables non-linear learning

## Run

```bash
cargo run --example neural_network_training
```