Migliora le prestazioni di inferenza per i modelli Mixtral e Llama 2 con i nuovi contenitori Amazon SageMaker | Servizi Web di Amazon

Nel mese di gennaio 2024, Amazon Sage Maker ha lanciato una nuova versione (0.26.0) di contenitori di deep learning (DLC) di Large Model Inference (LMI). Questa versione offre supporto per nuovi modelli (inclusa Mixture of Experts), miglioramenti delle prestazioni e dell'usabilità nei backend di inferenza, nonché dettagli di nuova generazione per un maggiore controllo e spiegabilità delle previsioni (come il motivo del completamento della generazione e le probabilità di registro a livello di token).

I DLC LMI offrono un'interfaccia low-code che semplifica l'utilizzo di tecniche e hardware all'avanguardia di ottimizzazione dell'inferenza. LMI consente di applicare il parallelismo tensoriale; le più recenti ed efficienti tecniche di attenzione, batching, quantizzazione e gestione della memoria; streaming di token; e molto altro ancora, richiedendo semplicemente l'ID del modello e i parametri del modello opzionali. Con i DLC LMI su SageMaker, puoi accelerare il time-to-value per il tuo intelligenza artificiale generativa (AI) applicazioni, alleggerisci i lavori pesanti legati all'infrastruttura e ottimizza i modelli linguistici di grandi dimensioni (LLM) per l'hardware di tua scelta per ottenere il miglior rapporto prezzo-prestazioni della categoria.

In questo post, esploriamo le ultime funzionalità introdotte in questa versione, esaminiamo i benchmark delle prestazioni e forniamo una guida dettagliata sulla distribuzione di nuovi LLM con DLC LMI ad alte prestazioni.

Nuove funzionalità con i DLC LMI

In questa sezione, discutiamo le nuove funzionalità dei backend LMI e ne approfondiamo alcune altre specifiche del backend. LMI attualmente supporta i seguenti backend:

• Biblioteca distribuita LMI – Questo è il framework AWS per eseguire l'inferenza con LLM, ispirato all'OSS, per ottenere la migliore latenza e precisione possibili sul risultato
• LMI vLLM – Questa è l'implementazione del backend AWS efficiente in termini di memoria vLLM libreria di inferenza
• Kit di strumenti LMI TensorRT-LLM – Questa è l'implementazione del backend AWS di NVIDIA TensorRT-LLM, che crea motori specifici per GPU per ottimizzare le prestazioni su diverse GPU
• LMI DeepSpeed – Questo è l'adattamento AWS di deepspeed, che aggiunge il vero batching continuo, la quantizzazione SmoothQuant e la capacità di regolare dinamicamente la memoria durante l'inferenza
• LMI NeuronX – È possibile utilizzarlo per la distribuzione su AWS Inferenziale2 ed AWSTrainiumistanze basate su , con batching e accelerazioni continui reali, basati su SDK di AWS Neuron

La tabella seguente riassume le funzionalità appena aggiunte, sia comuni che specifiche del backend.

Nuovi modelli supportati

Nuovi modelli popolari sono supportati nei backend, come Mistral-7B (tutti i backend), Mixtral basato su MoE (tutti i backend tranne Transformers-NeuronX) e Llama2-70B (Transformers-NeuronX).

Tecniche di estensione della finestra di contesto

Il ridimensionamento del contesto basato sul Rotary Positional Embedding (RoPE) è ora disponibile sui backend LMI-Dist, vLLM e TensorRT-LLM. Il ridimensionamento RoPE consente l'estensione della lunghezza della sequenza di un modello durante l'inferenza praticamente a qualsiasi dimensione, senza necessità di regolazione fine.

Di seguito sono riportate due considerazioni importanti quando si utilizza RoPE:

• Perplessità del modello – All’aumentare della lunghezza della sequenza, così puoi quello del modello perplessità. Questo effetto può essere parzialmente compensato eseguendo una messa a punto minima su sequenze di input più grandi di quelle utilizzate nell'addestramento originale. Per una comprensione approfondita di come RoPE influisce sulla qualità del modello, fare riferimento a Estendere il RoPE.
• Prestazioni di inferenza – Sequenze di lunghezza maggiore consumeranno la memoria a larghezza di banda elevata (HBM) dell'acceleratore maggiore. Questo maggiore utilizzo della memoria può influire negativamente sul numero di richieste simultanee che l'acceleratore può gestire.

Aggiunti dettagli sulla generazione

Ora puoi ottenere due dettagli dettagliati sui risultati della generazione:

• finitura_motivo – Ciò fornisce il motivo del completamento della generazione, che può essere il raggiungimento della lunghezza massima di generazione, la generazione di un token di fine frase (EOS) o la generazione di un token di arresto definito dall'utente. Viene restituito con l'ultimo pezzo di sequenza trasmesso in streaming.
• log_probs – Restituisce la probabilità logaritmica assegnata dal modello per ciascun token nel pezzo di sequenza trasmessa in streaming. È possibile utilizzarli come stima approssimativa della confidenza del modello calcolando la probabilità congiunta di una sequenza come somma di log_probs dei singoli token, che può essere utile per assegnare punteggi e classificare gli output del modello. Tieni presente che le probabilità dei token LLM sono generalmente troppo sicure senza calibrazione.

Puoi abilitare l'output dei risultati della generazione aggiungendo Details=True nel payload di input a LMI, lasciando tutti gli altri parametri invariati:

payload = {“inputs”:“your prompt”,
“parameters”:{max_new_tokens”:256,...,“details”:True}
}

Parametri di configurazione consolidati

Infine, sono stati consolidati anche i parametri di configurazione dell'LMI. Per ulteriori informazioni su tutti i parametri di configurazione della distribuzione comuni e specifici del backend, vedere Configurazioni di inferenza di modelli di grandi dimensioni.

Backend distribuito LMI

Ad AWS re:Invent 2023, LMI-Dist ha aggiunto nuove operazioni collettive ottimizzate per accelerare la comunicazione tra GPU, con conseguente latenza inferiore e throughput più elevato per i modelli troppo grandi per una singola GPU. Questi collettivi sono disponibili esclusivamente per SageMaker, per le istanze p4d.

Mentre l'iterazione precedente supportava solo lo sharding su tutte e 8 le GPU, LMI 0.26.0 introduce il supporto per un grado parallelo tensore di 4, in uno schema parziale all-to-all. Questo può essere combinato con Componenti di inferenza di SageMaker, con cui è possibile configurare in modo granulare il numero di acceleratori da allocare a ciascun modello distribuito dietro un endpoint. Insieme, queste funzionalità forniscono un migliore controllo sull'utilizzo delle risorse dell'istanza sottostante, consentendoti di aumentare la multi-tenancy del modello ospitando modelli diversi dietro un endpoint o di ottimizzare il throughput aggregato della tua distribuzione in modo che corrisponda al tuo modello e alle caratteristiche del traffico.

La figura seguente confronta il tutto-a-tutto diretto con il tutto-a-tutto parziale.

Backend TensorRT-LLM

TensorRT-LLM di NVIDIA è stato introdotto come parte della precedente versione del DLC LMI (0.25.0), consentendo prestazioni e ottimizzazioni della GPU all'avanguardia come SmoothQuant, FP8 e batching continuo per LLM quando si utilizzano GPU NVIDIA.

TensorRT-LLM richiede che i modelli vengano compilati in motori efficienti prima della distribuzione. Il DLC LMI TensorRT-LLM può gestire automaticamente la compilazione di un elenco di modelli supportati just-in-time (JIT), prima di avviare il server e caricare il modello per l'inferenza in tempo reale. La versione 0.26.0 del DLC amplia l'elenco dei modelli supportati per la compilazione JIT, introducendo i modelli Baichuan, ChatGLM, GPT2, GPT-J, InternLM, Mistral, Mixtral, Qwen, SantaCoder e StarCoder.

