import speechrecognition as sr from llamacpp import Llama import threading import queue…
- User
import speech_recognition as sr from llama_cpp import Llama import threading import queue import time
def listen_for_speech(audio_queue): r = sr.Recognizer() with sr.Microphone() as source: print("In ascolto...") r.adjust_for_ambient_noise(source) while True: try: audio = r.listen(source, timeout=None, phrase_time_limit=10) audio_queue.put(audio) except sr.WaitTimeoutError: continue
def transcribe_audio(audio): r = sr.Recognizer() try: text = r.recognize_google(audio, language="it-IT") return text except sr.UnknownValueError: print("Nessuna voce") return None except sr.RequestError as e: print(f"Impossibile richiedere risultati dal servizio di riconoscimento vocale; {e}") return None
model_path = "Gemma-2.6B-F16.gguf" llm = Llama(model_path=model_path, n_ctx=8919)
chat_history = [] audio_queue = queue.Queue() interrupt_event = threading.Event()
listening_thread = threading.Thread(target=listen_for_speech, args=(audio_queue,)) listening_thread.daemon = True listening_thread.start()
def get_last_role(): return chat_history[-1]["role"] if chat_history else None
def generate_response(prompt): response = "" stream = llm.create_chat_completion( messages=prompt, stream=True, temperature=0.7, max_tokens=150 )
for chunk in stream: if interrupt_event.is_set(): break if "content" in chunk["choices"][0]["delta"]: response_piece = chunk["choices"][0]["delta"]["content"] if response_piece.strip() not in ["<end_of_turn>", "<eos>"]: response += response_piece print(response_piece, end="", flush=True) else: break return response.strip()while True: print("\nParla per fare una domanda...") audio = audio_queue.get() user_query = transcribe_audio(audio)
if user_query: print(f"Hai detto: {user_query}") if get_last_role() != "assistant": chat_history.append({"role": "user", "content": user_query}) else: chat_history.append({"role": "user", "content": user_query}) interrupt_event.clear() def check_for_interrupt(): while not interrupt_event.is_set(): if not audio_queue.empty(): interrupt_event.set() break time.sleep(0.1) interrupt_checker = threading.Thread(target=check_for_interrupt) interrupt_checker.daemon = True interrupt_checker.start() lm_response = generate_response(chat_history) if interrupt_event.is_set(): print(" <interruzione>") lm_response += " <interruzione>" elif not lm_response: print(" <nessuna risposta>") else: print() # Nuova linea dopo la risposta completa if lm_response: chat_history.append({"role": "assistant", "content": lm_response}) else: print("Nessun discorso rilevato o impossibile trascrivere. Per favore riprova.") # Pulisci la coda audio while not audio_queue.empty(): try: audio_queue.get_nowait() except queue.Empty: breakcon questo codice posso avere conversazioni fluide e interrompere la risposta streaming del modello. solo che c'è un problema: spesso, avviene l' interruzione dell output streaming perchè vengono rilevati dei rumori, e questo credo che influisca sulla interruzione. come si può regolare solo quando sente la mia voce?
- Assistant
Hai riscontrato che il tuo codice interrompe il flusso di output del modello a causa di rumori ambientali che vengono rilevati come input vocale. Questo accade perché qualsiasi suono che il microfono cattura viene messo in coda e considerato potenzialmente come un'interruzione.
Ecco alcune soluzioni per fare in modo che l'interruzione avvenga solo quando il microfono rileva la tua voce e non per rumori di fondo:
1. Regola la soglia di energia per riconoscere solo la tua voce
La libreria
speech_recognitionutilizza una soglia di energia per determinare quando un suono è considerato voce. Puoi aumentare questa soglia per rendere il riconoscitore meno sensibile ai rumori di fondo.Nel tuo codice, dopo aver creato l'istanza del riconoscitore, puoi disabilitare la soglia di energia dinamica e impostare manualmente una soglia più alta:
def listen_for_speech(audio_queue): r = sr.Recognizer() r.dynamic_energy_threshold = False r.energy_threshold = 4000 # Regola questo valore in base alle tue necessità with sr.Microphone() as source: print("In ascolto...") # r.adjust_for_ambient_noise(source) # Puoi rimuovere questa linea se imposti manualmente la soglia while True: try: audio = r.listen(source, timeout=None, phrase_time_limit=10) audio_queue.put(audio) except sr.WaitTimeoutError: continueNote:
- Disabilita la soglia di energia dinamica: impostando
r.dynamic_energy_threshold = False, il riconoscitore non regolerà automaticamente la soglia in base al rumore ambientale. - Imposta una soglia di energia più alta: aumentando
r.energy_threshold, il riconoscitore ignorerà i suoni sotto quel livello di energia. Dovresti sperimentare con valori diversi (4000,5000,6000, ecc.) per trovare quello che funziona meglio nel tuo ambiente.
2. Utilizza il rilevamento di attività vocale (VAD)
Per un rilevamento più affidabile della voce, puoi integrare un modulo di Rilevamento dell'Attività Vocale (VAD) come
webrtcvad. Questo modulo è progettato per distinguere tra voce umana e rumore di fondo con alta precisione.Installazione di webrtcvad:
pip install webrtcvadIntegrazione nel codice:
Prima, importa il modulo
webrtcvad:import webrtcvadPoi, modifica la funzione
check_for_interruptper analizzare l'audio e determinare se contiene voce prima di impostare l'evento di interruzione:def is_speech(audio_data, sample_rate): vad = webrtcvad.Vad() vad.set_mode(1) # Modalità da 0 a 3, dove 3 è la più sensibile frames = [] frame_duration = 30 # Durata di ogni frame in ms frame_bytes = int(sample_rate * frame_duration / 1000 * 2) # 2 byte per campione (16 bit) audio_bytes = audio_data.get_raw_data(convert_rate=sample_rate, convert_width=2) for i in range(0, len(audio_bytes), frame_bytes): frame = audio_bytes[i:i+frame_bytes] if len(frame) < frame_bytes: break frames.append(frame) for frame in frames: if vad.is_speech(frame, sample_rate): return True return False def check_for_interrupt(): while not interrupt_event.is_set(): if not audio_queue.empty(): audio = audio_queue.get() sample_rate = audio.sample_rate if is_speech(audio, sample_rate): interrupt_event.set() break time.sleep(0.1)Note:
- Funzione
is_speech: determina se l'audio contiene voce utilizzandowebrtcvad. - Analisi dell'audio: l'audio viene suddiviso in frame e analizzato per rilevare la presenza di voce.
- Impostazione dell'evento di interruzione:
interrupt_eventviene impostato solo se viene rilevata voce nell'audio.
3. Filtra l'audio durante l'ascolto
Un'altra opzione è filtrare gli audio direttamente nella funzione
listen_for_speech, evitando di mettere in coda audio che non contengono voce:def listen_for_speech(audio_queue): r = sr.Recognizer() r.dynamic_energy_threshold = False r.energy_threshold = 4000 # Regola questo valore with sr.Microphone() as source: print("In ascolto...") while True: try: audio = r.listen(source, timeout=None, phrase_time_limit=10) # Verifica se l'audio contiene voce prima di metterlo in coda if is_speech(audio, audio.sample_rate): audio_queue.put(audio) except sr.WaitTimeoutError: continueIn questo modo, solo gli audio che contengono effettivamente la tua voce vengono messi in coda, riducendo ulteriormente le false interruzioni.
4. Utilizza l'attributo
non_speaking_durationLa funzione
listendel riconoscitore ha un parametronon_speaking_durationche controlla per quanto tempo deve esserci silenzio prima di considerare l'audio terminato.audio = r.listen(source, timeout=None, phrase_time_limit=10, non_speaking_duration=0.5)Impostando
non_speaking_durationa un valore più alto, il riconoscitore ignorerà piccoli rumori tra le parole.5. Gestisci le eccezioni per rumori di fondo
Assicurati che la funzione
transcribe_audiogestisca correttamente le eccezioni dovute a rumori di fondo:def transcribe_audio(audio): r = sr.Recognizer() try: text = r.recognize_google(audio, language="it-IT") return text except sr.UnknownValueError: # Nessuna voce comprensibile rilevata return None except sr.RequestError as e: print(f"Impossibile richiedere risultati dal servizio di riconoscimento vocale; {e}") return NoneSe il riconoscitore non è in grado di trascrivere l'audio, restituisce
Nonee l'interruzione non viene innescata.Conclusione
Implementando queste modifiche, dovresti essere in grado di ridurre significativamente le interruzioni indesiderate causate dai rumori di fondo. Ricorda che potrebbe essere necessario sperimentare con i valori della soglia di energia (
energy_threshold) e dei parametri del VAD per adattarli al tuo ambiente specifico.Nota: L'utilizzo del VAD (
webrtcvad) è altamente consigliato per applicazioni che richiedono un riconoscimento vocale affidabile in ambienti rumorosi. - Disabilita la soglia di energia dinamica: impostando