Ääni- ja tekstipohjaiset agenttityönkulut
Transkriptio → päättely → äänivastaus alusta loppuun.
Ääni- ja tekstipohjaiset agenttityönkulut on ilmainen Tekoälyagentit-oppitunti CoddyKitissä. Tämä on oppitunti 2/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Tekoälyagentit-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Tekoälyagentit-kurssilla on yhteensä 4 oppituntia.
Ääni-teksti-agenttiputken yleiskatsaus
Ääni-teksti-agenttiputki muuntaa puhutun ja kirjoitetun maailman välillä. Tyypillinen työnkulku on: äänisyöte → Whisper-transkriptio → tekstipohjainen agentti → TTS-äänituloste. Tämä mahdollistaa ääniavustajat, puheluiden analysoinnin, kokousten tiivistämisen ja handsfree-käyttöliittymät.
Tuetut äänimuodot
OpenAI Whisper hyväksyy seuraavat muodot: mp3, mp4, mpeg, mpga, m4a, wav ja webm. Tiedoston enimmäiskoko on 25 Mt. Suuremmat tiedostot on jaettava osiin tai pakattava ennen lähettämistä.
Paras transkription laatu ja pienin tiedostokoko saavutetaan tallentamalla tai muuntamalla ääni aina 16 kHz:n monoääneksi.
import os
SUPPORTED_FORMATS = {'.mp3', '.mp4', '.mpeg', '.mpga', '.m4a', '.wav', '.webm'}
MAX_FILE_SIZE_BYTES = 25 * 1024 * 1024 # 25 MB
def validate_audio_file(path: str) -> dict:
ext = os.path.splitext(path)[1].lower()
size = os.path.getsize(path) if os.path.exists(path) else 0
return {
'path': path,
'format_ok': ext in SUPPORTED_FORMATS,
'size_ok': size <= MAX_FILE_SIZE_BYTES,
'size_mb': round(size / 1024 / 1024, 2),
'extension': ext
}
# Usage:
info = validate_audio_file('meeting.wav')
print(info)Äänen transkriptio Whisperillä
OpenAI:n audio.transcriptions.create-päätepiste käyttää Whisperiä. Sille välitetään tiedosto-objekti, mallin nimi ja tarvittaessa kielivihje (nopeuttaa käsittelyä ja ehkäisee väärän kielen tunnistamista) sekä kehote (alustaa sanaston toimialakohtaisia termejä varten).
from openai import OpenAI
client = OpenAI(api_key='YOUR_OPENAI_API_KEY')
def transcribe_audio(
audio_path: str,
language: str = 'en',
prompt: str = ''
) -> str:
with open(audio_path, 'rb') as audio_file:
transcript = client.audio.transcriptions.create(
model='whisper-1',
file=audio_file,
language=language,
prompt=prompt, # e.g. 'Python, NestJS, TypeScript, API'
response_format='text'
)
return transcript
text = transcribe_audio('user_query.mp3', language='en',
prompt='Kubernetes, microservices, Docker')
print('Transcription:', text)Transkriptio aikaleimojen kanssa
Kokousten analysointia tai puhujien erottelua varten pyytäkää muotoa verbose_json. Se palauttaa sana- tai segmenttikohtaiset aikaleimat, joiden avulla äänitteestä voi paikantaa tarkat kohdat viittaamista tai leikkaamista varten.
def transcribe_with_timestamps(audio_path: str) -> dict:
from openai import OpenAI
client = OpenAI(api_key='YOUR_OPENAI_API_KEY')
with open(audio_path, 'rb') as f:
result = client.audio.transcriptions.create(
model='whisper-1',
file=f,
response_format='verbose_json',
timestamp_granularities=['segment']
)
# result.segments: list of {start, end, text}
segments = [
{'start': s.start, 'end': s.end, 'text': s.text}
for s in result.segments
]
return {'full_text': result.text, 'segments': segments}
# Example output structure:
# {'full_text': 'Hello team...', 'segments': [{'start': 0.0, 'end': 2.3, 'text': 'Hello team'}]}Tekstiagentin käsittely
Transkription jälkeen teksti kulkee LLM-agentille tavallisena tekstiviestinä. Mukaan kannattaa lisätä järjestelmäkehote, joka määrittää kontekstin: teksti on peräisin puhutusta lausumasta, joten siinä voi olla täytesanoja ja keskeneräisiä lauseita.
import anthropic
VOICE_AGENT_SYSTEM = (
'You are a helpful voice assistant. The user\'s message was transcribed from speech '
'and may contain filler words ("um", "uh"), false starts, or incomplete sentences. '
'Interpret the intent charitably and respond concisely in 1-3 sentences. '
'Your response will be converted to speech, so avoid markdown, lists, or code blocks.'
)
def voice_agent_respond(transcription: str) -> str:
client = anthropic.Anthropic(api_key='YOUR_ANTHROPIC_API_KEY')
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=256,
system=VOICE_AGENT_SYSTEM,
messages=[{'role': 'user', 'content': transcription}]
)
return response.content[0].textTekstistä puheeksi OpenAI TTS:llä
Muuntakaa agentin tekstimuotoinen vastaus takaisin puheeksi OpenAI:n TTS-rajapinnan avulla. Valitkaa ääni (alloy, echo, fable, onyx, nova tai shimmer) ja malli (tts-1 nopeutta ja tts-1-hd laatua varten). Tulos voidaan tallentaa mp3-tiedostoksi tai suoratoistaa suoraan.
from openai import OpenAI
from pathlib import Path
client = OpenAI(api_key='YOUR_OPENAI_API_KEY')
def text_to_speech(
text: str,
output_path: str = 'response.mp3',
voice: str = 'nova',
model: str = 'tts-1'
) -> str:
response = client.audio.speech.create(
model=model,
voice=voice,
input=text,
response_format='mp3'
)
Path(output_path).write_bytes(response.content)
print(f'TTS audio saved to {output_path}')
return output_path
# Full pipeline:
tts_file = text_to_speech(
'The weather in London is currently 15 degrees and partly cloudy.',
voice='nova'
)Äänitulosteen suoratoisto
Reaaliaikaisia äänivastauksia varten TTS-ääni kannattaa suoratoistaa paloina sen sijaan, että koko tiedostoa odotetaan ensin. OpenAI:n stream_to_file-apuohjelman tai manuaalisen palojen läpikäynnin avulla äänen toiston voi aloittaa, kun loppuosa on vielä muodostumassa.
from openai import OpenAI
client = OpenAI(api_key='YOUR_OPENAI_API_KEY')
def stream_tts_to_file(text: str, output_path: str):
# OpenAI SDK streams the audio response
with client.audio.speech.with_streaming_response.create(
model='tts-1',
voice='nova',
input=text,
response_format='mp3'
) as response:
response.stream_to_file(output_path)
print(f'Streamed to {output_path}')
def stream_tts_chunks(text: str):
"""Yield raw audio bytes for piping to an audio player."""
with client.audio.speech.with_streaming_response.create(
model='tts-1',
voice='nova',
input=text
) as response:
for chunk in response.iter_bytes(chunk_size=4096):
yield chunk # pipe to audio player or WebSocketPitkien äänitiedostojen jakaminen
Yli 25 Mt:n äänitiedostot on jaettava osiin ennen niiden lähettämistä Whisperille. Jakakaa tiedosto pydub-kirjaston avulla aikaväleihin, käsitelkää kukin osa erikseen ja yhdistäkää transkriptiot lopuksi.
from pydub import AudioSegment
import os
def split_audio(
path: str,
chunk_minutes: int = 10
) -> list:
audio = AudioSegment.from_file(path)
chunk_ms = chunk_minutes * 60 * 1000
chunks = []
os.makedirs('audio_chunks', exist_ok=True)
for i, start in enumerate(range(0, len(audio), chunk_ms)):
chunk = audio[start:start + chunk_ms]
chunk_path = f'audio_chunks/chunk_{i:03d}.mp3'
chunk.export(chunk_path, format='mp3')
chunks.append(chunk_path)
return chunks
def transcribe_long_audio(path: str) -> str:
chunks = split_audio(path, chunk_minutes=10)
transcripts = []
for chunk_path in chunks:
text = transcribe_audio(chunk_path)
transcripts.append(text)
# Clean up chunks
for chunk_path in chunks:
os.remove(chunk_path)
return ' '.join(transcripts)Reaaliaikainen ääniputki
Reaaliaikainen putki tallentaa mikrofonin syötettä paloina, lähettää kunkin palan Whisperille sen saapuessa ja suoratoistaa TTS-tulosteen takaisin. Näin syntyy lähes reaaliaikainen äänikeskustelun silmukka. Keskeinen haaste on viiveen hallinta jokaisessa vaiheessa.
import asyncio
import time
async def realtime_voice_loop(mic_stream, speaker_stream, client):
"""
mic_stream: async generator yielding audio bytes
speaker_stream: async callable accepting audio bytes
"""
buffer = b''
BUFFER_THRESHOLD = 50 * 1024 # ~3 seconds at 16kHz mono mp3
async for audio_chunk in mic_stream:
buffer += audio_chunk
if len(buffer) >= BUFFER_THRESHOLD:
t0 = time.time()
# Save buffer to temp file
with open('/tmp/voice_chunk.mp3', 'wb') as f:
f.write(buffer)
buffer = b''
# Transcribe
text = transcribe_audio('/tmp/voice_chunk.mp3')
print(f'Transcribed ({time.time()-t0:.1f}s): {text}')
# Agent response
reply = voice_agent_respond(text)
# TTS and stream to speaker
for audio_bytes in stream_tts_chunks(reply):
await speaker_stream(audio_bytes)Kielen tunnistus ja automaattinen reititys
Whisper tunnistaa puhutun kielen automaattisesti. Tunnistettua kieltä voidaan käyttää keskustelun reitittämiseen oikealle agenttipersoonalle tai vastauksen TTS-kielen määrittämiseen.
def transcribe_and_detect_language(audio_path: str) -> dict:
from openai import OpenAI
client = OpenAI(api_key='YOUR_OPENAI_API_KEY')
with open(audio_path, 'rb') as f:
result = client.audio.transcriptions.create(
model='whisper-1',
file=f,
response_format='verbose_json'
)
return {
'text': result.text,
'language': result.language, # e.g. 'english', 'spanish'
'duration': result.duration
}
LANGUAGE_VOICE_MAP = {
'english': 'nova',
'spanish': 'alloy',
'french': 'echo',
'german': 'fable'
}
def respond_in_detected_language(audio_path: str) -> str:
info = transcribe_and_detect_language(audio_path)
voice = LANGUAGE_VOICE_MAP.get(info['language'], 'nova')
reply = voice_agent_respond(info['text'])
return text_to_speech(reply, voice=voice)Taustamelun ja heikkolaatuisen äänen käsittely
Heikkolaatuinen ääni heikentää transkription tarkkuutta. Käytännön ratkaisuja ovat melunvaimennuksen käyttö esikäsittelyssä (noisereduce-kirjasto), toimialan sanaston lisääminen Whisperin prompt-parametriin, transkription varmuuden tarkistaminen ja tarkennuksen pyytäminen, kun varmuus on heikko.
def transcribe_with_quality_check(
audio_path: str,
min_confidence_words: int = 3
) -> dict:
from openai import OpenAI
import string
client = OpenAI(api_key='YOUR_OPENAI_API_KEY')
with open(audio_path, 'rb') as f:
result = client.audio.transcriptions.create(
model='whisper-1',
file=f,
response_format='verbose_json',
timestamp_granularities=['word']
)
# Word count as a basic quality proxy
words = result.text.translate(
str.maketrans('', '', string.punctuation)
).split()
quality_ok = len(words) >= min_confidence_words
return {
'text': result.text,
'word_count': len(words),
'quality_ok': quality_ok,
'fallback_message': None if quality_ok else 'I could not hear you clearly. Please repeat.'
}Tietojen tarkistus
Mitä Whisperin prompt-parametri tekee?
Kertaus: ääni–teksti-agenttien työnkulut
Erinomaista! Tärkeimmät opit:
- Whisper: tukee esimerkiksi mp3-, wav- ja m4a-muotoja, enimmäiskoko on 25 Mt; suuret tiedostot jaetaan
pydub-kirjastolla - Aikaleimat: käyttäkää segmenttien ajoitukseen muotoa
verbose_jsonyhdessä parametrintimestamp_granularitieskanssa - TTS: OpenAI TTS tarjoaa useita äänivaihtoehtoja; suoratoistakaa paloja pienen viiveen saavuttamiseksi
- Kielen tunnistus: Whisper tunnistaa kielen automaattisesti; reitittäkää pyyntö oikealle äänelle tai agentille tunnistetun kielen perusteella
- Reaaliaikainen putki: puskuroikaa äänipalat → transkriboi → agentti → suoratoista TTS
Seuraavaksi: agenttien videon ymmärtäminen – kuvien irrottaminen ja ajallinen päättely.
Opi Tekoälyagentit tekoälytuutorin avulla — ilmaiseksi
Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.
- Kurssit
- 60
- Oppitunnit
- 239
Usein kysytyt kysymykset
Onko oppitunti ”Ääni- ja tekstipohjaiset agenttityönkulut” ilmainen?
Kyllä – oppitunnin ”Ääni- ja tekstipohjaiset agenttityönkulut” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Tekoälyagentit-kurssin, päivitä CoddyKit PROhon. Tekoälyagentit-kurssilla on yhteensä 4 oppituntia.
Mitä opin oppitunnilla ”Ääni- ja tekstipohjaiset agenttityönkulut”?
Transkriptio → päättely → äänivastaus alusta loppuun. Harjoittelet Tekoälyagentit-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.
Tarvitsenko kokemusta aloittaakseni Tekoälyagentit-opiskelun?
Aiempi kokemus ei ole tarpeen. CoddyKitin Tekoälyagentit-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 2/4.
Kuinka kauan ”Ääni- ja tekstipohjaiset agenttityönkulut”-oppitunnin suorittaminen kestää?
Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.
Voinko kirjoittaa ja suorittaa koodia tällä Tekoälyagentit-oppitunnilla?
Kyllä. Jokainen Tekoälyagentit-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.
Kaikki tämän kurssin oppitunnit
- Kuva- ja tekstipohjaiset agentit Claude Visionilla ja GPT-4V:llä
- Ääni- ja tekstipohjaiset agenttityönkulut
- Videoiden ymmärtäminen agenteissa
- Ristiinmodaalisen päättelyn mallit