Täielik hääletöötlus
Sellel lehel
Kursust uuendati 3. novembril 2026 Voxtral TTS 3 jaoks, tuginedes Migrate from Voxtral 2 juhendile ja Mistrali Text to Speech lehekülgedele:
voxtral-mini-tts-2603, mis tunnistati aegunuks 31. oktoobril 2026 ja lõpetati 30. aprillil 2027, on näidetes asendatud mudeligavoxtral-mini-tts-3-0. Voxtral 2 eelmääratud hääled (gb_jane_neutral…) jäävad toetuks; Voxtral 3 lisab teksti sisse sildid[emotion=…]ja[pace=…], seadeexpressiveness, kohandatud häälduse (phoneme_hints) ja 35 keelt. Mistral soovitab pärast üleminekut latentsust uuesti mõõta. Allikad: Migrate from Voxtral 2 · Speech generation.
Tundi parandati 2. novembril 2026 vastavalt Mistrali audiodokumentatsioonile: transkriptsioonimeetod on
client.audio.transcriptions.complete(mittecreate), fail edastatakse kujul{"file_name": ..., "content": ...}ja praegune mudel onvoxtral-mini-transcribe-3. Allikas: Transcribe a file.
Häälest häälele: STT → LLM → TTS torustik
Sa oskad luua hääli, genereerida kõnet ja hallata latentsust. Selles viimases tunnis paneme need ehitusplokid kokku terviklikuks süsteemiks: kasutaja räägib, masin kuulab, mõistab, arutleb ja vastab loomulikul häälel.
Arhitektuur koosneb kolmest lülist. Esiteks teisendab kõnetuvustus (STT) kõne tekstiks; Mistral pakub oma mudelit, kuid sama hästi sobib ka OpenAI Whisper või mõni muu lahendus. See tekst liigub seejärel suurele keelemudelile (LLM), mis tõlgendab päringut ja koostab vastuse – olgu selleks Mistral Large 3, Claude, GPT-5.6 või Llama; torustik ei eelda mingit konkreetset teenusepakkujat. Lõpuks jõuab vastus tagasi Voxtral TTS-i, mis renderdab selle kõneks ja edastab voogedastuse kaudu.
Funktsionaalne torustik
Allpool olev kood ühendab need kolm sammu. Igaüks on isoleeritud oma funktsiooni, mis võimaldab vahetada STT või LLM mudelit ilma ülejäänud koodi puutumata. Pane tähele, et vestluse ajalugu antakse edasi funktsioonile generer_reponse() ja seda rikastatakse seal: just see annab järjestikustele vahetustele sidususe.
import base64
from pathlib import Path
from mistralai.client import Mistral
client = Mistral(api_key="your-api-key")
# Configuration
VOICE_ID = "your-voice-id"
LLM_MODEL = "mistral-large-latest"
TTS_MODEL = "voxtral-mini-tts-3-0"
def transcribe_audio(audio_path: str) -> str:
"""Step 1: Convert audio to text (STT)."""
path = Path(audio_path)
with path.open("rb") as audio:
response = client.audio.transcriptions.complete(
model="voxtral-mini-transcribe-3",
file={"file_name": path.name, "content": audio},
)
return response.text
def generate_response(question: str, history: list) -> str:
"""Step 2: Generate a response with the LLM."""
history.append({"role": "user", "content": question})
response = client.chat.complete(
model=LLM_MODEL,
messages=history,
)
answer = response.choices[0].message.content
history.append({"role": "assistant", "content": answer})
return answer
def synthesize_speech(output_file: str, fichier_sortie: str):
"""Step 3: Convert text to speech (TTS)."""
audio_chunks = []
with client.audio.speech.complete(
model=TTS_MODEL,
input=output_file,
voice_id=VOICE_ID,
response_format="pcm",
stream=True,
) as stream:
for event in stream:
if event.event == "speech.audio.delta":
audio_chunks.append(
base64.b64decode(event.data.audio_data)
)
Path(fichier_sortie).write_bytes(b"".join(audio_chunks))
def pipeline_vocal(audio_path: str):
"""Complete pipeline: STT → LLM → TTS."""
history = [
{
"role": "system",
"content": (
"You are a professional voice assistant. "
"Respond concisely and naturally, "
"as in an oral conversation."
),
}
]
# Step 1: Transcribe
print("Transcribing...")
question = transcribe_audio(audio_path)
print(f"Question: {question}")
# Step 2: Reason
print("Generating response...")
answer = generate_response(question, history)
print(f"Response: {answer}")
# Step 3: Synthesize
print("Synthesizing speech...")
synthesize_speech(answer, "answer.pcm")
print("Pipeline complete — file answer.pcm generated")
# Run the pipeline
pipeline_vocal("question_utilisateur.wav")
Süsteemne viip väärib märkimist: selgesõnaline palve esitada lühikesi ja kõneldud vastuseid pole pelgalt viisakus. Piiranguteta LLM toodab hea meelega struktureeritud lõike pealkirjadega, mis on ettelugemisel katastroofiline – ja nende sünteesimine võtab veelgi rohkem aega.
Lõpeta ootamist, kuni arutlemine lõpeb
Eelnev torustik on järjestikune: süntees ei alga enne, kui LLM on vastuse täielikult valmis kirjutanud. Kolmekümne sõna pikkuse vastuse korral lisab see mitu sekundit vaikust, mida kasutaja ei oska seletada. Lahendus on sammude 2 ja 3 kattumine: LLM genereerib voogedastuses ja niipea, kui terve lause on saadaval – ehk kui token lõpeb punkti, hüüumärgi või küsimärgiga – saadetakse see sünteesi, samal ajal kui mudel jätkab ülejäänud osa koostamist.
def streaming_pipeline(question_text: str):
"""Optimized pipeline: TTS starts as soon as the first
LLM tokens arrive."""
# LLM generates in streaming
partial_response = ""
phrases_to_synthesize = []
llm_stream = client.chat.stream(
model=LLM_MODEL,
messages=[
{"role": "system", "content": "Respond briefly."},
{"role": "user", "content": question_text},
],
)
for chunk in llm_stream:
token = chunk.data.choices[0].delta.content or ""
partial_response += token
# As soon as a complete sentence is available
if token.endswith((".", "!", "?")):
phrases_to_synthesize.append(partial_response)
partial_response = ""
# Synthesize each sentence in streaming
for phrase in phrases_to_synthesize:
with client.audio.speech.complete(
model=TTS_MODEL,
input=phrase,
voice_id=VOICE_ID,
response_format="pcm",
stream=True,
) as stream:
for event in stream:
if event.event == "speech.audio.delta":
yield base64.b64decode(event.data.audio_data)
Vestlusring
Tõeline assistent ei tegele üksikute küsimustega: ta aheldab kõnevahetusi, hoides samal ajal niiti. Allpool olev tsükkel salvestab, transkribeerib, kontrollib, kas kasutaja soovib lõpetada, ja vastab seejärel – süstides igal pöördel sama historique, mis vahetuse käigus kasvab.
def voice_assistant():
"""Complete conversational loop."""
history = [
{
"role": "system",
"content": "You are a concise voice assistant.",
}
]
print("Voice assistant ready. Speak!")
while True:
# Record the question (via microphone)
audio_question = record_microphone(duration=10)
# STT → LLM → TTS pipeline
question = transcribe_audio(audio_question)
if question.lower() in ("stop", "arrête", "au revoir"):
synthesize_speech("Goodbye!", "sortie.pcm")
break
answer = generate_response(question, history)
synthesize_speech(answer, "sortie.pcm")
play_audio("sortie.pcm")
Mis eraldab seda prototüüpi tootmisest?
Salvestuses olev duree=10 illustreerib ees ootavat teed: fikseeritud viivitus sunnib jutuka kasutaja ennast katkestama ja paneb „jah“ vastava isiku ootama kümme sekundit. Hääleaktiivsuse detektor (VAD) lahendab selle, tuvastades tegelikult kõne lõpu. Seejärel tuleb hallata katkestusi, kuna kasutaja katkestab hea meelega assistendi, kes räägib liiga kaua: sinu kood peab suutma peatada käimasoleva sünteesi, mida voogedastus võimaldab, kuid seda prototüüp ei tee.
Kolm muud punkti määravad kasutuselevõtu tingimused. Vestluse ajalugu, mis on siin juba olemas, tuleb piirata ja püsivustada, kui sessioonid kestavad pikalt. Varuvariant on hädavajalik – kui STT või TTS ebaõnnestub, kuva tekst, mitte ära jäta seletamatut vaikust. Lõpuks instrumendi iga samm tootmises: ainult nii saad teada, kas see lisasekund tuleb transkriptsioonist, LLM-ist või sünteesist.
Järgmised sammud
Nüüd on sul kõik vajalik, et rakendada Voxtral TTS-i oma projektides. Sõltuvalt sinu piirangutest avaneb mitu suunda: majuta Voxtral kohapeal, kui latentsus või andmekontroll on ülioluline, integreeri see olemasolevasse raamistikku nagu LangChain, LlamaIndex või Haystack, või ehita täielik veebirakendus WebRTC-ga kahepoolseks audioks. Samuti saad uurida Mistrali multimodaalseid mudeleid, mis ühendavad teksti, pildi ja heli, ning liituda Mistrali kogukonnaga Discordis, et võrrelda oma lahendusi teistega.
Peamised punktid
- Täielik hääleassistent aheldab kolm sammu: STT → LLM → TTS
- Sammude paralleelimine (TTS-i genereerimine samal ajal, kui LLM jätkab) vähendab latentsust drastiliselt
- PCM-formaat voogedastuses pakub loomulikuks vestluseks vajalikku reageerimisvõimet
- Tootmises tuleb hallata kõne lõpu tuvastamist, katkestusi ja tekstivaruvarianti
- Voxtral TTS integreerub igasse hääletorustikku tänu Mistrali Pythoni SDK-le
Testi oma teadmisi
Süntees, hääl, latentsus: lõplik kontroll enne täielikku torustikku.
1. Mida võimaldab Voices API?
Vastus: Hallata saadaolevaid hääli ja luua kohandatud hääli – hääl muutub konfigureeritud varaks, mida saab uuesti kasutada kõigis genereeringutes.
2. Millised eetilised reeglid reguleerivad hääle kloonimist?
Vastus: Kloonitava isiku selge nõusolek ja läbipaistev, legitiimne kasutamine – hääle kloonimine ilma loata on välistatud; tehniline võimalikkus ei tähenda lubatavust.
3. Kuidas kontrollida teksti hääldust?
Vastus: Teksti ettevalmistamisega: häälda fonetiliselt mitmetähenduslikke termineid, käitle akronüüme ja numbreid, kasuta rütmi jaoks kirjavahemärke – TTS loeb seda, mida sa kirjutad.
4. Millised hoovad vähendavad latentsust?
Vastus: Reaalajas voogedastus (heli toodetakse teksti saabumisel), kohandatud heliformaadid ja segmenteeritud tekst – hääl algab enne genereerimise lõppu.
5. Kuidas näeb välja täielik hääletorustik?
Vastus: Kasutaja transkriptsioon (Voxtral) → mudeli töötlemine → vastuse süntees (TTS), otsast otsani voogedastuses: hääleassistendi tsükkel.
Tsükkel on suletud: sisenevast häälest väljuva hääleni – kursuse viimane torustik ühendab kõike, mida sa just kinnitasid.