Ricerca nel sito web

Trasformare le tue goccioline GPU modello con 1 clic in un assistente personale


1-Click Models è il nuovo progetto di collaborazione di DigitalOcean e Hugging Face per offrirti un metodo semplice per interfacciarti con alcuni dei migliori Large Language Models (LLM) open source sulle GPU più potenti disponibili sul cloud. Insieme, gli utenti possono ottimizzare l'utilizzo dei migliori modelli open source senza problemi o codifica da configurare.

In questo tutorial, mostreremo e analizzeremo lo sviluppo di uno strumento di assistente personale abilitato alla voce progettato per essere eseguito su qualsiasi Droplet GPU abilitato al modello 1-Click. Questa applicazione utilizza Gradio ed è completamente abilitata per API con FastAPI. Segui per saperne di più sui vantaggi dell'utilizzo dei modelli 1-Click, apprendi le nozioni di base per eseguire query su un droplet GPU modello 1-Click distribuito e scopri come utilizzare l'assistente personale sulle tue macchine!

Modelli di volti abbracciati in 1 clic con le goccioline GPU DigitalOcean

I nuovi modelli 1-Click sono dotati di un'ampia varietà di opzioni LLM, tutte con casi d'uso diversi. Questi sono e precisamente:

  • meta-llama/Meta-Llama-3.1-8B-Istruire
  • meta-llama/Meta-Llama-3.1-70B-Istruire
  • meta-llama/Meta-Llama-3.1-405B-Instruct-FP8
  • Qwen/Qwen2.5-7B-Istruzione
  • 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

La creazione di un nuovo droplet GPU con uno qualsiasi di questi modelli richiede solo il processo di configurazione di un droplet GPU, come mostrato qui.

Guarda il video seguente per una guida passo passo completa sulla creazione di un droplet GPU modello a 1 clic e consulta questo articolo per ulteriori dettagli sull'avvio di una nuova istanza.

Dopo aver configurato la tua nuova macchina, vai alla sezione successiva per maggiori dettagli sull'interazione con il tuo modello in 1 clic.

Interazione con la distribuzione del modello in 1 clic

Connettersi al modello 1-Click Deployment è semplice se vogliamo interagire con esso sulla stessa macchina. “Quando ci si connette all’HUGS Droplet, il messaggio SSH iniziale visualizzerà un Bearer Token, necessario per inviare richieste all’IP pubblico dell’HUGS Droplet distribuito. Quindi puoi inviare richieste all'API Messaggi tramite localhost se connesso all'interno della Droplet HUGS o tramite il suo IP pubblico. " (Fonte). Per accedere al Droplet su altre macchine, quindi, sarà necessario ottenere il Bearer Token. Connettiti al tuo computer utilizzando SSH per ottenere una copia del token e salvarla per dopo. Se vogliamo semplicemente interagire con l'endpoint di inferenza dalla nostra GPU Droplet, le cose sono piuttosto semplici. La variabile è già salvata nell'ambiente.

Una volta impostata la variabile Bearer Token sulla macchina che scegliamo di utilizzare, possiamo iniziare a inferire con il modello. Al momento ci sono due percorsi per farlo: cURL e Python. L'endpoint verrà eseguito automaticamente dalla porta 8080, quindi possiamo inviare richieste predefinite alla nostra macchina. Se stiamo utilizzando una macchina diversa, modifica il valore localhost di seguito con l'indirizzo IPv4.

arricciare

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"

Questo codice chiederà al modello “Cos’è il Deep Learning? " ed emettere una risposta nel seguente formato:

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

Questo può quindi essere collegato a una varietà di applicazioni di sviluppo web secondo necessità.

Pitone

È possibile accedere al modello anche tramite Python utilizzando i pacchetti Hugging Face Hub o OpenAI. Faremo riferimento al codice di riferimento Hugging Face Hub per questa dimostrazione.

### 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,
)

Ciò restituirà una risposta formattata come oggetto ChatCompletionOutput.

## 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))

Possiamo stampare solo l'output con:

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

Creazione di un assistente personale abilitato alla voce

Per utilizzare al meglio questo nuovo potente strumento, abbiamo sviluppato una nuova applicazione di assistente personale da eseguire con i modelli. L'applicazione è completamente abilitata alla voce, in grado di ascoltare e leggere ad alta voce ingressi e uscite. Per rendere ciò possibile, la demo utilizza Whisper per trascrivere un input audio o prende testo semplice e lo inserisce in un LLM basato su GPU Droplet con 1 clic per generare una risposta testuale. Utilizziamo quindi il modello XTTS2 di Coqui-AI per convertire l'input di testo in un output audio comprensibile. Vale la pena notare che il software utilizza la clonazione vocale per generare l'audio in uscita, quindi gli utenti riceveranno un output vocale vicino alla propria voce parlante.

Dai un'occhiata al codice qui sotto:

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)

Nel complesso, questo sistema integrato consente di sfruttare appieno la velocità e la disponibilità di una GPU cloud per fungere da assistente personale per tutti i tipi di attività. Lo abbiamo utilizzato al posto di popolari strumenti closed source come Gemini e ChatGPT e siamo rimasti davvero colpiti dai risultati.

Configurazione ed esecuzione della demo

Per installare i pacchetti richiesti sulla tua GPU Droplet, incolla quanto segue nel terminale:

pip install gradio tts huggingface_hub transformers datasets scipy torch torchaudio

Per eseguire questa demo, incolla semplicemente il codice qui sopra in un file Python vuoto (chiamiamolo arbitrariamente app.py) sulla tua GPU Cloud abilitata per il modello 1-Click ed eseguilo con python3 app.py.

Pensieri conclusivi

L'applicazione dell'assistente personale sviluppata per questo tutorial si è già rivelata utile nella nostra vita quotidiana e speriamo che altri possano trovare qualche utilità nell'utilizzarla. Inoltre, le nuove goccioline GPU modello 1-Click offrono un'alternativa davvero interessante al software LLM aziendale. Sebbene costosi per i singoli utenti, ci sono una serie di casi d'uso a cui possiamo pensare (vale a dire l'esecuzione dei più grandi LLM open source) che possono giustificare la spesa. Le nostre nuove offerte includono i modelli Mixtral e LLaMA più grandi disponibili, quindi è un'interessante opportunità per testare la potenza di questi modelli rispetto alla migliore concorrenza.

Grazie per aver letto!

Articoli correlati: