This library provides differentiable operations and tensors. The current backend is rust-ndarray.
Here we are computing partial derivatives of z = 2x^2 + 3y + 1.
```rust
extern crate ndarray; extern crate autograd as ag;
let ref x = ag::placeholder(&[]); let ref y = ag::placeholder(&[]); let ref z = 2xx + 3*y + 1;
// dz/dy let ref gy = ag::grad(&[z], &[y])[0];
// dz/dx let ref gx = ag::grad(&[z], &[x])[0];
// ddz/dx (differentiates z again)
let ref ggx = ag::grad(&[gx], &[x])[0];
// evaluation of symbolic gradients let mut ctx = ag::Context::new(); println!("{}", gy.eval(&mut ctx)); // => 3. println!("{}", ggx.eval(&mut ctx)); // => 4.
// dz/dx requires to fill the placeholder x
ctx.feed_input(x, ndarray::arr0(2.));
println!("{}", gx.eval(&mut ctx)); // => 8.
```
Another example: multi layer perceptron for MNIST digits classification.
```rust // -- graph def -- let mut ctx = ag::Context::new(); let ref x = ag::placeholder(&[-1, 2828]); let ref y = ag::placeholder(&[-1]); let ref w = ctx.variable(ag::ndarray_ext::glorot_uniform(&[2828, 10])); let ref b = ctx.variable(ag::ndarrayext::zeros(&[1, 10])); let ref z = ag::matmul(x, w) + b; let ref loss = ag::reducemean(&ag::sparsesoftmaxcrossentropy(z, y), &[0], false); let ref grads = ag::grad(loss, &[w, b]); let ref predictions = ag::argmax(z, -1, true); let ref accuracy = ag::reducemean(&ag::equal(predictions, y), &[0], false);
// -- dataset -- let ((xtrain, ytrain), (xtest, ytest)) = dataset::load();
// -- training method -- let mut optimizer = ag::gradient_descent::SGD { lr: 0.01 };
// -- training loop -- for epoch in 0..max_epoch { ... }
``` For more, see documentation or examples