La compilazione JIT aggiunge diversi minuti di sovraccarico al provisioning degli endpoint e ai tempi di dimensionamento, quindi è sempre consigliabile compilare il modello in anticipo. Per una guida su come eseguire questa operazione e un elenco dei modelli supportati, vedere Tutorial sulla compilazione anticipata dei modelli TensorRT-LLM. Se il modello selezionato non è ancora supportato, fare riferimento a Tutorial sulla compilazione manuale dei modelli TensorRT-LLM per compilare qualsiasi altro modello supportato da TensorRT-LLM.

Inoltre, LMI ora espone la quantizzazione nativa TensorRT-LLM SmootQuant, con parametri per controllare l'alfa e il fattore di scala per token o canale. Per ulteriori informazioni sulle configurazioni correlate, fare riferimento a TensorRT-LLM.

Back-end vLLM

La versione aggiornata di vLLM inclusa nel DLC LMI presenta miglioramenti delle prestazioni fino al 50% alimentati dalla modalità grafico CUDA anziché dalla modalità desiderosa. I grafici CUDA accelerano i carichi di lavoro della GPU avviando diverse operazioni della GPU in una volta sola invece di avviarle singolarmente, riducendo così i costi generali. Ciò è particolarmente efficace per i modelli di piccole dimensioni quando si utilizza il parallelismo tensoriale.

Le prestazioni aggiuntive derivano da un compromesso con il consumo aggiuntivo di memoria della GPU. La modalità grafico CUDA è ora predefinita per il backend vLLM, quindi se sei limitato sulla quantità di memoria GPU disponibile, puoi impostare option.enforce_eager=True per forzare la modalità desiderosa di PyTorch.

Backend Transformers-NeuronX

La versione aggiornata di NeuronX incluso nel DLC LMI NeuronX ora supporta modelli che presentano il meccanismo di attenzione delle query raggruppate, come Mistral-7B e LLama2-70B. L'attenzione delle query raggruppate rappresenta un'importante ottimizzazione del meccanismo di attenzione del trasformatore predefinito, in cui il modello viene addestrato con meno teste di chiave e valore rispetto alle teste di query. Ciò riduce la dimensione della cache KV sulla memoria della GPU, consentendo una maggiore concorrenza e migliorando il rapporto prezzo-prestazioni.

La figura seguente illustra i metodi di attenzione multi-head, query raggruppate e multi-query (source).

Sono disponibili diverse strategie di partizionamento della cache KV per adattarsi a diversi tipi di carichi di lavoro. Per ulteriori informazioni sulle strategie di partizionamento orizzontale, vedere Supporto per l'attenzione alle query raggruppate (GQA).. Puoi abilitare la strategia desiderata (shard-over-heads, ad esempio) con il seguente codice:

option.group_query_attention=shard-over-heads

Inoltre, la nuova implementazione del DLC NeuronX introduce un'API cache per TransformerNeuronX che consente l'accesso alla cache KV. Ti consente di inserire e rimuovere righe della cache KV dalle nuove richieste mentre esegui l'inferenza batch. Prima di introdurre questa API, la cache KV veniva ricalcolata per tutte le richieste appena aggiunte. Rispetto a LMI V7 (0.25.0), abbiamo migliorato la latenza di oltre il 33% con richieste simultanee e supportiamo un throughput molto più elevato.

Selezionare il backend giusto

Per decidere quale backend utilizzare in base al modello e all'attività selezionati, utilizzare il seguente diagramma di flusso. Per le guide utente dei singoli backend insieme ai modelli supportati, vedere Guide per l'utente del backend LMI.

Distribuisci Mixtral con il DLC LMI con attributi aggiuntivi

Esaminiamo come distribuire il modello Mixtral-8x7B con il contenitore LMI 0.26.0 e generare dettagli aggiuntivi come log_prob ed finish_reason come parte dell'output. Discuteremo anche di come trarre vantaggio da questi attributi aggiuntivi attraverso un caso d'uso di generazione di contenuti.

Il quaderno completo con le istruzioni dettagliate è disponibile nel Repository GitHub.

Iniziamo importando le librerie e configurando l'ambiente della sessione:

import boto3
import sagemaker 
import json 
import io 
import numpy as np 
from sagemaker import Model, image_uris, serializers, deserializers 

