> ## Documentation Index
> Fetch the complete documentation index at: https://docs.gradium.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Renforcement de mots-clés

> Reconnaître les noms, marques et termes techniques en orientant le STT vers un dictionnaire personnalisé

La transcription (STT) excelle sur le langage courant. Le renforcement de
mots-clés (keyword boosting) étend cet atout au vocabulaire propre à *votre*
produit : noms de joueurs, marques, produits et noms de chaînes. Des termes
comme `Mbappé` ou `Vinícius` sont transcrits exactement comme vous l'attendez.

Vous transmettez dans `json_config` un dictionnaire des termes qui vous
importent, et le modèle leur donne la priorité pendant le décodage, en temps
réel, sans réentraînement.

## Le principe

Ajoutez un objet `keywords` contenant les termes et un poids `boost` :

```python theme={null}
json_config = {
    "language": "en",
    "keywords": {
        "words": ["Mbappé", "Haaland", "Vinícius", "Bellingham", "Lewandowski"],
        "boost": 3,
    },
}
```

`boost` s'applique dans l'espace des log-probabilités, son effet est donc
exponentiel : une petite valeur modifie déjà sensiblement le décodage. Utilisez
la plage `-6` à `6`, avec `3` comme valeur par défaut efficace. Consultez
[Paramètres de transcription](/fr/guides/transcription-settings#renforcement-de-mots-clés-keyword-boosting)
pour la référence complète du paramètre.

## Construire un bon dictionnaire

Les mots-clés sont comparés un token à la fois, ce qui implique deux choses.

1. **Utilisez des tokens uniques, sans espaces.** Découpez les noms composés de
   plusieurs mots : `"Ferran Torres"` devient `"Ferran"` et `"Torres"`.
2. **Respectez la casse et les accents.** `"Mbappé"` et `"Mbappe"` sont des clés
   différentes : incluez donc les variantes que vous attendez.

Vous pouvez renforcer jusqu'à **500 mots-clés**. Chaque variante d'un mot
(minuscules, majuscules, accentuée, etc.) constitue une clé à part entière et
compte dans cette limite : prévoyez votre budget en conséquence lorsque vous
déclinez des termes en variantes.

Une petite fonction utilitaire qui fait les deux :

```python theme={null}
import unicodedata


def build_keywords(terms):
    strip = lambda s: "".join(
        c for c in unicodedata.normalize("NFKD", s) if not unicodedata.combining(c)
    )
    out = []
    for term in terms:
        for token in term.split():                       # split phrases into tokens
            for variant in (token, token.lower(), strip(token), strip(token).lower()):
                if variant not in out:
                    out.append(variant)
    return out


build_keywords(["Ferran Torres", "Mbappé"])
# ['Ferran', 'ferran', 'Torres', 'torres', 'Mbappé', 'mbappé', 'Mbappe', 'mbappe']
```

## Exemple complet

```python theme={null}
import asyncio
import gradium

TERMS = ["Kylian Mbappé", "Erling Haaland", "Vinícius Júnior", "Jude Bellingham"]


async def transcribe(audio_source):
    client = gradium.client.GradiumClient(api_key="your-api-key")

    async with client.stt_realtime(
        model_name="default",
        input_format="pcm",
        json_config={
            "language": "en",
            "delay_in_frames": 16,
            "keywords": {"words": build_keywords(TERMS), "boost": 3},
        },
    ) as stt:
        transcript = []

        async def producer():
            async for chunk in audio_source:
                await stt.send_audio(chunk)
            await stt.send_eos()

        async def consumer():
            async for msg in stt:
                if msg["type"] == "text":
                    transcript.append(msg["text"])
                elif msg["type"] == "end_of_stream":
                    return

        await asyncio.gather(producer(), consumer())
        return " ".join(transcript).strip()
```

## Réglage

| Boost | Comportement | Quand l'utiliser |
| - | - | - |
| `1`-`2` | Léger coup de pouce, sans risque | Vocabulaire assez courant, où il suffit de départager. |
| `3` | Valeur par défaut recommandée ; récupère la plupart des noms rares | Dans la plupart des cas. |
| `4` | Récupération plus forte | Noms propres nombreux ou étrangers. |
| `5`-`6` | Rendements décroissants, et le décodeur peut se mettre à boucler (répéter un mot-clé) | Rarement, en surveillant la sortie. |
| négatif | Pénalise un terme | Uniquement pour exclure un mot précis que vous ne voulez jamais voir. |

Le renforcement est entièrement compatible avec le streaming, et il est le plus
utile avec un `delay_in_frames` faible, lorsque le modèle dispose de moins
d'anticipation et s'appuie davantage sur le dictionnaire.

## Voir aussi

<CardGroup cols={2}>
  <Card title="Paramètres de transcription" icon="sliders" href="/fr/guides/transcription-settings#renforcement-de-mots-clés-keyword-boosting">
    La référence du paramètre `keywords` et le reste de `json_config`.
  </Card>

  <Card title="WebSocket de transcription (STT)" icon="microphone" href="/fr/guides/speech-to-text">
    Types de messages STT, détails sur la VAD et flush.
  </Card>
</CardGroup>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.