burn_p2p_auth_github 0.21.0-pre.6

Optional GitHub auth connector for burn_p2p.
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

# burn_p2p 🔥🤝

[![GitHub License](https://img.shields.io/github/license/aberration-technology/burn_p2p)](https://raw.githubusercontent.com/aberration-technology/burn_p2p/main/LICENSE-MIT)
[![crates.io](https://img.shields.io/crates/v/burn_p2p.svg)](https://crates.io/crates/burn_p2p)

`burn_p2p` turns a burn learner into a decentralized training network.

core shape:

- trainers download the current head and assigned data shard, run one train window, then publish a candidate head
- validators evaluate candidates and promote accepted updates
- the same network can include native peers, browser peers, viewers, and validators

## install

```toml
[dependencies]
burn_p2p = { version = "=0.21.0-pre.6", features = ["burn"] }
```

## happy path

```rust
use burn::train::Learner;
use burn_p2p::{ExperimentId, RevisionId, StorageConfig, StudyId};
use burn_p2p::burn::from_loaders;

let mut trainer = from_loaders(
    Learner::new(model, optimizer, scheduler),
    device,
    train_loader,
    eval_loader,
)
.trainer(release_manifest, supported_workload)?
.with_network(network_manifest)?
.with_storage(StorageConfig::new("./node"))
.with_bootstrap_peer(validator_addr)
.spawn()?;

let experiment = trainer.experiment(
    StudyId::new("study"),
    ExperimentId::new("mnist"),
    RevisionId::new("rev-1"),
);

let outcome = trainer.train_window_once(&experiment)?;
println!("published {}", outcome.head.head_id.as_str());
```

keep your existing burn model, optimizer, scheduler, and loaders.

`burn_p2p` handles:

- head sync
- window-by-window training publication
- checkpoint/artifact movement
- validator promotion flow
- assigned shard fetch for distributed runs

one validator/authority node must exist somewhere on the network to initialize
and promote heads.

## data

trainers fetch only their assigned shard:
`with_sharded_dataset(...)`.

> browser peers fetch assigned shards from an http dataset origin, not over the
p2p overlay.

## what the repo includes

- `burn_p2p`: core runtime
- `burn_p2p_browser`: browser runtime
- `burn_p2p_bootstrap`: bootstrap coherence-seed + browser-edge http surface
- `burn_p2p_app`: reference dioxus ui

same experiment layout works across native and browser peers. browser-facing
runtime and ui live in the companion crates above.

## see it working

single-machine mixed-fleet mnist sanity run:

```bash
cargo xtask e2e mnist --profile smoke --keep-artifacts
```

best follow-up docs:

- [docs/examples/mnist.md](docs/examples/mnist.md)
- [docs/downstream-burn-guide.md](docs/downstream-burn-guide.md)
- [docs/features.md](docs/features.md)

non-burn runtime? implement `P2pWorkload` directly.