role = sagemaker.get_execution_role() # execution role for the endpoint 
session = sagemaker.session.Session() # sagemaker session for interacting with different AWS APIs 
region = session._region_name # region name of the current SageMaker Studio environment

È possibile utilizzare i contenitori LMI SageMaker per ospitare modelli senza alcun codice di inferenza aggiuntivo. È possibile configurare il server modello tramite le variabili di ambiente o a serving.properties file. Facoltativamente, potresti avere un file model.py file per qualsiasi pre-elaborazione o post-elaborazione e a requirements.txt file per eventuali pacchetti aggiuntivi che devono essere installati.

In questo caso utilizziamo il file serving.properties file per configurare i parametri e personalizzare il comportamento del contenitore LMI. Per maggiori dettagli fare riferimento al Repository GitHub. Il repository spiega i dettagli dei vari parametri di configurazione che è possibile impostare. Abbiamo bisogno dei seguenti parametri chiave:

• motore – Specifica il motore runtime da utilizzare per DJL. Ciò guida la strategia di partizionamento orizzontale e di caricamento del modello negli acceleratori per il modello.
• opzione.model_id – Specifica il Servizio di archiviazione semplice Amazon (Amazon S3) URI del modello pre-addestrato o ID modello di un modello pre-addestrato ospitato all'interno di un repository di modelli su Abbracciare il viso. In questo caso, forniamo l'ID modello per il modello Mixtral-8x7B.
• opzione.tensore_parallelo_grado – Imposta il numero di dispositivi GPU su cui Accelerate deve partizionare il modello. Questo parametro controlla anche il numero di lavoratori per modello che verrà avviato durante l'esecuzione del servizio DJL. Impostiamo questo valore su max (GPU massima sulla macchina attuale).
• opzione.rolling_batch – Consente il batching continuo per ottimizzare l'utilizzo dell'acceleratore e la produttività complessiva. Per il contenitore TensorRT-LLM, utilizziamo auto.
• opzione.model_loading_timeout – Imposta il valore di timeout per il download e il caricamento del modello per servire l'inferenza.
• opzione.max_rolling_batch – Imposta la dimensione massima del batch continuo, definendo quante sequenze possono essere elaborate in parallelo in un dato momento.

%%writefile serving.properties 
engine=MPI 
option.model_id=mistralai/Mixtral-8x7B-v0.1 
option.tensor_parallel_degree=max 
option.max_rolling_batch_size=32 
option.rolling_batch=auto 
option.model_loading_timeout = 7200

Imballiamo il serving.properties file di configurazione nel formato tar.gz, in modo che soddisfi i requisiti di hosting di SageMaker. Configuriamo il contenitore DJL LMI con tensorrtllm come motore di backend. Inoltre, specifichiamo l'ultima versione del contenitore (0.26.0).

image_uri = image_uris.retrieve(
   framework="djl-tensorrtllm",
   region=sess.boto_session.region_name,
   version="0.26.0"
)

Successivamente, carichiamo il tarball locale (contenente il file serving.properties file di configurazione) a un prefisso S3. Utilizziamo l'URI dell'immagine per il contenitore DJL e la posizione Amazon S3 in cui è stato caricato il file tar degli artefatti del modello, per creare l'oggetto del modello SageMaker.

model = Model(image_uri=image_uri, model_data=code_artifact, role=role) 

instance_type = "ml.p4d.24xlarge" 
endpoint_name = sagemaker.utils.name_from_base("mixtral-lmi-model") 

model.deploy(
   initial_instance_count=1,
   instance_type=instance_type,
   endpoint_name=endpoint_name,
   container_startup_health_check_timeout=1800
)

Come parte di LMI 0.26.0, ora puoi utilizzare due ulteriori dettagli a grana fine sull'output generato:

• log_probs – Questa è la probabilità logaritmica assegnata dal modello per ciascun token nel pezzo di sequenza trasmessa in streaming. È possibile utilizzarli come stima approssimativa della confidenza del modello calcolando la probabilità congiunta di una sequenza come somma delle probabilità logaritmiche dei singoli token, che può essere utile per assegnare punteggi e classificare gli output del modello. Tieni presente che le probabilità dei token LLM sono generalmente troppo sicure senza calibrazione.
• finitura_motivo – Questo è il motivo del completamento della generazione, che può raggiungere la lunghezza massima della generazione, generare un token EOS o generare un token di arresto definito dall'utente. Questo viene restituito con l'ultimo pezzo di sequenza trasmesso in streaming.

Puoi abilitarli passando "details"=True come parte del tuo contributo al modello.

Vediamo come è possibile generare questi dettagli. Utilizziamo un esempio di generazione di contenuti per comprenderne l'applicazione.

Definiamo a LineIterator classe helper, che ha funzioni per recuperare pigramente byte da un flusso di risposta, memorizzarli nel buffer e suddividere il buffer in righe. L'idea è di servire byte dal buffer recuperando più byte dal flusso in modo asincrono.

class LineIterator:
    def __init__(self, stream):
        # Iterator to get bytes from stream 
        self.byte_iterator = iter(stream)  
        # Buffer stream bytes until we get a full line
        self.buffer = io.BytesIO()  
        # Track current reading position within buffer
        self.read_pos = 0

   def __iter__(self):
        # Make class iterable 
        return self

    def __next__(self):
        while True:
           # Seek read position within buffer
           self.buffer.seek(self.read_pos)  
           # Try reading a line from current position
           line = self.buffer.readline()
           # If we have a full line
           if line and line[-1] == ord('n'):
               # Increment reading position past this line
               self.read_pos += len(line)  
               # Return the line read without newline char
               return line[:-1] 
           # Fetch next chunk from stream  
           try:
               chunk = next(self.byte_iterator)
           # Handle end of stream 
           except StopIteration:
               # Check if we have any bytes still unread
               if self.read_pos < self.buffer.getbuffer().nbytes:
                   continue
               # If not, raise StopIteration
               raise
           # Add fetched bytes to end of buffer
           self.buffer.seek(0, io.SEEK_END)  
           self.buffer.write(chunk['PayloadPart']['Bytes'])

Genera e utilizza la probabilità del token come dettaglio aggiuntivo

Considera un caso d'uso in cui stiamo generando contenuti. Nello specifico, abbiamo il compito di scrivere un breve paragrafo sui vantaggi dell'esercizio fisico regolare per un sito Web incentrato sullo stile di vita. Vogliamo generare contenuto e produrre un punteggio indicativo della fiducia che il modello ha nel contenuto generato.

Invochiamo l'endpoint del modello con il nostro prompt e acquisiamo la risposta generata. Prepariamo "details": True come parametro di runtime all'interno dell'input del modello. Poiché la probabilità di log viene generata per ciascun token di output, aggiungiamo le singole probabilità di log a un elenco. Catturiamo anche il testo completo generato dalla risposta.

sm_client = boto3.client("sagemaker-runtime")

# Set details: True as a runtime parameter within the input.
body = {"inputs": prompt, "parameters": {"max_new_tokens":512, "details": True}}
resp = sm_client.invoke_endpoint_with_response_stream(EndpointName=endpoint_name, Body=json.dumps(body), ContentType="application/json")
event_stream = resp['Body']

overall_log_prob = []

for line in LineIterator(event_stream):
    resp = json.loads(line)
    if resp['token'].get('text') != None:
        token_log_prob = resp['token']['log_prob']
        overall_log_prob.append(token_log_prob)
    elif resp['generated_text'] != None:
        generated_text= resp['generated_text']

Per calcolare il punteggio di confidenza complessivo, calcoliamo la media di tutte le probabilità dei singoli token e successivamente otteniamo il valore esponenziale compreso tra 0 e 1. Questo è il nostro punteggio di confidenza complessivo dedotto per il testo generato, che in questo caso è un paragrafo sui vantaggi di esercizio fisico regolare.

print(generated_text) 
overall_score=np.exp(np.mean(overall_log_prob)) 
print(f"nnOverall confidence score in the generated text: {overall_score}")

