Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

import speechrecognition as sr from llamacpp import Llama import threading import queue…

  1. 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:
            break
    

    con 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?

  2. 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_recognition utilizza 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:
                    continue
    

    Note:

    • 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 webrtcvad
    

    Integrazione nel codice:

    Prima, importa il modulo webrtcvad:

    import webrtcvad
    

    Poi, modifica la funzione check_for_interrupt per 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 utilizzando webrtcvad.
    • Analisi dell'audio: l'audio viene suddiviso in frame e analizzato per rilevare la presenza di voce.
    • Impostazione dell'evento di interruzione: interrupt_event viene 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:
                    continue
    

    In 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_duration

    La funzione listen del riconoscitore ha un parametro non_speaking_duration che 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_duration a 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_audio gestisca 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 None
    

    Se il riconoscitore non è in grado di trascrivere l'audio, restituisce None e 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.