Website-Suche

Verwandeln Sie Ihre 1-Klick-Modell-GPU-Droplets in einen persönlichen Assistenten


1-Click Models sind das neue Gemeinschaftsprojekt von DigitalOcean und Hugging Face, das Ihnen eine einfache Methode zur Schnittstelle mit einigen der besten Open-Source-LLMs (Large Language Models) auf den leistungsstärksten in der Cloud verfügbaren GPUs bietet. Gemeinsam können Benutzer die Nutzung der besten Open-Source-Modelle optimieren, ohne dass Aufwand oder Programmieraufwand für die Einrichtung erforderlich sind.

In diesem Tutorial zeigen wir die Entwicklung eines sprachgesteuerten persönlichen Assistenten-Tools, das auf jedem 1-Click-Modell-fähigen GPU-Droplet ausgeführt werden kann. Diese Anwendung verwendet Gradio und ist mit FastAPI vollständig API-fähig. Folgen Sie uns, um mehr über die Vorteile der Verwendung von 1-Click-Modellen zu erfahren, lernen Sie die Grundlagen der Abfrage eines bereitgestellten 1-Click-Modell-GPU-Droplets kennen und erfahren Sie, wie Sie den persönlichen Assistenten auf Ihren eigenen Computern verwenden!

1-Klick-Umarmungsgesichtsmodelle mit DigitalOcean-GPU-Tröpfchen

Die neuen 1-Click-Modelle verfügen über eine Vielzahl von LLM-Optionen mit jeweils unterschiedlichen Anwendungsfällen. Dies sind nämlich:

  • meta-llama/Meta-Llama-3.1-8B-Instruct
  • meta-llama/Meta-Llama-3.1-70B-Instruct
  • meta-Lama/Meta-Llama-3.1-405B-Instruct-FP8
  • Qwen/Qwen2.5-7B-Anleitung
  • google/gemma-2-9b-it
  • google/gemma-2-27b-it
  • mistralai/Mixtral-8x7B-Instruct-v0.1
  • mistralai/Mistral-7B-Instruct-v0.3
  • mistralai/Mixtral-8x22B-Instruct-v0.1
  • NousResearch/Hermes-3-Llama-3.1-8B
  • NousResearch/Hermes-3-Llama-3.1-70B
  • NousResearch/Hermes-3-Llama-3.1-405B
  • NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO

Um mit einem dieser Modelle ein neues GPU-Droplet zu erstellen, muss lediglich ein GPU-Droplet eingerichtet werden, wie hier gezeigt.

Sehen Sie sich das folgende Video an, um eine vollständige Schritt-für-Schritt-Anleitung zum Erstellen eines 1-Click-Modell-GPU-Droplets zu erhalten. Weitere Informationen zum Starten einer neuen Instanz finden Sie in diesem Artikel.

Sobald Sie Ihre neue Maschine eingerichtet haben, navigieren Sie zum nächsten Abschnitt, um weitere Einzelheiten zur Interaktion mit Ihrem 1-Klick-Modell zu erfahren.

Interaktion mit der 1-Klick-Modellbereitstellung

Die Verbindung zum 1-Click Model Deployment ist einfach, wenn wir auf demselben Computer damit interagieren möchten. „Bei Verbindung mit dem HUGS Droplet zeigt die erste SSH-Nachricht ein Bearer-Token an, das zum Senden von Anfragen an die öffentliche IP des bereitgestellten HUGS Droplet erforderlich ist. Anschließend können Sie Anfragen an die Nachrichten-API entweder über localhost (sofern eine Verbindung innerhalb des HUGS-Droplets besteht) oder über dessen öffentliche IP senden. " (Quelle). Um dann auf anderen Computern auf das Droplet zugreifen zu können, benötigen wir den Bearer-Token. Stellen Sie über SSH eine Verbindung zu Ihrem Computer her, um eine Kopie des Tokens zu erhalten und diese für später zu speichern. Wenn wir nur mit dem Inferenzendpunkt unseres GPU-Droplets interagieren möchten, sind die Dinge ziemlich einfach. Die Variable ist bereits in der Umgebung gespeichert.

Sobald die Bearer-Token-Variable auf der Maschine festgelegt ist, die wir verwenden möchten, können wir mit der Inferenz mit dem Modell beginnen. Derzeit gibt es zwei Möglichkeiten, dies zu tun: cURL und Python. Der Endpunkt wird automatisch über Port 8080 ausgeführt, sodass wir standardmäßig Anfragen an unseren Computer senden können. Wenn wir einen anderen Computer verwenden, ändern Sie den Wert localhost unten in die IPv4-Adresse.

cURL

curl http://localhost:8080/v1/chat/completions \
    -X POST \
    -d '{"messages":[{"role":"user","content":"What is Deep Learning?"}],"temperature":0.7,"top_p":0.95,"max_tokens":128}}' \
    -H 'Content-Type: application/json' \
    -H "Authorization: Bearer $BEARER_TOKEN"

Dieser Code fragt das Modell: „Was ist Deep Learning?“ ” und geben Sie eine Antwort im folgenden Format aus:

{"object":"chat.completion","id":"","created":1731532721,"model":"hfhugs/Meta-Llama-3.1-8B-Instruct","system_fingerprint":"2.3.1-dev0-sha-169178b","choices":[{"index":0,"message":{"role":"assistant","content":"**Deep Learning: A Subfield of Machine Learning**\n=====================================================\n\nDeep learning is a subfield of machine learning that focuses on the use of artificial neural networks to analyze and interpret data. It is inspired by the structure and function of the human brain and is particularly well-suited for tasks such as image and speech recognition, natural language processing, and data classification.\n\n**Key Characteristics of Deep Learning:**\n\n1. **Artificial Neural Networks**: Deep learning models are composed of multiple layers of interconnected nodes or \"neurons\" that process and transform inputs into outputs.\n2. **Non-Linear Transformations**: Each layer applies a non-linear"},"logprobs":null,"finish_reason":"length"}],"usage":{"prompt_tokens":40,"completion_tokens":128,"total_tokens":168}}

Dies kann dann je nach Bedarf in eine Vielzahl von Webentwicklungsanwendungen eingebunden werden.

Python

Auf das Modell kann auch pythonisch mit den Hugging Face Hub- oder OpenAI-Paketen zugegriffen werden. Für diese Demonstration beziehen wir uns auf den Hugging Face Hub-Referenzcode.

### Hugging Face Hub
import os
from huggingface_hub import InferenceClient

client = InferenceClient(base_url="http://localhost:8080", api_key=os.getenv("BEARER_TOKEN"))

chat_completion = client.chat.completions.create(
    messages=[
        {"role":"user","content":"What is Deep Learning?"},
    ],
    temperature=0.7,
    top_p=0.95,
    max_tokens=128,
)

Dadurch wird eine formatierte Antwort als ChatCompletionOutput-Objekt zurückgegeben.

## HuggingFace Hub
ChatCompletionOutput(choices=[ChatCompletionOutputComplete(finish_reason='length', index=0, message=ChatCompletionOutputMessage(role='assistant', content='**Deep Learning: An Overview**\n\nDeep Learning is a subset of Machine Learning that involves the use of Artificial Neural Networks (ANNs) with multiple layers to analyze and interpret data. These networks are inspired by the structure and function of the human brain, with each layer processing the input data in a hierarchical manner.\n\n**Key Characteristics:**\n\n1.  **Multiple Layers:** Deep Learning models typically have 2 or more hidden layers, allowing them to learn complex patterns and relationships in the data.\n2.  **Neural Networks:** Deep Learning models are based on artificial neural networks, which are composed of interconnected nodes (neurons) that process', tool_calls=None), logprobs=None)], created=1731532948, id='', model='hfhugs/Meta-Llama-3.1-8B-Instruct', system_fingerprint='2.3.1-dev0-sha-169178b', usage=ChatCompletionOutputUsage(completion_tokens=128, prompt_tokens=40, total_tokens=168))

Wir können nur die Ausgabe drucken mit:

chat_completion.choices[0]['message']['content']

Erstellen eines sprachgesteuerten persönlichen Assistenten

Um dieses leistungsstarke neue Tool optimal nutzen zu können, haben wir eine neue persönliche Assistentenanwendung entwickelt, die mit den Modellen ausgeführt werden kann. Die Anwendung ist vollständig sprachgesteuert und kann Eingaben und Ausgaben laut anhören und vorlesen. Um dies zu ermöglichen, verwendet die Demo Whisper, um eine Audioeingabe zu transkribieren, oder nimmt einfachen Text und gibt diesen in ein LLM ein, das von 1-Click GPU Droplets unterstützt wird, um eine Textantwort zu generieren. Anschließend verwenden wir das XTTS2-Modell von Coqui-AI, um die Texteingabe in eine verständliche Audioausgabe umzuwandeln. Es ist erwähnenswert, dass die Software das Klonen von Stimmen verwendet, um die Audioausgabe zu erzeugen, sodass Benutzer eine Sprachausgabe erhalten, die ihrer eigenen Sprechstimme nahe kommt.

Schauen Sie sich den folgenden Code an:

import gradio as gr
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, StoppingCriteria, StoppingCriteriaList, TextIteratorStreamer
from threading import Thread
import os
from huggingface_hub import InferenceClient
import gradio as gr
import random
import time
from TTS.api import TTS
import torch
from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor, pipeline
from datasets import load_dataset
import scipy.io.wavfile as wavfile
import numpy as np


device = "cuda:0" if torch.cuda.is_available() else "cpu"
torch_dtype = torch.float16 if torch.cuda.is_available() else torch.float32

model_id_w = "openai/whisper-large-v3"

model_w = AutoModelForSpeechSeq2Seq.from_pretrained(
    model_id_w, torch_dtype=torch_dtype, low_cpu_mem_usage=True, use_safetensors=True
)
model_w.to(device)

processor = AutoProcessor.from_pretrained(model_id_w)

pipe_w = pipeline(
    "automatic-speech-recognition",
    model=model_w,
    tokenizer=processor.tokenizer,
    feature_extractor=processor.feature_extractor,
    torch_dtype=torch_dtype,
    device=device,
)

client = InferenceClient(base_url="http://localhost:8080", api_key=os.getenv("BEARER_TOKEN"))
Example voice cloning with YourTTS in English, French and Portuguesetts = TTS("tts_models/multilingual/multi-dataset/bark", gpu=True)
get v2.0.2
tts = TTS(model_name="xtts_v2.0.2", gpu=True)

with gr.Blocks() as demo:
    chatbot = gr.Chatbot(type="messages")
    with gr.Row():
        msg = gr.Textbox(label = 'Prompt')
        audi = gr.Audio(label = 'Transcribe audio')
    with gr.Row():
        submit = gr.Button('Submit')
        submit_audio = gr.Button('Submit Audio')
        read_audio = gr.Button('Transcribe Text to Audio')
        clear = gr.ClearButton([msg, chatbot])
    with gr.Row():
        token_val = gr.Slider(label = 'Max new tokens', value = 512, minimum = 128, maximum = 1024, step = 8, interactive=True)
        temperature_ = gr.Slider(label = 'Temperature', value = .7, minimum = 0, maximum =1, step = .1, interactive=True)
        top_p_ = gr.Slider(label = 'Top P', value = .95, minimum = 0, maximum =1, step = .05, interactive=True)

    def respond(message, chat_history, token_val, temperature_, top_p_):
        bot_message = client.chat.completions.create(messages=[{"role":"user","content":f"{message}"},],temperature=temperature_,top_p=top_p_,max_tokens=token_val,).choices[0]['message']['content']
        chat_history.append({"role": "user", "content": message})
        chat_history.append({"role": "assistant", "content": bot_message})
        # tts.tts_to_file(bot_message, speaker_wav="output.wav", language="en", file_path="output.wav")

        return "", chat_history, #"output.wav"
    
    def respond_audio(audi, chat_history, token_val, temperature_, top_p_):  
        wavfile.write("output.wav", 44100, audi[1]) 
        result = pipe_w('output.wav')
        message = result["text"]
        print(message)
        bot_message = client.chat.completions.create(messages=[{"role":"user","content":f"{message}"},],temperature=temperature_,top_p=top_p_,max_tokens=token_val,).choices[0]['message']['content']
        chat_history.append({"role": "user", "content": message})
        chat_history.append({"role": "assistant", "content": bot_message})
        # tts.tts_to_file(bot_message, speaker_wav="output.wav", language="en", file_path="output2.wav")
        # tts.tts_to_file(bot_message,
                # file_path="output.wav",
                # speaker_wav="output.wav",
                # language="en")
        return "", chat_history, #"output.wav"
    def read_text(chat_history):
        print(chat_history)
        print(type(chat_history))
        tts.tts_to_file(chat_history[-1]['content'],
                file_path="output.wav",
                speaker_wav="output.wav",
                language="en")
        return 'output.wav'


    msg.submit(respond, [msg, chatbot, token_val, temperature_, top_p_], [msg, chatbot])
    submit.click(respond, [msg, chatbot, token_val, temperature_, top_p_], [msg, chatbot])
    submit_audio.click(respond_audio, [audi, chatbot, token_val, temperature_, top_p_], [msg, chatbot])
    read_audio.click(read_text, [chatbot], [audi])
demo.launch(share = True)

Zusammengenommen ermöglicht dieses integrierte System, die Geschwindigkeit und Verfügbarkeit einer Cloud-GPU voll auszunutzen, um als persönlicher Assistent für alle Arten von Aufgaben zu fungieren. Wir haben es anstelle beliebter Closed-Source-Tools wie Gemini und ChatGPT verwendet und waren von den Ergebnissen wirklich beeindruckt.

Einrichten und Ausführen der Demo

Um die erforderlichen Pakete auf Ihrem GPU-Droplet zu installieren, fügen Sie Folgendes in das Terminal ein:

pip install gradio tts huggingface_hub transformers datasets scipy torch torchaudio

Um diese Demo auszuführen, fügen Sie einfach den obigen Code in eine leere Python-Datei (nennen wir sie willkürlich app.py) auf Ihrer 1-Click-Modell-fähigen Cloud-GPU ein und führen Sie sie mit python3 app.py aus.

Schlussgedanken

Die für dieses Tutorial entwickelte persönliche Assistentenanwendung hat sich in unserem täglichen Leben bereits als nützlich erwiesen, und wir hoffen, dass auch andere davon profitieren können. Darüber hinaus bieten die neuen 1-Click Model GPU Droplets eine wirklich interessante Alternative zur Enterprise-LLM-Software. Obwohl es für einzelne Benutzer kostspielig ist, können wir uns eine Reihe von Anwendungsfällen vorstellen (nämlich die Ausführung der größten Open-Source-LLMs), die den Aufwand rechtfertigen können. Unsere neuen Angebote umfassen die größten verfügbaren Mixtral- und LLaMA-Modelle, daher ist es eine interessante Gelegenheit, die Leistung dieser Modelle im Vergleich zur besten Konkurrenz zu testen.

Vielen Dank fürs Lesen!

Verwandte Artikel: