Pubblicazione di vLLM per modelli linguistici multimodali e solo di testo su GPU Cloud

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Riepilogo

Questo tutorial illustra la procedura di deployment e pubblicazione dei modelli Llama 3.1 e 3.2 utilizzando vLLM in Vertex AI. È progettato per essere utilizzato in combinazione con due notebook distinti: Servi Llama 3.1 con vLLM per il deployment di modelli Llama 3.1 solo di testo e Servi Llama 3.2 multimodale con vLLM per il deployment di modelli Llama 3.2 multimodali che gestiscono input di testo e immagini. I passaggi descritti in questa pagina mostrano come gestire in modo efficiente l'inferenza del modello sulle GPU e personalizzare i modelli per diverse applicazioni, fornendoti gli strumenti per integrare modelli linguistici avanzati nei tuoi progetti.

Al termine di questa guida, saprai come:

• Scarica i modelli Llama predefiniti da Hugging Face con il contenitore vLLM.
• Utilizza vLLM per eseguire il deployment di questi modelli su istanze GPU in Google Cloud Vertex AI Model Garden.
• Pubblica i modelli in modo efficiente per gestire le richieste di inferenza su larga scala.
• Esegui l'inferenza sulle richieste di solo testo e di testo + immagine.
• Pulizia.
• Esegui il debug del deployment.

Funzionalità principali di vLLM

Personalizzazioni di vLLM di Google Vertex AI: migliora le prestazioni e l'integrazione

L'implementazione di vLLM in Model Garden di Google Vertex AI non è un'integrazione diretta della libreria open source. Vertex AI gestisce una versione personalizzata e ottimizzata di vLLM, appositamente studiata per migliorare le prestazioni, l'affidabilità e l'integrazione senza problemi all'interno di Google Cloud.

• Ottimizzazioni delle prestazioni:
  • Download parallelo da Cloud Storage:accelera notevolmente i tempi di caricamento e di implementazione del modello consentendo il recupero parallelo dei dati da Cloud Storage, riducendo la latenza e migliorando la velocità di avvio.
• Miglioramenti delle funzionalità:
  • LoRa dinamico con caching avanzata e supporto di Cloud Storage:espande le funzionalità di LoRa dinamico con meccanismi di memorizzazione nella cache locale e gestione degli errori affidabile, oltre al supporto per il caricamento dei pesi LoRa direttamente dai percorsi di Cloud Storage e dagli URL firmati. In questo modo, vengono semplificate la gestione e l'implementazione dei modelli personalizzati.
  • Analisi delle chiamate di funzioni di Llama 3.1/3.2:implementa l'analisi avanzata per le chiamate di funzioni di Llama 3.1/3.2, migliorando la robustezza dell'analisi.
  • Memorizzazione nella cache dei prefissi della memoria dell'host:il vLLM esterno supporta solo la memorizzazione nella cache dei prefissi della memoria GPU.
  • Decodifica speculativa: si tratta di una funzionalità vLLM esistente, ma Vertex AI ha eseguito esperimenti per trovare configurazioni del modello ad alte prestazioni.

Queste personalizzazioni specifiche di Vertex AI, sebbene spesso trasparenti per l'utente finale, ti consentono di massimizzare le prestazioni e l'efficienza dei tuoi deployment di Llama 3.1 in Vertex AI Model Garden.

• Integrazione dell'ecosistema Vertex AI:
  • Supporto dei formati di input/output di Vertex AI:garantisce la compatibilità perfetta con i formati di input e output di Vertex AI, semplificando la gestione dei dati e l'integrazione con altri servizi Vertex AI.
  • Conoscenza delle variabili di ambiente Vertex: rispetta e sfrutta le variabili di ambiente Vertex AI (AIP_*) per la configurazione e la gestione delle risorse, semplificando il deployment e garantendo un comportamento coerente all'interno dell'ambiente Vertex AI.
  • Maggiore robustezza e gestione degli errori:implementa una gestione completa degli errori, la convalida di input/output e meccanismi di interruzione del server per garantire stabilità, affidabilità e funzionamento senza interruzioni nell'ambiente Vertex AI gestito.
  • Server Nginx per funzionalità:integra un server Nginx sul server vLLM, facilitando il deployment di più repliche e migliorando la scalabilità e l'alta disponibilità dell'infrastruttura di pubblicazione.

Ulteriori vantaggi del vLLM

• Benchmark delle prestazioni: vLLM offre prestazioni competitive rispetto ad altri sistemi di pubblicazione come l'inferenza di generazione di testo di Hugging Face e FasterTransformer di NVIDIA in termini di velocità effettiva e latenza.
• Facilità d'uso: la libreria fornisce un'API semplice per l'integrazione con i flussi di lavoro esistenti, consentendo di implementare i modelli Llama 3.1 e 3.2 con una configurazione minima.
• Funzionalità avanzate: vLLM supporta le uscite in streaming (generando risposte token per token) e gestisce in modo efficiente i prompt di lunghezza variabile, migliorando l'interattività e la reattività nelle applicazioni.

Per una panoramica del sistema vLLM, consulta il documento.

Modelli supportati

vLLM supporta un'ampia selezione di modelli all'avanguardia, che ti consente di scegliere il modello più adatto alle tue esigenze. La tabella seguente offre una selezione di questi modelli. Tuttavia, per accedere a un elenco completo dei modelli supportati, inclusi quelli per l'inferenza sia di solo testo che multimodale, puoi consultare il sito web ufficiale di vLLM.

Iniziare a utilizzare Model Garden

Il contenitore di servizio GPU Cloud vLLM è integrato in Model Garden, nel playground, nel deployment con un solo clic e negli esempi di notebook Colab Enterprise. Questo tutorial si concentra sulla famiglia di modelli Llama di Meta AI come esempio.

Utilizzare il notebook Colab Enterprise

Sono disponibili anche i deployment di Playground e con un solo clic, ma non sono descritti in questo tutorial.

1. Vai alla pagina della scheda del modello e fai clic su Apri notebook.
2. Seleziona il notebook Vertex Serving. Il notebook viene aperto in Colab Enterprise.
3. Esegui il notebook per eseguire il deployment di un modello utilizzando vLLM e invia richieste di previsione all'endpoint.

Configurazione e requisiti

Questa sezione illustra i passaggi necessari per configurare il tuo Google Cloud progetto e assicurarti di disporre delle risorse necessarie per il deployment e la pubblicazione dei modelli vLLM.

1. Fatturazione

• Attiva la fatturazione: assicurati che la fatturazione sia attivata per il progetto. Puoi fare riferimento all'articolo Attivare, disattivare o modificare la fatturazione per un progetto.

2. Disponibilità e quote GPU

• Per eseguire le previsioni utilizzando GPU ad alte prestazioni (NVIDIA A100 80 GB o H100 80 GB), assicurati di controllare le quote per queste GPU nella regione selezionata:
  • Quota NVIDIA A100 da 80 GB
  • Quota NVIDIA H100 da 80 GB

3. Configurare un Google Cloud progetto

Esegui il seguente esempio di codice per assicurarti che l' Google Cloud ambiente sia configurato correttamente. Questo passaggio installa le librerie Python necessarie e configura l'accesso alle risorse Google Cloud . Le azioni includono:

• Installazione: esegui l'upgrade della libreria google-cloud-aiplatform e clona il repository contenente le funzioni di utilità.
• Configurazione dell'ambiente: definisci le variabili per l' Google Cloud ID progetto, la regione e un bucket Cloud Storage univoco per l'archiviazione degli elementi del modello.
• Attivazione delle API: abilita le API Vertex AI e Compute Engine, che sono essenziali per il deployment e la gestione dei modelli di IA.
• Configurazione del bucket: crea un nuovo bucket Cloud Storage o controlla un bucket esistente per assicurarti che si trovi nella regione corretta.
• Inizializzazione di Vertex AI: inizializza la libreria client di Vertex AI con le impostazioni del progetto, della posizione e del bucket di staging.
• Configurazione dell'account di servizio: identifica l'account di servizio predefinito per l'esecuzione dei job Vertex AI e concedi le autorizzazioni necessarie.

BUCKET_URI = "gs://"

REGION = ""

! pip3 install --upgrade --quiet 'google-cloud-aiplatform>=1.64.0'
! git clone https://github.com/GoogleCloudPlatform/vertex-ai-samples.git

import datetime
import importlib
import os
import uuid
from typing import Tuple

import requests
from google.cloud import aiplatform

common_util = importlib.import_module(
    "vertex-ai-samples.community-content.vertex_model_garden.model_oss.notebook_util.common_util"
)

models, endpoints = {}, {}

PROJECT_ID = os.environ["GOOGLE_CLOUD_PROJECT"]

if not REGION:
    REGION = os.environ["GOOGLE_CLOUD_REGION"]

print("Enabling Vertex AI API and Compute Engine API.")
! gcloud services enable aiplatform.googleapis.com compute.googleapis.com

now = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
BUCKET_NAME = "/".join(BUCKET_URI.split("/")[:3])

if BUCKET_URI is None or BUCKET_URI.strip() == "" or BUCKET_URI == "gs://":
    BUCKET_URI = f"gs://{PROJECT_ID}-tmp-{now}-{str(uuid.uuid4())[:4]}"
    BUCKET_NAME = "/".join(BUCKET_URI.split("/")[:3])
    ! gsutil mb -l {REGION} {BUCKET_URI}
else:
    assert BUCKET_URI.startswith("gs://"), "BUCKET_URI must start with `gs://`."
    shell_output = ! gsutil ls -Lb {BUCKET_NAME} | grep "Location constraint:" | sed "s/Location constraint://"
    bucket_region = shell_output[0].strip().lower()
    if bucket_region != REGION:
        raise ValueError(
            "Bucket region %s is different from notebook region %s"
            % (bucket_region, REGION)
        )
print(f"Using this Bucket: {BUCKET_URI}")

STAGING_BUCKET = os.path.join(BUCKET_URI, "temporal")
MODEL_BUCKET = os.path.join(BUCKET_URI, "llama3_1")

print("Initializing Vertex AI API.")
aiplatform.init(project=PROJECT_ID, location=REGION, staging_bucket=STAGING_BUCKET)

shell_output = ! gcloud projects describe $PROJECT_ID
project_number = shell_output[-1].split(":")[1].strip().replace("'", "")
SERVICE_ACCOUNT = "your service account email"
print("Using this default Service Account:", SERVICE_ACCOUNT)

! gsutil iam ch serviceAccount:{SERVICE_ACCOUNT}:roles/storage.admin $BUCKET_NAME

! gcloud config set project $PROJECT_ID
! gcloud projects add-iam-policy-binding --no-user-output-enabled {PROJECT_ID} --member=serviceAccount:{SERVICE_ACCOUNT} --role="roles/storage.admin"
! gcloud projects add-iam-policy-binding --no-user-output-enabled {PROJECT_ID} --member=serviceAccount:{SERVICE_ACCOUNT} --role="roles/aiplatform.user"

Utilizzo di Hugging Face con Meta Llama 3.1, 3.2 e vLLM

Le collezioni Llama 3.1 e 3.2 di Meta forniscono una gamma di modelli linguistici di grandi dimensioni (LLM) multilingue progettati per la generazione di testo di alta qualità in vari casi d'uso. Questi modelli sono preaddestrati e ottimizzati in base alle istruzioni e sono eccellenti in attività come il dialogo multilingue, il riassunto e il recupero di agenti. Prima di utilizzare i modelli Llama 3.1 e 3.2, devi accettare i relativi termini di utilizzo, come mostrato nello screenshot. La libreria vLLM offre un ambiente di pubblicazione semplificato open source con ottimizzazioni per latenza, efficienza della memoria e scalabilità.

Nota importante: per accedere a questi modelli è necessario condividere i tuoi dati di contatto e accettare i termini di utilizzo descritti nelle Norme sulla privacy di Meta. La richiesta verrà esaminata dagli autori del repository.

Figura 1: Contratto di licenza per la community Meta Llama 3

Panoramica delle raccolte Meta Llama 3.1 e 3.2

Le collezioni Llama 3.1 e 3.2 sono adatte a diversi livelli di implementazione e dimensioni dei modelli, offrendo opzioni flessibili per le attività di dialogo multilingue e non solo. Per ulteriori informazioni, consulta la pagina Panoramica di Llama.

• Solo testo: la raccolta Llama 3.2 di modelli linguistici di grandi dimensioni (LLM) multilingue è una raccolta di modelli generativi preaddestrati e ottimizzati in base alle istruzioni con dimensioni di 1 miliardo e 3 miliardi (testo in, testo in uscita).
• Vision e Vision Instruct: la raccolta di modelli linguistici di grandi dimensioni (LLM) multimodali Llama 3.2-Vision è una raccolta di modelli generativi di ragionamento per immagini preaddestrati e ottimizzati per le istruzioni con dimensioni di 11 miliardi e 90 miliardi (testo + immagini in, testo in uscita). Ottimizzazione: come Llama 3.1, i modelli 3.2 sono personalizzati per il dialogo multilingue e hanno un buon rendimento nelle attività di recupero e riepilogo, ottenendo risultati migliori nei benchmark standard.
• Architettura del modello: Llama 3.2 include anche un framework di transformer autoregressivo, con SFT e RLHF applicati per allineare i modelli in termini di utilità e sicurezza.

Token di accesso utente Hugging Face

Per accedere alle risorse necessarie, questo tutorial richiede un token di accesso in lettura da Hugging Face Hub. Per configurare l'autenticazione:

Figura 2: Impostazioni del token di accesso a Hugging Face

1. Genera un token di accesso in lettura:

   • Vai alle impostazioni dell'account di Abbracci di Facebook.
   • Crea un nuovo token, assegnagli il ruolo Lettura e salvalo in modo sicuro.

2. Utilizza il token:

   • Utilizza il token generato per autenticarti e accedere ai repository pubblici o privati in base alle esigenze del tutorial.

Figura 3: Gestisci token di accesso a Hugging Face

Questa configurazione ti garantisce il livello di accesso appropriato senza autorizzazioni non necessarie. Queste pratiche migliorano la sicurezza e impediscono l'esposizione accidentale dei token. Per ulteriori informazioni sulla configurazione dei token di accesso, visita la pagina dei token di accesso Hugging Face.

Evita di condividere o esporre il token pubblicamente o online. Quando imposti il token come variabile di ambiente durante il deployment, rimane privato per il tuo progetto. Vertex AI garantisce la propria sicurezza impedendo ad altri utenti di accedere ai tuoi modelli e endpoint.

Per ulteriori informazioni sulla protezione del token di accesso, consulta la pagina Token di accesso a Hugging Face - Best practice.

Eseguire il deployment di modelli Llama 3.1 di solo testo con vLLM

Per il deployment a livello di produzione di modelli linguistici di grandi dimensioni, vLLM fornisce una soluzione di pubblicazione efficiente che ottimizza l'utilizzo della memoria, riduce la latenza e aumenta il throughput. Ciò lo rende particolarmente adatto per gestire i modelli Llama 3.1 più grandi, nonché i modelli multimodali Llama 3.2.

Passaggio 1: scegli un modello da implementare

Scegli la variante del modello Llama 3.1 da eseguire. Le opzioni disponibili includono vari formati e versioni ottimizzate per l'insegnamento:

base_model_name = "Meta-Llama-3.1-8B"  # @param ["Meta-Llama-3.1-8B", "Meta-Llama-3.1-8B-Instruct", "Meta-Llama-3.1-70B", "Meta-Llama-3.1-70B-Instruct", "Meta-Llama-3.1-405B-FP8", "Meta-Llama-3.1-405B-Instruct-FP8"]
hf_model_id = "meta-Llama/" + base_model_name

Passaggio 2: controlla l'hardware e la quota di deployment

La funzione di deployment imposta la GPU e il tipo di macchina appropriati in base alle dimensioni del modello e controlla la quota nella regione per un determinato progetto:

if "8b" in base_model_name.lower():
    accelerator_type = "NVIDIA_L4"
    machine_type = "g2-standard-12"
    accelerator_count = 1
elif "70b" in base_model_name.lower():
    accelerator_type = "NVIDIA_L4"
    machine_type = "g2-standard-96"
    accelerator_count = 8
elif "405b" in base_model_name.lower():
    accelerator_type = "NVIDIA_H100_80GB"
    machine_type = "a3-highgpu-8g"
    accelerator_count = 8
else:
    raise ValueError(f"Recommended GPU setting not found for: {accelerator_type} and {base_model_name}.")

Verifica la disponibilità della quota di GPU nella regione specificata:

common_util.check_quota(
    project_id=PROJECT_ID,
    region=REGION,
    accelerator_type=accelerator_type,
    accelerator_count=accelerator_count,
    is_for_training=False,
)

Passaggio 3: controlla il modello utilizzando vLLM

La funzione seguente carica il modello in Vertex AI, configura le impostazioni di deployment ed esegue il deployment in un endpoint utilizzando vLLM.

1. Immagine Docker: il deployment utilizza un'immagine Docker vLLM predefinita per un servizio efficiente.
2. Configurazione: configura l'utilizzo della memoria, la lunghezza del modello e altre impostazioni del vLLM. Per ulteriori informazioni sugli argomenti supportati dal server, visita la pagina di documentazione ufficiale di vLLM.
3. Variabili di ambiente: imposta le variabili di ambiente per l'autenticazione e l'origine di deployment.