Questo era un esempio di come è possibile generare e utilizzare log_prob, nel contesto di un caso d'uso di generazione di contenuti. Allo stesso modo, puoi usare log_prob come misura del punteggio di confidenza per i casi d'uso della classificazione.

In alternativa, è possibile utilizzarlo per la sequenza di output complessiva o per il punteggio a livello di frase per valutare l'effetto di parametri come la temperatura sull'output generato.

Genera e utilizza il motivo di finitura come dettaglio aggiuntivo

Partiamo dallo stesso caso d'uso, ma questa volta abbiamo il compito di scrivere un articolo più lungo. Inoltre, vogliamo assicurarci che l'output non venga troncato a causa di problemi di lunghezza di generazione (lunghezza massima del token) o a causa del rilevamento di token di arresto.

Per raggiungere questo obiettivo, utilizziamo il file finish_reason attributo generato nell'output, monitorarne il valore e continuare a generare finché non viene generato l'intero output.

Definiamo una funzione di inferenza che accetta un input di payload e chiama l'endpoint SageMaker, trasmette una risposta ed elabora la risposta per estrarre il testo generato. Il payload contiene il testo del prompt come input e parametri come token massimi e dettagli. La risposta viene letta in un flusso ed elaborata riga per riga per estrarre i token di testo generati in un elenco. Estraiamo dettagli come finish_reason. Chiamiamo la funzione di inferenza in un ciclo (richieste concatenate) aggiungendo ogni volta più contesto e monitorando il numero di token generati e il numero di richieste inviate fino al completamento del modello.

def inference(payload):
    # Call SageMaker endpoint and get response stream
    resp = sm_client.invoke_endpoint_with_response_stream(EndpointName=endpoint_name, Body=json.dumps(payload), ContentType="application/json")
    event_stream = resp['Body']
    text_output = []
    for line in LineIterator(event_stream):
        resp = json.loads(line) 
        # Extract text tokens if present
        if resp['token'].get('text') != None:
            token = resp['token']['text']
            text_output.append(token)  
            print(token, end='')
        # Get finish reason if details present
        if resp.get('details') != None:
            finish_reason = resp['details']['finish_reason']
            # Return extracted output, finish reason and token length
            return payload['inputs'] + ''.join(text_output), finish_reason, len(text_output)

# set details: True as a runtime parameter within the input.
payload = {"inputs": prompt,  "parameters": {"max_new_tokens":256, "details": True}} 

finish_reason = "length"
# Print initial output 
print(f"Output: {payload['inputs']}", end='')  
total_tokens = 0
total_requests = 0
while finish_reason == 'length':
    # Call inference and get extracts
    output_text, finish_reason, out_token_len = inference(payload)
    # Update payload for next request
    payload['inputs'] = output_text 
    total_tokens += out_token_len
    total_requests += 1
# Print metrics
print(f"nntotal tokens generated: {total_tokens} ntotal requests sent: {total_requests}")

Come possiamo vedere, anche se il max_new_token è impostato su 256, utilizziamo l'attributo finish_reason detail come parte dell'output per concatenare più richieste all'endpoint, finché non viene generato l'intero output.

Allo stesso modo, in base al caso d'uso, puoi utilizzare stop_reason per rilevare una lunghezza insufficiente della sequenza di output specificata per una determinata attività o il completamento involontario a causa di una sequenza di arresto umano.

Conclusione

In questo post abbiamo esaminato la versione v0.26.0 del contenitore AWS LMI. Abbiamo evidenziato miglioramenti chiave delle prestazioni, supporto di nuovi modelli e nuove funzionalità di usabilità. Con queste funzionalità, puoi bilanciare meglio le caratteristiche di costo e prestazioni, fornendo al tempo stesso un'esperienza migliore ai tuoi utenti finali.

Per ulteriori informazioni sulle funzionalità DLC LMI, fare riferimento a Parallelismo dei modelli e grande inferenza dei modelli. Siamo entusiasti di vedere come utilizzerai queste nuove funzionalità di SageMaker.

Circa gli autori

