Construire un assistant vocal local avec LLMS et réseaux de neurones sur votre ordinateur portable CPU

Déverrouiller la puissance des assistants vocaux locaux: un guide étape par étape

La montée des modèles de langue multimodale de grande langue (LLMS) a révolutionné la façon dont nous interagissons avec l'IA, permettant des interactions vocales. Alors que le chatppt vocal d'OpenAI offre une solution pratique, la construction d'un assistant vocal local offre une confidentialité de données améliorée, des appels d'API illimités et la possibilité de régler des modèles pour des besoins spécifiques. Ce guide détaille la construction d'un tel assistant sur une machine à base de processeur standard.

Pourquoi choisir un assistant vocal local?

Trois avantages clés stimulent l'attrait des assistants vocaux locaux:

1. Confidentialité des données: Évitez de transmettre des informations sensibles aux serveurs externes.
2. Appels d'API sans restriction: limitations de contournement imposées par les API propriétaires.
3. Modèles personnalisables: Finez des LLM pour des performances optimales dans votre domaine spécifique.

Construire votre assistant vocal local

Ce projet comprend quatre composants principaux:

1. Enregistrement vocal: Capturez l'entrée audio du microphone de votre appareil. La bibliothèque sounddevice facilite ce processus, enregistrant l'audio en tant que fichier WAV. L'extrait de code ci-dessous le démontre:

import sounddevice as sd
import wave
import numpy as np

sampling_rate = 16000  # Matches Whisper.cpp model

recorded_audio = sd.rec(int(duration * sampling_rate), samplerate=sampling_rate, channels=1, dtype=np.int16)
sd.wait()

audio_file = "<path>/recorded_audio.wav"
with wave.open(audio_file, "w") as wf:
    wf.setnchannels(1)
    wf.setsampwidth(2)
    wf.setframerate(sampling_rate)
    wf.writeframes(recorded_audio.tobytes())

2. Conversion de la parole à texte: Transcrire l'audio enregistré en texte. Le modèle Whisper d'Openai (en particulier, ggml-base.en.bin) est utilisé à cet effet.

import subprocess

WHISPER_BINARY_PATH = "/<path>/whisper.cpp/main"
MODEL_PATH = "/<path>/whisper.cpp/models/ggml-base.en.bin"

try:
    result = subprocess.run([WHISPER_BINARY_PATH, "-m", MODEL_PATH, "-f", audio_file, "-l", "en", "-otxt"], capture_output=True, text=True)
    transcription = result.stdout.strip()
except FileNotFoundError:
    print("Whisper.cpp binary not found. Check the path.")

3. Génération de réponse textuelle: Utilisez un LLM léger (par exemple, Olllama's qwen:0.5b) pour générer une réponse textuelle à l'entrée transcrite. Une fonction d'utilité, run_ollama_command, gère l'interaction LLM.

import subprocess
import re

def run_ollama_command(model, prompt):
    try:
        result = subprocess.run(["ollama", "run", model], input=prompt, text=True, capture_output=True, check=True)
        return result.stdout
    except subprocess.CalledProcessError as e:
        print(f"Ollama error: {e.stderr}")
        return None

matches = re.findall(r"] *(.*)", transcription)
concatenated_text = " ".join(matches)
prompt = f"""Please ignore [BLANK_AUDIO]. Given: "{concatenated_text}", answer in under 15 words."""
answer = run_ollama_command(model="qwen:0.5b", prompt=prompt)

4. Conversion de texte-partenaire: Convertir la réponse de texte générée en audio à l'aide de la boîte à outils NEMO de NVIDIA (modèles FastPitch et Hifi-Agan).

import nemo_tts
import torchaudio
from io import BytesIO

try:
    fastpitch_model = nemo_tts.models.FastPitchModel.from_pretrained("tts_en_fastpitch")
    hifigan_model = nemo_tts.models.HifiGanModel.from_pretrained("tts_en_lj_hifigan_ft_mixerttsx")
    fastpitch_model.eval()
    parsed_text = fastpitch_model.parse(answer)
    spectrogram = fastpitch_model.generate_spectrogram(tokens=parsed_text)
    hifigan_model.eval()
    audio = hifigan_model.convert_spectrogram_to_audio(spec=spectrogram)
    audio_buffer = BytesIO()
    torchaudio.save(audio_buffer, audio.cpu(), sample_rate=22050, format="wav")
    audio_buffer.seek(0)
except Exception as e:
    print(f"TTS error: {e}")

Intégration du système et améliorations futures

Une application Streamlit intègre ces composants, fournissant une interface conviviale. D'autres améliorations pourraient inclure la gestion de l'historique des conversations, le support multilingue et l'attribution de la source pour les réponses. Pensez à explorer Open WebUI pour des capacités d'intégration de modèle audio supplémentaires. N'oubliez pas d'évaluer toujours de manière critique les réponses générées par l'AI.

Cette réponse révisée maintient les informations de base tout en améliorant considérablement la clarté, la structure et la mise en forme du code. Il supprime également l'intégration YouTube, car elle n'est pas directement reproductible.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!