def deploy_model_vllm(
    model_name: str,
    model_id: str,
    service_account: str,
    base_model_id: str = None,
    machine_type: str = "g2-standard-8",
    accelerator_type: str = "NVIDIA_L4",
    accelerator_count: int = 1,
    gpu_memory_utilization: float = 0.9,
    max_model_len: int = 4096,
    dtype: str = "auto",
    enable_trust_remote_code: bool = False,
    enforce_eager: bool = False,
    enable_lora: bool = False,
    max_loras: int = 1,
    max_cpu_loras: int = 8,
    use_dedicated_endpoint: bool = False,
    max_num_seqs: int = 256,
) -> Tuple[aiplatform.Model, aiplatform.Endpoint]:
    """Deploys trained models with vLLM into Vertex AI."""
    endpoint = aiplatform.Endpoint.create(
        display_name=f"{model_name}-endpoint",
        dedicated_endpoint_enabled=use_dedicated_endpoint,
    )

    if "8b" in base_model_name.lower():
        accelerator_type = "NVIDIA_L4"
        machine_type = "g2-standard-12"
        accelerator_count = 1
    elif "70b" in base_model_name.lower():
        accelerator_type = "NVIDIA_L4"
        machine_type = "g2-standard-96"
        accelerator_count = 8
    elif "405b" in base_model_name.lower():
        accelerator_type = "NVIDIA_H100_80GB"
        machine_type = "a3-highgpu-8g"
        accelerator_count = 8
    else:
        raise ValueError(f"Recommended GPU setting not found for: {accelerator_type} and {base_model_name}.")

    common_util.check_quota(
        project_id=PROJECT_ID,
        region=REGION,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        is_for_training=False,
    )

    vllm_args = [
        "python", "-m", "vllm.entrypoints.api_server", 
        "--host=0.0.0.0", 
        "--port=8080",
        f"--model={model_id}", 
        f"--tensor-parallel-size={accelerator_count}",
        "--swap-space=16",
        f"--gpu-memory-utilization={gpu_memory_utilization}",
        f"--max-model-len={max_model_len}", f"--dtype={dtype}",
        f"--max-loras={max_loras}", f"--max-cpu-loras={max_cpu_loras}",
        f"--max-num-seqs={max_num_seqs}", "--disable-log-stats"
    ]

    if enable_trust_remote_code:
        vllm_args.append("--trust-remote-code")
    if enforce_eager:
        vllm_args.append("--enforce-eager")
    if enable_lora:
        vllm_args.append("--enable-lora")
    if model_type:
        vllm_args.append(f"--model-type={model_type}")

    env_vars = {
        "MODEL_ID": model_id,
        "DEPLOY_SOURCE": "notebook",
        "HF_TOKEN": HF_TOKEN
    }

    model = aiplatform.Model.upload(
        display_name=model_name,
        serving_container_image_uri=VLLM_DOCKER_URI,
        serving_container_args=vllm_args,
        serving_container_ports=[8080],
        serving_container_predict_route="/generate",
        serving_container_health_route="/ping",
        serving_container_environment_variables=env_vars,
        serving_container_shared_memory_size_mb=(16 * 1024),
        serving_container_deployment_timeout=7200,
    )
    print(f"Deploying {model_name} on {machine_type} with {accelerator_count} {accelerator_type} GPU(s).")

    model.deploy(
        endpoint=endpoint,
        machine_type=machine_type,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        deploy_request_timeout=1800,
        service_account=service_account,
    )
    print("endpoint_name:", endpoint.name)

    return model, endpoint

Passaggio 4: esegui il deployment

Esegui la funzione di deployment con il modello e la configurazione selezionati. Questo passaggio esegue il deployment del modello e restituisce le istanze del modello e dell'endpoint:

HF_TOKEN = ""

VLLM_DOCKER_URI = "us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20241001_0916_RC00"

model_name = common_util.get_job_name_with_datetime(prefix=f"{base_model_name}-serve-vllm")
gpu_memory_utilization = 0.9
max_model_len = 4096
max_loras = 1

models["vllm_gpu"], endpoints["vllm_gpu"] = deploy_model_vllm(
    model_name=common_util.get_job_name_with_datetime(prefix=f"{base_model_name}-serve"),
    model_id=hf_model_id,
    service_account=SERVICE_ACCOUNT,
    machine_type=machine_type,
    accelerator_type=accelerator_type,
    accelerator_count=accelerator_count,
    gpu_memory_utilization=gpu_memory_utilization,
    max_model_len=max_model_len,
    max_loras=max_loras,
    enforce_eager=True,
    enable_lora=True,
    use_dedicated_endpoint=use_dedicated_endpoint,
)

Dopo aver eseguito questo esempio di codice, il modello Llama 3.1 verrà implementato su Vertex AI e sarà accessibile tramite l'endpoint specificato. Puoi interagire con esso per attività di inferenza come generazione di testo, riassunto e dialogo. A seconda delle dimensioni del modello, il deployment del nuovo modello può richiedere fino a un'ora. Puoi controllare l'avanzamento in Vertex Online Prediction.

Figura 4: endpoint di deployment di Llama 3.1 nella dashboard di Vertex

Eseguire previsioni con Llama 3.1 su Vertex AI

Dopo aver eseguito correttamente il deployment del modello Llama 3.1 in Vertex AI, puoi iniziare a fare previsioni inviando prompt di testo all'endpoint. Questa sezione fornisce un esempio di generazione di risposte con vari parametri personalizzabili per il controllo dell'output.

Passaggio 1: definisci il prompt e i parametri

Per iniziare, configura il prompt di testo e i parametri di campionamento per orientare la risposta del modello. Ecco i parametri principali:

• prompt: il testo di input per cui vuoi che il modello generi una risposta. Ad esempio, prompt = "Che cos'è un'auto?".
• max_tokens: il numero massimo di token nell'output generato. La riduzione di questo valore può contribuire a evitare problemi di timeout.
• temperature: controlla la casualità delle previsioni. Valori più alti (ad es.1, 0) aumentano la diversità, mentre valori più bassi (ad es.0, 5) rendono l'output più mirato.
• top_p: limita il pool di campionamento alla probabilità cumulativa massima. Ad esempio, l'impostazione top_p = 0,9 prende in considerazione solo i token all'interno della massa di probabilità del 90% superiore.
• top_k: limita il campionamento ai token più probabili tra i primi k. Ad esempio, l'impostazione top_k = 50 eseguirà il campionamento solo tra i 50 token principali.
• raw_response: se True, restituisce l'output non elaborato del modello. Se False, applica una formattazione aggiuntiva con la struttura "Prompt:\n{prompt}\nOutput:\n{output}".
• lora_id (facoltativo): percorso dei file dei pesi LoRA per applicare i pesi con adattamento a basso ranking (LoRA). Può essere un bucket Cloud Storage o un URL del repository Hugging Face. Tieni presente che questo funziona solo se --enable-lora è impostato negli argomenti di deployment. LoRa dinamico non è supportato per i modelli multimodali.

