Controllo vocale su PC e RaspberryPi con Whisper

controllo vocale su pc e raspberry pi

L'idea del progetto è dare istruzioni vocali per interagire tramite il nostro PC o il nostro Raspberry Pi utilizzando il modello Whisper Voice-to-text.

Daremo un ordine che verrà trascritto, convertito in testo, con Whisper e quindi analizzato per eseguire l'ordine appropriato, che può essere dall'esecuzione di un programma alla fornitura di tensione ai pin RaspberryPi.

Userò un vecchio Raspberry Pi 2, una micro USB e utilizzerò il modello Voice-to-text recentemente rilasciato da OpenAI, Sussurro. Alla fine dell'articolo puoi vedere ancora un po' di sussurro.

tutto programmato Python.

Vi lascio una dimostrazione di come funziona in questo video, il controllo vocale del PC.

Montaggio

Per usarlo con il PC, avremo solo bisogno di un microfono.

Se hai intenzione di montarlo sul RaspberryPi, avrai bisogno di un microfono USB, perché il jack che ha è solo per l'uscita.

Bisogno:

Poiché lo scopo generale dello strumento è l'identificazione vocale. Trovo molto utile integrarlo nel funzionamento di altri dispositivi.

  • Micro USB
  • Raspberry PI con sistema operativo (esempio Raspbian pro)
  • Elettronica (LED, cavi, resistore da 480 ohm e breadboard)

Colleghiamo il LED al pin 17, che è quello che attiveremo e disattiveremo per questa esperienza.

sviluppo del codice

È diviso in tre parti, la prima, la registrazione audio da cui ho preso un codice Geeksforgeek, perché non conosco quelle librerie. Il secondo, la conversione dell'audio in testo con Whisper e il terzo, il trattamento di quel testo e la risposta nel RaspberryPi

Nell'esempio di prova interagirò solo con un Led, facendolo accendere o lampeggiare, ma potremmo sviluppare lo script per adattarlo alle nostre esigenze.

Sono consapevole che questo è un Raspberry Pi 2 e sarà molto più lento di un Raspberry Pi 4, ma per i test va bene.

Prima che tu possa farlo funzionare, dovrai installare quanto segue

#Instalar whisper
pip install git+https://github.com/openai/whisper.git
sudo apt update && sudo apt install ffmpeg

#para que funcione la grabación de audio
python3 -m pip install sounddevice --user
pip install git+https://github.com/WarrenWeckesser/wavio.git

#si vas a instalarlo en la raspberry
#dar permisos para usar la GPIO
sudo apt install python3-gpiozero
sudo usermode -aG gpio <username>

tutto il codice

#!/usr/bin/env python3
import whisper
import time
from gpiozero import LED
import sounddevice as sd
from scipy.io.wavfile import write
import wavio as wv

        
def main ():
    inicio = time.time()
    record_audio ()

    model = whisper.load_model("tiny")
    result = model.transcribe("audio1.wav")
    words = result["text"].split()

    for word in words:
        word = word.replace(',', '').replace('.', '').lower()
        if word == 'enciende' or 'encender':
            encender()
            break
        if word == 'parpadea' or 'parpadear':
            parpadear()
            break      
    fin = time.time()
    print(fin-inicio)

def encender ():
    LED(17).on()

def parpadear ():
    light = LED(17)
    while True:
        light.on()
        sleep(1)
        light.off()
        sleep(1)

def record_audio ():
    # Sampling frequency
    freq = 44100
    # Recording duration
    duration = 5
    # Start recorder with the given values
    # of duration and sample frequency
    recording = sd.rec(int(duration * freq),
                    samplerate=freq, channels=2)
    # Record audio for the given number of seconds
    sd.wait()
    # This will convert the NumPy array to an audio
    # file with the given sampling frequency
    write("audio0.wav", freq, recording)
    # Convert the NumPy array to audio file
    wv.write("audio1.wav", recording, freq, sampwidth=2)
        
main ()


#dar permisos para usar la GPIO
#sudo apt install python3-gpiozero
#sudo usermode -aG gpio <username>

#Instalar whisper
#pip install git+https://github.com/openai/whisper.git
#sudo apt update &amp;&amp; sudo apt install ffmpeg

Non ho potuto testarlo perché non ho una microSD per il RaspberryPi, o un altoparlante USB da collegare, ma appena lo provo correggo qualche errore che è facile infilarsi.

Spiegazione passo passo del codice

#!/usr/bin/env python3

The Shebang per dire al dispositivo in che lingua abbiamo programmato e quale interprete usare. Anche se sembra banale, non metterlo causa errori in molte occasioni.

librerie importate

import whisper
import time
from gpiozero import LED
import sounddevice as sd
from scipy.io.wavfile import write
import wavio as wv

Sussurra di lavorare con il modello

