Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Gabháil an Mhicreafóin le PyAudio

Ceacht 11 as 16 Nuashonraithe 3 Samhain 2026 Forbróir
Ar an leathanach seo
  1. Ó Chomhad go Micreafón
  2. PyAudio a Shuiteáil
  3. An Ginneadóir Micreafóin
  4. Clár Iomlán: Ó Mhicreafón go Tras-scríobh
  5. An Gléas Ceart a Roghnú
  6. Príomhphointí

An cúrsa nuashonraithe an 3 Samhain 2026 do Voxtral 3, bunaithe ar threoir Aistrigh ó Voxtral 2 ó Mistral: tá samhlacha Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), a díothaíodh an 31 Deireadh Fómhair 2026 agus a scoradh an 30 Aibreán 2027, curtha in ionad sna samplaí ag voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3, agus voxtral-mini-tts-3-0. Príomhathruithe: ní bhíonn stampaí ama ach ar leibhéal na míreanna (tuilleann word earráid 400), tá dé-aitheantas fíor-ama tacaithe, tá socruithe seisiúin fíor-ama glasáilte tar éis an chéad smután fuaime, agus tá ionchuir context_bias solúbtha (frásaí le spásanna). Foinse: Aistrigh ó Voxtral 2 · Caint go Téacs.

Ó Chomhad go Micreafón

Bunaíodh ailtireacht sa cheacht roimhe seo ina bhfuil an fhoinse fuaime ina ghineadóir comhtháthach simplí in-mhalartaithe. Bainfidh tú úsáid as sin láithreach: trí ghineadóir léitheoireachta comhaid a mhalartú le ceann a léann ó do chárta fuaime, tosaíonn do chlár ag tras-scríobh do ghutha beo gan líne amháin den chuid eile den chód a athrú.

Is é PyAudio an uirlis don cheacht seo, an leabharlann Python chaighdeánach chun rochtain a fháil ar ghléasanna fuaime. Braitheann sé ar PortAudio, sraith dhúchasach a d’fhéadfadh ort a shuiteáil ar leithligh ag brath ar do chóras.

PyAudio a Shuiteáil

# Linux (Debian/Ubuntu)
sudo apt-get install portaudio19-dev
pip install pyaudio

# macOS
brew install portaudio
pip install pyaudio

# Windows
pip install pyaudio

An Ginneadóir Micreafóin

Tá croílár an cheachta seo oiriúnach i dtríocha líne thart. Osclaíonn an fheidhm sruth ionchurtha ar an ngléas réamhshocraithe, déanann lúib gan teorainn ag léamh blocanna de mhéid seasta, agus soláthraíonn sé gach ceann acu don inneall tras-scríofa. Níl an bloc finally maisiúil: ráthaíonn sé go stopann an sruth, go ndúntar é, agus go scaoileann PyAudio an crua-earrais fiú má chuirtear isteach go tobann ar an gclár. Gan é, d’fhéadfadh an micreafón fanacht glasáilte, rud a chuirfeadh bac ar fheidhmchláir eile.

import asyncio
import pyaudio

async def iter_microphone(
    sample_rate: int = 16000,
    chunk_duration_ms: int = 480
):
    """Gabháil an mhicreafóin agus soláthar smután PCM.

    Args:
        sample_rate: Ráta samplála (16000 Hz do Voxtral)
        chunk_duration_ms: Fad gach smután i millisoicindí

    Yields:
        bytes: Smután fuaime PCM mona 16-giotán
    """
    p = pyaudio.PyAudio()

    # Líon na samplaí in aghaidh an smután
    chunk_samples = int(sample_rate * chunk_duration_ms / 1000)

    # Oscail sruth an mhicreafóin
    stream = p.open(
        format=pyaudio.paInt16,    # PCM 16-giotán
        channels=1,                 # Mona
        rate=sample_rate,           # 16 kHz
        input=True,                 # Mód gabhála
        frames_per_buffer=chunk_samples
    )

    loop = asyncio.get_running_loop()

    try:
        print("Micreafón gníomhach — labhair...")
        while True:
            # Léigh an smután gan bac
            data = await loop.run_in_executor(
                None,
                stream.read,
                chunk_samples,
                False  # exception_on_overflow
            )
            yield data
    finally:
        stream.stop_stream()
        stream.close()
        p.terminate()
        print("Micreafón dúnta")

Tá cúis shonrach le gach paraiméadar. Is é sample_rate=16000 riachtanas samhla, ní rogha: tá 16 kHz ag teastáil ó Voxtral, mar sin ná hathraigh an luach seo. Meaitseálann pyaudio.paInt16 an fhormáid PCM shínithe 16-giotán, atá coibhéiseach go díreach leis an pcm_s16le a dheclaraítear ar thaobh an API, agus forfheidhmíonn channels=1 mona, rud atá riachtanach freisin. Níl fágtha ach chunk_duration_ms=480, an t-aon socrú atá faoi dhíospóid i ndáiríre: léiríonn gach smután 480 millisoicind d’fhuaime, comhréiteach maith idir freagrúlacht agus éifeachtúlacht líonra. Feabhsaíonn smután níos giorra, 100 ms mar shampla, an fhreagrúlacht ach méadaíonn sé iarratais líonra; sábhálann smután níos faide bandaleithead ar chostas moille breise sula bhfeiceann an tsamhail an fhuaim.

Tuilleann an glao loop.run_in_executor míniú freisin. Is feidhm bhacach í stream.read: coinníonn sí an snáithe go dtí go bhfuil an líon samplaí a iarradh ar fáil. Dá rithfí go díreach í i gcorútán, reoigh sí an lúib asyncio ar fad, lena n-áirítear glacadh le himeachtaí tras-scríofa. Trí í a aistriú chuig feidhmitheoir, déanann tú an léitheoireacht comhoiriúnach leis an gcuid eile den chlár comhtháthach.

Leanann ríomh mhéid an bhlóic go meicniúil ón dá shocrú, do sample_rate=16000 agus chunk_duration_ms=480:

chunk_samples = 16000 × 480 / 1000 = 7680 sampla
byte_size = 7680 × 2 bheart = 15360 bheart in aghaidh an smután

Clár Iomlán: Ó Mhicreafón go Tras-scríobh

Comhcheanglaíonn an script seo a leanas gabháil agus tras-scríobh ina uirlis dictéid atá réidh le húsáid. Is é an gné nua i gcomparáid leis an ngineadóir roimhe seo ná láimhseáil ghlan scor: idirghabhálann láimhseálaí comhartha Ctrl+C, casann an brat running go False, rud a fhágann an lúib gabhála, a dhúnann an sruth, agus a ligeann don chlár an téacs carntha a shábháil. Gan an mheicníocht seo, mharódh briseadh méarchláir an próiseas sula sábhálfaí é, agus chaillfeá an dictéad.

import asyncio
import os
import signal
from mistralai.client import Mistral
from mistralai.client.models import (
    AudioFormat,
    TranscriptionStreamTextDelta,
    TranscriptionStreamDone
)
import pyaudio

# Brat le haghaidh scor glan
running = True

def signal_handler(sig, frame):
    global running
    print("\n\nAg múchadh...")
    running = False

signal.signal(signal.SIGINT, signal_handler)

async def iter_microphone(sample_rate=16000, chunk_duration_ms=480):
    """Gabháil an mhicreafóin go dtí go gcuirtear isteach air (Ctrl+C)."""
    p = pyaudio.PyAudio()
    chunk_samples = int(sample_rate * chunk_duration_ms / 1000)

    stream = p.open(
        format=pyaudio.paInt16,
        channels=1,
        rate=sample_rate,
        input=True,
        frames_per_buffer=chunk_samples
    )

    loop = asyncio.get_running_loop()

    try:
        while running:
            data = await loop.run_in_executor(
                None, stream.read, chunk_samples, False
            )
            yield data
    finally:
        stream.stop_stream()
        stream.close()
        p.terminate()

