helena 0.1.0

Core types and component interfaces for helena, a latent data-to-waveform generation platform.
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

# helena

Core types and component interfaces for **helena**, a latent data-to-waveform
generation platform: it learns to turn structured source data into audio by
predicting compressed audio latents that a frozen neural codec decodes.

This crate is the foundation the rest of the platform builds on. It holds the
*vocabulary every other crate speaks* — the data structures that flow through the
pipeline and the traits the swappable components implement — and nothing that
pulls in a tensor backend, a neural network, or an FFT. It is host-side,
`serde`-friendly, and dependency-light by design.

```text
source data ──▶ DataEncoder ──▶ ConditioningLatents ──▶ ConditionalGenerator
                                                             │
                                                      AudioLatent / tokens
                                                             │
                                                         AudioCodec::decode
                                                             ▼
                                                          Waveform
```

## What's here

- **Pipeline data** — `Tensor` (a host-side, serde-friendly wrapper over Burn's
  `TensorData`), `Waveform`, the conditioning and audio latents
  (`ConditioningLatents`, `AudioLatent`), and the experiment/generation config and
  manifest records.
- **Component seams** — the three traits the platform is built to swap parts
  behind: `DataEncoder`, `AudioCodec`, and `ConditionalGenerator`. They are
  backend-agnostic: a model's tensor backend never leaks into its callers.
- **The diffusion kernel** — variance-preserving v-prediction levels, a cosine
  schedule, classifier-free-guidance scheduling, and Min-SNR loss weighting.
- **Subsystems behind their modules** — generator-output diagnostics under
  `eval`, streaming statistics under `stats`, content hashing under `hash`. The
  crate root stays the vocabulary; these are reached through their module path.

## Backend

The tensor backend is [Burn](https://burn.dev). helena stays backend-agnostic by
speaking Burn's host-side `TensorData` at its boundaries, so latents serialize,
hash, and disk-cache without a device. Models in the (currently unpublished)
training and inference crates are generic over `B: Backend` and convert to
`Tensor<B, D>` at their edges.

## Status

Pre-1.0 and evolving; the public API may change between `0.x` releases. The other
helena crates (data, model, train, infer, eval, cli) are not yet published.

## License

AGPL-3.0-only.