time, perché lo uso per controllare il tempo necessario per eseguire lo script, gpiozero per lavorare con i pin GPIO del Raspberry e sounddevice, scipy e wavio per registrare l'audio

Le funzioni

Ho creato 4 funzioni:

  • principale ()
  • luce ()
  • lampeggiare ()
  • registra audio()

accendere() dà semplicemente tensione al pin 17 del lampone dove abbiamo collegato in questo caso il led da testare

def encender ():
    LED(17).on()

blink() è come on() ma fa lampeggiare il led accendendolo e spegnendolo all'interno di un ciclo.

def parpadear ():
    light = LED(17)
    while True:
        light.on()
        sleep(1)
        light.off()
        sleep(1)

Con record_audio() registriamo il file audio

def record_audio ():
    # Sampling frequency
    freq = 44100
    # Recording duration
    duration = 5
    # Start recorder with the given values
    # of duration and sample frequency
    recording = sd.rec(int(duration * freq),
                    samplerate=freq, channels=2)
    # Record audio for the given number of seconds
    sd.wait()
    # This will convert the NumPy array to an audio
    # file with the given sampling frequency
    write("audio0.wav", freq, recording)
    # Convert the NumPy array to audio file
    wv.write("audio1.wav", recording, freq, sampwidth=2)

Main è la funzione principale, nota che l'unica cosa che abbiamo al di fuori delle funzioni è la chiamata a main() alla fine dello script. In questo modo all'avvio importerà le librerie e quindi effettuerà la chiamata alla funzione.

def main ():
    inicio = time.time()
    record_audio ()

    model = whisper.load_model("tiny")
    result = model.transcribe("audio1.wav")
    words = result["text"].split()

    for word in words:
        word = word.replace(',', '').replace('.', '').lower()
        if word == 'enciende' or 'encender':
            encender()
            break
        if word == 'parpadea' or 'parpadear':
            parpadear()
            break      
    fin = time.time()
    print(fin-inicio)

Salviamo il tempo in cui iniziamo ad eseguire la funzione e poi chiamiamo la funzione di registrazione audio che registrerà la nostra istruzione in un file .wav, .mp3, ecc. che poi convertiremo in testo

    inicio = time.time()
    record_audio ()

  

Una volta che avremo l'audio, verrà chiamato sussurro e gli diciamo il modello che vogliamo usare, ce ne sono 5 disponibili e useremo tiny, anche se è il più impreciso perché è il più veloce e l'audio sarà semplice, solo 3 o 4 parole.

     model = whisper.load_model("tiny")
    result = model.transcribe("audio1.wav")

  

Con questo abbiamo l'audio convertito in testo e salvato in una variabile. Modifichiamolo un po'.

Convertiamo il risultato in un elenco con ciascuna delle parole dell'audio

     words = result["text"].split()

  

E tutto pronto per interagire con il nostro dispositivo. Ora non ci resta che creare le condizioni che vogliamo.

Se l'audio ha la parola X, fai Y. Poiché abbiamo le parole in un elenco, è molto facile aggiungere condizioni

         for word in words:
        word = word.replace(',', '').replace('.', '').lower()
        if word == 'enciende' or 'encender':
            encender()
            break
        if word == 'parpadea' or 'parpadear':
            parpadear()
            break   

  

linea

         
        word = word.replace(',', '').replace('.', '').lower()


  

Lo uso per convertire le parole nell'audio in minuscolo e rimuovere le virgole e i punti. E così evitare errori nei confronti

In ciascuno se la condizione di avere una qualsiasi delle parole che abbiamo scelto è soddisfatta, chiama una funzione che farà ciò che vogliamo,

È qui che gli diciamo di attivare un PIN che accenderà un LED o lo farà lampeggiare. Eseguire del codice o spegnere il computer.

Tutto questo è un'idea di base. Da qui puoi sviluppare il progetto e migliorarlo a tuo piacimento. Ogni persona può trovarne un uso diverso.

Cose che possiamo fare con questo montaggio

Queste sono idee che mi vengono in mente per sfruttare questo montaggio. Una volta armato lo scheletro, possiamo usarlo per attivare tutto ciò che ci viene in mente a voce, possiamo attivare un relè che avvia un motore oppure possiamo lanciare uno script che esegue uno script, un'e-mail o altro.

Cos'è il sussurro

Whisper è un modello di riconoscimento vol, funziona in multilingua con un gran numero di lingue e consente la traduzione in inglese. È quello che conosciamo come uno strumento da testo a voce, ma questo è Open Source, rilasciato dal team OpenAI, i creatori di Stable Diffusion.

Se sei una persona irrequieta come noi e vuoi collaborare al mantenimento e al miglioramento del progetto, puoi fare una donazione. Tutti i soldi andranno ad acquistare libri e materiali per sperimentare e fare tutorial

Lascia un commento