README.md

---
language:
- da
base_model:
- HuggingFaceTB/SmolLM2-135M
pipeline_tag: text-to-speech
tags:
- text-to-speech
- tts
- danish
- dansk
library_name: transformers
license: cc-by-4.0
---

# Plapre Pico - Dansk Tekst-til-Tale

Dansk TTS-model med talerkonditionering og stemmekloningssupport. Genererer 24kHz lyd fra dansk tekst ved hjælp af autoregressiv lydtoken-prædiktion.

## Modeldetaljer

| | |
|---|---|
| **Arkitektur** | LLaMA-baseret (30 lag, hidden_size=576) |
| **Parametre** | ~118M (base) + 74K (talerprojektion) |
| **Vocab-størrelse** | 20.802 (BPE + lydtokens + separatorer) |
| **Lydtokenizer** | [Kanade](https://huggingface.co/frothywater/kanade-25hz-clean) (25 tokens/sek, 12.800 codebook) |
| **Samplerate** | 24kHz |
| **Præcision** | bfloat16 |

## Sådan virker det

Modellen tager dansk tekst, konverterer den til BPE-tokens, og genererer autoregressivt Kanade-lydtokens, som afkodes til en lydbølge.

**Sekvensformat:**
```
[speaker_embedding] <text> BPE tokens <audio> audio tokens <eos>
```

**Talerkonditionering:** En indlært lineær projektion (`nn.Linear(128, 576)`) mapper en 128-dimensionel Kanade-talerembedding til modellens skjulte dimension. Denne indsættes som det første token i sekvensen, så modellen kan konditionere på taleridentitet via attention. Til stemmekloning udtrækkes talerembeddingen fra et referenceaudioklip via Kanade-encoderen.

## Filer

| Fil | Beskrivelse |
|------|-------------|
| `model.safetensors` | Base model-vægte (bfloat16) |
| `speaker_proj.pt` | Talerprojektionslag (`nn.Linear(128, 576)`) |
| `speakers.json` | Indbyggede talerembeddings |
| `tokenizer.json` | Tokenizer |
| `tokenizer_config.json` | Tokenizer-konfiguration |
| `config.json` | Modelkonfiguration |
| `gguf/plapre-pico.f16.gguf` | GGUF f16 (227 MB) |
| `gguf/plapre-pico.q8_0.gguf` | GGUF q8_0 (121 MB) |
| `gguf/plapre-pico.q6_k.gguf` | GGUF q6_k (115 MB) |
| `gguf/plapre-pico.q4_k_m.gguf` | GGUF q4_k_m (83 MB) |
| `gguf/plapre-pico.q4_0.gguf` | GGUF q4_0 (70 MB) |

## Installation

```bash
uv add git+https://github.com/syv-ai/plapre.git
```

## Inferens

### Grundlæggende brug

```python
from plapre import Plapre

tts = Plapre("syvai/plapre-pico")
tts.speak("Hej, hvordan har du det?", output="output.wav")
```

### Vis tilgængelige talere

```python
print(tts.list_speakers())
# ['tor', 'ida', 'liv', 'ask', 'kaj']
```

### Vælg en taler

```python
tts.speak("Hej med dig.", output="output.wav", speaker="ida")
```

### Stemmekloning

```python
tts.speak("Hej med dig.", output="cloned.wav", speaker_wav="reference.wav")
```

### Lange tekster med sætningsopdeling

```python
tts.speak(
    "Første sætning. Anden sætning. Tredje sætning!",
    output="long.wav",
    split_sentences=True,
)
```

### Genereringsparametre

```python
tts.speak(
    "Hej verden.",
    output="output.wav",
    temperature=0.8,     # sampling-temperatur (standard: 0.8)
    top_p=0.95,          # nucleus sampling (standard: 0.95)
    top_k=50,            # top-k sampling (standard: 50)
    max_tokens=500,      # maks lydtokens at generere (standard: 500)
)
```

### Udtræk en talerembedding

Udtræk en 128-dim talerembedding fra en wav-fil og genbrug den på tværs af flere genereringer:

```python
speaker_emb = tts.extract_speaker("reference.wav")
tts.speak("Hej.", output="a.wav", speaker_emb=speaker_emb)
tts.speak("Farvel.", output="b.wav", speaker_emb=speaker_emb)
```

### Returværdi

`speak()` returnerer lyden som et numpy-array (24 kHz, float32) ud over at gemme filen:

```python
audio = tts.speak("Hej.", output="output.wav")
print(f"Varighed: {len(audio) / 24000:.2f}s")
```

## API-server

```bash
uv add "plapre[serve] @ git+https://github.com/syv-ai/plapre.git"
plapre-serve --model plapre-pico-q8_0 --port 8000
```

```bash
curl -X POST http://localhost:8000/v1/audio/speech \
  -H "Content-Type: application/json" \
  -d '{"text": "Hej, hvordan har du det?", "speaker": "tor"}' \
  --output output.pcm

ffmpeg -f s16le -ar 24000 -ac 1 -i output.pcm output.wav
```