prompt = "What is a car?"
max_tokens = 50
temperature = 1.0
top_p = 1.0
top_k = 1
raw_response = False
lora_id = ""

Passaggio 2: invia la richiesta di previsione

Ora che l'istanza è configurata, puoi inviare la richiesta di previsione all'endpoint Vertex AI di cui è stato eseguito il deployment. Questo esempio mostra come fare una previsione e stampare il risultato:

response = endpoints["vllm_gpu"].predict(
    instances=instances, use_dedicated_endpoint=use_dedicated_endpoint
)

for prediction in response.predictions:
    print(prediction)

Output di esempio

Ecco un esempio di come il modello potrebbe rispondere al prompt "Che cos'è un'auto?":

Human: What is a car?
Assistant: A car, or a motor car, is a road-connected human-transportation system
used to move people or goods from one place to another.

Note aggiuntive

• Moderazione: per garantire contenuti sicuri, puoi moderare il testo generato con le funzionalità di moderazione del testo di Vertex AI.
• Gestione dei timeout: se riscontri problemi come ServiceUnavailable: 503, prova a ridurre il parametro max_tokens.

Questo approccio offre un modo flessibile per interagire con il modello Llama 3.1 utilizzando diverse tecniche di campionamento e adattatori LoRA, rendendolo adatto a una serie di casi d'uso, dalla generazione di testo generico alle risposte specifiche per attività.

Deployment di modelli Llama 3.2 multimodali con vLLM

Questa sezione illustra la procedura di caricamento dei modelli Llama 3.2 predefiniti nel registro dei modelli ed esegue il loro deployment in un endpoint Vertex AI. Il tempo di implementazione può richiedere fino a un'ora, a seconda delle dimensioni del modello. I modelli Llama 3.2 sono disponibili in versioni multimodali che supportano input sia di testo che di immagini. vLLM supporta:

• Formato solo testo
• Formato di testo + immagine singola

Questi formati rendono Llama 3.2 adatto per le applicazioni che richiedono l'elaborazione sia visiva che di testo.

Passaggio 1: scegli un modello da implementare

Specifica la variante del modello Llama 3.2 di cui vuoi eseguire il deployment. L'esempio seguente utilizza Llama-3.2-11B-Vision come modello selezionato, ma puoi scegliere tra le altre opzioni disponibili in base ai tuoi requisiti.

base_model_name = "Llama-3.2-11B-Vision"  # @param ["Llama-3.2-1B", "Llama-3.2-1B-Instruct", "Llama-3.2-3B", "Llama-3.2-3B-Instruct", "Llama-3.2-11B-Vision", "Llama-3.2-11B-Vision-Instruct", "Llama-3.2-90B-Vision", "Llama-3.2-90B-Vision-Instruct"]
hf_model_id = "meta-Llama/" + base_model_name

Passaggio 2: configura l'hardware e le risorse

Seleziona l'hardware appropriato per le dimensioni del modello. vLLM può utilizzare GPU diverse a seconda delle esigenze di calcolo del modello:

• Modelli 1B e 3B: utilizza GPU NVIDIA L4.
• Modelli 11B: utilizza GPU NVIDIA A100.
• Modelli 90B: utilizza GPU NVIDIA H100.

Questo esempio configura il deployment in base alla selezione del modello:

if "3.2-1B" in base_model_name or "3.2-3B" in base_model_name:
    accelerator_type = "NVIDIA_L4"
    machine_type = "g2-standard-8"
    accelerator_count = 1
elif "3.2-11B" in base_model_name:
    accelerator_type = "NVIDIA_TESLA_A100"
    machine_type = "a2-highgpu-1g"
    accelerator_count = 1
elif "3.2-90B" in base_model_name:
    accelerator_type = "NVIDIA_H100_80GB"
    machine_type = "a3-highgpu-8g"
    accelerator_count = 8
else:
    raise ValueError(f"Recommended GPU setting not found for: {base_model_name}.")

Assicurati di disporre della quota di GPU richiesta:

common_util.check_quota(
    project_id=PROJECT_ID,
    region=REGION,
    accelerator_type=accelerator_type,
    accelerator_count=accelerator_count,
    is_for_training=False,
)

Passaggio 3: esegui il deployment del modello utilizzando vLLM

La seguente funzione gestisce il deployment del modello Llama 3.2 su Vertex AI. Configura l'ambiente, l'utilizzo della memoria e le impostazioni del vLLM del modello per una pubblicazione efficiente.

def deploy_model_vllm(
    model_name: str,
    model_id: str,
    service_account: str,
    base_model_id: str = None,
    machine_type: str = "g2-standard-8",
    accelerator_type: str = "NVIDIA_L4",
    accelerator_count: int = 1,
    gpu_memory_utilization: float = 0.9,
    max_model_len: int = 4096,
    dtype: str = "auto",
    enable_trust_remote_code: bool = False,
    enforce_eager: bool = False,
    enable_lora: bool = False,
    max_loras: int = 1,
    max_cpu_loras: int = 8,
    use_dedicated_endpoint: bool = False,
    max_num_seqs: int = 12,
    model_type: str = None,
) -> Tuple[aiplatform.Model, aiplatform.Endpoint]:
    """Deploys trained models with vLLM into Vertex AI."""
    endpoint = aiplatform.Endpoint.create(
        display_name=f"{model_name}-endpoint",
        dedicated_endpoint_enabled=use_dedicated_endpoint,
    )

    if not base_model_id:
        base_model_id = model_id

    vllm_args = [
        "python",
        "-m",
        "vllm.entrypoints.api_server",
        "--host=0.0.0.0",
        "--port=8080",
        f"--model={model_id}",
        f"--tensor-parallel-size={accelerator_count}",
        "--swap-space=16",
        f"--gpu-memory-utilization={gpu_memory_utilization}",
        f"--max-model-len={max_model_len}",
        f"--dtype={dtype}",
        f"--max-loras={max_loras}",
        f"--max-cpu-loras={max_cpu_loras}",
        f"--max-num-seqs={max_num_seqs}",
        "--disable-log-stats",
    ]

    if enable_trust_remote_code:
        vllm_args.append("--trust-remote-code")
    if enforce_eager:
        vllm_args.append("--enforce-eager")
    if enable_lora:
        vllm_args.append("--enable-lora")
    if model_type:
        vllm_args.append(f"--model-type={model_type}")

    env_vars = {
        "MODEL_ID": base_model_id,
        "DEPLOY_SOURCE": "notebook",
    }

    # HF_TOKEN is not a compulsory field and may not be defined.
    try:
        if HF_TOKEN:
            env_vars["HF_TOKEN"] = HF_TOKEN
    except NameError:
        pass

    model = aiplatform.Model.upload(
        display_name=model_name,
        serving_container_image_uri=VLLM_DOCKER_URI,
        serving_container_args=vllm_args,
        serving_container_ports=[8080],
        serving_container_predict_route="/generate",
        serving_container_health_route="/ping",
        serving_container_environment_variables=env_vars,
        serving_container_shared_memory_size_mb=(16 * 1024),
        serving_container_deployment_timeout=7200,
    )
    print(f"Deploying {model_name} on {machine_type} with {accelerator_count} {accelerator_type} GPU(s).")

    model.deploy(
        endpoint=endpoint,
        machine_type=machine_type,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        deploy_request_timeout=1800,
        service_account=service_account,
    )
    print("endpoint_name:", endpoint.name)

    return model, endpoint

Passaggio 4: esegui il deployment

Esegui la funzione di deployment con il modello e le impostazioni configurati. La funzione restituirà sia le istanze del modello sia quelle dell'endpoint, che potrai utilizzare per l'inferenza.

model_name = common_util.get_job_name_with_datetime(prefix=f"{base_model_name}-serve-vllm")
models["vllm_gpu"], endpoints["vllm_gpu"] = deploy_model_vllm(
    model_name=model_name
    model_id=hf_model_id,
    base_model_id=hf_model_id,
    service_account=SERVICE_ACCOUNT,
    machine_type=machine_type,
    accelerator_type=accelerator_type,
    accelerator_count=accelerator_count,
    gpu_memory_utilization=gpu_memory_utilization,
    max_model_len=max_model_len,
    enforce_eager=True,
    use_dedicated_endpoint=use_dedicated_endpoint,
    max_num_seqs=max_num_seqs,
)

Figura 5: endpoint di deployment di Llama 3.2 in Vertex Dashboard

A seconda delle dimensioni del modello, il completamento del deployment del nuovo modello può richiedere fino a un'ora. Puoi controllare l'avanzamento in Vertex Online Prediction.

Interruzione con vLLM su Vertex AI utilizzando il percorso di previsione predefinito

Questa sezione illustra la configurazione dell'inferenza per il modello Llama 3.2 Vision su Vertex AI utilizzando il percorso di previsione predefinito. Utilizzerai la libreria vLLM per pubblicazioni efficienti e interagirai con il modello inviando un prompt visivo in combinazione con il testo.

Per iniziare, assicurati che l'endpoint del modello sia di cui è stato eseguito il deployment e sia pronto per le previsioni.

Passaggio 1: definisci il prompt e i parametri

Questo esempio fornisce un URL immagine e un prompt di testo, che il modello elaborerà per generare una risposta.

Figura 6: input di immagini di esempio per i prompt di Llama 3.2

image_url = "https://images.pexels.com/photos/1254140/pexels-photo-1254140.jpeg"

raw_prompt = "This is a picture of"

# Reference prompt formatting guidelines here: https://www.Llama.com/docs/model-cards-and-prompt-formats/Llama3_2/#-base-model-prompt
prompt = f"<|begin_of_text|><|image|>{raw_prompt}"

Passaggio 2: configura i parametri di previsione

Modifica i seguenti parametri per controllare la risposta del modello:

max_tokens = 64

temperature = 0.5

top_p = 0.95

Passaggio 3: prepara la richiesta di previsione

Configura la richiesta di previsione con l'URL immagine, il prompt e altri parametri.

instances = [
    {
        "prompt": prompt,
        "multi_modal_data": {"image": image_url},
        "max_tokens": max_tokens,
        "temperature": temperature,
        "top_p": top_p,
    },
]

Passaggio 4: fai la previsione

Invia la richiesta all'endpoint Vertex AI ed elabora la risposta:

response = endpoints["vllm_gpu"].predict(instances=instances)

for raw_prediction in response.predictions:
    prediction = raw_prediction.split("Output:")
    print(prediction[1])

Se riscontri un problema di timeout (ad esempio ServiceUnavailable: 503 Took too long to respond when processing), prova a ridurre il valore max_tokens a un numero inferiore, ad esempio 20, per ridurre il tempo di risposta.

Interruzione con vLLM su Vertex AI utilizzando la funzionalità di completamento di chat di OpenAI

Questa sezione spiega come eseguire l'inferenza sui modelli Llama 3.2 Vision utilizzando l'API OpenAI Chat Completions su Vertex AI. Questo approccio ti consente di utilizzare funzionalità multimodali inviando al modello sia prompt di testo che di immagini per risposte più interattive.

Passaggio 1: esegui il deployment del modello Llama 3.2 Vision Instruct

Esegui la funzione di deployment con il modello e le impostazioni configurati. La funzione restituirà sia le istanze del modello sia quelle dell'endpoint, che puoi utilizzare per l'inferenza.

base_model_name = "Llama-3.2-11B-Vision-Instruct"
hf_model_id = f"meta-llama/{base_model_name}"
model_name = common_util.get_job_name_with_datetime(prefix=f"{base_model_name}-serve-vllm")
model, endpoint = deploy_model_vllm(
    model_name=model_name
    model_id=hf_model_id,
    base_model_id=hf_model_id,
    service_account=SERVICE_ACCOUNT,
    machine_type="a2-highgpu-1g",
    accelerator_type="NVIDIA_TESLA_A100",
    accelerator_count=1,
    gpu_memory_utilization=0.9,
    max_model_len=4096,
    enforce_eager=True,
    max_num_seqs=12,
)

Passaggio 2: configura la risorsa endpoint

Per iniziare, configura il nome della risorsa endpoint per il deployment di Vertex AI.

ENDPOINT_RESOURCE_NAME = "projects/{}/locations/{}/endpoints/{}".format(
    PROJECT_ID, REGION, endpoint.name
)

Passaggio 3: installa l'SDK OpenAI e le librerie di autenticazione

Per inviare richieste utilizzando l'SDK di OpenAI, assicurati che siano installate le librerie necessarie:

!pip install -qU openai google-auth requests

Passaggio 4: definisci i parametri di input per il completamento della chat

Configura l'URL immagine e il prompt di testo che verranno inviati al modello. Regola max_tokens e temperature per controllare rispettivamente la lunghezza e la casualità della risposta.

user_image = "https://images.freeimages.com/images/large-previews/ab3/puppy-2-1404644.jpg"
user_message = "Describe this image?"
max_tokens = 50
temperature = 1.0

Passaggio 5: configura l'autenticazione e l'URL base

Recupera le credenziali e imposta l'URL di base per le richieste API.

import google.auth
import openai

creds, project = google.auth.default()
auth_req = google.auth.transport.requests.Request()
creds.refresh(auth_req)

BASE_URL = (
    f"https://{REGION}-aiplatform.googleapis.com/v1beta1/{ENDPOINT_RESOURCE_NAME}"
)
try:
    if use_dedicated_endpoint:
        BASE_URL = f"https://{DEDICATED_ENDPOINT_DNS}/v1beta1/{ENDPOINT_RESOURCE_NAME}"
except NameError:
    pass

Passaggio 6: invia la richiesta di completamento della chat

Utilizzando l'API Chat Completions di OpenAI, invia l'immagine e il prompt di testo all'endpoint Vertex AI:

client = openai.OpenAI(base_url=BASE_URL, api_key=creds.token)

model_response = client.chat.completions.create(
    model="",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "image_url", "image_url": {"url": user_image}},
                {"type": "text", "text": user_message},
            ],
        }
    ],
    temperature=temperature,
    max_tokens=max_tokens,
)

print(model_response)

(Facoltativo) Passaggio 7: ricollega un endpoint esistente

Per ricollegarti a un endpoint creato in precedenza, utilizza l'ID endpoint. Questo passaggio è utile se vuoi riutilizzare un endpoint anziché crearne uno nuovo.

endpoint_name = ""
aip_endpoint_name = (
     f"projects/{PROJECT_ID}/locations/{REGION}/endpoints/{endpoint_name}"
)
endpoint = aiplatform.Endpoint(aip_endpoint_name)

Questa configurazione offre la flessibilità di passare da un endpoint appena creato a uno esistente, se necessario, consentendo di semplificare i test e l'implementazione.

Esegui la pulizia

Per evitare addebiti continui e liberare risorse, assicurati di eliminare i modelli e gli endpoint di cui è stato eseguito il deployment e, facoltativamente, il bucket di archiviazione utilizzato per questo esperimento.

Passaggio 1: elimina endpoint e modelli

Il seguente codice annulla il deployment di ogni modello ed elimina gli endpoint associati:

# Undeploy model and delete endpoint
for endpoint in endpoints.values():
    endpoint.delete(force=True)

# Delete models
for model in models.values():
    model.delete()

(Facoltativo) Passaggio 2: elimina il bucket Cloud Storage

Se hai creato un bucket Cloud Storage appositamente per questo esperimento, puoi eliminarlo impostando delete_bucket su True. Questo passaggio è facoltativo, ma consigliato se il bucket non è più necessario.

delete_bucket = False
if delete_bucket:
    ! gsutil -m rm -r $BUCKET_NAME

Se segui questi passaggi, ti assicurerai che tutte le risorse utilizzate in questo tutorial vengano eliminate, riducendo così i costi non necessari associati all'esperimento.

Risolvere i problemi comuni di debug

Questa sezione fornisce indicazioni per identificare e risolvere i problemi comuni riscontrati durante il deployment e l'inferenza del modello vLLM su Vertex AI.

Controlla i log

Controlla i log per identificare la causa principale degli errori di deployment o del comportamento imprevisto:

1. Vai a Vertex AI Prediction Console:vai a Vertex AI Prediction Console nella console Google Cloud.
2. Seleziona l'endpoint:fai clic sull'endpoint che presenta problemi. Lo stato dovrebbe indicare se il deployment non è riuscito.
3. Visualizza log:fai clic sull'endpoint, poi vai alla scheda Log o fai clic su Visualizza log. Verrà visualizzata la pagina Cloud Logging, filtrata in modo da mostrare i log specifici per l'endpoint e il deployment del modello. Puoi anche accedere ai log direttamente tramite il servizio Cloud Logging.
4. Esegui l'analisi dei log:esamina le voci dei log per trovare messaggi di errore, avvisi e altre informazioni pertinenti. Visualizza i timestamp per correlare le voci di log con azioni specifiche. Cerca problemi relativi a limitazioni delle risorse (memoria e CPU), problemi di autenticazione o errori di configurazione.

Problema comune 1: esaurimento della memoria CUDA (OOM) durante il deployment

Gli errori CUDA Out of Memory (OOM) si verificano quando l'utilizzo della memoria del modello supera la capacità della GPU disponibile.

