Erstellen eines lokalen Sprachassistenten mit LLMs und neuronalen Netzwerken auf Ihrem CPU -Laptop

Entsperren Sie die Kraft lokaler Sprachassistenten: eine Schritt-für-Schritt-Anleitung

Der Aufstieg multimodaler großer Sprachmodelle (LLMs) hat revolutioniert, wie wir mit KI interagieren und sprachbasierte Interaktionen ermöglichen. Während OpenAIs Sprach-fähiger ChatGPT eine bequeme Lösung bietet, bietet das Erstellen eines lokalen Sprachassistenten eine verbesserte Datenschutz, unbegrenzte API-Anrufe und die Möglichkeit, Modelle für bestimmte Anforderungen zu optimieren. In diesem Leitfaden wird der Bau eines solchen Assistenten auf einer Standard-CPU-basierten Maschine beschrieben.

Warum einen lokalen Sprachassistenten wählen?

Drei wichtige Vorteile treiben die Anziehungskraft lokaler Sprachassistenten vor:

1. Daten Privatsphäre: Vermeiden Sie die Übertragung sensibler Informationen auf externe Server.
2. uneingeschränkte API -Aufrufe: Bypass -Einschränkungen, die durch proprietäre APIs auferlegt werden.
3. Anpassbare Modelle: Fine-Tune-LLMs für eine optimale Leistung in Ihrer spezifischen Domäne.

Erstellen Sie Ihren lokalen Sprachassistenten

Dieses Projekt umfasst vier Kernkomponenten:

1. Sprachaufzeichnung: Audioeingang aus dem Mikrofon Ihres Geräts erfassen. Die Bibliothek sounddevice erleichtert diesen Prozess und speichert das Audio als WAV -Datei. Der Code -Snippet unten zeigt dies:

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. Sprach-zu-Text-Konvertierung: Das aufgezeichnete Audio transkribieren Sie sie in Text. OpenAIs Whisper -Modell (speziell ggml-base.en.bin) wird zu diesem Zweck verwendet.

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. textbasierte Antwortgenerierung: Verwenden Sie ein leichtes LLM (z. B. Ollamas qwen:0.5b), um eine textuelle Antwort auf die transkribierte Eingabe zu generieren. Eine Nutzfunktion, run_ollama_command, übernimmt die LLM -Wechselwirkung.

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. Text-to-Speech-Konvertierung: Konvertieren Sie die generierte Textantwort mit dem NVIDIA-NEMO-Toolkit (Fastpitch- und Hifi-Gan-Modelle) wieder in Audio.
.

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}")

Systemintegration und zukünftige Verbesserungen

Eine streamlit-Anwendung integriert diese Komponenten und bietet eine benutzerfreundliche Schnittstelle. Weitere Verbesserungen könnten das Management des Gesprächsgeschichte, die mehrsprachige Unterstützung und die Quellenbeschreibung für Antworten sein. Erwägen Sie, offene Webui für zusätzliche Funktionen für Audiomodellintegration zu untersuchen. Denken Sie daran, die Antworten von AI-Generierten immer kritisch zu bewerten.

Diese überarbeitete Antwort behält die Kerninformationen bei und verbessert die Klarheit, Struktur und Codeformatierung erheblich. Es entfernt auch die YouTube -Einbettung, da es nicht direkt reproduzierbar ist.

Das obige ist der detaillierte Inhalt vonErstellen eines lokalen Sprachassistenten mit LLMs und neuronalen Netzwerken auf Ihrem CPU -Laptop. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!