Ownvoice

OwnVoice

Train a LoRA voice adapter for pocket-tts and keep the result: a file on your own disk, not an API subscription.

pip install ownvoice-cli

Requires Python 3.11 or newer. See Install below for the npx / agent-sandbox path.

Table of Contents

• Install
• Quickstart
• CLI Reference
• Features
• How It Works
• Setup-Time Benchmark vs Comparable Tools
• Why OwnVoice Exists
• What OwnVoice Is Not
• Consent and Misuse
• Implementation Status
• FAQ
• Contributing
• License

Install

pip install ownvoice-cli

npx / agent-native environments: OwnVoice is a Python/PyTorch CLI, so the npm package is a thin wrapper, not a Node reimplementation. It bootstraps into the real CLI via uv or pipx, whichever is already on PATH, useful for coding-agent sandboxes and CI runners that default to a Node toolchain. The npm package was renamed to ownvoice-cli (from the old plain ownvoice, now deprecated) to match its PyPI counterpart.

npx ownvoice-cli check

Both the npm wrapper and the PyPI package (ownvoice-cli) are live, so the command above works today.

Torch and CUDA: ownvoice check needs no GPU at all and runs on CPU, matching pocket-tts's own CPU-capable design. Training a real adapter is much faster on an NVIDIA GPU. If you have one, install the CUDA build of PyTorch first by following pytorch.org/get-started/locally, then install OwnVoice on top of it, so pip does not silently pull the CPU-only wheel instead. On Apple Silicon or a CPU-only machine, the default pip install of torch is fine: ownvoice check and ownvoice infer run normally, ownvoice train just takes longer per epoch.

Quickstart

1. ownvoice check, the free Day-0 validation

Before recording anything or renting a GPU, confirm that PEFT's LoRA injection actually works against pocket-tts's real model structure. This is entirely free: CPU only, no training, no GPU.

$ ownvoice check

[ownvoice check] PASS: PEFT LoRA injection succeeded against pocket-tts's flow_lm module (target_modules="all-linear").

If it fails, OwnVoice prints the model's real module tree instead of a raw stack trace, so you can see exactly what did not match and report it precisely:

$ ownvoice check

[ownvoice check] FAIL: PEFT LoRA injection failed against pocket-tts's flow_lm module structure: . Please post an honest blocker (this error plus the module tree above) as a comment on https://github.com/kyutai-labs/pocket-tts/issues/30 rather than working around it silently, that issue is exactly where this gap needs to be visible.

Module tree (for debugging / for the issue #30 blocker post): : FlowLMModel input_linear: Linear transformer: StreamingTransformer transformer.layers.0.self_attn.in_proj: Linear transformer.layers.0.self_attn.out_proj: Linear ...

2. ownvoice train

Record 5 to 10 minutes of clean audio of the voice you want to train (your own voice, with your own consent, see Consent and misuse), split into a few .wav clips in one directory, then point OwnVoice at it:

$ ownvoice train --voice-clips ./my-voice-clips

[ownvoice train] USABLE ADAPTER Usable adapter (similarity 0.812 >= 0.75). Try it now: ownvoice infer --adapter ownvoice-adapter/adapter.safetensors --text "This is my own voice, trained with OwnVoice."

Only --voice-clips is required. Every other flag has a sensible default (see the full CLI Reference below).

A run that finishes but does not clear the similarity bar still exits 0. It is a labeled result with a concrete next step, not a crash:

$ ownvoice train --voice-clips ./my-voice-clips

[ownvoice train] BELOW THRESHOLD Below threshold (similarity 0.612 < 0.75). The adapter was still saved, try more/cleaner voice clips, more epochs, or a higher --lora-rank, then re-run. You can still listen to it: ownvoice infer --adapter ownvoice-adapter/adapter.safetensors --text "This is my own voice, trained with OwnVoice."

Only a data-loading problem (no usable clips) or a caught PEFT-injection failure exits non-zero. A finished run always writes adapter.safetensors and metadata.json (training config, similarity score, a timestamp) to the output directory: two files you keep, with no server round-trip needed to use them again.

3. ownvoice infer

$ ownvoice infer --adapter ownvoice-adapter/adapter.safetensors --text "Hello, this is my own voice."

[ownvoice infer] Wrote ownvoice-output.wav

Every subcommand also supports --json for a structured, machine-parseable output mode, useful if a script or an agent is calling ownvoice programmatically instead of a person reading the terminal:

$ ownvoice check --json

{"success": true, "message": "PEFT LoRA injection succeeded against pocket-tts's flow_lm module (target_modules=\"all-linear\").", "module_tree": null}

CLI Reference

Reference below is taken directly from each subcommand's real --help output (ownvoice-cli 0.1.2 on PyPI).

Global

ownvoice [OPTIONS] COMMAND [ARGS]...

ownvoice check

Free, CPU-only compatibility check: load pocket-tts and dry-run the LoRA injection. No GPU and no training required.

ownvoice train

Train a LoRA voice adapter from a directory of .wav voice clips. Only --voice-clips is required.

ownvoice infer

Generate speech in the trained voice from a saved adapter, and save it to a .wav file.

Features

• A free compatibility check before you spend anything on a GPU. ownvoice check loads pocket-tts and dry-runs PEFT's LoRA injection against its real flow_lm module tree, CPU only, no training. On failure it prints the actual module tree instead of a stack trace, so a real blocker is reportable instead of silent.
• An objective usable/not-usable signal, not a guess. Every training run resamples the generated test utterance to 16kHz mono and scores it against your reference clips with Resemblyzer cosine similarity. 0.75 or higher is labeled USABLE ADAPTER; anything lower is BELOW THRESHOLD, a labeled outcome and not a crash, exit code 0 either way.
• Structured output on every subcommand. check, train, and infer all accept --json, returning one machine-parseable object instead of colored terminal text: confirmed directly, ownvoice check --json returns {"success": true, "message": "...", "module_tree": null}.
• Two files you keep, no server round-trip. A finished training run writes adapter.safetensors (the trained weights, a few megabytes at the default --lora-rank 8) and metadata.json (the full training config, similarity score, per-epoch loss, and a timestamp) to disk. Load them back any time later with ownvoice infer, no network call required.
• One base model, on purpose. OwnVoice wraps pocket-tts only. There is no abstraction layer for a second base model, matching the codebase's own single-target-by-design architecture note: the LoRA injection path (target_modules="all-linear" against pocket-tts's real flow_lm layers) stays exact instead of generic.

How It Works

voice clips (wav)

| v data.py --validate format/duration--> clean clip set | v train.py --PEFT LoRA (target_modules="all-linear")--> adapter.safetensors + metadata.json | v infer.py --generate test utterance--> synthesized audio | v score.py --resample to 16kHz mono--> Resemblyzer cosine similarity | v CLI report (>= 0.75 = usable adapter, below triggers a labeled next-step message)

ownvoice/data.py loads and validates the voice-clip directory. ownvoice/train.py loads pocket-tts's frozen base model, injects a LoRA adapter into its flow_lm transformer with PEFT (target_modules="all-linear"), runs the training loop, and saves the adapter plus a manifest. ownvoice/infer.py loads a saved adapter back onto the base model and generates speech. ownvoice/score.py resamples audio to 16kHz mono with torchaudio.transforms.Resample and scores speaker similarity with Resemblyzer.

OwnVoice is intentionally single-model: it wraps pocket-tts only, with no abstraction layer for a second base model, since none is in scope.

Setup-Time Benchmark vs Comparable Tools

| OwnVoice | under 2 minutes to a co