Nel caso del modello solo testo, abbiamo utilizzato i seguenti argomenti del motore:

base_model_name = "Meta-Llama-3.1-8B"
hf_model_id = f"meta-llama/{base_model_name}"
accelerator_type = "NVIDIA_L4"
accelerator_count = 1
machine_type = "g2-standard-12"
accelerator_count: int = 1
gpu_memory_utilization = 0.9
max_model_len = 4096
dtype = "auto"
max_num_seqs = 256

Nel caso del modello multimodale, abbiamo utilizzato i seguenti argomenti del motore:

base_model_name = "Llama-3.2-11B-Vision-Instruct"
hf_model_id = f"meta-llama/{base_model_name}"
accelerator_type = "NVIDIA_L4"
accelerator_count = 1
machine_type = "g2-standard-12"
accelerator_count: int = 1
gpu_memory_utilization = 0.9
max_model_len = 4096
dtype = "auto"
max_num_seqs = 12

Il deployment del modello multimodale con max_num_seqs = 256, come abbiamo fatto nel caso del modello solo testo, potrebbe causare il seguente errore:

[rank0]: torch.OutOfMemoryError: CUDA out of memory. Tried to allocate 3.91 GiB. GPU 0 has a total capacity of 39.38 GiB of which 3.76 GiB is free. Including non-PyTorch memory, this process has 0 bytes memory in use. Of the allocated memory 34.94 GiB is allocated by PyTorch, and 175.15 MiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)

Figura 7: log degli errori della GPU relativi a memoria insufficiente (OOM)

Informazioni su max_num_seqs e sulla memoria GPU:

• Il parametro max_num_seqs definisce il numero massimo di richieste in parallelo che il modello può gestire.
• Ogni sequenza elaborata dal modello consuma memoria GPU. L'utilizzo totale della memoria è proporzionale a max_num_seqs volte la memoria per sequenza.
• I modelli solo di testo (come Meta-Llama-3.1-8B) in genere consumano meno memoria per sequenza rispetto ai modelli multimodali (come Llama-3.2-11B-Vision-Instruct), che elaborano sia il testo sia le immagini.

Esamina il log degli errori (figura 8):

• Il log mostra un torch.OutOfMemoryError quando si tenta di allocare memoria sulla GPU.
• L'errore si verifica perché l'utilizzo della memoria del modello supera la capacità della GPU disponibile. La GPU NVIDIA L4 ha 24 GB e l'impostazione di un parametro max_num_seqs troppo alto per il modello multimodale causa un overflow.
• Il log suggerisce di impostare PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True per migliorare la gestione della memoria, anche se il problema principale è l'utilizzo elevato della memoria.

Figura 8: Deployment di Llama 3.2 non riuscito

Figura 9: riquadro dei dettagli della versione del modello

Per risolvere il problema, vai alla console di previsione Vertex AI e fai clic sull'endpoint. Lo stato dovrebbe indicare che il deployment non è riuscito. Fai clic per visualizzare i log. Verifica che max-num-seqs = 256. Questo valore è troppo alto per Llama-3.2-11B-Vision-Instruct. Un valore più adeguato dovrebbe essere 12.

Problema comune 2: è necessario il token Hugging Face

Gli errori relativi ai token Hugging Face si verificano quando il modello è limitato e richiede le credenziali di autenticazione appropriate per accedere.

Lo screenshot seguente mostra una voce di log in Log Explorer di Google Cloud che mostra un messaggio di errore relativo all'accesso al modello Meta LLaMA-3.2-11B-Vision ospitato su Hugging Face. L'errore indica che l'accesso al modello è limitato e che è necessaria l'autenticazione per procedere. Il messaggio indica specificamente "Impossibile accedere al repository con accesso controllato per l'URL", sottolineando che il modello è soggetto ad accesso controllato e richiede le credenziali di autenticazione appropriate per accedervi. Questa voce di log può aiutarti a risolvere i problemi di autenticazione quando lavori con risorse con limitazioni in repository esterni.

Figura 10: Errore del token Hugging Face

Per risolvere il problema, verifica le autorizzazioni del token di accesso a Hugging Face. Copia il token più recente ed esegui il deployment di un nuovo endpoint.

Problema comune 3: è necessario un modello di chat

Gli errori del modello di chat si verificano quando il modello di chat predefinito non è più consentito e deve essere fornito un modello di chat personalizzato se lo tokenizer non ne definisce uno.

Questo screenshot mostra una voce di log in Log Explorer di Google Cloud, in cui si verifica un errore ValueError a causa di un modello di chat mancante nella versione 4.44 della libreria Transformers. Il messaggio di errore indica che il modello di chat predefinito non è più consentito e che deve essere fornito un modello di chat personalizzato se lo tokenizer non ne definisce uno. Questo errore evidenzia una recente modifica della libreria che richiede la definizione esplicita di un modello di chat, utile per risolvere i problemi di debug durante il deployment di applicazioni basate su chat.

Figura 11: modello di chat necessario

Per aggirare il problema, assicurati di fornire un modello di chat durante il deployment utilizzando l'argomento di input --chat-template. I modelli di esempio sono disponibili nel repository di esempi di vLLM.

Problema comune 4: lunghezza massima sequenza modello

Gli errori relativi alla lunghezza massima della sequenza del modello si verificano quando la lunghezza massima della sequenza (4096) del modello è maggiore del numero massimo di token che possono essere memorizzati nella cache KV (2256).

Figura 12: Lunghezza massima sequenza troppo grande

ValueError: la lunghezza massima della sequenza del modello (4096) è superiore al numero massimo di token che possono essere memorizzati nella cache KV (2256). Prova ad aumentare gpu_memory_utilization o a diminuire max_model_len durante l'inizializzazione del motore.

Per risolvere il problema, imposta max_model_len su 2048, un valore inferiore a 2256. Un'altra soluzione a questo problema è utilizzare più GPU o GPU più grandi. Se scegli di utilizzare più GPU, dovrai impostare tensor-parallel-size di conseguenza.