Presentazione del contenitore di inferenza LLM di Hugging Face per Amazon SageMaker

Introducing Hugging Face's LLM inference container for Amazon SageMaker.

Questo è un esempio su come distribuire i LLM open-source, come BLOOM, su Amazon SageMaker per l’interferenza utilizzando il nuovo Hugging Face LLM Inference Container. Distribuiremo il modello Open Assistant 12B Pythia, un Chat LLM open-source addestrato con il dataset Open Assistant.

L’esempio copre:

1. Configurazione dell’ambiente di sviluppo
2. Ottieni il nuovo Hugging Face LLM DLC
3. Effettua il deploy di Open Assistant 12B su Amazon SageMaker
4. Esegui l’interferenza e chatta con il nostro modello
5. Crea un Chatbot Gradio supportato da Amazon SageMaker

Puoi trovare il codice per l’esempio anche nel repository dei notebook.

Cosa è Hugging Face LLM Inference DLC?

Hugging Face LLM DLC è un nuovo container di inferenza appositamente creato per distribuire facilmente LLM in un ambiente sicuro e gestito. Il DLC è alimentato da Text Generation Inference (TGI), una soluzione open-source appositamente progettata per distribuire e servire Large Language Models (LLM). TGI consente la generazione di testo ad alte prestazioni utilizzando la parallelizzazione del tensore e il batching dinamico per i LLM open-source più popolari, tra cui StarCoder, BLOOM, GPT-NeoX, Llama e T5. La Text Generation Inference è già utilizzata da clienti come IBM, Grammarly e l’iniziativa Open-Assistant implementa ottimizzazioni per tutte le architetture di modelli supportate, tra cui:

• Hugging Face selezionata per il Programma di Supporto Avanzato dell’Agenzia Francese per la Protezione dei Dati
• Annunciamo la Open Source AI Game Jam 🎮
• Riconoscimento vocale con intelligenza artificiale in Unity

• Parallelismo del tensore e kernel cuda personalizzati
• Codice dei trasformatori ottimizzato per l’interferenza utilizzando flash-attention sulle architetture più popolari
• Quantizzazione con bitsandbytes
• Batching continuo delle richieste in arrivo per aumentare il throughput totale
• Caricamento accelerato dei pesi (tempo di avvio) con safetensors
• Logits warpers (temperatura di ridimensionamento, topk, penalità di ripetizione…)
• Watermarking con A Watermark for Large Language Models
• Sequenze di stop, probabilità di log
• Streaming dei token utilizzando Server-Sent Events (SSE)

Le architetture di modelli supportate ufficialmente sono attualmente:

• BLOOM / BLOOMZ
• MT0-XXL
• Galactica
• SantaCoder
• GPT-Neox 20B (joi, pythia, lotus, rosey, chip, RedPajama, open assistant)
• FLAN-T5-XXL (T5-11B)
• Llama (vicuna, alpaca, koala)
• Starcoder / SantaCoder
• Falcon 7B / Falcon 40B

Con i nuovi Hugging Face LLM Inference DLC su Amazon SageMaker, i clienti AWS possono beneficiare delle stesse tecnologie che alimentano esperienze LLM altamente concorrenti e a bassa latenza come HuggingChat, OpenAssistant e API di inferenza per modelli LLM su Hugging Face Hub.

Cominciamo!

1. Configurazione dell’ambiente di sviluppo

Utilizzeremo il SDK Python sagemaker per distribuire BLOOM su Amazon SageMaker. Assicuriamoci di avere un account AWS configurato e il SDK Python sagemaker installato.

!pip install "sagemaker==2.163.0" --upgrade --quiet

Se si intende utilizzare Sagemaker in un ambiente locale, è necessario avere accesso a un ruolo IAM con le autorizzazioni necessarie per Sagemaker. Puoi trovare ulteriori informazioni qui.

import sagemaker
import boto3
sess = sagemaker.Session()
# sagemaker session bucket -> utilizzato per caricare dati, modelli e log
# sagemaker creerà automaticamente questo bucket se non esiste
sagemaker_session_bucket=None
if sagemaker_session_bucket is None and sess is not None:
    # impostato sul bucket predefinito se non viene fornito un nome del bucket
    sagemaker_session_bucket = sess.default_bucket()

try:
    role = sagemaker.get_execution_role()
except ValueError:
    iam = boto3.client('iam')
    role = iam.get_role(RoleName='sagemaker_execution_role')['Role']['Arn']

sess = sagemaker.Session(default_bucket=sagemaker_session_bucket)

print(f"sagemaker role arn: {role}")
print(f"sagemaker session region: {sess.boto_region_name}")

2. Recupera il nuovo pacchetto Hugging Face LLM DLC

Rispetto al rilascio dei modelli Hugging Face normali, dobbiamo prima recuperare l’URI del contenitore e fornirlo alla nostra classe di modello HuggingFaceModel con un image_uri che punta all’immagine. Per recuperare il nuovo pacchetto Hugging Face LLM DLC in Amazon SageMaker, possiamo utilizzare il metodo get_huggingface_llm_image_uri fornito dal SDK sagemaker. Questo metodo ci permette di recuperare l’URI per il pacchetto Hugging Face LLM desiderato in base al backend, session, region e versione specificati. Puoi trovare le versioni disponibili qui

from sagemaker.huggingface import get_huggingface_llm_image_uri

# recupera l'URI dell'immagine llm
llm_image = get_huggingface_llm_image_uri(
  "huggingface",
  version="0.8.2"
)

# stampa l'URI dell'immagine ecr
print(f"URI dell'immagine llm: {llm_image}")

3. Distribuisci Open Assistant 12B su Amazon SageMaker

Nota: Le quote per Amazon SageMaker possono variare tra gli account. Se ricevi un errore che indica di aver superato la quota, puoi aumentarle attraverso la console delle quote di servizio.

Per distribuire il modello Open Assistant su Amazon SageMaker, creiamo una classe di modello HuggingFaceModel e definiamo la nostra configurazione del punto di accesso, inclusi hf_model_id, instance_type, ecc. Utilizzeremo un tipo di istanza g5.12xlarge, che ha 4 GPU NVIDIA A10G e 96 GB di memoria GPU.

Nota: Potremmo anche ottimizzare la distribuzione per il costo e utilizzare il tipo di istanza g5.2xlarge ed abilitare la quantizzazione int-8.

import json
from sagemaker.huggingface import HuggingFaceModel

# configurazione sagemaker
instance_type = "ml.g5.12xlarge"
numero_di_gpu = 4
health_check_timeout = 300

# Definisci i parametri di configurazione del modello e del punto di accesso
config = {
  'HF_MODEL_ID': "OpenAssistant/pythia-12b-sft-v8-7k-steps", # model_id da hf.co/models
  'SM_NUM_GPUS': json.dumps(numero_di_gpu), # Numero di GPU utilizzate per replica
  'MAX_INPUT_LENGTH': json.dumps(1024),  # Lunghezza massima del testo di input
  'MAX_TOTAL_TOKENS': json.dumps(2048),  # Lunghezza massima della generazione (compreso il testo di input)
  # 'HF_MODEL_QUANTIZE': "bitsandbytes", # commenta per quantizzare
}

# crea HuggingFaceModel con l'URI dell'immagine
llm_model = HuggingFaceModel(
  role=role,
  image_uri=llm_image,
  env=config
)

Dopo aver creato il HuggingFaceModel, possiamo distribuirlo su Amazon SageMaker utilizzando il metodo deploy. Distribuiremo il modello con il tipo di istanza ml.g5.12xlarge. TGI distribuirà automaticamente e suddividerà il modello su tutte le GPU.

# Distribuisci il modello su un punto di accesso
# https://sagemaker.readthedocs.io/en/stable/api/inference/model.html#sagemaker.model.Model.deploy
llm = llm_model.deploy(
  initial_instance_count=1,
  instance_type=instance_type,
  # volume_size=400, # Se si utilizza un'istanza con archiviazione SSD locale, volume_size deve essere None, ad esempio p4 ma non p3
  container_startup_health_check_timeout=health_check_timeout, # 10 minuti per caricare il modello
)

SageMaker creerà ora il nostro punto di accesso e distribuirà il modello su di esso. Ciò potrebbe richiedere da 5 a 10 minuti.

4. Esegui l’elaborazione e chatta con il nostro modello

Dopo aver distribuito il nostro punto di accesso, possiamo eseguire l’elaborazione su di esso utilizzando il metodo predict dal predictor. Possiamo utilizzare diversi parametri per controllare la generazione, definendoli nell’attributo parameters del payload. Ad oggi TGI supporta i seguenti parametri:

• temperature : Controlla la casualità nel modello. Valori più bassi renderanno il modello più deterministico, mentre valori più alti renderanno il modello più casuale. Il valore predefinito è 1.0.
• max_new_tokens : Il numero massimo di token da generare. Il valore predefinito è 20, il valore massimo è 512.
• repetition_penalty : Controlla la probabilità di ripetizione, predefinito a null.
• seed : Il seed da utilizzare per la generazione casuale, predefinito a null.
• stop : Una lista di token per interrompere la generazione. La generazione si interromperà quando uno dei token viene generato.
• top_k : Il numero di token del vocabolario con la probabilità più alta da mantenere per il filtraggio top-k. Il valore predefinito è null, che disabilita il filtraggio top-k.
• top_p : La probabilità cumulativa dei token di vocabolario con la probabilità più alta da mantenere per il campionamento nucleus, predefinito a null.
• do_sample : Se utilizzare o meno il campionamento; altrimenti, utilizzare la decodifica greedy. Il valore predefinito è false.
• best_of : Genera sequenze best_of e restituisci quella con i logprobs dei token più alti, predefinito a null.
• details : Se restituire o meno dettagli sulla generazione. Il valore predefinito è false.
• return_full_text : Se restituire o meno il testo completo o solo la parte generata. Il valore predefinito è false.
• truncate : Se troncare o meno l’input alla lunghezza massima del modello. Il valore predefinito è true.
• typical_p : La probabilità tipica di un token. Il valore predefinito è null.
• watermark : Il watermark da utilizzare per la generazione. Il valore predefinito è false.