async def main():
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
    audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

    print("=" * 50)
    print("TRAS-SCRÍOBH BEO")
    print("Labhair isteach sa mhicreafón (Ctrl+C chun stop)")
    print("=" * 50)
    print()

    full_text = []

    async for event in client.audio.realtime.transcribe_stream(
        audio_stream=iter_microphone(),
        model="voxtral-mini-transcribe-realtime-3",
        audio_format=audio_format,
    ):
        if isinstance(event, TranscriptionStreamTextDelta):
            print(event.text, end="", flush=True)
            full_text.append(event.text)

        elif isinstance(event, TranscriptionStreamDone):
            break

    # Sábháil
    final_text = "".join(full_text)
    if final_text.strip():
        with open("dictee.txt", "w", encoding="utf-8") as f:
            f.write(final_text)
        print(f"\n\nTras-scríobh sábháilte i dictee.txt")
        print(f"Fad: {len(final_text)} carachtar")
    else:
        print("\n\nNíor tras-scríobhadh aon téacs.")

asyncio.run(main())

Rith é, labhair, stop le Ctrl+C: feictear an téacs de réir mar a labhraíonn tú, agus críochnaíonn sé i dictee.txt.

python dictee_vocale.py
# Labhair isteach i do mhicreafón
# Feictear an téacs i bhfíor-am
# Ctrl+C chun stop

Bain triail as le thart ar thríocha soicind de Fhraincis leanúnach, ag athrú do luas, agus déan comparáid idir an méid a dúirt tú agus an méid atá sa chomhad. Is é seo an bealach is fearr chun do chuid ionchais a chalabrú sula ndéanann tú tiúniú ar an moill sa chéad cheacht eile.

An Gléas Ceart a Roghnú

Ar mheaisín a bhfuil micreafón ionsuite, clogad USB, agus camghréasán ann, ní hé an gléas réamhshocraithe i gcónaí an ceann a shílfeá, agus is minic gurb é an mionsonra seo is cúis le tras-scríobh folamh. Ar dtús, liostaigh na hionchuir atá ar fáil lena n-innéacs:

def list_microphones():
    """Liostaigh gach gléas ionchurtha fuaime atá ar fáil."""
    p = pyaudio.PyAudio()
    print("Gléasanna ionchurtha ar fáil:")
    for i in range(p.get_device_count()):
        info = p.get_device_info_by_index(i)
        if info["maxInputChannels"] > 0:
            print(f"  [{i}] {info['name']} "
                  f"(cainéil: {info['maxInputChannels']}, "
                  f"ráta: {int(info['defaultSampleRate'])} Hz)")
    p.terminate()

list_microphones()

Ansin, forfheidhmigh an t-innéacs roghnaithe nuair a osclaíonn tú an sruth, tríd an bparaiméadar input_device_index:

stream = p.open(
    format=pyaudio.paInt16,
    channels=1,
    rate=sample_rate,
    input=True,
    input_device_index=2,  # Innéacs an ghléis
    frames_per_buffer=chunk_samples
)

Príomhphointí

  • Gabhann PyAudio an micreafón i PCM mona 16-giotán ag 16 kHz, díreach mar a bhíonn ag teastáil ó Voxtral
  • Soláthraíonn an gineadóir iter_microphone smutánanna 480 ms de réir réamhshocraithe
  • Déanann loop.run_in_executor léitheoireacht an mhicreafóin neamh-bhacach in asyncio
  • Stopann Ctrl+C an ghabháil go glan trí láimhseálaí comhartha
  • Liostaigh gléasanna le get_device_count() chun an micreafón ceart a roghnú