DADOES

DADOES

Do Androids Dream of Electric Sheep.

DADOES is a microsecond-level text-to-mood inference engine for Rust projects.

The crate can be used as a library by other Rust projects. It also includes CLI and training binaries for local experimentation.

DADOES is not positioned as a replacement for transformer GoEmotions models on full-label accuracy. Its advantage is deployment shape: a 1.7 MB checkpoint, no Python, no PyTorch, no GPU, no Transformers runtime, and local Rust inference at 281,972.5 texts/s, or 3.546 us/text, on the current benchmark.

Use it as a cheap first mood signal for agent reports, chat logs, issue/support routing, local log or inbox triage, and high-volume text-stream pre-filtering.

The current implementation is a compact inference baseline:

• multi-label mood taxonomy
• hashed text features
• linear sigmoid classifier
• SGD training on a public mixed English mood dataset assembled from GoEmotions-compatible sources and DADOES seed examples
• validation-loss early stopping
• 1.7 MB binary checkpoint
• binary checkpoint save/load
• JSON CLI output

The classifier core is intentionally small. Dataset import uses structured CSV and JSON parsers at the training boundary, while the public Rust interface stays stable for downstream projects.

Why DADOES

Library Usage

After the first crates.io release, add DADOES as a normal dependency:

[dependencies]
dadoes = "0.1.0"

For this checkout before release, use a local dependency:

[dependencies]
dadoes = { path = "/Users/ryan/DADOES" }

Use the embedded default checkpoint:

use dadoes::{DadoesClassifier, EmotionClassifier};

fn main() -> Result<(), dadoes::ModelIoError> {
    let classifier = DadoesClassifier::from_default_model()?;
    let analysis = classifier.classify(
        "I missed the deadline again and felt frustrated and exhausted.",
    );

    if let Some(primary) = analysis.primary_mood() {
        println!("primary={} score={:.3}", primary.mood.as_str(), primary.score);
    }

    for score in classifier.active_moods(&analysis) {
        println!("active={} score={:.3}", score.mood.as_str(), score.score);
    }

    Ok(())
}

Load a custom checkpoint when you train one:

let classifier = dadoes::DadoesClassifier::from_path("models/custom.dadoes")?;

Runnable example:

cargo run --release --example library_usage

Run

cargo run --release --bin dadoes -- "I missed the deadline again and felt frustrated and exhausted tonight."

The command prints:

{"primary_mood":"tired","moods":[...]}

The CLI loads models/goemotions-linear.dadoes when it exists. If no local checkpoint exists, it falls back to the embedded default checkpoint.

Current Evaluation

The headline metric for DADOES is inference cost. Accuracy is reported here to make the current signal quality inspectable, not to claim state-of-the-art mood understanding.

This is a multi-label classifier, so a single "accuracy" number is less useful than F1 and exact multi-label match rate. The closest strict accuracy measure is exact_match, where every predicted label for an example must match.

Current default checkpoint:

Training stopped at epoch 28, with the best validation checkpoint selected from epoch 24.

These numbers are for the current linear hashed-feature baseline trained on the public mixed dataset. GoEmotions is one source in that mix; optional external sources under data/raw/external and DADOES seed examples are also used. They should be treated as a baseline, not a production ceiling.

Signal quality is uneven across labels. The current checkpoint is strongest on happy, satisfied, hopeful, and lonely, with lonely measured on a small 153-example supervised slice; weaker labels include frustrated at F1 0.2255, curious at F1 0.3839, angry at F1 0.4187, sad at F1 0.4328, and excited at F1 0.4362. bored and tired do not yet have supervised examples in the loaded mixed test, so they require held-out reviewed data before per-label accuracy can be reported.

Mixed per-mood diagnostic metrics at threshold 0.35:

The loaded mixed test currently has no supervised examples for bored or tired; those labels should not be published as 0/0 metrics. They require held-out reviewed examples before a per-label accuracy can be reported.

Microsecond inference benchmark:

Benchmark numbers measure classification after loading the model and should be treated as local-machine measurements, not portable latency guarantees.

Comparison

DADOES should not be read as "more accurate than BERT." The useful comparison is operational: when a Rust project needs cheap local text-to-mood inference, DADOES avoids the Python/PyTorch/Transformers deployment stack and runs from a small binary checkpoint.

The table below is a reference comparison, not a leaderboard. DADOES uses a smaller 13-label runtime taxonomy and shows local Rust performance. Most public GoEmotions models publish the original 28-label task, often with different thresholds, hardware, and evaluation scripts.

Accuracy comparison:

Microsecond inference performance:

Adoption Roadmap

• Publish the crate to crates.io; the manifest no longer disables publishing.
• Add a Hugging Face Space demo that accepts text and returns DADOES JSON.
• Run same-test-set baselines for fastText, TF-IDF logistic regression, DistilRoBERTa, ModernBERT, and DADOES.
• Add DADOES-owned reviewed labels for bored, tired, frustrated, and lonely.
• Keep the public positioning focused on microsecond-level Rust-native text-to-mood inference, not transformer-level full-taxonomy accuracy.

Train

Prepare the base GoEmotions split files in data/raw/goemotions, then run:

cargo run --release --bin train

Optional external datasets are read from data/raw/external. Public raw-file sources are downloaded by the Rust data-preparation binary and included automatically when their files exist:

cargo run --release --features dataset-download --bin prepare_external_datasets
cargo run --release --bin train

Non-commercial sources such as EmpatheticDialogues and FIG-Loneliness are kept behind an explicit research switch. The trainer can read their exported local CSV/JSONL files, but DADOES does not depend on Python or Hugging Face datasets to produce them:

DADOES_INCLUDE_NON_COMMERCIAL=1 cargo run --release --bin train

The trainer skips missing optional files, but fails on malformed files that are present. Use DADOES_EXTERNAL_DATA_DIR=/path/to/external to override the external-data root.

To regenerate the evaluation and benchmark tables:

cargo run --release --bin evaluate

The default trainer:

• uses train.tsv for gradient updates
• uses dev.tsv for early stopping
• starts from test.tsv and mixes optional external test splits before final evaluation
• repeats the local seed examples 4 times to cover DADOES labels that GoEmotions does not annotate, such as lonely, bored, and tired
• mixes optional public external sources when prepared under data/raw/external
• only mixes non-commercial sources when DADOES_INCLUDE_NON_COMMERCIAL=1

Current checkpoint summary:

best_epoch=24
epochs_trained=28
validation_micro_f1=0.6341
validation_exact_match=0.2971
test_micro_f1=0.6439
test_exact_match=0.3069

The full report is saved at models/goemotions-linear.report.json.

License

DADOES is licensed under the GNU Affero General Public License v3.0 only.

Dataset Direction

Use a public mixed dataset assembled from GoEmotions and compatible external sources, then add curated DADOES-domain text. Keep the runtime labels smaller than GoEmotions:

• happy
• satisfied
• excited
• curious
• anxious
• frustrated
• sad
• angry
• lonely
• bored
• tired
• hopeful
• neutral

The missing high-priority dimensions are lonely, bored, and tired. GoEmotions does not directly annotate them. The current public mixed checkpoint adds direct lonely supervision from public loneliness data, while bored and tired still only have weak coverage from the small seed set unless DADOES-owned reviewed labels are added.

The project data format is documented in data/README.md. The public dataset survey and coverage matrix are documented in data/DATASETS.md.