native_neural_network_std 0.0.1

Ergonomic std wrapper for the `native_neural_network` crate (no_std) — std-friendly re-exports and utilities.
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

# native_neural_network_std

`native_neural_network_std` fournit un wrapper ergonomique orienté `std` autour du crate `native_neural_network` (qui cible `no_std`). Ce crate expose des types possédant la propriété d'ownership (owned APIs) et des fonctions utilitaires plus confortables pour les utilisateurs de l'écosystème Rust standard.

Principales fonctionnalités

- Ré-exports ergonomiques des API du crate upstream via des types `Std` (par exemple `ModelStd`, `TensorStd`, `NeuralNetworkStd`, `RnnStd`).
- Types propriétaires (owned) pour éviter les emprunts temporaires et simplifier l'interface (pas de zero-copy public, pas de shims de rétro-compatibilité).
- Conversions sécurisées entre les types `Std` et les structures internes nécessaires pour appeler les fonctions native (buffers temporaires, helpers `as_native_plan`, etc.).
- Wrappers pour : parsing et encodage de formats modèle, initialisation, quantization helpers, engine inference, optimisation, utilitaires cryptographiques, etc.

Documentation détaillée

Pour la description détaillée du format `.rnn`, des algorithmes internes, des invariants mémoire, et des exemples d'utilisation bas-niveau, consultez le README du crate upstream :

- https://crates.io/crates/native_neural_network (voir `native_neural_network` README)

Publication et docs

- Ce crate inclut `readme = "README.md"` dans le `Cargo.toml` pour que la page crates.io et `docs.rs` affichent ce fichier.
- Lorsque vous publiez (`cargo publish`) ce crate sur crates.io, `docs.rs` reconstruira automatiquement la documentation et publiera les pages HTML sous `https://docs.rs/native_neural_network_std`.

Usage rapide

Cargo.toml :

```toml
[dependencies]
# native_neural_network_std

native_neural_network_std is an ergonomic `std`-focused wrapper around the `native_neural_network` crate (which targets `no_std`). This crate provides owned, convenient APIs and small helper utilities for users working in the Rust standard environment.

What this crate provides

- Ergonomic `Std` types and re-exports for common upstream functionality, for example: `ModelStd`, `TensorStd`, `NeuralNetworkStd`, `RnnStd`.
- Owned APIs (no public zero-copy) that simplify memory ownership and calls into the native engine.
- Safe conversion helpers between `Std` types and the internal native representations when calling upstream functions (temporary buffers, `as_native_plan` helpers, etc.).
- Convenient wrappers for model format (encode/decode), initializers, quantization helpers, inference engine calls, optimizers, crypto helpers, and more.

Detailed documentation

For full, low-level details (the `.rnn` format, internal algorithms, memory invariants and low-level examples), see the upstream crate documentation and README:

- https://crates.io/crates/native_neural_network

Publishing and docs.rs

- This crate includes `readme = "README.md"` and `package.metadata.docs.rs` entries in `Cargo.toml` so that `crates.io` and `docs.rs` display this README and build documentation automatically when published.
- After `cargo publish`, `docs.rs` will build and host the API documentation at `https://docs.rs/native_neural_network_std`.

Quick start

Add to your `Cargo.toml`:

```toml
[dependencies]
native_neural_network_std = "0.0"
```

Example usage in code:

```rust
use native_neural_network_std::ModelStd;

// load, build or create a model using the Std wrappers and run inference
```

License

MIT OR Apache-2.0