Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Iqbad il-Mikrofonu b'PyAudio

Lezzjoni 11 / 16 Aġġornat 3 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. Mill-Fajl għall-Mikrofonu
  2. Installazzjoni ta’ PyAudio
  3. Il-Ġeneratur tal-Mikrofonu
  4. Programm Sħiħ: Mill-Mikrofonu għat-Traskrizzjoni
  5. Għażla tal-Apparat It-Tajjeb
  6. Punti Ewlenin

Il-kors aġġornat fit-3 ta’ Novembru 2026 għal Voxtral 3, ibbażat fuq il-gwida Migrate from Voxtral 2 ta’ Mistral: il-mudelli Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603, skaduti fil-31 ta’ Ottubru 2026 u rtirati fit-30 ta’ April 2027) ġew sostitwiti fl-eżempji b’voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3, u voxtral-mini-tts-3-0. Bidliet ewlenin: it-timstamps huma biss għas-segmenti (word tirritorna żball 400), id-dijarizzazzjoni f’ħin reali hija appoġġjata, is-settings tas-sessjoni f’ħin reali jissakraw wara l-ewwel biċċa awdjo, u l-inputs ta’ context_bias huma flessibbli (frażijiet b’ispazji). Sorsi: Migrate from Voxtral 2 · Speech to Text.

Mill-Fajl għall-Mikrofonu

Il-lezzjoni preċedenti stabbilixxiet arkitettura fejn is-sors tal-awdjo huwa ġeneratur asinkronu sempliċi u interkambjabbli. Se tuża dan immedjatament: billi tibdel il-ġeneratur li jaqra l-fajl ma’ wieħed li jaqra mill-karta tas-sound tiegħek, il-programm tiegħek jibda jittraskrivi leħnek ħaj mingħajr ma tbiddel linja waħda mill-kumplament tal-kodiċi.

L-għodda għal din il-lezzjoni hija PyAudio, il-librerija standard ta’ Python biex taċċessa apparati tal-awdjo. Tiddependi fuq PortAudio, saff nattiv li jista’ jkollok bżonn tinstalla separatament skont is-sistema tiegħek.

Installazzjoni ta’ PyAudio

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

# macOS
brew install portaudio
pip install pyaudio

# Windows
pip install pyaudio

Il-Ġeneratur tal-Mikrofonu

Il-qalba ta’ din il-lezzjoni tinsab f’madwar tletin linja. Il-funzjoni tiftaħ fluss ta’ input fuq l-apparat default, tagħmel loop indefinitament taqra blokok ta’ daqs fiss, u tagħti kull waħda lill-magna tat-traskrizzjoni. Il-blokk finally mhuwiex dekorattiv: jiggarantixxi li l-fluss jieqaf, jingħalaq, u PyAudio jirrilaxxa l-ħardwer anke jekk il-programm jiġi interrott f’daqqa. Mingħajru, il-mikrofonu jista’ jibqa’ msakkar, u jimblokaw applikazzjonijiet oħra.

import asyncio
import pyaudio

async def iter_microphone(
    sample_rate: int = 16000,
    chunk_duration_ms: int = 480
):
    """Iqbad il-mikrofonu u agħti biċċiet PCM.

    Args:
        sample_rate: Rata ta' kampjunar (16000 Hz għal Voxtral)
        chunk_duration_ms: Tul ta' kull biċċa f'millisekondi

    Yields:
        bytes: Biċċiet awdjo PCM mono ta' 16-il bit
    """
    p = pyaudio.PyAudio()

    # Numru ta' kampjuni għal kull biċċa
    chunk_samples = int(sample_rate * chunk_duration_ms / 1000)

    # Iftaħ il-fluss tal-mikrofonu
    stream = p.open(
        format=pyaudio.paInt16,    # PCM ta' 16-il bit
        channels=1,                 # Mono
        rate=sample_rate,           # 16 kHz
        input=True,                 # Modalità ta' qbid
        frames_per_buffer=chunk_samples
    )

    loop = asyncio.get_running_loop()

    try:
        print("Mikrofonu attiv — kellem...")
        while True:
            # Aqra l-biċċa mingħajr blokk
            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("Mikrofonu magħluq")

Kull parametru għandu raġuni speċifika. sample_rate=16000 tirrifletti rekwiżit tal-mudell, mhux preferenza: Voxtral jistenna 16 kHz, allura tibdilx dan il-valur. pyaudio.paInt16 jaqbel mal-format PCM iffirmat ta’ 16-il bit, ekwivalenti eżattament għal pcm_s16le iddikjarat fuq in-naħa tal-API, u channels=1 jinfurza l-mono, li huwa meħtieġ ukoll. Jibqa’ chunk_duration_ms=480, l-uniku setting verament diskutibbli: kull biċċa tirrappreżenta 480 millisekonda ta’ awdjo, kompromess tajjeb bejn ir-reattività u l-effiċjenza tan-netwerk. Biċċa iqsar, ngħidu aħna 100 ms, ittejjeb ir-reattività iżda timmultiplika t-talbiet tan-netwerk; biċċa itwal tiffranka bandwidth bl-ispiża ta’ latenza miżjuda qabel ma l-mudell jara l-awdjo.