Puoi trovare la specifica dell’API aperta di TGI nella documentazione di Swagger

Il OpenAssistant/pythia-12b-sft-v8-7k-steps è un modello di chat conversazionale, il che significa che possiamo chattare con esso utilizzando il seguente prompt:

<|prompter|>[Istruzione]<|endoftext|>
<|assistant|>

Diamo un primo tentativo e chiediamo alcune idee interessanti da fare durante l’estate:

chat = llm.predict({
    "inputs": """<|prompter|>Quali sono alcune idee interessanti da fare durante l'estate?<|endoftext|><|assistant|>"""
})

print(chat[0]["generated_text"])
#     <|prompter|>Quali sono alcune idee interessanti da fare durante l'estate?<|endoftext|><|assistant|&gt>Ci sono molte cose divertenti ed emozionanti che puoi fare durante l'estate. Ecco alcune idee:

Ora mostreremo come utilizzare i parametri di generazione nell’attributo parameters del payload. Oltre a impostare il temperature , top_p , ecc personalizzati, interrompiamo anche la generazione dopo il turno del bot.

# definire il payload
prompt="""<|prompter|>Come posso rimanere più attivo durante l'inverno? Dammi 3 consigli.<|endoftext|><|assistant|>"""

# iperparametri per llm
payload = {
  "inputs": prompt,
  "parameters": {
    "do_sample": True,
    "top_p": 0.7,
    "temperature": 0.7,
    "top_k": 50,
    "max_new_tokens": 256,
    "repetition_penalty": 1.03,
    "stop": ["<|endoftext|>"]
  }
}

# invia la richiesta all'endpoint
response = llm.predict(payload)

# print(response[0]["generated_text"][:-len("<human>:")])
print(response[0]["generated_text"])

5. Creare un chatbot Gradio supportato da Amazon SageMaker

Possiamo anche creare un’applicazione Gradio per chattare con il nostro modello. Gradio è una libreria Python che ti permette di creare rapidamente componenti UI personalizzabili intorno ai tuoi modelli di apprendimento automatico. Puoi trovare ulteriori informazioni su Gradio qui.

!pip install gradio --upgrade

import gradio as gr

# iperparametri per il LLM
parametri = {
    "do_sample": True,
    "top_p": 0.7,
    "temperature": 0.7,
    "top_k": 50,
    "max_new_tokens": 256,
    "repetition_penalty": 1.03,
    "stop": ["<|endoftext|>"]
}

with gr.Blocks() as demo:
    gr.Markdown("## Chatta con Amazon SageMaker")
    with gr.Column():
        chatbot = gr.Chatbot()
        with gr.Row():
            with gr.Column():
                message = gr.Textbox(label="Casella di messaggio", placeholder="Casella di messaggio", show_label=False)
            with gr.Column():
                with gr.Row():
                    submit = gr.Button("Invia")
                    clear = gr.Button("Cancella")

    def rispondi(messaggio, cronologia_chat):
        # converti la cronologia della chat in un prompt
        cronologia_chat_convertita = ""
        if len(cronologia_chat) > 0:
            for c in cronologia_chat:
                cronologia_chat_convertita += f"<|prompter|>{c[0]}<|endoftext|><|assistant|>{c[1]}<|endoftext|>"
        prompt = f"{cronologia_chat_convertita}<|prompter|>{messaggio}<|endoftext|><|assistant|>"

        # invia la richiesta all'endpoint
        risposta_llm = llm.predict({"inputs": prompt, "parameters": parametri})

        # rimuovi il prompt dalla risposta
        risposta_parsata = risposta_llm[0]["generated_text"][len(prompt):]
        cronologia_chat.append((messaggio, risposta_parsata))
        return "", cronologia_chat

    submit.click(rispondi, [message, chatbot], [message, chatbot], queue=False)
    clear.click(lambda: None, None, chatbot, queue=False)

demo.launch(share=True)

Fantastico! 🚀 Abbiamo tranquillamente distribuito il modello Open Assistant su Amazon SageMaker e abbiamo eseguito l’inferenza su di esso. Inoltre, abbiamo creato un’applicazione Gradio rapida per chattare con il nostro modello.

Ora è il momento di provarlo tu stesso e creare applicazioni di generazione AI con il nuovo Hugging Face LLM DLC su Amazon SageMaker.

Per pulire, possiamo eliminare il modello e l’endpoint.

llm.delete_model()
llm.delete_endpoint()

Conclusioni

Il nuovo Hugging Face LLM Inference DLC consente ai clienti di distribuire facilmente e in modo sicuro LLM open-source su Amazon SageMaker. L’API e il processo di distribuzione facili da usare consentono ai clienti di creare chatbot e assistenti virtuali AI scalabili con modelli all’avanguardia come Open Assistant. Nel complesso, questo nuovo DLC permetterà agli sviluppatori e alle aziende di sfruttare gli ultimi progressi nella generazione del linguaggio naturale.

---

Grazie per la lettura! Se hai domande, non esitare a contattarmi su Twitter o LinkedIn.