João Moura è un Senior AI/ML Specialist Solutions Architect presso AWS. João aiuta i clienti AWS, dalle piccole startup alle grandi imprese, ad addestrare e distribuire modelli di grandi dimensioni in modo efficiente e, più in generale, a costruire piattaforme ML su AWS.

Rahul Sharma è un Senior Solutions Architect presso AWS e aiuta i clienti AWS a progettare e realizzare soluzioni AI/ML. Prima di entrare in AWS, Rahul ha trascorso diversi anni nel settore finanziario e assicurativo, aiutando i clienti a creare piattaforme dati e analitiche.

Qing Lan è un ingegnere di sviluppo software in AWS. Ha lavorato su diversi prodotti impegnativi in ​​Amazon, tra cui soluzioni di inferenza ML ad alte prestazioni e sistema di registrazione ad alte prestazioni. Il team di Qing ha lanciato con successo il primo modello di miliardi di parametri in Amazon Advertising con una latenza molto bassa richiesta. Qing ha una conoscenza approfondita dell'ottimizzazione dell'infrastruttura e dell'accelerazione del Deep Learning.

Jian Sheng è un ingegnere di sviluppo software presso Amazon Web Services che ha lavorato su diversi aspetti chiave dei sistemi di apprendimento automatico. Ha contribuito in modo determinante al servizio SageMaker Neo, concentrandosi sulla compilazione del deep learning e sull'ottimizzazione del runtime del framework. Recentemente, ha indirizzato i suoi sforzi e contribuito all'ottimizzazione del sistema di apprendimento automatico per l'inferenza di modelli di grandi dimensioni.

Tyler Osterberg è un ingegnere di sviluppo software presso AWS. È specializzato nella creazione di esperienze di inferenza di machine learning ad alte prestazioni all'interno di SageMaker. Recentemente, il suo focus si è concentrato sull'ottimizzazione delle prestazioni di Inferentia Deep Learning Containers sulla piattaforma SageMaker. Tyler eccelle nell'implementazione di soluzioni di hosting performanti per modelli linguistici di grandi dimensioni e nel miglioramento delle esperienze degli utenti utilizzando tecnologie all'avanguardia.

Rupinder Grewal è un Senior AI/ML Specialist Solutions Architect presso AWS. Attualmente si concentra sulla fornitura di modelli e MLOps su Amazon SageMaker. Prima di questo ruolo, ha lavorato come ingegnere di machine learning, costruendo e ospitando modelli. Fuori dal lavoro gli piace giocare a tennis e andare in bicicletta sui sentieri di montagna.

Dhawal Patel è un Principal Machine Learning Architect presso AWS. Ha lavorato con organizzazioni che vanno dalle grandi imprese alle startup di medie dimensioni su problemi legati all'informatica distribuita e all'intelligenza artificiale. Si concentra sull'apprendimento profondo, inclusi i domini della PNL e della visione artificiale. Aiuta i clienti a ottenere l'inferenza del modello ad alte prestazioni su SageMaker.

Raghu Ramesha è un Senior ML Solutions Architect presso il team di assistenza Amazon SageMaker. Il suo obiettivo è aiutare i clienti a creare, distribuire e migrare carichi di lavoro di produzione ML su SageMaker su larga scala. È specializzato in ambiti di machine learning, intelligenza artificiale e visione artificiale e ha conseguito un master in informatica presso l'UT di Dallas. Nel tempo libero gli piace viaggiare e fotografare.

• Distribuzione di contenuti basati su SEO e PR. Ricevi amplificazione oggi.
• PlatoData.Network Generativo verticale Ai. Potenzia te stesso. Accedi qui.
• PlatoAiStream. Intelligenza Web3. Conoscenza amplificata. Accedi qui.
• PlatoneESG. Carbonio, Tecnologia pulita, Energia, Ambiente, Solare, Gestione dei rifiuti. Accedi qui.
• Platone Salute. Intelligence sulle biotecnologie e sulle sperimentazioni cliniche. Accedi qui.
• Fonte: https://aws.amazon.com/blogs/machine-learning/boost-inference-performance-for-mixtral-and-llama-2-models-with-new-amazon-sagemaker-containers/