Is-sejħa loop.run_in_executor tisħoqilha spjegazzjoni wkoll. stream.read hija funzjoni li timblokka: iżżomm it-thread sakemm in-numru mitlub ta’ kampjuni jkun disponibbli. Jekk tmexxiha direttament f’korutina, tissakkar il-loop sħiħ ta’ asyncio, inkluża r-riċevjoni ta’ eventi ta’ traskrizzjoni. Billi tgħaddiha lil eżekuter, tagħmel il-qari kompatibbli mal-bqija tal-programm asinkronu.

Il-kalkolu tad-daqs tal-blokk isegwi mekkanikament miż-żewġ settings, għal sample_rate=16000 u chunk_duration_ms=480:

chunk_samples = 16000 × 480 / 1000 = 7680 kampjun
byte_size = 7680 × 2 bytes = 15360 bytes għal kull biċċa

Programm Sħiħ: Mill-Mikrofonu għat-Traskrizzjoni

L-iskritt li ġej jgħaqqad il-qbid u t-traskrizzjoni f’għodda tad-dettatura lesta biex tuża. L-element il-ġdid meta mqabbel mal-ġeneratur preċedenti huwa t-trattament nadif tal-għeluq: handler tas-sinjal jinterċetta Ctrl+C, ibiddel il-flag running għal False, li joħroġ mill-loop tal-qbid, jagħlaq il-fluss, u jippermetti lill-programm isalva t-test akkumulat. Mingħajr dan il-mekkaniżmu, interruzzjoni tat-tastiera tkun toqtol il-proċess qabel ma jsir is-salvataġġ, u titlef id-dettatura.

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

# Flag għal għeluq nadif
running = True

def signal_handler(sig, frame):
    global running
    print("\n\nQed nagħlqu...")
    running = False

signal.signal(signal.SIGINT, signal_handler)

async def iter_microphone(sample_rate=16000, chunk_duration_ms=480):
    """Iqbad il-mikrofonu sakemm tiġi interrott (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("TRASKRIZZJONI ĦAJJA")
    print("Kellem fil-mikrofonu (Ctrl+C biex tieqaf)")
    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

    # Salva
    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\nTraskrizzjoni salvata f'dictee.txt")
        print(f"Tul: {len(final_text)} karattru")
    else:
        print("\n\nL-ebda test ma ġie ttraskritt.")

asyncio.run(main())

Mexxih, kellem, waqqaf b’Ctrl+C: it-test jidher hekk kif titkellem, imbagħad jispiċċa f’dictee.txt.

python dictee_vocale.py
# Kellem fil-mikrofonu tiegħek
# It-test jidher f'ħin reali
# Ctrl+C biex tieqaf

Ipprovah b’madwar tletin sekonda ta’ Franċiż kontinwu, ibiddel il-veloċità tiegħek, u qabbel dak li għedt ma’ dak li fih il-fajl. Hija l-aħjar mod biex tikkalibra l-aspettattivi tiegħek qabel ma ttaffi l-latenza fil-lezzjoni li jmiss.

Għażla tal-Apparat It-Tajjeb

Fuq magna b’mikrofonu integrat, headset USB, u webcam, l-apparat default mhux dejjem huwa dak li taħseb, u traskrizzjoni vojta ħafna drabi tiġi minn dan id-dettall. L-ewwel, elenka l-inputs disponibbli bl-indiċi tagħhom:

def list_microphones():
    """Elenska l-apparati kollha tal-input tal-awdjo disponibbli."""
    p = pyaudio.PyAudio()
    print("Apparati tal-input disponibbli:")
    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"(kanali: {info['maxInputChannels']}, "
                  f"rata: {int(info['defaultSampleRate'])} Hz)")
    p.terminate()

list_microphones()

Imbagħad sempliċiment infurza l-indiċi magħżul meta tiftaħ il-fluss, permezz tal-parametru input_device_index:

stream = p.open(
    format=pyaudio.paInt16,
    channels=1,
    rate=sample_rate,
    input=True,
    input_device_index=2,  # Indiċi tal-apparat
    frames_per_buffer=chunk_samples
)

Punti Ewlenin

  • PyAudio jaqbad il-mikrofonu f’PCM mono ta’ 16-il bit f’16 kHz, eżattament dak li jistenna Voxtral
  • Il-ġeneratur iter_microphone jagħti biċċiet ta’ 480 ms b’mod default
  • loop.run_in_executor jagħmel il-qari tal-mikrofonu mingħajr blokk f’asyncio
  • Ctrl+C iwaqqaf il-qbid b’mod nadif permezz ta’ handler tas-sinjal
  • Elenka l-apparati b’get_device_count() biex tagħżel il-mikrofonu t-tajjeb